diff --git a/LICENSE b/LICENSE new file mode 100644 index 00000000..53320c35 --- /dev/null +++ b/LICENSE @@ -0,0 +1,185 @@ +This software is licensed under the LGPLv3, included below. + +As a special exception to the GNU Lesser General Public License version 3 +("LGPL3"), the copyright holders of this Library give you permission to +convey to a third party a Combined Work that links statically or dynamically +to this Library without providing any Minimal Corresponding Source or +Minimal Application Code as set out in 4d or providing the installation +information set out in section 4e, provided that you comply with the other +provisions of LGPL3 and provided that you meet, for the Application the +terms and conditions of the license(s) which apply to the Application. + +Except as stated in this special exception, the provisions of LGPL3 will +continue to comply in full to this Library. If you modify this Library, you +may apply this exception to your version of this Library, but you are not +obliged to do so. If you do not wish to do so, delete this exception +statement from your version. This exception does not (and cannot) modify any +license terms which apply to the Application, with which you must still +comply. + + + GNU LESSER GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + + This version of the GNU Lesser General Public License incorporates +the terms and conditions of version 3 of the GNU General Public +License, supplemented by the additional permissions listed below. + + 0. Additional Definitions. + + As used herein, "this License" refers to version 3 of the GNU Lesser +General Public License, and the "GNU GPL" refers to version 3 of the GNU +General Public License. + + "The Library" refers to a covered work governed by this License, +other than an Application or a Combined Work as defined below. + + An "Application" is any work that makes use of an interface provided +by the Library, but which is not otherwise based on the Library. +Defining a subclass of a class defined by the Library is deemed a mode +of using an interface provided by the Library. + + A "Combined Work" is a work produced by combining or linking an +Application with the Library. The particular version of the Library +with which the Combined Work was made is also called the "Linked +Version". + + The "Minimal Corresponding Source" for a Combined Work means the +Corresponding Source for the Combined Work, excluding any source code +for portions of the Combined Work that, considered in isolation, are +based on the Application, and not on the Linked Version. + + The "Corresponding Application Code" for a Combined Work means the +object code and/or source code for the Application, including any data +and utility programs needed for reproducing the Combined Work from the +Application, but excluding the System Libraries of the Combined Work. + + 1. Exception to Section 3 of the GNU GPL. + + You may convey a covered work under sections 3 and 4 of this License +without being bound by section 3 of the GNU GPL. + + 2. Conveying Modified Versions. + + If you modify a copy of the Library, and, in your modifications, a +facility refers to a function or data to be supplied by an Application +that uses the facility (other than as an argument passed when the +facility is invoked), then you may convey a copy of the modified +version: + + a) under this License, provided that you make a good faith effort to + ensure that, in the event an Application does not supply the + function or data, the facility still operates, and performs + whatever part of its purpose remains meaningful, or + + b) under the GNU GPL, with none of the additional permissions of + this License applicable to that copy. + + 3. Object Code Incorporating Material from Library Header Files. + + The object code form of an Application may incorporate material from +a header file that is part of the Library. You may convey such object +code under terms of your choice, provided that, if the incorporated +material is not limited to numerical parameters, data structure +layouts and accessors, or small macros, inline functions and templates +(ten or fewer lines in length), you do both of the following: + + a) Give prominent notice with each copy of the object code that the + Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the object code with a copy of the GNU GPL and this license + document. + + 4. Combined Works. + + You may convey a Combined Work under terms of your choice that, +taken together, effectively do not restrict modification of the +portions of the Library contained in the Combined Work and reverse +engineering for debugging such modifications, if you also do each of +the following: + + a) Give prominent notice with each copy of the Combined Work that + the Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the Combined Work with a copy of the GNU GPL and this license + document. + + c) For a Combined Work that displays copyright notices during + execution, include the copyright notice for the Library among + these notices, as well as a reference directing the user to the + copies of the GNU GPL and this license document. + + d) Do one of the following: + + 0) Convey the Minimal Corresponding Source under the terms of this + License, and the Corresponding Application Code in a form + suitable for, and under terms that permit, the user to + recombine or relink the Application with a modified version of + the Linked Version to produce a modified Combined Work, in the + manner specified by section 6 of the GNU GPL for conveying + Corresponding Source. + + 1) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (a) uses at run time + a copy of the Library already present on the user's computer + system, and (b) will operate properly with a modified version + of the Library that is interface-compatible with the Linked + Version. + + e) Provide Installation Information, but only if you would otherwise + be required to provide such information under section 6 of the + GNU GPL, and only to the extent that such information is + necessary to install and execute a modified version of the + Combined Work produced by recombining or relinking the + Application with a modified version of the Linked Version. (If + you use option 4d0, the Installation Information must accompany + the Minimal Corresponding Source and Corresponding Application + Code. If you use option 4d1, you must provide the Installation + Information in the manner specified by section 6 of the GNU GPL + for conveying Corresponding Source.) + + 5. Combined Libraries. + + You may place library facilities that are a work based on the +Library side by side in a single library together with other library +facilities that are not Applications and are not covered by this +License, and convey such a combined library under terms of your +choice, if you do both of the following: + + a) Accompany the combined library with a copy of the same work based + on the Library, uncombined with any other library facilities, + conveyed under the terms of this License. + + b) Give prominent notice with the combined library that part of it + is a work based on the Library, and explaining where to find the + accompanying uncombined form of the same work. + + 6. Revised Versions of the GNU Lesser General Public License. + + The Free Software Foundation may publish revised and/or new versions +of the GNU Lesser General Public License from time to time. Such new +versions will be similar in spirit to the present version, but may +differ in detail to address new problems or concerns. + + Each version is given a distinguishing version number. If the +Library as you received it specifies that a certain numbered version +of the GNU Lesser General Public License "or any later version" +applies to it, you have the option of following the terms and +conditions either of that published version or of any later version +published by the Free Software Foundation. If the Library as you +received it does not specify a version number of the GNU Lesser +General Public License, you may choose any version of the GNU Lesser +General Public License ever published by the Free Software Foundation. + + If the Library as you received it specifies that a proxy can decide +whether future versions of the GNU Lesser General Public License shall +apply, that proxy's public statement of acceptance of any version is +permanent authorization for you to choose that version for the +Library. diff --git a/README.md b/README.md new file mode 100644 index 00000000..2093bcb5 --- /dev/null +++ b/README.md @@ -0,0 +1,164 @@ +# QML support for the Go language + +## amlwwalker/qml + +* I have made the `go1.6-port` branch the master branch here as it seems more relevant in this day and age... +* It is not my work, but I have been using it for a while so please shout if I can help! + + + +Original Documentation +------------- + +The introductory documentation as well as the detailed API documentation is +available at [gopkg.in/qml.v1](http://godoc.org/gopkg.in/qml.v1). + + +Blog posts +---------- + +Some relevant blog posts: + + * [Announcing qml v1 for Go](http://blog.labix.org/2014/08/13/announcing-qml-v1-for-go) + * [Packing resources into Go qml binaries](http://blog.labix.org/2014/09/26/packing-resources-into-go-qml-binaries) + * [Go qml contest results](http://blog.labix.org/2014/04/25/qml-contest-results) + * [Arbitrary Qt extensions with Go qml](http://blog.labix.org/2014/03/21/arbitrary-qt-extensions-with-go-qml) + * [The new Go qml OpenGL API](http://blog.labix.org/2014/08/29/the-new-go-qml-opengl-api) + * [QML components with Go and OpenGL](http://blog.labix.org/2013/12/23/qml-components-with-go-and-opengl) + + +Videos +------ + +These introductory videos demonstrate the use of Go QML: + + * [Initial demo and overview](http://youtu.be/FVQlMrPa7lI) + * [Initial demo running on an Ubuntu Touch phone](http://youtu.be/HB-3o8Cysec) + * [Spinning Gopher with Go + QML + OpenGL](http://youtu.be/qkH7_dtOyPk) + * [SameGame QML tutorial in Go](http://youtu.be/z8noX48hiMI) + + +Community +--------- + +Please join the [mailing list](https://groups.google.com/forum/#!forum/go-qml) for +following relevant development news and discussing project details. + + +Installation +------------ + +To try the alpha release you'll need: + + * Go >= 1.2, for the C++ support of _go build_ + * Qt 5.0.X or 5.1.X with the development files + * The Qt headers qmetaobject_p.h and qmetaobjectbuilder_p.h, for the dynamic meta object support + +See below for more details about getting these requirements installed in different environments and operating systems. + +After the requirements are satisfied, _go get_ should work as usual: + + go get gopkg.in/qml.v1 + + +Requirements on Ubuntu +---------------------- + +If you are using Ubuntu, the [Ubuntu SDK](http://developer.ubuntu.com/get-started/) will take care of the Qt dependencies: + + $ sudo add-apt-repository ppa:ubuntu-sdk-team/ppa + $ sudo apt-get update + $ sudo apt-get install qtdeclarative5-dev qtbase5-private-dev qtdeclarative5-private-dev libqt5opengl5-dev qtdeclarative5-qtquick2-plugin + +and Go >= 1.2 may be installed using [godeb](http://blog.labix.org/2013/06/15/in-flight-deb-packages-of-go): + + $ # Pick the right one for your system: 386 or amd64 + $ ARCH=amd64 + $ wget -q https://godeb.s3.amazonaws.com/godeb-$ARCH.tar.gz + $ tar xzvf godeb-$ARCH.tar.gz + godeb + $ sudo mv godeb /usr/local/bin + $ godeb install + $ go get gopkg.in/qml.v1 + + +Requirements on Ubuntu Touch +---------------------------- + +After following the [installation instructions](https://wiki.ubuntu.com/Touch/Install) for Ubuntu Touch, +run the following commands to get a working build environment inside the device: + + $ adb shell + # cd /tmp + # wget https://github.com/go-qml/qml/raw/v1/cmd/ubuntu-touch/setup.sh + # /bin/bash setup.sh + # su - phablet + $ + +At the end of setup.sh, the phablet user will have GOPATH=$HOME in the environment, +the qml package will be built, and the particle example will be built and run. For +stopping it from the command line, run as the phablet user: + + $ ubuntu-app-stop gopkg.in.qml.particle-example + +for running it again: + + $ ubuntu-app-launch gopkg.in.qml.particle-example + +These commands depend on the following file, installed by setup.sh: + + ~/.local/share/applications/gopkg.in.qml.particle-example.desktop + + +Requirements on Mac OS X +------------------------ + +On Mac OS X you'll need QT5. It's easiest to install with Homebrew, a +third-party package management system for OS X. + +Installation instructions for Homebrew are here: + + http://brew.sh/ + +Then, install the qt5 and pkg-config packages: + + $ brew install qt5 pkg-config + +Then, force brew to "link" qt5 (this makes it available under /usr/local): + + $ brew link --force qt5 + +And finally, fetch and install go-qml: + + $ go get gopkg.in/qml.v1 + + +Requirements on Windows +----------------------- + +On Windows you'll need the following: + + * [MinGW gcc](http://sourceforge.net/projects/mingw/files/latest/download) 4.8.1 (install mingw-get and install the gcc from within the setup GUI) + * [Qt 5.1.1](http://download.qt-project.org/official_releases/qt/5.1/5.1.1/qt-windows-opensource-5.1.1-mingw48_opengl-x86-offline.exe) for MinGW 4.8 + * [Go >= 1.2](http://golang.org/doc/install) + +Then, assuming Qt was installed under `C:\Qt5.1.1\`, set up the following environment variables in the respective configuration: + + CPATH += C:\Qt5.1.1\5.1.1\mingw48_32\include + LIBRARY_PATH += C:\Qt5.1.1\5.1.1\mingw48_32\lib + PATH += C:\Qt5.1.1\5.1.1\mingw48_32\bin + +After reopening the shell for the environment changes to take effect, this should work: + + go get gopkg.in/qml.v1 + + +Requirements everywhere else +---------------------------- + +If your operating system does not offer these dependencies readily, +you may still have success installing [Go >= 1.2](http://golang.org/doc/install) +and [Qt 5.0.2](http://download.qt-project.org/archive/qt/5.0/5.0.2/) +directly from the upstreams. Note that you'll likely have to adapt +environment variables to reflect the custom installation path for +these libraries. See the instructions above for examples. diff --git a/all.cpp b/all.cpp new file mode 100644 index 00000000..965867b1 --- /dev/null +++ b/all.cpp @@ -0,0 +1,12 @@ + +#include "cpp/capi.cpp" +#include "cpp/govalue.cpp" +#include "cpp/govaluetype.cpp" +#include "cpp/idletimer.cpp" +#include "cpp/connector.cpp" + +#include "cpp/moc_all.cpp" + +#ifdef _WIN32 +#include "cpp/mmemwin.cpp" +#endif diff --git a/bridge.go b/bridge.go new file mode 100644 index 00000000..e6c8a7fa --- /dev/null +++ b/bridge.go @@ -0,0 +1,719 @@ +package qml + +// #cgo CPPFLAGS: -I./cpp +// #cgo CXXFLAGS: -std=c++0x -pedantic-errors -Wall -fno-strict-aliasing +// #cgo LDFLAGS: -lstdc++ +// #cgo pkg-config: Qt5Core Qt5Widgets Qt5Quick +// +// #include +// +// #include "cpp/capi.h" +// +import "C" + +import ( + "fmt" + "os" + "reflect" + "runtime" + "sync/atomic" + "unsafe" + + "gopkg.in/qml.v1/cdata" +) + +var ( + guiFunc = make(chan func()) + guiDone = make(chan struct{}) + guiLock = 0 + guiMainRef uintptr + guiPaintRef uintptr + guiIdleRun int32 + + initialized int32 +) + +func init() { + runtime.LockOSThread() + guiMainRef = cdata.Ref() +} + +// Run runs the main QML event loop, runs f, and then terminates the +// event loop once f returns. +// +// Most functions from the qml package block until Run is called. +// +// The Run function must necessarily be called from the same goroutine as +// the main function or the application may fail when running on Mac OS. +func Run(f func() error) error { + if cdata.Ref() != guiMainRef { + panic("Run must be called on the initial goroutine so apps are portable to Mac OS") + } + if !atomic.CompareAndSwapInt32(&initialized, 0, 1) { + panic("qml.Run called more than once") + } + C.newGuiApplication() + C.idleTimerInit((*C.int32_t)(&guiIdleRun)) + done := make(chan error, 1) + go func() { + RunMain(func() {}) // Block until the event loop is running. + done <- f() + C.applicationExit() + }() + C.applicationExec() + return <-done +} + +// RunMain runs f in the main QML thread and waits for f to return. +// +// This is meant to be used by extensions that integrate directly with the +// underlying QML logic. +func RunMain(f func()) { + ref := cdata.Ref() + if ref == guiMainRef || ref == atomic.LoadUintptr(&guiPaintRef) { + // Already within the GUI or render threads. Attempting to wait would deadlock. + f() + return + } + + // Tell Qt we're waiting for the idle hook to be called. + if atomic.AddInt32(&guiIdleRun, 1) == 1 { + C.idleTimerStart() + } + + // Send f to be executed by the idle hook in the main GUI thread. + guiFunc <- f + + // Wait until f is done executing. + <-guiDone +} + +// Lock freezes all QML activity by blocking the main event loop. +// Locking is necessary before updating shared data structures +// without race conditions. +// +// It's safe to use qml functionality while holding a lock, as +// long as the requests made do not depend on follow up QML +// events to be processed before returning. If that happens, the +// problem will be observed as the application freezing. +// +// The Lock function is reentrant. That means it may be called +// multiple times, and QML activities will only be resumed after +// Unlock is called a matching number of times. +func Lock() { + // TODO Better testing for this. + RunMain(func() { + guiLock++ + }) +} + +// Unlock releases the QML event loop. See Lock for details. +func Unlock() { + RunMain(func() { + if guiLock == 0 { + panic("qml.Unlock called without lock being held") + } + guiLock-- + }) +} + +// Flush synchronously flushes all pending QML activities. +func Flush() { + // TODO Better testing for this. + RunMain(func() { + C.applicationFlushAll() + }) +} + +// Changed notifies all QML bindings that the given field value has changed. +// +// For example: +// +// qml.Changed(&value, &value.Field) +// +func Changed(value, fieldAddr interface{}) { + valuev := reflect.ValueOf(value) + fieldv := reflect.ValueOf(fieldAddr) + for valuev.Kind() == reflect.Ptr { + valuev = valuev.Elem() + } + if fieldv.Kind() != reflect.Ptr { + panic("qml.Changed received non-address value as fieldAddr") + } + fieldv = fieldv.Elem() + if fieldv.Type().Size() == 0 { + panic("cannot report changes on zero-sized fields") + } + offset := fieldv.UnsafeAddr() - valuev.UnsafeAddr() + if !(0 <= offset && offset < valuev.Type().Size()) { + panic("provided field is not a member of the given value") + } + + RunMain(func() { + tinfo := typeInfo(value) + for _, engine := range engines { + fold := engine.values[value] + for fold != nil { + C.goValueActivate(fold.cvalue, tinfo, C.int(offset)) + fold = fold.next + } + // TODO typeNew might also be a linked list keyed by the gvalue. + // This would prevent the iteration and the deferrals. + for fold, _ = range typeNew { + if fold.gvalue == value { + // Activate these later so they don't get recursively moved + // out of typeNew while the iteration is still happening. + defer C.goValueActivate(fold.cvalue, tinfo, C.int(offset)) + } + } + } + }) +} + +// hookIdleTimer is run once per iteration of the Qt event loop, +// within the main GUI thread, but only if at least one goroutine +// has atomically incremented guiIdleRun. +// +//export hookIdleTimer +func hookIdleTimer() { + var f func() + for { + select { + case f = <-guiFunc: + default: + if guiLock > 0 { + f = <-guiFunc + } else { + return + } + } + f() + guiDone <- struct{}{} + atomic.AddInt32(&guiIdleRun, -1) + } +} + +type valueFold struct { + engine *Engine + gvalue interface{} + cvalue unsafe.Pointer + init reflect.Value + prev *valueFold + next *valueFold + owner valueOwner +} + +// cgoFolds holds all fold values that get reference to on the cgo space. +// Since Go Pointer are not allowed to be held by cgo. We need a lookup +// table to interface the two space. +var cgoFolds = make(map[C.GoRef]*valueFold) + +// GoRef index the valueFold value and return a lookup +// key (C.GoRef), so that we can retrieve the fold using +// the C.GoRef. need to cross between go and cgo +func (f *valueFold) goRef() C.GoRef { + ref := C.GoRef(uintptr(unsafe.Pointer(f))) + cgoFolds[ref] = f + return ref +} + +// destroyRef remove the valueFold reference from the lookup table. +func (f *valueFold) destroyRef() { + ref := C.GoRef(uintptr(unsafe.Pointer(f))) + delete(cgoFolds, ref) +} + +// getFoldFromGoRef return the valueFold value located at ref +func getFoldFromGoRef(ref C.GoRef) *valueFold { + fold := cgoFolds[ref] + if fold == nil { + panic("cannot find fold go reference") + } + return fold +} + +type valueOwner uint8 + +const ( + cppOwner = 1 << iota + jsOwner +) + +// wrapGoValue creates a new GoValue object in C++ land wrapping +// the Go value contained in the given interface. +// +// This must be run from the main GUI thread. +func wrapGoValue(engine *Engine, gvalue interface{}, owner valueOwner) (cvalue unsafe.Pointer) { + gvaluev := reflect.ValueOf(gvalue) + gvaluek := gvaluev.Kind() + if gvaluek == reflect.Struct && !hashable(gvalue) { + name := gvaluev.Type().Name() + if name != "" { + name = " (" + name + ")" + } + panic("cannot hand an unhashable struct value" + name + " to QML logic; use its address instead") + } + if gvaluek == reflect.Ptr && gvaluev.Elem().Kind() == reflect.Ptr { + panic("cannot hand pointer of pointer to QML logic; use a simple pointer instead") + } + + painting := cdata.Ref() == atomic.LoadUintptr(&guiPaintRef) + + // Cannot reuse a jsOwner because the QML runtime may choose to destroy + // the value _after_ we hand it a new reference to the same value. + // See issue #68 for details. + prev, ok := engine.values[gvalue] + if ok && (prev.owner == cppOwner || painting) { + return prev.cvalue + } + + if painting { + panic("cannot allocate new objects while painting") + } + + parent := nilPtr + if owner == cppOwner { + parent = engine.addr + } + fold := &valueFold{ + engine: engine, + gvalue: gvalue, + owner: owner, + } + fold.cvalue = C.newGoValue(fold.goRef(), typeInfo(gvalue), parent) + if prev != nil { + // Put new fold first so the single cppOwner, if any, is always the first entry. + fold.next = prev + prev.prev = fold + } + engine.values[gvalue] = fold + + //fmt.Printf("[DEBUG] value alive (wrapped): cvalue=%x gvalue=%x/%#v\n", fold.cvalue, addrOf(fold.gvalue), fold.gvalue) + stats.valuesAlive(+1) + C.engineSetContextForObject(engine.addr, fold.cvalue) + switch owner { + case cppOwner: + C.engineSetOwnershipCPP(engine.addr, fold.cvalue) + case jsOwner: + C.engineSetOwnershipJS(engine.addr, fold.cvalue) + } + return fold.cvalue +} + +func addrOf(gvalue interface{}) uintptr { + return reflect.ValueOf(gvalue).Pointer() +} + +// typeNew holds fold values that are created by registered types. +// These values are special in two senses: first, they don't have a +// reference to an engine before they are used in a context that can +// set the reference; second, these values always hold a new cvalue, +// because they are created as a side-effect of the registered type +// being instantiated (it's too late to reuse an existent cvalue). +// +// For these reasons, typeNew holds the fold for these values until +// their engine is known, and once it's known they may have to be +// added to the linked list, since mulitple references for the same +// gvalue may occur. +var typeNew = make(map[*valueFold]bool) + +//export hookGoValueTypeNew +func hookGoValueTypeNew(cvalue unsafe.Pointer, specr C.GoTypeSpec_) (foldr C.GoRef) { + // Initialization is postponed until the engine is available, so that + // we can hand Init the qml.Object that represents the object. + spec := types[specr] + if spec == nil { + panic("cannot find the specified TypeSpec") + } + + init := reflect.ValueOf(spec.Init) + fold := &valueFold{ + init: init, + gvalue: reflect.New(init.Type().In(0).Elem()).Interface(), + cvalue: cvalue, + owner: jsOwner, + } + + typeNew[fold] = true + //fmt.Printf("[DEBUG] value alive (type-created): cvalue=%x gvalue=%x/%#v\n", fold.cvalue, addrOf(fold.gvalue), fold.gvalue) + stats.valuesAlive(+1) + return fold.goRef() +} + +//export hookGoValueDestroyed +func hookGoValueDestroyed(enginep unsafe.Pointer, foldr C.GoRef) { + fold := getFoldFromGoRef(foldr) + + engine := fold.engine + if engine == nil { + before := len(typeNew) + delete(typeNew, fold) + fold.destroyRef() + if len(typeNew) == before { + panic("destroying value without an associated engine; who created the value?") + } + } else if engines[engine.addr] == nil { + // Must never do that. The engine holds memory references that C++ depends on. + panic(fmt.Sprintf("engine %p was released from global list while its values were still alive", engine.addr)) + } else { + switch { + case fold.prev != nil: + fold.prev.next = fold.next + if fold.next != nil { + fold.next.prev = fold.prev + } + case fold.next != nil: + fold.next.prev = fold.prev + if fold.prev != nil { + fold.prev.next = fold.next + } else { + fold.engine.values[fold.gvalue] = fold.next + } + default: + before := len(engine.values) + delete(engine.values, fold.gvalue) + if len(engine.values) == before { + panic("destroying value that knows about the engine, but the engine doesn't know about the value; who cleared the engine?") + } + if engine.destroyed && len(engine.values) == 0 { + delete(engines, engine.addr) + } + } + fold.destroyRef() + } + //fmt.Printf("[DEBUG] value destroyed: cvalue=%x gvalue=%x/%#v\n", fold.cvalue, addrOf(fold.gvalue), fold.gvalue) + stats.valuesAlive(-1) +} + +func deref(value reflect.Value) reflect.Value { + for { + switch value.Kind() { + case reflect.Ptr, reflect.Interface: + value = value.Elem() + continue + } + return value + } + panic("cannot happen") +} + +//export hookGoValueReadField +func hookGoValueReadField(enginep unsafe.Pointer, foldr C.GoRef, reflectIndex, getIndex, setIndex C.int, resultdv *C.DataValue) { + fold := ensureEngine(enginep, foldr) + + var field reflect.Value + if getIndex >= 0 { + field = reflect.ValueOf(fold.gvalue).Method(int(getIndex)).Call(nil)[0] + } else { + field = deref(reflect.ValueOf(fold.gvalue)).Field(int(reflectIndex)) + } + field = deref(field) + + // Cannot compare Type directly as field may be invalid (nil). + if field.Kind() == reflect.Slice && field.Type() == typeObjSlice { + // TODO Handle getters that return []qml.Object. + // TODO Handle other GoValue slices (!= []qml.Object). + resultdv.dataType = C.DTListProperty + *(*unsafe.Pointer)(unsafe.Pointer(&resultdv.data)) = C.newListProperty(C.GoRef(foldr), C.intptr_t(reflectIndex), C.intptr_t(setIndex)) + return + } + + fieldk := field.Kind() + if fieldk == reflect.Slice || fieldk == reflect.Struct && field.Type() != typeRGBA { + if field.CanAddr() { + field = field.Addr() + } else if !hashable(field.Interface()) { + t := reflect.ValueOf(fold.gvalue).Type() + for t.Kind() == reflect.Ptr { + t = t.Elem() + } + panic(fmt.Sprintf("cannot access unaddressable and unhashable struct value on interface field %s.%s; value: %#v", t.Name(), t.Field(int(reflectIndex)).Name, field.Interface())) + } + } + var gvalue interface{} + if field.IsValid() { + gvalue = field.Interface() + } + + // TODO Strings are being passed in an unsafe manner here. There is a + // small chance that the field is changed and the garbage collector is run + // before C++ has a chance to look at the data. We can solve this problem + // by queuing up values in a stack, and cleaning the stack when the + // idle timer fires next. + packDataValue(gvalue, resultdv, fold.engine, jsOwner) +} + +//export hookGoValueWriteField +func hookGoValueWriteField(enginep unsafe.Pointer, foldr C.GoRef, reflectIndex, setIndex C.int, assigndv *C.DataValue) { + fold := ensureEngine(enginep, foldr) + v := reflect.ValueOf(fold.gvalue) + ve := v + for ve.Type().Kind() == reflect.Ptr { + ve = ve.Elem() + } + var field, setMethod reflect.Value + if reflectIndex >= 0 { + // It's a real field rather than a getter. + field = ve.Field(int(reflectIndex)) + } + if setIndex >= 0 { + // It has a setter. + setMethod = v.Method(int(setIndex)) + } + + assign := unpackDataValue(assigndv, fold.engine) + + // TODO Return false to the call site if it fails. That's how Qt seems to handle it internally. + err := convertAndSet(field, reflect.ValueOf(assign), setMethod) + if err != nil { + panic(err.Error()) + } +} + +func convertAndSet(to, from reflect.Value, setMethod reflect.Value) (err error) { + var toType reflect.Type + if setMethod.IsValid() { + toType = setMethod.Type().In(0) + } else { + toType = to.Type() + } + fromType := from.Type() + defer func() { + // TODO This is catching more than it should. There are calls + // to custom code below that should be isolated. + if v := recover(); v != nil { + err = fmt.Errorf("cannot use %s as a %s", fromType, toType) + } + }() + if fromType == typeList && toType.Kind() == reflect.Slice { + list := from.Interface().(*List) + from = reflect.MakeSlice(toType, len(list.data), len(list.data)) + elemType := toType.Elem() + for i, elem := range list.data { + from.Index(i).Set(reflect.ValueOf(elem).Convert(elemType)) + } + } else if fromType == typeMap && toType.Kind() == reflect.Map { + qmap := from.Interface().(*Map) + from = reflect.MakeMap(toType) + elemType := toType.Elem() + for i := 0; i < len(qmap.data); i += 2 { + key := reflect.ValueOf(qmap.data[i]) + val := reflect.ValueOf(qmap.data[i+1]) + if val.Type() != elemType { + val = val.Convert(elemType) + } + from.SetMapIndex(key, val) + } + } else if toType != fromType { + from = from.Convert(toType) + } + if setMethod.IsValid() { + setMethod.Call([]reflect.Value{from}) + } else { + to.Set(from) + } + return nil +} + +var ( + dataValueSize = uintptr(unsafe.Sizeof(C.DataValue{})) + dataValueArray [C.MaxParams]C.DataValue +) + +//export hookGoValueCallMethod +func hookGoValueCallMethod(enginep unsafe.Pointer, foldr C.GoRef, reflectIndex C.int, args *C.DataValue) { + fold := ensureEngine(enginep, foldr) + v := reflect.ValueOf(fold.gvalue) + + // TODO Must assert that v is necessarily a pointer here, but we shouldn't have to manipulate + // gvalue here for that. This should happen in a sensible place in the wrapping functions + // that can still error out to the user in due time. + + method := v.Method(int(reflectIndex)) + methodt := method.Type() + methodName := v.Type().Method(int(reflectIndex)).Name + + // TODO Ensure methods with more parameters than this are not registered. + var params [C.MaxParams]reflect.Value + var err error + + numIn := methodt.NumIn() + for i := 0; i < numIn; i++ { + paramdv := (*C.DataValue)(unsafe.Pointer(uintptr(unsafe.Pointer(args)) + (uintptr(i)+1)*dataValueSize)) + param := reflect.ValueOf(unpackDataValue(paramdv, fold.engine)) + if argt := methodt.In(i); param.Type() != argt { + param, err = convertParam(methodName, i, param, argt) + if err != nil { + panic(err.Error()) + } + } + params[i] = param + } + + result := method.Call(params[:numIn]) + + if len(result) == 1 { + packDataValue(result[0].Interface(), args, fold.engine, jsOwner) + } else if len(result) > 1 { + if len(result) > len(dataValueArray) { + panic("function has too many results") + } + for i, v := range result { + packDataValue(v.Interface(), &dataValueArray[i], fold.engine, jsOwner) + } + args.dataType = C.DTVariantList + *(*unsafe.Pointer)(unsafe.Pointer(&args.data)) = C.newVariantList(&dataValueArray[0], C.int(len(result))) + } +} + +func convertParam(methodName string, index int, param reflect.Value, argt reflect.Type) (reflect.Value, error) { + out := reflect.New(argt).Elem() + err := convertAndSet(out, param, reflect.Value{}) + if err != nil { + err = fmt.Errorf("cannot convert parameter %d of method %s from %s to %s; provided value: %#v", + index, methodName, param.Type(), argt, param.Interface()) + return reflect.Value{}, err + } + return out, nil +} + +func printPaintPanic() { + if v := recover(); v != nil { + buf := make([]byte, 8192) + runtime.Stack(buf, false) + fmt.Fprintf(os.Stderr, "panic while painting: %s\n\n%s", v, buf) + } +} + +//export hookGoValuePaint +func hookGoValuePaint(enginep unsafe.Pointer, foldr C.GoRef, reflectIndex C.intptr_t) { + // Besides a convenience this is a workaround for http://golang.org/issue/8588 + defer printPaintPanic() + defer atomic.StoreUintptr(&guiPaintRef, 0) + + // The main GUI thread is mutex-locked while paint methods are called, + // so no two paintings should be happening at the same time. + atomic.StoreUintptr(&guiPaintRef, cdata.Ref()) + + fold := ensureEngine(enginep, foldr) + if fold.init.IsValid() { + return + } + + painter := &Painter{engine: fold.engine, obj: &Common{fold.cvalue, fold.engine}} + v := reflect.ValueOf(fold.gvalue) + method := v.Method(int(reflectIndex)) + method.Call([]reflect.Value{reflect.ValueOf(painter)}) +} + +func ensureEngine(enginep unsafe.Pointer, foldr C.GoRef) *valueFold { + fold := getFoldFromGoRef(foldr) + if fold.engine != nil { + if fold.init.IsValid() { + initGoType(fold) + } + return fold + } + + if enginep == nilPtr { + panic("accessing value without an engine pointer; who created the value?") + } + engine := engines[enginep] + if engine == nil { + panic("unknown engine pointer; who created the engine?") + } + fold.engine = engine + prev := engine.values[fold.gvalue] + if prev != nil { + for prev.next != nil { + prev = prev.next + } + prev.next = fold + fold.prev = prev + } else { + engine.values[fold.gvalue] = fold + } + before := len(typeNew) + delete(typeNew, fold) + if len(typeNew) == before { + panic("value had no engine, but was not created by a registered type; who created the value?") + } + initGoType(fold) + return fold +} + +func initGoType(fold *valueFold) { + if cdata.Ref() == atomic.LoadUintptr(&guiPaintRef) { + go RunMain(func() { _initGoType(fold, true) }) + } else { + _initGoType(fold, false) + } +} + +func _initGoType(fold *valueFold, schedulePaint bool) { + if !fold.init.IsValid() { + return + } + // TODO Would be good to preserve identity on the Go side. See unpackDataValue as well. + obj := &Common{engine: fold.engine, addr: fold.cvalue} + fold.init.Call([]reflect.Value{reflect.ValueOf(fold.gvalue), reflect.ValueOf(obj)}) + fold.init = reflect.Value{} + if schedulePaint { + obj.Call("update") + } +} + +//export hookPanic +func hookPanic(message *C.char) { + defer C.free(unsafe.Pointer(message)) + panic(C.GoString(message)) +} + +func listSlice(fold *valueFold, reflectIndex C.intptr_t) *[]Object { + field := deref(reflect.ValueOf(fold.gvalue)).Field(int(reflectIndex)) + return field.Addr().Interface().(*[]Object) +} + +//export hookListPropertyAt +func hookListPropertyAt(foldr C.GoRef, reflectIndex, setIndex C.intptr_t, index C.int) (objp unsafe.Pointer) { + fold := getFoldFromGoRef(foldr) + slice := listSlice(fold, reflectIndex) + return (*slice)[int(index)].Common().addr +} + +//export hookListPropertyCount +func hookListPropertyCount(foldr C.GoRef, reflectIndex, setIndex C.intptr_t) C.int { + fold := getFoldFromGoRef(foldr) + slice := listSlice(fold, reflectIndex) + return C.int(len(*slice)) +} + +//export hookListPropertyAppend +func hookListPropertyAppend(foldr C.GoRef, reflectIndex, setIndex C.intptr_t, objp unsafe.Pointer) { + fold := getFoldFromGoRef(foldr) + slice := listSlice(fold, reflectIndex) + var objdv C.DataValue + objdv.dataType = C.DTObject + *(*unsafe.Pointer)(unsafe.Pointer(&objdv.data)) = objp + newslice := append(*slice, unpackDataValue(&objdv, fold.engine).(Object)) + if setIndex >= 0 { + reflect.ValueOf(fold.gvalue).Method(int(setIndex)).Call([]reflect.Value{reflect.ValueOf(newslice)}) + } else { + *slice = newslice + } +} + +//export hookListPropertyClear +func hookListPropertyClear(foldr C.GoRef, reflectIndex, setIndex C.intptr_t) { + fold := getFoldFromGoRef(foldr) + slice := listSlice(fold, reflectIndex) + newslice := (*slice)[0:0] + if setIndex >= 0 { + reflect.ValueOf(fold.gvalue).Method(int(setIndex)).Call([]reflect.Value{reflect.ValueOf(newslice)}) + } else { + for i := range *slice { + (*slice)[i] = nil + } + *slice = newslice + } +} diff --git a/cdata/cdata.go b/cdata/cdata.go new file mode 100644 index 00000000..6f13b810 --- /dev/null +++ b/cdata/cdata.go @@ -0,0 +1,6 @@ +// Package cdata supports the implementation of the qml package. +package cdata + +func Ref() uintptr + +func Addrs() (uintptr, uintptr) diff --git a/cdata/cdata12.c b/cdata/cdata12.c new file mode 100644 index 00000000..2e60abfa --- /dev/null +++ b/cdata/cdata12.c @@ -0,0 +1,18 @@ +// +build !go1.4 + +#include "runtime.h" + +void ·Ref(uintptr ref) { + ref = (uintptr)g->m; + FLUSH(&ref); +} + +void runtime·main(void); +void main·main(void); + +void ·Addrs(uintptr rmain, uintptr mmain) { + rmain = (uintptr)runtime·main; + mmain = (uintptr)main·main; + FLUSH(&rmain); + FLUSH(&mmain); +} diff --git a/cdata/cdata14_386.s b/cdata/cdata14_386.s new file mode 100644 index 00000000..7dae9b96 --- /dev/null +++ b/cdata/cdata14_386.s @@ -0,0 +1,17 @@ +// +build go1.4 + +#include "textflag.h" + +TEXT ·Ref(SB),NOSPLIT,$4-4 + CALL runtime·acquirem(SB) + MOVL 0(SP), AX + MOVL AX, ret+0(FP) + CALL runtime·releasem(SB) + RET + +TEXT ·Addrs(SB),NOSPLIT,$0-8 + MOVL $runtime·main(SB), AX + MOVL AX, ret+0(FP) + MOVL $runtime·main_main(SB), AX + MOVL AX, ret+8(FP) + RET diff --git a/cdata/cdata14_amd64.s b/cdata/cdata14_amd64.s new file mode 100644 index 00000000..83cc22c9 --- /dev/null +++ b/cdata/cdata14_amd64.s @@ -0,0 +1,17 @@ +// +build go1.4 + +#include "textflag.h" + +TEXT ·Ref(SB),NOSPLIT,$8-8 + CALL runtime·acquirem(SB) + MOVQ 0(SP), AX + MOVQ AX, ret+0(FP) + CALL runtime·releasem(SB) + RET + +TEXT ·Addrs(SB),NOSPLIT,$0-16 + MOVQ $runtime·main(SB), AX + MOVQ AX, ret+0(FP) + MOVQ $runtime·main_main(SB), AX + MOVQ AX, ret+8(FP) + RET diff --git a/cdata/cdata14_arm.s b/cdata/cdata14_arm.s new file mode 100644 index 00000000..c66bbafb --- /dev/null +++ b/cdata/cdata14_arm.s @@ -0,0 +1,18 @@ +// +build go1.4 + +#include "textflag.h" + +TEXT ·Ref(SB),NOSPLIT,$4-4 + BL runtime·acquirem(SB) + MOVW 4(R13), R0 + MOVW R0, ret+0(FP) + MOVW R0, 4(R13) + BL runtime·releasem(SB) + RET + +TEXT ·Addrs(SB),NOSPLIT,$0-8 + MOVW $runtime·main(SB), R0 + MOVW R0, ret+0(FP) + MOVW $runtime·main_main(SB), R0 + MOVW R0, ret+4(FP) + RET diff --git a/cdata/cdata_test.go b/cdata/cdata_test.go new file mode 100644 index 00000000..e7c3f33c --- /dev/null +++ b/cdata/cdata_test.go @@ -0,0 +1,42 @@ +package cdata + +import ( + "runtime" + "sync" + "testing" +) + +type refPair struct { + ref1, ref2 uintptr +} + +func TestRef(t *testing.T) { + const N = 10 + runtime.LockOSThread() + exit := sync.WaitGroup{} + exit.Add(1) + defer exit.Done() + wg := sync.WaitGroup{} + wg.Add(N) + ch := make(chan refPair) + for i := 0; i < N; i++ { + go func() { + runtime.LockOSThread() + wg.Done() + ch <- refPair{Ref(), Ref()} + exit.Wait() + }() + } + wg.Wait() + refs := make(map[uintptr]bool) + for i := 0; i < N; i++ { + pair := <-ch + if pair.ref1 != pair.ref2 { + t.Fatalf("found inconsistent ref: %d != %d", pair.ref1, pair.ref2) + } + if refs[pair.ref1] { + t.Fatalf("found duplicated ref: %d", pair.ref1) + } + refs[pair.ref1] = true + } +} diff --git a/cmd/genqrc/genqrc b/cmd/genqrc/genqrc new file mode 100755 index 00000000..9ac5c445 Binary files /dev/null and b/cmd/genqrc/genqrc differ diff --git a/cmd/genqrc/main.go b/cmd/genqrc/main.go new file mode 100644 index 00000000..a601d812 --- /dev/null +++ b/cmd/genqrc/main.go @@ -0,0 +1,218 @@ + +// XXX: The documentation is duplicated here and in the the doc variable +// below. Update both at the same time. + +// Command genqrc packs resource files into the Go binary. +// +// Usage: genqrc [options] [ ...] +// +// The genqrc tool packs all resource files under the provided subdirectories into +// a single qrc.go file that may be built into the generated binary. Bundled files +// may then be loaded by Go or QML code under the URL "qrc:///some/path", where +// "some/path" matches the original path for the resource file locally. +// +// For example, the following will load a .qml file from the resource pack, and +// that file may in turn reference other content (code, images, etc) in the pack: +// +// component, err := engine.LoadFile("qrc://path/to/file.qml") +// +// Starting with Go 1.4, this tool may be conveniently run by the "go generate" +// subcommand by adding a line similar to the following one to any existent .go +// file in the project (assuming the subdirectories ./code/ and ./images/ exist): +// +// //go:generate genqrc code images +// +// Then, just run "go generate" to update the qrc.go file. +// +// During development, the generated qrc.go can repack the filesystem content at +// runtime to avoid the process of regenerating the qrc.go file and rebuilding the +// application to test every minor change made. Runtime repacking is enabled by +// setting the QRC_REPACK environment variable to 1: +// +// export QRC_REPACK=1 +// +// This does not update the static content in the qrc.go file, though, so after +// the changes are performed, genqrc must be run again to update the content that +// will ship with built binaries. +package main + +import ( + "flag" + "fmt" + "io/ioutil" + "os" + "path/filepath" + "text/template" + + "gopkg.in/qml.v1" +) + +const doc = ` +Usage: genqrc [options] [ ...] + +The genqrc tool packs all resource files under the provided subdirectories into +a single qrc.go file that may be built into the generated binary. Bundled files +may then be loaded by Go or QML code under the URL "qrc:///some/path", where +"some/path" matches the original path for the resource file locally. + +For example, the following will load a .qml file from the resource pack, and +that file may in turn reference other content (code, images, etc) in the pack: + + component, err := engine.LoadFile("qrc://path/to/file.qml") + +Starting with Go 1.4, this tool may be conveniently run by the "go generate" +subcommand by adding a line similar to the following one to any existent .go +file in the project (assuming the subdirectories ./code/ and ./images/ exist): + + //go:generate genqrc code images + +Then, just run "go generate" to update the qrc.go file. + +During development, the generated qrc.go can repack the filesystem content at +runtime to avoid the process of regenerating the qrc.go file and rebuilding the +application to test every minor change made. Runtime repacking is enabled by +setting the QRC_REPACK environment variable to 1: + + export QRC_REPACK=1 + +This does not update the static content in the qrc.go file, though, so after +the changes are performed, genqrc must be run again to update the content that +will ship with built binaries. +` + +// XXX: The documentation is duplicated here and in the the package comment +// above. Update both at the same time. + +var packageName = flag.String("package", "main", "package name that qrc.go will be under (not needed for go generate)") + +func main() { + flag.Usage = func() { + fmt.Fprintf(os.Stderr, "%s", doc) + flag.PrintDefaults() + } + flag.Parse() + if err := run(); err != nil { + fmt.Fprintf(os.Stderr, "error: %v\n", err) + os.Exit(1) + } +} + +func run() error { + subdirs := flag.Args() + if len(subdirs) == 0 { + return fmt.Errorf("must provide at least one subdirectory path") + } + + var rp qml.ResourcesPacker + + for _, subdir := range flag.Args() { + err := filepath.Walk(subdir, func(path string, info os.FileInfo, err error) error { + if err != nil { + return err + } + if info.IsDir() { + return nil + } + data, err := ioutil.ReadFile(path) + if err != nil { + return err + } + rp.Add(filepath.ToSlash(path), data) + return nil + }) + if err != nil { + return err + } + } + + resdata := rp.Pack().Bytes() + + f, err := os.Create("qrc.go") + if err != nil { + return err + } + defer f.Close() + + data := templateData{ + PackageName: *packageName, + SubDirs: subdirs, + ResourcesData: resdata, + } + + // $GOPACKAGE is set automatically by go generate. + if pkgname := os.Getenv("GOPACKAGE"); pkgname != "" { + data.PackageName = pkgname + } + + return tmpl.Execute(f, data) +} + +type templateData struct { + PackageName string + SubDirs []string + ResourcesData []byte +} + +func buildTemplate(name, content string) *template.Template { + return template.Must(template.New(name).Parse(content)) +} + +var tmpl = buildTemplate("qrc.go", `package {{.PackageName}} + +// This file is automatically generated by gopkg.in/qml.v1/cmd/genqrc + +import ( + "io/ioutil" + "os" + "path/filepath" + + "gopkg.in/qml.v1" +) + +func init() { + var r *qml.Resources + var err error + if os.Getenv("QRC_REPACK") == "1" { + err = qrcRepackResources() + if err != nil { + panic("cannot repack qrc resources: " + err.Error()) + } + r, err = qml.ParseResources(qrcResourcesRepacked) + } else { + r, err = qml.ParseResourcesString(qrcResourcesData) + } + if err != nil { + panic("cannot parse bundled resources data: " + err.Error()) + } + qml.LoadResources(r) +} + +func qrcRepackResources() error { + subdirs := {{printf "%#v" .SubDirs}} + var rp qml.ResourcesPacker + for _, subdir := range subdirs { + err := filepath.Walk(subdir, func(path string, info os.FileInfo, err error) error { + if err != nil { + return err + } + if info.IsDir() { + return nil + } + data, err := ioutil.ReadFile(path) + if err != nil { + return err + } + rp.Add(filepath.ToSlash(path), data) + return nil + }) + if err != nil { + return err + } + } + qrcResourcesRepacked = rp.Pack().Bytes() + return nil +} + +var qrcResourcesRepacked []byte +var qrcResourcesData = {{printf "%q" .ResourcesData}} +`) diff --git a/cmd/ubuntu-touch/particle.desktop b/cmd/ubuntu-touch/particle.desktop new file mode 100644 index 00000000..76a62cb5 --- /dev/null +++ b/cmd/ubuntu-touch/particle.desktop @@ -0,0 +1,15 @@ +[Desktop Entry] +Encoding=UTF-8 +Version=1.0 +Type=Application +Terminal=false +Path=/home/phablet/src/gopkg.in/qml.v0/examples/particle/ +Exec=./particle +Icon=properties +Name=Particle Example +X-Ubuntu-Touch=true +X-Ubuntu-StageHint=SideStage + +# Copy this file to: +# +# ~phablet/.local/share/applications/gopkg.in.qml.particle-example.desktop diff --git a/cmd/ubuntu-touch/setup.sh b/cmd/ubuntu-touch/setup.sh new file mode 100644 index 00000000..1d045411 --- /dev/null +++ b/cmd/ubuntu-touch/setup.sh @@ -0,0 +1,41 @@ +#!/bin/sh + +set -e + +if [ "$USER" != "root" ]; then + echo 'This script must be run as root.' + exit 1 +fi + +echo 'Remounting root as read-write ------------------------------------------------' + +mount -o remount,rw / + +echo 'Installing Go and dependencies -----------------------------------------------' + +apt-get update +apt-get install -y \ + golang-go g++ git pkg-config ubuntu-app-launch\ + qtbase5-private-dev qtdeclarative5-private-dev libqt5opengl5-dev +apt-get clean + +echo 'Setting up environment for phablet user --------------------------------------' + +echo 'export GOPATH=$HOME' >> ~phablet/.bash_profile + +echo 'Fetching the qml package -----------------------------------------------------' + +su -l phablet -c 'go get gopkg.in/qml.v0' + +echo 'Installing the .desktop file for the particle example ------------------------' + +APP_ID='gopkg.in.qml.particle-example' +cp ~phablet/src/gopkg.in/qml.v*/cmd/ubuntu-touch/particle.desktop ~phablet/.local/share/applications/$APP_ID.desktop + +echo 'Building and launching particle example --------------------------------------' + +su -l phablet -c 'cd $HOME/src/gopkg.in/qml.v0/examples/particle; go build' + +echo 'Launching particle example ---------------------------------------------------' + +su -l phablet -c "ubuntu-app-launch $APP_ID" diff --git a/cpp/capi.cpp b/cpp/capi.cpp new file mode 100644 index 00000000..8a3dcfd2 --- /dev/null +++ b/cpp/capi.cpp @@ -0,0 +1,874 @@ +#include +#include +#include +#include +#include +#include + +#include + +#include "govalue.h" +#include "govaluetype.h" +#include "connector.h" +#include "capi.h" + +static char *local_strdup(const char *str) +{ + char *strcopy = 0; + if (str) { + size_t len = strlen(str) + 1; + strcopy = (char *)malloc(len); + memcpy(strcopy, str, len); + } + return strcopy; +} + +error *errorf(const char *format, ...) +{ + va_list ap; + va_start(ap, format); + QString str = QString().vsprintf(format, ap); + va_end(ap); + QByteArray ba = str.toUtf8(); + return local_strdup(ba.constData()); +} + +void panicf(const char *format, ...) +{ + va_list ap; + va_start(ap, format); + QString str = QString().vsprintf(format, ap); + va_end(ap); + QByteArray ba = str.toUtf8(); + hookPanic(local_strdup(ba.constData())); +} + +void newGuiApplication() +{ + static char empty[1] = {0}; + static char *argv[] = {empty, 0}; + static int argc = 1; + new QApplication(argc, argv); + + // The event loop should never die. + qApp->setQuitOnLastWindowClosed(false); +} + +void applicationExec() +{ + qApp->exec(); +} + +void applicationExit() +{ + qApp->exit(0); +} + +void applicationFlushAll() +{ + qApp->processEvents(); +} + +void *currentThread() +{ + return QThread::currentThread(); +} + +void *appThread() +{ + return QCoreApplication::instance()->thread(); +} + +QQmlEngine_ *newEngine(QObject_ *parent) +{ + return new QQmlEngine(reinterpret_cast(parent)); +} + +QQmlContext_ *engineRootContext(QQmlEngine_ *engine) +{ + return reinterpret_cast(engine)->rootContext(); +} + +void engineSetContextForObject(QQmlEngine_ *engine, QObject_ *object) +{ + QQmlEngine *qengine = reinterpret_cast(engine); + QObject *qobject = reinterpret_cast(object); + + QQmlEngine::setContextForObject(qobject, qengine->rootContext()); +} + +void engineSetOwnershipCPP(QQmlEngine_ *engine, QObject_ *object) +{ + QQmlEngine *qengine = reinterpret_cast(engine); + QObject *qobject = reinterpret_cast(object); + + qengine->setObjectOwnership(qobject, QQmlEngine::CppOwnership); +} + +void engineSetOwnershipJS(QQmlEngine_ *engine, QObject_ *object) +{ + QQmlEngine *qengine = reinterpret_cast(engine); + QObject *qobject = reinterpret_cast(object); + + qengine->setObjectOwnership(qobject, QQmlEngine::JavaScriptOwnership); +} + +QQmlComponent_ *newComponent(QQmlEngine_ *engine, QObject_ *parent) +{ + QQmlEngine *qengine = reinterpret_cast(engine); + //QObject *qparent = reinterpret_cast(parent); + QQmlComponent *qcomponent = new QQmlComponent(qengine); + // Qt 5.2.0 returns NULL on qmlEngine(qcomponent) without this. + QQmlEngine::setContextForObject(qcomponent, qengine->rootContext()); + return qcomponent; +} + +class GoImageProvider : public QQuickImageProvider { + + // TODO Destroy this when engine is destroyed. + + public: + + GoImageProvider(void *imageFunc) : QQuickImageProvider(QQmlImageProviderBase::Image), imageFunc(imageFunc) {}; + + virtual QImage requestImage(const QString &id, QSize *size, const QSize &requestedSize) + { + QByteArray ba = id.toUtf8(); + int width = 0, height = 0; + if (requestedSize.isValid()) { + width = requestedSize.width(); + height = requestedSize.height(); + } + QImage *ptr = reinterpret_cast(hookRequestImage(imageFunc, (char*)ba.constData(), ba.size(), width, height)); + QImage image = *ptr; + delete ptr; + + *size = image.size(); + if (requestedSize.isValid() && requestedSize != *size) { + image = image.scaled(requestedSize, Qt::KeepAspectRatio); + } + return image; + }; + + private: + + void *imageFunc; +}; + +void engineAddImageProvider(QQmlEngine_ *engine, QString_ *providerId, void *imageFunc) +{ + QQmlEngine *qengine = reinterpret_cast(engine); + QString *qproviderId = reinterpret_cast(providerId); + + qengine->addImageProvider(*qproviderId, new GoImageProvider(imageFunc)); +} + +void componentLoadURL(QQmlComponent_ *component, const char *url, int urlLen) +{ + QByteArray qurl(url, urlLen); + QString qsurl = QString::fromUtf8(qurl); + reinterpret_cast(component)->loadUrl(qsurl); +} + +void componentSetData(QQmlComponent_ *component, const char *data, int dataLen, const char *url, int urlLen) +{ + QByteArray qdata(data, dataLen); + QByteArray qurl(url, urlLen); + QString qsurl = QString::fromUtf8(qurl); + reinterpret_cast(component)->setData(qdata, qsurl); +} + +char *componentErrorString(QQmlComponent_ *component) +{ + QQmlComponent *qcomponent = reinterpret_cast(component); + if (qcomponent->isReady()) { + return NULL; + } + if (qcomponent->isError()) { + QByteArray ba = qcomponent->errorString().toUtf8(); + return local_strdup(ba.constData()); + } + return local_strdup("component is not ready (why!?)"); +} + +QObject_ *componentCreate(QQmlComponent_ *component, QQmlContext_ *context) +{ + QQmlComponent *qcomponent = reinterpret_cast(component); + QQmlContext *qcontext = reinterpret_cast(context); + + if (!qcontext) { + qcontext = qmlContext(qcomponent); + } + return qcomponent->create(qcontext); +} + +QQuickWindow_ *componentCreateWindow(QQmlComponent_ *component, QQmlContext_ *context) +{ + QQmlComponent *qcomponent = reinterpret_cast(component); + QQmlContext *qcontext = reinterpret_cast(context); + + if (!qcontext) { + qcontext = qmlContext(qcomponent); + } + QObject *obj = qcomponent->create(qcontext); + if (!objectIsWindow(obj)) { + QQuickView *view = new QQuickView(qmlEngine(qcomponent), 0); + view->setContent(qcomponent->url(), qcomponent, obj); + view->setResizeMode(QQuickView::SizeRootObjectToView); + obj = view; + } + return obj; +} + +// Workaround for bug https://bugs.launchpad.net/bugs/1179716 +struct DoShowWindow : public QQuickWindow { + void show() { + QQuickWindow::show(); + QResizeEvent resize(size(), size()); + resizeEvent(&resize); + } +}; + +void windowShow(QQuickWindow_ *win) +{ + reinterpret_cast(win)->show(); +} + +void windowHide(QQuickWindow_ *win) +{ + reinterpret_cast(win)->hide(); +} + +uintptr_t windowPlatformId(QQuickWindow_ *win) +{ + return reinterpret_cast(win)->winId(); +} + +void windowConnectHidden(QQuickWindow_ *win) +{ + QQuickWindow *qwin = reinterpret_cast(win); + QObject::connect(qwin, &QWindow::visibleChanged, [=](bool visible){ + if (!visible) { + hookWindowHidden(win); + } + }); +} + +QObject_ *windowRootObject(QQuickWindow_ *win) +{ + if (objectIsView(win)) { + return reinterpret_cast(win)->rootObject(); + } + return win; +} + +QImage_ *windowGrabWindow(QQuickWindow_ *win) +{ + QQuickWindow *qwin = reinterpret_cast(win); + QImage *image = new QImage; + *image = qwin->grabWindow().convertToFormat(QImage::Format_ARGB32_Premultiplied); + return image; +} + +QImage_ *newImage(int width, int height) +{ + return new QImage(width, height, QImage::Format_ARGB32_Premultiplied); +} + +void delImage(QImage_ *image) +{ + delete reinterpret_cast(image); +} + +void imageSize(QImage_ *image, int *width, int *height) +{ + QImage *qimage = reinterpret_cast(image); + *width = qimage->width(); + *height = qimage->height(); +} + +unsigned char *imageBits(QImage_ *image) +{ + QImage *qimage = reinterpret_cast(image); + return qimage->bits(); +} + +const unsigned char *imageConstBits(QImage_ *image) +{ + QImage *qimage = reinterpret_cast(image); + return qimage->constBits(); +} + +void contextSetObject(QQmlContext_ *context, QObject_ *value) +{ + QQmlContext *qcontext = reinterpret_cast(context); + QObject *qvalue = reinterpret_cast(value); + + // Give qvalue an engine reference if it doesn't yet have one. + if (!qmlEngine(qvalue)) { + QQmlEngine::setContextForObject(qvalue, qcontext->engine()->rootContext()); + } + + qcontext->setContextObject(qvalue); +} + +void contextSetProperty(QQmlContext_ *context, QString_ *name, DataValue *value) +{ + const QString *qname = reinterpret_cast(name); + QQmlContext *qcontext = reinterpret_cast(context); + + QVariant var; + unpackDataValue(value, &var); + + // Give qvalue an engine reference if it doesn't yet have one . + QObject *obj = var.value(); + if (obj && !qmlEngine(obj)) { + QQmlEngine::setContextForObject(obj, qcontext); + } + + qcontext->setContextProperty(*qname, var); +} + +void contextGetProperty(QQmlContext_ *context, QString_ *name, DataValue *result) +{ + QQmlContext *qcontext = reinterpret_cast(context); + const QString *qname = reinterpret_cast(name); + + QVariant var = qcontext->contextProperty(*qname); + packDataValue(&var, result); +} + +QQmlContext_ *contextSpawn(QQmlContext_ *context) +{ + QQmlContext *qcontext = reinterpret_cast(context); + return new QQmlContext(qcontext); +} + +void delObject(QObject_ *object) +{ + delete reinterpret_cast(object); +} + +void delObjectLater(QObject_ *object) +{ + reinterpret_cast(object)->deleteLater(); +} + +const char *objectTypeName(QObject_ *object) +{ + return reinterpret_cast(object)->metaObject()->className(); +} + +int objectGetProperty(QObject_ *object, const char *name, DataValue *result) +{ + QObject *qobject = reinterpret_cast(object); + + QVariant var = qobject->property(name); + packDataValue(&var, result); + + if (!var.isValid() && qobject->metaObject()->indexOfProperty(name) == -1) { + // TODO May have to check the dynamic property names too. + return 0; + } + return 1; +} + +error *objectSetProperty(QObject_ *object, const char *name, DataValue *value) +{ + QObject *qobject = reinterpret_cast(object); + QVariant var; + unpackDataValue(value, &var); + + // Give qvalue an engine reference if it doesn't yet have one. + QObject *obj = var.value(); + if (obj && !qmlEngine(obj)) { + QQmlContext *context = qmlContext(qobject); + if (context) { + QQmlEngine::setContextForObject(obj, context); + } + } + + // Check that the types are compatible. There's probably more to be done here. + const QMetaObject *metaObject = qobject->metaObject(); + int propIndex = metaObject->indexOfProperty(name); + if (propIndex == -1) { + return errorf("cannot set non-existent property \"%s\" on type %s", name, qobject->metaObject()->className()); + } + + QMetaProperty prop = metaObject->property(propIndex); + int propType = prop.userType(); + void *valueArg; + if (propType == QMetaType::QVariant) { + valueArg = (void *)&var; + } else { + int varType = var.userType(); + QVariant saved = var; + if (propType != varType && !var.convert(propType)) { + if (varType == QMetaType::QObjectStar) { + return errorf("cannot set property \"%s\" with type %s to value of %s*", + name, QMetaType::typeName(propType), saved.value()->metaObject()->className()); + } else { + return errorf("cannot set property \"%s\" with type %s to value of %s", + name, QMetaType::typeName(propType), QMetaType::typeName(varType)); + } + } + valueArg = (void *)var.constData(); + } + + int status = -1; + int flags = 0; + void *args[] = {valueArg, 0, &status, &flags}; + QMetaObject::metacall(qobject, QMetaObject::WriteProperty, propIndex, args); + return 0; +} + +error *objectInvoke(QObject_ *object, const char *method, int methodLen, DataValue *resultdv, DataValue *paramsdv, int paramsLen) +{ + QObject *qobject = reinterpret_cast(object); + + QVariant result; + QVariant param[MaxParams]; + QGenericArgument arg[MaxParams]; + for (int i = 0; i < paramsLen; i++) { + unpackDataValue(¶msdv[i], ¶m[i]); + arg[i] = Q_ARG(QVariant, param[i]); + } + if (paramsLen > 10) { + panicf("fix the parameter dispatching"); + } + + const QMetaObject *metaObject = qobject->metaObject(); + // Walk backwards so descendants have priority. + for (int i = metaObject->methodCount()-1; i >= 0; i--) { + QMetaMethod metaMethod = metaObject->method(i); + QMetaMethod::MethodType methodType = metaMethod.methodType(); + if (methodType == QMetaMethod::Method || methodType == QMetaMethod::Slot) { + QByteArray name = metaMethod.name(); + if (name.length() == methodLen && qstrncmp(name.constData(), method, methodLen) == 0) { + if (metaMethod.parameterCount() < paramsLen) { + // TODO Might continue looking to see if a different signal has the same name and enough arguments. + return errorf("method \"%s\" has too few parameters for provided arguments", method); + } + + bool ok; + if (metaMethod.returnType() == QMetaType::Void) { + ok = metaMethod.invoke(qobject, Qt::DirectConnection, + arg[0], arg[1], arg[2], arg[3], arg[4], arg[5], arg[6], arg[7], arg[8], arg[9]); + } else { + ok = metaMethod.invoke(qobject, Qt::DirectConnection, Q_RETURN_ARG(QVariant, result), + arg[0], arg[1], arg[2], arg[3], arg[4], arg[5], arg[6], arg[7], arg[8], arg[9]); + } + if (!ok) { + return errorf("invalid parameters to method \"%s\"", method); + } + + packDataValue(&result, resultdv); + return 0; + } + } + } + + return errorf("object does not expose a method \"%s\"", method); +} + +void objectFindChild(QObject_ *object, QString_ *name, DataValue *resultdv) +{ + QObject *qobject = reinterpret_cast(object); + QString *qname = reinterpret_cast(name); + + QVariant var; + QObject *result = qobject->findChild(*qname); + if (result) { + var.setValue(result); + } + packDataValue(&var, resultdv); +} + +void objectSetParent(QObject_ *object, QObject_ *parent) +{ + QObject *qobject = reinterpret_cast(object); + QObject *qparent = reinterpret_cast(parent); + + qobject->setParent(qparent); +} + +error *objectConnect(QObject_ *object, const char *signal, int signalLen, QQmlEngine_ *engine, GoRef func, int argsLen) +{ + QObject *qobject = reinterpret_cast(object); + QQmlEngine *qengine = reinterpret_cast(engine); + QByteArray qsignal(signal, signalLen); + + const QMetaObject *meta = qobject->metaObject(); + // Walk backwards so descendants have priority. + for (int i = meta->methodCount()-1; i >= 0; i--) { + QMetaMethod method = meta->method(i); + if (method.methodType() == QMetaMethod::Signal) { + QByteArray name = method.name(); + if (name.length() == signalLen && qstrncmp(name.constData(), signal, signalLen) == 0) { + if (method.parameterCount() < argsLen) { + // TODO Might continue looking to see if a different signal has the same name and enough arguments. + return errorf("signal \"%s\" has too few parameters for provided function", name.constData()); + } + Connector *connector = new Connector(qobject, method, qengine, func, argsLen); + const QMetaObject *connmeta = connector->metaObject(); + QObject::connect(qobject, method, connector, connmeta->method(connmeta->methodOffset())); + return 0; + } + } + } + // Cannot use constData here as the byte array is not null-terminated. + return errorf("object does not expose a \"%s\" signal", qsignal.data()); +} + +QQmlContext_ *objectContext(QObject_ *object) +{ + return qmlContext(static_cast(object)); +} + +int objectIsComponent(QObject_ *object) +{ + QObject *qobject = static_cast(object); + return dynamic_cast(qobject) ? 1 : 0; +} + +int objectIsWindow(QObject_ *object) +{ + QObject *qobject = static_cast(object); + return dynamic_cast(qobject) ? 1 : 0; +} + +int objectIsView(QObject_ *object) +{ + QObject *qobject = static_cast(object); + return dynamic_cast(qobject) ? 1 : 0; +} + +error *objectGoRef(QObject_ *object, GoRef *ref) +{ + QObject *qobject = static_cast(object); + GoValue *goValue = dynamic_cast(qobject); + if (goValue) { + *ref = goValue->ref; + return 0; + } + GoPaintedValue *goPaintedValue = dynamic_cast(qobject); + if (goPaintedValue) { + *ref= goPaintedValue->ref; + return 0; + } + return errorf("QML object is not backed by a Go value"); +} + +QString_ *newString(const char *data, int len) +{ + // This will copy data only once. + QByteArray ba = QByteArray::fromRawData(data, len); + return new QString(ba); +} + +void delString(QString_ *s) +{ + delete reinterpret_cast(s); +} + +GoValue_ *newGoValue(GoRef ref, GoTypeInfo *typeInfo, QObject_ *parent) +{ + QObject *qparent = reinterpret_cast(parent); + if (typeInfo->paint) { + return new GoPaintedValue(ref, typeInfo, qparent); + } + return new GoValue(ref, typeInfo, qparent); +} + +void goValueActivate(GoValue_ *value, GoTypeInfo *typeInfo, int addrOffset) +{ + GoMemberInfo *fieldInfo = typeInfo->fields; + for (int i = 0; i < typeInfo->fieldsLen; i++) { + if (fieldInfo->addrOffset == addrOffset) { + if (typeInfo->paint) { + static_cast(value)->activate(fieldInfo->metaIndex); + } else { + static_cast(value)->activate(fieldInfo->metaIndex); + } + return; + } + fieldInfo++; + } + + // TODO Return an error; probably an unexported field. +} + +void unpackDataValue(DataValue *value, QVariant_ *var) +{ + QVariant *qvar = reinterpret_cast(var); + switch (value->dataType) { + case DTString: + *qvar = QString::fromUtf8(*(char **)value->data, value->len); + break; + case DTBool: + *qvar = bool(*(char *)(value->data) != 0); + break; + case DTInt64: + *qvar = *(qint64*)(value->data); + break; + case DTInt32: + *qvar = *(qint32*)(value->data); + break; + case DTUint64: + *qvar = *(quint64*)(value->data); + break; + case DTUint32: + *qvar = *(quint32*)(value->data); + break; + case DTFloat64: + *qvar = *(double*)(value->data); + break; + case DTFloat32: + *qvar = *(float*)(value->data); + break; + case DTColor: + *qvar = QColor::fromRgba(*(QRgb*)(value->data)); + break; + case DTVariantList: + *qvar = **(QVariantList**)(value->data); + delete *(QVariantList**)(value->data); + break; + case DTObject: + qvar->setValue(*(QObject**)(value->data)); + break; + case DTInvalid: + // null would be more natural, but an invalid variant means + // it has proper semantics when dealing with non-qml qt code. + //qvar->setValue(QJSValue(QJSValue::NullValue)); + qvar->clear(); + break; + default: + panicf("unknown data type: %d", value->dataType); + break; + } +} + +void packDataValue(QVariant_ *var, DataValue *value) +{ + QVariant *qvar = reinterpret_cast(var); + + // Some assumptions are made below regarding the size of types. + // There's apparently no better way to handle this since that's + // how the types with well defined sizes (qint64) are mapped to + // meta-types (QMetaType::LongLong). + switch ((int)qvar->type()) { + case QVariant::Invalid: + value->dataType = DTInvalid; + break; + case QMetaType::QUrl: + *qvar = qvar->value().toString(); + // fallthrough + case QMetaType::QString: + { + value->dataType = DTString; + QByteArray ba = qvar->toByteArray(); + *(char**)(value->data) = local_strdup(ba.constData()); + value->len = ba.size(); + break; + } + case QMetaType::Bool: + value->dataType = DTBool; + *(qint8*)(value->data) = (qint8)qvar->toInt(); + break; + case QMetaType::LongLong: + // Some of these entries will have to be fixed when handling platforms + // where sizeof(long long) != 8 or sizeof(int) != 4. + value->dataType = DTInt64; + *(qint64*)(value->data) = qvar->toLongLong(); + break; + case QMetaType::ULongLong: + value->dataType = DTUint64; + *(quint64*)(value->data) = qvar->toLongLong(); + break; + case QMetaType::Int: + value->dataType = DTInt32; + *(qint32*)(value->data) = qvar->toInt(); + break; + case QMetaType::UInt: + value->dataType = DTUint32; + *(quint32*)(value->data) = qvar->toUInt(); + break; + case QMetaType::VoidStar: + value->dataType = DTUintptr; + *(uintptr_t*)(value->data) = (uintptr_t)qvar->value(); + break; + case QMetaType::Double: + value->dataType = DTFloat64; + *(double*)(value->data) = qvar->toDouble(); + break; + case QMetaType::Float: + value->dataType = DTFloat32; + *(float*)(value->data) = qvar->toFloat(); + break; + case QMetaType::QColor: + value->dataType = DTColor; + *(unsigned int*)(value->data) = qvar->value().rgba(); + break; + case QMetaType::QVariantList: + { + QVariantList varlist = qvar->toList(); + int len = varlist.size(); + DataValue *dvlist = (DataValue *) malloc(sizeof(DataValue) * len); + for (int i = 0; i < len; i++) { + packDataValue((void*)&varlist.at(i), &dvlist[i]); + } + value->dataType = DTValueList; + value->len = len; + *(DataValue**)(value->data) = dvlist; + } + break; + case QMetaType::QVariantMap: + { + QVariantMap varmap = qvar->toMap(); + int len = varmap.size() * 2; + DataValue *dvlist = (DataValue *) malloc(sizeof(DataValue) * len); + QMapIterator it(varmap); + for (int i = 0; i < len; i += 2) { + if (!it.hasNext()) { + panicf("QVariantMap mutated during iteration"); + } + it.next(); + QVariant key = it.key(); + QVariant val = it.value(); + packDataValue((void*)&key, &dvlist[i]); + packDataValue((void*)&val, &dvlist[i+1]); + } + value->dataType = DTValueMap; + value->len = len; + *(DataValue**)(value->data) = dvlist; + } + break; + default: + if (qvar->type() == (int)QMetaType::QObjectStar || qvar->canConvert()) { + QObject *qobject = qvar->value(); + GoValue *goValue = dynamic_cast(qobject); + if (goValue) { + value->dataType = DTGoAddr; + *(uintptr_t*)(value->data) = goValue->ref; + break; + } + GoPaintedValue *goPaintedValue = dynamic_cast(qobject); + if (goPaintedValue) { + value->dataType = DTGoAddr; + *(uintptr_t*)(value->data) = goPaintedValue->ref; + break; + } + value->dataType = DTObject; + *(void **)(value->data) = qobject; + break; + } + { + QQmlListReference ref = qvar->value(); + if (ref.isValid() && ref.canCount() && ref.canAt()) { + int len = ref.count(); + DataValue *dvlist = (DataValue *) malloc(sizeof(DataValue) * len); + QVariant elem; + for (int i = 0; i < len; i++) { + elem.setValue(ref.at(i)); + packDataValue(&elem, &dvlist[i]); + } + value->dataType = DTValueList; + value->len = len; + *(DataValue**)(value->data) = dvlist; + break; + } + } + if (qstrncmp(qvar->typeName(), "QQmlListProperty<", 17) == 0) { + QQmlListProperty *list = reinterpret_cast*>(qvar->data()); + if (list->count && list->at) { + int len = list->count(list); + DataValue *dvlist = (DataValue *) malloc(sizeof(DataValue) * len); + QVariant elem; + for (int i = 0; i < len; i++) { + elem.setValue(list->at(list, i)); + packDataValue(&elem, &dvlist[i]); + } + value->dataType = DTValueList; + value->len = len; + *(DataValue**)(value->data) = dvlist; + break; + } + } + panicf("unsupported variant type: %d (%s)", qvar->type(), qvar->typeName()); + break; + } +} + +QVariantList_ *newVariantList(DataValue *list, int len) +{ + QVariantList *vlist = new QVariantList(); + vlist->reserve(len); + for (int i = 0; i < len; i++) { + QVariant var; + unpackDataValue(&list[i], &var); + vlist->append(var); + } + return vlist; +} + +QObject *listPropertyAt(QQmlListProperty *list, int i) +{ + return reinterpret_cast(hookListPropertyAt((uintptr_t)list->data, (intptr_t)list->dummy1, (intptr_t)list->dummy2, i)); +} + +int listPropertyCount(QQmlListProperty *list) +{ + return hookListPropertyCount((uintptr_t)list->data, (intptr_t)list->dummy1, (intptr_t)list->dummy2); +} + +void listPropertyAppend(QQmlListProperty *list, QObject *obj) +{ + hookListPropertyAppend((uintptr_t)list->data, (intptr_t)list->dummy1, (intptr_t)list->dummy2, obj); +} + +void listPropertyClear(QQmlListProperty *list) +{ + hookListPropertyClear((uintptr_t)list->data, (intptr_t)list->dummy1, (intptr_t)list->dummy2); +} + +QQmlListProperty_ *newListProperty(GoRef ref, intptr_t reflectIndex, intptr_t setIndex) +{ + QQmlListProperty *list = new QQmlListProperty(); + list->data = (void*)ref; + list->dummy1 = (void*)reflectIndex; + list->dummy2 = (void*)setIndex; + list->at = listPropertyAt; + list->count = listPropertyCount; + list->append = listPropertyAppend; + list->clear = listPropertyClear; + return list; +} + +void internalLogHandler(QtMsgType severity, const QMessageLogContext &context, const QString &text) +{ + QByteArray textba = text.toUtf8(); + const int fileLength = context.file ? strlen(context.file) : 0; + LogMessage message = {severity, textba.constData(), textba.size(), context.file, fileLength, context.line}; + hookLogHandler(&message); +} + +void installLogHandler() +{ + qInstallMessageHandler(internalLogHandler); +} + + +extern bool qRegisterResourceData(int version, const unsigned char *tree, const unsigned char *name, const unsigned char *data); +extern bool qUnregisterResourceData(int version, const unsigned char *tree, const unsigned char *name, const unsigned char *data); + +void registerResourceData(int version, char *tree, char *name, char *data) +{ + qRegisterResourceData(version, (unsigned char*)tree, (unsigned char*)name, (unsigned char*)data); +} + +void unregisterResourceData(int version, char *tree, char *name, char *data) +{ + qUnregisterResourceData(version, (unsigned char*)tree, (unsigned char*)name, (unsigned char*)data); +} + +// vim:ts=4:sw=4:et:ft=cpp diff --git a/cpp/capi.h b/cpp/capi.h new file mode 100644 index 00000000..1dd6824b --- /dev/null +++ b/cpp/capi.h @@ -0,0 +1,212 @@ +#ifndef CAPI_H +#define CAPI_H + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// It's surprising that MaximumParamCount is privately defined within qmetaobject.cpp. +// Must fix the objectInvoke function if this is changed. +// This is Qt's MaximuParamCount - 1, as it does not take the result value in account. +enum { MaxParams = 10 }; + +typedef void QApplication_; +typedef void QMetaObject_; +typedef void QObject_; +typedef void QVariant_; +typedef void QVariantList_; +typedef void QString_; +typedef void QQmlEngine_; +typedef void QQmlContext_; +typedef void QQmlComponent_; +typedef void QQmlListProperty_; +typedef void QQuickWindow_; +typedef void QQuickView_; +typedef void QMessageLogContext_; +typedef void QImage_; +typedef void GoValue_; +typedef void GoAddr; +typedef uintptr_t GoRef; +typedef uintptr_t GoTypeSpec_; + +typedef char error; +error *errorf(const char *format, ...); +void panicf(const char *format, ...); + +typedef enum { + DTUnknown = 0, // Has an unsupported type. + DTInvalid = 1, // Does not exist or similar. + + DTString = 10, + DTBool = 11, + DTInt64 = 12, + DTInt32 = 13, + DTUint64 = 14, + DTUint32 = 15, + DTUintptr = 16, + DTFloat64 = 17, + DTFloat32 = 18, + DTColor = 19, + + DTGoAddr = 100, + DTObject = 101, + DTValueMap = 102, + DTValueList = 103, + DTVariantList = 104, + DTListProperty = 105, + + // Used in type information, not in an actual data value. + DTAny = 201, // Can hold any of the above types. + DTMethod = 202 +} DataType; + +typedef struct { + DataType dataType; + char data[8]; + int len; +} DataValue; + +typedef struct { + char *memberName; // points to memberNames + DataType memberType; + int reflectIndex; + int reflectGetIndex; + int reflectSetIndex; + int metaIndex; + int addrOffset; + char *methodSignature; + char *resultSignature; + int numIn; + int numOut; +} GoMemberInfo; + +typedef struct { + char *typeName; + GoMemberInfo *fields; + GoMemberInfo *methods; + GoMemberInfo *members; // fields + methods + GoMemberInfo *paint; // in methods too + int fieldsLen; + int methodsLen; + int membersLen; + char *memberNames; + + QMetaObject_ *metaObject; +} GoTypeInfo; + +typedef struct { + int severity; + const char *text; + int textLen; + const char *file; + int fileLen; + int line; +} LogMessage; + +void newGuiApplication(); +void applicationExec(); +void applicationExit(); +void applicationFlushAll(); + +void idleTimerInit(int32_t *guiIdleRun); +void idleTimerStart(); + +void *currentThread(); +void *appThread(); + +QQmlEngine_ *newEngine(QObject_ *parent); +QQmlContext_ *engineRootContext(QQmlEngine_ *engine); +void engineSetOwnershipCPP(QQmlEngine_ *engine, QObject_ *object); +void engineSetOwnershipJS(QQmlEngine_ *engine, QObject_ *object); +void engineSetContextForObject(QQmlEngine_ *engine, QObject_ *object); +void engineAddImageProvider(QQmlEngine_ *engine, QString_ *providerId, void *imageFunc); + +void contextGetProperty(QQmlContext_ *context, QString_ *name, DataValue *value); +void contextSetProperty(QQmlContext_ *context, QString_ *name, DataValue *value); +void contextSetObject(QQmlContext_ *context, QObject_ *value); +QQmlContext_ *contextSpawn(QQmlContext_ *context); + +void delObject(QObject_ *object); +void delObjectLater(QObject_ *object); +const char *objectTypeName(QObject_ *object); +int objectGetProperty(QObject_ *object, const char *name, DataValue *result); +error *objectSetProperty(QObject_ *object, const char *name, DataValue *value); +void objectSetParent(QObject_ *object, QObject_ *parent); +error *objectInvoke(QObject_ *object, const char *method, int methodLen, DataValue *result, DataValue *params, int paramsLen); +void objectFindChild(QObject_ *object, QString_ *name, DataValue *result); +QQmlContext_ *objectContext(QObject_ *object); +int objectIsComponent(QObject_ *object); +int objectIsWindow(QObject_ *object); +int objectIsView(QObject_ *object); +error *objectConnect(QObject_ *object, const char *signal, int signalLen, QQmlEngine_ *engine, GoRef func, int argsLen); +error *objectGoRef(QObject_ *object, GoRef *ref); + +QQmlComponent_ *newComponent(QQmlEngine_ *engine, QObject_ *parent); +void componentLoadURL(QQmlComponent_ *component, const char *url, int urlLen); +void componentSetData(QQmlComponent_ *component, const char *data, int dataLen, const char *url, int urlLen); +char *componentErrorString(QQmlComponent_ *component); +QObject_ *componentCreate(QQmlComponent_ *component, QQmlContext_ *context); +QQuickWindow_ *componentCreateWindow(QQmlComponent_ *component, QQmlContext_ *context); + +void windowShow(QQuickWindow_ *win); +void windowHide(QQuickWindow_ *win); +uintptr_t windowPlatformId(QQuickWindow_ *win); +void windowConnectHidden(QQuickWindow_ *win); +QObject_ *windowRootObject(QQuickWindow_ *win); +QImage_ *windowGrabWindow(QQuickWindow_ *win); + +QImage_ *newImage(int width, int height); +void delImage(QImage_ *image); +void imageSize(QImage_ *image, int *width, int *height); +unsigned char *imageBits(QImage_ *image); +const unsigned char *imageConstBits(QImage_ *image); + +QString_ *newString(const char *data, int len); +void delString(QString_ *s); + +GoValue_ *newGoValue(GoRef ref, GoTypeInfo *typeInfo, QObject_ *parent); +void goValueActivate(GoValue_ *value, GoTypeInfo *typeInfo, int addrOffset); + +void packDataValue(QVariant_ *var, DataValue *result); +void unpackDataValue(DataValue *value, QVariant_ *result); + +QVariantList_ *newVariantList(DataValue *list, int len); + +QQmlListProperty_ *newListProperty(GoRef ref, intptr_t reflectIndex, intptr_t setIndex); + +int registerType(char *location, int major, int minor, char *name, GoTypeInfo *typeInfo, GoTypeSpec_ spec); +int registerSingleton(char *location, int major, int minor, char *name, GoTypeInfo *typeInfo, GoTypeSpec_ spec); + +void installLogHandler(); + +void hookIdleTimer(); +void hookLogHandler(LogMessage *message); +void hookGoValueReadField(QQmlEngine_ *engine, GoRef ref, int memberIndex, int getIndex, int setIndex, DataValue *result); +void hookGoValueWriteField(QQmlEngine_ *engine, GoRef ref, int memberIndex, int setIndex, DataValue *assign); +void hookGoValueCallMethod(QQmlEngine_ *engine, GoRef ref, int memberIndex, DataValue *result); +void hookGoValueDestroyed(QQmlEngine_ *engine, GoRef ref); +void hookGoValuePaint(QQmlEngine_ *engine, GoRef ref, intptr_t reflextIndex); +QImage_ *hookRequestImage(void *imageFunc, char *id, int idLen, int width, int height); +GoRef hookGoValueTypeNew(GoValue_ *value, GoTypeSpec_ spec); +void hookWindowHidden(QObject_ *addr); +void hookSignalCall(QQmlEngine_ *engine, GoRef func, DataValue *params); +void hookSignalDisconnect(GoRef func); +void hookPanic(char *message); +int hookListPropertyCount(GoRef ref, intptr_t reflectIndex, intptr_t setIndex); +QObject_ *hookListPropertyAt(GoRef ref, intptr_t reflectIndex, intptr_t setIndex, int i); +void hookListPropertyAppend(GoRef ref, intptr_t reflectIndex, intptr_t setIndex, QObject_ *obj); +void hookListPropertyClear(GoRef ref, intptr_t reflectIndex, intptr_t setIndex); + +void registerResourceData(int version, char *tree, char *name, char *data); +void unregisterResourceData(int version, char *tree, char *name, char *data); + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // CAPI_H + +// vim:ts=4:et diff --git a/cpp/connector.cpp b/cpp/connector.cpp new file mode 100644 index 00000000..6005bfc6 --- /dev/null +++ b/cpp/connector.cpp @@ -0,0 +1,46 @@ +#include + +#include "connector.h" +#include "capi.h" + +Connector::~Connector() +{ + hookSignalDisconnect(func); +} + +void Connector::invoke() +{ + panicf("should never get called"); +} + +int Connector::qt_metacall(QMetaObject::Call c, int idx, void **a) +{ + if (c == QMetaObject::InvokeMetaMethod && idx == metaObject()->methodOffset()) { + DataValue args[MaxParams]; + QObject *plain = NULL; + for (int i = 0; i < argsLen; i++) { + int paramType = method.parameterType(i); + if (paramType == 0 && a[1 + i] != NULL) { + const char *typeName = method.parameterTypes()[i].constData(); + void *addr = a[1 + i]; + if (typeName[strlen(typeName)-1] == '*') { + addr = *(void **)addr; + } + plain = new PlainObject(typeName, addr, plain); + QVariant var = QVariant::fromValue((QObject *)plain); + packDataValue(&var, &args[i]); + } else { + QVariant var(method.parameterType(i), a[1 + i]); + packDataValue(&var, &args[i]); + } + } + hookSignalCall(engine, func, args); + if (plain != NULL) { + delete plain; + } + return -1; + } + return standard_qt_metacall(c, idx, a); +} + +// vim:ts=4:sw=4:et diff --git a/cpp/connector.h b/cpp/connector.h new file mode 100644 index 00000000..d68f3645 --- /dev/null +++ b/cpp/connector.h @@ -0,0 +1,58 @@ +#ifndef CONNECTOR_H +#define CONNECTOR_H + +#include + +#include + +class Connector : public QObject +{ + Q_OBJECT + + public: + + Connector(QObject *sender, QMetaMethod method, QQmlEngine *engine, GoRef func, int argsLen) + : QObject(sender), engine(engine), method(method), func(func), argsLen(argsLen) {}; + + virtual ~Connector(); + + // MOC HACK: s/Connector::qt_metacall/Connector::standard_qt_metacall/ + int standard_qt_metacall(QMetaObject::Call c, int idx, void **a); + + public slots: + + void invoke(); + + private: + + QQmlEngine *engine; + QMetaMethod method; + GoRef func; + int argsLen; +}; + +class PlainObject : public QObject +{ + Q_OBJECT + + Q_PROPERTY(QString plainType READ getPlainType) + Q_PROPERTY(void *plainAddr READ getPlainAddr) + + QString plainType; + void *plainAddr; + + public: + + PlainObject(QObject *parent = 0) + : QObject(parent) {}; + + PlainObject(const char *plainType, void *plainAddr, QObject *parent = 0) + : QObject(parent), plainType(plainType), plainAddr(plainAddr) {}; + + QString getPlainType() { return plainType; }; + void *getPlainAddr() { return plainAddr; }; +}; + +#endif // CONNECTOR_H + +// vim:ts=4:sw=4:et diff --git a/cpp/govalue.cpp b/cpp/govalue.cpp new file mode 100644 index 00000000..1f7237c4 --- /dev/null +++ b/cpp/govalue.cpp @@ -0,0 +1,236 @@ +#include + +#include +#include + +#include +#include +#include + +#include "govalue.h" +#include "capi.h" + +class GoValueMetaObject : public QAbstractDynamicMetaObject +{ +public: + GoValueMetaObject(QObject* value, GoRef ref, GoTypeInfo *typeInfo); + + void activatePropIndex(int propIndex); + +protected: + int metaCall(QMetaObject::Call c, int id, void **a); + +private: + QObject *value; + GoRef ref; + GoTypeInfo *typeInfo; +}; + +GoValueMetaObject::GoValueMetaObject(QObject *value, GoRef ref, GoTypeInfo *typeInfo) + : value(value), ref(ref), typeInfo(typeInfo) +{ + //d->parent = static_cast(priv->metaObject); + *static_cast(this) = *metaObjectFor(typeInfo); + + QObjectPrivate *objPriv = QObjectPrivate::get(value); + objPriv->metaObject = this; +} + +int GoValueMetaObject::metaCall(QMetaObject::Call c, int idx, void **a) +{ + //qWarning() << "GoValueMetaObject::metaCall" << c << idx; + switch (c) { + case QMetaObject::ReadProperty: + case QMetaObject::WriteProperty: + { + // TODO Cache propertyOffset, methodOffset (and maybe qmlEngine) + int propOffset = propertyOffset(); + if (idx < propOffset) { + return value->qt_metacall(c, idx, a); + } + GoMemberInfo *memberInfo = typeInfo->fields; + for (int i = 0; i < typeInfo->fieldsLen; i++) { + if (memberInfo->metaIndex == idx) { + if (c == QMetaObject::ReadProperty) { + DataValue result; + hookGoValueReadField(qmlEngine(value), ref, memberInfo->reflectIndex, memberInfo->reflectGetIndex, memberInfo->reflectSetIndex, &result); + if (memberInfo->memberType == DTListProperty) { + if (result.dataType != DTListProperty) { + panicf("reading DTListProperty field returned non-DTListProperty result"); + } + QQmlListProperty *in = *reinterpret_cast **>(result.data); + QQmlListProperty *out = reinterpret_cast *>(a[0]); + *out = *in; + // TODO Could provide a single variable in the stack to ReadField instead. + delete in; + } else { + QVariant *out = reinterpret_cast(a[0]); + unpackDataValue(&result, out); + } + } else { + DataValue assign; + QVariant *in = reinterpret_cast(a[0]); + packDataValue(in, &assign); + hookGoValueWriteField(qmlEngine(value), ref, memberInfo->reflectIndex, memberInfo->reflectSetIndex, &assign); + activate(value, methodOffset() + (idx - propOffset), 0); + } + return -1; + } + memberInfo++; + } + QMetaProperty prop = property(idx); + qWarning() << "Property" << prop.name() << "not found!?"; + break; + } + case QMetaObject::InvokeMetaMethod: + { + if (idx < methodOffset()) { + return value->qt_metacall(c, idx, a); + } + GoMemberInfo *memberInfo = typeInfo->methods; + for (int i = 0; i < typeInfo->methodsLen; i++) { + if (memberInfo->metaIndex == idx) { + // args[0] is the result if any. + DataValue args[1 + MaxParams]; + for (int i = 1; i < memberInfo->numIn+1; i++) { + packDataValue(reinterpret_cast(a[i]), &args[i]); + } + hookGoValueCallMethod(qmlEngine(value), ref, memberInfo->reflectIndex, args); + if (memberInfo->numOut > 0) { + unpackDataValue(&args[0], reinterpret_cast(a[0])); + } + return -1; + } + memberInfo++; + } + QMetaMethod m = method(idx); + qWarning() << "Method" << m.name() << "not found!?"; + break; + } + default: + break; // Unhandled. + } + return -1; +} + +void GoValueMetaObject::activatePropIndex(int propIndex) +{ + // Properties are added first, so the first fieldLen methods are in + // fact the signals of the respective properties. + int relativeIndex = propIndex - propertyOffset(); + activate(value, methodOffset() + relativeIndex, 0); +} + +GoValue::GoValue(GoRef ref, GoTypeInfo *typeInfo, QObject *parent) + : ref(ref), typeInfo(typeInfo) +{ + valueMeta = new GoValueMetaObject(this, ref, typeInfo); + setParent(parent); +} + +GoValue::~GoValue() +{ + hookGoValueDestroyed(qmlEngine(this), ref); +} + +void GoValue::activate(int propIndex) +{ + valueMeta->activatePropIndex(propIndex); +} + +GoPaintedValue::GoPaintedValue(GoRef ref, GoTypeInfo *typeInfo, QObject *parent) + : ref(ref), typeInfo(typeInfo) +{ + valueMeta = new GoValueMetaObject(this, ref, typeInfo); + setParent(parent); + + QQuickItem::setFlag(QQuickItem::ItemHasContents, true); + QQuickPaintedItem::setRenderTarget(QQuickPaintedItem::FramebufferObject); +} + +GoPaintedValue::~GoPaintedValue() +{ + hookGoValueDestroyed(qmlEngine(this), ref); +} + +void GoPaintedValue::activate(int propIndex) +{ + valueMeta->activatePropIndex(propIndex); +} + +void GoPaintedValue::paint(QPainter *painter) +{ + painter->beginNativePainting(); + hookGoValuePaint(qmlEngine(this), ref, typeInfo->paint->reflectIndex); + painter->endNativePainting(); +} + +QMetaObject *metaObjectFor(GoTypeInfo *typeInfo) +{ + if (typeInfo->metaObject) { + return reinterpret_cast(typeInfo->metaObject); + } + + QMetaObjectBuilder mob; + if (typeInfo->paint) { + mob.setSuperClass(&QQuickPaintedItem::staticMetaObject); + } else { + mob.setSuperClass(&QObject::staticMetaObject); + } + mob.setClassName(typeInfo->typeName); + mob.setFlags(QMetaObjectBuilder::DynamicMetaObject); + + GoMemberInfo *memberInfo; + + memberInfo = typeInfo->fields; + int relativePropIndex = mob.propertyCount(); + for (int i = 0; i < typeInfo->fieldsLen; i++) { + mob.addSignal("__" + QByteArray::number(relativePropIndex) + "()"); + const char *typeName = "QVariant"; + if (memberInfo->memberType == DTListProperty) { + typeName = "QQmlListProperty"; + } + QMetaPropertyBuilder propb = mob.addProperty(memberInfo->memberName, typeName, relativePropIndex); + propb.setWritable(true); + memberInfo->metaIndex = relativePropIndex; + memberInfo++; + relativePropIndex++; + } + + memberInfo = typeInfo->methods; + int relativeMethodIndex = mob.methodCount(); + for (int i = 0; i < typeInfo->methodsLen; i++) { + if (*memberInfo->resultSignature) { + mob.addMethod(memberInfo->methodSignature, memberInfo->resultSignature); + } else { + mob.addMethod(memberInfo->methodSignature); + } + memberInfo->metaIndex = relativeMethodIndex; + memberInfo++; + relativeMethodIndex++; + } + + // TODO Support default properties. + //mob.addClassInfo("DefaultProperty", "objects"); + + QMetaObject *mo = mob.toMetaObject(); + + // Turn the relative indexes into absolute indexes. + memberInfo = typeInfo->fields; + int propOffset = mo->propertyOffset(); + for (int i = 0; i < typeInfo->fieldsLen; i++) { + memberInfo->metaIndex += propOffset; + memberInfo++; + } + memberInfo = typeInfo->methods; + int methodOffset = mo->methodOffset(); + for (int i = 0; i < typeInfo->methodsLen; i++) { + memberInfo->metaIndex += methodOffset; + memberInfo++; + } + + typeInfo->metaObject = mo; + return mo; +} + +// vim:ts=4:sw=4:et:ft=cpp diff --git a/cpp/govalue.h b/cpp/govalue.h new file mode 100644 index 00000000..0d1cb0a8 --- /dev/null +++ b/cpp/govalue.h @@ -0,0 +1,56 @@ +#ifndef GOVALUE_H +#define GOVALUE_H + +// Unfortunatley we need access to private bits, because the +// whole dynamic meta-object concept is sadly being hidden +// away, and without it this package wouldn't exist. +#include + +#include +#include + +#include "capi.h" + +class GoValueMetaObject; + +QMetaObject *metaObjectFor(GoTypeInfo *typeInfo); + +class GoValue : public QObject +{ + Q_OBJECT + +public: + GoRef ref; + GoTypeInfo *typeInfo; + + GoValue(GoRef ref, GoTypeInfo *typeInfo, QObject *parent); + virtual ~GoValue(); + + void activate(int propIndex); + +private: + GoValueMetaObject *valueMeta; +}; + +class GoPaintedValue : public QQuickPaintedItem +{ + Q_OBJECT + +public: + GoRef ref; + GoTypeInfo *typeInfo; + + GoPaintedValue(GoRef ref, GoTypeInfo *typeInfo, QObject *parent); + virtual ~GoPaintedValue(); + + void activate(int propIndex); + + virtual void paint(QPainter *painter); + +private: + GoValueMetaObject *valueMeta; +}; + +#endif // GOVALUE_H + +// vim:ts=4:sw=4:et:ft=cpp diff --git a/cpp/govaluetype.cpp b/cpp/govaluetype.cpp new file mode 100644 index 00000000..d9416578 --- /dev/null +++ b/cpp/govaluetype.cpp @@ -0,0 +1,254 @@ +#include "govaluetype.h" + +#define DEFINE_GOVALUETYPE(N) \ + template<> QMetaObject GoValueType::staticMetaObject = QMetaObject(); \ + template<> GoTypeInfo *GoValueType::typeInfo = 0; \ + template<> GoTypeSpec_ GoValueType::typeSpec = 0; + +#define DEFINE_GOPAINTEDVALUETYPE(N) \ + template<> QMetaObject GoPaintedValueType::staticMetaObject = QMetaObject(); \ + template<> GoTypeInfo *GoPaintedValueType::typeInfo = 0; \ + template<> GoTypeSpec_ GoPaintedValueType::typeSpec = 0; + +DEFINE_GOVALUETYPE(1) +DEFINE_GOVALUETYPE(2) +DEFINE_GOVALUETYPE(3) +DEFINE_GOVALUETYPE(4) +DEFINE_GOVALUETYPE(5) +DEFINE_GOVALUETYPE(6) +DEFINE_GOVALUETYPE(7) +DEFINE_GOVALUETYPE(8) +DEFINE_GOVALUETYPE(9) +DEFINE_GOVALUETYPE(10) +DEFINE_GOVALUETYPE(11) +DEFINE_GOVALUETYPE(12) +DEFINE_GOVALUETYPE(13) +DEFINE_GOVALUETYPE(14) +DEFINE_GOVALUETYPE(15) +DEFINE_GOVALUETYPE(16) +DEFINE_GOVALUETYPE(17) +DEFINE_GOVALUETYPE(18) +DEFINE_GOVALUETYPE(19) +DEFINE_GOVALUETYPE(20) +DEFINE_GOVALUETYPE(21) +DEFINE_GOVALUETYPE(22) +DEFINE_GOVALUETYPE(23) +DEFINE_GOVALUETYPE(24) +DEFINE_GOVALUETYPE(25) +DEFINE_GOVALUETYPE(26) +DEFINE_GOVALUETYPE(27) +DEFINE_GOVALUETYPE(28) +DEFINE_GOVALUETYPE(29) +DEFINE_GOVALUETYPE(30) + +DEFINE_GOPAINTEDVALUETYPE(1) +DEFINE_GOPAINTEDVALUETYPE(2) +DEFINE_GOPAINTEDVALUETYPE(3) +DEFINE_GOPAINTEDVALUETYPE(4) +DEFINE_GOPAINTEDVALUETYPE(5) +DEFINE_GOPAINTEDVALUETYPE(6) +DEFINE_GOPAINTEDVALUETYPE(7) +DEFINE_GOPAINTEDVALUETYPE(8) +DEFINE_GOPAINTEDVALUETYPE(9) +DEFINE_GOPAINTEDVALUETYPE(10) +DEFINE_GOPAINTEDVALUETYPE(11) +DEFINE_GOPAINTEDVALUETYPE(12) +DEFINE_GOPAINTEDVALUETYPE(13) +DEFINE_GOPAINTEDVALUETYPE(14) +DEFINE_GOPAINTEDVALUETYPE(15) +DEFINE_GOPAINTEDVALUETYPE(16) +DEFINE_GOPAINTEDVALUETYPE(17) +DEFINE_GOPAINTEDVALUETYPE(18) +DEFINE_GOPAINTEDVALUETYPE(19) +DEFINE_GOPAINTEDVALUETYPE(20) +DEFINE_GOPAINTEDVALUETYPE(21) +DEFINE_GOPAINTEDVALUETYPE(22) +DEFINE_GOPAINTEDVALUETYPE(23) +DEFINE_GOPAINTEDVALUETYPE(24) +DEFINE_GOPAINTEDVALUETYPE(25) +DEFINE_GOPAINTEDVALUETYPE(26) +DEFINE_GOPAINTEDVALUETYPE(27) +DEFINE_GOPAINTEDVALUETYPE(28) +DEFINE_GOPAINTEDVALUETYPE(29) +DEFINE_GOPAINTEDVALUETYPE(30) + +static int goValueTypeN = 0; +static int goPaintedValueTypeN = 0; + +template +int registerSingletonN(char *location, int major, int minor, char *name, GoTypeInfo *info, GoTypeSpec_ spec) { + GoValueType::init(info, spec); + return qmlRegisterSingletonType< GoValueType >(location, major, minor, name, [](QQmlEngine *qmlEngine, QJSEngine *jsEngine) -> QObject* { + QObject *singleton = new GoValueType(); + QQmlEngine::setContextForObject(singleton, qmlEngine->rootContext()); + return singleton; + }); +} + +template +int registerPaintedSingletonN(char *location, int major, int minor, char *name, GoTypeInfo *info, GoTypeSpec_ spec) { + GoPaintedValueType::init(info, spec); + return qmlRegisterSingletonType< GoPaintedValueType >(location, major, minor, name, [](QQmlEngine *qmlEngine, QJSEngine *jsEngine) -> QObject* { + QObject *singleton = new GoPaintedValueType(); + QQmlEngine::setContextForObject(singleton, qmlEngine->rootContext()); + return singleton; + }); +} + +#define GOVALUETYPE_CASE_SINGLETON(N) \ + case N: return registerSingletonN(location, major, minor, name, info, spec); +#define GOPAINTEDVALUETYPE_CASE_SINGLETON(N) \ + case N: return registerPaintedSingletonN(location, major, minor, name, info, spec); + +int registerSingleton(char *location, int major, int minor, char *name, GoTypeInfo *info, GoTypeSpec_ spec) +{ + if (!info->paint) { + switch (++goValueTypeN) { + GOVALUETYPE_CASE_SINGLETON(1) + GOVALUETYPE_CASE_SINGLETON(2) + GOVALUETYPE_CASE_SINGLETON(3) + GOVALUETYPE_CASE_SINGLETON(4) + GOVALUETYPE_CASE_SINGLETON(5) + GOVALUETYPE_CASE_SINGLETON(6) + GOVALUETYPE_CASE_SINGLETON(7) + GOVALUETYPE_CASE_SINGLETON(8) + GOVALUETYPE_CASE_SINGLETON(9) + GOVALUETYPE_CASE_SINGLETON(10) + GOVALUETYPE_CASE_SINGLETON(11) + GOVALUETYPE_CASE_SINGLETON(12) + GOVALUETYPE_CASE_SINGLETON(13) + GOVALUETYPE_CASE_SINGLETON(14) + GOVALUETYPE_CASE_SINGLETON(15) + GOVALUETYPE_CASE_SINGLETON(16) + GOVALUETYPE_CASE_SINGLETON(17) + GOVALUETYPE_CASE_SINGLETON(18) + GOVALUETYPE_CASE_SINGLETON(19) + GOVALUETYPE_CASE_SINGLETON(20) + GOVALUETYPE_CASE_SINGLETON(21) + GOVALUETYPE_CASE_SINGLETON(22) + GOVALUETYPE_CASE_SINGLETON(23) + GOVALUETYPE_CASE_SINGLETON(24) + GOVALUETYPE_CASE_SINGLETON(25) + GOVALUETYPE_CASE_SINGLETON(26) + GOVALUETYPE_CASE_SINGLETON(27) + GOVALUETYPE_CASE_SINGLETON(28) + GOVALUETYPE_CASE_SINGLETON(29) + GOVALUETYPE_CASE_SINGLETON(30) + } + } else { + switch (++goPaintedValueTypeN) { + GOPAINTEDVALUETYPE_CASE_SINGLETON(1) + GOPAINTEDVALUETYPE_CASE_SINGLETON(2) + GOPAINTEDVALUETYPE_CASE_SINGLETON(3) + GOPAINTEDVALUETYPE_CASE_SINGLETON(4) + GOPAINTEDVALUETYPE_CASE_SINGLETON(5) + GOPAINTEDVALUETYPE_CASE_SINGLETON(6) + GOPAINTEDVALUETYPE_CASE_SINGLETON(7) + GOPAINTEDVALUETYPE_CASE_SINGLETON(8) + GOPAINTEDVALUETYPE_CASE_SINGLETON(9) + GOPAINTEDVALUETYPE_CASE_SINGLETON(10) + GOPAINTEDVALUETYPE_CASE_SINGLETON(11) + GOPAINTEDVALUETYPE_CASE_SINGLETON(12) + GOPAINTEDVALUETYPE_CASE_SINGLETON(13) + GOPAINTEDVALUETYPE_CASE_SINGLETON(14) + GOPAINTEDVALUETYPE_CASE_SINGLETON(15) + GOPAINTEDVALUETYPE_CASE_SINGLETON(16) + GOPAINTEDVALUETYPE_CASE_SINGLETON(17) + GOPAINTEDVALUETYPE_CASE_SINGLETON(18) + GOPAINTEDVALUETYPE_CASE_SINGLETON(19) + GOPAINTEDVALUETYPE_CASE_SINGLETON(20) + GOPAINTEDVALUETYPE_CASE_SINGLETON(21) + GOPAINTEDVALUETYPE_CASE_SINGLETON(22) + GOPAINTEDVALUETYPE_CASE_SINGLETON(23) + GOPAINTEDVALUETYPE_CASE_SINGLETON(24) + GOPAINTEDVALUETYPE_CASE_SINGLETON(25) + GOPAINTEDVALUETYPE_CASE_SINGLETON(26) + GOPAINTEDVALUETYPE_CASE_SINGLETON(27) + GOPAINTEDVALUETYPE_CASE_SINGLETON(28) + GOPAINTEDVALUETYPE_CASE_SINGLETON(29) + GOPAINTEDVALUETYPE_CASE_SINGLETON(30) + } + } + panicf("too many registered types; please contact the Go QML developers"); + return 0; +} + +#define GOVALUETYPE_CASE(N) \ + case N: GoValueType::init(info, spec); return qmlRegisterType< GoValueType >(location, major, minor, name); +#define GOPAINTEDVALUETYPE_CASE(N) \ + case N: GoPaintedValueType::init(info, spec); return qmlRegisterType< GoPaintedValueType >(location, major, minor, name); + +int registerType(char *location, int major, int minor, char *name, GoTypeInfo *info, GoTypeSpec_ spec) +{ + if (!info->paint) { + switch (++goValueTypeN) { + GOVALUETYPE_CASE(1) + GOVALUETYPE_CASE(2) + GOVALUETYPE_CASE(3) + GOVALUETYPE_CASE(4) + GOVALUETYPE_CASE(5) + GOVALUETYPE_CASE(6) + GOVALUETYPE_CASE(7) + GOVALUETYPE_CASE(8) + GOVALUETYPE_CASE(9) + GOVALUETYPE_CASE(10) + GOVALUETYPE_CASE(11) + GOVALUETYPE_CASE(12) + GOVALUETYPE_CASE(13) + GOVALUETYPE_CASE(14) + GOVALUETYPE_CASE(15) + GOVALUETYPE_CASE(16) + GOVALUETYPE_CASE(17) + GOVALUETYPE_CASE(18) + GOVALUETYPE_CASE(19) + GOVALUETYPE_CASE(20) + GOVALUETYPE_CASE(21) + GOVALUETYPE_CASE(22) + GOVALUETYPE_CASE(23) + GOVALUETYPE_CASE(24) + GOVALUETYPE_CASE(25) + GOVALUETYPE_CASE(26) + GOVALUETYPE_CASE(27) + GOVALUETYPE_CASE(28) + GOVALUETYPE_CASE(29) + GOVALUETYPE_CASE(30) + } + } else { + switch (++goPaintedValueTypeN) { + GOPAINTEDVALUETYPE_CASE(1) + GOPAINTEDVALUETYPE_CASE(2) + GOPAINTEDVALUETYPE_CASE(3) + GOPAINTEDVALUETYPE_CASE(4) + GOPAINTEDVALUETYPE_CASE(5) + GOPAINTEDVALUETYPE_CASE(6) + GOPAINTEDVALUETYPE_CASE(7) + GOPAINTEDVALUETYPE_CASE(8) + GOPAINTEDVALUETYPE_CASE(9) + GOPAINTEDVALUETYPE_CASE(10) + GOPAINTEDVALUETYPE_CASE(11) + GOPAINTEDVALUETYPE_CASE(12) + GOPAINTEDVALUETYPE_CASE(13) + GOPAINTEDVALUETYPE_CASE(14) + GOPAINTEDVALUETYPE_CASE(15) + GOPAINTEDVALUETYPE_CASE(16) + GOPAINTEDVALUETYPE_CASE(17) + GOPAINTEDVALUETYPE_CASE(18) + GOPAINTEDVALUETYPE_CASE(19) + GOPAINTEDVALUETYPE_CASE(20) + GOPAINTEDVALUETYPE_CASE(21) + GOPAINTEDVALUETYPE_CASE(22) + GOPAINTEDVALUETYPE_CASE(23) + GOPAINTEDVALUETYPE_CASE(24) + GOPAINTEDVALUETYPE_CASE(25) + GOPAINTEDVALUETYPE_CASE(26) + GOPAINTEDVALUETYPE_CASE(27) + GOPAINTEDVALUETYPE_CASE(28) + GOPAINTEDVALUETYPE_CASE(29) + GOPAINTEDVALUETYPE_CASE(30) + } + } + panicf("too many registered types; please contact the Go QML developers"); + return 0; +} + +// vim:sw=4:st=4:et:ft=cpp diff --git a/cpp/govaluetype.h b/cpp/govaluetype.h new file mode 100644 index 00000000..978bfb7b --- /dev/null +++ b/cpp/govaluetype.h @@ -0,0 +1,48 @@ +#ifndef GOVALUETYPE_H +#define GOVALUETYPE_H + +#include "govalue.h" + +template +class GoValueType : public GoValue +{ +public: + + GoValueType() + : GoValue(hookGoValueTypeNew(this, typeSpec), typeInfo, 0) {}; + + static void init(GoTypeInfo *info, GoTypeSpec_ spec) + { + typeInfo = info; + typeSpec = spec; + static_cast(staticMetaObject) = *metaObjectFor(typeInfo); + }; + + static GoTypeSpec_ typeSpec; + static GoTypeInfo *typeInfo; + static QMetaObject staticMetaObject; +}; + +template +class GoPaintedValueType : public GoPaintedValue +{ +public: + + GoPaintedValueType() + : GoPaintedValue(hookGoValueTypeNew(this, typeSpec), typeInfo, 0) {}; + + static void init(GoTypeInfo *info, GoTypeSpec_ spec) + { + typeInfo = info; + typeSpec = spec; + static_cast(staticMetaObject) = *metaObjectFor(typeInfo); + }; + + static GoTypeSpec_ typeSpec; + static GoTypeInfo *typeInfo; + static QMetaObject staticMetaObject; +}; + +#endif // GOVALUETYPE_H + +// vim:ts=4:sw=4:et diff --git a/cpp/idletimer.cpp b/cpp/idletimer.cpp new file mode 100644 index 00000000..3bd09750 --- /dev/null +++ b/cpp/idletimer.cpp @@ -0,0 +1,58 @@ +#include +#include +#include +#include + +#include "capi.h" + +class IdleTimer : public QObject +{ + Q_OBJECT + + public: + + static IdleTimer *singleton() { + static IdleTimer singleton; + return &singleton; + } + + void init(int32_t *guiIdleRun) + { + this->guiIdleRun = guiIdleRun; + } + + Q_INVOKABLE void start() + { + timer.start(0, this); + } + + protected: + + void timerEvent(QTimerEvent *event) + { + __sync_synchronize(); + if (*guiIdleRun > 0) { + hookIdleTimer(); + } else { + timer.stop(); + } + } + + private: + + int32_t *guiIdleRun; + + QBasicTimer timer; +}; + +void idleTimerInit(int32_t *guiIdleRun) +{ + IdleTimer::singleton()->init(guiIdleRun); +} + +void idleTimerStart() +{ + QMetaObject::invokeMethod(IdleTimer::singleton(), "start", Qt::QueuedConnection); +} + +// vim:ts=4:sw=4:et:ft=cpp diff --git a/cpp/mmemwin.cpp b/cpp/mmemwin.cpp new file mode 100644 index 00000000..7aa3bff2 --- /dev/null +++ b/cpp/mmemwin.cpp @@ -0,0 +1,27 @@ +#include + +#define protREAD 1 +#define protWRITE 2 +#define protEXEC 4 + +extern "C" { + +int mprotect(void *addr, size_t len, int prot) +{ + DWORD wprot = 0; + if (prot & protWRITE) { + wprot = PAGE_READWRITE; + } else if (prot & protREAD) { + wprot = PAGE_READONLY; + } + if (prot & protEXEC) { + wprot <<= 4; + } + DWORD oldwprot; + if (!VirtualProtect(addr, len, wprot, &oldwprot)) { + return -1; + } + return 0; +} + +} // extern "C" diff --git a/cpp/moc_all.cpp b/cpp/moc_all.cpp new file mode 100644 index 00000000..cff09705 --- /dev/null +++ b/cpp/moc_all.cpp @@ -0,0 +1,4 @@ +// This file is automatically generated by cpp/update-moc.sh +#include "cpp/moc_connector.cpp" +#include "cpp/moc_govalue.cpp" +#include "cpp/moc_idletimer.cpp" diff --git a/cpp/moc_connector.cpp b/cpp/moc_connector.cpp new file mode 100644 index 00000000..2de2d827 --- /dev/null +++ b/cpp/moc_connector.cpp @@ -0,0 +1,211 @@ +/**************************************************************************** +** Meta object code from reading C++ file 'connector.h' +** +** Created by: The Qt Meta Object Compiler version 67 (Qt 5.2.1) +** +** WARNING! All changes made in this file will be lost! +*****************************************************************************/ + +#include "connector.h" +#include +#include +#if !defined(Q_MOC_OUTPUT_REVISION) +#error "The header file 'connector.h' doesn't include ." +#elif Q_MOC_OUTPUT_REVISION != 67 +#error "This file was generated using the moc from 5.2.1. It" +#error "cannot be used with the include files from this version of Qt." +#error "(The moc has changed too much.)" +#endif + +QT_BEGIN_MOC_NAMESPACE +struct qt_meta_stringdata_Connector_t { + QByteArrayData data[3]; + char stringdata[19]; +}; +#define QT_MOC_LITERAL(idx, ofs, len) \ + Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \ + offsetof(qt_meta_stringdata_Connector_t, stringdata) + ofs \ + - idx * sizeof(QByteArrayData) \ + ) +static const qt_meta_stringdata_Connector_t qt_meta_stringdata_Connector = { + { +QT_MOC_LITERAL(0, 0, 9), +QT_MOC_LITERAL(1, 10, 6), +QT_MOC_LITERAL(2, 17, 0) + }, + "Connector\0invoke\0\0" +}; +#undef QT_MOC_LITERAL + +static const uint qt_meta_data_Connector[] = { + + // content: + 7, // revision + 0, // classname + 0, 0, // classinfo + 1, 14, // methods + 0, 0, // properties + 0, 0, // enums/sets + 0, 0, // constructors + 0, // flags + 0, // signalCount + + // slots: name, argc, parameters, tag, flags + 1, 0, 19, 2, 0x0a, + + // slots: parameters + QMetaType::Void, + + 0 // eod +}; + +void Connector::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a) +{ + if (_c == QMetaObject::InvokeMetaMethod) { + Connector *_t = static_cast(_o); + switch (_id) { + case 0: _t->invoke(); break; + default: ; + } + } + Q_UNUSED(_a); +} + +const QMetaObject Connector::staticMetaObject = { + { &QObject::staticMetaObject, qt_meta_stringdata_Connector.data, + qt_meta_data_Connector, qt_static_metacall, 0, 0} +}; + + +const QMetaObject *Connector::metaObject() const +{ + return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject; +} + +void *Connector::qt_metacast(const char *_clname) +{ + if (!_clname) return 0; + if (!strcmp(_clname, qt_meta_stringdata_Connector.stringdata)) + return static_cast(const_cast< Connector*>(this)); + return QObject::qt_metacast(_clname); +} + +int Connector::standard_qt_metacall(QMetaObject::Call _c, int _id, void **_a) +{ + _id = QObject::qt_metacall(_c, _id, _a); + if (_id < 0) + return _id; + if (_c == QMetaObject::InvokeMetaMethod) { + if (_id < 1) + qt_static_metacall(this, _c, _id, _a); + _id -= 1; + } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) { + if (_id < 1) + *reinterpret_cast(_a[0]) = -1; + _id -= 1; + } + return _id; +} +struct qt_meta_stringdata_PlainObject_t { + QByteArrayData data[3]; + char stringdata[33]; +}; +#define QT_MOC_LITERAL(idx, ofs, len) \ + Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \ + offsetof(qt_meta_stringdata_PlainObject_t, stringdata) + ofs \ + - idx * sizeof(QByteArrayData) \ + ) +static const qt_meta_stringdata_PlainObject_t qt_meta_stringdata_PlainObject = { + { +QT_MOC_LITERAL(0, 0, 11), +QT_MOC_LITERAL(1, 12, 9), +QT_MOC_LITERAL(2, 22, 9) + }, + "PlainObject\0plainType\0plainAddr\0" +}; +#undef QT_MOC_LITERAL + +static const uint qt_meta_data_PlainObject[] = { + + // content: + 7, // revision + 0, // classname + 0, 0, // classinfo + 0, 0, // methods + 2, 14, // properties + 0, 0, // enums/sets + 0, 0, // constructors + 0, // flags + 0, // signalCount + + // properties: name, type, flags + 1, QMetaType::QString, 0x00095001, + 2, QMetaType::VoidStar, 0x00095001, + + 0 // eod +}; + +void PlainObject::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a) +{ + Q_UNUSED(_o); + Q_UNUSED(_id); + Q_UNUSED(_c); + Q_UNUSED(_a); +} + +const QMetaObject PlainObject::staticMetaObject = { + { &QObject::staticMetaObject, qt_meta_stringdata_PlainObject.data, + qt_meta_data_PlainObject, qt_static_metacall, 0, 0} +}; + + +const QMetaObject *PlainObject::metaObject() const +{ + return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject; +} + +void *PlainObject::qt_metacast(const char *_clname) +{ + if (!_clname) return 0; + if (!strcmp(_clname, qt_meta_stringdata_PlainObject.stringdata)) + return static_cast(const_cast< PlainObject*>(this)); + return QObject::qt_metacast(_clname); +} + +int PlainObject::qt_metacall(QMetaObject::Call _c, int _id, void **_a) +{ + _id = QObject::qt_metacall(_c, _id, _a); + if (_id < 0) + return _id; + +#ifndef QT_NO_PROPERTIES + if (_c == QMetaObject::ReadProperty) { + void *_v = _a[0]; + switch (_id) { + case 0: *reinterpret_cast< QString*>(_v) = getPlainType(); break; + case 1: *reinterpret_cast< void**>(_v) = getPlainAddr(); break; + } + _id -= 2; + } else if (_c == QMetaObject::WriteProperty) { + _id -= 2; + } else if (_c == QMetaObject::ResetProperty) { + _id -= 2; + } else if (_c == QMetaObject::QueryPropertyDesignable) { + _id -= 2; + } else if (_c == QMetaObject::QueryPropertyScriptable) { + _id -= 2; + } else if (_c == QMetaObject::QueryPropertyStored) { + _id -= 2; + } else if (_c == QMetaObject::QueryPropertyEditable) { + _id -= 2; + } else if (_c == QMetaObject::QueryPropertyUser) { + _id -= 2; + } else if (_c == QMetaObject::RegisterPropertyMetaType) { + if (_id < 2) + *reinterpret_cast(_a[0]) = -1; + _id -= 2; + } +#endif // QT_NO_PROPERTIES + return _id; +} +QT_END_MOC_NAMESPACE diff --git a/cpp/moc_govalue.cpp b/cpp/moc_govalue.cpp new file mode 100644 index 00000000..e41f8604 --- /dev/null +++ b/cpp/moc_govalue.cpp @@ -0,0 +1,155 @@ +/**************************************************************************** +** Meta object code from reading C++ file 'govalue.h' +** +** Created by: The Qt Meta Object Compiler version 67 (Qt 5.2.1) +** +** WARNING! All changes made in this file will be lost! +*****************************************************************************/ + +#include "govalue.h" +#include +#include +#if !defined(Q_MOC_OUTPUT_REVISION) +#error "The header file 'govalue.h' doesn't include ." +#elif Q_MOC_OUTPUT_REVISION != 67 +#error "This file was generated using the moc from 5.2.1. It" +#error "cannot be used with the include files from this version of Qt." +#error "(The moc has changed too much.)" +#endif + +QT_BEGIN_MOC_NAMESPACE +struct qt_meta_stringdata_GoValue_t { + QByteArrayData data[1]; + char stringdata[9]; +}; +#define QT_MOC_LITERAL(idx, ofs, len) \ + Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \ + offsetof(qt_meta_stringdata_GoValue_t, stringdata) + ofs \ + - idx * sizeof(QByteArrayData) \ + ) +static const qt_meta_stringdata_GoValue_t qt_meta_stringdata_GoValue = { + { +QT_MOC_LITERAL(0, 0, 7) + }, + "GoValue\0" +}; +#undef QT_MOC_LITERAL + +static const uint qt_meta_data_GoValue[] = { + + // content: + 7, // revision + 0, // classname + 0, 0, // classinfo + 0, 0, // methods + 0, 0, // properties + 0, 0, // enums/sets + 0, 0, // constructors + 0, // flags + 0, // signalCount + + 0 // eod +}; + +void GoValue::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a) +{ + Q_UNUSED(_o); + Q_UNUSED(_id); + Q_UNUSED(_c); + Q_UNUSED(_a); +} + +const QMetaObject GoValue::staticMetaObject = { + { &QObject::staticMetaObject, qt_meta_stringdata_GoValue.data, + qt_meta_data_GoValue, qt_static_metacall, 0, 0} +}; + + +const QMetaObject *GoValue::metaObject() const +{ + return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject; +} + +void *GoValue::qt_metacast(const char *_clname) +{ + if (!_clname) return 0; + if (!strcmp(_clname, qt_meta_stringdata_GoValue.stringdata)) + return static_cast(const_cast< GoValue*>(this)); + return QObject::qt_metacast(_clname); +} + +int GoValue::qt_metacall(QMetaObject::Call _c, int _id, void **_a) +{ + _id = QObject::qt_metacall(_c, _id, _a); + if (_id < 0) + return _id; + return _id; +} +struct qt_meta_stringdata_GoPaintedValue_t { + QByteArrayData data[1]; + char stringdata[16]; +}; +#define QT_MOC_LITERAL(idx, ofs, len) \ + Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \ + offsetof(qt_meta_stringdata_GoPaintedValue_t, stringdata) + ofs \ + - idx * sizeof(QByteArrayData) \ + ) +static const qt_meta_stringdata_GoPaintedValue_t qt_meta_stringdata_GoPaintedValue = { + { +QT_MOC_LITERAL(0, 0, 14) + }, + "GoPaintedValue\0" +}; +#undef QT_MOC_LITERAL + +static const uint qt_meta_data_GoPaintedValue[] = { + + // content: + 7, // revision + 0, // classname + 0, 0, // classinfo + 0, 0, // methods + 0, 0, // properties + 0, 0, // enums/sets + 0, 0, // constructors + 0, // flags + 0, // signalCount + + 0 // eod +}; + +void GoPaintedValue::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a) +{ + Q_UNUSED(_o); + Q_UNUSED(_id); + Q_UNUSED(_c); + Q_UNUSED(_a); +} + +const QMetaObject GoPaintedValue::staticMetaObject = { + { &QQuickPaintedItem::staticMetaObject, qt_meta_stringdata_GoPaintedValue.data, + qt_meta_data_GoPaintedValue, qt_static_metacall, 0, 0} +}; + + +const QMetaObject *GoPaintedValue::metaObject() const +{ + return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject; +} + +void *GoPaintedValue::qt_metacast(const char *_clname) +{ + if (!_clname) return 0; + if (!strcmp(_clname, qt_meta_stringdata_GoPaintedValue.stringdata)) + return static_cast(const_cast< GoPaintedValue*>(this)); + return QQuickPaintedItem::qt_metacast(_clname); +} + +int GoPaintedValue::qt_metacall(QMetaObject::Call _c, int _id, void **_a) +{ + _id = QQuickPaintedItem::qt_metacall(_c, _id, _a); + if (_id < 0) + return _id; + return _id; +} +QT_END_MOC_NAMESPACE diff --git a/cpp/moc_idletimer.cpp b/cpp/moc_idletimer.cpp new file mode 100644 index 00000000..98dda16e --- /dev/null +++ b/cpp/moc_idletimer.cpp @@ -0,0 +1,108 @@ +/**************************************************************************** +** Meta object code from reading C++ file 'idletimer.cpp' +** +** Created by: The Qt Meta Object Compiler version 67 (Qt 5.2.1) +** +** WARNING! All changes made in this file will be lost! +*****************************************************************************/ + +#include +#include +#if !defined(Q_MOC_OUTPUT_REVISION) +#error "The header file 'idletimer.cpp' doesn't include ." +#elif Q_MOC_OUTPUT_REVISION != 67 +#error "This file was generated using the moc from 5.2.1. It" +#error "cannot be used with the include files from this version of Qt." +#error "(The moc has changed too much.)" +#endif + +QT_BEGIN_MOC_NAMESPACE +struct qt_meta_stringdata_IdleTimer_t { + QByteArrayData data[3]; + char stringdata[18]; +}; +#define QT_MOC_LITERAL(idx, ofs, len) \ + Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \ + offsetof(qt_meta_stringdata_IdleTimer_t, stringdata) + ofs \ + - idx * sizeof(QByteArrayData) \ + ) +static const qt_meta_stringdata_IdleTimer_t qt_meta_stringdata_IdleTimer = { + { +QT_MOC_LITERAL(0, 0, 9), +QT_MOC_LITERAL(1, 10, 5), +QT_MOC_LITERAL(2, 16, 0) + }, + "IdleTimer\0start\0\0" +}; +#undef QT_MOC_LITERAL + +static const uint qt_meta_data_IdleTimer[] = { + + // content: + 7, // revision + 0, // classname + 0, 0, // classinfo + 1, 14, // methods + 0, 0, // properties + 0, 0, // enums/sets + 0, 0, // constructors + 0, // flags + 0, // signalCount + + // methods: name, argc, parameters, tag, flags + 1, 0, 19, 2, 0x02, + + // methods: parameters + QMetaType::Void, + + 0 // eod +}; + +void IdleTimer::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a) +{ + if (_c == QMetaObject::InvokeMetaMethod) { + IdleTimer *_t = static_cast(_o); + switch (_id) { + case 0: _t->start(); break; + default: ; + } + } + Q_UNUSED(_a); +} + +const QMetaObject IdleTimer::staticMetaObject = { + { &QObject::staticMetaObject, qt_meta_stringdata_IdleTimer.data, + qt_meta_data_IdleTimer, qt_static_metacall, 0, 0} +}; + + +const QMetaObject *IdleTimer::metaObject() const +{ + return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject; +} + +void *IdleTimer::qt_metacast(const char *_clname) +{ + if (!_clname) return 0; + if (!strcmp(_clname, qt_meta_stringdata_IdleTimer.stringdata)) + return static_cast(const_cast< IdleTimer*>(this)); + return QObject::qt_metacast(_clname); +} + +int IdleTimer::qt_metacall(QMetaObject::Call _c, int _id, void **_a) +{ + _id = QObject::qt_metacall(_c, _id, _a); + if (_id < 0) + return _id; + if (_c == QMetaObject::InvokeMetaMethod) { + if (_id < 1) + qt_static_metacall(this, _c, _id, _a); + _id -= 1; + } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) { + if (_id < 1) + *reinterpret_cast(_a[0]) = -1; + _id -= 1; + } + return _id; +} +QT_END_MOC_NAMESPACE diff --git a/cpp/private/qmetaobject_p.h b/cpp/private/qmetaobject_p.h new file mode 100644 index 00000000..af506e54 --- /dev/null +++ b/cpp/private/qmetaobject_p.h @@ -0,0 +1,2 @@ +#include "private/qtheader.h" +#include QT_PRIVATE_HEADER(QtCore,qmetaobject_p.h) diff --git a/cpp/private/qmetaobjectbuilder_p.h b/cpp/private/qmetaobjectbuilder_p.h new file mode 100644 index 00000000..47cd9b77 --- /dev/null +++ b/cpp/private/qmetaobjectbuilder_p.h @@ -0,0 +1,2 @@ +#include "private/qtheader.h" +#include QT_PRIVATE_HEADER(QtCore,qmetaobjectbuilder_p.h) diff --git a/cpp/private/qobject_p.h b/cpp/private/qobject_p.h new file mode 100644 index 00000000..75c7f84b --- /dev/null +++ b/cpp/private/qobject_p.h @@ -0,0 +1,2 @@ +#include "private/qtheader.h" +#include QT_PRIVATE_HEADER(QtCore,qobject_p.h) diff --git a/cpp/private/qtheader.h b/cpp/private/qtheader.h new file mode 100644 index 00000000..efa8b87c --- /dev/null +++ b/cpp/private/qtheader.h @@ -0,0 +1,70 @@ +#ifndef QTPRIVATE_H +#define QTPRIVATE_H + +#include + +#define QT_MAJOR_ (QT_VERSION>>16) +#define QT_MINOR_ (QT_VERSION>>8&0xFF) +#define QT_MICRO_ (QT_VERSION&0xFF) + +#if QT_MAJOR_ == 5 +#define QT_MAJOR 5 +#else +#error Unupported Qt major version. Please report. +#endif + +#if QT_MINOR_ == 0 +#define QT_MINOR 0 +#elif QT_MINOR_ == 1 +#define QT_MINOR 1 +#elif QT_MINOR_ == 2 +#define QT_MINOR 2 +#elif QT_MINOR_ == 3 +#define QT_MINOR 3 +#elif QT_MINOR_ == 4 +#define QT_MINOR 4 +#elif QT_MINOR_ == 5 +#define QT_MINOR 5 +#elif QT_MINOR_ == 6 +#define QT_MINOR 6 +#elif QT_MINOR_ == 7 +#define QT_MINOR 7 +#elif QT_MINOR_ == 8 +#define QT_MINOR 8 +#elif QT_MINOR_ == 9 +#define QT_MINOR 9 +#elif QT_MINOR_ == 10 +#define QT_MINOR 10 +#else +#error Unupported Qt minor version. Please report. +#endif + +#if QT_MICRO_ == 0 +#define QT_MICRO 0 +#elif QT_MICRO_ == 1 +#define QT_MICRO 1 +#elif QT_MICRO_ == 2 +#define QT_MICRO 2 +#elif QT_MICRO_ == 3 +#define QT_MICRO 3 +#elif QT_MICRO_ == 4 +#define QT_MICRO 4 +#elif QT_MICRO_ == 5 +#define QT_MICRO 5 +#elif QT_MICRO_ == 6 +#define QT_MICRO 6 +#elif QT_MICRO_ == 7 +#define QT_MICRO 7 +#elif QT_MICRO_ == 8 +#define QT_MICRO 8 +#elif QT_MICRO_ == 9 +#define QT_MICRO 9 +#elif QT_MICRO_ == 10 +#define QT_MICRO 10 +#else +#error Unupported Qt micro version. Please report. +#endif + +#define QT_PRIVATE_HEADER(dir,file) + +#endif // QTPRIVATE_H diff --git a/cpp/update-moc.sh b/cpp/update-moc.sh new file mode 100755 index 00000000..135840f4 --- /dev/null +++ b/cpp/update-moc.sh @@ -0,0 +1,19 @@ +#!/bin/sh + +set -e +cd `dirname $0` + +subdir=`basename $PWD` + +export QT_SELECT=5 + +ALL=moc_all.cpp + +echo "// This file is automatically generated by cpp/update-moc.sh" > $ALL + +for file in `grep -l Q_''OBJECT *`; do + mocfile=`echo $file | awk -F. '{print("moc_"$1".cpp")}'` + mochack=`sed -n 's,^ *// MOC HACK: \(.*\),\1,p' $file` + moc $file | sed "$mochack" > $mocfile + echo "#include \"$subdir/$mocfile\"" >> $ALL +done diff --git a/cpptest/cpptest.cpp b/cpptest/cpptest.cpp new file mode 100644 index 00000000..e0b25699 --- /dev/null +++ b/cpptest/cpptest.cpp @@ -0,0 +1,14 @@ +#include + +#include "cpptest.h" +#include "testtype.h" + +TestType_ *newTestType() +{ + return new TestType(); +} + +int plainTestTypeN(PlainTestType_ *plain) +{ + return static_cast(plain)->n; +} diff --git a/cpptest/cpptest.go b/cpptest/cpptest.go new file mode 100644 index 00000000..4ba24bce --- /dev/null +++ b/cpptest/cpptest.go @@ -0,0 +1,30 @@ +// Package cpptest is an internal test helper. +package cpptest + +// #cgo CXXFLAGS: -std=c++0x -Wall -fno-strict-aliasing -I.. +// #cgo LDFLAGS: -lstdc++ +// +// #cgo pkg-config: Qt5Core +// +// #include "cpptest.h" +// +import "C" + +import ( + "unsafe" + + "gopkg.in/qml.v1" +) + +func NewTestType(engine *qml.Engine) qml.Object { + var obj qml.Object + qml.RunMain(func() { + addr := C.newTestType() + obj = qml.CommonOf(addr, engine) + }) + return obj +} + +func PlainTestTypeN(obj qml.Object) int { + return int(C.plainTestTypeN(unsafe.Pointer(obj.Property("plainAddr").(uintptr)))) +} diff --git a/cpptest/cpptest.h b/cpptest/cpptest.h new file mode 100644 index 00000000..e06a8af3 --- /dev/null +++ b/cpptest/cpptest.h @@ -0,0 +1,23 @@ +#ifndef UONEAUTH_H +#define UONEAUTH_H + +#include +#include +#include + +typedef void TestType_; +typedef void PlainTestType_; + +#ifdef __cplusplus +extern "C" { +#endif + +TestType_ *newTestType(); + +int plainTestTypeN(PlainTestType_ *plain); + +#ifdef __cplusplus +} +#endif + +#endif // UONEAUTH_H diff --git a/cpptest/moc_testtype.cpp b/cpptest/moc_testtype.cpp new file mode 100644 index 00000000..f958d1b8 --- /dev/null +++ b/cpptest/moc_testtype.cpp @@ -0,0 +1,202 @@ +/**************************************************************************** +** Meta object code from reading C++ file 'testtype.h' +** +** Created by: The Qt Meta Object Compiler version 67 (Qt 5.2.1) +** +** WARNING! All changes made in this file will be lost! +*****************************************************************************/ + +#include "testtype.h" +#include +#include +#if !defined(Q_MOC_OUTPUT_REVISION) +#error "The header file 'testtype.h' doesn't include ." +#elif Q_MOC_OUTPUT_REVISION != 67 +#error "This file was generated using the moc from 5.2.1. It" +#error "cannot be used with the include files from this version of Qt." +#error "(The moc has changed too much.)" +#endif + +QT_BEGIN_MOC_NAMESPACE +struct qt_meta_stringdata_TestType_t { + QByteArrayData data[10]; + char stringdata[119]; +}; +#define QT_MOC_LITERAL(idx, ofs, len) \ + Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \ + offsetof(qt_meta_stringdata_TestType_t, stringdata) + ofs \ + - idx * sizeof(QByteArrayData) \ + ) +static const qt_meta_stringdata_TestType_t qt_meta_stringdata_TestType = { + { +QT_MOC_LITERAL(0, 0, 8), +QT_MOC_LITERAL(1, 9, 15), +QT_MOC_LITERAL(2, 25, 0), +QT_MOC_LITERAL(3, 26, 13), +QT_MOC_LITERAL(4, 40, 5), +QT_MOC_LITERAL(5, 46, 15), +QT_MOC_LITERAL(6, 62, 15), +QT_MOC_LITERAL(7, 78, 20), +QT_MOC_LITERAL(8, 99, 9), +QT_MOC_LITERAL(9, 109, 8) + }, + "TestType\0plainEmittedCpy\0\0PlainTestType\0" + "plain\0plainEmittedRef\0plainEmittedPtr\0" + "const PlainTestType*\0emitPlain\0voidAddr\0" +}; +#undef QT_MOC_LITERAL + +static const uint qt_meta_data_TestType[] = { + + // content: + 7, // revision + 0, // classname + 0, 0, // classinfo + 4, 14, // methods + 1, 44, // properties + 0, 0, // enums/sets + 0, 0, // constructors + 0, // flags + 3, // signalCount + + // signals: name, argc, parameters, tag, flags + 1, 1, 34, 2, 0x06, + 5, 1, 37, 2, 0x06, + 6, 1, 40, 2, 0x06, + + // methods: name, argc, parameters, tag, flags + 8, 0, 43, 2, 0x02, + + // signals: parameters + QMetaType::Void, 0x80000000 | 3, 4, + QMetaType::Void, 0x80000000 | 3, 4, + QMetaType::Void, 0x80000000 | 7, 4, + + // methods: parameters + QMetaType::Void, + + // properties: name, type, flags + 9, QMetaType::VoidStar, 0x00095001, + + 0 // eod +}; + +void TestType::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a) +{ + if (_c == QMetaObject::InvokeMetaMethod) { + TestType *_t = static_cast(_o); + switch (_id) { + case 0: _t->plainEmittedCpy((*reinterpret_cast< const PlainTestType(*)>(_a[1]))); break; + case 1: _t->plainEmittedRef((*reinterpret_cast< const PlainTestType(*)>(_a[1]))); break; + case 2: _t->plainEmittedPtr((*reinterpret_cast< const PlainTestType*(*)>(_a[1]))); break; + case 3: _t->emitPlain(); break; + default: ; + } + } else if (_c == QMetaObject::IndexOfMethod) { + int *result = reinterpret_cast(_a[0]); + void **func = reinterpret_cast(_a[1]); + { + typedef void (TestType::*_t)(const PlainTestType ); + if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestType::plainEmittedCpy)) { + *result = 0; + } + } + { + typedef void (TestType::*_t)(const PlainTestType & ); + if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestType::plainEmittedRef)) { + *result = 1; + } + } + { + typedef void (TestType::*_t)(const PlainTestType * ); + if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TestType::plainEmittedPtr)) { + *result = 2; + } + } + } +} + +const QMetaObject TestType::staticMetaObject = { + { &QObject::staticMetaObject, qt_meta_stringdata_TestType.data, + qt_meta_data_TestType, qt_static_metacall, 0, 0} +}; + + +const QMetaObject *TestType::metaObject() const +{ + return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject; +} + +void *TestType::qt_metacast(const char *_clname) +{ + if (!_clname) return 0; + if (!strcmp(_clname, qt_meta_stringdata_TestType.stringdata)) + return static_cast(const_cast< TestType*>(this)); + return QObject::qt_metacast(_clname); +} + +int TestType::qt_metacall(QMetaObject::Call _c, int _id, void **_a) +{ + _id = QObject::qt_metacall(_c, _id, _a); + if (_id < 0) + return _id; + if (_c == QMetaObject::InvokeMetaMethod) { + if (_id < 4) + qt_static_metacall(this, _c, _id, _a); + _id -= 4; + } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) { + if (_id < 4) + *reinterpret_cast(_a[0]) = -1; + _id -= 4; + } +#ifndef QT_NO_PROPERTIES + else if (_c == QMetaObject::ReadProperty) { + void *_v = _a[0]; + switch (_id) { + case 0: *reinterpret_cast< void**>(_v) = getVoidAddr(); break; + } + _id -= 1; + } else if (_c == QMetaObject::WriteProperty) { + _id -= 1; + } else if (_c == QMetaObject::ResetProperty) { + _id -= 1; + } else if (_c == QMetaObject::QueryPropertyDesignable) { + _id -= 1; + } else if (_c == QMetaObject::QueryPropertyScriptable) { + _id -= 1; + } else if (_c == QMetaObject::QueryPropertyStored) { + _id -= 1; + } else if (_c == QMetaObject::QueryPropertyEditable) { + _id -= 1; + } else if (_c == QMetaObject::QueryPropertyUser) { + _id -= 1; + } else if (_c == QMetaObject::RegisterPropertyMetaType) { + if (_id < 1) + *reinterpret_cast(_a[0]) = -1; + _id -= 1; + } +#endif // QT_NO_PROPERTIES + return _id; +} + +// SIGNAL 0 +void TestType::plainEmittedCpy(const PlainTestType _t1) +{ + void *_a[] = { 0, const_cast(reinterpret_cast(&_t1)) }; + QMetaObject::activate(this, &staticMetaObject, 0, _a); +} + +// SIGNAL 1 +void TestType::plainEmittedRef(const PlainTestType & _t1) +{ + void *_a[] = { 0, const_cast(reinterpret_cast(&_t1)) }; + QMetaObject::activate(this, &staticMetaObject, 1, _a); +} + +// SIGNAL 2 +void TestType::plainEmittedPtr(const PlainTestType * _t1) +{ + void *_a[] = { 0, const_cast(reinterpret_cast(&_t1)) }; + QMetaObject::activate(this, &staticMetaObject, 2, _a); +} +QT_END_MOC_NAMESPACE diff --git a/cpptest/testtype.h b/cpptest/testtype.h new file mode 100644 index 00000000..4d281b98 --- /dev/null +++ b/cpptest/testtype.h @@ -0,0 +1,45 @@ +#ifndef TESTTYPE_H +#define TESTTYPE_H + +#include + +class PlainTestType { + + public: + + PlainTestType(int n) : n(n) {}; + + int n; +}; + +class TestType : public QObject +{ + Q_OBJECT + + Q_PROPERTY(void *voidAddr READ getVoidAddr) + + void *voidAddr; + + public: + + TestType(QObject *parent = 0) : QObject(parent), voidAddr((void*)42) {}; + + void *getVoidAddr() { return voidAddr; }; + + Q_INVOKABLE void emitPlain() { + PlainTestType plain = PlainTestType(42); + emit plainEmittedCpy(plain); + emit plainEmittedRef(plain); + emit plainEmittedPtr(&plain); + }; + + signals: + + void plainEmittedCpy(const PlainTestType plain); + void plainEmittedRef(const PlainTestType &plain); + void plainEmittedPtr(const PlainTestType *plain); +}; + +#endif // TESTTYPE_H + +// vim:ts=4:sw=4:et diff --git a/cpptest/update-moc.sh b/cpptest/update-moc.sh new file mode 100755 index 00000000..9abbfdf2 --- /dev/null +++ b/cpptest/update-moc.sh @@ -0,0 +1,12 @@ +#!/bin/sh + +set -e +cd `dirname $0` + +export QT_SELECT=5 + +for file in `grep -l Q_''OBJECT *`; do + mocfile=`echo $file | awk -F. '{print("moc_"$1".cpp")}'` + mochack=`sed -n 's,^ *// MOC HACK: \(.*\),\1,p' $file` + moc $file | sed "$mochack" > $mocfile +done diff --git a/datatype.go b/datatype.go new file mode 100644 index 00000000..4b7fb643 --- /dev/null +++ b/datatype.go @@ -0,0 +1,530 @@ +package qml + +// #include +// #include "capi.h" +import "C" + +import ( + "bytes" + "fmt" + "image/color" + "reflect" + "strings" + "unicode" + "unsafe" +) + +var ( + intIs64 bool + intDT C.DataType + + ptrSize = C.size_t(unsafe.Sizeof(uintptr(0))) + + nilPtr = unsafe.Pointer(uintptr(0)) + nilCharPtr = (*C.char)(nilPtr) + + typeString = reflect.TypeOf("") + typeBool = reflect.TypeOf(false) + typeInt = reflect.TypeOf(int(0)) + typeInt64 = reflect.TypeOf(int64(0)) + typeInt32 = reflect.TypeOf(int32(0)) + typeFloat64 = reflect.TypeOf(float64(0)) + typeFloat32 = reflect.TypeOf(float32(0)) + typeIface = reflect.TypeOf(new(interface{})).Elem() + typeRGBA = reflect.TypeOf(color.RGBA{}) + typeObjSlice = reflect.TypeOf([]Object(nil)) + typeObject = reflect.TypeOf([]Object(nil)).Elem() + typePainter = reflect.TypeOf(&Painter{}) + typeList = reflect.TypeOf(&List{}) + typeMap = reflect.TypeOf(&Map{}) + typeGenericMap = reflect.TypeOf(map[string]interface{}(nil)) +) + +func init() { + var i int = 1<<31 - 1 + intIs64 = (i+1 > 0) + if intIs64 { + intDT = C.DTInt64 + } else { + intDT = C.DTInt32 + } +} + +// packDataValue packs the provided Go value into a C.DataValue for +// shiping into C++ land. +// +// For simple types (bool, int, etc) value is converted into a +// native C++ value. For anything else, including cases when value +// has a type that has an underlying simple type, the Go value itself +// is encapsulated into a C++ wrapper so that field access and method +// calls work. +// +// This must be run from the main GUI thread due to the cases where +// calling wrapGoValue is necessary. +func packDataValue(value interface{}, dvalue *C.DataValue, engine *Engine, owner valueOwner) { + datap := unsafe.Pointer(&dvalue.data) + if value == nil { + dvalue.dataType = C.DTInvalid + return + } + switch value := value.(type) { + case string: + dvalue.dataType = C.DTString + cstr, cstrlen := unsafeStringData(value) + *(**C.char)(datap) = cstr + dvalue.len = cstrlen + case bool: + dvalue.dataType = C.DTBool + *(*bool)(datap) = value + case int: + if value > 1<<31-1 { + dvalue.dataType = C.DTInt64 + *(*int64)(datap) = int64(value) + } else { + dvalue.dataType = C.DTInt32 + *(*int32)(datap) = int32(value) + } + case int64: + dvalue.dataType = C.DTInt64 + *(*int64)(datap) = value + case int32: + dvalue.dataType = C.DTInt32 + *(*int32)(datap) = value + case uint64: + dvalue.dataType = C.DTUint64 + *(*uint64)(datap) = value + case uint32: + dvalue.dataType = C.DTUint32 + *(*uint32)(datap) = value + case float64: + dvalue.dataType = C.DTFloat64 + *(*float64)(datap) = value + case float32: + dvalue.dataType = C.DTFloat32 + *(*float32)(datap) = value + case *Common: + dvalue.dataType = C.DTObject + *(*unsafe.Pointer)(datap) = value.addr + case color.RGBA: + dvalue.dataType = C.DTColor + *(*uint32)(datap) = uint32(value.A)<<24 | uint32(value.R)<<16 | uint32(value.G)<<8 | uint32(value.B) + default: + dvalue.dataType = C.DTObject + if obj, ok := value.(Object); ok { + *(*unsafe.Pointer)(datap) = obj.Common().addr + } else { + *(*unsafe.Pointer)(datap) = wrapGoValue(engine, value, owner) + } + } +} + +// TODO Handle byte slices. + +// unpackDataValue converts a value shipped by C++ into a native Go value. +// +// HEADS UP: This is considered safe to be run out of the main GUI thread. +// If that changes, fix the call sites. +func unpackDataValue(dvalue *C.DataValue, engine *Engine) interface{} { + datap := unsafe.Pointer(&dvalue.data) + switch dvalue.dataType { + case C.DTString: + s := C.GoStringN(*(**C.char)(datap), dvalue.len) + // TODO If we move all unpackDataValue calls to the GUI thread, + // can we get rid of this allocation somehow? + C.free(unsafe.Pointer(*(**C.char)(datap))) + return s + case C.DTBool: + return *(*bool)(datap) + case C.DTInt64: + return *(*int64)(datap) + case C.DTInt32: + return int(*(*int32)(datap)) + case C.DTUint64: + return *(*uint64)(datap) + case C.DTUint32: + return *(*uint32)(datap) + case C.DTUintptr: + return *(*uintptr)(datap) + case C.DTFloat64: + return *(*float64)(datap) + case C.DTFloat32: + return *(*float32)(datap) + case C.DTColor: + var c uint32 = *(*uint32)(datap) + return color.RGBA{byte(c >> 16), byte(c >> 8), byte(c), byte(c >> 24)} + case C.DTGoAddr: + // ObjectByName also does this fold conversion, to have access + // to the cvalue. Perhaps the fold should be returned. + fold := ensureEngine(engine.addr, C.GoRef(uintptr(*(*unsafe.Pointer)(datap)))) + return fold.gvalue + case C.DTInvalid: + return nil + case C.DTObject: + // TODO Would be good to preserve identity on the Go side. See initGoType as well. + obj := &Common{ + engine: engine, + addr: *(*unsafe.Pointer)(datap), + } + if len(converters) > 0 { + // TODO Embed the type name in DataValue to drop these calls. + typeName := obj.TypeName() + if typeName == "PlainObject" { + typeName = strings.TrimRight(obj.String("plainType"), "&*") + if strings.HasPrefix(typeName, "const ") { + typeName = typeName[6:] + } + } + if f, ok := converters[typeName]; ok { + return f(engine, obj) + } + } + return obj + case C.DTValueList, C.DTValueMap: + var dvlist []C.DataValue + var dvlisth = (*reflect.SliceHeader)(unsafe.Pointer(&dvlist)) + dvlisth.Data = uintptr(*(*unsafe.Pointer)(datap)) + dvlisth.Len = int(dvalue.len) + dvlisth.Cap = int(dvalue.len) + result := make([]interface{}, len(dvlist)) + for i := range result { + result[i] = unpackDataValue(&dvlist[i], engine) + } + C.free(*(*unsafe.Pointer)(datap)) + if dvalue.dataType == C.DTValueList { + return &List{result} + } else { + return &Map{result} + } + } + panic(fmt.Sprintf("unsupported data type: %d", dvalue.dataType)) +} + +func dataTypeOf(typ reflect.Type) C.DataType { + // Compare against the specific types rather than their kind. + // Custom types may have methods that must be supported. + switch typ { + case typeString: + return C.DTString + case typeBool: + return C.DTBool + case typeInt: + return intDT + case typeInt64: + return C.DTInt64 + case typeInt32: + return C.DTInt32 + case typeFloat32: + return C.DTFloat32 + case typeFloat64: + return C.DTFloat64 + case typeIface: + return C.DTAny + case typeRGBA: + return C.DTColor + case typeObjSlice: + return C.DTListProperty + } + return C.DTObject +} + +var typeInfoSize = C.size_t(unsafe.Sizeof(C.GoTypeInfo{})) +var memberInfoSize = C.size_t(unsafe.Sizeof(C.GoMemberInfo{})) + +var typeInfoCache = make(map[reflect.Type]*C.GoTypeInfo) + +func appendLoweredName(buf []byte, name string) []byte { + var last rune + var lasti int + for i, rune := range name { + if !unicode.IsUpper(rune) { + if lasti == 0 { + last = unicode.ToLower(last) + } + buf = append(buf, string(last)...) + buf = append(buf, name[i:]...) + return buf + } + if i > 0 { + buf = append(buf, string(unicode.ToLower(last))...) + } + lasti, last = i, rune + } + return append(buf, string(unicode.ToLower(last))...) +} + +func typeInfo(v interface{}) *C.GoTypeInfo { + vt := reflect.TypeOf(v) + for vt.Kind() == reflect.Ptr { + vt = vt.Elem() + } + + typeInfo := typeInfoCache[vt] + if typeInfo != nil { + return typeInfo + } + + typeInfo = (*C.GoTypeInfo)(C.malloc(typeInfoSize)) + typeInfo.typeName = C.CString(vt.Name()) + typeInfo.metaObject = nilPtr + typeInfo.paint = (*C.GoMemberInfo)(nilPtr) + + var setters map[string]int + var getters map[string]int + + // TODO Only do that if it's a struct? + vtptr := reflect.PtrTo(vt) + + if vt.Kind() != reflect.Struct { + panic(fmt.Sprintf("handling of %s (%#v) is incomplete; please report to the developers", vt, v)) + } + + numField := vt.NumField() + numMethod := vtptr.NumMethod() + privateFields := 0 + privateMethods := 0 + + // struct { FooBar T; Baz T } => "fooBar\0baz\0" + namesLen := 0 + for i := 0; i < numField; i++ { + field := vt.Field(i) + if field.PkgPath != "" { + privateFields++ + continue + } + namesLen += len(field.Name) + 1 + } + for i := 0; i < numMethod; i++ { + method := vtptr.Method(i) + if method.PkgPath != "" { + privateMethods++ + continue + } + namesLen += len(method.Name) + 1 + + // Track setters and getters. + if len(method.Name) > 3 && method.Name[:3] == "Set" { + if method.Type.NumIn() == 2 { + if setters == nil { + setters = make(map[string]int) + } + setters[method.Name[3:]] = i + } + } else if method.Type.NumIn() == 1 && method.Type.NumOut() == 1 { + if getters == nil { + getters = make(map[string]int) + } + getters[method.Name] = i + } + } + names := make([]byte, 0, namesLen) + for i := 0; i < numField; i++ { + field := vt.Field(i) + if field.PkgPath != "" { + continue // not exported + } + names = appendLoweredName(names, field.Name) + names = append(names, 0) + } + for i := 0; i < numMethod; i++ { + method := vtptr.Method(i) + if method.PkgPath != "" { + continue // not exported + } + if _, ok := getters[method.Name]; !ok { + continue + } + if _, ok := setters[method.Name]; !ok { + delete(getters, method.Name) + continue + } + // This is a getter method + names = appendLoweredName(names, method.Name) + names = append(names, 0) + } + for i := 0; i < numMethod; i++ { + method := vtptr.Method(i) + if method.PkgPath != "" { + continue // not exported + } + if _, ok := getters[method.Name]; ok { + continue // getter already handled above + } + names = appendLoweredName(names, method.Name) + names = append(names, 0) + } + if len(names) != namesLen { + panic("pre-allocated buffer size was wrong") + } + typeInfo.memberNames = C.CString(string(names)) + + // Assemble information on members. + membersLen := numField - privateFields + numMethod - privateMethods + membersi := uintptr(0) + mnamesi := uintptr(0) + members := uintptr(C.malloc(memberInfoSize * C.size_t(membersLen))) + mnames := uintptr(unsafe.Pointer(typeInfo.memberNames)) + for i := 0; i < numField; i++ { + field := vt.Field(i) + if field.PkgPath != "" { + continue // not exported + } + memberInfo := (*C.GoMemberInfo)(unsafe.Pointer(members + uintptr(memberInfoSize)*membersi)) + memberInfo.memberName = (*C.char)(unsafe.Pointer(mnames + mnamesi)) + memberInfo.memberType = dataTypeOf(field.Type) + memberInfo.reflectIndex = C.int(i) + memberInfo.reflectGetIndex = -1 + memberInfo.reflectSetIndex = -1 + memberInfo.addrOffset = C.int(field.Offset) + membersi += 1 + mnamesi += uintptr(len(field.Name)) + 1 + if methodIndex, ok := setters[field.Name]; ok { + memberInfo.reflectSetIndex = C.int(methodIndex) + } + } + for i := 0; i < numMethod; i++ { + method := vtptr.Method(i) + if method.PkgPath != "" { + continue // not exported + } + if _, ok := getters[method.Name]; !ok { + continue // not a getter + } + memberInfo := (*C.GoMemberInfo)(unsafe.Pointer(members + uintptr(memberInfoSize)*membersi)) + memberInfo.memberName = (*C.char)(unsafe.Pointer(mnames + mnamesi)) + memberInfo.memberType = dataTypeOf(method.Type.Out(0)) + memberInfo.reflectIndex = -1 + memberInfo.reflectGetIndex = C.int(getters[method.Name]) + memberInfo.reflectSetIndex = C.int(setters[method.Name]) + memberInfo.addrOffset = 0 + membersi += 1 + mnamesi += uintptr(len(method.Name)) + 1 + } + for i := 0; i < numMethod; i++ { + method := vtptr.Method(i) + if method.PkgPath != "" { + continue // not exported + } + if _, ok := getters[method.Name]; ok { + continue // getter already handled above + } + memberInfo := (*C.GoMemberInfo)(unsafe.Pointer(members + uintptr(memberInfoSize)*membersi)) + memberInfo.memberName = (*C.char)(unsafe.Pointer(mnames + mnamesi)) + memberInfo.memberType = C.DTMethod + memberInfo.reflectIndex = C.int(i) + memberInfo.reflectGetIndex = -1 + memberInfo.reflectSetIndex = -1 + memberInfo.addrOffset = 0 + signature, result := methodQtSignature(method) + // TODO The signature data might be embedded in the same array as the member names. + memberInfo.methodSignature = C.CString(signature) + memberInfo.resultSignature = C.CString(result) + // TODO Sort out methods with a variable number of arguments. + // It's called while bound, so drop the receiver. + memberInfo.numIn = C.int(method.Type.NumIn() - 1) + memberInfo.numOut = C.int(method.Type.NumOut()) + membersi += 1 + mnamesi += uintptr(len(method.Name)) + 1 + + if method.Name == "Paint" && memberInfo.numIn == 1 && memberInfo.numOut == 0 && method.Type.In(1) == typePainter { + typeInfo.paint = memberInfo + } + } + typeInfo.members = (*C.GoMemberInfo)(unsafe.Pointer(members)) + typeInfo.membersLen = C.int(membersLen) + + typeInfo.fields = typeInfo.members + typeInfo.fieldsLen = C.int(numField - privateFields + len(getters)) + typeInfo.methods = (*C.GoMemberInfo)(unsafe.Pointer(members + uintptr(memberInfoSize)*uintptr(typeInfo.fieldsLen))) + typeInfo.methodsLen = C.int(numMethod - privateMethods - len(getters)) + + if int(membersi) != membersLen { + panic("used more space than allocated for member names") + } + if int(mnamesi) != namesLen { + panic("allocated buffer doesn't match used space") + } + if typeInfo.fieldsLen+typeInfo.methodsLen != typeInfo.membersLen { + panic("lengths are inconsistent") + } + + typeInfoCache[vt] = typeInfo + return typeInfo +} + +func methodQtSignature(method reflect.Method) (signature, result string) { + var buf bytes.Buffer + for i, rune := range method.Name { + if i == 0 { + buf.WriteRune(unicode.ToLower(rune)) + } else { + buf.WriteString(method.Name[i:]) + break + } + } + buf.WriteByte('(') + n := method.Type.NumIn() + for i := 1; i < n; i++ { + if i > 1 { + buf.WriteByte(',') + } + buf.WriteString("QVariant") + } + buf.WriteByte(')') + signature = buf.String() + + switch method.Type.NumOut() { + case 0: + // keep it as "" + case 1: + result = "QVariant" + default: + result = "QVariantList" + } + return +} + +func hashable(value interface{}) (hashable bool) { + defer func() { recover() }() + return value == value +} + +// unsafeString returns a Go string backed by C data. +// +// If the C data is deallocated or moved, the string will be +// invalid and will crash the program if used. As such, the +// resulting string must only be used inside the implementation +// of the qml package and while the life time of the C data +// is guaranteed. +func unsafeString(data *C.char, size C.int) string { + var s string + sh := (*reflect.StringHeader)(unsafe.Pointer(&s)) + sh.Data = uintptr(unsafe.Pointer(data)) + sh.Len = int(size) + return s +} + +// unsafeStringData returns a C string backed by Go data. The C +// string is NOT null-terminated, so its length must be taken +// into account. +// +// If the s Go string is garbage collected, the returned C data +// will be invalid and will crash the program if used. As such, +// the resulting data must only be used inside the implementation +// of the qml package and while the life time of the Go string +// is guaranteed. +func unsafeStringData(s string) (*C.char, C.int) { + return *(**C.char)(unsafe.Pointer(&s)), C.int(len(s)) +} + +// unsafeBytesData returns a C string backed by Go data. The C +// string is NOT null-terminated, so its length must be taken +// into account. +// +// If the array backing the b Go slice is garbage collected, the +// returned C data will be invalid and will crash the program if +// used. As such, the resulting data must only be used inside the +// implementation of the qml package and while the life time of +// the Go array is guaranteed. +func unsafeBytesData(b []byte) (*C.char, C.int) { + return *(**C.char)(unsafe.Pointer(&b)), C.int(len(b)) +} diff --git a/doc.go b/doc.go new file mode 100644 index 00000000..94b2404a --- /dev/null +++ b/doc.go @@ -0,0 +1,199 @@ +// Package qml offers graphical QML application support for the Go language. +// +// Attention +// +// This package is in an alpha stage, and still in heavy development. APIs may +// change, and things may break. +// +// At this time contributors and developers that are interested in tracking the +// development closely are encouraged to use it. If you'd prefer a more stable +// release, please hold on a bit and subscribe to the mailing list for news. It's +// in a pretty good state, so it shall not take too long. +// +// See http://github.com/go-qml/qml for details. +// +// +// Introduction +// +// The qml package enables Go programs to display and manipulate graphical content +// using Qt's QML framework. QML uses a declarative language to express structure +// and style, and supports JavaScript for in-place manipulation of the described +// content. When using the Go qml package, such QML content can also interact with +// Go values, making use of its exported fields and methods, and even explicitly +// creating new instances of registered Go types. +// +// A simple Go application that integrates with QML may perform the following steps +// for offering a graphical interface: +// +// * Call qml.Run from function main providing a function with the logic below +// * Create an engine for loading and running QML content (see NewEngine) +// * Make Go values and types available to QML (see Context.SetVar and RegisterType) +// * Load QML content (see Engine.LoadString and Engine.LoadFile) +// * Create a new window for the content (see Component.CreateWindow) +// * Show the window and wait for it to be closed (see Window.Show and Window.Wait) +// +// Some of these topics are covered below, and may also be observed in practice +// in the following examples: +// +// https://github.com/go-qml/qml/tree/v1/examples +// +// +// Simple example +// +// The following logic demonstrates loading a QML file into a window: +// +// func main() { +// err := qml.Run(run) +// ... +// } +// +// func run() error { +// engine := qml.NewEngine() +// component, err := engine.LoadFile("file.qml") +// if err != nil { +// return err +// } +// win := component.CreateWindow(nil) +// win.Show() +// win.Wait() +// return nil +// } +// +// Handling QML objects in Go +// +// Any QML object may be manipulated by Go via the Object interface. That +// interface is implemented both by dynamic QML values obtained from a running +// engine, and by Go types in the qml package that represent QML values, such as +// Window, Context, and Engine. +// +// For example, the following logic creates a window and prints its width +// whenever it's made visible: +// +// win := component.CreateWindow(nil) +// win.On("visibleChanged", func(visible bool) { +// if (visible) { +// fmt.Println("Width:", win.Int("width")) +// } +// }) +// +// Information about the methods, properties, and signals that are available for QML +// objects may be obtained in the Qt documentation. As a reference, the "visibleChanged" +// signal and the "width" property used in the example above are described at: +// +// http://qt-project.org/doc/qt-5.0/qtgui/qwindow.html +// +// When in doubt about what type is being manipulated, the Object.TypeName method +// provides the type name of the underlying value. +// +// +// Publishing Go values to QML +// +// The simplest way of making a Go value available to QML code is setting it +// as a variable of the engine's root context, as in: +// +// context := engine.Context() +// context.SetVar("person", &Person{Name: "Ale"}) +// +// This logic would enable the following QML code to successfully run: +// +// import QtQuick 2.0 +// Item { +// Component.onCompleted: console.log("Name is", person.name) +// } +// +// +// Publishing Go types to QML +// +// While registering an individual Go value as described above is a quick way to get +// started, it is also fairly limited. For more flexibility, a Go type may be +// registered so that QML code can natively create new instances in an arbitrary +// position of the structure. This may be achieved via the RegisterType function, as +// the following example demonstrates: +// +// qml.RegisterTypes("GoExtensions", 1, 0, []qml.TypeSpec{{ +// Init: func(p *Person, obj qml.Object) { p.Name = "" }, +// }}) +// +// With this logic in place, QML code can create new instances of Person by itself: +// +// import QtQuick 2.0 +// import GoExtensions 1.0 +// Item{ +// Person { +// id: person +// name: "Ale" +// } +// Component.onCompleted: console.log("Name is", person.name) +// } +// +// +// Lowercasing of names +// +// Independently from the mechanism used to publish a Go value to QML code, its methods +// and fields are available to QML logic as methods and properties of the +// respective QML object representing it. As required by QML, though, the Go +// method and field names are lowercased according to the following scheme when +// being accesed from QML: +// +// value.Name => value.name +// value.UPPERName => value.upperName +// value.UPPER => value.upper +// +// +// Setters and getters +// +// While QML code can directly read and write exported fields of Go values, as described +// above, a Go type can also intercept writes to specific fields by declaring a setter +// method according to common Go conventions. This is often useful for updating the +// internal state or the visible content of a Go-defined type. +// +// For example: +// +// type Person struct { +// Name string +// } +// +// func (p *Person) SetName(name string) { +// fmt.Println("Old name is", p.Name) +// p.Name = name +// fmt.Println("New name is", p.Name) +// } +// +// In the example above, whenever QML code attempts to update the Person.Name field +// via any means (direct assignment, object declarations, etc) the SetName method +// is invoked with the provided value instead. +// +// A setter method may also be used in conjunction with a getter method rather +// than a real type field. A method is only considered a getter in the presence +// of the respective setter, and according to common Go conventions it must not +// have the Get prefix. +// +// Inside QML logic, the getter and setter pair is seen as a single object property. +// +// +// Painting +// +// Custom types implemented in Go may have displayable content by defining +// a Paint method such as: +// +// func (p *Person) Paint(painter *qml.Painter) { +// // ... OpenGL calls with the gopkg.in/qml.v1/gl/ package ... +// } +// +// A simple example is available at: +// +// https://github.com/go-qml/qml/tree/v1/examples/painting +// +// +// Packing resources into the Go qml binary +// +// Resource files (qml code, images, etc) may be packed into the Go qml application +// binary to simplify its handling and distribution. This is done with the genqrc tool: +// +// http://gopkg.in/qml.v1/cmd/genqrc#usage +// +// The following blog post provides more details: +// +// http://blog.labix.org/2014/09/26/packing-resources-into-go-qml-binaries +// +package qml diff --git a/error.go b/error.go deleted file mode 100644 index 187bae0d..00000000 --- a/error.go +++ /dev/null @@ -1,5 +0,0 @@ -package error - -func error() { - `ERROR: the correct import path is gopkg.in/qml.v1 ... ` -} diff --git a/examples/controls/.gitignore b/examples/controls/.gitignore new file mode 100644 index 00000000..309fbb35 --- /dev/null +++ b/examples/controls/.gitignore @@ -0,0 +1,5 @@ +basiclayouts/basiclayouts +gallery/gallery +splitview/splitview +tableview/tableview +touch/touch diff --git a/examples/controls/README.md b/examples/controls/README.md new file mode 100644 index 00000000..201846d8 --- /dev/null +++ b/examples/controls/README.md @@ -0,0 +1,8 @@ +These examples were ported from [qtquickcontrols](git@gitorious.org:qt/qtquickcontrols.git). + +Only the basic ones were ported, in order to demonstrate how easy it is to create a full-fledged UI with Go and QML. + +There were a few more, but they that had native modules and those were omitted due to laziness. + +In order to run them you might need some extra Qt5 plugins. On Ubuntu those can be installed using this command: + sudo apt-get install qtdeclarative5-controls-plugin qtdeclarative5-xmllistmodel-plugin diff --git a/examples/controls/basiclayouts/basiclayouts.go b/examples/controls/basiclayouts/basiclayouts.go new file mode 100644 index 00000000..a16b6b1a --- /dev/null +++ b/examples/controls/basiclayouts/basiclayouts.go @@ -0,0 +1,29 @@ +package main + +import ( + "fmt" + "gopkg.in/qml.v1" + "os" +) + +func main() { + if err := qml.Run(run); err != nil { + fmt.Fprintf(os.Stderr, "error: %v\n", err) + os.Exit(1) + } +} + +func run() error { + engine := qml.NewEngine() + + controls, err := engine.LoadFile("main.qml") + if err != nil { + return err + } + + window := controls.CreateWindow(nil) + + window.Show() + window.Wait() + return nil +} diff --git a/examples/controls/basiclayouts/main.qml b/examples/controls/basiclayouts/main.qml new file mode 100644 index 00000000..ecbbb75a --- /dev/null +++ b/examples/controls/basiclayouts/main.qml @@ -0,0 +1,116 @@ +/**************************************************************************** +** +** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/legal +** +** This file is part of the Qt Quick Controls module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "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. +** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names +** of its 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." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + + + + +import QtQuick 2.2 +import QtQuick.Controls 1.1 +import QtQuick.Layouts 1.0 + +ApplicationWindow { + visible: true + title: "Basic layouts" + property int margin: 11 + width: mainLayout.implicitWidth + 2 * margin + height: mainLayout.implicitHeight + 2 * margin + minimumWidth: mainLayout.Layout.minimumWidth + 2 * margin + minimumHeight: mainLayout.Layout.minimumHeight + 2 * margin + + ColumnLayout { + id: mainLayout + anchors.fill: parent + anchors.margins: margin + GroupBox { + id: rowBox + title: "Row layout" + Layout.fillWidth: true + + RowLayout { + id: rowLayout + anchors.fill: parent + TextField { + placeholderText: "This wants to grow horizontally" + Layout.fillWidth: true + } + Button { + text: "Button" + } + } + } + + GroupBox { + id: gridBox + title: "Grid layout" + Layout.fillWidth: true + + GridLayout { + id: gridLayout + rows: 3 + flow: GridLayout.TopToBottom + anchors.fill: parent + + Label { text: "Line 1" } + Label { text: "Line 2" } + Label { text: "Line 3" } + + TextField { } + TextField { } + TextField { } + + TextArea { + text: "This widget spans over three rows in the GridLayout.\n" + + "All items in the GridLayout are implicitly positioned from top to bottom." + Layout.rowSpan: 3 + Layout.fillHeight: true + Layout.fillWidth: true + } + } + } + TextArea { + id: t3 + text: "This fills the whole cell" + Layout.minimumHeight: 30 + Layout.fillHeight: true + Layout.fillWidth: true + } + } +} diff --git a/examples/controls/gallery/content/AboutDialog.qml b/examples/controls/gallery/content/AboutDialog.qml new file mode 100644 index 00000000..aec7b604 --- /dev/null +++ b/examples/controls/gallery/content/AboutDialog.qml @@ -0,0 +1,48 @@ +/**************************************************************************** +** +** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/legal +** +** This file is part of the Qt Quick Controls module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "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. +** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names +** of its 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." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ +import QtQuick 2.2 +import QtQuick.Dialogs 1.1 + +MessageDialog { + icon: StandardIcon.Information + text: "QtQuick.Controls gallery example" + detailedText: "This example demonstrates most of the available Qt Quick Controls." + title: "About Gallery" +} diff --git a/examples/controls/gallery/content/ChildWindow.qml b/examples/controls/gallery/content/ChildWindow.qml new file mode 100644 index 00000000..08925f63 --- /dev/null +++ b/examples/controls/gallery/content/ChildWindow.qml @@ -0,0 +1,122 @@ +/**************************************************************************** +** +** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/legal +** +** This file is part of the Qt Quick Controls module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "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. +** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names +** of its 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." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + + + + +import QtQuick 2.2 +import QtQuick.Window 2.1 +import QtQuick.Controls 1.1 + +Window { + id: window1 + + width: 400 + height: 400 + + title: "child window" + flags: Qt.Dialog + + Rectangle { + color: syspal.window + anchors.fill: parent + + Label { + id: dimensionsText + anchors.horizontalCenter: parent.horizontalCenter + anchors.top: parent.top + width: parent.width + horizontalAlignment: Text.AlignHCenter + } + + Label { + id: availableDimensionsText + anchors.horizontalCenter: parent.horizontalCenter + anchors.top: dimensionsText.bottom + width: parent.width + horizontalAlignment: Text.AlignHCenter + } + + Label { + id: closeText + anchors.horizontalCenter: parent.horizontalCenter + anchors.top: availableDimensionsText.bottom + text: "This is a new Window, press the\nbutton below to close it again." + } + Button { + anchors.horizontalCenter: closeText.horizontalCenter + anchors.top: closeText.bottom + id: closeWindowButton + text:"Close" + width: 98 + tooltip:"Press me, to close this window again" + onClicked: window1.visible = false + } + Button { + anchors.horizontalCenter: closeText.horizontalCenter + anchors.top: closeWindowButton.bottom + id: maximizeWindowButton + text:"Maximize" + width: 98 + tooltip:"Press me, to maximize this window again" + onClicked: window1.visibility = Window.Maximized; + } + Button { + anchors.horizontalCenter: closeText.horizontalCenter + anchors.top: maximizeWindowButton.bottom + id: normalizeWindowButton + text:"Normalize" + width: 98 + tooltip:"Press me, to normalize this window again" + onClicked: window1.visibility = Window.Windowed; + } + Button { + anchors.horizontalCenter: closeText.horizontalCenter + anchors.top: normalizeWindowButton.bottom + id: minimizeWindowButton + text:"Minimize" + width: 98 + tooltip:"Press me, to minimize this window again" + onClicked: window1.visibility = Window.Minimized; + } + } +} + diff --git a/examples/controls/gallery/content/Controls.qml b/examples/controls/gallery/content/Controls.qml new file mode 100644 index 00000000..b7e46188 --- /dev/null +++ b/examples/controls/gallery/content/Controls.qml @@ -0,0 +1,229 @@ +/**************************************************************************** +** +** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/legal +** +** This file is part of the Qt Quick Controls module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "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. +** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names +** of its 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." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + + + + +import QtQuick 2.2 +import QtQuick.Controls 1.1 +import QtQuick.Layouts 1.1 +import QtQuick.Controls.Styles 1.1 + +Item { + id: flickable + anchors.fill: parent + enabled: enabledCheck.checked + + property int tabPosition: tabPositionGroup.current === r2 ? Qt.BottomEdge : Qt.TopEdge + + RowLayout { + id: contentRow + anchors.fill:parent + anchors.margins: 8 + spacing: 16 + ColumnLayout { + id: firstColumn + Layout.minimumWidth: implicitWidth + Layout.fillWidth: false + RowLayout { + id: buttonrow + Button { + id: button1 + text: "Button 1" + tooltip:"This is an interesting tool tip" + Layout.fillWidth: true + } + Button { + id:button2 + text:"Button 2" + Layout.fillWidth: true + menu: Menu { + MenuItem { text: "This Button" } + MenuItem { text: "Happens To Have" } + MenuItem { text: "A Menu Assigned" } + } + } + } + ComboBox { + id: combo + model: choices + currentIndex: 2 + Layout.fillWidth: true + } + ComboBox { + model: Qt.fontFamilies() + Layout.fillWidth: true + currentIndex: 47 + } + ComboBox { + id: editableCombo + editable: true + model: choices + Layout.fillWidth: true + currentIndex: 2 + onAccepted: { + if (editableCombo.find(currentText) === -1) { + choices.append({text: editText}) + currentIndex = editableCombo.find(editText) + } + } + } + RowLayout { + SpinBox { + id: t1 + Layout.fillWidth: true + minimumValue: -50 + value: -20 + } + SpinBox { + id: t2 + Layout.fillWidth: true + } + } + TextField { + id: t3 + placeholderText: "This is a placeholder for a TextField" + Layout.fillWidth: true + } + ProgressBar { + // normalize value [0.0 .. 1.0] + value: (slider.value - slider.minimumValue) / (slider.maximumValue - slider.minimumValue) + Layout.fillWidth: true + } + ProgressBar { + indeterminate: true + Layout.fillWidth: true + } + Slider { + id: slider + value: 0.5 + Layout.fillWidth: true + tickmarksEnabled: tickmarkCheck.checked + stepSize: tickmarksEnabled ? 0.1 : 0 + } + MouseArea { + id: busyCheck + Layout.fillWidth: true + Layout.fillHeight: true + hoverEnabled:true + Layout.preferredHeight: busyIndicator.height + BusyIndicator { + id: busyIndicator + running: busyCheck.containsMouse + anchors.horizontalCenter: parent.horizontalCenter + } + } + } + ColumnLayout { + id: rightcol + Layout.fillWidth: true + anchors { + top: parent.top + bottom: parent.bottom + } + + GroupBox { + id: group1 + title: "CheckBox" + Layout.fillWidth: true + RowLayout { + Layout.fillWidth: true + CheckBox { + id: frameCheckbox + text: "Text frame" + checked: true + Layout.minimumWidth: 100 + } + CheckBox { + id: tickmarkCheck + text: "Tickmarks" + checked: false + Layout.minimumWidth: 100 + } + CheckBox { + id: wrapCheck + text: "Word wrap" + checked: true + Layout.minimumWidth: 100 + } + } + } + GroupBox { + id: group2 + title:"Tab Position" + Layout.fillWidth: true + RowLayout { + ExclusiveGroup { id: tabPositionGroup } + RadioButton { + id: r1 + text: "Top" + checked: true + exclusiveGroup: tabPositionGroup + Layout.minimumWidth: 100 + } + RadioButton { + id: r2 + text: "Bottom" + exclusiveGroup: tabPositionGroup + Layout.minimumWidth: 100 + } + } + } + + TextArea { + id: area + frameVisible: frameCheckbox.checked + text: loremIpsum + loremIpsum + textFormat: Qt.RichText + wrapMode: wrapCheck.checked ? TextEdit.WordWrap : TextEdit.NoWrap + Layout.fillWidth: true + Layout.fillHeight: true + MouseArea { + id: contextMenu + parent: area.viewport + anchors.fill: parent + acceptedButtons: Qt.RightButton + onPressed: editmenu.popup() + } + } + } + } +} diff --git a/examples/controls/gallery/content/ImageViewer.qml b/examples/controls/gallery/content/ImageViewer.qml new file mode 100644 index 00000000..01f24ab3 --- /dev/null +++ b/examples/controls/gallery/content/ImageViewer.qml @@ -0,0 +1,58 @@ +/**************************************************************************** +** +** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/legal +** +** This file is part of the Qt Quick Controls module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "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. +** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names +** of its 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." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ +import QtQuick 2.2 +import QtQuick.Window 2.1 + +Window { + id: imageViewer + minimumWidth: viewerImage.width + minimumHeight: viewerImage.height + function open(source) { + viewerImage.source = source + width = viewerImage.implicitWidth + 20 + height = viewerImage.implicitHeight + 20 + title = source + visible = true + } + Image { + id: viewerImage + anchors.centerIn: parent + } +} diff --git a/examples/controls/gallery/content/Layouts.qml b/examples/controls/gallery/content/Layouts.qml new file mode 100644 index 00000000..0cb234c3 --- /dev/null +++ b/examples/controls/gallery/content/Layouts.qml @@ -0,0 +1,107 @@ +/**************************************************************************** +** +** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/legal +** +** This file is part of the Qt Quick Controls module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "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. +** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names +** of its 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." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +import QtQuick 2.2 +import QtQuick.Controls 1.1 +import QtQuick.Layouts 1.0 + +Item { + id:root + anchors.fill: parent + anchors.margins: 8 + + ColumnLayout { + id: mainLayout + anchors.fill: parent + spacing: 4 + GroupBox { + id: rowBox + title: "Row layout" + Layout.fillWidth: true + RowLayout { + id: rowLayout + anchors.fill: parent + TextField { + placeholderText: "This wants to grow horizontally" + Layout.fillWidth: true + } + Button { + text: "Button" + } + } + } + + GroupBox { + id: gridBox + title: "Grid layout" + Layout.fillWidth: true + + GridLayout { + id: gridLayout + anchors.fill: parent + rows: 3 + flow: GridLayout.TopToBottom + + Label { text: "Line 1" } + Label { text: "Line 2" } + Label { text: "Line 3" } + + TextField { } + TextField { } + TextField { } + + TextArea { + text: "This widget spans over three rows in the GridLayout.\n" + + "All items in the GridLayout are implicitly positioned from top to bottom." + Layout.rowSpan: 3 + Layout.fillHeight: true + Layout.fillWidth: true + } + } + } + TextArea { + id: t3 + text: "This fills the whole cell" + Layout.minimumHeight: 30 + Layout.fillHeight: true + Layout.fillWidth: true + } + } +} diff --git a/examples/controls/gallery/content/ModelView.qml b/examples/controls/gallery/content/ModelView.qml new file mode 100644 index 00000000..be334458 --- /dev/null +++ b/examples/controls/gallery/content/ModelView.qml @@ -0,0 +1,103 @@ +/**************************************************************************** +** +** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/legal +** +** This file is part of the Qt Quick Controls module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "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. +** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names +** of its 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." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + + + + +import QtQuick 2.2 +import QtQuick.Controls 1.1 +//import QtQuick.XmlListModel 2.1 + +Item { + id: root + width: 600 + height: 300 + anchors.fill: parent + anchors.margins: Qt.platform.os === "osx" ? 12 : 6 + +// XmlListModel { +// id: flickerModel +// source: "http://api.flickr.com/services/feeds/photos_public.gne?format=rss2&tags=" + "Cat" +// query: "/rss/channel/item" +// namespaceDeclarations: "declare namespace media=\"http://search.yahoo.com/mrss/\";" +// XmlRole { name: "title"; query: "title/string()" } +// XmlRole { name: "imagesource"; query: "media:thumbnail/@url/string()" } +// XmlRole { name: "credit"; query: "media:credit/string()" } +// } + + ListModel { + id: dummyModel + Component.onCompleted: { + for (var i = 0 ; i < 100 ; ++i) { + append({"index": i, "title": "A title " + i, "imagesource" :"http://someurl.com", "credit" : "N/A"}) + } + } + } + + TableView{ + model: dummyModel + anchors.fill: parent + + TableViewColumn { + role: "index" + title: "#" + width: 36 + resizable: false + movable: false + } + TableViewColumn { + role: "title" + title: "Title" + width: 120 + } + TableViewColumn { + role: "credit" + title: "Credit" + width: 120 + } + TableViewColumn { + role: "imagesource" + title: "Image source" + width: 200 + visible: true + } + } +} diff --git a/examples/controls/gallery/content/Styles.qml b/examples/controls/gallery/content/Styles.qml new file mode 100644 index 00000000..ed237d82 --- /dev/null +++ b/examples/controls/gallery/content/Styles.qml @@ -0,0 +1,387 @@ +/**************************************************************************** +** +** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/legal +** +** This file is part of the Qt Quick Controls module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "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. +** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names +** of its 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." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + + + + +import QtQuick 2.2 +import QtQuick.Controls 1.1 +import QtQuick.Controls.Styles 1.1 +import QtQuick.Particles 2.0 +import QtQuick.Layouts 1.0 + +Item { + id: root + width: 300 + height: 200 + + property int columnWidth: 120 + GridLayout { + rowSpacing: 12 + columnSpacing: 30 + anchors.top: parent.top + anchors.horizontalCenter: parent.horizontalCenter + anchors.margins: 30 + + Button { + text: "Push me" + style: ButtonStyle { } + implicitWidth: columnWidth + } + Button { + text: "Push me" + style: ButtonStyle { + background: BorderImage { + source: control.pressed ? "../images/button-pressed.png" : "../images/button.png" + border.left: 4 ; border.right: 4 ; border.top: 4 ; border.bottom: 4 + } + } + implicitWidth: columnWidth + } + Button { + text: "Push me" + style: buttonStyle + implicitWidth: columnWidth + } + + TextField { + Layout.row: 1 + style: TextFieldStyle { } + implicitWidth: columnWidth + } + TextField { + style: TextFieldStyle { + background: BorderImage { + source: "../images/textfield.png" + border.left: 4 ; border.right: 4 ; border.top: 4 ; border.bottom: 4 + } + } + implicitWidth: columnWidth + } + TextField { + style: textfieldStyle + implicitWidth: columnWidth + } + + Slider { + id: slider1 + Layout.row: 2 + value: 0.5 + implicitWidth: columnWidth + style: SliderStyle { } + } + Slider { + id: slider2 + value: 0.5 + implicitWidth: columnWidth + style: SliderStyle { + groove: BorderImage { + height: 6 + border.top: 1 + border.bottom: 1 + source: "../images/progress-background.png" + border.left: 6 + border.right: 6 + BorderImage { + anchors.verticalCenter: parent.verticalCenter + source: "../images/progress-fill.png" + border.left: 5 ; border.top: 1 + border.right: 5 ; border.bottom: 1 + width: styleData.handlePosition + height: parent.height + } + } + handle: Item { + width: 13 + height: 13 + Image { + anchors.centerIn: parent + source: "../images/slider-handle.png" + } + } + } + } + Slider { + id: slider3 + value: 0.5 + implicitWidth: columnWidth + style: sliderStyle + } + + ProgressBar { + Layout.row: 3 + value: slider1.value + implicitWidth: columnWidth + style: ProgressBarStyle{ } + } + ProgressBar { + value: slider2.value + implicitWidth: columnWidth + style: progressBarStyle + } + ProgressBar { + value: slider3.value + implicitWidth: columnWidth + style: progressBarStyle2 + } + + CheckBox { + text: "CheckBox" + style: CheckBoxStyle{} + Layout.row: 4 + implicitWidth: columnWidth + } + RadioButton { + style: RadioButtonStyle{} + text: "RadioButton" + implicitWidth: columnWidth + } + + ComboBox { + model: ["Paris", "Oslo", "New York"] + style: ComboBoxStyle{} + implicitWidth: columnWidth + } + + TabView { + Layout.row: 5 + Layout.columnSpan: 3 + Layout.fillWidth: true + implicitHeight: 30 + Tab { title: "One" ; Item {}} + Tab { title: "Two" ; Item {}} + Tab { title: "Three" ; Item {}} + Tab { title: "Four" ; Item {}} + style: TabViewStyle {} + } + + TabView { + Layout.row: 6 + Layout.columnSpan: 3 + Layout.fillWidth: true + implicitHeight: 30 + Tab { title: "One" ; Item {}} + Tab { title: "Two" ; Item {}} + Tab { title: "Three" ; Item {}} + Tab { title: "Four" ; Item {}} + style: tabViewStyle + } + } + + // Style delegates: + + property Component buttonStyle: ButtonStyle { + background: Rectangle { + implicitHeight: 22 + implicitWidth: columnWidth + color: control.pressed ? "darkGray" : control.activeFocus ? "#cdd" : "#ccc" + antialiasing: true + border.color: "gray" + radius: height/2 + Rectangle { + anchors.fill: parent + anchors.margins: 1 + color: "transparent" + antialiasing: true + visible: !control.pressed + border.color: "#aaffffff" + radius: height/2 + } + } + } + + property Component textfieldStyle: TextFieldStyle { + background: Rectangle { + implicitWidth: columnWidth + implicitHeight: 22 + color: "#f0f0f0" + antialiasing: true + border.color: "gray" + radius: height/2 + Rectangle { + anchors.fill: parent + anchors.margins: 1 + color: "transparent" + antialiasing: true + border.color: "#aaffffff" + radius: height/2 + } + } + } + + property Component sliderStyle: SliderStyle { + handle: Rectangle { + width: 18 + height: 18 + color: control.pressed ? "darkGray" : "lightGray" + border.color: "gray" + antialiasing: true + radius: height/2 + Rectangle { + anchors.fill: parent + anchors.margins: 1 + color: "transparent" + antialiasing: true + border.color: "#eee" + radius: height/2 + } + } + + groove: Rectangle { + height: 8 + implicitWidth: columnWidth + implicitHeight: 22 + + antialiasing: true + color: "#ccc" + border.color: "#777" + radius: height/2 + Rectangle { + anchors.fill: parent + anchors.margins: 1 + color: "transparent" + antialiasing: true + border.color: "#66ffffff" + radius: height/2 + } + } + } + + property Component progressBarStyle: ProgressBarStyle { + background: BorderImage { + source: "../images/progress-background.png" + border.left: 2 ; border.right: 2 ; border.top: 2 ; border.bottom: 2 + } + progress: Item { + clip: true + BorderImage { + anchors.fill: parent + anchors.rightMargin: (control.value < control.maximumValue) ? -4 : 0 + source: "../images/progress-fill.png" + border.left: 10 ; border.right: 10 + Rectangle { + width: 1 + color: "#a70" + opacity: 0.8 + anchors.top: parent.top + anchors.bottom: parent.bottom + anchors.bottomMargin: 1 + anchors.right: parent.right + visible: control.value < control.maximumValue + anchors.rightMargin: -parent.anchors.rightMargin + } + } + ParticleSystem{ id: bubbles; running: visible } + ImageParticle{ + id: fireball + system: bubbles + source: "../images/bubble.png" + opacity: 0.7 + } + Emitter{ + system: bubbles + anchors.bottom: parent.bottom + anchors.margins: 4 + anchors.bottomMargin: -4 + anchors.left: parent.left + anchors.right: parent.right + size: 4 + sizeVariation: 4 + acceleration: PointDirection{ y: -6; xVariation: 3 } + emitRate: 6 * control.value + lifeSpan: 3000 + } + } + } + + property Component progressBarStyle2: ProgressBarStyle { + background: Rectangle { + implicitWidth: columnWidth + implicitHeight: 24 + color: "#f0f0f0" + border.color: "gray" + } + progress: Rectangle { + color: "#ccc" + border.color: "gray" + Rectangle { + color: "transparent" + border.color: "#44ffffff" + anchors.fill: parent + anchors.margins: 1 + } + } + } + + property Component tabViewStyle: TabViewStyle { + tabOverlap: 16 + frameOverlap: 4 + tabsMovable: true + + frame: Rectangle { + gradient: Gradient{ + GradientStop { color: "#e5e5e5" ; position: 0 } + GradientStop { color: "#e0e0e0" ; position: 1 } + } + border.color: "#898989" + Rectangle { anchors.fill: parent ; anchors.margins: 1 ; border.color: "white" ; color: "transparent" } + } + tab: Item { + property int totalOverlap: tabOverlap * (control.count - 1) + implicitWidth: Math.min ((styleData.availableWidth + totalOverlap)/control.count - 4, image.sourceSize.width) + implicitHeight: image.sourceSize.height + BorderImage { + id: image + anchors.fill: parent + source: styleData.selected ? "../images/tab_selected.png" : "../images/tab.png" + border.left: 30 + smooth: false + border.right: 30 + } + Text { + text: styleData.title + anchors.centerIn: parent + } + } + leftCorner: Item { implicitWidth: 12 } + } +} + diff --git a/examples/controls/gallery/gallery.go b/examples/controls/gallery/gallery.go new file mode 100644 index 00000000..a16b6b1a --- /dev/null +++ b/examples/controls/gallery/gallery.go @@ -0,0 +1,29 @@ +package main + +import ( + "fmt" + "gopkg.in/qml.v1" + "os" +) + +func main() { + if err := qml.Run(run); err != nil { + fmt.Fprintf(os.Stderr, "error: %v\n", err) + os.Exit(1) + } +} + +func run() error { + engine := qml.NewEngine() + + controls, err := engine.LoadFile("main.qml") + if err != nil { + return err + } + + window := controls.CreateWindow(nil) + + window.Show() + window.Wait() + return nil +} diff --git a/examples/controls/gallery/images/bubble.png b/examples/controls/gallery/images/bubble.png new file mode 100644 index 00000000..62aa1efe Binary files /dev/null and b/examples/controls/gallery/images/bubble.png differ diff --git a/examples/controls/gallery/images/button-pressed.png b/examples/controls/gallery/images/button-pressed.png new file mode 100644 index 00000000..d64cdaa7 Binary files /dev/null and b/examples/controls/gallery/images/button-pressed.png differ diff --git a/examples/controls/gallery/images/button.png b/examples/controls/gallery/images/button.png new file mode 100644 index 00000000..8ab41cc8 Binary files /dev/null and b/examples/controls/gallery/images/button.png differ diff --git a/examples/controls/gallery/images/document-open.png b/examples/controls/gallery/images/document-open.png new file mode 100644 index 00000000..f35f2583 Binary files /dev/null and b/examples/controls/gallery/images/document-open.png differ diff --git a/examples/controls/gallery/images/document-open@2x.png b/examples/controls/gallery/images/document-open@2x.png new file mode 100644 index 00000000..9fdbb665 Binary files /dev/null and b/examples/controls/gallery/images/document-open@2x.png differ diff --git a/examples/controls/gallery/images/document-save-as.png b/examples/controls/gallery/images/document-save-as.png new file mode 100644 index 00000000..5c9f6b34 Binary files /dev/null and b/examples/controls/gallery/images/document-save-as.png differ diff --git a/examples/controls/gallery/images/document-save-as@2x.png b/examples/controls/gallery/images/document-save-as@2x.png new file mode 100644 index 00000000..a15e34c9 Binary files /dev/null and b/examples/controls/gallery/images/document-save-as@2x.png differ diff --git a/examples/controls/gallery/images/folder_new.png b/examples/controls/gallery/images/folder_new.png new file mode 100644 index 00000000..8d8bb9bd Binary files /dev/null and b/examples/controls/gallery/images/folder_new.png differ diff --git a/examples/controls/gallery/images/go-next.png b/examples/controls/gallery/images/go-next.png new file mode 100644 index 00000000..a68e2db7 Binary files /dev/null and b/examples/controls/gallery/images/go-next.png differ diff --git a/examples/controls/gallery/images/go-previous.png b/examples/controls/gallery/images/go-previous.png new file mode 100644 index 00000000..c37bc041 Binary files /dev/null and b/examples/controls/gallery/images/go-previous.png differ diff --git a/examples/controls/gallery/images/preferences-system.png b/examples/controls/gallery/images/preferences-system.png new file mode 100644 index 00000000..6e52db7c Binary files /dev/null and b/examples/controls/gallery/images/preferences-system.png differ diff --git a/examples/controls/gallery/images/process-stop.png b/examples/controls/gallery/images/process-stop.png new file mode 100644 index 00000000..e7a8d172 Binary files /dev/null and b/examples/controls/gallery/images/process-stop.png differ diff --git a/examples/controls/gallery/images/progress-background.png b/examples/controls/gallery/images/progress-background.png new file mode 100644 index 00000000..55a069df Binary files /dev/null and b/examples/controls/gallery/images/progress-background.png differ diff --git a/examples/controls/gallery/images/progress-fill.png b/examples/controls/gallery/images/progress-fill.png new file mode 100644 index 00000000..b588c958 Binary files /dev/null and b/examples/controls/gallery/images/progress-fill.png differ diff --git a/examples/controls/gallery/images/slider-handle.png b/examples/controls/gallery/images/slider-handle.png new file mode 100644 index 00000000..ac4d4a0d Binary files /dev/null and b/examples/controls/gallery/images/slider-handle.png differ diff --git a/examples/controls/gallery/images/tab.png b/examples/controls/gallery/images/tab.png new file mode 100644 index 00000000..74fefab7 Binary files /dev/null and b/examples/controls/gallery/images/tab.png differ diff --git a/examples/controls/gallery/images/tab_selected.png b/examples/controls/gallery/images/tab_selected.png new file mode 100644 index 00000000..665400cc Binary files /dev/null and b/examples/controls/gallery/images/tab_selected.png differ diff --git a/examples/controls/gallery/images/textfield.png b/examples/controls/gallery/images/textfield.png new file mode 100644 index 00000000..1d4a38ab Binary files /dev/null and b/examples/controls/gallery/images/textfield.png differ diff --git a/examples/controls/gallery/images/toplevel_window.png b/examples/controls/gallery/images/toplevel_window.png new file mode 100644 index 00000000..4dc6a8ce Binary files /dev/null and b/examples/controls/gallery/images/toplevel_window.png differ diff --git a/examples/controls/gallery/images/view-refresh.png b/examples/controls/gallery/images/view-refresh.png new file mode 100644 index 00000000..606ea9eb Binary files /dev/null and b/examples/controls/gallery/images/view-refresh.png differ diff --git a/examples/controls/gallery/images/window-new.png b/examples/controls/gallery/images/window-new.png new file mode 100644 index 00000000..e091702e Binary files /dev/null and b/examples/controls/gallery/images/window-new.png differ diff --git a/examples/controls/gallery/images/window-new@2x.png b/examples/controls/gallery/images/window-new@2x.png new file mode 100644 index 00000000..36503018 Binary files /dev/null and b/examples/controls/gallery/images/window-new@2x.png differ diff --git a/examples/controls/gallery/main.qml b/examples/controls/gallery/main.qml new file mode 100644 index 00000000..7250bb31 --- /dev/null +++ b/examples/controls/gallery/main.qml @@ -0,0 +1,266 @@ +/**************************************************************************** +** +** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/legal +** +** This file is part of the Qt Quick Controls module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "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. +** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names +** of its 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." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + + + + +import QtQuick 2.2 +import QtQuick.Controls 1.1 +import QtQuick.Layouts 1.0 +import QtQuick.Dialogs 1.0 +import "content" + +ApplicationWindow { + visible: true + title: "Component Gallery" + + width: 640 + height: 420 + minimumHeight: 400 + minimumWidth: 600 + + property string loremIpsum: + "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor "+ + "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor "+ + "incididunt ut labore et dolore magna aliqua.\n Ut enim ad minim veniam, quis nostrud "+ + "exercitation ullamco laboris nisi ut aliquip ex ea commodo cosnsequat. "; + + ImageViewer { id: imageViewer } + + FileDialog { + id: fileDialog + nameFilters: [ "Image files (*.png *.jpg)" ] + onAccepted: imageViewer.open(fileUrl) + } + + AboutDialog { id: aboutDialog } + + Action { + id: openAction + text: "&Open" + shortcut: StandardKey.Open + iconSource: "images/document-open.png" + onTriggered: fileDialog.open() + tooltip: "Open an image" + } + + Action { + id: copyAction + text: "&Copy" + shortcut: StandardKey.Copy + iconName: "edit-copy" + enabled: (!!activeFocusItem && !!activeFocusItem["copy"]) + onTriggered: activeFocusItem.copy() + } + + Action { + id: cutAction + text: "Cu&t" + shortcut: StandardKey.Cut + iconName: "edit-cut" + enabled: (!!activeFocusItem && !!activeFocusItem["cut"]) + onTriggered: activeFocusItem.cut() + } + + Action { + id: pasteAction + text: "&Paste" + shortcut: StandardKey.Paste + iconName: "edit-paste" + enabled: (!!activeFocusItem && !!activeFocusItem["paste"]) + onTriggered: activeFocusItem.paste() + } + + Action { + id: aboutAction + text: "About" + onTriggered: aboutDialog.open() + } + + ExclusiveGroup { + id: textFormatGroup + + Action { + id: a1 + text: "Align &Left" + checkable: true + Component.onCompleted: checked = true + } + + Action { + id: a2 + text: "&Center" + checkable: true + } + + Action { + id: a3 + text: "Align &Right" + checkable: true + } + } + + ChildWindow { id: window1 } + + Menu { + id: editmenu + MenuItem { action: cutAction } + MenuItem { action: copyAction } + MenuItem { action: pasteAction } + MenuSeparator {} + Menu { + title: "Text &Format" + MenuItem { action: a1 } + MenuItem { action: a2 } + MenuItem { action: a3 } + MenuSeparator { } + MenuItem { text: "Allow &Hyphenation"; checkable: true } + } + Menu { + title: "Font &Style" + MenuItem { text: "&Bold"; checkable: true } + MenuItem { text: "&Italic"; checkable: true } + MenuItem { text: "&Underline"; checkable: true } + } + } + + toolBar: ToolBar { + id: toolbar + RowLayout { + id: toolbarLayout + spacing: 0 + width: parent.width + ToolButton { + iconSource: "images/window-new.png" + onClicked: window1.visible = !window1.visible + Accessible.name: "New window" + tooltip: "Toggle visibility of the second window" + } + ToolButton { action: openAction } + ToolButton { + Accessible.name: "Save as" + iconSource: "images/document-save-as.png" + tooltip: "(Pretend to) Save as..." + } + Item { Layout.fillWidth: true } + CheckBox { + id: enabledCheck + text: "Enabled" + checked: true + } + } + } + + menuBar: MenuBar { + Menu { + title: "&File" + MenuItem { action: openAction } + MenuItem { + text: "Close" + shortcut: StandardKey.Quit + onTriggered: Qt.quit() + } + } + Menu { + title: "&Edit" + MenuItem { action: cutAction } + MenuItem { action: copyAction } + MenuItem { action: pasteAction } + MenuSeparator { } + MenuItem { + text: "Do Nothing" + shortcut: "Ctrl+E,Shift+Ctrl+X" + enabled: false + } + MenuItem { + text: "Not Even There" + shortcut: "Ctrl+E,Shift+Ctrl+Y" + visible: false + } + Menu { + title: "Me Neither" + visible: false + } + } + Menu { + title: "&Help" + MenuItem { action: aboutAction } + } + } + + + SystemPalette {id: syspal} + color: syspal.window + ListModel { + id: choices + ListElement { text: "Banana" } + ListElement { text: "Orange" } + ListElement { text: "Apple" } + ListElement { text: "Coconut" } + } + + TabView { + id:frame + enabled: enabledCheck.checked + tabPosition: controlPage.item ? controlPage.item.tabPosition : Qt.TopEdge + anchors.fill: parent + anchors.margins: Qt.platform.os === "osx" ? 12 : 2 + + Tab { + id: controlPage + title: "Controls" + Controls { } + } + Tab { + title: "Itemviews" + ModelView { } + } + Tab { + title: "Styles" + Styles { anchors.fill: parent } + } + Tab { + title: "Layouts" + Layouts { anchors.fill:parent } + } + } +} + diff --git a/examples/controls/splitview/main.qml b/examples/controls/splitview/main.qml new file mode 100644 index 00000000..d93c74d3 --- /dev/null +++ b/examples/controls/splitview/main.qml @@ -0,0 +1,82 @@ +/**************************************************************************** +** +** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/legal +** +** This file is part of the Qt Quick Controls module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "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. +** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names +** of its 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." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + + + + +import QtQuick 2.2 +import QtQuick.Controls 1.1 +import QtQuick.Layouts 1.0 + +ApplicationWindow { + visible: true + width: 600 + height: 400 + + SplitView { + anchors.fill: parent + + Rectangle { + id: column + width: 200 + Layout.minimumWidth: 100 + Layout.maximumWidth: 300 + color: "lightsteelblue" + } + + SplitView { + orientation: Qt.Vertical + Layout.fillWidth: true + + Rectangle { + id: row1 + height: 200 + color: "lightblue" + Layout.minimumHeight: 1 + } + + Rectangle { + id: row2 + color: "lightgray" + } + } + } +} diff --git a/examples/controls/splitview/splitview.go b/examples/controls/splitview/splitview.go new file mode 100644 index 00000000..a16b6b1a --- /dev/null +++ b/examples/controls/splitview/splitview.go @@ -0,0 +1,29 @@ +package main + +import ( + "fmt" + "gopkg.in/qml.v1" + "os" +) + +func main() { + if err := qml.Run(run); err != nil { + fmt.Fprintf(os.Stderr, "error: %v\n", err) + os.Exit(1) + } +} + +func run() error { + engine := qml.NewEngine() + + controls, err := engine.LoadFile("main.qml") + if err != nil { + return err + } + + window := controls.CreateWindow(nil) + + window.Show() + window.Wait() + return nil +} diff --git a/examples/controls/tableview/images/header.png b/examples/controls/tableview/images/header.png new file mode 100644 index 00000000..dba66460 Binary files /dev/null and b/examples/controls/tableview/images/header.png differ diff --git a/examples/controls/tableview/images/selectedrow.png b/examples/controls/tableview/images/selectedrow.png new file mode 100644 index 00000000..71192ea4 Binary files /dev/null and b/examples/controls/tableview/images/selectedrow.png differ diff --git a/examples/controls/tableview/main.qml b/examples/controls/tableview/main.qml new file mode 100644 index 00000000..9fb36136 --- /dev/null +++ b/examples/controls/tableview/main.qml @@ -0,0 +1,405 @@ +/**************************************************************************** +** +** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/legal +** +** This file is part of the Qt Quick Controls module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "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. +** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names +** of its 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." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + + + + +import QtQuick 2.2 +import QtQuick.Window 2.1 +import QtQuick.Controls 1.1 +import QtQuick.XmlListModel 2.0 + +Window { + visible: true + width: 538 + frame.margins * 2 + height: 360 + frame.margins * 2 + + ToolBar { + id: toolbar + width: parent.width + + ListModel { + id: delegatemenu + ListElement { text: "Shiny delegate" } + ListElement { text: "Scale selected" } + ListElement { text: "Editable items" } + } + + ComboBox { + id: delegateChooser + enabled: frame.currentIndex === 3 ? 1 : 0 + model: delegatemenu + width: 150 + anchors.left: parent.left + anchors.leftMargin: 8 + anchors.verticalCenter: parent.verticalCenter + } + + CheckBox { + id: enabledCheck + text: "Enabled" + checked: true + anchors.right: parent.right + anchors.verticalCenter: parent.verticalCenter + } + } + + SystemPalette {id: syspal} + color: syspal.window + + XmlListModel { + id: flickerModel + source: "http://api.flickr.com/services/feeds/photos_public.gne?format=rss2&tags=" + "Qt" + query: "/rss/channel/item" + namespaceDeclarations: "declare namespace media=\"http://search.yahoo.com/mrss/\";" + XmlRole { name: "title"; query: "title/string()" } + XmlRole { name: "imagesource"; query: "media:thumbnail/@url/string()" } + XmlRole { name: "credit"; query: "media:credit/string()" } + } + + ListModel { + id: nestedModel + ListElement{content: ListElement { description: "Core" ; color:"#ffaacc"}} + ListElement{content: ListElement { description: "Second" ; color:"#ffccaa"}} + ListElement{content: ListElement { description: "Third" ; color:"#ffffaa"}} + } + + ListModel { + id: largeModel + Component.onCompleted: { + for (var i=0 ; i< 500 ; ++i) + largeModel.append({"name":"Person "+i , "age": Math.round(Math.random()*100), "gender": Math.random()>0.5 ? "Male" : "Female"}) + } + } + + Column { + anchors.top: toolbar.bottom + anchors.right: parent.right + anchors.left: parent.left + anchors.bottom: parent.bottom + anchors.margins: 8 + + TabView { + id:frame + focus:true + enabled: enabledCheck.checked + + property int margins: Qt.platform.os === "osx" ? 16 : 0 + + height: parent.height - 34 + anchors.right: parent.right + anchors.left: parent.left + anchors.margins: margins + + Tab { + title: "XmlListModel" + + TableView { + model: flickerModel + anchors.fill: parent + anchors.margins: 12 + + TableViewColumn { + role: "title" + title: "Title" + width: 120 + } + TableViewColumn { + role: "credit" + title: "Credit" + width: 120 + } + TableViewColumn { + role: "imagesource" + title: "Image source" + width: 200 + visible: true + } + + frameVisible: frameCheckbox.checked + headerVisible: headerCheckbox.checked + sortIndicatorVisible: sortableCheckbox.checked + alternatingRowColors: alternateCheckbox.checked + } + } + Tab { + title: "Multivalue" + + TableView { + model: nestedModel + anchors.fill: parent + anchors.margins: 12 + + TableViewColumn { + role: "content" + title: "Text and Color" + width: 220 + } + + itemDelegate: Item { + Rectangle{ + color: styleData.value.get(0).color + anchors.top:parent.top + anchors.right:parent.right + anchors.bottom:parent.bottom + anchors.margins: 4 + width:32 + border.color:"#666" + } + Text { + width: parent.width + anchors.margins: 4 + anchors.left: parent.left + anchors.verticalCenter: parent.verticalCenter + elide: styleData.elideMode + text: styleData.value.get(0).description + color: styleData.textColor + } + } + + frameVisible: frameCheckbox.checked + headerVisible: headerCheckbox.checked + sortIndicatorVisible: sortableCheckbox.checked + alternatingRowColors: alternateCheckbox.checked + } + } + Tab { + title: "Generated" + + TableView { + model: largeModel + anchors.margins: 12 + anchors.fill: parent + TableViewColumn { + role: "name" + title: "Name" + width: 120 + } + TableViewColumn { + role: "age" + title: "Age" + width: 120 + } + TableViewColumn { + role: "gender" + title: "Gender" + width: 120 + } + frameVisible: frameCheckbox.checked + headerVisible: headerCheckbox.checked + sortIndicatorVisible: sortableCheckbox.checked + alternatingRowColors: alternateCheckbox.checked + } + } + + Tab { + title: "Delegates" + Item { + anchors.fill: parent + + Component { + id: delegate1 + Item { + clip: true + Text { + width: parent.width + anchors.margins: 4 + anchors.left: parent.left + anchors.verticalCenter: parent.verticalCenter + elide: styleData.elideMode + text: styleData.value !== undefined ? styleData.value : "" + color: styleData.textColor + } + } + } + + Component { + id: delegate2 + Text { + width: parent.width + anchors.margins: 4 + anchors.left: parent.left + anchors.verticalCenter: parent.verticalCenter + elide: styleData.elideMode + text: styleData.value !== undefined ? styleData.value : "" + color: styleData.textColor + } + } + + Component { + id: editableDelegate + Item { + + Text { + width: parent.width + anchors.margins: 4 + anchors.left: parent.left + anchors.verticalCenter: parent.verticalCenter + elide: styleData.elideMode + text: styleData.value !== undefined ? styleData.value : "" + color: styleData.textColor + visible: !styleData.selected + } + Loader { // Initialize text editor lazily to improve performance + id: loaderEditor + anchors.fill: parent + anchors.margins: 4 + Connections { + target: loaderEditor.item + onAccepted: { + if (typeof styleData.value === 'number') + largeModel.setProperty(styleData.row, styleData.role, Number(parseFloat(loaderEditor.item.text).toFixed(0))) + else + largeModel.setProperty(styleData.row, styleData.role, loaderEditor.item.text) + } + } + sourceComponent: styleData.selected ? editor : null + Component { + id: editor + TextInput { + id: textinput + color: styleData.textColor + text: styleData.value + MouseArea { + id: mouseArea + anchors.fill: parent + hoverEnabled: true + onClicked: textinput.forceActiveFocus() + } + } + } + } + } + } + TableView { + model: largeModel + anchors.margins: 12 + anchors.fill:parent + frameVisible: frameCheckbox.checked + headerVisible: headerCheckbox.checked + sortIndicatorVisible: sortableCheckbox.checked + alternatingRowColors: alternateCheckbox.checked + + TableViewColumn { + role: "name" + title: "Name" + width: 120 + } + TableViewColumn { + role: "age" + title: "Age" + width: 120 + } + TableViewColumn { + role: "gender" + title: "Gender" + width: 120 + } + + headerDelegate: BorderImage{ + source: "images/header.png" + border{left:2;right:2;top:2;bottom:2} + Text { + text: styleData.value + anchors.centerIn:parent + color:"#333" + } + } + + rowDelegate: Rectangle { + height: (delegateChooser.currentIndex == 1 && styleData.selected) ? 30 : 20 + Behavior on height{ NumberAnimation{} } + + color: styleData.selected ? "#448" : (styleData.alternate? "#eee" : "#fff") + BorderImage{ + id: selected + anchors.fill: parent + source: "images/selectedrow.png" + visible: styleData.selected + border{left:2; right:2; top:2; bottom:2} + SequentialAnimation { + running: true; loops: Animation.Infinite + NumberAnimation { target:selected; property: "opacity"; to: 1.0; duration: 900} + NumberAnimation { target:selected; property: "opacity"; to: 0.5; duration: 900} + } + } + } + + itemDelegate: { + if (delegateChooser.currentIndex == 2) + return editableDelegate; + else + return delegate1; + } + } + } + } + } + Row{ + x: 12 + height: 34 + CheckBox{ + id: alternateCheckbox + checked: true + text: "Alternate" + anchors.verticalCenter: parent.verticalCenter + } + CheckBox{ + id: sortableCheckbox + checked: false + text: "Sort indicator" + anchors.verticalCenter: parent.verticalCenter + } + CheckBox{ + id: frameCheckbox + checked: true + text: "Frame" + anchors.verticalCenter: parent.verticalCenter + } + CheckBox{ + id: headerCheckbox + checked: true + text: "Headers" + anchors.verticalCenter: parent.verticalCenter + } + } + } +} diff --git a/examples/controls/tableview/tableview.go b/examples/controls/tableview/tableview.go new file mode 100644 index 00000000..a16b6b1a --- /dev/null +++ b/examples/controls/tableview/tableview.go @@ -0,0 +1,29 @@ +package main + +import ( + "fmt" + "gopkg.in/qml.v1" + "os" +) + +func main() { + if err := qml.Run(run); err != nil { + fmt.Fprintf(os.Stderr, "error: %v\n", err) + os.Exit(1) + } +} + +func run() error { + engine := qml.NewEngine() + + controls, err := engine.LoadFile("main.qml") + if err != nil { + return err + } + + window := controls.CreateWindow(nil) + + window.Show() + window.Wait() + return nil +} diff --git a/examples/controls/touch/content/AndroidDelegate.qml b/examples/controls/touch/content/AndroidDelegate.qml new file mode 100644 index 00000000..21ee8e68 --- /dev/null +++ b/examples/controls/touch/content/AndroidDelegate.qml @@ -0,0 +1,92 @@ +/**************************************************************************** +** +** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/legal +** +** This file is part of the Qt Quick Controls module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "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. +** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names +** of its 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." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + + + + +import QtQuick 2.2 + +Item { + id: root + width: parent.width + height: 88 + + property alias text: textitem.text + signal clicked + + Rectangle { + anchors.fill: parent + color: "#11ffffff" + visible: mouse.pressed + } + + Text { + id: textitem + color: "white" + font.pixelSize: 32 + text: modelData + anchors.verticalCenter: parent.verticalCenter + anchors.left: parent.left + anchors.leftMargin: 30 + } + + Rectangle { + anchors.left: parent.left + anchors.right: parent.right + anchors.margins: 15 + height: 1 + color: "#424246" + } + + Image { + anchors.right: parent.right + anchors.rightMargin: 20 + anchors.verticalCenter: parent.verticalCenter + source: "../images/navigation_next_item.png" + } + + MouseArea { + id: mouse + anchors.fill: parent + onClicked: root.clicked() + + } +} diff --git a/examples/controls/touch/content/ButtonPage.qml b/examples/controls/touch/content/ButtonPage.qml new file mode 100644 index 00000000..6058671c --- /dev/null +++ b/examples/controls/touch/content/ButtonPage.qml @@ -0,0 +1,176 @@ +/**************************************************************************** +** +** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/legal +** +** This file is part of the Qt Quick Controls module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "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. +** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names +** of its 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." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + + + + +import QtQuick 2.2 +import QtQuick.Controls 1.1 +import QtQuick.Controls.Styles 1.1 + +Item { + width: parent.width + height: parent.height + + property real progress: 0 + SequentialAnimation on progress { + loops: Animation.Infinite + running: true + NumberAnimation { + from: 0 + to: 1 + duration: 3000 + } + NumberAnimation { + from: 1 + to: 0 + duration: 3000 + } + } + + Column { + spacing: 40 + anchors.centerIn: parent + + Button { + text: "Press me" + style: touchStyle + } + + Button { + style: touchStyle + text: "Press me too" + } + + Button { + anchors.margins: 20 + style: touchStyle + text: "Don't press me" + onClicked: if (stackView) stackView.pop() + } + + Row { + spacing: 20 + Switch { + style: switchStyle + } + Switch { + style: switchStyle + } + } + + } + + Component { + id: touchStyle + ButtonStyle { + panel: Item { + implicitHeight: 50 + implicitWidth: 320 + BorderImage { + anchors.fill: parent + antialiasing: true + border.bottom: 8 + border.top: 8 + border.left: 8 + border.right: 8 + anchors.margins: control.pressed ? -4 : 0 + source: control.pressed ? "../images/button_pressed.png" : "../images/button_default.png" + Text { + text: control.text + anchors.centerIn: parent + color: "white" + font.pixelSize: 23 + renderType: Text.NativeRendering + } + } + } + } + } + + Component { + id: switchStyle + SwitchStyle { + + groove: Rectangle { + implicitHeight: 50 + implicitWidth: 1.1 + Rectangle { + anchors.top: parent.top + anchors.left: parent.left + anchors.bottom: parent.bottom + width: parent.width/2 - 2 + height: 20 + anchors.margins: 2 + color: control.checked ? "#468bb7" : "#222" + Behavior on color {ColorAnimation {}} + Text { + font.pixelSize: 23 + color: "white" + anchors.centerIn: parent + text: "ON" + } + } + Item { + width: parent.width/2 + height: parent.height + anchors.right: parent.right + Text { + font.pixelSize: 23 + color: "white" + anchors.centerIn: parent + text: "OFF" + } + } + color: "#222" + border.color: "#444" + border.width: 2 + } + handle: Rectangle { + width: parent.parent.width/2 + height: control.height + color: "#444" + border.color: "#555" + border.width: 2 + } + } + } +} diff --git a/examples/controls/touch/content/ListPage.qml b/examples/controls/touch/content/ListPage.qml new file mode 100644 index 00000000..65dc99f5 --- /dev/null +++ b/examples/controls/touch/content/ListPage.qml @@ -0,0 +1,82 @@ +/**************************************************************************** +** +** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/legal +** +** This file is part of the Qt Quick Controls module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "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. +** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names +** of its 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." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + + + + +import QtQuick 2.2 +import QtQuick.Controls 1.1 +import QtQuick.Controls.Styles 1.1 + +ScrollView { + width: parent.width + height: parent.height + + flickableItem.interactive: true + + ListView { + anchors.fill: parent + model: 100 + delegate: AndroidDelegate { + text: "Item #" + modelData + } + } + + style: ScrollViewStyle { + transientScrollBars: true + handle: Item { + implicitWidth: 14 + implicitHeight: 26 + Rectangle { + color: "#424246" + anchors.fill: parent + anchors.topMargin: 6 + anchors.leftMargin: 4 + anchors.rightMargin: 4 + anchors.bottomMargin: 6 + } + } + scrollBarBackground: Item { + implicitWidth: 14 + implicitHeight: 26 + } + } +} diff --git a/examples/controls/touch/content/ProgressBarPage.qml b/examples/controls/touch/content/ProgressBarPage.qml new file mode 100644 index 00000000..019d7206 --- /dev/null +++ b/examples/controls/touch/content/ProgressBarPage.qml @@ -0,0 +1,114 @@ +/**************************************************************************** +** +** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/legal +** +** This file is part of the Qt Quick Controls module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "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. +** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names +** of its 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." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + + + + +import QtQuick 2.2 +import QtQuick.Controls 1.1 +import QtQuick.Controls.Styles 1.1 + +Item { + width: parent.width + height: parent.height + + property real progress: 0 + SequentialAnimation on progress { + loops: Animation.Infinite + running: true + NumberAnimation { + from: 0 + to: 1 + duration: 3000 + } + NumberAnimation { + from: 1 + to: 0 + duration: 3000 + } + } + + Column { + spacing: 40 + anchors.centerIn: parent + + ProgressBar { + anchors.margins: 20 + style: touchStyle + width: 400 + value: progress + } + + ProgressBar { + anchors.margins: 20 + style: touchStyle + width: 400 + value: 1 - progress + } + + ProgressBar { + anchors.margins: 20 + style: touchStyle + value: 1 + width: 400 + } + + } + + Component { + id: touchStyle + ProgressBarStyle { + panel: Rectangle { + implicitHeight: 15 + implicitWidth: 400 + color: "#444" + opacity: 0.8 + Rectangle { + antialiasing: true + radius: 1 + color: "#468bb7" + height: parent.height + width: parent.width * control.value / control.maximumValue + } + } + } + } +} diff --git a/examples/controls/touch/content/SliderPage.qml b/examples/controls/touch/content/SliderPage.qml new file mode 100644 index 00000000..95009e4f --- /dev/null +++ b/examples/controls/touch/content/SliderPage.qml @@ -0,0 +1,106 @@ +/**************************************************************************** +** +** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/legal +** +** This file is part of the Qt Quick Controls module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "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. +** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names +** of its 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." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + + + + +import QtQuick 2.2 +import QtQuick.Controls 1.1 +import QtQuick.Controls.Styles 1.1 + +Item { + width: parent.width + height: parent.height + + Column { + spacing: 12 + anchors.centerIn: parent + + Slider { + anchors.margins: 20 + style: touchStyle + value: 0 + } + Slider { + anchors.margins: 20 + style: touchStyle + value: 0.5 + } + Slider { + anchors.margins: 20 + style: touchStyle + value: 1.0 + } + + } + + Component { + id: touchStyle + SliderStyle { + handle: Rectangle { + width: 30 + height: 30 + radius: height + antialiasing: true + color: Qt.lighter("#468bb7", 1.1) + } + + groove: Item { + implicitHeight: 50 + implicitWidth: 400 + Rectangle { + height: 8 + width: parent.width + anchors.verticalCenter: parent.verticalCenter + color: "#444" + opacity: 0.8 + Rectangle { + antialiasing: true + radius: 1 + color: "#468bb7" + height: parent.height + width: parent.width * control.value / control.maximumValue + } + } + } + } + } +} diff --git a/examples/controls/touch/content/TabBarPage.qml b/examples/controls/touch/content/TabBarPage.qml new file mode 100644 index 00000000..c9bebccd --- /dev/null +++ b/examples/controls/touch/content/TabBarPage.qml @@ -0,0 +1,102 @@ +/**************************************************************************** +** +** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/legal +** +** This file is part of the Qt Quick Controls module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "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. +** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names +** of its 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." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + + + + +import QtQuick 2.2 +import QtQuick.Controls 1.1 +import QtQuick.Controls.Styles 1.1 + +Item { + width: parent.width + height: parent.height + + TabView { + anchors.fill: parent + style: touchStyle + Tab { + title: "Buttons" + ButtonPage{ visible: true } + } + Tab { + title: "Sliders" + SliderPage{ visible: true } + } + Tab { + title: "Progress" + ProgressBarPage{ visible: true } + } + } + + Component { + id: touchStyle + TabViewStyle { + tabsAlignment: Qt.AlignVCenter + tabOverlap: 0 + frame: Item { } + tab: Item { + implicitWidth: control.width/control.count + implicitHeight: 50 + BorderImage { + anchors.fill: parent + border.bottom: 8 + border.top: 8 + source: styleData.selected ? "../images/tab_selected.png":"../images/tabs_standard.png" + Text { + anchors.centerIn: parent + color: "white" + text: styleData.title.toUpperCase() + font.pixelSize: 16 + } + Rectangle { + visible: index > 0 + anchors.top: parent.top + anchors.bottom: parent.bottom + anchors.margins: 10 + width:1 + color: "#3a3a3a" + } + } + } + } + } +} diff --git a/examples/controls/touch/content/TextInputPage.qml b/examples/controls/touch/content/TextInputPage.qml new file mode 100644 index 00000000..0eeea03a --- /dev/null +++ b/examples/controls/touch/content/TextInputPage.qml @@ -0,0 +1,106 @@ +/**************************************************************************** +** +** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/legal +** +** This file is part of the Qt Quick Controls module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "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. +** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names +** of its 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." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + + + + +import QtQuick 2.2 +import QtQuick.Controls 1.1 +import QtQuick.Controls.Styles 1.1 + +Item { + width: parent.width + height: parent.height + + property real progress: 0 + SequentialAnimation on progress { + loops: Animation.Infinite + running: true + NumberAnimation { + from: 0 + to: 1 + duration: 3000 + } + NumberAnimation { + from: 1 + to: 0 + duration: 3000 + } + } + + Column { + spacing: 40 + anchors.centerIn: parent + + TextField { + anchors.margins: 20 + text: "Text input" + style: touchStyle + } + + TextField { + anchors.margins: 20 + text: "Readonly Text input" + style: touchStyle + readOnly: true + } + } + Component { + id: touchStyle + + TextFieldStyle { + textColor: "white" + font.pixelSize: 28 + background: Item { + implicitHeight: 50 + implicitWidth: 320 + BorderImage { + source: "../images/textinput.png" + border.left: 8 + border.right: 8 + anchors.bottom: parent.bottom + anchors.left: parent.left + anchors.right: parent.right + } + } + } + } +} diff --git a/examples/controls/touch/images/NOTICE.txt b/examples/controls/touch/images/NOTICE.txt new file mode 100644 index 00000000..93a9afc8 --- /dev/null +++ b/examples/controls/touch/images/NOTICE.txt @@ -0,0 +1,2 @@ +Notice some of these images are derived from Google applications resources. They were provided under the following license: +You may use the materials in this directory without restriction to develop your apps and to use in your apps. diff --git a/examples/controls/touch/images/button_default.png b/examples/controls/touch/images/button_default.png new file mode 100644 index 00000000..6d6cfd9a Binary files /dev/null and b/examples/controls/touch/images/button_default.png differ diff --git a/examples/controls/touch/images/button_pressed.png b/examples/controls/touch/images/button_pressed.png new file mode 100644 index 00000000..ab78b6ea Binary files /dev/null and b/examples/controls/touch/images/button_pressed.png differ diff --git a/examples/controls/touch/images/navigation_next_item.png b/examples/controls/touch/images/navigation_next_item.png new file mode 100644 index 00000000..6665c9d8 Binary files /dev/null and b/examples/controls/touch/images/navigation_next_item.png differ diff --git a/examples/controls/touch/images/navigation_previous_item.png b/examples/controls/touch/images/navigation_previous_item.png new file mode 100644 index 00000000..f8be0119 Binary files /dev/null and b/examples/controls/touch/images/navigation_previous_item.png differ diff --git a/examples/controls/touch/images/tab_selected.png b/examples/controls/touch/images/tab_selected.png new file mode 100644 index 00000000..2345f7a8 Binary files /dev/null and b/examples/controls/touch/images/tab_selected.png differ diff --git a/examples/controls/touch/images/tabs_standard.png b/examples/controls/touch/images/tabs_standard.png new file mode 100644 index 00000000..7140ab7b Binary files /dev/null and b/examples/controls/touch/images/tabs_standard.png differ diff --git a/examples/controls/touch/images/textinput.png b/examples/controls/touch/images/textinput.png new file mode 100644 index 00000000..b0256db2 Binary files /dev/null and b/examples/controls/touch/images/textinput.png differ diff --git a/examples/controls/touch/images/toolbar.png b/examples/controls/touch/images/toolbar.png new file mode 100644 index 00000000..e9eba4c7 Binary files /dev/null and b/examples/controls/touch/images/toolbar.png differ diff --git a/examples/controls/touch/main.qml b/examples/controls/touch/main.qml new file mode 100644 index 00000000..c794f7dc --- /dev/null +++ b/examples/controls/touch/main.qml @@ -0,0 +1,147 @@ +/**************************************************************************** +** +** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/legal +** +** This file is part of the Qt Quick Controls module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "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. +** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names +** of its 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." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +import QtQuick 2.2 +import QtQuick.Controls 1.1 +import "content" + +ApplicationWindow { + visible: true + width: 800 + height: 1280 + + Rectangle { + color: "#212126" + anchors.fill: parent + } + + toolBar: BorderImage { + border.bottom: 8 + source: "images/toolbar.png" + width: parent.width + height: 100 + + Rectangle { + id: backButton + width: opacity ? 60 : 0 + anchors.left: parent.left + anchors.leftMargin: 20 + opacity: stackView.depth > 1 ? 1 : 0 + anchors.verticalCenter: parent.verticalCenter + antialiasing: true + height: 60 + radius: 4 + color: backmouse.pressed ? "#222" : "transparent" + Behavior on opacity { NumberAnimation{} } + Image { + anchors.verticalCenter: parent.verticalCenter + source: "images/navigation_previous_item.png" + } + MouseArea { + id: backmouse + anchors.fill: parent + anchors.margins: -10 + onClicked: stackView.pop() + } + } + + Text { + font.pixelSize: 42 + Behavior on x { NumberAnimation{ easing.type: Easing.OutCubic} } + x: backButton.x + backButton.width + 20 + anchors.verticalCenter: parent.verticalCenter + color: "white" + text: "Widget Gallery" + } + } + + ListModel { + id: pageModel + ListElement { + title: "Buttons" + page: "content/ButtonPage.qml" + } + ListElement { + title: "Sliders" + page: "content/SliderPage.qml" + } + ListElement { + title: "ProgressBar" + page: "content/ProgressBarPage.qml" + } + ListElement { + title: "Tabs" + page: "content/TabBarPage.qml" + } + ListElement { + title: "TextInput" + page: "content/TextInputPage.qml" + } + ListElement { + title: "List" + page: "content/ListPage.qml" + } + } + + StackView { + id: stackView + anchors.fill: parent + // Implements back key navigation + focus: true + Keys.onReleased: if (event.key === Qt.Key_Back && stackView.depth > 1) { + stackView.pop(); + event.accepted = true; + } + + initialItem: Item { + width: parent.width + height: parent.height + ListView { + model: pageModel + anchors.fill: parent + delegate: AndroidDelegate { + text: title + onClicked: stackView.push(Qt.resolvedUrl(page)) + } + } + } + } + +} diff --git a/examples/controls/touch/touch.go b/examples/controls/touch/touch.go new file mode 100644 index 00000000..a16b6b1a --- /dev/null +++ b/examples/controls/touch/touch.go @@ -0,0 +1,29 @@ +package main + +import ( + "fmt" + "gopkg.in/qml.v1" + "os" +) + +func main() { + if err := qml.Run(run); err != nil { + fmt.Fprintf(os.Stderr, "error: %v\n", err) + os.Exit(1) + } +} + +func run() error { + engine := qml.NewEngine() + + controls, err := engine.LoadFile("main.qml") + if err != nil { + return err + } + + window := controls.CreateWindow(nil) + + window.Show() + window.Wait() + return nil +} diff --git a/examples/customtype/customtype.go b/examples/customtype/customtype.go new file mode 100644 index 00000000..1433d6ed --- /dev/null +++ b/examples/customtype/customtype.go @@ -0,0 +1,48 @@ +package main + +import ( + "fmt" + "os" + + "gopkg.in/qml.v1" +) + +func main() { + if err := qml.Run(run); err != nil { + fmt.Fprintf(os.Stderr, "error: %v\n", err) + os.Exit(1) + } +} + +type GoType struct { + Text string +} + +func (v *GoType) SetText(text string) { + fmt.Println("Text changing to:", text) + v.Text = text +} + +type GoSingleton struct { + Event string +} + +func run() error { + qml.RegisterTypes("GoExtensions", 1, 0, []qml.TypeSpec{{ + Init: func(v *GoType, obj qml.Object) {}, + }, { + Init: func(v *GoSingleton, obj qml.Object) { v.Event = "birthday" }, + + Singleton: true, + }}) + + engine := qml.NewEngine() + component, err := engine.LoadFile("customtype.qml") + if err != nil { + return err + } + + value := component.Create(nil) + fmt.Println("Text is:", value.Interface().(*GoType).Text) + return nil +} diff --git a/examples/customtype/customtype.qml b/examples/customtype/customtype.qml new file mode 100644 index 00000000..54f7aa04 --- /dev/null +++ b/examples/customtype/customtype.qml @@ -0,0 +1,5 @@ +import GoExtensions 1.0 + +GoType { + text: "Happy " + GoSingleton.event + ", Go!" +} diff --git a/examples/gopher/gopher b/examples/gopher/gopher new file mode 100755 index 00000000..12753a1c Binary files /dev/null and b/examples/gopher/gopher differ diff --git a/examples/gopher/gopher.go b/examples/gopher/gopher.go new file mode 100644 index 00000000..13f3509b --- /dev/null +++ b/examples/gopher/gopher.go @@ -0,0 +1,117 @@ +package main + +import ( + "fmt" + "github.com/SjB/qml" + "github.com/SjB/qml/gl/2.0" + "os" +) + +var filename = "gopher.qml" + +func main() { + if len(os.Args) == 2 { + filename = os.Args[1] + } + if err := qml.Run(run); err != nil { + fmt.Fprintf(os.Stderr, "error: %v\n", err) + os.Exit(1) + } +} + +func run() error { + engine := qml.NewEngine() + + model, err := Read("model/gopher.obj") + if err != nil { + return err + } + + qml.RegisterTypes("GoExtensions", 1, 0, []qml.TypeSpec{{ + Init: func(g *Gopher, obj qml.Object) { + g.Object = obj + g.model = model + }, + }}) + + component, err := engine.LoadFile(filename) + if err != nil { + return err + } + + win := component.CreateWindow(nil) + win.Set("x", 560) + win.Set("y", 320) + win.Show() + win.Wait() + return nil +} + +type Gopher struct { + qml.Object + + model map[string]*Object + + Rotation int +} + +func (r *Gopher) SetRotation(rotation int) { + r.Rotation = rotation + r.Call("update") +} + +func (r *Gopher) Paint(p *qml.Painter) { + gl := GL.API(p) + + width := float32(r.Int("width")) + + gl.Enable(GL.BLEND) + gl.BlendFunc(GL.SRC_ALPHA, GL.ONE_MINUS_SRC_ALPHA) + + gl.ShadeModel(GL.SMOOTH) + gl.Enable(GL.DEPTH_TEST) + gl.DepthMask(true) + gl.Enable(GL.NORMALIZE) + + gl.Clear(GL.DEPTH_BUFFER_BIT) + + gl.Scalef(width/3, width/3, width/3) + + lka := []float32{0.3, 0.3, 0.3, 1.0} + lkd := []float32{1.0, 1.0, 1.0, 0.0} + lks := []float32{1.0, 1.0, 1.0, 1.0} + lpos := []float32{-2, 6, 3, 1.0} + + gl.Enable(GL.LIGHTING) + gl.Lightfv(GL.LIGHT0, GL.AMBIENT, lka) + gl.Lightfv(GL.LIGHT0, GL.DIFFUSE, lkd) + gl.Lightfv(GL.LIGHT0, GL.SPECULAR, lks) + gl.Lightfv(GL.LIGHT0, GL.POSITION, lpos) + gl.Enable(GL.LIGHT0) + + gl.EnableClientState(GL.NORMAL_ARRAY) + gl.EnableClientState(GL.VERTEX_ARRAY) + + gl.Translatef(1.5, 1.5, 0) + gl.Rotatef(-90, 0, 0, 1) + gl.Rotatef(float32(90+((36000+r.Rotation)%360)), 1, 0, 0) + + gl.Disable(GL.COLOR_MATERIAL) + + for _, obj := range r.model { + for _, group := range obj.Groups { + gl.Materialfv(GL.FRONT, GL.AMBIENT, group.Material.Ambient) + gl.Materialfv(GL.FRONT, GL.DIFFUSE, group.Material.Diffuse) + gl.Materialfv(GL.FRONT, GL.SPECULAR, group.Material.Specular) + gl.Materialf(GL.FRONT, GL.SHININESS, group.Material.Shininess) + gl.VertexPointer(3, GL.FLOAT, 0, group.Vertexes) + gl.NormalPointer(GL.FLOAT, 0, group.Normals) + gl.DrawArrays(GL.TRIANGLES, 0, len(group.Vertexes)/3) + } + } + + gl.Enable(GL.COLOR_MATERIAL) + + gl.DisableClientState(GL.NORMAL_ARRAY) + gl.DisableClientState(GL.VERTEX_ARRAY) +} diff --git a/examples/gopher/gopher.qml b/examples/gopher/gopher.qml new file mode 100644 index 00000000..1f4be6dd --- /dev/null +++ b/examples/gopher/gopher.qml @@ -0,0 +1,42 @@ +import QtQuick 2.0 +import GoExtensions 1.0 + +Rectangle { + width: 640; height: 400 + color: "black" + + Gopher { + id: gopher + width: 300; height: 300 + anchors.centerIn: parent + + NumberAnimation on rotation { + id: anim + from: 360; to: 0 + duration: 5000 + loops: Animation.Infinite + } + + MouseArea { + anchors.fill: parent + + property real startX + property real startR + + onPressed: { + startX = mouse.x + startR = gopher.rotation + anim.running = false + } + onReleased: { + anim.from = gopher.rotation + 360 + anim.to = gopher.rotation + anim.running = true + } + onPositionChanged: { + gopher.rotation = (36000 + (startR - (mouse.x - startX))) % 360 + } + } + + } +} diff --git a/examples/gopher/mix.qml b/examples/gopher/mix.qml new file mode 100644 index 00000000..0a9541ff --- /dev/null +++ b/examples/gopher/mix.qml @@ -0,0 +1,68 @@ +import QtQuick 2.0 +import GoExtensions 1.0 + +Rectangle { + id: root + + width: 640 + height: 220 + color: "black" + + Rectangle { + x: 20; y: 20; width: 100; height: 100 + color: "red" + + SequentialAnimation on x { + loops: Animation.Infinite + NumberAnimation { from: 20; to: 120; duration: 4000; easing.type: Easing.InOutQuad } + NumberAnimation { from: 120; to: 20; duration: 4000; easing.type: Easing.InOutQuad } + } + } + + Rectangle { + x: 40; y: 40; width: 100; height: 100 + color: "yellow" + opacity: 0.7 + + SequentialAnimation on x { + loops: Animation.Infinite + NumberAnimation { from: 40; to: 220; duration: 4000; easing.type: Easing.InOutQuad } + NumberAnimation { from: 220; to: 40; duration: 4000; easing.type: Easing.InOutQuad } + } + } + + Gopher { + id: gopher + + x: 60; y: 60; width: 100; height: 100 + + SequentialAnimation on x { + loops: Animation.Infinite + NumberAnimation { from: 60; to: 320; duration: 4000; easing.type: Easing.InOutQuad } + NumberAnimation { from: 320; to: 60; duration: 4000; easing.type: Easing.InOutQuad } + } + } + + Rectangle { + x: 80; y: 80; width: 100; height: 100 + color: "yellow" + opacity: 0.7 + + SequentialAnimation on x { + loops: Animation.Infinite + NumberAnimation { from: 80; to: 420; duration: 4000; easing.type: Easing.InOutQuad } + NumberAnimation { from: 420; to: 80; duration: 4000; easing.type: Easing.InOutQuad } + } + } + + Rectangle { + x: 100; y: 100; width: 100; height: 100 + color: "red" + + SequentialAnimation on x { + loops: Animation.Infinite + NumberAnimation { from: 100; to: 520; duration: 4000; easing.type: Easing.InOutQuad } + NumberAnimation { from: 520; to: 100; duration: 4000; easing.type: Easing.InOutQuad } + } + } +} diff --git a/examples/gopher/model/README.md b/examples/gopher/model/README.md new file mode 100644 index 00000000..77af7291 --- /dev/null +++ b/examples/gopher/model/README.md @@ -0,0 +1,10 @@ + +Author +------ + + * https://github.com/golang-samples/gopher-3d + +License +------- + + * http://creativecommons.org/licenses/by/3.0/deed.en diff --git a/examples/gopher/model/gopher.blend b/examples/gopher/model/gopher.blend new file mode 100644 index 00000000..89c92b0d Binary files /dev/null and b/examples/gopher/model/gopher.blend differ diff --git a/examples/gopher/model/gopher.mtl b/examples/gopher/model/gopher.mtl new file mode 100644 index 00000000..532f5dc6 --- /dev/null +++ b/examples/gopher/model/gopher.mtl @@ -0,0 +1,65 @@ +# Blender MTL File: 'gopher.blend' +# Material Count: 7 + +newmtl Body +Ns 96.078431 +Ka 0.000000 0.000000 0.000000 +Kd 0.000000 0.429367 0.640000 +Ks 0.500000 0.500000 0.500000 +Ni 1.000000 +d 1.000000 +illum 2 + +newmtl Eye-White +Ns 96.078431 +Ka 0.000000 0.000000 0.000000 +Kd 0.800000 0.800000 0.800000 +Ks 1.000000 1.000000 1.000000 +Ni 1.000000 +d 1.000000 +illum 2 + +newmtl Material +Ns 96.078431 +Ka 0.000000 0.000000 0.000000 +Kd 0.640000 0.640000 0.640000 +Ks 0.500000 0.500000 0.500000 +Ni 1.000000 +d 1.000000 +illum 2 + +newmtl Material.001 +Ns 96.078431 +Ka 0.000000 0.000000 0.000000 +Kd 0.000000 0.000000 0.000000 +Ks 0.000000 0.000000 0.000000 +Ni 1.000000 +d 1.000000 +illum 2 + +newmtl NoseTop +Ns 96.078431 +Ka 0.000000 0.000000 0.000000 +Kd 0.000000 0.000000 0.000000 +Ks 0.000000 0.000000 0.000000 +Ni 1.000000 +d 1.000000 +illum 2 + +newmtl SkinColor +Ns 96.078431 +Ka 0.000000 0.000000 0.000000 +Kd 0.609017 0.353452 0.144174 +Ks 0.500000 0.500000 0.500000 +Ni 1.000000 +d 1.000000 +illum 2 + +newmtl Tooth +Ns 96.078431 +Ka 0.000000 0.000000 0.000000 +Kd 0.640000 0.640000 0.640000 +Ks 0.500000 0.500000 0.500000 +Ni 1.000000 +d 1.000000 +illum 2 diff --git a/examples/gopher/model/gopher.obj b/examples/gopher/model/gopher.obj new file mode 100644 index 00000000..478a52be --- /dev/null +++ b/examples/gopher/model/gopher.obj @@ -0,0 +1,31375 @@ +# Blender v2.68 (sub 0) OBJ File: 'gopher.blend' +# www.blender.org +mtllib gopher.mtl +o Tail_Sphere.015 +v 0.836333 -0.874988 0.092526 +v 0.823645 -0.873627 0.085005 +v 0.812676 -0.872312 0.074263 +v 0.803848 -0.871095 0.060713 +v 0.796247 -0.876140 0.053739 +v 0.789379 -0.876140 0.037016 +v 0.785150 -0.876140 0.018871 +v 0.783722 -0.876140 -0.000000 +v 0.785150 -0.876140 -0.018871 +v 0.789379 -0.876140 -0.037016 +v 0.796247 -0.876140 -0.053739 +v 0.805489 -0.876140 -0.068397 +v 0.816750 -0.876140 -0.080426 +v 0.829598 -0.876140 -0.089365 +v 0.843539 -0.876140 -0.094869 +v 0.836872 -0.867136 0.092646 +v 0.824701 -0.858223 0.085240 +v 0.814209 -0.849949 0.074605 +v 0.805800 -0.842633 0.061148 +v 0.797434 -0.842508 0.053739 +v 0.790698 -0.838771 0.037016 +v 0.786551 -0.836469 0.018871 +v 0.785150 -0.835692 -0.000000 +v 0.786551 -0.836469 -0.018871 +v 0.790698 -0.838770 -0.037016 +v 0.797434 -0.842508 -0.053739 +v 0.806498 -0.847539 -0.068397 +v 0.817543 -0.853668 -0.080426 +v 0.830145 -0.860661 -0.089365 +v 0.843818 -0.868249 -0.094869 +v 0.837938 -0.859636 0.092845 +v 0.826792 -0.843511 0.085631 +v 0.817245 -0.828592 0.075171 +v 0.809664 -0.815450 0.061869 +v 0.800950 -0.810169 0.053739 +v 0.794605 -0.802837 0.037016 +v 0.790698 -0.798322 0.018871 +v 0.789379 -0.796797 -0.000000 +v 0.790698 -0.798322 -0.018871 +v 0.794605 -0.802837 -0.037016 +v 0.800950 -0.810169 -0.053739 +v 0.809489 -0.820036 -0.068397 +v 0.819893 -0.832060 -0.080426 +v 0.831763 -0.845777 -0.089365 +v 0.844643 -0.860661 -0.094869 +v 0.839491 -0.852777 0.093115 +v 0.829838 -0.830057 0.086161 +v 0.821667 -0.809059 0.075942 +v 0.815293 -0.790590 0.062850 +v 0.806660 -0.780365 0.053739 +v 0.800950 -0.769721 0.037016 +v 0.797434 -0.763166 0.018871 +v 0.796247 -0.760952 -0.000000 +v 0.797434 -0.763166 -0.018871 +v 0.800950 -0.769721 -0.037016 +v 0.806660 -0.780365 -0.053739 +v 0.814345 -0.794690 -0.068397 +v 0.823708 -0.812145 -0.080426 +v 0.834391 -0.832060 -0.089365 +v 0.845982 -0.853668 -0.094869 +v 0.841471 -0.846823 0.093447 +v 0.833722 -0.818378 0.086812 +v 0.827306 -0.792103 0.076886 +v 0.822469 -0.769009 0.064052 +v 0.814345 -0.754242 0.053739 +v 0.809489 -0.740694 0.037016 +v 0.806498 -0.732351 0.018871 +v 0.805489 -0.729534 -0.000000 +v 0.806498 -0.732351 -0.018871 +v 0.809489 -0.740694 -0.037016 +v 0.814345 -0.754242 -0.053739 +v 0.820880 -0.772474 -0.068397 +v 0.828843 -0.794690 -0.080426 +v 0.837928 -0.820036 -0.089365 +v 0.847785 -0.847539 -0.094869 +v 0.843802 -0.842002 0.093827 +v 0.838294 -0.808922 0.087557 +v 0.833943 -0.778375 0.077968 +v 0.830917 -0.751536 0.065429 +v 0.823708 -0.732803 0.053739 +v 0.819893 -0.716872 0.037016 +v 0.817543 -0.707062 0.018871 +v 0.816750 -0.703750 0.000000 +v 0.817543 -0.707062 -0.018871 +v 0.819893 -0.716872 -0.037016 +v 0.823708 -0.732803 -0.053739 +v 0.828843 -0.754242 -0.068397 +v 0.835099 -0.780365 -0.080426 +v 0.842237 -0.810169 -0.089365 +v 0.849982 -0.842508 -0.094869 +v 0.846394 -0.838500 0.094241 +v 0.843379 -0.802052 0.088369 +v 0.841325 -0.768402 0.079147 +v 0.840312 -0.738843 0.066929 +v 0.834391 -0.716872 0.053739 +v 0.831763 -0.699171 0.037016 +v 0.830145 -0.688271 0.018871 +v 0.829598 -0.684590 0.000000 +v 0.830145 -0.688271 -0.018871 +v 0.831763 -0.699171 -0.037016 +v 0.834391 -0.716872 -0.053739 +v 0.837928 -0.740694 -0.068397 +v 0.842237 -0.769721 -0.080426 +v 0.847154 -0.802837 -0.089365 +v 0.852489 -0.838770 -0.094869 +v 0.849148 -0.836451 0.094672 +v 0.848781 -0.798033 0.089215 +v 0.849168 -0.762567 0.080376 +v 0.850294 -0.731417 0.068493 +v 0.845982 -0.707062 0.053739 +v 0.844643 -0.688271 0.037016 +v 0.843818 -0.676699 0.018871 +v 0.843539 -0.672792 0.000000 +v 0.843818 -0.676699 -0.018871 +v 0.844643 -0.688271 -0.037016 +v 0.845982 -0.707062 -0.053739 +v 0.847785 -0.732351 -0.068397 +v 0.849982 -0.763166 -0.080426 +v 0.852489 -0.798322 -0.089365 +v 0.855209 -0.836469 -0.094869 +v 0.851958 -0.835934 0.095105 +v 0.854293 -0.797019 0.090064 +v 0.857170 -0.761096 0.081608 +v 0.860479 -0.729544 0.070062 +v 0.858037 -0.703750 0.053739 +v 0.858037 -0.684590 0.037016 +v 0.858037 -0.672792 0.018871 +v 0.858037 -0.668808 0.000000 +v 0.858037 -0.672792 -0.018871 +v 0.858037 -0.684590 -0.037016 +v 0.858037 -0.703750 -0.053739 +v 0.858037 -0.729534 -0.068397 +v 0.858037 -0.760952 -0.080426 +v 0.858037 -0.796797 -0.089365 +v 0.858037 -0.835691 -0.094869 +v 0.854716 -0.836969 0.095522 +v 0.859703 -0.799050 0.090883 +v 0.865024 -0.764043 0.082797 +v 0.870475 -0.733295 0.071575 +v 0.870092 -0.707062 0.053739 +v 0.871432 -0.688271 0.037016 +v 0.872257 -0.676699 0.018871 +v 0.872535 -0.672792 0.000000 +v 0.872257 -0.676699 -0.018871 +v 0.871432 -0.688271 -0.037016 +v 0.870092 -0.707062 -0.053739 +v 0.868289 -0.732351 -0.068397 +v 0.866092 -0.763166 -0.080426 +v 0.863585 -0.798322 -0.089365 +v 0.860866 -0.836469 -0.094869 +v 0.857315 -0.839517 0.095908 +v 0.864802 -0.804046 0.091640 +v 0.872427 -0.771297 0.083896 +v 0.879898 -0.742528 0.072974 +v 0.881683 -0.716872 0.053739 +v 0.884311 -0.699171 0.037016 +v 0.885930 -0.688271 0.018871 +v 0.886476 -0.684590 0.000000 +v 0.885930 -0.688271 -0.018871 +v 0.884311 -0.699171 -0.037016 +v 0.881683 -0.716872 -0.053739 +v 0.878147 -0.740694 -0.068397 +v 0.873837 -0.769721 -0.080426 +v 0.868920 -0.802837 -0.089365 +v 0.863585 -0.838770 -0.094869 +v 0.859657 -0.843478 0.096248 +v 0.869396 -0.811817 0.092306 +v 0.879096 -0.782578 0.084863 +v 0.888386 -0.756886 0.074205 +v 0.892366 -0.732803 0.053739 +v 0.896182 -0.716872 0.037016 +v 0.898531 -0.707062 0.018871 +v 0.899324 -0.703750 0.000000 +v 0.898531 -0.707062 -0.018871 +v 0.896182 -0.716872 -0.037016 +v 0.892366 -0.732803 -0.053739 +v 0.887232 -0.754242 -0.068397 +v 0.880975 -0.780365 -0.080426 +v 0.873837 -0.810169 -0.089365 +v 0.866092 -0.842508 -0.094869 +v 0.861651 -0.848701 0.096528 +v 0.873307 -0.822063 0.092857 +v 0.884775 -0.797453 0.085662 +v 0.895613 -0.775818 0.075221 +v 0.901730 -0.754242 0.053739 +v 0.906586 -0.740694 0.037016 +v 0.909576 -0.732351 0.018871 +v 0.910586 -0.729534 -0.000000 +v 0.909576 -0.732351 -0.018871 +v 0.906586 -0.740694 -0.037016 +v 0.901730 -0.754242 -0.053739 +v 0.895195 -0.772474 -0.068397 +v 0.887232 -0.794690 -0.080426 +v 0.878147 -0.820036 -0.089365 +v 0.868289 -0.847539 -0.094869 +v 0.863221 -0.854986 0.096739 +v 0.876386 -0.834390 0.093269 +v 0.889244 -0.815350 0.086261 +v 0.901301 -0.798597 0.075984 +v 0.909414 -0.780365 0.053739 +v 0.915124 -0.769721 0.037016 +v 0.918640 -0.763166 0.018871 +v 0.919828 -0.760953 -0.000000 +v 0.918640 -0.763166 -0.018871 +v 0.915124 -0.769721 -0.037016 +v 0.909414 -0.780365 -0.053739 +v 0.901730 -0.794690 -0.068397 +v 0.892366 -0.812145 -0.080426 +v 0.881683 -0.832060 -0.089365 +v 0.870092 -0.853668 -0.094869 +v 0.864305 -0.862090 0.096871 +v 0.878513 -0.848326 0.093528 +v 0.892332 -0.835581 0.086637 +v 0.905232 -0.824346 0.076463 +v 0.915124 -0.810169 0.053739 +v 0.921469 -0.802837 0.037016 +v 0.925376 -0.798322 0.018871 +v 0.926695 -0.796798 -0.000000 +v 0.925376 -0.798322 -0.018871 +v 0.921469 -0.802837 -0.037016 +v 0.915124 -0.810169 -0.053739 +v 0.906586 -0.820036 -0.068397 +v 0.896182 -0.832060 -0.080426 +v 0.884311 -0.845777 -0.089365 +v 0.871432 -0.860661 -0.094869 +v 0.864863 -0.869741 0.096920 +v 0.879607 -0.863334 0.093624 +v 0.893921 -0.857370 0.086777 +v 0.907254 -0.852077 0.076640 +v 0.918640 -0.842508 0.053739 +v 0.925376 -0.838771 0.037016 +v 0.929524 -0.836469 0.018871 +v 0.930924 -0.835692 -0.000000 +v 0.929524 -0.836469 -0.018871 +v 0.925376 -0.838771 -0.037016 +v 0.918640 -0.842508 -0.053739 +v 0.909576 -0.847539 -0.068397 +v 0.898531 -0.853668 -0.080426 +v 0.885930 -0.860661 -0.089365 +v 0.872257 -0.868249 -0.094869 +v 0.864873 -0.877645 0.096884 +v 0.879627 -0.878838 0.093553 +v 0.893949 -0.879878 0.086673 +v 0.907290 -0.880725 0.076509 +v 0.919828 -0.876140 0.053739 +v 0.926695 -0.876140 0.037016 +v 0.930924 -0.876140 0.018871 +v 0.932352 -0.876140 -0.000000 +v 0.930924 -0.876140 -0.018871 +v 0.926695 -0.876140 -0.037016 +v 0.919828 -0.876140 -0.053739 +v 0.910586 -0.876140 -0.068397 +v 0.899324 -0.876140 -0.080426 +v 0.886476 -0.876140 -0.089365 +v 0.872535 -0.876140 -0.094869 +v 0.864334 -0.885498 0.096764 +v 0.878570 -0.894241 0.093318 +v 0.892416 -0.902240 0.086332 +v 0.905338 -0.909187 0.076074 +v 0.918640 -0.909772 0.053739 +v 0.925376 -0.913510 0.037016 +v 0.929524 -0.915811 0.018871 +v 0.930924 -0.916589 -0.000000 +v 0.929524 -0.915811 -0.018871 +v 0.925376 -0.913510 -0.037016 +v 0.918640 -0.909772 -0.053739 +v 0.909576 -0.904741 -0.068397 +v 0.898531 -0.898612 -0.080426 +v 0.885930 -0.891619 -0.089365 +v 0.872257 -0.884031 -0.094869 +v 0.863268 -0.892998 0.096565 +v 0.876479 -0.908953 0.092927 +v 0.889380 -0.923598 0.085765 +v 0.901474 -0.936370 0.075352 +v 0.915124 -0.942111 0.053739 +v 0.921469 -0.949443 0.037016 +v 0.925376 -0.953958 0.018870 +v 0.926695 -0.955483 -0.000000 +v 0.925376 -0.953958 -0.018871 +v 0.921469 -0.949443 -0.037016 +v 0.915124 -0.942111 -0.053739 +v 0.906586 -0.932244 -0.068397 +v 0.896182 -0.920220 -0.080426 +v 0.884311 -0.906503 -0.089365 +v 0.871432 -0.891619 -0.094869 +v 0.861715 -0.899857 0.096294 +v 0.873433 -0.922407 0.092397 +v 0.884957 -0.943130 0.084994 +v 0.895845 -0.961230 0.074372 +v 0.909414 -0.971915 0.053739 +v 0.915124 -0.982559 0.037016 +v 0.918640 -0.989114 0.018870 +v 0.919828 -0.991328 -0.000000 +v 0.918640 -0.989114 -0.018871 +v 0.915124 -0.982559 -0.037016 +v 0.909414 -0.971915 -0.053739 +v 0.901730 -0.957590 -0.068397 +v 0.892366 -0.940135 -0.080426 +v 0.881683 -0.920220 -0.089365 +v 0.870092 -0.898612 -0.094869 +v 0.859735 -0.905811 0.095962 +v 0.869549 -0.934087 0.091746 +v 0.879319 -0.960086 0.084050 +v 0.888669 -0.982811 0.073170 +v 0.901730 -0.998038 0.053739 +v 0.906586 -1.011586 0.037016 +v 0.909576 -1.019929 0.018870 +v 0.910586 -1.022746 -0.000000 +v 0.909576 -1.019929 -0.018871 +v 0.906586 -1.011586 -0.037016 +v 0.901730 -0.998038 -0.053739 +v 0.895195 -0.979806 -0.068397 +v 0.887232 -0.957590 -0.080426 +v 0.878147 -0.932244 -0.089365 +v 0.868289 -0.904741 -0.094869 +v 0.857405 -0.910632 0.095582 +v 0.864977 -0.943543 0.091001 +v 0.872681 -0.973815 0.082968 +v 0.880221 -1.000284 0.071792 +v 0.892366 -1.019477 0.053739 +v 0.896182 -1.035408 0.037016 +v 0.898531 -1.045218 0.018870 +v 0.899324 -1.048530 -0.000000 +v 0.898531 -1.045218 -0.018871 +v 0.896182 -1.035408 -0.037016 +v 0.892366 -1.019477 -0.053739 +v 0.887232 -0.998038 -0.068397 +v 0.880975 -0.971915 -0.080426 +v 0.873837 -0.942111 -0.089365 +v 0.866092 -0.909772 -0.094869 +v 0.858037 -0.876140 -0.096728 +v 0.854812 -0.914134 0.095169 +v 0.859892 -0.950413 0.090189 +v 0.865299 -0.983788 0.081790 +v 0.870826 -1.012977 0.070293 +v 0.881683 -1.035408 0.053739 +v 0.884311 -1.053109 0.037016 +v 0.885930 -1.064009 0.018870 +v 0.886476 -1.067690 -0.000000 +v 0.885930 -1.064009 -0.018871 +v 0.884311 -1.053109 -0.037016 +v 0.881683 -1.035408 -0.053739 +v 0.878147 -1.011586 -0.068397 +v 0.873837 -0.982559 -0.080426 +v 0.868920 -0.949443 -0.089365 +v 0.863585 -0.913509 -0.094869 +v 0.852058 -0.916182 0.094737 +v 0.854490 -0.954431 0.089343 +v 0.857457 -0.989622 0.080561 +v 0.860844 -1.020403 0.068729 +v 0.870092 -1.045218 0.053739 +v 0.871432 -1.064009 0.037016 +v 0.872257 -1.075581 0.018870 +v 0.872535 -1.079488 -0.000000 +v 0.872257 -1.075581 -0.018871 +v 0.871432 -1.064009 -0.037016 +v 0.870092 -1.045218 -0.053739 +v 0.868289 -1.019929 -0.068397 +v 0.866092 -0.989114 -0.080426 +v 0.863585 -0.953958 -0.089365 +v 0.860866 -0.915811 -0.094869 +v 0.849249 -0.916699 0.094304 +v 0.848979 -0.955445 0.088494 +v 0.849455 -0.991094 0.079328 +v 0.850659 -1.022276 0.067160 +v 0.858037 -1.048530 0.053739 +v 0.858037 -1.067690 0.037016 +v 0.858037 -1.079488 0.018870 +v 0.858037 -1.083472 -0.000000 +v 0.858037 -1.079488 -0.018871 +v 0.858037 -1.067690 -0.037016 +v 0.858037 -1.048530 -0.053739 +v 0.858037 -1.022746 -0.068397 +v 0.858037 -0.991327 -0.080426 +v 0.858037 -0.955482 -0.089365 +v 0.858037 -0.916588 -0.094869 +v 0.846491 -0.915664 0.093887 +v 0.843569 -0.953415 0.087675 +v 0.841601 -0.988146 0.078140 +v 0.840663 -1.018525 0.065647 +v 0.845982 -1.045218 0.053739 +v 0.844643 -1.064009 0.037016 +v 0.843818 -1.075581 0.018870 +v 0.843539 -1.079488 -0.000000 +v 0.843818 -1.075581 -0.018871 +v 0.844643 -1.064009 -0.037016 +v 0.845982 -1.045218 -0.053739 +v 0.847785 -1.019929 -0.068397 +v 0.849982 -0.989114 -0.080426 +v 0.852489 -0.953958 -0.089365 +v 0.855209 -0.915811 -0.094869 +v 0.843891 -0.913117 0.093501 +v 0.838469 -0.948418 0.086918 +v 0.834198 -0.980893 0.077040 +v 0.831240 -1.009292 0.064248 +v 0.834391 -1.035408 0.053739 +v 0.831763 -1.053109 0.037016 +v 0.830145 -1.064009 0.018870 +v 0.829598 -1.067690 -0.000000 +v 0.830145 -1.064009 -0.018871 +v 0.831763 -1.053109 -0.037016 +v 0.834391 -1.035408 -0.053739 +v 0.837928 -1.011586 -0.068397 +v 0.842237 -0.982559 -0.080426 +v 0.847154 -0.949443 -0.089365 +v 0.852489 -0.913509 -0.094869 +v 0.841549 -0.909156 0.093161 +v 0.833875 -0.940648 0.086252 +v 0.827529 -0.969612 0.076073 +v 0.822752 -0.994934 0.063017 +v 0.823708 -1.019477 0.053739 +v 0.819893 -1.035408 0.037016 +v 0.817543 -1.045218 0.018870 +v 0.816750 -1.048530 -0.000000 +v 0.817543 -1.045218 -0.018871 +v 0.819893 -1.035408 -0.037016 +v 0.823708 -1.019477 -0.053739 +v 0.828843 -0.998038 -0.068397 +v 0.835099 -0.971915 -0.080426 +v 0.842237 -0.942111 -0.089365 +v 0.849982 -0.909772 -0.094869 +v 0.839555 -0.903932 0.092881 +v 0.829964 -0.930402 0.085701 +v 0.821850 -0.954737 0.075274 +v 0.815525 -0.976002 0.062000 +v 0.814345 -0.998038 0.053739 +v 0.809489 -1.011586 0.037016 +v 0.806498 -1.019929 0.018870 +v 0.805489 -1.022746 -0.000000 +v 0.806498 -1.019929 -0.018871 +v 0.809489 -1.011586 -0.037016 +v 0.814345 -0.998038 -0.053739 +v 0.820880 -0.979806 -0.068397 +v 0.828843 -0.957590 -0.080426 +v 0.837928 -0.932244 -0.089365 +v 0.847785 -0.904741 -0.094869 +v 0.837986 -0.897648 0.092671 +v 0.826886 -0.918074 0.085289 +v 0.817381 -0.936840 0.074675 +v 0.809837 -0.953223 0.061238 +v 0.806660 -0.971915 0.053739 +v 0.800950 -0.982559 0.037016 +v 0.797434 -0.989114 0.018870 +v 0.796247 -0.991327 -0.000000 +v 0.797434 -0.989114 -0.018871 +v 0.800950 -0.982559 -0.037016 +v 0.806660 -0.971915 -0.053739 +v 0.814345 -0.957590 -0.068397 +v 0.823708 -0.940135 -0.080426 +v 0.834391 -0.920220 -0.089365 +v 0.845982 -0.898612 -0.094869 +v 0.850254 -0.876345 0.096537 +v 0.836901 -0.890543 0.092538 +v 0.824759 -0.904138 0.085030 +v 0.814293 -0.916608 0.074299 +v 0.805907 -0.927474 0.060759 +v 0.800950 -0.942111 0.053739 +v 0.794605 -0.949443 0.037016 +v 0.790698 -0.953958 0.018870 +v 0.789379 -0.955482 -0.000000 +v 0.790698 -0.953958 -0.018871 +v 0.794605 -0.949443 -0.037016 +v 0.800950 -0.942111 -0.053739 +v 0.809489 -0.932244 -0.068397 +v 0.819893 -0.920220 -0.080426 +v 0.831763 -0.906503 -0.089365 +v 0.844643 -0.891619 -0.094869 +v 0.836343 -0.882892 0.092489 +v 0.823664 -0.889130 0.084934 +v 0.812704 -0.894820 0.074160 +v 0.803884 -0.899742 0.060582 +v 0.797434 -0.909772 0.053739 +v 0.790698 -0.913509 0.037016 +v 0.786551 -0.915811 0.018871 +v 0.785150 -0.916588 -0.000000 +v 0.786551 -0.915811 -0.018871 +v 0.790698 -0.913509 -0.037016 +v 0.797434 -0.909772 -0.053739 +v 0.806498 -0.904741 -0.068397 +v 0.817543 -0.898612 -0.080426 +v 0.830145 -0.891619 -0.089365 +v 0.843818 -0.884031 -0.094869 +vn -0.474349 0.000000 -0.880306 +vn -0.655507 0.000000 -0.755150 +vn -0.647633 0.046113 -0.760521 +vn -0.988464 0.000000 -0.151402 +vn -0.999969 0.000000 0.000000 +vn -0.997345 0.072542 0.000000 +vn -0.765252 0.020234 0.643361 +vn -0.773370 0.019623 0.633595 +vn -0.748558 0.065889 0.659749 +vn -0.251717 0.000000 -0.967772 +vn -0.467391 0.032685 -0.883419 +vn -0.952696 0.000000 -0.303873 +vn -0.985443 0.071627 -0.153996 +vn -0.820399 -0.001923 0.571764 +vn -0.889187 0.000000 -0.457533 +vn -0.948637 0.068850 -0.308725 +vn -0.952696 0.000000 0.303873 +vn -0.948637 0.068850 0.308725 +vn -0.792291 0.000000 -0.610096 +vn -0.883602 0.063936 -0.463820 +vn -0.988464 0.000000 0.151402 +vn -0.985443 0.071627 0.154027 +vn -0.610096 0.012482 0.792199 +vn -0.398755 0.004120 0.917020 +vn -0.600971 0.045442 0.797937 +vn -0.785180 0.056490 -0.616627 +vn -0.763176 0.066286 0.642750 +vn -0.623493 0.092318 -0.776330 +vn -0.988678 0.149998 0.000000 +vn -0.726035 0.115757 0.677816 +vn -0.247871 0.016572 -0.968627 +vn -0.446333 0.065004 -0.892483 +vn -0.975585 0.147893 -0.162267 +vn -0.813562 0.056154 0.578722 +vn -0.798059 0.118290 0.590808 +vn -0.935453 0.141453 -0.323862 +vn -0.935453 0.141453 0.323862 +vn -0.865780 0.130345 -0.483108 +vn -0.975585 0.147893 0.162267 +vn -0.393628 0.020753 0.919004 +vn -0.578478 0.077517 0.811975 +vn -0.762963 0.114109 -0.636250 +vn -0.737999 0.112491 0.665304 +vn -0.380627 0.037080 0.923948 +vn -0.541765 0.108127 0.833522 +vn -0.722526 0.174047 -0.669057 +vn -0.971160 0.238380 0.000000 +vn -0.695730 0.158147 0.700644 +vn -0.581256 0.138615 -0.801782 +vn -0.694723 0.165868 0.699850 +vn -0.236000 0.033082 -0.971160 +vn -0.410535 0.096469 -0.906705 +vn -0.955840 0.234291 -0.177343 +vn -0.771081 0.184210 0.609455 +vn -0.909665 0.222144 -0.350932 +vn -0.909665 0.222144 0.350932 +vn -0.832057 0.202002 -0.516556 +vn -0.955840 0.234291 0.177343 +vn -0.863491 0.316263 0.392804 +vn -0.774987 0.281594 -0.565752 +vn -0.919065 0.338603 0.201514 +vn -0.359539 0.052492 0.931639 +vn -0.489944 0.136296 0.860988 +vn -0.658132 0.236946 -0.714621 +vn -0.938078 0.346385 0.000000 +vn -0.632801 0.202429 0.747368 +vn -0.517869 0.184515 -0.835292 +vn -0.647328 0.220069 0.729728 +vn -0.215888 0.049043 -0.975158 +vn -0.359264 0.126194 -0.924650 +vn -0.919065 0.338603 -0.201514 +vn -0.726005 0.259590 0.636799 +vn -0.863491 0.316263 -0.392804 +vn -0.849025 0.471603 -0.238166 +vn -0.649464 0.347636 0.676229 +vn -0.781121 0.429792 -0.452834 +vn -0.781121 0.429792 0.452834 +vn -0.681265 0.370678 -0.631214 +vn -0.849025 0.471572 0.238166 +vn -0.330454 0.066439 0.941465 +vn -0.422285 0.160894 0.892056 +vn -0.561144 0.301920 -0.770653 +vn -0.873379 0.487014 0.000000 +vn -0.544939 0.243538 0.802301 +vn -0.429518 0.228523 -0.873653 +vn -0.575243 0.279366 0.768761 +vn -0.187597 0.063875 -0.980132 +vn -0.291940 0.153142 -0.944060 +vn -0.312937 0.267800 -0.911222 +vn -0.738243 0.674490 0.000000 +vn -0.466842 0.344157 0.814600 +vn -0.151463 0.077120 -0.985443 +vn -0.208625 0.176000 -0.962004 +vn -0.708945 0.643117 -0.289438 +vn -0.518967 0.448225 0.727805 +vn -0.632313 0.564592 -0.530412 +vn -0.632313 0.564592 0.530412 +vn -0.530625 0.466109 -0.707907 +vn -0.708945 0.643117 0.289438 +vn -0.293710 0.078433 0.952666 +vn -0.338694 0.180486 0.923399 +vn -0.421216 0.364910 -0.830287 +vn -0.428510 0.278115 0.859645 +vn -0.231147 0.416120 -0.879421 +vn -0.456832 0.889523 0.000000 +vn -0.282876 0.301004 0.910672 +vn -0.167486 0.297586 -0.939848 +vn -0.304575 0.412214 0.858638 +vn -0.108036 0.088382 -0.990204 +vn -0.110172 0.192907 -0.975005 +vn -0.433058 0.832545 -0.345378 +vn -0.305216 0.546983 0.779473 +vn -0.373699 0.700034 -0.608478 +vn -0.373699 0.700034 0.608478 +vn -0.301431 0.551836 -0.777551 +vn -0.433058 0.832545 0.345378 +vn -0.249733 0.088198 0.964263 +vn -0.239937 0.193182 0.951353 +vn 0.000000 0.589892 -0.807459 +vn 0.000000 0.928312 0.371776 +vn -0.198462 0.095065 0.975463 +vn -0.130131 0.194739 0.972167 +vn 0.000000 0.437483 -0.899197 +vn 0.000000 1.000000 0.000000 +vn -0.116214 0.304025 0.945524 +vn 0.000000 0.309641 -0.950835 +vn -0.079653 0.456710 0.886013 +vn -0.057314 0.097201 -0.993591 +vn 0.000000 0.199774 -0.979827 +vn 0.000000 0.928312 -0.371776 +vn -0.007996 0.604389 0.796625 +vn 0.000000 0.764885 -0.644154 +vn 0.000000 0.764885 0.644154 +vn 0.190344 0.451918 0.871487 +vn 0.301431 0.551836 -0.777551 +vn 0.312357 0.582080 0.750694 +vn 0.231117 0.416120 -0.879421 +vn 0.373699 0.700034 0.608478 +vn -0.141118 0.096316 0.985290 +vn -0.084964 0.089877 0.992309 +vn 0.167486 0.297586 -0.939848 +vn 0.433058 0.832545 0.345378 +vn -0.021851 0.182775 0.982910 +vn 0.110172 0.192907 -0.975005 +vn 0.433058 0.832545 -0.345378 +vn 0.048067 0.283486 0.957762 +vn 0.000000 0.101108 -0.994873 +vn 0.057314 0.097201 -0.993591 +vn 0.373699 0.700034 -0.608478 +vn 0.456832 0.889523 0.000000 +vn 0.708945 0.643117 -0.289438 +vn 0.190039 0.247749 0.949980 +vn 0.108036 0.088382 -0.990204 +vn 0.632313 0.564592 -0.530412 +vn 0.416395 0.396496 0.818140 +vn 0.530625 0.466109 -0.707907 +vn 0.560320 0.496719 0.662770 +vn 0.421216 0.364910 -0.830287 +vn 0.632313 0.564592 0.530412 +vn -0.035615 0.079226 0.996216 +vn 0.312937 0.267800 -0.911222 +vn 0.708945 0.643117 0.289468 +vn 0.074343 0.162053 0.983947 +vn 0.208625 0.176000 -0.962004 +vn 0.429518 0.228492 -0.873653 +vn 0.738243 0.674490 0.000000 +vn 0.849025 0.471603 0.238166 +vn 0.155705 0.136418 0.978332 +vn 0.291940 0.153142 -0.944060 +vn 0.849025 0.471603 -0.238166 +vn 0.304086 0.204810 0.930357 +vn 0.151494 0.077120 -0.985443 +vn 0.781121 0.429792 -0.452834 +vn 0.571764 0.317209 0.756584 +vn 0.681265 0.370678 -0.631214 +vn 0.719779 0.392926 0.572283 +vn 0.561144 0.301920 -0.770653 +vn 0.781121 0.429792 0.452834 +vn 0.006561 0.066561 0.997742 +vn 0.658132 0.236946 -0.714621 +vn 0.863491 0.316263 0.392804 +vn 0.041444 0.052217 0.997772 +vn 0.517869 0.184515 -0.835292 +vn 0.873379 0.487014 0.000000 +vn 0.919065 0.338603 0.201514 +vn 0.221351 0.107547 0.969237 +vn 0.359264 0.126194 -0.924650 +vn 0.919065 0.338603 -0.201514 +vn 0.390820 0.158757 0.906644 +vn 0.187597 0.063906 -0.980163 +vn 0.863491 0.316263 -0.392804 +vn 0.668630 0.236610 0.704886 +vn 0.774987 0.281594 -0.565752 +vn 0.812281 0.294595 0.503342 +vn 0.725761 0.162084 0.668538 +vn 0.832057 0.202002 -0.516556 +vn 0.863643 0.208136 0.459059 +vn 0.722526 0.174047 -0.669057 +vn 0.909665 0.222144 0.350902 +vn 0.068514 0.036592 0.996979 +vn 0.581256 0.138615 -0.801782 +vn 0.938078 0.346385 0.000000 +vn 0.955840 0.234291 0.177343 +vn 0.271065 0.076571 0.959471 +vn 0.410535 0.096469 -0.906705 +vn 0.955840 0.234291 -0.177343 +vn 0.453108 0.111942 0.884365 +vn 0.215888 0.049043 -0.975158 +vn 0.909665 0.222144 -0.350902 +vn 0.971160 0.238380 0.000000 +vn 0.975585 0.147893 -0.162267 +vn 0.494186 0.065462 0.866848 +vn 0.236030 0.033082 -0.971160 +vn 0.935453 0.141453 -0.323862 +vn 0.756218 0.093966 0.647481 +vn 0.865780 0.130345 -0.483108 +vn 0.890439 0.132023 0.435469 +vn 0.762963 0.114109 -0.636250 +vn 0.935453 0.141453 0.323862 +vn 0.087374 0.020142 0.995972 +vn 0.623493 0.092318 -0.776330 +vn 0.975585 0.147893 0.162267 +vn 0.305277 0.044527 0.951201 +vn 0.446333 0.065004 -0.892483 +vn 0.647633 0.046113 -0.760521 +vn 0.988678 0.149998 0.000000 +vn 0.985443 0.071627 0.154027 +vn 0.324534 0.012085 0.945769 +vn 0.467391 0.032685 -0.883419 +vn 0.985443 0.071627 -0.154027 +vn 0.516739 0.019532 0.855892 +vn 0.247871 0.016572 -0.968627 +vn 0.948637 0.068850 -0.308725 +vn 0.767357 0.030549 0.640461 +vn 0.883602 0.063936 -0.463820 +vn 0.901456 0.062929 0.428266 +vn 0.785180 0.056490 -0.616627 +vn 0.948637 0.068850 0.308725 +vn 0.097934 0.003418 0.995178 +vn 0.792291 0.000000 -0.610096 +vn 0.952696 0.000000 0.303873 +vn 0.100528 -0.013092 0.994842 +vn 0.655507 0.000000 -0.755150 +vn 0.997345 0.072542 0.000000 +vn 0.988464 0.000000 0.151402 +vn 0.329356 -0.020356 0.943968 +vn 0.474349 0.000000 -0.880306 +vn 0.988464 0.000000 -0.151402 +vn 0.522233 -0.026002 0.852382 +vn 0.251717 0.000000 -0.967772 +vn 0.952696 0.000000 -0.303873 +vn 0.762444 -0.030000 0.646321 +vn 0.889187 0.000000 -0.457533 +vn 0.900571 -0.002441 0.434675 +vn 0.948637 -0.068850 -0.308725 +vn 0.948637 -0.068850 0.308725 +vn 0.883602 -0.063936 -0.463820 +vn 0.985443 -0.071627 0.154027 +vn 0.319773 -0.052461 0.946013 +vn 0.785180 -0.056490 -0.616627 +vn 1.000000 0.000000 0.000000 +vn 0.997345 -0.072542 0.000000 +vn 0.511002 -0.071200 0.856594 +vn 0.647633 -0.046113 -0.760521 +vn 0.739006 -0.082705 0.668569 +vn 0.467391 -0.032685 -0.883419 +vn 0.985443 -0.071627 -0.154027 +vn 0.696951 -0.147862 0.701682 +vn 0.247841 -0.016572 -0.968627 +vn 0.446333 -0.065004 -0.892483 +vn 0.975585 -0.147893 -0.162267 +vn 0.891446 -0.062014 0.448836 +vn 0.870388 -0.132664 0.474136 +vn 0.935453 -0.141453 -0.323862 +vn 0.935453 -0.141453 0.323862 +vn 0.865780 -0.130345 -0.483108 +vn 0.975585 -0.147893 0.162267 +vn 0.095340 -0.029481 0.994995 +vn 0.295663 -0.083834 0.951567 +vn 0.762963 -0.114109 -0.636250 +vn 0.988678 -0.149998 0.000000 +vn 0.482406 -0.116214 0.868191 +vn 0.623493 -0.092318 -0.776330 +vn 0.971160 -0.238380 0.000000 +vn 0.434706 -0.160985 0.886044 +vn 0.581256 -0.138615 -0.801782 +vn 0.637593 -0.208747 0.741539 +vn 0.236000 -0.033082 -0.971160 +vn 0.410535 -0.096469 -0.906705 +vn 0.955840 -0.234291 -0.177343 +vn 0.832209 -0.203070 0.515915 +vn 0.909665 -0.222144 -0.350932 +vn 0.909665 -0.222144 0.350902 +vn 0.832057 -0.202002 -0.516556 +vn 0.955840 -0.234291 0.177343 +vn 0.082064 -0.045534 0.995575 +vn 0.256508 -0.113987 0.959777 +vn 0.722526 -0.174047 -0.669057 +vn 0.774987 -0.281594 -0.565752 +vn 0.919065 -0.338603 0.201514 +vn 0.060488 -0.060823 0.996307 +vn 0.201636 -0.142125 0.969085 +vn 0.658132 -0.236946 -0.714621 +vn 0.938078 -0.346385 0.000000 +vn 0.364940 -0.204962 0.908170 +vn 0.517869 -0.184515 -0.835292 +vn 0.550890 -0.270608 0.789453 +vn 0.215888 -0.049043 -0.975158 +vn 0.359264 -0.126194 -0.924650 +vn 0.919065 -0.338603 -0.201514 +vn 0.771477 -0.280831 0.570879 +vn 0.863491 -0.316263 -0.392804 +vn 0.863491 -0.316263 0.392804 +vn 0.781121 -0.429792 -0.452834 +vn 0.781121 -0.429792 0.452834 +vn 0.681265 -0.370678 -0.631214 +vn 0.849025 -0.471603 0.238166 +vn 0.030824 -0.074740 0.996704 +vn 0.130833 -0.167150 0.977203 +vn 0.561144 -0.301920 -0.770653 +vn 0.873379 -0.487014 0.000000 +vn 0.269753 -0.246559 0.930784 +vn 0.429518 -0.228492 -0.873653 +vn 0.428663 -0.331248 0.840510 +vn 0.187597 -0.063906 -0.980163 +vn 0.291940 -0.153142 -0.944060 +vn 0.849025 -0.471603 -0.238166 +vn 0.675710 -0.367534 0.638966 +vn 0.263527 -0.384533 0.884671 +vn 0.151494 -0.077120 -0.985443 +vn 0.208655 -0.176000 -0.962004 +vn 0.708945 -0.643117 -0.289468 +vn 0.525498 -0.460768 0.715201 +vn 0.632313 -0.564592 -0.530412 +vn 0.632313 -0.564592 0.530412 +vn 0.530625 -0.466109 -0.707907 +vn 0.708945 -0.643117 0.289438 +vn -0.006500 -0.086886 0.996185 +vn 0.044496 -0.187719 0.981201 +vn 0.421216 -0.364910 -0.830287 +vn 0.738243 -0.674490 0.000000 +vn 0.146733 -0.282876 0.947844 +vn 0.312937 -0.267800 -0.911222 +vn 0.456832 -0.889523 0.000000 +vn -0.003662 -0.308847 0.951079 +vn 0.167486 -0.297586 -0.939848 +vn 0.049257 -0.434462 0.899319 +vn 0.108036 -0.088382 -0.990204 +vn 0.110172 -0.192907 -0.975005 +vn 0.433058 -0.832545 -0.345378 +vn 0.288614 -0.540483 0.790277 +vn 0.373699 -0.700034 -0.608478 +vn 0.373699 -0.700034 0.608478 +vn 0.301431 -0.551836 -0.777551 +vn 0.433058 -0.832545 0.345378 +vn -0.050996 -0.096957 0.993957 +vn -0.056215 -0.201880 0.977783 +vn 0.231117 -0.416120 -0.879421 +vn 0.000000 -0.589892 -0.807459 +vn 0.000000 -0.928312 0.371776 +vn -0.102664 -0.104282 0.989227 +vn -0.166997 -0.205145 0.964354 +vn 0.000000 -0.437483 -0.899197 +vn 0.000000 -1.000000 0.000000 +vn -0.172643 -0.315592 0.933042 +vn 0.000000 -0.309641 -0.950835 +vn -0.174261 -0.448103 0.876797 +vn 0.057314 -0.097232 -0.993591 +vn 0.000000 -0.199774 -0.979827 +vn 0.000000 -0.928312 -0.371776 +vn 0.000000 -0.764885 -0.644154 +vn 0.000000 -0.764885 0.644154 +vn -0.301431 -0.551836 -0.777551 +vn 0.000946 -0.567644 0.823237 +vn -0.288766 -0.529832 0.797388 +vn -0.231147 -0.416120 -0.879421 +vn -0.373699 -0.700034 0.608478 +vn -0.160222 -0.106052 0.981353 +vn -0.216468 -0.100040 0.971129 +vn -0.167516 -0.297586 -0.939848 +vn -0.433058 -0.832545 0.345378 +vn -0.275094 -0.194525 0.941527 +vn -0.110172 -0.192907 -0.975005 +vn -0.433058 -0.832545 -0.345378 +vn -0.336253 -0.297891 0.893399 +vn 0.000000 -0.101108 -0.994873 +vn -0.057283 -0.097201 -0.993591 +vn -0.373699 -0.700034 -0.608478 +vn -0.397290 -0.408582 0.821680 +vn -0.108036 -0.088382 -0.990204 +vn -0.632313 -0.564592 -0.530412 +vn -0.564409 -0.343852 0.750450 +vn -0.530625 -0.466109 -0.707907 +vn -0.507706 -0.447005 0.736442 +vn -0.421216 -0.364910 -0.830287 +vn -0.632313 -0.564592 0.530412 +vn -0.265603 -0.089602 0.959899 +vn -0.312937 -0.267800 -0.911222 +vn -0.456832 -0.889523 0.000000 +vn -0.708945 -0.643117 0.289438 +vn -0.369793 -0.174444 0.912564 +vn -0.208655 -0.176000 -0.962004 +vn -0.708945 -0.643117 -0.289438 +vn -0.474197 -0.263222 0.840114 +vn -0.448561 -0.148778 0.881252 +vn -0.291940 -0.153142 -0.944060 +vn -0.738243 -0.674490 0.000000 +vn -0.849025 -0.471572 -0.238166 +vn -0.581683 -0.219764 0.783135 +vn -0.151463 -0.077120 -0.985443 +vn -0.781121 -0.429792 -0.452834 +vn -0.675222 -0.272042 0.685568 +vn -0.681265 -0.370678 -0.631214 +vn -0.650624 -0.355327 0.671102 +vn -0.561144 -0.301920 -0.770653 +vn -0.781121 -0.429792 0.452834 +vn -0.307321 -0.076937 0.948454 +vn -0.429518 -0.228492 -0.873653 +vn -0.849025 -0.471603 0.238166 +vn -0.863491 -0.316263 0.392804 +vn -0.341594 -0.062441 0.937742 +vn -0.517869 -0.184515 -0.835292 +vn -0.873379 -0.487014 0.000000 +vn -0.919065 -0.338603 0.201514 +vn -0.510971 -0.119327 0.851253 +vn -0.359264 -0.126194 -0.924650 +vn -0.919065 -0.338603 -0.201514 +vn -0.660726 -0.172308 0.730552 +vn -0.187597 -0.063875 -0.980163 +vn -0.863491 -0.316263 -0.392804 +vn -0.740806 -0.201972 0.640614 +vn -0.774987 -0.281594 -0.565752 +vn -0.737144 -0.269326 0.619709 +vn -0.658132 -0.236946 -0.714621 +vn -0.832057 -0.202002 -0.516556 +vn -0.785943 -0.192419 0.587573 +vn -0.722526 -0.174047 -0.669057 +vn -0.909665 -0.222144 0.350932 +vn -0.367992 -0.046541 0.928648 +vn -0.581256 -0.138615 -0.801782 +vn -0.938078 -0.346385 0.000000 +vn -0.955840 -0.234291 0.177343 +vn -0.557390 -0.087497 0.825587 +vn -0.410535 -0.096469 -0.906705 +vn -0.955840 -0.234291 -0.177343 +vn -0.715659 -0.123692 0.687399 +vn -0.215888 -0.049043 -0.975158 +vn -0.909665 -0.222144 -0.350932 +vn -0.772942 -0.137364 0.619373 +vn -0.236000 -0.033082 -0.971160 +vn -0.935453 -0.141453 -0.323862 +vn -0.782128 -0.079409 0.618000 +vn -0.865780 -0.130345 -0.483108 +vn -0.810572 -0.123783 0.572375 +vn -0.762963 -0.114109 -0.636250 +vn -0.935453 -0.141453 0.323862 +vn -0.386242 -0.029756 0.921903 +vn -0.623493 -0.092318 -0.776330 +vn -0.971160 -0.238380 0.000000 +vn -0.975585 -0.147893 0.162267 +vn -0.588763 -0.054415 0.806452 +vn -0.446333 -0.065004 -0.892483 +vn -0.975585 -0.147893 -0.162267 +vn -0.750755 -0.075289 0.656240 +vn -0.606067 -0.020905 0.795099 +vn -0.467391 -0.032685 -0.883419 +vn -0.988678 -0.149998 0.000000 +vn -0.985443 -0.071657 -0.154027 +vn -0.769402 -0.027558 0.638142 +vn -0.247871 -0.016572 -0.968627 +vn -0.948637 -0.068850 -0.308725 +vn -0.777337 -0.027436 0.628437 +vn -0.883602 -0.063936 -0.463820 +vn -0.820246 -0.061220 0.568712 +vn -0.785180 -0.056490 -0.616627 +vn -0.948637 -0.068850 0.308725 +vn -0.396374 -0.012726 0.917997 +vn -0.647633 -0.046113 -0.760521 +vn -0.985443 -0.071657 0.154027 +vn 0.000000 0.000000 -1.000000 +vn -0.151952 -0.004700 0.988372 +vn -0.997345 -0.072542 0.000000 +usemtl SkinColor +s 1 +f 14//1 13//2 28//3 +f 9//4 8//5 23//6 +f 4//7 3//8 19//9 +f 15//10 14//1 29//11 +f 10//12 9//4 24//13 +f 5//14 4//7 19//9 +f 11//15 10//12 25//16 +f 6//17 5//14 21//18 +f 12//19 11//15 26//20 +f 7//21 6//17 22//22 +f 2//23 1//24 17//25 +f 13//2 12//19 27//26 +f 8//5 7//21 23//6 +f 3//8 2//23 18//27 +f 29//11 28//3 43//28 +f 24//13 23//6 38//29 +f 19//9 18//27 34//30 +f 30//31 29//11 44//32 +f 25//16 24//13 39//33 +f 20//34 19//9 35//35 +f 26//20 25//16 40//36 +f 21//18 20//34 36//37 +f 27//26 26//20 41//38 +f 22//22 21//18 37//39 +f 17//25 16//40 32//41 +f 28//3 27//26 42//42 +f 23//6 22//22 38//29 +f 18//27 17//25 33//43 +f 32//41 31//44 47//45 +f 43//28 42//42 57//46 +f 38//29 37//39 53//47 +f 33//43 32//41 48//48 +f 44//32 43//28 58//49 +f 39//33 38//29 53//47 +f 34//30 33//43 49//50 +f 45//51 44//32 59//52 +f 40//36 39//33 54//53 +f 35//35 34//30 50//54 +f 41//38 40//36 55//55 +f 36//37 35//35 51//56 +f 42//42 41//38 56//57 +f 37//39 36//37 52//58 +f 51//56 50//54 66//59 +f 57//46 56//57 71//60 +f 52//58 51//56 67//61 +f 47//45 46//62 62//63 +f 58//49 57//46 72//64 +f 53//47 52//58 68//65 +f 48//48 47//45 63//66 +f 59//52 58//49 73//67 +f 54//53 53//47 68//65 +f 49//50 48//48 64//68 +f 60//69 59//52 74//70 +f 55//55 54//53 69//71 +f 50//54 49//50 65//72 +f 56//57 55//55 70//73 +f 70//73 69//71 84//74 +f 65//72 64//68 80//75 +f 71//60 70//73 85//76 +f 66//59 65//72 81//77 +f 72//64 71//60 86//78 +f 67//61 66//59 82//79 +f 62//63 61//80 77//81 +f 73//67 72//64 87//82 +f 68//65 67//61 83//83 +f 63//66 62//63 78//84 +f 74//70 73//67 88//85 +f 69//71 68//65 83//83 +f 64//68 63//66 79//86 +f 75//87 74//70 89//88 +f 89//88 88//85 103//89 +f 84//74 83//83 98//90 +f 79//86 78//84 94//91 +f 90//92 89//88 104//93 +f 85//76 84//74 99//94 +f 80//75 79//86 95//95 +f 86//78 85//76 100//96 +f 81//77 80//75 96//97 +f 87//82 86//78 101//98 +f 82//79 81//77 97//99 +f 77//81 76//100 92//101 +f 88//85 87//82 102//102 +f 83//83 82//79 98//90 +f 78//84 77//81 93//103 +f 103//89 102//102 117//104 +f 98//90 97//99 113//105 +f 93//103 92//101 108//106 +f 104//93 103//89 118//107 +f 99//94 98//90 113//105 +f 94//91 93//103 109//108 +f 105//109 104//93 119//110 +f 100//96 99//94 114//111 +f 95//95 94//91 110//112 +f 101//98 100//96 115//113 +f 96//97 95//95 111//114 +f 102//102 101//98 116//115 +f 97//99 96//97 112//116 +f 92//101 91//117 107//118 +f 117//104 116//115 131//119 +f 112//116 111//114 127//120 +f 107//118 106//121 122//122 +f 118//107 117//104 132//123 +f 113//105 112//116 128//124 +f 108//106 107//118 123//125 +f 119//110 118//107 133//126 +f 114//111 113//105 128//124 +f 109//108 108//106 124//127 +f 120//128 119//110 134//129 +f 115//113 114//111 129//130 +f 110//112 109//108 125//131 +f 116//115 115//113 130//132 +f 111//114 110//112 126//133 +f 125//131 124//127 139//134 +f 131//119 130//132 146//135 +f 126//133 125//131 140//136 +f 132//123 131//119 147//137 +f 127//120 126//133 141//138 +f 122//122 121//139 136//140 +f 133//126 132//123 148//141 +f 128//124 127//120 142//142 +f 123//125 122//122 137//143 +f 134//129 133//126 149//144 +f 129//130 128//124 144//145 +f 124//127 123//125 138//146 +f 135//147 134//129 150//148 +f 130//132 129//130 145//149 +f 144//145 143//150 159//151 +f 139//134 138//146 153//152 +f 150//148 149//144 165//153 +f 145//149 144//145 160//154 +f 140//136 139//134 154//155 +f 146//135 145//149 161//156 +f 141//138 140//136 155//157 +f 147//137 146//135 162//158 +f 142//142 141//138 156//159 +f 137//143 136//140 151//160 +f 148//141 147//137 163//161 +f 143//150 142//142 157//162 +f 138//146 137//143 152//163 +f 149//144 148//141 164//164 +f 163//161 162//158 178//165 +f 158//166 157//162 172//167 +f 153//152 152//163 167//168 +f 164//164 163//161 179//169 +f 159//151 158//166 174//170 +f 154//155 153//152 168//171 +f 165//153 164//164 180//172 +f 160//154 159//151 175//173 +f 155//157 154//155 169//174 +f 161//156 160//154 176//175 +f 156//159 155//157 170//176 +f 162//158 161//156 177//177 +f 157//162 156//159 171//178 +f 152//163 151//160 166//179 +f 177//177 176//175 192//180 +f 172//167 171//178 186//181 +f 167//168 166//179 181//182 +f 178//165 177//177 193//183 +f 173//184 172//167 187//185 +f 168//171 167//168 182//186 +f 179//169 178//165 194//187 +f 174//170 173//184 189//188 +f 169//174 168//171 183//189 +f 180//172 179//169 195//190 +f 175//173 174//170 190//191 +f 170//176 169//174 184//192 +f 176//175 175//173 191//193 +f 171//178 170//176 185//194 +f 185//194 184//192 199//195 +f 191//193 190//191 206//196 +f 186//181 185//194 200//197 +f 192//180 191//193 207//198 +f 187//185 186//181 201//199 +f 182//186 181//182 196//200 +f 193//183 192//180 208//201 +f 188//202 187//185 202//203 +f 183//189 182//186 197//204 +f 194//187 193//183 209//205 +f 189//188 188//202 204//206 +f 184//192 183//189 198//207 +f 195//190 194//187 210//208 +f 190//191 189//188 205//209 +f 204//206 203//210 219//211 +f 199//195 198//207 213//212 +f 210//208 209//205 225//213 +f 205//209 204//206 220//214 +f 200//197 199//195 214//215 +f 206//196 205//209 221//216 +f 201//199 200//197 215//217 +f 207//198 206//196 222//218 +f 202//203 201//199 216//219 +f 197//204 196//200 211//220 +f 208//201 207//198 223//221 +f 203//210 202//203 217//222 +f 198//207 197//204 212//223 +f 209//205 208//201 224//224 +f 223//221 222//218 238//225 +f 218//226 217//222 232//227 +f 213//212 212//223 227//228 +f 224//224 223//221 239//229 +f 219//211 218//226 234//230 +f 214//215 213//212 228//231 +f 225//213 224//224 240//232 +f 220//214 219//211 235//233 +f 215//217 214//215 229//234 +f 221//216 220//214 236//235 +f 216//219 215//217 230//236 +f 222//218 221//216 237//237 +f 217//222 216//219 231//238 +f 212//223 211//220 226//239 +f 237//237 236//235 252//240 +f 232//227 231//238 246//241 +f 227//228 226//239 241//242 +f 238//225 237//237 253//243 +f 233//244 232//227 247//245 +f 228//231 227//228 242//246 +f 239//229 238//225 254//247 +f 234//230 233//244 249//248 +f 229//234 228//231 243//249 +f 240//232 239//229 255//250 +f 235//233 234//230 250//251 +f 230//236 229//234 244//252 +f 236//235 235//233 251//253 +f 231//238 230//236 245//254 +f 251//253 250//251 265//255 +f 246//241 245//254 261//256 +f 252//240 251//253 266//257 +f 247//245 246//241 262//258 +f 242//246 241//242 257//259 +f 253//243 252//240 267//260 +f 248//261 247//245 263//262 +f 243//249 242//246 258//263 +f 254//247 253//243 268//264 +f 249//248 248//261 263//262 +f 244//252 243//249 259//265 +f 255//250 254//247 269//266 +f 250//251 249//248 264//267 +f 245//254 244//252 259//265 +f 259//265 258//263 274//268 +f 270//269 269//266 284//270 +f 265//255 264//267 279//271 +f 260//272 259//265 275//273 +f 266//257 265//255 280//274 +f 261//256 260//272 276//275 +f 267//260 266//257 281//276 +f 262//258 261//256 277//277 +f 257//259 256//278 272//279 +f 268//264 267//260 282//280 +f 263//262 262//258 278//281 +f 258//263 257//259 273//282 +f 269//266 268//264 283//283 +f 264//267 263//262 278//281 +f 278//281 277//277 293//284 +f 273//282 272//279 288//285 +f 284//270 283//283 298//286 +f 279//271 278//281 293//284 +f 274//268 273//282 289//287 +f 285//288 284//270 299//289 +f 280//274 279//271 294//290 +f 275//273 274//268 290//291 +f 281//276 280//274 295//292 +f 276//275 275//273 291//293 +f 282//280 281//276 296//294 +f 277//277 276//275 292//295 +f 272//279 271//296 287//297 +f 283//283 282//280 297//298 +f 297//298 296//294 311//299 +f 292//295 291//293 307//300 +f 287//297 286//301 302//302 +f 298//286 297//298 312//303 +f 293//284 292//295 308//304 +f 288//285 287//297 303//305 +f 299//289 298//286 313//306 +f 294//290 293//284 308//304 +f 289//287 288//285 304//307 +f 300//308 299//289 314//309 +f 295//292 294//290 309//310 +f 290//291 289//287 305//311 +f 296//294 295//292 310//312 +f 291//293 290//291 306//313 +f 311//299 310//312 325//314 +f 306//313 305//311 321//315 +f 312//303 311//299 326//316 +f 307//300 306//313 322//317 +f 302//302 301//318 317//319 +f 313//306 312//303 327//320 +f 308//304 307//300 323//321 +f 303//305 302//302 318//322 +f 314//309 313//306 328//323 +f 309//310 308//304 323//321 +f 304//307 303//305 319//324 +f 315//325 314//309 329//326 +f 310//312 309//310 324//327 +f 305//311 304//307 320//328 +f 319//324 318//322 335//329 +f 330//330 329//326 345//331 +f 325//314 324//327 340//332 +f 320//328 319//324 336//333 +f 326//316 325//314 341//334 +f 321//315 320//328 337//335 +f 327//320 326//316 342//336 +f 322//317 321//315 338//337 +f 317//319 316//338 333//339 +f 328//323 327//320 343//340 +f 323//321 322//317 339//341 +f 318//322 317//319 334//342 +f 329//326 328//323 344//343 +f 324//327 323//321 339//341 +f 339//341 338//337 354//344 +f 334//342 333//339 349//345 +f 345//331 344//343 359//346 +f 340//332 339//341 354//344 +f 335//329 334//342 350//347 +f 346//348 345//331 360//349 +f 341//334 340//332 355//350 +f 336//333 335//329 351//351 +f 342//336 341//334 356//352 +f 337//335 336//333 352//353 +f 343//340 342//336 357//354 +f 338//337 337//335 353//355 +f 333//339 332//356 348//357 +f 344//343 343//340 358//358 +f 358//358 357//354 372//359 +f 353//355 352//353 368//360 +f 348//357 347//361 363//362 +f 359//346 358//358 373//363 +f 354//344 353//355 369//364 +f 349//345 348//357 364//365 +f 360//349 359//346 374//366 +f 355//350 354//344 369//364 +f 350//347 349//345 365//367 +f 361//368 360//349 375//369 +f 356//352 355//350 370//370 +f 351//351 350//347 365//367 +f 357//354 356//352 371//371 +f 352//353 351//351 367//372 +f 372//359 371//371 387//373 +f 367//372 366//374 381//375 +f 373//363 372//359 388//376 +f 368//360 367//372 382//377 +f 363//362 362//378 377//379 +f 374//366 373//363 389//380 +f 369//364 368//360 383//381 +f 364//365 363//362 378//382 +f 375//369 374//366 390//383 +f 370//370 369//364 385//384 +f 365//367 364//365 379//385 +f 376//386 375//369 391//387 +f 371//371 370//370 386//388 +f 366//374 365//367 380//389 +f 391//387 390//383 406//390 +f 386//388 385//384 401//391 +f 381//375 380//389 395//392 +f 387//373 386//388 402//393 +f 382//377 381//375 396//394 +f 388//376 387//373 403//395 +f 383//381 382//377 397//396 +f 378//382 377//379 392//397 +f 389//380 388//376 404//398 +f 384//399 383//381 398//400 +f 379//385 378//382 393//401 +f 390//383 389//380 405//402 +f 385//384 384//399 400//403 +f 380//389 379//385 394//404 +f 394//404 393//401 408//405 +f 405//402 404//398 420//406 +f 400//403 399//407 415//408 +f 395//392 394//404 409//409 +f 406//390 405//402 421//410 +f 401//391 400//403 416//411 +f 396//394 395//392 410//412 +f 402//393 401//391 417//413 +f 397//396 396//394 411//414 +f 403//395 402//393 418//415 +f 398//400 397//396 412//416 +f 393//401 392//397 407//417 +f 404//398 403//395 419//418 +f 399//407 398//400 413//419 +f 413//419 412//416 427//420 +f 408//405 407//417 422//421 +f 419//418 418//415 434//422 +f 414//423 413//419 428//424 +f 409//409 408//405 423//425 +f 420//406 419//418 435//426 +f 415//408 414//423 430//427 +f 410//412 409//409 424//428 +f 421//410 420//406 436//429 +f 416//411 415//408 431//430 +f 411//414 410//412 425//431 +f 417//413 416//411 432//432 +f 412//416 411//414 426//433 +f 418//415 417//413 433//434 +f 432//432 431//430 447//435 +f 427//420 426//433 441//436 +f 433//434 432//432 448//437 +f 428//424 427//420 442//438 +f 423//425 422//421 437//439 +f 434//422 433//434 449//440 +f 429//441 428//424 443//442 +f 424//428 423//425 438//443 +f 435//426 434//422 450//444 +f 430//427 429//441 445//445 +f 425//431 424//428 439//446 +f 436//429 435//426 451//447 +f 431//430 430//427 446//448 +f 426//433 425//431 440//449 +f 451//447 450//444 467//450 +f 446//448 445//445 462//451 +f 441//436 440//449 456//452 +f 447//435 446//448 463//453 +f 442//438 441//436 457//454 +f 448//437 447//435 464//455 +f 443//442 442//438 458//456 +f 438//443 437//439 453//457 +f 449//440 448//437 465//458 +f 444//459 443//442 459//460 +f 439//446 438//443 454//461 +f 450//444 449//440 466//462 +f 445//445 444//459 461//463 +f 440//449 439//446 455//464 +f 455//464 454//461 469//465 +f 466//462 465//458 481//466 +f 461//463 460//467 476//468 +f 456//452 455//464 470//469 +f 467//450 466//462 482//470 +f 462//451 461//463 477//471 +f 457//454 456//452 471//472 +f 463//453 462//451 478//473 +f 458//456 457//454 472//474 +f 464//455 463//453 479//475 +f 459//460 458//456 473//476 +f 454//461 453//457 468//477 +f 465//458 464//455 480//478 +f 460//467 459//460 474//479 +f 331//480 15//10 30//31 +f 1//24 452//481 16//40 +f 331//480 30//31 45//51 +f 16//40 452//481 31//44 +f 331//480 45//51 60//69 +f 31//44 452//481 46//62 +f 46//62 452//481 61//80 +f 331//480 60//69 75//87 +f 331//480 75//87 90//92 +f 61//80 452//481 76//100 +f 331//480 90//92 105//109 +f 76//100 452//481 91//117 +f 331//480 105//109 120//128 +f 91//117 452//481 106//121 +f 106//121 452//481 121//139 +f 331//480 120//128 135//147 +f 331//480 135//147 150//148 +f 121//139 452//481 136//140 +f 331//480 150//148 165//153 +f 136//140 452//481 151//160 +f 331//480 165//153 180//172 +f 151//160 452//481 166//179 +f 166//179 452//481 181//182 +f 331//480 180//172 195//190 +f 331//480 195//190 210//208 +f 181//182 452//481 196//200 +f 331//480 210//208 225//213 +f 196//200 452//481 211//220 +f 331//480 225//213 240//232 +f 211//220 452//481 226//239 +f 331//480 240//232 255//250 +f 226//239 452//481 241//242 +f 331//480 255//250 270//269 +f 241//242 452//481 256//278 +f 331//480 270//269 285//288 +f 256//278 452//481 271//296 +f 331//480 285//288 300//308 +f 271//296 452//481 286//301 +f 331//480 300//308 315//325 +f 286//301 452//481 301//318 +f 331//480 315//325 330//330 +f 301//318 452//481 316//338 +f 331//480 330//330 346//348 +f 316//338 452//481 332//356 +f 331//480 346//348 361//368 +f 332//356 452//481 347//361 +f 331//480 361//368 376//386 +f 347//361 452//481 362//378 +f 331//480 376//386 391//387 +f 362//378 452//481 377//379 +f 331//480 391//387 406//390 +f 377//379 452//481 392//397 +f 331//480 406//390 421//410 +f 392//397 452//481 407//417 +f 331//480 421//410 436//429 +f 407//417 452//481 422//421 +f 422//421 452//481 437//439 +f 331//480 436//429 451//447 +f 331//480 451//447 467//450 +f 437//439 452//481 453//457 +f 331//480 467//450 482//470 +f 453//457 452//481 468//477 +f 474//479 473//476 6//17 +f 469//465 468//477 1//24 +f 480//478 479//475 13//2 +f 475//482 474//479 7//21 +f 470//469 469//465 2//23 +f 481//466 480//478 14//1 +f 476//468 475//482 9//4 +f 471//472 470//469 3//8 +f 482//470 481//466 15//10 +f 477//471 476//468 10//12 +f 472//474 471//472 4//7 +f 331//480 482//470 15//10 +f 478//473 477//471 11//15 +f 473//476 472//474 5//14 +f 468//477 452//481 1//24 +f 479//475 478//473 12//19 +f 29//11 14//1 28//3 +f 24//13 9//4 23//6 +f 3//8 18//27 19//9 +f 30//31 15//10 29//11 +f 25//16 10//12 24//13 +f 20//34 5//14 19//9 +f 26//20 11//15 25//16 +f 5//14 20//34 21//18 +f 27//26 12//19 26//20 +f 6//17 21//18 22//22 +f 1//24 16//40 17//25 +f 28//3 13//2 27//26 +f 7//21 22//22 23//6 +f 2//23 17//25 18//27 +f 44//32 29//11 43//28 +f 39//33 24//13 38//29 +f 18//27 33//43 34//30 +f 45//51 30//31 44//32 +f 40//36 25//16 39//33 +f 19//9 34//30 35//35 +f 41//38 26//20 40//36 +f 20//34 35//35 36//37 +f 42//42 27//26 41//38 +f 21//18 36//37 37//39 +f 16//40 31//44 32//41 +f 43//28 28//3 42//42 +f 22//22 37//39 38//29 +f 17//25 32//41 33//43 +f 31//44 46//62 47//45 +f 58//49 43//28 57//46 +f 37//39 52//58 53//47 +f 32//41 47//45 48//48 +f 59//52 44//32 58//49 +f 54//53 39//33 53//47 +f 33//43 48//48 49//50 +f 60//69 45//51 59//52 +f 55//55 40//36 54//53 +f 34//30 49//50 50//54 +f 56//57 41//38 55//55 +f 35//35 50//54 51//56 +f 57//46 42//42 56//57 +f 36//37 51//56 52//58 +f 50//54 65//72 66//59 +f 72//64 57//46 71//60 +f 51//56 66//59 67//61 +f 46//62 61//80 62//63 +f 73//67 58//49 72//64 +f 52//58 67//61 68//65 +f 47//45 62//63 63//66 +f 74//70 59//52 73//67 +f 69//71 54//53 68//65 +f 48//48 63//66 64//68 +f 75//87 60//69 74//70 +f 70//73 55//55 69//71 +f 49//50 64//68 65//72 +f 71//60 56//57 70//73 +f 85//76 70//73 84//74 +f 64//68 79//86 80//75 +f 86//78 71//60 85//76 +f 65//72 80//75 81//77 +f 87//82 72//64 86//78 +f 66//59 81//77 82//79 +f 61//80 76//100 77//81 +f 88//85 73//67 87//82 +f 67//61 82//79 83//83 +f 62//63 77//81 78//84 +f 89//88 74//70 88//85 +f 84//74 69//71 83//83 +f 63//66 78//84 79//86 +f 90//92 75//87 89//88 +f 104//93 89//88 103//89 +f 99//94 84//74 98//90 +f 78//84 93//103 94//91 +f 105//109 90//92 104//93 +f 100//96 85//76 99//94 +f 79//86 94//91 95//95 +f 101//98 86//78 100//96 +f 80//75 95//95 96//97 +f 102//102 87//82 101//98 +f 81//77 96//97 97//99 +f 76//100 91//117 92//101 +f 103//89 88//85 102//102 +f 82//79 97//99 98//90 +f 77//81 92//101 93//103 +f 118//107 103//89 117//104 +f 97//99 112//116 113//105 +f 92//101 107//118 108//106 +f 119//110 104//93 118//107 +f 114//111 99//94 113//105 +f 93//103 108//106 109//108 +f 120//128 105//109 119//110 +f 115//113 100//96 114//111 +f 94//91 109//108 110//112 +f 116//115 101//98 115//113 +f 95//95 110//112 111//114 +f 117//104 102//102 116//115 +f 96//97 111//114 112//116 +f 91//117 106//121 107//118 +f 132//123 117//104 131//119 +f 111//114 126//133 127//120 +f 106//121 121//139 122//122 +f 133//126 118//107 132//123 +f 112//116 127//120 128//124 +f 107//118 122//122 123//125 +f 134//129 119//110 133//126 +f 129//130 114//111 128//124 +f 108//106 123//125 124//127 +f 135//147 120//128 134//129 +f 130//132 115//113 129//130 +f 109//108 124//127 125//131 +f 131//119 116//115 130//132 +f 110//112 125//131 126//133 +f 140//136 125//131 139//134 +f 130//132 145//149 146//135 +f 141//138 126//133 140//136 +f 131//119 146//135 147//137 +f 142//142 127//120 141//138 +f 137//143 122//122 136//140 +f 132//123 147//137 148//141 +f 143//150 128//124 142//142 +f 138//146 123//125 137//143 +f 133//126 148//141 149//144 +f 128//124 143//150 144//145 +f 139//134 124//127 138//146 +f 134//129 149//144 150//148 +f 129//130 144//145 145//149 +f 143//150 158//166 159//151 +f 154//155 139//134 153//152 +f 149//144 164//164 165//153 +f 144//145 159//151 160//154 +f 155//157 140//136 154//155 +f 145//149 160//154 161//156 +f 156//159 141//138 155//157 +f 146//135 161//156 162//158 +f 157//162 142//142 156//159 +f 152//163 137//143 151//160 +f 147//137 162//158 163//161 +f 158//166 143//150 157//162 +f 153//152 138//146 152//163 +f 148//141 163//161 164//164 +f 162//158 177//177 178//165 +f 173//184 158//166 172//167 +f 168//171 153//152 167//168 +f 163//161 178//165 179//169 +f 158//166 173//184 174//170 +f 169//174 154//155 168//171 +f 164//164 179//169 180//172 +f 159//151 174//170 175//173 +f 170//176 155//157 169//174 +f 160//154 175//173 176//175 +f 171//178 156//159 170//176 +f 161//156 176//175 177//177 +f 172//167 157//162 171//178 +f 167//168 152//163 166//179 +f 176//175 191//193 192//180 +f 187//185 172//167 186//181 +f 182//186 167//168 181//182 +f 177//177 192//180 193//183 +f 188//202 173//184 187//185 +f 183//189 168//171 182//186 +f 178//165 193//183 194//187 +f 173//184 188//202 189//188 +f 184//192 169//174 183//189 +f 179//169 194//187 195//190 +f 174//170 189//188 190//191 +f 185//194 170//176 184//192 +f 175//173 190//191 191//193 +f 186//181 171//178 185//194 +f 200//197 185//194 199//195 +f 190//191 205//209 206//196 +f 201//199 186//181 200//197 +f 191//193 206//196 207//198 +f 202//203 187//185 201//199 +f 197//204 182//186 196//200 +f 192//180 207//198 208//201 +f 203//210 188//202 202//203 +f 198//207 183//189 197//204 +f 193//183 208//201 209//205 +f 188//202 203//210 204//206 +f 199//195 184//192 198//207 +f 194//187 209//205 210//208 +f 189//188 204//206 205//209 +f 203//210 218//226 219//211 +f 214//215 199//195 213//212 +f 209//205 224//224 225//213 +f 204//206 219//211 220//214 +f 215//217 200//197 214//215 +f 205//209 220//214 221//216 +f 216//219 201//199 215//217 +f 206//196 221//216 222//218 +f 217//222 202//203 216//219 +f 212//223 197//204 211//220 +f 207//198 222//218 223//221 +f 218//226 203//210 217//222 +f 213//212 198//207 212//223 +f 208//201 223//221 224//224 +f 222//218 237//237 238//225 +f 233//244 218//226 232//227 +f 228//231 213//212 227//228 +f 223//221 238//225 239//229 +f 218//226 233//244 234//230 +f 229//234 214//215 228//231 +f 224//224 239//229 240//232 +f 219//211 234//230 235//233 +f 230//236 215//217 229//234 +f 220//214 235//233 236//235 +f 231//238 216//219 230//236 +f 221//216 236//235 237//237 +f 232//227 217//222 231//238 +f 227//228 212//223 226//239 +f 236//235 251//253 252//240 +f 247//245 232//227 246//241 +f 242//246 227//228 241//242 +f 237//237 252//240 253//243 +f 248//261 233//244 247//245 +f 243//249 228//231 242//246 +f 238//225 253//243 254//247 +f 233//244 248//261 249//248 +f 244//252 229//234 243//249 +f 239//229 254//247 255//250 +f 234//230 249//248 250//251 +f 245//254 230//236 244//252 +f 235//233 250//251 251//253 +f 246//241 231//238 245//254 +f 266//257 251//253 265//255 +f 245//254 260//272 261//256 +f 267//260 252//240 266//257 +f 246//241 261//256 262//258 +f 241//242 256//278 257//259 +f 268//264 253//243 267//260 +f 247//245 262//258 263//262 +f 242//246 257//259 258//263 +f 269//266 254//247 268//264 +f 264//267 249//248 263//262 +f 243//249 258//263 259//265 +f 270//269 255//250 269//266 +f 265//255 250//251 264//267 +f 260//272 245//254 259//265 +f 258//263 273//282 274//268 +f 285//288 270//269 284//270 +f 280//274 265//255 279//271 +f 259//265 274//268 275//273 +f 281//276 266//257 280//274 +f 260//272 275//273 276//275 +f 282//280 267//260 281//276 +f 261//256 276//275 277//277 +f 256//278 271//296 272//279 +f 283//283 268//264 282//280 +f 262//258 277//277 278//281 +f 257//259 272//279 273//282 +f 284//270 269//266 283//283 +f 279//271 264//267 278//281 +f 277//277 292//295 293//284 +f 272//279 287//297 288//285 +f 299//289 284//270 298//286 +f 294//290 279//271 293//284 +f 273//282 288//285 289//287 +f 300//308 285//288 299//289 +f 295//292 280//274 294//290 +f 274//268 289//287 290//291 +f 296//294 281//276 295//292 +f 275//273 290//291 291//293 +f 297//298 282//280 296//294 +f 276//275 291//293 292//295 +f 271//296 286//301 287//297 +f 298//286 283//283 297//298 +f 312//303 297//298 311//299 +f 291//293 306//313 307//300 +f 286//301 301//318 302//302 +f 313//306 298//286 312//303 +f 292//295 307//300 308//304 +f 287//297 302//302 303//305 +f 314//309 299//289 313//306 +f 309//310 294//290 308//304 +f 288//285 303//305 304//307 +f 315//325 300//308 314//309 +f 310//312 295//292 309//310 +f 289//287 304//307 305//311 +f 311//299 296//294 310//312 +f 290//291 305//311 306//313 +f 326//316 311//299 325//314 +f 305//311 320//328 321//315 +f 327//320 312//303 326//316 +f 306//313 321//315 322//317 +f 301//318 316//338 317//319 +f 328//323 313//306 327//320 +f 307//300 322//317 323//321 +f 302//302 317//319 318//322 +f 329//326 314//309 328//323 +f 324//327 309//310 323//321 +f 303//305 318//322 319//324 +f 330//330 315//325 329//326 +f 325//314 310//312 324//327 +f 304//307 319//324 320//328 +f 318//322 334//342 335//329 +f 346//348 330//330 345//331 +f 341//334 325//314 340//332 +f 319//324 335//329 336//333 +f 342//336 326//316 341//334 +f 320//328 336//333 337//335 +f 343//340 327//320 342//336 +f 321//315 337//335 338//337 +f 316//338 332//356 333//339 +f 344//343 328//323 343//340 +f 322//317 338//337 339//341 +f 317//319 333//339 334//342 +f 345//331 329//326 344//343 +f 340//332 324//327 339//341 +f 338//337 353//355 354//344 +f 333//339 348//357 349//345 +f 360//349 345//331 359//346 +f 355//350 340//332 354//344 +f 334//342 349//345 350//347 +f 361//368 346//348 360//349 +f 356//352 341//334 355//350 +f 335//329 350//347 351//351 +f 357//354 342//336 356//352 +f 336//333 351//351 352//353 +f 358//358 343//340 357//354 +f 337//335 352//353 353//355 +f 332//356 347//361 348//357 +f 359//346 344//343 358//358 +f 373//363 358//358 372//359 +f 352//353 367//372 368//360 +f 347//361 362//378 363//362 +f 374//366 359//346 373//363 +f 353//355 368//360 369//364 +f 348//357 363//362 364//365 +f 375//369 360//349 374//366 +f 370//370 355//350 369//364 +f 349//345 364//365 365//367 +f 376//386 361//368 375//369 +f 371//371 356//352 370//370 +f 366//374 351//351 365//367 +f 372//359 357//354 371//371 +f 351//351 366//374 367//372 +f 371//371 386//388 387//373 +f 382//377 367//372 381//375 +f 372//359 387//373 388//376 +f 383//381 368//360 382//377 +f 378//382 363//362 377//379 +f 373//363 388//376 389//380 +f 384//399 369//364 383//381 +f 379//385 364//365 378//382 +f 374//366 389//380 390//383 +f 369//364 384//399 385//384 +f 380//389 365//367 379//385 +f 375//369 390//383 391//387 +f 370//370 385//384 386//388 +f 381//375 366//374 380//389 +f 390//383 405//402 406//390 +f 385//384 400//403 401//391 +f 396//394 381//375 395//392 +f 386//388 401//391 402//393 +f 397//396 382//377 396//394 +f 387//373 402//393 403//395 +f 398//400 383//381 397//396 +f 393//401 378//382 392//397 +f 388//376 403//395 404//398 +f 399//407 384//399 398//400 +f 394//404 379//385 393//401 +f 389//380 404//398 405//402 +f 384//399 399//407 400//403 +f 395//392 380//389 394//404 +f 409//409 394//404 408//405 +f 404//398 419//418 420//406 +f 399//407 414//423 415//408 +f 410//412 395//392 409//409 +f 405//402 420//406 421//410 +f 400//403 415//408 416//411 +f 411//414 396//394 410//412 +f 401//391 416//411 417//413 +f 412//416 397//396 411//414 +f 402//393 417//413 418//415 +f 413//419 398//400 412//416 +f 408//405 393//401 407//417 +f 403//395 418//415 419//418 +f 414//423 399//407 413//419 +f 428//424 413//419 427//420 +f 423//425 408//405 422//421 +f 418//415 433//434 434//422 +f 429//441 414//423 428//424 +f 424//428 409//409 423//425 +f 419//418 434//422 435//426 +f 414//423 429//441 430//427 +f 425//431 410//412 424//428 +f 420//406 435//426 436//429 +f 415//408 430//427 431//430 +f 426//433 411//414 425//431 +f 416//411 431//430 432//432 +f 427//420 412//416 426//433 +f 417//413 432//432 433//434 +f 431//430 446//448 447//435 +f 442//438 427//420 441//436 +f 432//432 447//435 448//437 +f 443//442 428//424 442//438 +f 438//443 423//425 437//439 +f 433//434 448//437 449//440 +f 444//459 429//441 443//442 +f 439//446 424//428 438//443 +f 434//422 449//440 450//444 +f 429//441 444//459 445//445 +f 440//449 425//431 439//446 +f 435//426 450//444 451//447 +f 430//427 445//445 446//448 +f 441//436 426//433 440//449 +f 450//444 466//462 467//450 +f 445//445 461//463 462//451 +f 457//454 441//436 456//452 +f 446//448 462//451 463//453 +f 458//456 442//438 457//454 +f 447//435 463//453 464//455 +f 459//460 443//442 458//456 +f 454//461 438//443 453//457 +f 448//437 464//455 465//458 +f 460//467 444//459 459//460 +f 455//464 439//446 454//461 +f 449//440 465//458 466//462 +f 444//459 460//467 461//463 +f 456//452 440//449 455//464 +f 470//469 455//464 469//465 +f 465//458 480//478 481//466 +f 460//467 475//482 476//468 +f 471//472 456//452 470//469 +f 466//462 481//466 482//470 +f 461//463 476//468 477//471 +f 472//474 457//454 471//472 +f 462//451 477//471 478//473 +f 473//476 458//456 472//474 +f 463//453 478//473 479//475 +f 474//479 459//460 473//476 +f 469//465 454//461 468//477 +f 464//455 479//475 480//478 +f 475//482 460//467 474//479 +f 7//21 474//479 6//17 +f 2//23 469//465 1//24 +f 479//475 12//19 13//2 +f 8//5 475//482 7//21 +f 3//8 470//469 2//23 +f 480//478 13//2 14//1 +f 475//482 8//5 9//4 +f 4//7 471//472 3//8 +f 481//466 14//1 15//10 +f 476//468 9//4 10//12 +f 5//14 472//474 4//7 +f 477//471 10//12 11//15 +f 6//17 473//476 5//14 +f 478//473 11//15 12//19 +o Foot_R.001_Sphere.014 +v 1.075241 0.496383 0.547398 +v 1.072531 0.479456 0.520507 +v 1.071806 0.464152 0.495335 +v 1.073094 0.451061 0.472848 +v 1.076347 0.440684 0.453912 +v 1.081437 0.433421 0.439254 +v 1.088171 0.429551 0.429436 +v 1.096290 0.429222 0.424838 +v 1.105480 0.432448 0.425634 +v 1.115390 0.439104 0.431795 +v 1.125638 0.448934 0.443084 +v 1.135830 0.461562 0.459067 +v 1.145576 0.476500 0.479129 +v 1.154499 0.493176 0.502500 +v 1.162258 0.510949 0.528282 +v 1.075570 0.500339 0.546759 +v 1.073176 0.487215 0.519253 +v 1.072743 0.475417 0.493515 +v 1.074287 0.465397 0.470532 +v 1.077749 0.457542 0.451188 +v 1.082996 0.452153 0.436227 +v 1.089826 0.449436 0.426224 +v 1.097976 0.449498 0.421562 +v 1.107134 0.452334 0.422421 +v 1.116948 0.457836 0.428768 +v 1.127040 0.465793 0.440360 +v 1.137023 0.475899 0.456750 +v 1.146513 0.487765 0.477309 +v 1.155145 0.500935 0.501247 +v 1.162587 0.514904 0.527643 +v 1.076095 0.504836 0.547197 +v 1.074207 0.496036 0.520113 +v 1.074240 0.488223 0.494762 +v 1.076192 0.481697 0.472119 +v 1.079989 0.476708 0.453055 +v 1.085485 0.473449 0.438301 +v 1.092468 0.472044 0.428425 +v 1.100670 0.472548 0.423807 +v 1.109777 0.474941 0.424623 +v 1.119437 0.479132 0.430843 +v 1.129280 0.484959 0.442227 +v 1.138928 0.492198 0.458338 +v 1.148009 0.500571 0.478557 +v 1.156176 0.509757 0.502106 +v 1.163113 0.519401 0.528081 +v 1.076797 0.509701 0.548695 +v 1.075584 0.505580 0.523052 +v 1.076239 0.502079 0.499029 +v 1.078736 0.499332 0.477550 +v 1.082981 0.497444 0.459441 +v 1.088809 0.496490 0.445397 +v 1.095997 0.496504 0.435958 +v 1.104268 0.497488 0.431487 +v 1.113306 0.499402 0.432155 +v 1.122761 0.502173 0.437938 +v 1.132272 0.505695 0.448612 +v 1.141472 0.509833 0.463768 +v 1.150008 0.514427 0.482823 +v 1.157552 0.519301 0.505045 +v 1.163815 0.524267 0.529580 +v 1.077649 0.514748 0.551196 +v 1.077254 0.515480 0.527957 +v 1.078663 0.516451 0.506151 +v 1.081822 0.517625 0.486615 +v 1.086609 0.518955 0.470100 +v 1.092840 0.520391 0.457240 +v 1.100277 0.521878 0.448531 +v 1.108632 0.523358 0.444306 +v 1.117585 0.524775 0.444729 +v 1.126793 0.526074 0.449782 +v 1.135900 0.527206 0.459271 +v 1.144558 0.528126 0.472833 +v 1.152433 0.528800 0.489945 +v 1.159222 0.529201 0.509951 +v 1.164666 0.529314 0.532081 +v 1.078617 0.519783 0.554604 +v 1.079153 0.525356 0.534642 +v 1.081419 0.530789 0.515855 +v 1.085330 0.535873 0.498965 +v 1.090734 0.540413 0.484623 +v 1.097424 0.544234 0.473377 +v 1.105143 0.547189 0.465662 +v 1.113594 0.549165 0.461773 +v 1.122452 0.550086 0.461860 +v 1.131377 0.549917 0.465919 +v 1.140026 0.548664 0.473794 +v 1.148066 0.546374 0.485184 +v 1.155189 0.543137 0.499649 +v 1.161121 0.539077 0.516635 +v 1.165634 0.534349 0.535488 +v 1.079664 0.524612 0.558787 +v 1.081207 0.534828 0.542847 +v 1.084402 0.544541 0.527767 +v 1.089127 0.553375 0.514127 +v 1.095199 0.560993 0.502451 +v 1.102385 0.567102 0.493187 +v 1.110409 0.571466 0.486692 +v 1.118963 0.573917 0.483215 +v 1.127718 0.574363 0.482890 +v 1.136337 0.572785 0.485729 +v 1.144490 0.569244 0.491623 +v 1.151863 0.563877 0.500346 +v 1.158172 0.556889 0.511562 +v 1.163176 0.548549 0.524841 +v 1.166681 0.539178 0.539671 +v 1.080751 0.529050 0.563585 +v 1.083339 0.543533 0.552259 +v 1.087497 0.557178 0.541431 +v 1.093065 0.569459 0.531518 +v 1.099830 0.579906 0.522900 +v 1.107531 0.588116 0.515909 +v 1.115872 0.593774 0.510814 +v 1.124533 0.596663 0.507809 +v 1.133181 0.596672 0.507011 +v 1.141483 0.593799 0.508451 +v 1.149121 0.588157 0.512072 +v 1.155801 0.579960 0.517736 +v 1.161267 0.569526 0.525226 +v 1.165307 0.557253 0.534252 +v 1.167768 0.543615 0.544469 +v 1.081835 0.532925 0.568814 +v 1.085465 0.551135 0.562515 +v 1.090584 0.568214 0.556321 +v 1.096995 0.583506 0.550469 +v 1.104450 0.596423 0.545184 +v 1.112665 0.606469 0.540670 +v 1.121322 0.613258 0.537100 +v 1.130090 0.616529 0.534610 +v 1.138631 0.616155 0.533297 +v 1.146617 0.612152 0.533212 +v 1.153742 0.604674 0.534356 +v 1.159731 0.594007 0.536687 +v 1.164354 0.580562 0.540115 +v 1.167434 0.564855 0.544509 +v 1.168852 0.547491 0.549698 +v 1.082875 0.536090 0.574272 +v 1.087505 0.557343 0.573222 +v 1.093546 0.577226 0.571864 +v 1.100764 0.594976 0.570252 +v 1.108882 0.609911 0.568447 +v 1.117589 0.621456 0.566518 +v 1.126550 0.629168 0.564539 +v 1.135420 0.632750 0.562587 +v 1.143859 0.632065 0.560737 +v 1.151542 0.627139 0.559059 +v 1.158174 0.618162 0.557619 +v 1.163500 0.605478 0.556470 +v 1.167315 0.589574 0.555659 +v 1.169474 0.571063 0.555215 +v 1.169892 0.550655 0.555156 +v 1.083830 0.538422 0.579750 +v 1.089380 0.561917 0.583967 +v 1.096267 0.583868 0.587464 +v 1.104228 0.603429 0.590107 +v 1.112956 0.619851 0.591794 +v 1.122115 0.632500 0.592459 +v 1.131355 0.640892 0.592079 +v 1.140319 0.644704 0.590666 +v 1.148664 0.643789 0.588276 +v 1.156068 0.638183 0.585001 +v 1.162247 0.628101 0.580965 +v 1.166964 0.613930 0.576325 +v 1.170037 0.596216 0.571259 +v 1.171348 0.575638 0.565960 +v 1.170848 0.552987 0.560634 +v 1.084665 0.539832 0.585037 +v 1.091017 0.564683 0.594338 +v 1.098645 0.587883 0.602521 +v 1.107254 0.608540 0.609270 +v 1.116514 0.625860 0.614328 +v 1.126069 0.639178 0.617498 +v 1.135552 0.647981 0.618659 +v 1.144598 0.651932 0.617768 +v 1.152861 0.650878 0.614857 +v 1.160021 0.644861 0.610039 +v 1.165805 0.634111 0.603499 +v 1.169990 0.619041 0.595489 +v 1.172414 0.600231 0.586315 +v 1.172986 0.578404 0.576332 +v 1.171683 0.554397 0.565921 +v 1.085347 0.540266 0.589930 +v 1.092355 0.565534 0.603937 +v 1.100587 0.589118 0.616456 +v 1.109725 0.610112 0.627006 +v 1.119420 0.627709 0.635183 +v 1.129298 0.641232 0.640671 +v 1.138980 0.650162 0.643260 +v 1.148093 0.654155 0.642850 +v 1.156289 0.653059 0.639457 +v 1.163250 0.646915 0.633212 +v 1.168711 0.635959 0.624355 +v 1.172461 0.620613 0.613225 +v 1.174356 0.601466 0.600250 +v 1.174324 0.579255 0.585930 +v 1.172364 0.554831 0.570815 +v 1.085850 0.539706 0.594242 +v 1.093341 0.564437 0.612394 +v 1.102018 0.587526 0.628734 +v 1.111547 0.608085 0.642633 +v 1.121562 0.625325 0.653558 +v 1.131678 0.638583 0.661088 +v 1.141507 0.647350 0.664935 +v 1.150670 0.651289 0.664950 +v 1.158816 0.650247 0.661132 +v 1.165631 0.644267 0.653629 +v 1.170853 0.633576 0.642730 +v 1.174283 0.618586 0.628851 +v 1.175788 0.599874 0.612528 +v 1.175310 0.578158 0.594387 +v 1.172867 0.554272 0.575126 +v 1.086154 0.538176 0.597805 +v 1.093938 0.561435 0.619385 +v 1.102884 0.583167 0.638882 +v 1.112649 0.602537 0.655550 +v 1.122858 0.618801 0.668746 +v 1.133119 0.631334 0.677965 +v 1.143036 0.639655 0.682851 +v 1.152229 0.643442 0.683217 +v 1.160345 0.642552 0.679048 +v 1.167071 0.637018 0.670506 +v 1.172150 0.627052 0.657918 +v 1.175385 0.613038 0.641768 +v 1.176654 0.595515 0.622677 +v 1.175906 0.575155 0.601378 +v 1.173171 0.552741 0.578690 +v 1.086248 0.535732 0.600485 +v 1.094122 0.556642 0.624640 +v 1.103152 0.576209 0.646512 +v 1.112990 0.593681 0.665261 +v 1.123259 0.608388 0.680165 +v 1.133564 0.619763 0.690652 +v 1.143508 0.627371 0.696320 +v 1.152711 0.630918 0.696950 +v 1.160817 0.630268 0.692518 +v 1.167516 0.625447 0.683194 +v 1.172550 0.616639 0.669337 +v 1.175726 0.604182 0.651479 +v 1.176921 0.588557 0.630307 +v 1.176091 0.570362 0.606633 +v 1.173265 0.550298 0.581369 +v 1.086128 0.532470 0.602176 +v 1.093887 0.550243 0.627958 +v 1.102811 0.566919 0.651329 +v 1.112556 0.581857 0.671392 +v 1.122748 0.594485 0.687375 +v 1.132996 0.604315 0.698664 +v 1.142906 0.610971 0.704824 +v 1.152097 0.614197 0.705621 +v 1.160215 0.613869 0.701022 +v 1.166949 0.609998 0.691205 +v 1.172040 0.602735 0.676547 +v 1.175292 0.592359 0.657610 +v 1.176580 0.579267 0.635124 +v 1.175856 0.563963 0.609952 +v 1.173145 0.547036 0.583061 +v 1.085799 0.528515 0.602815 +v 1.093242 0.542484 0.629212 +v 1.101874 0.555654 0.653149 +v 1.111363 0.567521 0.673708 +v 1.121346 0.577626 0.690099 +v 1.131438 0.585583 0.701690 +v 1.141252 0.591085 0.708037 +v 1.150410 0.593922 0.708897 +v 1.158561 0.593983 0.704235 +v 1.165390 0.591266 0.694232 +v 1.170637 0.585877 0.679270 +v 1.174099 0.578022 0.659927 +v 1.175643 0.568003 0.636944 +v 1.175210 0.556204 0.611205 +v 1.172816 0.543080 0.583700 +v 1.085274 0.524018 0.602377 +v 1.092211 0.533663 0.628353 +v 1.100377 0.542848 0.651902 +v 1.109458 0.551222 0.672121 +v 1.119106 0.558461 0.688232 +v 1.128949 0.564287 0.699616 +v 1.138610 0.568478 0.705836 +v 1.147716 0.570871 0.706652 +v 1.155918 0.571375 0.702033 +v 1.162902 0.569971 0.692157 +v 1.168397 0.566711 0.677404 +v 1.172194 0.561723 0.658339 +v 1.174147 0.555196 0.635697 +v 1.174179 0.547383 0.610346 +v 1.172291 0.538583 0.583262 +v 1.084572 0.519152 0.600879 +v 1.090834 0.524119 0.625414 +v 1.098378 0.528993 0.647635 +v 1.106914 0.533587 0.666690 +v 1.116114 0.537724 0.681846 +v 1.125625 0.541246 0.692521 +v 1.135081 0.544017 0.698303 +v 1.144118 0.545932 0.698972 +v 1.152390 0.546915 0.694501 +v 1.159577 0.546929 0.685062 +v 1.165406 0.545975 0.671018 +v 1.169650 0.544088 0.652909 +v 1.172148 0.541341 0.631430 +v 1.172802 0.537839 0.607407 +v 1.171589 0.533718 0.581763 +v 1.083720 0.514105 0.598378 +v 1.089164 0.514219 0.620508 +v 1.095954 0.514620 0.640513 +v 1.103829 0.515293 0.657626 +v 1.112486 0.516214 0.671187 +v 1.121593 0.517345 0.680677 +v 1.130801 0.518644 0.685730 +v 1.139754 0.520061 0.686152 +v 1.148110 0.521541 0.681928 +v 1.155546 0.523028 0.673218 +v 1.161777 0.524464 0.660359 +v 1.166564 0.525795 0.643844 +v 1.169723 0.526968 0.624308 +v 1.171132 0.527939 0.602501 +v 1.170738 0.528671 0.579262 +v 1.082752 0.509071 0.594971 +v 1.087265 0.504343 0.613824 +v 1.093197 0.500282 0.630809 +v 1.100320 0.497045 0.645275 +v 1.108361 0.494756 0.656664 +v 1.117010 0.493502 0.664540 +v 1.125934 0.493333 0.668599 +v 1.134793 0.494254 0.668686 +v 1.143243 0.496230 0.664797 +v 1.150962 0.499185 0.657081 +v 1.157652 0.503006 0.645836 +v 1.163056 0.507546 0.631493 +v 1.166967 0.512630 0.614604 +v 1.169234 0.518063 0.595817 +v 1.169770 0.523636 0.575855 +v 1.168554 0.529135 0.555484 +v 1.081705 0.504242 0.590787 +v 1.085210 0.494870 0.605618 +v 1.090214 0.486531 0.618897 +v 1.096524 0.479543 0.630113 +v 1.103896 0.474175 0.638836 +v 1.112049 0.470634 0.644730 +v 1.120669 0.469056 0.647569 +v 1.129423 0.469502 0.647243 +v 1.137977 0.471954 0.643766 +v 1.146002 0.476318 0.637271 +v 1.153188 0.482426 0.628007 +v 1.159260 0.490044 0.616331 +v 1.163984 0.498879 0.602691 +v 1.167179 0.508591 0.587611 +v 1.168722 0.518807 0.571672 +v 1.080618 0.499804 0.585989 +v 1.083079 0.486166 0.596206 +v 1.087120 0.473894 0.605233 +v 1.092585 0.463459 0.612722 +v 1.099265 0.455263 0.618386 +v 1.106903 0.449620 0.622008 +v 1.115206 0.446748 0.623447 +v 1.123853 0.446756 0.622649 +v 1.132514 0.449645 0.619645 +v 1.140856 0.455303 0.614549 +v 1.148556 0.463513 0.607558 +v 1.155321 0.473960 0.598941 +v 1.160889 0.486242 0.589027 +v 1.165047 0.499886 0.578200 +v 1.167636 0.514370 0.566874 +v 1.079534 0.495929 0.580761 +v 1.080952 0.478564 0.585950 +v 1.084032 0.462857 0.590343 +v 1.088656 0.449412 0.593771 +v 1.094645 0.438745 0.596102 +v 1.101769 0.431267 0.597247 +v 1.109755 0.427264 0.597161 +v 1.118297 0.426891 0.595849 +v 1.127064 0.430161 0.593359 +v 1.135722 0.436950 0.589789 +v 1.143936 0.446996 0.585274 +v 1.151392 0.459913 0.579990 +v 1.157802 0.475205 0.574138 +v 1.162921 0.492284 0.567944 +v 1.166551 0.510494 0.561645 +v 1.078494 0.492764 0.575303 +v 1.078912 0.472356 0.575244 +v 1.081071 0.453845 0.574800 +v 1.084886 0.437942 0.573988 +v 1.090213 0.425258 0.572840 +v 1.096845 0.416280 0.571399 +v 1.104527 0.411354 0.569722 +v 1.112966 0.410669 0.567871 +v 1.121836 0.414252 0.565919 +v 1.130797 0.421963 0.563941 +v 1.139504 0.433508 0.562012 +v 1.147622 0.448443 0.560207 +v 1.154841 0.466193 0.558594 +v 1.160881 0.486077 0.557237 +v 1.165511 0.507330 0.556187 +v 1.077538 0.490432 0.569825 +v 1.077038 0.467781 0.564498 +v 1.078349 0.447204 0.559200 +v 1.081422 0.429489 0.554133 +v 1.086139 0.415318 0.549493 +v 1.092318 0.405236 0.545458 +v 1.099723 0.399630 0.542182 +v 1.108067 0.398715 0.539792 +v 1.117031 0.402527 0.538380 +v 1.126271 0.410919 0.537999 +v 1.135431 0.423569 0.538665 +v 1.144158 0.439990 0.540352 +v 1.152119 0.459552 0.542995 +v 1.159006 0.481502 0.546492 +v 1.164556 0.504997 0.550709 +v 1.076704 0.489022 0.564537 +v 1.075400 0.465016 0.554127 +v 1.075972 0.443188 0.544143 +v 1.078396 0.424378 0.534970 +v 1.082581 0.409308 0.526959 +v 1.088365 0.398558 0.520419 +v 1.095526 0.392541 0.515602 +v 1.103788 0.391487 0.512691 +v 1.112834 0.395438 0.511799 +v 1.122317 0.404242 0.512961 +v 1.131873 0.417559 0.516131 +v 1.141132 0.434879 0.521188 +v 1.149742 0.455536 0.527938 +v 1.157369 0.478736 0.536121 +v 1.163721 0.503587 0.545422 +v 1.076022 0.488588 0.559644 +v 1.074063 0.464165 0.544528 +v 1.074030 0.441953 0.530208 +v 1.075925 0.422806 0.517234 +v 1.079675 0.407460 0.506104 +v 1.085136 0.396504 0.497246 +v 1.092098 0.390360 0.491001 +v 1.100293 0.389264 0.487609 +v 1.109407 0.393258 0.487199 +v 1.119088 0.402188 0.489788 +v 1.128966 0.415711 0.495276 +v 1.138661 0.433307 0.503452 +v 1.147800 0.454301 0.514003 +v 1.156031 0.477885 0.526522 +v 1.163039 0.503154 0.540528 +v 1.075519 0.489147 0.555333 +v 1.073077 0.465262 0.536071 +v 1.072599 0.443545 0.517931 +v 1.074103 0.424833 0.501607 +v 1.077533 0.409843 0.487729 +v 1.082756 0.399153 0.476829 +v 1.089571 0.393172 0.469326 +v 1.097716 0.392131 0.465509 +v 1.106879 0.396069 0.465524 +v 1.116708 0.404836 0.469371 +v 1.126824 0.418094 0.476901 +v 1.136839 0.435334 0.487826 +v 1.146368 0.455893 0.501725 +v 1.155045 0.478982 0.518065 +v 1.162536 0.503713 0.536217 +v 1.079832 0.514284 0.574974 +v 1.075215 0.490678 0.551769 +v 1.072480 0.468264 0.529081 +v 1.071732 0.447905 0.507782 +v 1.073001 0.430381 0.488690 +v 1.076236 0.416367 0.472540 +v 1.081315 0.406402 0.459953 +v 1.088042 0.400867 0.451410 +v 1.096157 0.399977 0.447242 +v 1.105350 0.403765 0.447608 +v 1.115268 0.412085 0.452494 +v 1.125528 0.424618 0.461712 +v 1.135737 0.440882 0.474909 +v 1.145502 0.460253 0.491576 +v 1.154449 0.481985 0.511074 +v 1.162232 0.505244 0.532653 +v 1.075121 0.493121 0.549090 +v 1.072296 0.473057 0.523825 +v 1.071465 0.454863 0.500152 +v 1.072660 0.439237 0.478980 +v 1.075836 0.426781 0.461122 +v 1.080870 0.417973 0.447265 +v 1.087569 0.413151 0.437941 +v 1.095675 0.412501 0.433509 +v 1.104878 0.416048 0.434139 +v 1.114823 0.423656 0.439806 +v 1.125127 0.435031 0.450294 +v 1.135396 0.449738 0.465198 +v 1.145234 0.467211 0.483947 +v 1.154264 0.486778 0.505819 +v 1.162138 0.507687 0.529974 +v 1.070255 0.396948 0.582602 +v 1.067545 0.380021 0.555711 +v 1.066820 0.364717 0.530538 +v 1.068109 0.351625 0.508052 +v 1.071361 0.341249 0.489116 +v 1.076452 0.333986 0.474457 +v 1.083186 0.330116 0.464640 +v 1.091304 0.329787 0.460041 +v 1.100495 0.333013 0.460838 +v 1.110404 0.339669 0.466999 +v 1.120652 0.349499 0.478287 +v 1.130845 0.362126 0.494270 +v 1.140590 0.377065 0.514333 +v 1.149514 0.393741 0.537704 +v 1.157272 0.411514 0.563486 +v 1.070584 0.400904 0.581962 +v 1.068190 0.387780 0.554457 +v 1.067757 0.375982 0.528718 +v 1.069301 0.365962 0.505735 +v 1.072763 0.358107 0.486392 +v 1.078010 0.352718 0.471431 +v 1.084840 0.350001 0.461427 +v 1.092991 0.350062 0.456765 +v 1.102149 0.352899 0.457625 +v 1.111962 0.358401 0.463972 +v 1.122055 0.366358 0.475564 +v 1.132037 0.376463 0.491954 +v 1.141527 0.388330 0.512513 +v 1.150159 0.401500 0.536450 +v 1.157601 0.415469 0.562847 +v 1.071110 0.405401 0.582401 +v 1.069221 0.396601 0.555316 +v 1.069254 0.388788 0.529966 +v 1.071206 0.382261 0.507323 +v 1.075003 0.377273 0.488258 +v 1.080499 0.374013 0.473505 +v 1.087482 0.372609 0.463629 +v 1.095685 0.373113 0.459010 +v 1.104791 0.375506 0.459827 +v 1.114451 0.379697 0.466046 +v 1.124295 0.385523 0.477430 +v 1.133942 0.392762 0.493541 +v 1.143024 0.401136 0.513760 +v 1.151190 0.410321 0.537310 +v 1.158127 0.419966 0.563285 +v 1.071812 0.410266 0.583899 +v 1.070598 0.406145 0.558255 +v 1.071253 0.402643 0.534232 +v 1.073750 0.399896 0.512753 +v 1.077995 0.398009 0.494644 +v 1.083823 0.397055 0.480600 +v 1.091011 0.397069 0.471161 +v 1.099283 0.398053 0.466690 +v 1.108320 0.399967 0.467359 +v 1.117776 0.402738 0.473142 +v 1.127286 0.406260 0.483816 +v 1.136486 0.410397 0.498972 +v 1.145023 0.414991 0.518027 +v 1.152567 0.419865 0.540249 +v 1.158829 0.424832 0.564783 +v 1.072663 0.415313 0.586400 +v 1.072268 0.416045 0.563161 +v 1.073677 0.417016 0.541354 +v 1.076836 0.418190 0.521818 +v 1.081623 0.419520 0.505303 +v 1.087855 0.420956 0.492444 +v 1.095291 0.422443 0.483735 +v 1.103646 0.423923 0.479510 +v 1.112600 0.425340 0.479932 +v 1.121807 0.426639 0.484985 +v 1.130914 0.427771 0.494475 +v 1.139572 0.428691 0.508037 +v 1.147447 0.429364 0.525149 +v 1.154237 0.429766 0.545154 +v 1.159680 0.429879 0.567284 +v 1.073631 0.420348 0.589807 +v 1.074167 0.425921 0.569845 +v 1.076434 0.431354 0.551058 +v 1.080345 0.436438 0.534169 +v 1.085749 0.440978 0.519826 +v 1.092439 0.444799 0.508581 +v 1.100157 0.447754 0.500866 +v 1.108608 0.449730 0.496976 +v 1.117466 0.450651 0.497063 +v 1.126391 0.450482 0.501122 +v 1.135040 0.449228 0.508998 +v 1.143080 0.446939 0.520387 +v 1.150204 0.443702 0.534853 +v 1.156135 0.439642 0.551839 +v 1.160648 0.434914 0.570692 +v 1.074678 0.425177 0.593991 +v 1.076222 0.435393 0.578051 +v 1.079417 0.445106 0.562971 +v 1.084141 0.453940 0.549331 +v 1.090213 0.461558 0.537655 +v 1.097399 0.467667 0.528391 +v 1.105423 0.472030 0.521896 +v 1.113977 0.474482 0.518419 +v 1.122732 0.474928 0.518093 +v 1.131351 0.473350 0.520932 +v 1.139504 0.469809 0.526827 +v 1.146877 0.464442 0.535549 +v 1.153186 0.457454 0.546766 +v 1.158190 0.449114 0.560044 +v 1.161696 0.439742 0.574875 +v 1.075765 0.429614 0.598789 +v 1.078353 0.444098 0.587462 +v 1.082511 0.457742 0.576635 +v 1.088080 0.470024 0.566722 +v 1.094844 0.480471 0.558104 +v 1.102545 0.488681 0.551113 +v 1.110886 0.494339 0.546017 +v 1.119547 0.497228 0.543013 +v 1.128195 0.497236 0.542215 +v 1.136497 0.494364 0.543654 +v 1.144135 0.488721 0.547276 +v 1.150816 0.480525 0.552940 +v 1.156281 0.470090 0.560429 +v 1.160322 0.457818 0.569456 +v 1.162782 0.444180 0.579673 +v 1.076849 0.433490 0.604017 +v 1.080480 0.451700 0.597719 +v 1.085599 0.468779 0.591524 +v 1.092009 0.484071 0.585673 +v 1.099465 0.496988 0.580388 +v 1.107679 0.507034 0.575874 +v 1.116336 0.513823 0.572303 +v 1.125104 0.517093 0.569814 +v 1.133645 0.516720 0.568501 +v 1.141631 0.512717 0.568415 +v 1.148756 0.505239 0.569560 +v 1.154745 0.494572 0.571891 +v 1.159368 0.481127 0.575319 +v 1.162448 0.465420 0.579712 +v 1.163867 0.448055 0.584902 +v 1.077889 0.436655 0.609475 +v 1.082520 0.457908 0.608425 +v 1.088560 0.477791 0.607068 +v 1.095778 0.495541 0.605456 +v 1.103897 0.510476 0.603650 +v 1.112604 0.522021 0.601721 +v 1.121564 0.529733 0.599743 +v 1.130434 0.533315 0.597791 +v 1.138873 0.532630 0.595941 +v 1.146556 0.527704 0.594263 +v 1.153188 0.518726 0.592822 +v 1.158514 0.506042 0.591674 +v 1.162330 0.490139 0.590862 +v 1.164488 0.471628 0.590419 +v 1.164906 0.451220 0.590360 +v 1.078845 0.438987 0.614953 +v 1.084394 0.462482 0.619170 +v 1.091282 0.484433 0.622668 +v 1.099242 0.503994 0.625310 +v 1.107970 0.520415 0.626997 +v 1.117130 0.533065 0.627663 +v 1.126369 0.541457 0.627282 +v 1.135333 0.545269 0.625870 +v 1.143678 0.544354 0.623480 +v 1.151082 0.538748 0.620204 +v 1.157261 0.528666 0.616169 +v 1.161978 0.514495 0.611529 +v 1.165051 0.496781 0.606462 +v 1.166363 0.476203 0.601164 +v 1.165862 0.453552 0.595838 +v 1.079680 0.440397 0.620240 +v 1.086032 0.465248 0.629542 +v 1.093659 0.488448 0.637724 +v 1.102268 0.509105 0.644474 +v 1.111528 0.526425 0.649531 +v 1.121083 0.539742 0.652701 +v 1.130566 0.548546 0.653863 +v 1.139613 0.552497 0.652971 +v 1.147875 0.551443 0.650061 +v 1.155035 0.545426 0.645243 +v 1.160819 0.534676 0.638703 +v 1.165004 0.519606 0.630692 +v 1.167429 0.500796 0.621519 +v 1.168000 0.478969 0.611535 +v 1.166697 0.454962 0.601125 +v 1.080361 0.440831 0.625134 +v 1.087369 0.466099 0.639140 +v 1.095601 0.489683 0.651659 +v 1.104739 0.510677 0.662210 +v 1.114434 0.528274 0.670386 +v 1.124312 0.541797 0.675874 +v 1.133994 0.550726 0.678463 +v 1.143108 0.554720 0.678054 +v 1.151303 0.553624 0.674661 +v 1.158265 0.547480 0.668416 +v 1.163725 0.536524 0.659558 +v 1.167475 0.521178 0.648428 +v 1.169371 0.502031 0.635454 +v 1.169338 0.479819 0.621134 +v 1.167379 0.455396 0.606018 +v 1.080864 0.440271 0.629445 +v 1.088355 0.465002 0.647597 +v 1.097032 0.488091 0.663937 +v 1.106561 0.508650 0.677836 +v 1.116576 0.525890 0.688761 +v 1.126693 0.539148 0.696292 +v 1.136521 0.547915 0.700138 +v 1.145684 0.551853 0.700153 +v 1.153830 0.550812 0.696336 +v 1.160645 0.544831 0.688833 +v 1.165868 0.534141 0.677933 +v 1.169297 0.519151 0.664055 +v 1.170802 0.500439 0.647732 +v 1.170324 0.478722 0.629591 +v 1.167881 0.454837 0.610329 +v 1.081168 0.438741 0.633009 +v 1.088952 0.461999 0.654588 +v 1.097898 0.483732 0.674086 +v 1.107664 0.503102 0.690753 +v 1.117873 0.519366 0.703950 +v 1.128133 0.531899 0.713168 +v 1.138050 0.540220 0.718054 +v 1.147243 0.544007 0.718420 +v 1.155359 0.543117 0.714252 +v 1.162085 0.537583 0.705710 +v 1.167164 0.527617 0.693122 +v 1.170400 0.513603 0.676972 +v 1.171668 0.496080 0.657880 +v 1.170921 0.475720 0.636581 +v 1.168186 0.453306 0.613893 +v 1.081262 0.436297 0.635688 +v 1.089136 0.457207 0.659843 +v 1.098166 0.476773 0.681716 +v 1.108004 0.494246 0.700464 +v 1.118273 0.508953 0.715369 +v 1.128578 0.520328 0.725856 +v 1.138523 0.527936 0.731524 +v 1.147725 0.531483 0.732153 +v 1.155831 0.530833 0.727721 +v 1.162531 0.526012 0.718397 +v 1.167565 0.517203 0.704540 +v 1.170740 0.504747 0.686682 +v 1.171936 0.489121 0.665510 +v 1.171105 0.470927 0.641837 +v 1.168280 0.450863 0.616572 +v 1.081143 0.433035 0.637380 +v 1.088901 0.450808 0.663162 +v 1.097825 0.467484 0.686533 +v 1.107570 0.482422 0.706595 +v 1.117763 0.495050 0.722578 +v 1.128011 0.504880 0.733867 +v 1.137920 0.511536 0.740028 +v 1.147111 0.514762 0.740824 +v 1.155229 0.514433 0.736226 +v 1.161963 0.510563 0.726409 +v 1.167054 0.503300 0.711750 +v 1.170306 0.492923 0.692814 +v 1.171595 0.479832 0.670327 +v 1.170870 0.464528 0.645155 +v 1.168160 0.447601 0.618264 +v 1.080813 0.429080 0.638019 +v 1.088256 0.443049 0.664415 +v 1.096888 0.456219 0.688353 +v 1.106378 0.468085 0.708912 +v 1.116360 0.478191 0.725302 +v 1.126452 0.486148 0.736894 +v 1.136266 0.491650 0.743241 +v 1.145424 0.494486 0.744100 +v 1.153575 0.494548 0.739439 +v 1.160405 0.491831 0.729435 +v 1.165652 0.486442 0.714474 +v 1.169114 0.478587 0.695130 +v 1.170658 0.468567 0.672148 +v 1.170224 0.456769 0.646409 +v 1.167831 0.443645 0.618903 +v 1.080288 0.424583 0.637581 +v 1.087225 0.434228 0.663556 +v 1.095391 0.443413 0.687106 +v 1.104473 0.451786 0.707324 +v 1.114120 0.459026 0.723435 +v 1.123963 0.464852 0.734819 +v 1.133624 0.469043 0.741039 +v 1.142730 0.471436 0.741855 +v 1.150933 0.471940 0.737237 +v 1.157916 0.470535 0.727361 +v 1.163412 0.467276 0.712607 +v 1.167209 0.462288 0.693543 +v 1.169161 0.455761 0.670900 +v 1.169194 0.447948 0.645550 +v 1.167305 0.439148 0.618465 +v 1.079586 0.419717 0.636083 +v 1.085848 0.424684 0.660617 +v 1.093392 0.429557 0.682839 +v 1.101928 0.434151 0.701894 +v 1.111129 0.438289 0.717050 +v 1.120639 0.441811 0.727724 +v 1.130095 0.444582 0.733507 +v 1.139132 0.446496 0.734175 +v 1.147404 0.447480 0.729704 +v 1.154592 0.447494 0.720266 +v 1.160420 0.446540 0.706222 +v 1.164664 0.444653 0.688112 +v 1.167162 0.441905 0.666633 +v 1.167817 0.438404 0.642611 +v 1.166603 0.434283 0.616967 +v 1.078735 0.414670 0.633582 +v 1.084178 0.414783 0.655711 +v 1.090968 0.415185 0.675717 +v 1.098843 0.415858 0.692829 +v 1.107500 0.416778 0.706391 +v 1.116608 0.417910 0.715880 +v 1.125815 0.419209 0.720933 +v 1.134769 0.420626 0.721356 +v 1.143124 0.422106 0.717131 +v 1.150560 0.423593 0.708422 +v 1.156792 0.425029 0.695562 +v 1.161579 0.426359 0.679047 +v 1.164738 0.427533 0.659511 +v 1.166147 0.428504 0.637705 +v 1.165752 0.429236 0.614466 +v 1.077767 0.409635 0.630174 +v 1.082279 0.404907 0.649027 +v 1.088211 0.400847 0.666013 +v 1.095334 0.397610 0.680478 +v 1.103375 0.395321 0.691868 +v 1.112024 0.394067 0.699743 +v 1.120949 0.393898 0.703802 +v 1.129807 0.394819 0.703889 +v 1.138258 0.396795 0.700000 +v 1.145976 0.399750 0.692285 +v 1.152666 0.403571 0.681040 +v 1.158070 0.408111 0.666697 +v 1.161981 0.413195 0.649807 +v 1.164248 0.418628 0.631021 +v 1.164784 0.424201 0.611058 +v 1.163568 0.429700 0.590688 +v 1.076719 0.404806 0.625991 +v 1.080225 0.395435 0.640822 +v 1.085228 0.387095 0.654100 +v 1.091538 0.380107 0.665316 +v 1.098911 0.374740 0.674039 +v 1.107064 0.371199 0.679933 +v 1.115683 0.369621 0.682772 +v 1.124438 0.370067 0.682447 +v 1.132992 0.372519 0.678970 +v 1.141016 0.376882 0.672475 +v 1.148202 0.382991 0.663211 +v 1.154274 0.390609 0.651535 +v 1.158998 0.399443 0.637895 +v 1.162193 0.409156 0.622815 +v 1.163736 0.419372 0.606875 +v 1.075633 0.400369 0.621193 +v 1.078093 0.386731 0.631410 +v 1.082134 0.374459 0.640436 +v 1.087599 0.364024 0.647926 +v 1.094279 0.355828 0.653590 +v 1.101918 0.350185 0.657211 +v 1.110220 0.347313 0.658651 +v 1.118868 0.347321 0.657853 +v 1.127529 0.350210 0.654848 +v 1.135870 0.355868 0.649753 +v 1.143571 0.364078 0.642762 +v 1.150335 0.374525 0.634144 +v 1.155904 0.386807 0.624231 +v 1.160062 0.400451 0.613403 +v 1.162650 0.414935 0.602077 +v 1.074548 0.396493 0.615964 +v 1.075967 0.379129 0.621154 +v 1.079047 0.363422 0.625547 +v 1.083670 0.349977 0.628975 +v 1.089659 0.339310 0.631306 +v 1.096784 0.331832 0.632451 +v 1.104770 0.327829 0.632365 +v 1.113311 0.327456 0.631052 +v 1.122079 0.330726 0.628563 +v 1.130736 0.337515 0.624992 +v 1.138950 0.347561 0.620478 +v 1.146406 0.360478 0.615193 +v 1.152816 0.375770 0.609341 +v 1.157935 0.392849 0.603147 +v 1.161566 0.411059 0.596849 +v 1.073509 0.393329 0.610506 +v 1.073927 0.372921 0.610447 +v 1.076085 0.354410 0.610003 +v 1.079901 0.338507 0.609192 +v 1.085227 0.325823 0.608044 +v 1.091859 0.316845 0.606603 +v 1.099542 0.311919 0.604925 +v 1.107980 0.311234 0.603075 +v 1.116851 0.314816 0.601123 +v 1.125811 0.322528 0.599144 +v 1.134518 0.334073 0.597215 +v 1.142637 0.349008 0.595410 +v 1.149855 0.366758 0.593798 +v 1.155895 0.386641 0.592441 +v 1.160526 0.407894 0.591390 +v 1.072553 0.390997 0.605028 +v 1.072052 0.368346 0.599702 +v 1.073364 0.347768 0.594404 +v 1.076437 0.330054 0.589337 +v 1.081154 0.315883 0.584697 +v 1.087333 0.305801 0.580661 +v 1.094737 0.300195 0.577386 +v 1.103082 0.299280 0.574996 +v 1.112046 0.303092 0.573583 +v 1.121285 0.311484 0.573203 +v 1.130445 0.324134 0.573869 +v 1.139173 0.340555 0.575555 +v 1.147133 0.360116 0.578198 +v 1.154021 0.382067 0.581695 +v 1.159570 0.405562 0.585913 +v 1.071718 0.389587 0.599741 +v 1.070414 0.365580 0.589331 +v 1.070986 0.343753 0.579347 +v 1.073411 0.324943 0.570173 +v 1.077595 0.309873 0.562163 +v 1.083379 0.299123 0.555623 +v 1.090540 0.293106 0.550805 +v 1.098802 0.292052 0.547894 +v 1.107849 0.296003 0.547003 +v 1.117332 0.304807 0.548164 +v 1.126887 0.318124 0.551335 +v 1.136147 0.335444 0.556392 +v 1.144756 0.356101 0.563141 +v 1.152383 0.379301 0.571324 +v 1.158735 0.404152 0.580625 +v 1.071036 0.389153 0.594848 +v 1.069077 0.364730 0.579732 +v 1.069044 0.342518 0.565412 +v 1.070939 0.323371 0.552438 +v 1.074690 0.308025 0.541308 +v 1.080150 0.297069 0.532450 +v 1.087112 0.290925 0.526205 +v 1.095307 0.289829 0.522812 +v 1.104421 0.293823 0.522402 +v 1.114103 0.302752 0.524991 +v 1.123981 0.316275 0.530479 +v 1.133675 0.333872 0.538656 +v 1.142814 0.354866 0.549206 +v 1.151046 0.378450 0.561725 +v 1.158053 0.403718 0.575732 +v 1.070533 0.389712 0.590536 +v 1.068091 0.365826 0.571275 +v 1.067613 0.344110 0.553134 +v 1.069118 0.325398 0.536811 +v 1.072547 0.310408 0.522933 +v 1.077770 0.299718 0.512033 +v 1.084585 0.293737 0.504530 +v 1.092731 0.292696 0.500713 +v 1.101894 0.296634 0.500728 +v 1.111722 0.305401 0.504574 +v 1.121838 0.318659 0.512105 +v 1.131854 0.335899 0.523029 +v 1.141383 0.356458 0.536929 +v 1.150059 0.379547 0.553268 +v 1.157551 0.404278 0.571421 +v 1.074846 0.414849 0.610178 +v 1.070229 0.391243 0.586972 +v 1.067494 0.368829 0.564284 +v 1.066747 0.348469 0.542985 +v 1.068015 0.330946 0.523894 +v 1.071251 0.316932 0.507744 +v 1.076329 0.306967 0.495156 +v 1.083056 0.301432 0.486614 +v 1.091172 0.300542 0.482445 +v 1.100365 0.304330 0.482811 +v 1.110282 0.312650 0.487697 +v 1.120542 0.325183 0.496916 +v 1.130751 0.341447 0.510112 +v 1.140516 0.360817 0.526780 +v 1.149463 0.382550 0.546278 +v 1.157247 0.405808 0.567857 +v 1.070135 0.393686 0.584293 +v 1.067310 0.373622 0.559029 +v 1.066479 0.355428 0.535356 +v 1.067675 0.339802 0.514183 +v 1.070850 0.327346 0.496325 +v 1.075884 0.318537 0.482468 +v 1.082583 0.313716 0.473145 +v 1.090690 0.313066 0.468712 +v 1.099892 0.316613 0.469342 +v 1.109837 0.324221 0.475010 +v 1.120142 0.335596 0.485497 +v 1.130410 0.350303 0.500402 +v 1.140249 0.367776 0.519150 +v 1.149279 0.387342 0.541022 +v 1.157153 0.408252 0.565178 +vn -0.672781 -0.204535 -0.710959 +vn -0.898373 -0.088931 -0.430067 +vn -0.876644 0.072756 -0.475539 +vn -0.997467 0.068545 0.018494 +vn -0.993500 0.086367 0.074129 +vn -0.992523 0.102908 0.065584 +vn 0.941404 -0.153844 -0.300119 +vn 0.908231 -0.176580 -0.379315 +vn 0.937925 -0.100772 -0.331828 +vn -0.152104 -0.310160 -0.938414 +vn -0.198889 -0.023286 -0.979736 +vn -0.997772 0.047273 -0.046663 +vn -0.994812 0.101535 0.001404 +vn 0.962035 -0.135166 -0.236976 +vn 0.961150 -0.101779 -0.256539 +vn 0.412458 -0.301157 -0.859737 +vn 0.343089 -0.060488 -0.937315 +vn -0.991333 0.019440 -0.129917 +vn -0.992401 0.099338 -0.072451 +vn 0.976043 -0.118656 -0.182318 +vn 0.976135 -0.101993 -0.191595 +vn 0.719718 -0.248726 -0.648152 +vn 0.676351 -0.081973 -0.731986 +vn -0.968688 -0.021241 -0.247261 +vn -0.981689 0.095645 -0.164678 +vn 0.848048 -0.206641 -0.487930 +vn 0.827662 -0.093204 -0.553392 +vn -0.952849 0.088565 -0.290139 +vn 0.899289 -0.098392 -0.426069 +vn -0.665792 0.034822 -0.745293 +vn -0.846431 0.208655 -0.489853 +vn -0.991119 0.118686 0.059786 +vn 0.933683 -0.046907 -0.354991 +vn -0.228523 0.209021 -0.950804 +vn -0.991028 0.133061 -0.010193 +vn 0.960173 -0.068239 -0.270821 +vn 0.277139 0.153752 -0.948424 +vn -0.984832 0.148473 -0.089450 +vn 0.976409 -0.085635 -0.198157 +vn 0.626759 0.080386 -0.775018 +vn -0.968413 0.165899 -0.185949 +vn 0.802332 0.021424 -0.596423 +vn -0.931425 0.186224 -0.312632 +vn 0.888028 -0.018738 -0.459365 +vn 0.776208 0.130039 -0.616901 +vn -0.908689 0.270241 -0.318155 +vn 0.876247 0.058138 -0.478256 +vn -0.643361 0.224097 -0.732017 +vn -0.815516 0.319437 -0.482528 +vn -0.989441 0.133274 0.056642 +vn 0.929441 0.005188 -0.368877 +vn -0.245003 0.383892 -0.890255 +vn -0.986602 0.162206 -0.016449 +vn 0.959471 -0.035951 -0.279458 +vn 0.222266 0.328990 -0.917783 +vn -0.976226 0.193304 -0.097964 +vn 0.976836 -0.070193 -0.202002 +vn 0.579180 0.226264 -0.783135 +vn -0.953795 0.228553 -0.194952 +vn 0.977538 -0.056124 -0.203040 +vn 0.539903 0.351177 -0.764946 +vn -0.939543 0.282876 -0.192877 +vn 0.753441 0.227729 -0.616779 +vn -0.887509 0.341136 -0.309702 +vn 0.866146 0.128880 -0.482833 +vn -0.617603 0.368267 -0.694906 +vn -0.788049 0.409223 -0.459883 +vn -0.987640 0.146306 0.056093 +vn 0.926176 0.053438 -0.373211 +vn -0.252632 0.515458 -0.818781 +vn -0.981933 0.188269 -0.017457 +vn 0.959319 -0.006195 -0.282235 +vn 0.181738 0.468245 -0.864681 +vn -0.967498 0.232887 -0.098361 +vn -0.977447 0.210639 -0.013398 +vn 0.960021 0.019868 -0.279122 +vn 0.156011 0.579455 -0.799890 +vn -0.959441 0.266671 -0.091220 +vn 0.978515 -0.043947 -0.201361 +vn 0.512742 0.455367 -0.727805 +vn -0.926969 0.328654 -0.180822 +vn 0.737602 0.311899 -0.598865 +vn -0.869625 0.399915 -0.289468 +vn 0.859706 0.190771 -0.473769 +vn -0.594195 0.479232 -0.645924 +vn -0.765801 0.482040 -0.425611 +vn -0.985809 0.157445 0.058077 +vn 0.924833 0.095828 -0.368084 +vn -0.254433 0.617847 -0.743980 +vn -0.575182 0.566820 -0.589770 +vn -0.749413 0.541063 -0.381573 +vn -0.984039 0.166540 0.062349 +vn 0.926054 0.130741 -0.353923 +vn -0.252022 0.701041 -0.667074 +vn -0.973418 0.228889 -0.004578 +vn 0.961852 0.041292 -0.270394 +vn 0.144475 0.670217 -0.727958 +vn -0.952635 0.294168 -0.076998 +vn 0.979766 -0.034028 -0.197089 +vn 0.499863 0.540849 -0.676443 +vn -0.916837 0.365856 -0.159734 +vn 0.731132 0.381237 -0.565752 +vn -0.855892 0.447584 -0.258950 +vn 0.858486 0.241798 -0.452193 +vn 0.735557 0.435041 -0.519272 +vn -0.738945 0.588336 -0.328318 +vn 0.863369 0.280618 -0.419263 +vn -0.560869 0.637928 -0.527665 +vn -0.551073 0.696860 -0.458968 +vn -0.982421 0.173345 0.068819 +vn 0.930296 0.157018 -0.331462 +vn -0.246101 0.771630 -0.586505 +vn -0.970061 0.242653 0.008667 +vn 0.964843 0.057344 -0.256386 +vn 0.146641 0.746055 -0.649495 +vn -0.947386 0.315043 -0.056307 +vn 0.981323 -0.026582 -0.190435 +vn 0.502518 0.609516 -0.613117 +vn -0.909635 0.394391 -0.130345 +vn 0.968993 0.067476 -0.237648 +vn 0.162847 0.810358 -0.562792 +vn -0.846767 0.484756 -0.219001 +vn -0.842189 0.511643 -0.169958 +vn 0.521378 0.662160 -0.538224 +vn -0.734153 0.624866 -0.265572 +vn 0.751366 0.472518 -0.460555 +vn -0.545396 0.746117 -0.381878 +vn -0.967437 0.251656 0.026002 +vn 0.874599 0.306070 -0.375988 +vn -0.236579 0.833583 -0.499130 +vn -0.943876 0.328959 -0.029603 +vn 0.937498 0.173742 -0.301431 +vn -0.905423 0.414075 -0.093265 +vn 0.947325 0.180242 -0.264657 +vn -0.222541 0.888974 -0.400189 +vn -0.904111 0.424451 -0.048921 +vn 0.983123 -0.021821 -0.181585 +vn 0.974059 0.071322 -0.214667 +vn 0.194128 0.864284 -0.464003 +vn -0.841853 0.527909 -0.111942 +vn 0.556658 0.697928 -0.450545 +vn -0.734581 0.650655 -0.192328 +vn 0.778161 0.492233 -0.390027 +vn -0.543321 0.786554 -0.293374 +vn -0.980987 0.177831 0.077303 +vn -0.965606 0.255593 0.046937 +vn 0.891568 0.317057 -0.323283 +vn -0.941984 0.335551 0.002533 +vn -0.979766 0.179785 0.087619 +vn -0.964476 0.254311 0.071078 +vn 0.912961 0.312510 -0.262276 +vn -0.202246 0.937559 -0.282876 +vn -0.941557 0.334452 0.039460 +vn 0.958953 0.175939 -0.222266 +vn -0.905209 0.424940 0.002136 +vn 0.985107 -0.019868 -0.170721 +vn 0.979736 0.068575 -0.188147 +vn 0.242317 0.905911 -0.347209 +vn -0.845149 0.532579 -0.044771 +vn 0.607868 0.713858 -0.347667 +vn -0.739555 0.664510 -0.106906 +vn 0.814203 0.492172 -0.307871 +vn -0.544053 0.817408 -0.189245 +vn -0.747826 0.663808 -0.007324 +vn 0.856349 0.469527 -0.214789 +vn -0.546098 0.835261 -0.063662 +vn -0.978759 0.179113 0.099521 +vn -0.963897 0.247597 0.097720 +vn 0.936521 0.291574 -0.194586 +vn -0.172582 0.975341 -0.137455 +vn -0.942167 0.325297 0.080508 +vn 0.971221 0.160680 -0.175665 +vn -0.907987 0.414686 0.059420 +vn 0.987182 -0.020905 -0.158086 +vn 0.985473 0.059206 -0.159062 +vn 0.309305 0.928678 -0.204505 +vn -0.851039 0.524094 0.031678 +vn 0.672811 0.704062 -0.227058 +vn 0.394635 0.918393 -0.027894 +vn -0.857936 0.500168 0.117161 +vn 0.746147 0.659902 -0.087893 +vn -0.757225 0.644093 0.108249 +vn 0.899625 0.421735 -0.113041 +vn -0.546434 0.832606 0.090152 +vn -0.977935 0.175726 0.112766 +vn -0.963652 0.235450 0.126164 +vn 0.959380 0.254067 -0.122593 +vn -0.129063 0.990448 0.048250 +vn -0.943266 0.307718 0.124638 +vn 0.982727 0.134770 -0.126621 +vn -0.911496 0.392743 0.121952 +vn 0.989227 -0.025056 -0.144139 +vn 0.990753 0.043428 -0.128483 +vn 0.992035 0.099155 -0.077273 +vn -0.067629 0.956816 0.282693 +vn -0.914487 0.358104 0.188299 +vn 0.991058 -0.032136 -0.129307 +vn 0.994964 0.021851 -0.097629 +vn 0.491501 0.851314 0.183416 +vn -0.863643 0.457991 0.210425 +vn 0.817621 0.572069 0.064760 +vn -0.764183 0.598590 0.240181 +vn 0.937468 0.347911 -0.007447 +vn -0.539506 0.794885 0.277505 +vn -0.977294 0.169591 0.126957 +vn -0.963500 0.217780 0.155644 +vn 0.978332 0.200964 -0.049623 +vn -0.944243 0.281503 0.170690 +vn -0.976745 0.160680 0.141728 +vn -0.963225 0.194769 0.185003 +vn 0.990692 0.134587 0.019929 +vn -0.517350 0.699820 0.492477 +vn -0.944487 0.246529 0.217017 +vn 0.998016 0.055269 -0.030091 +vn 0.009095 0.835170 0.549883 +vn -0.915586 0.309976 0.256050 +vn 0.992553 -0.042146 -0.114078 +vn 0.997681 -0.004883 -0.067843 +vn 0.583148 0.701956 0.408826 +vn -0.865474 0.394910 0.308145 +vn 0.873012 0.437117 0.216193 +vn -0.763482 0.519150 0.384075 +vn 0.963469 0.250710 0.093905 +vn -0.860775 0.309885 0.403668 +vn 0.973693 0.137883 0.181341 +vn -0.749626 0.400525 0.526872 +vn -0.976348 0.148991 0.156529 +vn -0.962737 0.166814 0.212714 +vn 0.994934 0.059145 0.081149 +vn -0.474044 0.529954 0.703116 +vn -0.943602 0.203375 0.261116 +vn 0.999908 0.005371 0.012055 +vn 0.087130 0.605884 0.790735 +vn -0.913724 0.248634 0.321360 +vn 0.993530 -0.054872 -0.099124 +vn 0.998505 -0.035646 -0.040925 +vn 0.647694 0.470229 0.599414 +vn 0.900327 0.267037 0.343608 +vn 0.672781 0.204535 0.710959 +vn -0.908231 0.176580 0.379345 +vn 0.968688 0.021241 0.247261 +vn -0.848048 0.206641 0.487960 +vn 0.991333 -0.019440 0.129917 +vn -0.719718 0.248726 0.648152 +vn -0.976104 0.134678 0.170446 +vn -0.976043 0.118625 0.182318 +vn 0.997772 -0.047273 0.046663 +vn -0.412458 0.301126 0.859737 +vn -0.962035 0.135166 0.236976 +vn 0.997467 -0.068545 -0.018494 +vn 0.152104 0.310160 0.938414 +vn -0.941404 0.153844 0.300119 +vn 0.993866 -0.069948 -0.085452 +vn 0.993469 -0.086398 -0.074099 +vn 0.994812 -0.101505 -0.001434 +vn 0.198889 0.023316 0.979736 +vn -0.937925 0.100772 0.331828 +vn 0.992523 -0.102908 -0.065554 +vn 0.898373 0.088931 0.430067 +vn 0.876644 -0.072756 0.475539 +vn -0.899289 0.098392 0.426069 +vn 0.952849 -0.088565 0.290139 +vn -0.827662 0.093204 0.553392 +vn 0.981689 -0.095645 0.164678 +vn -0.676351 0.081973 0.731986 +vn -0.976135 0.102023 0.191595 +vn 0.992401 -0.099338 0.072481 +vn -0.343089 0.060488 0.937315 +vn -0.961150 0.101749 0.256539 +vn 0.984832 -0.148503 0.089450 +vn -0.277139 -0.153752 0.948424 +vn -0.960173 0.068209 0.270821 +vn 0.991028 -0.133061 0.010193 +vn 0.665822 -0.034822 0.745293 +vn 0.228523 -0.209021 0.950804 +vn -0.933683 0.046937 0.354991 +vn 0.991119 -0.118686 -0.059786 +vn 0.846431 -0.208625 0.489853 +vn -0.888028 0.018738 0.459365 +vn 0.931425 -0.186224 0.312632 +vn -0.802332 -0.021424 0.596454 +vn 0.968413 -0.165899 0.185949 +vn -0.626789 -0.080386 0.775018 +vn -0.976409 0.085665 0.198157 +vn 0.953795 -0.228523 0.194952 +vn -0.579180 -0.226264 0.783135 +vn -0.976836 0.070193 0.201972 +vn 0.976226 -0.193304 0.097964 +vn -0.222236 -0.328990 0.917783 +vn -0.959471 0.035951 0.279458 +vn 0.986602 -0.162206 0.016449 +vn 0.643361 -0.224097 0.732017 +vn 0.245003 -0.383892 0.890255 +vn -0.929441 -0.005188 0.368908 +vn 0.989441 -0.133274 -0.056642 +vn 0.815516 -0.319437 0.482528 +vn -0.876247 -0.058168 0.478256 +vn 0.908689 -0.270241 0.318155 +vn -0.776208 -0.130039 0.616901 +vn -0.866146 -0.128880 0.482833 +vn 0.887509 -0.341136 0.309702 +vn -0.753441 -0.227729 0.616779 +vn 0.939543 -0.282876 0.192877 +vn -0.539872 -0.351177 0.764946 +vn -0.977538 0.056154 0.203040 +vn 0.967498 -0.232887 0.098361 +vn -0.181738 -0.468245 0.864681 +vn -0.959319 0.006195 0.282235 +vn 0.981933 -0.188269 0.017457 +vn 0.617573 -0.368267 0.694906 +vn 0.252632 -0.515458 0.818781 +vn -0.926176 -0.053438 0.373211 +vn 0.987640 -0.146275 -0.056093 +vn 0.788049 -0.409223 0.459883 +vn 0.594226 -0.479202 0.645924 +vn 0.254433 -0.617847 0.743980 +vn -0.924833 -0.095828 0.368084 +vn 0.985809 -0.157445 -0.058077 +vn 0.765801 -0.482040 0.425611 +vn -0.859706 -0.190741 0.473769 +vn 0.869625 -0.399915 0.289468 +vn -0.737602 -0.311899 0.598865 +vn 0.926969 -0.328654 0.180822 +vn -0.512742 -0.455367 0.727805 +vn -0.978515 0.043947 0.201361 +vn 0.959441 -0.266671 0.091220 +vn -0.156011 -0.579455 0.799890 +vn -0.960021 -0.019868 0.279122 +vn 0.977447 -0.210639 0.013398 +vn 0.952635 -0.294137 0.076998 +vn -0.144475 -0.670217 0.727958 +vn -0.961852 -0.041292 0.270394 +vn 0.973418 -0.228889 0.004578 +vn 0.575182 -0.566820 0.589770 +vn 0.252022 -0.701041 0.667074 +vn -0.926084 -0.130741 0.353923 +vn 0.984039 -0.166540 -0.062349 +vn 0.749413 -0.541063 0.381573 +vn -0.858486 -0.241798 0.452193 +vn 0.855892 -0.447584 0.258950 +vn -0.731132 -0.381237 0.565752 +vn 0.916837 -0.365856 0.159734 +vn -0.499863 -0.540849 0.676443 +vn -0.979766 0.033998 0.197089 +vn 0.909604 -0.394421 0.130345 +vn -0.502518 -0.609516 0.613117 +vn -0.981323 0.026582 0.190435 +vn 0.947386 -0.315043 0.056307 +vn -0.146641 -0.746055 0.649525 +vn -0.964843 -0.057314 0.256417 +vn 0.970061 -0.242653 -0.008667 +vn 0.560869 -0.637928 0.527665 +vn 0.246101 -0.771630 0.586505 +vn -0.930296 -0.157018 0.331462 +vn 0.982421 -0.173376 -0.068819 +vn 0.551073 -0.696860 0.458968 +vn -0.863369 -0.280618 0.419263 +vn 0.738945 -0.588336 0.328318 +vn -0.735527 -0.435041 0.519272 +vn -0.751396 -0.472488 0.460555 +vn 0.846767 -0.484756 0.219001 +vn 0.734153 -0.624866 0.265572 +vn -0.521378 -0.662160 0.538224 +vn 0.842189 -0.511673 0.169988 +vn -0.162816 -0.810389 0.562792 +vn -0.968993 -0.067476 0.237648 +vn 0.905423 -0.414075 0.093265 +vn -0.937498 -0.173742 0.301431 +vn 0.943876 -0.328959 0.029603 +vn 0.236549 -0.833583 0.499130 +vn -0.874599 -0.306070 0.375988 +vn 0.967467 -0.251625 -0.025971 +vn 0.545396 -0.746117 0.381878 +vn 0.222541 -0.888974 0.400189 +vn -0.891568 -0.317057 0.323283 +vn 0.980987 -0.177831 -0.077303 +vn 0.965606 -0.255593 -0.046968 +vn 0.543321 -0.786554 0.293374 +vn -0.778161 -0.492233 0.390027 +vn 0.734611 -0.650624 0.192328 +vn -0.556658 -0.697928 0.450545 +vn 0.841853 -0.527909 0.111942 +vn -0.194098 -0.864284 0.464003 +vn -0.983123 0.021821 0.181585 +vn -0.974059 -0.071322 0.214667 +vn 0.904111 -0.424451 0.048921 +vn -0.947325 -0.180242 0.264687 +vn 0.941984 -0.335551 -0.002533 +vn 0.905179 -0.424940 -0.002136 +vn 0.202246 -0.937559 0.282876 +vn -0.958953 -0.175939 0.222266 +vn 0.941557 -0.334452 -0.039491 +vn -0.912961 -0.312510 0.262276 +vn 0.979766 -0.179785 -0.087588 +vn 0.964476 -0.254311 -0.071078 +vn 0.544053 -0.817408 0.189245 +vn -0.814203 -0.492141 0.307871 +vn 0.739555 -0.664510 0.106906 +vn -0.607868 -0.713828 0.347697 +vn 0.845149 -0.532579 0.044771 +vn -0.242317 -0.905911 0.347209 +vn -0.985107 0.019868 0.170721 +vn -0.979736 -0.068575 0.188147 +vn 0.851039 -0.524094 -0.031678 +vn -0.309305 -0.928709 0.204505 +vn -0.987182 0.020905 0.158086 +vn -0.985473 -0.059206 0.159062 +vn 0.907987 -0.414686 -0.059420 +vn 0.172582 -0.975341 0.137455 +vn -0.971221 -0.160649 0.175665 +vn 0.942167 -0.325297 -0.080508 +vn -0.936521 -0.291574 0.194586 +vn 0.978759 -0.179113 -0.099521 +vn 0.963897 -0.247597 -0.097720 +vn 0.546098 -0.835261 0.063662 +vn -0.856349 -0.469527 0.214789 +vn 0.747826 -0.663808 0.007324 +vn -0.672811 -0.704062 0.227027 +vn 0.757225 -0.644093 -0.108249 +vn -0.746147 -0.659902 0.087893 +vn 0.857936 -0.500168 -0.117161 +vn -0.394635 -0.918393 0.027894 +vn -0.989227 0.025056 0.144108 +vn -0.990753 -0.043458 0.128483 +vn 0.911496 -0.392743 -0.121952 +vn 0.129063 -0.990448 -0.048250 +vn -0.982727 -0.134770 0.126621 +vn 0.943266 -0.307718 -0.124638 +vn -0.959380 -0.254067 0.122593 +vn 0.977935 -0.175695 -0.112766 +vn 0.963652 -0.235420 -0.126164 +vn 0.546434 -0.832606 -0.090152 +vn -0.899625 -0.421766 0.113010 +vn -0.978332 -0.200934 0.049623 +vn 0.977294 -0.169561 -0.126988 +vn 0.963500 -0.217780 -0.155614 +vn 0.539506 -0.794885 -0.277505 +vn -0.937468 -0.347911 0.007447 +vn 0.764183 -0.598590 -0.240181 +vn -0.817621 -0.572069 -0.064760 +vn 0.863643 -0.458022 -0.210425 +vn -0.491501 -0.851314 -0.183416 +vn -0.991058 0.032167 0.129276 +vn -0.994964 -0.021851 0.097598 +vn 0.914487 -0.358104 -0.188299 +vn 0.067629 -0.956816 -0.282693 +vn -0.992035 -0.099155 0.077273 +vn 0.944243 -0.281503 -0.170690 +vn -0.009095 -0.835170 -0.549883 +vn -0.998016 -0.055269 0.030091 +vn 0.944487 -0.246559 -0.217017 +vn 0.517350 -0.699820 -0.492477 +vn -0.990692 -0.134587 -0.019929 +vn 0.976745 -0.160680 -0.141728 +vn 0.963225 -0.194769 -0.185003 +vn -0.963469 -0.250710 -0.093905 +vn 0.763482 -0.519150 -0.384075 +vn -0.873012 -0.437117 -0.216193 +vn 0.865474 -0.394910 -0.308145 +vn -0.583148 -0.701956 -0.408826 +vn -0.992553 0.042146 0.114078 +vn -0.997681 0.004852 0.067843 +vn 0.915586 -0.309976 -0.256050 +vn 0.860775 -0.309915 -0.403668 +vn -0.647694 -0.470260 -0.599414 +vn -0.993530 0.054872 0.099124 +vn -0.998505 0.035646 0.040925 +vn 0.913724 -0.248634 -0.321360 +vn -0.087130 -0.605914 -0.790735 +vn -0.999908 -0.005371 -0.012055 +vn 0.943602 -0.203375 -0.261116 +vn 0.474044 -0.529954 -0.703116 +vn -0.994934 -0.059175 -0.081149 +vn 0.976348 -0.148991 -0.156560 +vn 0.962737 -0.166784 -0.212714 +vn 0.749626 -0.400525 -0.526872 +vn -0.973693 -0.137883 -0.181341 +vn -0.900327 -0.267037 -0.343608 +vn 0.986389 -0.102298 -0.128636 +vn -0.986389 0.102298 0.128636 +vn 0.976104 -0.134739 -0.170446 +vn -0.993866 0.069948 0.085452 +vn -0.992523 0.102878 0.065584 +vn 0.908231 -0.176580 -0.379345 +vn 0.937925 -0.100742 -0.331828 +vn -0.198889 -0.023316 -0.979736 +vn -0.994812 0.101505 0.001434 +vn -0.992401 0.099338 -0.072481 +vn 0.976043 -0.118625 -0.182318 +vn 0.848048 -0.206641 -0.487960 +vn -0.846431 0.208625 -0.489853 +vn 0.933683 -0.046937 -0.354991 +vn 0.960173 -0.068209 -0.270821 +vn -0.984832 0.148473 -0.089480 +vn 0.976409 -0.085665 -0.198157 +vn 0.802332 0.021424 -0.596454 +vn 0.876247 0.058168 -0.478256 +vn 0.959471 -0.035920 -0.279458 +vn 0.222236 0.328990 -0.917783 +vn 0.977538 -0.056154 -0.203040 +vn -0.617573 0.368267 -0.694906 +vn 0.926176 0.053407 -0.373211 +vn -0.967498 0.232917 -0.098361 +vn 0.156011 0.579485 -0.799890 +vn 0.859706 0.190741 -0.473769 +vn -0.594226 0.479202 -0.645924 +vn 0.924833 0.095798 -0.368084 +vn -0.254402 0.617847 -0.743980 +vn 0.926084 0.130741 -0.353923 +vn -0.855892 0.447554 -0.258950 +vn 0.735557 0.435072 -0.519272 +vn -0.738945 0.588305 -0.328318 +vn -0.982421 0.173376 0.068819 +vn 0.964843 0.057344 -0.256417 +vn -0.909604 0.394421 -0.130345 +vn 0.162816 0.810389 -0.562792 +vn -0.842189 0.511643 -0.169988 +vn 0.751396 0.472488 -0.460555 +vn -0.967467 0.251625 0.025971 +vn -0.236549 0.833583 -0.499130 +vn 0.947325 0.180242 -0.264687 +vn 0.194098 0.864284 -0.464003 +vn -0.734611 0.650624 -0.192328 +vn -0.965606 0.255593 0.046968 +vn 0.891568 0.317087 -0.323283 +vn -0.979766 0.179785 0.087588 +vn -0.941557 0.334452 0.039491 +vn -0.905179 0.424940 0.002136 +vn 0.985107 -0.019868 -0.170690 +vn 0.607868 0.713828 -0.347697 +vn -0.747826 0.663839 -0.007324 +vn 0.856380 0.469527 -0.214789 +vn -0.963897 0.247627 0.097720 +vn 0.936521 0.291543 -0.194586 +vn 0.985473 0.059175 -0.159062 +vn -0.851039 0.524094 0.031648 +vn 0.394665 0.918393 -0.027894 +vn 0.899625 0.421766 -0.113010 +vn -0.977935 0.175695 0.112766 +vn -0.963652 0.235420 0.126164 +vn 0.989227 -0.025025 -0.144139 +vn 0.990753 0.043458 -0.128483 +vn -0.067598 0.956816 0.282693 +vn 0.991058 -0.032136 -0.129276 +vn -0.863643 0.458022 0.210425 +vn -0.977294 0.169561 0.126988 +vn 0.978332 0.200934 -0.049623 +vn -0.944487 0.246559 0.217017 +vn -0.915586 0.309946 0.256081 +vn 0.997681 -0.004852 -0.067843 +vn -0.860805 0.309885 0.403668 +vn -0.962737 0.166784 0.212714 +vn 0.994934 0.059175 0.081149 +vn -0.474044 0.529923 0.703116 +vn 0.087130 0.605914 0.790735 +vn 0.993530 -0.054903 -0.099124 +vn 0.647694 0.470260 0.599414 +vn -0.976043 0.118656 0.182318 +vn -0.343089 0.060518 0.937315 +vn -0.961150 0.101779 0.256539 +vn 0.984832 -0.148473 0.089480 +vn -0.960173 0.068239 0.270821 +vn 0.665792 -0.034822 0.745293 +vn -0.933683 0.046907 0.354991 +vn 0.846431 -0.208655 0.489853 +vn -0.976409 0.085635 0.198157 +vn 0.953795 -0.228553 0.194952 +vn -0.976867 0.070193 0.201972 +vn -0.222266 -0.328990 0.917783 +vn -0.959471 0.035981 0.279458 +vn 0.986602 -0.162236 0.016449 +vn 0.245033 -0.383892 0.890255 +vn -0.929441 -0.005219 0.368877 +vn 0.989441 -0.133244 -0.056642 +vn -0.876247 -0.058138 0.478256 +vn -0.753441 -0.227760 0.616779 +vn -0.539903 -0.351177 0.764946 +vn -0.977538 0.056124 0.203040 +vn 0.967498 -0.232887 0.098392 +vn 0.252632 -0.515488 0.818781 +vn 0.985809 -0.157476 -0.058077 +vn -0.978515 0.043977 0.201361 +vn -0.156041 -0.579455 0.799890 +vn 0.952635 -0.294168 0.076998 +vn -0.926054 -0.130741 0.353923 +vn 0.984039 -0.166509 -0.062349 +vn -0.979766 0.034028 0.197089 +vn 0.909635 -0.394391 0.130345 +vn -0.502518 -0.609516 0.613147 +vn -0.146641 -0.746055 0.649495 +vn -0.964843 -0.057344 0.256417 +vn 0.982421 -0.173345 -0.068819 +vn -0.735557 -0.435041 0.519272 +vn -0.751366 -0.472518 0.460555 +vn 0.842189 -0.511673 0.169958 +vn -0.162816 -0.810358 0.562792 +vn 0.967437 -0.251656 -0.025971 +vn -0.194128 -0.864284 0.464003 +vn 0.905209 -0.424940 -0.002136 +vn 0.979766 -0.179785 -0.087619 +vn -0.814203 -0.492172 0.307871 +vn -0.607868 -0.713858 0.347667 +vn 0.845180 -0.532579 0.044771 +vn 0.851039 -0.524094 -0.031648 +vn -0.309305 -0.928678 0.204505 +vn 0.907987 -0.414716 -0.059420 +vn -0.971221 -0.160680 0.175665 +vn -0.856380 -0.469527 0.214789 +vn 0.857936 -0.500137 -0.117161 +vn -0.989227 0.025056 0.144139 +vn -0.990753 -0.043428 0.128483 +vn -0.899625 -0.421735 0.113041 +vn 0.977294 -0.169561 -0.126957 +vn 0.963500 -0.217780 -0.155644 +vn 0.863643 -0.457991 -0.210425 +vn -0.991058 0.032136 0.129307 +vn -0.994964 -0.021851 0.097629 +vn 0.067598 -0.956816 -0.282693 +vn 0.944487 -0.246529 -0.217017 +vn -0.997681 0.004883 0.067843 +vn -0.647694 -0.470229 -0.599414 +vn -0.993530 0.054903 0.099124 +vn 0.962737 -0.166814 -0.212714 +vn 0.976104 -0.134709 -0.170446 +usemtl SkinColor +s 1 +f 489//483 488//484 503//485 +f 484//486 483//487 498//488 +f 495//489 494//490 510//491 +f 490//492 489//483 505//493 +f 485//494 484//486 499//495 +f 496//496 495//489 511//497 +f 491//498 490//492 506//499 +f 486//500 485//494 500//501 +f 497//502 496//496 512//503 +f 492//504 491//498 507//505 +f 487//506 486//500 501//507 +f 493//508 492//504 508//509 +f 488//484 487//506 502//510 +f 494//490 493//508 509//511 +f 504//512 503//485 518//513 +f 499//495 498//488 513//514 +f 510//491 509//511 525//515 +f 505//493 504//512 520//516 +f 500//501 499//495 514//517 +f 511//497 510//491 526//518 +f 506//499 505//493 521//519 +f 501//507 500//501 515//520 +f 512//503 511//497 527//521 +f 507//505 506//499 522//522 +f 502//510 501//507 516//523 +f 508//509 507//505 523//524 +f 503//485 502//510 517//525 +f 509//511 508//509 524//526 +f 523//524 522//522 538//527 +f 518//513 517//525 532//528 +f 524//526 523//524 539//529 +f 519//530 518//513 533//531 +f 514//517 513//514 528//532 +f 525//515 524//526 540//533 +f 520//516 519//530 535//534 +f 515//520 514//517 529//535 +f 526//518 525//515 541//536 +f 521//519 520//516 536//537 +f 516//523 515//520 530//538 +f 527//521 526//518 542//539 +f 522//522 521//519 537//540 +f 517//525 516//523 531//541 +f 542//539 541//536 557//542 +f 537//540 536//537 552//543 +f 532//528 531//541 546//544 +f 538//527 537//540 553//545 +f 533//531 532//528 547//546 +f 539//529 538//527 554//547 +f 534//548 533//531 548//549 +f 529//535 528//532 543//550 +f 540//533 539//529 555//551 +f 535//534 534//548 550//552 +f 530//538 529//535 544//553 +f 541//536 540//533 556//554 +f 536//537 535//534 551//555 +f 531//541 530//538 545//556 +f 545//556 544//553 559//557 +f 556//554 555//551 571//558 +f 551//555 550//552 566//559 +f 546//544 545//556 560//560 +f 557//542 556//554 572//561 +f 552//543 551//555 567//562 +f 547//546 546//544 561//563 +f 553//545 552//543 568//564 +f 548//549 547//546 562//565 +f 554//547 553//545 569//566 +f 549//567 548//549 563//568 +f 544//553 543//550 558//569 +f 555//551 554//547 570//570 +f 550//552 549//567 565//571 +f 564//572 563//568 578//573 +f 559//557 558//569 573//574 +f 570//570 569//566 585//575 +f 565//571 564//572 580//576 +f 560//560 559//557 574//577 +f 571//558 570//570 586//578 +f 566//559 565//571 581//579 +f 561//563 560//560 575//580 +f 572//561 571//558 587//581 +f 567//562 566//559 582//582 +f 562//565 561//563 576//583 +f 568//564 567//562 583//584 +f 563//568 562//565 577//585 +f 569//566 568//564 584//586 +f 583//584 582//582 598//587 +f 578//573 577//585 593//588 +f 584//586 583//584 599//589 +f 579//590 578//573 594//591 +f 574//577 573//574 588//592 +f 585//575 584//586 600//593 +f 580//576 579//590 595//594 +f 575//580 574//577 589//595 +f 586//578 585//575 601//596 +f 581//579 580//576 596//597 +f 576//583 575//580 590//598 +f 587//581 586//578 602//599 +f 582//582 581//579 597//600 +f 577//585 576//583 591//601 +f 602//599 601//596 616//602 +f 597//600 596//597 611//603 +f 592//604 591//601 607//605 +f 598//587 597//600 612//606 +f 593//588 592//604 608//607 +f 599//589 598//587 613//608 +f 594//591 593//588 609//609 +f 589//595 588//592 604//610 +f 600//593 599//589 614//611 +f 595//594 594//591 610//612 +f 590//598 589//595 605//613 +f 601//596 600//593 615//614 +f 596//597 595//594 611//603 +f 591//601 590//598 606//615 +f 616//602 615//614 630//616 +f 611//603 610//612 625//617 +f 606//615 605//613 621//618 +f 617//619 616//602 631//620 +f 612//606 611//603 626//621 +f 607//605 606//615 622//622 +f 613//608 612//606 627//623 +f 608//607 607//605 623//624 +f 614//611 613//608 628//625 +f 609//609 608//607 624//626 +f 604//610 603//627 619//628 +f 615//614 614//611 629//629 +f 610//612 609//609 625//617 +f 605//613 604//610 620//630 +f 619//628 618//631 634//632 +f 630//616 629//629 644//633 +f 625//617 624//626 640//634 +f 620//630 619//628 635//635 +f 631//620 630//616 645//636 +f 626//621 625//617 640//634 +f 621//618 620//630 636//637 +f 632//638 631//620 646//639 +f 627//623 626//621 641//640 +f 622//622 621//618 637//641 +f 628//625 627//623 642//642 +f 623//624 622//622 638//643 +f 629//629 628//625 643//644 +f 624//626 623//624 639//645 +f 638//643 637//641 653//646 +f 644//633 643//644 658//647 +f 639//645 638//643 654//648 +f 634//632 633//649 649//650 +f 645//636 644//633 659//651 +f 640//634 639//645 655//652 +f 635//635 634//632 650//653 +f 646//639 645//636 660//654 +f 641//640 640//634 655//652 +f 636//637 635//635 651//655 +f 647//656 646//639 661//657 +f 642//642 641//640 656//658 +f 637//641 636//637 652//659 +f 643//644 642//642 657//660 +f 657//660 656//658 671//661 +f 652//659 651//655 667//662 +f 658//647 657//660 672//663 +f 653//646 652//659 668//664 +f 659//651 658//647 673//665 +f 654//648 653//646 669//666 +f 649//650 648//667 664//668 +f 660//654 659//651 674//669 +f 655//652 654//648 670//670 +f 650//653 649//650 665//671 +f 661//657 660//654 675//672 +f 656//658 655//652 670//670 +f 651//655 650//653 666//673 +f 662//674 661//657 676//675 +f 676//675 675//672 690//676 +f 671//661 670//670 685//677 +f 666//673 665//671 681//678 +f 677//679 676//675 691//680 +f 672//663 671//661 686//681 +f 667//662 666//673 682//682 +f 673//665 672//663 687//683 +f 668//664 667//662 683//684 +f 674//669 673//665 688//685 +f 669//666 668//664 684//686 +f 664//668 663//687 679//688 +f 675//672 674//669 689//689 +f 670//670 669//666 685//677 +f 665//671 664//668 680//690 +f 679//688 678//691 694//692 +f 690//676 689//689 704//693 +f 685//677 684//686 699//694 +f 680//690 679//688 695//695 +f 691//680 690//676 705//696 +f 686//681 685//677 700//697 +f 681//678 680//690 696//698 +f 692//699 691//680 706//700 +f 687//683 686//681 701//701 +f 682//682 681//678 697//702 +f 688//685 687//683 702//703 +f 683//684 682//682 698//704 +f 689//689 688//685 703//705 +f 684//686 683//684 699//694 +f 698//704 697//702 712//706 +f 704//693 703//705 718//707 +f 699//694 698//704 713//708 +f 694//692 693//709 709//710 +f 705//696 704//693 719//711 +f 700//697 699//694 714//712 +f 695//695 694//692 710//713 +f 706//700 705//696 720//714 +f 701//701 700//697 715//715 +f 696//698 695//695 711//716 +f 707//717 706//700 721//718 +f 702//703 701//701 716//719 +f 697//702 696//698 712//706 +f 703//705 702//703 717//720 +f 717//720 716//719 731//721 +f 712//706 711//716 726//722 +f 718//707 717//720 733//723 +f 713//708 712//706 727//724 +f 719//711 718//707 734//725 +f 714//712 713//708 728//726 +f 709//710 708//727 723//728 +f 720//714 719//711 735//729 +f 715//715 714//712 729//730 +f 710//713 709//710 724//731 +f 721//718 720//714 736//732 +f 716//719 715//715 730//733 +f 711//716 710//713 725//734 +f 722//735 721//718 737//736 +f 736//732 735//729 751//737 +f 731//721 730//733 745//738 +f 726//722 725//734 740//739 +f 737//736 736//732 752//740 +f 732//741 731//721 747//742 +f 727//724 726//722 741//743 +f 733//723 732//741 748//744 +f 728//726 727//724 742//745 +f 734//725 733//723 749//746 +f 729//730 728//726 743//747 +f 724//731 723//728 738//748 +f 735//729 734//725 750//749 +f 730//733 729//730 744//750 +f 725//734 724//731 739//751 +f 750//749 749//746 765//752 +f 745//738 744//750 759//753 +f 740//739 739//751 754//754 +f 751//737 750//749 766//755 +f 746//756 745//738 760//757 +f 741//743 740//739 755//758 +f 752//740 751//737 767//759 +f 747//742 746//756 762//760 +f 742//745 741//743 756//761 +f 748//744 747//742 763//762 +f 743//747 742//745 757//763 +f 749//746 748//744 764//764 +f 744//750 743//747 758//765 +f 739//751 738//748 753//766 +f 764//764 763//762 779//767 +f 759//753 758//765 773//768 +f 754//754 753//766 768//769 +f 765//752 764//764 780//770 +f 760//757 759//753 774//771 +f 755//758 754//754 769//772 +f 766//755 765//752 781//773 +f 761//774 760//757 775//775 +f 756//761 755//758 770//776 +f 767//759 766//755 782//777 +f 762//760 761//774 777//778 +f 757//763 756//761 771//779 +f 763//762 762//760 778//780 +f 758//765 757//763 772//781 +f 772//781 771//779 786//782 +f 778//780 777//778 793//783 +f 773//768 772//781 787//784 +f 779//767 778//780 794//785 +f 774//771 773//768 788//786 +f 769//772 768//769 783//787 +f 780//770 779//767 795//788 +f 775//775 774//771 789//789 +f 770//776 769//772 784//790 +f 781//773 780//770 796//791 +f 776//792 775//775 790//793 +f 771//779 770//776 785//794 +f 782//777 781//773 797//795 +f 777//778 776//792 792//796 +f 791//797 790//793 805//798 +f 786//782 785//794 800//799 +f 797//795 796//791 812//800 +f 792//796 791//797 807//801 +f 787//784 786//782 801//802 +f 793//783 792//796 808//803 +f 788//786 787//784 802//804 +f 794//785 793//783 809//805 +f 789//789 788//786 803//806 +f 784//790 783//787 798//807 +f 795//788 794//785 810//808 +f 790//793 789//789 804//809 +f 785//794 784//790 799//810 +f 796//791 795//788 811//811 +f 810//808 809//805 826//812 +f 805//798 804//809 820//813 +f 800//799 799//810 815//814 +f 811//811 810//808 827//815 +f 806//816 805//798 821//817 +f 801//802 800//799 816//818 +f 812//800 811//811 828//819 +f 807//801 806//816 823//820 +f 802//804 801//802 817//821 +f 808//803 807//801 824//822 +f 803//806 802//804 818//823 +f 809//805 808//803 825//824 +f 804//809 803//806 819//825 +f 799//810 798//807 814//826 +f 825//824 824//822 840//827 +f 820//813 819//825 834//828 +f 815//814 814//826 829//829 +f 826//812 825//824 841//830 +f 821//817 820//813 835//831 +f 816//818 815//814 830//832 +f 827//815 826//812 842//833 +f 822//834 821//817 836//835 +f 817//821 816//818 831//836 +f 828//819 827//815 843//837 +f 823//820 822//834 837//838 +f 818//823 817//821 832//839 +f 824//822 823//820 838//840 +f 819//825 818//823 833//841 +f 833//841 832//839 848//842 +f 839//843 838//840 853//844 +f 834//828 833//841 849//845 +f 840//827 839//843 854//846 +f 835//831 834//828 850//847 +f 830//832 829//829 845//848 +f 841//830 840//827 855//849 +f 836//835 835//831 850//847 +f 831//836 830//832 846//850 +f 842//833 841//830 856//851 +f 837//838 836//835 851//852 +f 832//839 831//836 847//853 +f 843//837 842//833 857//854 +f 838//840 837//838 852//855 +f 852//855 851//852 866//856 +f 847//853 846//850 862//857 +f 858//858 857//854 872//859 +f 853//844 852//855 867//860 +f 848//842 847//853 863//861 +f 854//846 853//844 868//862 +f 849//845 848//842 864//863 +f 855//849 854//846 869//864 +f 850//847 849//845 865//865 +f 845//848 844//866 860//867 +f 856//851 855//849 870//868 +f 851//852 850//847 866//856 +f 846//850 845//848 861//869 +f 857//854 856//851 871//870 +f 871//870 870//868 885//871 +f 866//856 865//865 881//872 +f 861//869 860//867 876//873 +f 872//859 871//870 886//874 +f 867//860 866//856 881//872 +f 862//857 861//869 877//875 +f 873//876 872//859 887//877 +f 868//862 867//860 882//878 +f 863//861 862//857 878//879 +f 869//864 868//862 883//880 +f 864//863 863//861 879//881 +f 870//868 869//864 884//882 +f 865//865 864//863 880//883 +f 860//867 859//884 875//885 +f 885//871 884//882 899//886 +f 880//883 879//881 895//887 +f 875//885 874//888 890//889 +f 886//874 885//871 900//890 +f 881//872 880//883 896//891 +f 876//873 875//885 891//892 +f 887//877 886//874 901//893 +f 882//878 881//872 896//891 +f 877//875 876//873 892//894 +f 888//895 887//877 902//896 +f 883//880 882//878 897//897 +f 878//879 877//875 893//898 +f 884//882 883//880 898//899 +f 879//881 878//879 894//900 +f 899//886 898//899 913//901 +f 894//900 893//898 909//902 +f 900//890 899//886 914//903 +f 895//887 894//900 910//904 +f 890//889 889//905 905//906 +f 901//893 900//890 915//907 +f 896//891 895//887 911//908 +f 891//892 890//889 906//909 +f 902//896 901//893 916//910 +f 897//897 896//891 911//908 +f 892//894 891//892 907//911 +f 903//912 902//896 917//913 +f 898//899 897//897 912//914 +f 893//898 892//894 908//915 +f 907//911 906//909 922//916 +f 918//917 917//913 932//918 +f 913//901 912//914 927//919 +f 908//915 907//911 923//920 +f 914//903 913//901 928//921 +f 909//902 908//915 924//922 +f 915//907 914//903 929//923 +f 910//904 909//902 925//924 +f 905//906 904//925 920//926 +f 916//910 915//907 930//927 +f 911//908 910//904 926//928 +f 906//909 905//906 921//929 +f 917//913 916//910 931//930 +f 912//914 911//908 926//928 +f 926//928 925//924 942//931 +f 921//929 920//926 937//932 +f 932//918 931//930 947//933 +f 927//919 926//928 943//934 +f 922//916 921//929 938//935 +f 933//936 932//918 948//937 +f 928//921 927//919 943//934 +f 923//920 922//916 939//938 +f 929//923 928//921 944//939 +f 924//922 923//920 940//940 +f 930//927 929//923 945//941 +f 925//924 924//922 941//942 +f 920//926 919//943 936//944 +f 931//930 930//927 946//945 +f 946//945 945//941 960//946 +f 941//942 940//940 956//947 +f 936//944 935//948 951//949 +f 947//933 946//945 961//950 +f 942//931 941//942 957//951 +f 937//932 936//944 952//952 +f 948//937 947//933 962//953 +f 943//934 942//931 958//954 +f 938//935 937//932 953//955 +f 949//956 948//937 963//957 +f 944//939 943//934 959//958 +f 939//938 938//935 954//959 +f 945//941 944//939 960//946 +f 940//940 939//938 955//960 +f 813//961 497//502 512//503 +f 483//487 934//962 498//488 +f 813//961 512//503 527//521 +f 498//488 934//962 513//514 +f 513//514 934//962 528//532 +f 813//961 527//521 542//539 +f 813//961 542//539 557//542 +f 528//532 934//962 543//550 +f 813//961 557//542 572//561 +f 543//550 934//962 558//569 +f 813//961 572//561 587//581 +f 558//569 934//962 573//574 +f 573//574 934//962 588//592 +f 813//961 587//581 602//599 +f 813//961 602//599 617//619 +f 588//592 934//962 603//627 +f 813//961 617//619 632//638 +f 603//627 934//962 618//631 +f 813//961 632//638 647//656 +f 618//631 934//962 633//649 +f 633//649 934//962 648//667 +f 813//961 647//656 662//674 +f 813//961 662//674 677//679 +f 648//667 934//962 663//687 +f 813//961 677//679 692//699 +f 663//687 934//962 678//691 +f 813//961 692//699 707//717 +f 678//691 934//962 693//709 +f 693//709 934//962 708//727 +f 813//961 707//717 722//735 +f 813//961 722//735 737//736 +f 708//727 934//962 723//728 +f 813//961 737//736 752//740 +f 723//728 934//962 738//748 +f 813//961 752//740 767//759 +f 738//748 934//962 753//766 +f 753//766 934//962 768//769 +f 813//961 767//759 782//777 +f 813//961 782//777 797//795 +f 768//769 934//962 783//787 +f 813//961 797//795 812//800 +f 783//787 934//962 798//807 +f 813//961 812//800 828//819 +f 798//807 934//962 814//826 +f 814//826 934//962 829//829 +f 813//961 828//819 843//837 +f 813//961 843//837 858//858 +f 829//829 934//962 844//866 +f 813//961 858//858 873//876 +f 844//866 934//962 859//884 +f 813//961 873//876 888//895 +f 859//884 934//962 874//888 +f 813//961 888//895 903//912 +f 874//888 934//962 889//905 +f 813//961 903//912 918//917 +f 889//905 934//962 904//925 +f 813//961 918//917 933//936 +f 904//925 934//962 919//943 +f 813//961 933//936 949//956 +f 919//943 934//962 935//948 +f 813//961 949//956 964//963 +f 935//948 934//962 950//964 +f 813//961 964//963 497//502 +f 960//946 959//958 493//508 +f 955//960 954//959 487//506 +f 950//964 934//962 483//487 +f 961//950 960//946 494//490 +f 956//947 955//960 489//483 +f 951//949 950//964 483//487 +f 962//953 961//950 495//489 +f 957//951 956//947 490//492 +f 952//952 951//949 484//486 +f 963//957 962//953 496//496 +f 958//954 957//951 491//498 +f 953//955 952//952 485//494 +f 964//963 963//957 497//502 +f 959//958 958//954 492//504 +f 954//959 953//955 486//500 +f 971//483 970//484 985//485 +f 966//486 965//487 980//965 +f 977//489 976//966 992//967 +f 972//492 971//483 987//968 +f 967//494 966//486 981//969 +f 978//496 977//489 993//497 +f 973//498 972//492 988//499 +f 968//500 967//494 982//970 +f 979//971 978//496 994//503 +f 974//504 973//498 989//505 +f 969//506 968//500 983//507 +f 975//972 974//504 990//509 +f 970//484 969//506 984//510 +f 976//966 975//972 991//511 +f 986//512 985//485 1000//973 +f 981//969 980//965 995//514 +f 992//967 991//511 1007//974 +f 987//968 986//512 1002//516 +f 982//970 981//969 996//517 +f 993//497 992//967 1008//975 +f 988//499 987//968 1003//519 +f 983//507 982//970 997//976 +f 994//503 993//497 1009//977 +f 989//505 988//499 1004//522 +f 984//510 983//507 998//523 +f 990//509 989//505 1005//978 +f 985//485 984//510 999//525 +f 991//511 990//509 1006//526 +f 1005//978 1004//522 1020//527 +f 1000//973 999//525 1014//528 +f 1006//526 1005//978 1021//979 +f 1001//530 1000//973 1015//531 +f 996//517 995//514 1010//532 +f 1007//974 1006//526 1022//533 +f 1002//516 1001//530 1017//534 +f 997//976 996//517 1011//535 +f 1008//975 1007//974 1023//980 +f 1003//519 1002//516 1018//981 +f 998//523 997//976 1012//538 +f 1009//977 1008//975 1024//539 +f 1004//522 1003//519 1019//540 +f 999//525 998//523 1013//541 +f 1024//539 1023//980 1039//982 +f 1019//540 1018//981 1034//543 +f 1014//528 1013//541 1028//544 +f 1020//527 1019//540 1035//545 +f 1015//531 1014//528 1029//546 +f 1021//979 1020//527 1036//547 +f 1016//983 1015//531 1030//549 +f 1011//535 1010//532 1025//550 +f 1022//533 1021//979 1037//984 +f 1017//534 1016//983 1032//552 +f 1012//538 1011//535 1026//553 +f 1023//980 1022//533 1038//554 +f 1018//981 1017//534 1033//555 +f 1013//541 1012//538 1027//985 +f 1027//985 1026//553 1041//557 +f 1038//554 1037//984 1053//558 +f 1033//555 1032//552 1048//986 +f 1028//544 1027//985 1042//560 +f 1039//982 1038//554 1054//561 +f 1034//543 1033//555 1049//562 +f 1029//546 1028//544 1043//563 +f 1035//545 1034//543 1050//564 +f 1030//549 1029//546 1044//565 +f 1036//547 1035//545 1051//987 +f 1031//988 1030//549 1045//568 +f 1026//553 1025//550 1040//569 +f 1037//984 1036//547 1052//989 +f 1032//552 1031//988 1047//990 +f 1046//572 1045//568 1060//573 +f 1041//557 1040//569 1055//574 +f 1052//989 1051//987 1067//991 +f 1047//990 1046//572 1062//576 +f 1042//560 1041//557 1056//577 +f 1053//558 1052//989 1068//578 +f 1048//986 1047//990 1063//579 +f 1043//563 1042//560 1057//580 +f 1054//561 1053//558 1069//581 +f 1049//562 1048//986 1064//582 +f 1044//565 1043//563 1058//583 +f 1050//564 1049//562 1065//584 +f 1045//568 1044//565 1059//992 +f 1051//987 1050//564 1066//586 +f 1065//584 1064//582 1080//993 +f 1060//573 1059//992 1075//994 +f 1066//586 1065//584 1081//589 +f 1061//590 1060//573 1076//591 +f 1056//577 1055//574 1070//995 +f 1067//991 1066//586 1082//593 +f 1062//576 1061//590 1077//594 +f 1057//580 1056//577 1071//595 +f 1068//578 1067//991 1083//996 +f 1063//579 1062//576 1078//597 +f 1058//583 1057//580 1072//598 +f 1069//581 1068//578 1084//599 +f 1064//582 1063//579 1079//600 +f 1059//992 1058//583 1073//997 +f 1084//599 1083//996 1098//602 +f 1079//600 1078//597 1093//998 +f 1074//604 1073//997 1089//999 +f 1080//993 1079//600 1094//606 +f 1075//994 1074//604 1090//607 +f 1081//589 1080//993 1095//1000 +f 1076//591 1075//994 1091//609 +f 1071//595 1070//995 1086//1001 +f 1082//593 1081//589 1096//611 +f 1077//594 1076//591 1092//1002 +f 1072//598 1071//595 1087//613 +f 1083//996 1082//593 1097//614 +f 1078//597 1077//594 1093//998 +f 1073//997 1072//598 1088//615 +f 1098//602 1097//614 1112//1003 +f 1093//998 1092//1002 1107//617 +f 1088//615 1087//613 1103//618 +f 1099//619 1098//602 1113//620 +f 1094//606 1093//998 1108//1004 +f 1089//999 1088//615 1104//622 +f 1095//1000 1094//606 1109//623 +f 1090//607 1089//999 1105//1005 +f 1096//611 1095//1000 1110//625 +f 1091//609 1090//607 1106//626 +f 1086//1001 1085//627 1101//1006 +f 1097//614 1096//611 1111//1007 +f 1092//1002 1091//609 1107//617 +f 1087//613 1086//1001 1102//630 +f 1101//1006 1100//1008 1116//632 +f 1112//1003 1111//1007 1126//633 +f 1107//617 1106//626 1122//634 +f 1102//630 1101//1006 1117//1009 +f 1113//620 1112//1003 1127//636 +f 1108//1004 1107//617 1122//634 +f 1103//618 1102//630 1118//1010 +f 1114//1011 1113//620 1128//639 +f 1109//623 1108//1004 1123//640 +f 1104//622 1103//618 1119//641 +f 1110//625 1109//623 1124//1012 +f 1105//1005 1104//622 1120//643 +f 1111//1007 1110//625 1125//644 +f 1106//626 1105//1005 1121//645 +f 1120//643 1119//641 1135//1013 +f 1126//633 1125//644 1140//1014 +f 1121//645 1120//643 1136//648 +f 1116//632 1115//649 1131//1015 +f 1127//636 1126//633 1141//1016 +f 1122//634 1121//645 1137//652 +f 1117//1009 1116//632 1132//653 +f 1128//639 1127//636 1142//654 +f 1123//640 1122//634 1137//652 +f 1118//1010 1117//1009 1133//655 +f 1129//656 1128//639 1143//1017 +f 1124//1012 1123//640 1138//658 +f 1119//641 1118//1010 1134//1018 +f 1125//644 1124//1012 1139//660 +f 1139//660 1138//658 1153//1019 +f 1134//1018 1133//655 1149//662 +f 1140//1014 1139//660 1154//663 +f 1135//1013 1134//1018 1150//664 +f 1141//1016 1140//1014 1155//1020 +f 1136//648 1135//1013 1151//666 +f 1131//1015 1130//1021 1146//1022 +f 1142//654 1141//1016 1156//669 +f 1137//652 1136//648 1152//670 +f 1132//653 1131//1015 1147//671 +f 1143//1017 1142//654 1157//672 +f 1138//658 1137//652 1152//670 +f 1133//655 1132//653 1148//673 +f 1144//1023 1143//1017 1158//1024 +f 1158//1024 1157//672 1172//676 +f 1153//1019 1152//670 1167//1025 +f 1148//673 1147//671 1163//678 +f 1159//1026 1158//1024 1173//680 +f 1154//663 1153//1019 1168//681 +f 1149//662 1148//673 1164//1027 +f 1155//1020 1154//663 1169//683 +f 1150//664 1149//662 1165//684 +f 1156//669 1155//1020 1170//685 +f 1151//666 1150//664 1166//686 +f 1146//1022 1145//1028 1161//688 +f 1157//672 1156//669 1171//1029 +f 1152//670 1151//666 1167//1025 +f 1147//671 1146//1022 1162//690 +f 1161//688 1160//691 1176//692 +f 1172//676 1171//1029 1186//693 +f 1167//1025 1166//686 1181//694 +f 1162//690 1161//688 1177//1030 +f 1173//680 1172//676 1187//696 +f 1168//681 1167//1025 1182//697 +f 1163//678 1162//690 1178//1031 +f 1174//699 1173//680 1188//1032 +f 1169//683 1168//681 1183//701 +f 1164//1027 1163//678 1179//702 +f 1170//685 1169//683 1184//703 +f 1165//684 1164//1027 1180//704 +f 1171//1029 1170//685 1185//705 +f 1166//686 1165//684 1181//694 +f 1180//704 1179//702 1194//1033 +f 1186//693 1185//705 1200//707 +f 1181//694 1180//704 1195//708 +f 1176//692 1175//709 1191//1034 +f 1187//696 1186//693 1201//1035 +f 1182//697 1181//694 1196//1036 +f 1177//1030 1176//692 1192//713 +f 1188//1032 1187//696 1202//714 +f 1183//701 1182//697 1197//1037 +f 1178//1031 1177//1030 1193//716 +f 1189//1038 1188//1032 1203//718 +f 1184//703 1183//701 1198//1039 +f 1179//702 1178//1031 1194//1033 +f 1185//705 1184//703 1199//720 +f 1199//720 1198//1039 1213//721 +f 1194//1033 1193//716 1208//722 +f 1200//707 1199//720 1215//723 +f 1195//708 1194//1033 1209//724 +f 1201//1035 1200//707 1216//725 +f 1196//1036 1195//708 1210//726 +f 1191//1034 1190//727 1205//1040 +f 1202//714 1201//1035 1217//729 +f 1197//1037 1196//1036 1211//730 +f 1192//713 1191//1034 1206//731 +f 1203//718 1202//714 1218//732 +f 1198//1039 1197//1037 1212//733 +f 1193//716 1192//713 1207//734 +f 1204//735 1203//718 1219//736 +f 1218//732 1217//729 1233//737 +f 1213//721 1212//733 1227//738 +f 1208//722 1207//734 1222//739 +f 1219//736 1218//732 1234//740 +f 1214//741 1213//721 1229//742 +f 1209//724 1208//722 1223//743 +f 1215//723 1214//741 1230//744 +f 1210//726 1209//724 1224//745 +f 1216//725 1215//723 1231//746 +f 1211//730 1210//726 1225//747 +f 1206//731 1205//1040 1220//748 +f 1217//729 1216//725 1232//749 +f 1212//733 1211//730 1226//1041 +f 1207//734 1206//731 1221//1042 +f 1232//749 1231//746 1247//1043 +f 1227//738 1226//1041 1241//753 +f 1222//739 1221//1042 1236//1044 +f 1233//737 1232//749 1248//755 +f 1228//1045 1227//738 1242//757 +f 1223//743 1222//739 1237//1046 +f 1234//740 1233//737 1249//759 +f 1229//742 1228//1045 1244//1047 +f 1224//745 1223//743 1238//761 +f 1230//744 1229//742 1245//762 +f 1225//747 1224//745 1239//763 +f 1231//746 1230//744 1246//764 +f 1226//1041 1225//747 1240//765 +f 1221//1042 1220//748 1235//1048 +f 1246//764 1245//762 1261//1049 +f 1241//753 1240//765 1255//768 +f 1236//1044 1235//1048 1250//1050 +f 1247//1043 1246//764 1262//770 +f 1242//757 1241//753 1256//1051 +f 1237//1046 1236//1044 1251//1052 +f 1248//755 1247//1043 1263//1053 +f 1243//774 1242//757 1257//1054 +f 1238//761 1237//1046 1252//1055 +f 1249//759 1248//755 1264//1056 +f 1244//1047 1243//774 1259//778 +f 1239//763 1238//761 1253//1057 +f 1245//762 1244//1047 1260//780 +f 1240//765 1239//763 1254//781 +f 1254//781 1253//1057 1268//782 +f 1260//780 1259//778 1275//783 +f 1255//768 1254//781 1269//1058 +f 1261//1049 1260//780 1276//785 +f 1256//1051 1255//768 1270//1059 +f 1251//1052 1250//1050 1265//1060 +f 1262//770 1261//1049 1277//1061 +f 1257//1054 1256//1051 1271//789 +f 1252//1055 1251//1052 1266//790 +f 1263//1053 1262//770 1278//791 +f 1258//792 1257//1054 1272//1062 +f 1253//1057 1252//1055 1267//794 +f 1264//1056 1263//1053 1279//795 +f 1259//778 1258//792 1274//796 +f 1273//797 1272//1062 1287//798 +f 1268//782 1267//794 1282//799 +f 1279//795 1278//791 1294//1063 +f 1274//796 1273//797 1289//801 +f 1269//1058 1268//782 1283//802 +f 1275//783 1274//796 1290//803 +f 1270//1059 1269//1058 1284//804 +f 1276//785 1275//783 1291//805 +f 1271//789 1270//1059 1285//806 +f 1266//790 1265//1060 1280//1064 +f 1277//1061 1276//785 1292//808 +f 1272//1062 1271//789 1286//1065 +f 1267//794 1266//790 1281//810 +f 1278//791 1277//1061 1293//811 +f 1292//808 1291//805 1308//1066 +f 1287//798 1286//1065 1302//813 +f 1282//799 1281//810 1297//814 +f 1293//811 1292//808 1309//815 +f 1288//816 1287//798 1303//817 +f 1283//802 1282//799 1298//1067 +f 1294//1063 1293//811 1310//1068 +f 1289//801 1288//816 1305//820 +f 1284//804 1283//802 1299//821 +f 1290//803 1289//801 1306//822 +f 1285//806 1284//804 1300//823 +f 1291//805 1290//803 1307//824 +f 1286//1065 1285//806 1301//825 +f 1281//810 1280//1064 1296//1069 +f 1307//824 1306//822 1322//1070 +f 1302//813 1301//825 1316//1071 +f 1297//814 1296//1069 1311//829 +f 1308//1066 1307//824 1323//830 +f 1303//817 1302//813 1317//1072 +f 1298//1067 1297//814 1312//1073 +f 1309//815 1308//1066 1324//833 +f 1304//834 1303//817 1318//835 +f 1299//821 1298//1067 1313//836 +f 1310//1068 1309//815 1325//1074 +f 1305//820 1304//834 1319//838 +f 1300//823 1299//821 1314//839 +f 1306//822 1305//820 1320//840 +f 1301//825 1300//823 1315//1075 +f 1315//1075 1314//839 1330//1076 +f 1321//843 1320//840 1335//844 +f 1316//1071 1315//1075 1331//845 +f 1322//1070 1321//843 1336//1077 +f 1317//1072 1316//1071 1332//1078 +f 1312//1073 1311//829 1327//848 +f 1323//830 1322//1070 1337//849 +f 1318//835 1317//1072 1332//1078 +f 1313//836 1312//1073 1328//850 +f 1324//833 1323//830 1338//851 +f 1319//838 1318//835 1333//852 +f 1314//839 1313//836 1329//853 +f 1325//1074 1324//833 1339//1079 +f 1320//840 1319//838 1334//855 +f 1334//855 1333//852 1348//856 +f 1329//853 1328//850 1344//857 +f 1340//858 1339//1079 1354//859 +f 1335//844 1334//855 1349//860 +f 1330//1076 1329//853 1345//861 +f 1336//1077 1335//844 1350//862 +f 1331//845 1330//1076 1346//863 +f 1337//849 1336//1077 1351//864 +f 1332//1078 1331//845 1347//1080 +f 1327//848 1326//866 1342//867 +f 1338//851 1337//849 1352//868 +f 1333//852 1332//1078 1348//856 +f 1328//850 1327//848 1343//869 +f 1339//1079 1338//851 1353//870 +f 1353//870 1352//868 1367//1081 +f 1348//856 1347//1080 1363//872 +f 1343//869 1342//867 1358//873 +f 1354//859 1353//870 1368//874 +f 1349//860 1348//856 1363//872 +f 1344//857 1343//869 1359//875 +f 1355//1082 1354//859 1369//877 +f 1350//862 1349//860 1364//878 +f 1345//861 1344//857 1360//1083 +f 1351//864 1350//862 1365//880 +f 1346//863 1345//861 1361//1084 +f 1352//868 1351//864 1366//1085 +f 1347//1080 1346//863 1362//883 +f 1342//867 1341//884 1357//885 +f 1367//1081 1366//1085 1381//1086 +f 1362//883 1361//1084 1377//1087 +f 1357//885 1356//888 1372//889 +f 1368//874 1367//1081 1382//1088 +f 1363//872 1362//883 1378//891 +f 1358//873 1357//885 1373//1089 +f 1369//877 1368//874 1383//893 +f 1364//878 1363//872 1378//891 +f 1359//875 1358//873 1374//894 +f 1370//895 1369//877 1384//896 +f 1365//880 1364//878 1379//897 +f 1360//1083 1359//875 1375//1090 +f 1366//1085 1365//880 1380//899 +f 1361//1084 1360//1083 1376//900 +f 1381//1086 1380//899 1395//901 +f 1376//900 1375//1090 1391//902 +f 1382//1088 1381//1086 1396//1091 +f 1377//1087 1376//900 1392//904 +f 1372//889 1371//1092 1387//1093 +f 1383//893 1382//1088 1397//907 +f 1378//891 1377//1087 1393//908 +f 1373//1089 1372//889 1388//909 +f 1384//896 1383//893 1398//910 +f 1379//897 1378//891 1393//908 +f 1374//894 1373//1089 1389//911 +f 1385//912 1384//896 1399//913 +f 1380//899 1379//897 1394//914 +f 1375//1090 1374//894 1390//1094 +f 1389//911 1388//909 1404//916 +f 1400//1095 1399//913 1414//1096 +f 1395//901 1394//914 1409//919 +f 1390//1094 1389//911 1405//920 +f 1396//1091 1395//901 1410//921 +f 1391//902 1390//1094 1406//922 +f 1397//907 1396//1091 1411//1097 +f 1392//904 1391//902 1407//924 +f 1387//1093 1386//1098 1402//1099 +f 1398//910 1397//907 1412//927 +f 1393//908 1392//904 1408//1100 +f 1388//909 1387//1093 1403//929 +f 1399//913 1398//910 1413//930 +f 1394//914 1393//908 1408//1100 +f 1408//1100 1407//924 1424//931 +f 1403//929 1402//1099 1419//932 +f 1414//1096 1413//930 1429//1101 +f 1409//919 1408//1100 1425//934 +f 1404//916 1403//929 1420//935 +f 1415//936 1414//1096 1430//937 +f 1410//921 1409//919 1425//934 +f 1405//920 1404//916 1421//938 +f 1411//1097 1410//921 1426//939 +f 1406//922 1405//920 1422//940 +f 1412//927 1411//1097 1427//941 +f 1407//924 1406//922 1423//942 +f 1402//1099 1401//943 1418//1102 +f 1413//930 1412//927 1428//945 +f 1428//945 1427//941 1442//946 +f 1423//942 1422//940 1438//1103 +f 1418//1102 1417//1104 1433//949 +f 1429//1101 1428//945 1443//950 +f 1424//931 1423//942 1439//951 +f 1419//932 1418//1102 1434//952 +f 1430//937 1429//1101 1444//953 +f 1425//934 1424//931 1440//954 +f 1420//935 1419//932 1435//955 +f 1431//956 1430//937 1445//1105 +f 1426//939 1425//934 1441//958 +f 1421//938 1420//935 1436//959 +f 1427//941 1426//939 1442//946 +f 1422//940 1421//938 1437//960 +f 1295//961 979//971 994//503 +f 965//487 1416//962 980//965 +f 1295//961 994//503 1009//977 +f 980//965 1416//962 995//514 +f 995//514 1416//962 1010//532 +f 1295//961 1009//977 1024//539 +f 1295//961 1024//539 1039//982 +f 1010//532 1416//962 1025//550 +f 1295//961 1039//982 1054//561 +f 1025//550 1416//962 1040//569 +f 1295//961 1054//561 1069//581 +f 1040//569 1416//962 1055//574 +f 1055//574 1416//962 1070//995 +f 1295//961 1069//581 1084//599 +f 1295//961 1084//599 1099//619 +f 1070//995 1416//962 1085//627 +f 1295//961 1099//619 1114//1011 +f 1085//627 1416//962 1100//1008 +f 1295//961 1114//1011 1129//656 +f 1100//1008 1416//962 1115//649 +f 1115//649 1416//962 1130//1021 +f 1295//961 1129//656 1144//1023 +f 1295//961 1144//1023 1159//1026 +f 1130//1021 1416//962 1145//1028 +f 1295//961 1159//1026 1174//699 +f 1145//1028 1416//962 1160//691 +f 1295//961 1174//699 1189//1038 +f 1160//691 1416//962 1175//709 +f 1175//709 1416//962 1190//727 +f 1295//961 1189//1038 1204//735 +f 1295//961 1204//735 1219//736 +f 1190//727 1416//962 1205//1040 +f 1295//961 1219//736 1234//740 +f 1205//1040 1416//962 1220//748 +f 1295//961 1234//740 1249//759 +f 1220//748 1416//962 1235//1048 +f 1235//1048 1416//962 1250//1050 +f 1295//961 1249//759 1264//1056 +f 1295//961 1264//1056 1279//795 +f 1250//1050 1416//962 1265//1060 +f 1295//961 1279//795 1294//1063 +f 1265//1060 1416//962 1280//1064 +f 1295//961 1294//1063 1310//1068 +f 1280//1064 1416//962 1296//1069 +f 1296//1069 1416//962 1311//829 +f 1295//961 1310//1068 1325//1074 +f 1295//961 1325//1074 1340//858 +f 1311//829 1416//962 1326//866 +f 1295//961 1340//858 1355//1082 +f 1326//866 1416//962 1341//884 +f 1295//961 1355//1082 1370//895 +f 1341//884 1416//962 1356//888 +f 1295//961 1370//895 1385//912 +f 1356//888 1416//962 1371//1092 +f 1295//961 1385//912 1400//1095 +f 1371//1092 1416//962 1386//1098 +f 1295//961 1400//1095 1415//936 +f 1386//1098 1416//962 1401//943 +f 1295//961 1415//936 1431//956 +f 1401//943 1416//962 1417//1104 +f 1295//961 1431//956 1446//1106 +f 1417//1104 1416//962 1432//964 +f 1295//961 1446//1106 979//971 +f 1442//946 1441//958 975//972 +f 1437//960 1436//959 969//506 +f 1432//964 1416//962 965//487 +f 1443//950 1442//946 976//966 +f 1438//1103 1437//960 971//483 +f 1433//949 1432//964 965//487 +f 1444//953 1443//950 977//489 +f 1439//951 1438//1103 972//492 +f 1434//952 1433//949 966//486 +f 1445//1105 1444//953 978//496 +f 1440//954 1439//951 973//498 +f 1435//955 1434//952 967//494 +f 1446//1106 1445//1105 979//971 +f 1441//958 1440//954 974//504 +f 1436//959 1435//955 968//500 +f 504//512 489//483 503//485 +f 499//495 484//486 498//488 +f 494//490 509//511 510//491 +f 489//483 504//512 505//493 +f 500//501 485//494 499//495 +f 495//489 510//491 511//497 +f 490//492 505//493 506//499 +f 501//507 486//500 500//501 +f 496//496 511//497 512//503 +f 491//498 506//499 507//505 +f 502//510 487//506 501//507 +f 492//504 507//505 508//509 +f 503//485 488//484 502//510 +f 493//508 508//509 509//511 +f 519//530 504//512 518//513 +f 514//517 499//495 513//514 +f 509//511 524//526 525//515 +f 504//512 519//530 520//516 +f 515//520 500//501 514//517 +f 510//491 525//515 526//518 +f 505//493 520//516 521//519 +f 516//523 501//507 515//520 +f 511//497 526//518 527//521 +f 506//499 521//519 522//522 +f 517//525 502//510 516//523 +f 507//505 522//522 523//524 +f 518//513 503//485 517//525 +f 508//509 523//524 524//526 +f 522//522 537//540 538//527 +f 533//531 518//513 532//528 +f 523//524 538//527 539//529 +f 534//548 519//530 533//531 +f 529//535 514//517 528//532 +f 524//526 539//529 540//533 +f 519//530 534//548 535//534 +f 530//538 515//520 529//535 +f 525//515 540//533 541//536 +f 520//516 535//534 536//537 +f 531//541 516//523 530//538 +f 526//518 541//536 542//539 +f 521//519 536//537 537//540 +f 532//528 517//525 531//541 +f 541//536 556//554 557//542 +f 536//537 551//555 552//543 +f 547//546 532//528 546//544 +f 537//540 552//543 553//545 +f 548//549 533//531 547//546 +f 538//527 553//545 554//547 +f 549//567 534//548 548//549 +f 544//553 529//535 543//550 +f 539//529 554//547 555//551 +f 534//548 549//567 550//552 +f 545//556 530//538 544//553 +f 540//533 555//551 556//554 +f 535//534 550//552 551//555 +f 546//544 531//541 545//556 +f 560//560 545//556 559//557 +f 555//551 570//570 571//558 +f 550//552 565//571 566//559 +f 561//563 546//544 560//560 +f 556//554 571//558 572//561 +f 551//555 566//559 567//562 +f 562//565 547//546 561//563 +f 552//543 567//562 568//564 +f 563//568 548//549 562//565 +f 553//545 568//564 569//566 +f 564//572 549//567 563//568 +f 559//557 544//553 558//569 +f 554//547 569//566 570//570 +f 549//567 564//572 565//571 +f 579//590 564//572 578//573 +f 574//577 559//557 573//574 +f 569//566 584//586 585//575 +f 564//572 579//590 580//576 +f 575//580 560//560 574//577 +f 570//570 585//575 586//578 +f 565//571 580//576 581//579 +f 576//583 561//563 575//580 +f 571//558 586//578 587//581 +f 566//559 581//579 582//582 +f 577//585 562//565 576//583 +f 567//562 582//582 583//584 +f 578//573 563//568 577//585 +f 568//564 583//584 584//586 +f 582//582 597//600 598//587 +f 577//585 592//604 593//588 +f 583//584 598//587 599//589 +f 578//573 593//588 594//591 +f 589//595 574//577 588//592 +f 584//586 599//589 600//593 +f 579//590 594//591 595//594 +f 590//598 575//580 589//595 +f 585//575 600//593 601//596 +f 580//576 595//594 596//597 +f 591//601 576//583 590//598 +f 586//578 601//596 602//599 +f 581//579 596//597 597//600 +f 592//604 577//585 591//601 +f 617//619 602//599 616//602 +f 612//606 597//600 611//603 +f 591//601 606//615 607//605 +f 613//608 598//587 612//606 +f 592//604 607//605 608//607 +f 614//611 599//589 613//608 +f 593//588 608//607 609//609 +f 588//592 603//627 604//610 +f 615//614 600//593 614//611 +f 594//591 609//609 610//612 +f 589//595 604//610 605//613 +f 616//602 601//596 615//614 +f 595//594 610//612 611//603 +f 590//598 605//613 606//615 +f 631//620 616//602 630//616 +f 626//621 611//603 625//617 +f 605//613 620//630 621//618 +f 632//638 617//619 631//620 +f 627//623 612//606 626//621 +f 606//615 621//618 622//622 +f 628//625 613//608 627//623 +f 607//605 622//622 623//624 +f 629//629 614//611 628//625 +f 608//607 623//624 624//626 +f 603//627 618//631 619//628 +f 630//616 615//614 629//629 +f 609//609 624//626 625//617 +f 604//610 619//628 620//630 +f 618//631 633//649 634//632 +f 645//636 630//616 644//633 +f 624//626 639//645 640//634 +f 619//628 634//632 635//635 +f 646//639 631//620 645//636 +f 641//640 626//621 640//634 +f 620//630 635//635 636//637 +f 647//656 632//638 646//639 +f 642//642 627//623 641//640 +f 621//618 636//637 637//641 +f 643//644 628//625 642//642 +f 622//622 637//641 638//643 +f 644//633 629//629 643//644 +f 623//624 638//643 639//645 +f 637//641 652//659 653//646 +f 659//651 644//633 658//647 +f 638//643 653//646 654//648 +f 633//649 648//667 649//650 +f 660//654 645//636 659//651 +f 639//645 654//648 655//652 +f 634//632 649//650 650//653 +f 661//657 646//639 660//654 +f 656//658 641//640 655//652 +f 635//635 650//653 651//655 +f 662//674 647//656 661//657 +f 657//660 642//642 656//658 +f 636//637 651//655 652//659 +f 658//647 643//644 657//660 +f 672//663 657//660 671//661 +f 651//655 666//673 667//662 +f 673//665 658//647 672//663 +f 652//659 667//662 668//664 +f 674//669 659//651 673//665 +f 653//646 668//664 669//666 +f 648//667 663//687 664//668 +f 675//672 660//654 674//669 +f 654//648 669//666 670//670 +f 649//650 664//668 665//671 +f 676//675 661//657 675//672 +f 671//661 656//658 670//670 +f 650//653 665//671 666//673 +f 677//679 662//674 676//675 +f 691//680 676//675 690//676 +f 686//681 671//661 685//677 +f 665//671 680//690 681//678 +f 692//699 677//679 691//680 +f 687//683 672//663 686//681 +f 666//673 681//678 682//682 +f 688//685 673//665 687//683 +f 667//662 682//682 683//684 +f 689//689 674//669 688//685 +f 668//664 683//684 684//686 +f 663//687 678//691 679//688 +f 690//676 675//672 689//689 +f 669//666 684//686 685//677 +f 664//668 679//688 680//690 +f 678//691 693//709 694//692 +f 705//696 690//676 704//693 +f 700//697 685//677 699//694 +f 679//688 694//692 695//695 +f 706//700 691//680 705//696 +f 701//701 686//681 700//697 +f 680//690 695//695 696//698 +f 707//717 692//699 706//700 +f 702//703 687//683 701//701 +f 681//678 696//698 697//702 +f 703//705 688//685 702//703 +f 682//682 697//702 698//704 +f 704//693 689//689 703//705 +f 683//684 698//704 699//694 +f 713//708 698//704 712//706 +f 719//711 704//693 718//707 +f 714//712 699//694 713//708 +f 693//709 708//727 709//710 +f 720//714 705//696 719//711 +f 715//715 700//697 714//712 +f 694//692 709//710 710//713 +f 721//718 706//700 720//714 +f 716//719 701//701 715//715 +f 695//695 710//713 711//716 +f 722//735 707//717 721//718 +f 717//720 702//703 716//719 +f 696//698 711//716 712//706 +f 718//707 703//705 717//720 +f 732//741 717//720 731//721 +f 727//724 712//706 726//722 +f 717//720 732//741 733//723 +f 728//726 713//708 727//724 +f 718//707 733//723 734//725 +f 729//730 714//712 728//726 +f 724//731 709//710 723//728 +f 719//711 734//725 735//729 +f 730//733 715//715 729//730 +f 725//734 710//713 724//731 +f 720//714 735//729 736//732 +f 731//721 716//719 730//733 +f 726//722 711//716 725//734 +f 721//718 736//732 737//736 +f 735//729 750//749 751//737 +f 746//756 731//721 745//738 +f 741//743 726//722 740//739 +f 736//732 751//737 752//740 +f 731//721 746//756 747//742 +f 742//745 727//724 741//743 +f 732//741 747//742 748//744 +f 743//747 728//726 742//745 +f 733//723 748//744 749//746 +f 744//750 729//730 743//747 +f 739//751 724//731 738//748 +f 734//725 749//746 750//749 +f 745//738 730//733 744//750 +f 740//739 725//734 739//751 +f 749//746 764//764 765//752 +f 760//757 745//738 759//753 +f 755//758 740//739 754//754 +f 750//749 765//752 766//755 +f 761//774 746//756 760//757 +f 756//761 741//743 755//758 +f 751//737 766//755 767//759 +f 746//756 761//774 762//760 +f 757//763 742//745 756//761 +f 747//742 762//760 763//762 +f 758//765 743//747 757//763 +f 748//744 763//762 764//764 +f 759//753 744//750 758//765 +f 754//754 739//751 753//766 +f 763//762 778//780 779//767 +f 774//771 759//753 773//768 +f 769//772 754//754 768//769 +f 764//764 779//767 780//770 +f 775//775 760//757 774//771 +f 770//776 755//758 769//772 +f 765//752 780//770 781//773 +f 776//792 761//774 775//775 +f 771//779 756//761 770//776 +f 766//755 781//773 782//777 +f 761//774 776//792 777//778 +f 772//781 757//763 771//779 +f 762//760 777//778 778//780 +f 773//768 758//765 772//781 +f 787//784 772//781 786//782 +f 777//778 792//796 793//783 +f 788//786 773//768 787//784 +f 778//780 793//783 794//785 +f 789//789 774//771 788//786 +f 784//790 769//772 783//787 +f 779//767 794//785 795//788 +f 790//793 775//775 789//789 +f 785//794 770//776 784//790 +f 780//770 795//788 796//791 +f 791//797 776//792 790//793 +f 786//782 771//779 785//794 +f 781//773 796//791 797//795 +f 776//792 791//797 792//796 +f 806//816 791//797 805//798 +f 801//802 786//782 800//799 +f 796//791 811//811 812//800 +f 791//797 806//816 807//801 +f 802//804 787//784 801//802 +f 792//796 807//801 808//803 +f 803//806 788//786 802//804 +f 793//783 808//803 809//805 +f 804//809 789//789 803//806 +f 799//810 784//790 798//807 +f 794//785 809//805 810//808 +f 805//798 790//793 804//809 +f 800//799 785//794 799//810 +f 795//788 810//808 811//811 +f 809//805 825//824 826//812 +f 821//817 805//798 820//813 +f 816//818 800//799 815//814 +f 810//808 826//812 827//815 +f 822//834 806//816 821//817 +f 817//821 801//802 816//818 +f 811//811 827//815 828//819 +f 806//816 822//834 823//820 +f 818//823 802//804 817//821 +f 807//801 823//820 824//822 +f 819//825 803//806 818//823 +f 808//803 824//822 825//824 +f 820//813 804//809 819//825 +f 815//814 799//810 814//826 +f 824//822 839//843 840//827 +f 835//831 820//813 834//828 +f 830//832 815//814 829//829 +f 825//824 840//827 841//830 +f 836//835 821//817 835//831 +f 831//836 816//818 830//832 +f 826//812 841//830 842//833 +f 837//838 822//834 836//835 +f 832//839 817//821 831//836 +f 827//815 842//833 843//837 +f 838//840 823//820 837//838 +f 833//841 818//823 832//839 +f 839//843 824//822 838//840 +f 834//828 819//825 833//841 +f 832//839 847//853 848//842 +f 854//846 839//843 853//844 +f 833//841 848//842 849//845 +f 855//849 840//827 854//846 +f 834//828 849//845 850//847 +f 829//829 844//866 845//848 +f 856//851 841//830 855//849 +f 851//852 836//835 850//847 +f 830//832 845//848 846//850 +f 857//854 842//833 856//851 +f 852//855 837//838 851//852 +f 831//836 846//850 847//853 +f 858//858 843//837 857//854 +f 853//844 838//840 852//855 +f 867//860 852//855 866//856 +f 846//850 861//869 862//857 +f 873//876 858//858 872//859 +f 868//862 853//844 867//860 +f 847//853 862//857 863//861 +f 869//864 854//846 868//862 +f 848//842 863//861 864//863 +f 870//868 855//849 869//864 +f 849//845 864//863 865//865 +f 844//866 859//884 860//867 +f 871//870 856//851 870//868 +f 850//847 865//865 866//856 +f 845//848 860//867 861//869 +f 872//859 857//854 871//870 +f 886//874 871//870 885//871 +f 865//865 880//883 881//872 +f 860//867 875//885 876//873 +f 887//877 872//859 886//874 +f 882//878 867//860 881//872 +f 861//869 876//873 877//875 +f 888//895 873//876 887//877 +f 883//880 868//862 882//878 +f 862//857 877//875 878//879 +f 884//882 869//864 883//880 +f 863//861 878//879 879//881 +f 885//871 870//868 884//882 +f 864//863 879//881 880//883 +f 859//884 874//888 875//885 +f 900//890 885//871 899//886 +f 879//881 894//900 895//887 +f 874//888 889//905 890//889 +f 901//893 886//874 900//890 +f 880//883 895//887 896//891 +f 875//885 890//889 891//892 +f 902//896 887//877 901//893 +f 897//897 882//878 896//891 +f 876//873 891//892 892//894 +f 903//912 888//895 902//896 +f 898//899 883//880 897//897 +f 877//875 892//894 893//898 +f 899//886 884//882 898//899 +f 878//879 893//898 894//900 +f 914//903 899//886 913//901 +f 893//898 908//915 909//902 +f 915//907 900//890 914//903 +f 894//900 909//902 910//904 +f 889//905 904//925 905//906 +f 916//910 901//893 915//907 +f 895//887 910//904 911//908 +f 890//889 905//906 906//909 +f 917//913 902//896 916//910 +f 912//914 897//897 911//908 +f 891//892 906//909 907//911 +f 918//917 903//912 917//913 +f 913//901 898//899 912//914 +f 892//894 907//911 908//915 +f 906//909 921//929 922//916 +f 933//936 918//917 932//918 +f 928//921 913//901 927//919 +f 907//911 922//916 923//920 +f 929//923 914//903 928//921 +f 908//915 923//920 924//922 +f 930//927 915//907 929//923 +f 909//902 924//922 925//924 +f 904//925 919//943 920//926 +f 931//930 916//910 930//927 +f 910//904 925//924 926//928 +f 905//906 920//926 921//929 +f 932//918 917//913 931//930 +f 927//919 912//914 926//928 +f 925//924 941//942 942//931 +f 920//926 936//944 937//932 +f 948//937 932//918 947//933 +f 926//928 942//931 943//934 +f 921//929 937//932 938//935 +f 949//956 933//936 948//937 +f 944//939 928//921 943//934 +f 922//916 938//935 939//938 +f 945//941 929//923 944//939 +f 923//920 939//938 940//940 +f 946//945 930//927 945//941 +f 924//922 940//940 941//942 +f 919//943 935//948 936//944 +f 947//933 931//930 946//945 +f 961//950 946//945 960//946 +f 940//940 955//960 956//947 +f 935//948 950//964 951//949 +f 962//953 947//933 961//950 +f 941//942 956//947 957//951 +f 936//944 951//949 952//952 +f 963//957 948//937 962//953 +f 942//931 957//951 958//954 +f 937//932 952//952 953//955 +f 964//963 949//956 963//957 +f 943//934 958//954 959//958 +f 938//935 953//955 954//959 +f 944//939 959//958 960//946 +f 939//938 954//959 955//960 +f 959//958 492//504 493//508 +f 488//484 955//960 487//506 +f 960//946 493//508 494//490 +f 955//960 488//484 489//483 +f 484//486 951//949 483//487 +f 961//950 494//490 495//489 +f 956//947 489//483 490//492 +f 485//494 952//952 484//486 +f 962//953 495//489 496//496 +f 957//951 490//492 491//498 +f 486//500 953//955 485//494 +f 963//957 496//496 497//502 +f 958//954 491//498 492//504 +f 487//506 954//959 486//500 +f 986//512 971//483 985//485 +f 981//969 966//486 980//965 +f 976//966 991//511 992//967 +f 971//483 986//512 987//968 +f 982//970 967//494 981//969 +f 977//489 992//967 993//497 +f 972//492 987//968 988//499 +f 983//507 968//500 982//970 +f 978//496 993//497 994//503 +f 973//498 988//499 989//505 +f 984//510 969//506 983//507 +f 974//504 989//505 990//509 +f 985//485 970//484 984//510 +f 975//972 990//509 991//511 +f 1001//530 986//512 1000//973 +f 996//517 981//969 995//514 +f 991//511 1006//526 1007//974 +f 986//512 1001//530 1002//516 +f 997//976 982//970 996//517 +f 992//967 1007//974 1008//975 +f 987//968 1002//516 1003//519 +f 998//523 983//507 997//976 +f 993//497 1008//975 1009//977 +f 988//499 1003//519 1004//522 +f 999//525 984//510 998//523 +f 989//505 1004//522 1005//978 +f 1000//973 985//485 999//525 +f 990//509 1005//978 1006//526 +f 1004//522 1019//540 1020//527 +f 1015//531 1000//973 1014//528 +f 1005//978 1020//527 1021//979 +f 1016//983 1001//530 1015//531 +f 1011//535 996//517 1010//532 +f 1006//526 1021//979 1022//533 +f 1001//530 1016//983 1017//534 +f 1012//538 997//976 1011//535 +f 1007//974 1022//533 1023//980 +f 1002//516 1017//534 1018//981 +f 1013//541 998//523 1012//538 +f 1008//975 1023//980 1024//539 +f 1003//519 1018//981 1019//540 +f 1014//528 999//525 1013//541 +f 1023//980 1038//554 1039//982 +f 1018//981 1033//555 1034//543 +f 1029//546 1014//528 1028//544 +f 1019//540 1034//543 1035//545 +f 1030//549 1015//531 1029//546 +f 1020//527 1035//545 1036//547 +f 1031//988 1016//983 1030//549 +f 1026//553 1011//535 1025//550 +f 1021//979 1036//547 1037//984 +f 1016//983 1031//988 1032//552 +f 1027//985 1012//538 1026//553 +f 1022//533 1037//984 1038//554 +f 1017//534 1032//552 1033//555 +f 1028//544 1013//541 1027//985 +f 1042//560 1027//985 1041//557 +f 1037//984 1052//989 1053//558 +f 1032//552 1047//990 1048//986 +f 1043//563 1028//544 1042//560 +f 1038//554 1053//558 1054//561 +f 1033//555 1048//986 1049//562 +f 1044//565 1029//546 1043//563 +f 1034//543 1049//562 1050//564 +f 1045//568 1030//549 1044//565 +f 1035//545 1050//564 1051//987 +f 1046//572 1031//988 1045//568 +f 1041//557 1026//553 1040//569 +f 1036//547 1051//987 1052//989 +f 1031//988 1046//572 1047//990 +f 1061//590 1046//572 1060//573 +f 1056//577 1041//557 1055//574 +f 1051//987 1066//586 1067//991 +f 1046//572 1061//590 1062//576 +f 1057//580 1042//560 1056//577 +f 1052//989 1067//991 1068//578 +f 1047//990 1062//576 1063//579 +f 1058//583 1043//563 1057//580 +f 1053//558 1068//578 1069//581 +f 1048//986 1063//579 1064//582 +f 1059//992 1044//565 1058//583 +f 1049//562 1064//582 1065//584 +f 1060//573 1045//568 1059//992 +f 1050//564 1065//584 1066//586 +f 1064//582 1079//600 1080//993 +f 1059//992 1074//604 1075//994 +f 1065//584 1080//993 1081//589 +f 1060//573 1075//994 1076//591 +f 1071//595 1056//577 1070//995 +f 1066//586 1081//589 1082//593 +f 1061//590 1076//591 1077//594 +f 1072//598 1057//580 1071//595 +f 1067//991 1082//593 1083//996 +f 1062//576 1077//594 1078//597 +f 1073//997 1058//583 1072//598 +f 1068//578 1083//996 1084//599 +f 1063//579 1078//597 1079//600 +f 1074//604 1059//992 1073//997 +f 1099//619 1084//599 1098//602 +f 1094//606 1079//600 1093//998 +f 1073//997 1088//615 1089//999 +f 1095//1000 1080//993 1094//606 +f 1074//604 1089//999 1090//607 +f 1096//611 1081//589 1095//1000 +f 1075//994 1090//607 1091//609 +f 1070//995 1085//627 1086//1001 +f 1097//614 1082//593 1096//611 +f 1076//591 1091//609 1092//1002 +f 1071//595 1086//1001 1087//613 +f 1098//602 1083//996 1097//614 +f 1077//594 1092//1002 1093//998 +f 1072//598 1087//613 1088//615 +f 1113//620 1098//602 1112//1003 +f 1108//1004 1093//998 1107//617 +f 1087//613 1102//630 1103//618 +f 1114//1011 1099//619 1113//620 +f 1109//623 1094//606 1108//1004 +f 1088//615 1103//618 1104//622 +f 1110//625 1095//1000 1109//623 +f 1089//999 1104//622 1105//1005 +f 1111//1007 1096//611 1110//625 +f 1090//607 1105//1005 1106//626 +f 1085//627 1100//1008 1101//1006 +f 1112//1003 1097//614 1111//1007 +f 1091//609 1106//626 1107//617 +f 1086//1001 1101//1006 1102//630 +f 1100//1008 1115//649 1116//632 +f 1127//636 1112//1003 1126//633 +f 1106//626 1121//645 1122//634 +f 1101//1006 1116//632 1117//1009 +f 1128//639 1113//620 1127//636 +f 1123//640 1108//1004 1122//634 +f 1102//630 1117//1009 1118//1010 +f 1129//656 1114//1011 1128//639 +f 1124//1012 1109//623 1123//640 +f 1103//618 1118//1010 1119//641 +f 1125//644 1110//625 1124//1012 +f 1104//622 1119//641 1120//643 +f 1126//633 1111//1007 1125//644 +f 1105//1005 1120//643 1121//645 +f 1119//641 1134//1018 1135//1013 +f 1141//1016 1126//633 1140//1014 +f 1120//643 1135//1013 1136//648 +f 1115//649 1130//1021 1131//1015 +f 1142//654 1127//636 1141//1016 +f 1121//645 1136//648 1137//652 +f 1116//632 1131//1015 1132//653 +f 1143//1017 1128//639 1142//654 +f 1138//658 1123//640 1137//652 +f 1117//1009 1132//653 1133//655 +f 1144//1023 1129//656 1143//1017 +f 1139//660 1124//1012 1138//658 +f 1118//1010 1133//655 1134//1018 +f 1140//1014 1125//644 1139//660 +f 1154//663 1139//660 1153//1019 +f 1133//655 1148//673 1149//662 +f 1155//1020 1140//1014 1154//663 +f 1134//1018 1149//662 1150//664 +f 1156//669 1141//1016 1155//1020 +f 1135//1013 1150//664 1151//666 +f 1130//1021 1145//1028 1146//1022 +f 1157//672 1142//654 1156//669 +f 1136//648 1151//666 1152//670 +f 1131//1015 1146//1022 1147//671 +f 1158//1024 1143//1017 1157//672 +f 1153//1019 1138//658 1152//670 +f 1132//653 1147//671 1148//673 +f 1159//1026 1144//1023 1158//1024 +f 1173//680 1158//1024 1172//676 +f 1168//681 1153//1019 1167//1025 +f 1147//671 1162//690 1163//678 +f 1174//699 1159//1026 1173//680 +f 1169//683 1154//663 1168//681 +f 1148//673 1163//678 1164//1027 +f 1170//685 1155//1020 1169//683 +f 1149//662 1164//1027 1165//684 +f 1171//1029 1156//669 1170//685 +f 1150//664 1165//684 1166//686 +f 1145//1028 1160//691 1161//688 +f 1172//676 1157//672 1171//1029 +f 1151//666 1166//686 1167//1025 +f 1146//1022 1161//688 1162//690 +f 1160//691 1175//709 1176//692 +f 1187//696 1172//676 1186//693 +f 1182//697 1167//1025 1181//694 +f 1161//688 1176//692 1177//1030 +f 1188//1032 1173//680 1187//696 +f 1183//701 1168//681 1182//697 +f 1162//690 1177//1030 1178//1031 +f 1189//1038 1174//699 1188//1032 +f 1184//703 1169//683 1183//701 +f 1163//678 1178//1031 1179//702 +f 1185//705 1170//685 1184//703 +f 1164//1027 1179//702 1180//704 +f 1186//693 1171//1029 1185//705 +f 1165//684 1180//704 1181//694 +f 1195//708 1180//704 1194//1033 +f 1201//1035 1186//693 1200//707 +f 1196//1036 1181//694 1195//708 +f 1175//709 1190//727 1191//1034 +f 1202//714 1187//696 1201//1035 +f 1197//1037 1182//697 1196//1036 +f 1176//692 1191//1034 1192//713 +f 1203//718 1188//1032 1202//714 +f 1198//1039 1183//701 1197//1037 +f 1177//1030 1192//713 1193//716 +f 1204//735 1189//1038 1203//718 +f 1199//720 1184//703 1198//1039 +f 1178//1031 1193//716 1194//1033 +f 1200//707 1185//705 1199//720 +f 1214//741 1199//720 1213//721 +f 1209//724 1194//1033 1208//722 +f 1199//720 1214//741 1215//723 +f 1210//726 1195//708 1209//724 +f 1200//707 1215//723 1216//725 +f 1211//730 1196//1036 1210//726 +f 1206//731 1191//1034 1205//1040 +f 1201//1035 1216//725 1217//729 +f 1212//733 1197//1037 1211//730 +f 1207//734 1192//713 1206//731 +f 1202//714 1217//729 1218//732 +f 1213//721 1198//1039 1212//733 +f 1208//722 1193//716 1207//734 +f 1203//718 1218//732 1219//736 +f 1217//729 1232//749 1233//737 +f 1228//1045 1213//721 1227//738 +f 1223//743 1208//722 1222//739 +f 1218//732 1233//737 1234//740 +f 1213//721 1228//1045 1229//742 +f 1224//745 1209//724 1223//743 +f 1214//741 1229//742 1230//744 +f 1225//747 1210//726 1224//745 +f 1215//723 1230//744 1231//746 +f 1226//1041 1211//730 1225//747 +f 1221//1042 1206//731 1220//748 +f 1216//725 1231//746 1232//749 +f 1227//738 1212//733 1226//1041 +f 1222//739 1207//734 1221//1042 +f 1231//746 1246//764 1247//1043 +f 1242//757 1227//738 1241//753 +f 1237//1046 1222//739 1236//1044 +f 1232//749 1247//1043 1248//755 +f 1243//774 1228//1045 1242//757 +f 1238//761 1223//743 1237//1046 +f 1233//737 1248//755 1249//759 +f 1228//1045 1243//774 1244//1047 +f 1239//763 1224//745 1238//761 +f 1229//742 1244//1047 1245//762 +f 1240//765 1225//747 1239//763 +f 1230//744 1245//762 1246//764 +f 1241//753 1226//1041 1240//765 +f 1236//1044 1221//1042 1235//1048 +f 1245//762 1260//780 1261//1049 +f 1256//1051 1241//753 1255//768 +f 1251//1052 1236//1044 1250//1050 +f 1246//764 1261//1049 1262//770 +f 1257//1054 1242//757 1256//1051 +f 1252//1055 1237//1046 1251//1052 +f 1247//1043 1262//770 1263//1053 +f 1258//792 1243//774 1257//1054 +f 1253//1057 1238//761 1252//1055 +f 1248//755 1263//1053 1264//1056 +f 1243//774 1258//792 1259//778 +f 1254//781 1239//763 1253//1057 +f 1244//1047 1259//778 1260//780 +f 1255//768 1240//765 1254//781 +f 1269//1058 1254//781 1268//782 +f 1259//778 1274//796 1275//783 +f 1270//1059 1255//768 1269//1058 +f 1260//780 1275//783 1276//785 +f 1271//789 1256//1051 1270//1059 +f 1266//790 1251//1052 1265//1060 +f 1261//1049 1276//785 1277//1061 +f 1272//1062 1257//1054 1271//789 +f 1267//794 1252//1055 1266//790 +f 1262//770 1277//1061 1278//791 +f 1273//797 1258//792 1272//1062 +f 1268//782 1253//1057 1267//794 +f 1263//1053 1278//791 1279//795 +f 1258//792 1273//797 1274//796 +f 1288//816 1273//797 1287//798 +f 1283//802 1268//782 1282//799 +f 1278//791 1293//811 1294//1063 +f 1273//797 1288//816 1289//801 +f 1284//804 1269//1058 1283//802 +f 1274//796 1289//801 1290//803 +f 1285//806 1270//1059 1284//804 +f 1275//783 1290//803 1291//805 +f 1286//1065 1271//789 1285//806 +f 1281//810 1266//790 1280//1064 +f 1276//785 1291//805 1292//808 +f 1287//798 1272//1062 1286//1065 +f 1282//799 1267//794 1281//810 +f 1277//1061 1292//808 1293//811 +f 1291//805 1307//824 1308//1066 +f 1303//817 1287//798 1302//813 +f 1298//1067 1282//799 1297//814 +f 1292//808 1308//1066 1309//815 +f 1304//834 1288//816 1303//817 +f 1299//821 1283//802 1298//1067 +f 1293//811 1309//815 1310//1068 +f 1288//816 1304//834 1305//820 +f 1300//823 1284//804 1299//821 +f 1289//801 1305//820 1306//822 +f 1301//825 1285//806 1300//823 +f 1290//803 1306//822 1307//824 +f 1302//813 1286//1065 1301//825 +f 1297//814 1281//810 1296//1069 +f 1306//822 1321//843 1322//1070 +f 1317//1072 1302//813 1316//1071 +f 1312//1073 1297//814 1311//829 +f 1307//824 1322//1070 1323//830 +f 1318//835 1303//817 1317//1072 +f 1313//836 1298//1067 1312//1073 +f 1308//1066 1323//830 1324//833 +f 1319//838 1304//834 1318//835 +f 1314//839 1299//821 1313//836 +f 1309//815 1324//833 1325//1074 +f 1320//840 1305//820 1319//838 +f 1315//1075 1300//823 1314//839 +f 1321//843 1306//822 1320//840 +f 1316//1071 1301//825 1315//1075 +f 1314//839 1329//853 1330//1076 +f 1336//1077 1321//843 1335//844 +f 1315//1075 1330//1076 1331//845 +f 1337//849 1322//1070 1336//1077 +f 1316//1071 1331//845 1332//1078 +f 1311//829 1326//866 1327//848 +f 1338//851 1323//830 1337//849 +f 1333//852 1318//835 1332//1078 +f 1312//1073 1327//848 1328//850 +f 1339//1079 1324//833 1338//851 +f 1334//855 1319//838 1333//852 +f 1313//836 1328//850 1329//853 +f 1340//858 1325//1074 1339//1079 +f 1335//844 1320//840 1334//855 +f 1349//860 1334//855 1348//856 +f 1328//850 1343//869 1344//857 +f 1355//1082 1340//858 1354//859 +f 1350//862 1335//844 1349//860 +f 1329//853 1344//857 1345//861 +f 1351//864 1336//1077 1350//862 +f 1330//1076 1345//861 1346//863 +f 1352//868 1337//849 1351//864 +f 1331//845 1346//863 1347//1080 +f 1326//866 1341//884 1342//867 +f 1353//870 1338//851 1352//868 +f 1332//1078 1347//1080 1348//856 +f 1327//848 1342//867 1343//869 +f 1354//859 1339//1079 1353//870 +f 1368//874 1353//870 1367//1081 +f 1347//1080 1362//883 1363//872 +f 1342//867 1357//885 1358//873 +f 1369//877 1354//859 1368//874 +f 1364//878 1349//860 1363//872 +f 1343//869 1358//873 1359//875 +f 1370//895 1355//1082 1369//877 +f 1365//880 1350//862 1364//878 +f 1344//857 1359//875 1360//1083 +f 1366//1085 1351//864 1365//880 +f 1345//861 1360//1083 1361//1084 +f 1367//1081 1352//868 1366//1085 +f 1346//863 1361//1084 1362//883 +f 1341//884 1356//888 1357//885 +f 1382//1088 1367//1081 1381//1086 +f 1361//1084 1376//900 1377//1087 +f 1356//888 1371//1092 1372//889 +f 1383//893 1368//874 1382//1088 +f 1362//883 1377//1087 1378//891 +f 1357//885 1372//889 1373//1089 +f 1384//896 1369//877 1383//893 +f 1379//897 1364//878 1378//891 +f 1358//873 1373//1089 1374//894 +f 1385//912 1370//895 1384//896 +f 1380//899 1365//880 1379//897 +f 1359//875 1374//894 1375//1090 +f 1381//1086 1366//1085 1380//899 +f 1360//1083 1375//1090 1376//900 +f 1396//1091 1381//1086 1395//901 +f 1375//1090 1390//1094 1391//902 +f 1397//907 1382//1088 1396//1091 +f 1376//900 1391//902 1392//904 +f 1371//1092 1386//1098 1387//1093 +f 1398//910 1383//893 1397//907 +f 1377//1087 1392//904 1393//908 +f 1372//889 1387//1093 1388//909 +f 1399//913 1384//896 1398//910 +f 1394//914 1379//897 1393//908 +f 1373//1089 1388//909 1389//911 +f 1400//1095 1385//912 1399//913 +f 1395//901 1380//899 1394//914 +f 1374//894 1389//911 1390//1094 +f 1388//909 1403//929 1404//916 +f 1415//936 1400//1095 1414//1096 +f 1410//921 1395//901 1409//919 +f 1389//911 1404//916 1405//920 +f 1411//1097 1396//1091 1410//921 +f 1390//1094 1405//920 1406//922 +f 1412//927 1397//907 1411//1097 +f 1391//902 1406//922 1407//924 +f 1386//1098 1401//943 1402//1099 +f 1413//930 1398//910 1412//927 +f 1392//904 1407//924 1408//1100 +f 1387//1093 1402//1099 1403//929 +f 1414//1096 1399//913 1413//930 +f 1409//919 1394//914 1408//1100 +f 1407//924 1423//942 1424//931 +f 1402//1099 1418//1102 1419//932 +f 1430//937 1414//1096 1429//1101 +f 1408//1100 1424//931 1425//934 +f 1403//929 1419//932 1420//935 +f 1431//956 1415//936 1430//937 +f 1426//939 1410//921 1425//934 +f 1404//916 1420//935 1421//938 +f 1427//941 1411//1097 1426//939 +f 1405//920 1421//938 1422//940 +f 1428//945 1412//927 1427//941 +f 1406//922 1422//940 1423//942 +f 1401//943 1417//1104 1418//1102 +f 1429//1101 1413//930 1428//945 +f 1443//950 1428//945 1442//946 +f 1422//940 1437//960 1438//1103 +f 1417//1104 1432//964 1433//949 +f 1444//953 1429//1101 1443//950 +f 1423//942 1438//1103 1439//951 +f 1418//1102 1433//949 1434//952 +f 1445//1105 1430//937 1444//953 +f 1424//931 1439//951 1440//954 +f 1419//932 1434//952 1435//955 +f 1446//1106 1431//956 1445//1105 +f 1425//934 1440//954 1441//958 +f 1420//935 1435//955 1436//959 +f 1426//939 1441//958 1442//946 +f 1421//938 1436//959 1437//960 +f 1441//958 974//504 975//972 +f 970//484 1437//960 969//506 +f 1442//946 975//972 976//966 +f 1437//960 970//484 971//483 +f 966//486 1433//949 965//487 +f 1443//950 976//966 977//489 +f 1438//1103 971//483 972//492 +f 967//494 1434//952 966//486 +f 1444//953 977//489 978//496 +f 1439//951 972//492 973//498 +f 968//500 1435//955 967//494 +f 1445//1105 978//496 979//971 +f 1440//954 973//498 974//504 +f 969//506 1436//959 968//500 +o Foot_R_Sphere.013 +v 1.070087 0.436287 -0.613739 +v 1.067775 0.408819 -0.597702 +v 1.067363 0.383059 -0.583396 +v 1.068870 0.359998 -0.571371 +v 1.072236 0.340521 -0.562090 +v 1.077332 0.325377 -0.555908 +v 1.083963 0.315147 -0.553064 +v 1.091874 0.310225 -0.553667 +v 1.100760 0.310801 -0.557693 +v 1.110280 0.316851 -0.564988 +v 1.120069 0.328144 -0.575272 +v 1.129750 0.344245 -0.588149 +v 1.138951 0.364536 -0.603124 +v 1.147318 0.388237 -0.619623 +v 1.154530 0.414437 -0.637010 +v 1.070029 0.435806 -0.617730 +v 1.067660 0.407876 -0.605530 +v 1.067197 0.381690 -0.594761 +v 1.068659 0.358255 -0.585837 +v 1.071988 0.338472 -0.579100 +v 1.077056 0.323099 -0.574808 +v 1.083670 0.312730 -0.573128 +v 1.091575 0.307761 -0.574124 +v 1.100467 0.308383 -0.577757 +v 1.110004 0.314574 -0.583888 +v 1.119821 0.326095 -0.592281 +v 1.129539 0.342502 -0.602614 +v 1.138785 0.363167 -0.614490 +v 1.147204 0.387294 -0.627451 +v 1.154472 0.413956 -0.641001 +v 1.070163 0.436416 -0.622236 +v 1.067924 0.409072 -0.614368 +v 1.067580 0.383428 -0.607592 +v 1.069145 0.360466 -0.602167 +v 1.072560 0.341072 -0.598302 +v 1.077693 0.325989 -0.596145 +v 1.084346 0.315797 -0.595780 +v 1.092264 0.310888 -0.597219 +v 1.101142 0.311450 -0.600408 +v 1.110641 0.317463 -0.605225 +v 1.120393 0.328695 -0.611484 +v 1.130026 0.344713 -0.618945 +v 1.139167 0.364904 -0.627320 +v 1.147467 0.388490 -0.636289 +v 1.154606 0.414566 -0.645507 +v 1.070485 0.438093 -0.627082 +v 1.068555 0.412363 -0.623876 +v 1.068496 0.388205 -0.621395 +v 1.070312 0.366547 -0.619735 +v 1.073931 0.348221 -0.618960 +v 1.079216 0.333933 -0.619099 +v 1.085963 0.324230 -0.620147 +v 1.093913 0.319486 -0.622064 +v 1.102760 0.319884 -0.624776 +v 1.112164 0.325407 -0.628179 +v 1.121764 0.335844 -0.632142 +v 1.131192 0.350794 -0.636513 +v 1.140084 0.369681 -0.641123 +v 1.148098 0.391781 -0.645797 +v 1.154928 0.416243 -0.650353 +v 1.070982 0.440774 -0.632085 +v 1.069529 0.417621 -0.633688 +v 1.069911 0.395838 -0.635640 +v 1.072112 0.376262 -0.637865 +v 1.076049 0.359645 -0.640278 +v 1.081569 0.346627 -0.642787 +v 1.088461 0.337706 -0.645294 +v 1.096459 0.333226 -0.647703 +v 1.105257 0.333360 -0.649923 +v 1.114517 0.338101 -0.651867 +v 1.123882 0.347268 -0.653460 +v 1.132992 0.360509 -0.654643 +v 1.141498 0.377315 -0.655368 +v 1.149073 0.397039 -0.655609 +v 1.155425 0.418924 -0.655356 +v 1.071635 0.444354 -0.637050 +v 1.070810 0.424644 -0.643427 +v 1.071770 0.406034 -0.649779 +v 1.074478 0.389240 -0.655861 +v 1.078831 0.374905 -0.661439 +v 1.084660 0.363582 -0.666299 +v 1.091742 0.355706 -0.670255 +v 1.099805 0.351579 -0.673153 +v 1.108539 0.351360 -0.674883 +v 1.117608 0.355057 -0.675379 +v 1.126664 0.362528 -0.674621 +v 1.135358 0.373487 -0.672638 +v 1.143357 0.387511 -0.669507 +v 1.150353 0.404062 -0.665348 +v 1.156078 0.422504 -0.660321 +v 1.072418 0.448697 -0.641787 +v 1.072347 0.433163 -0.652719 +v 1.074001 0.418402 -0.663269 +v 1.077318 0.404980 -0.673030 +v 1.082170 0.393414 -0.681628 +v 1.088371 0.384149 -0.688732 +v 1.095682 0.377539 -0.694069 +v 1.103822 0.373840 -0.697434 +v 1.112479 0.373193 -0.698698 +v 1.121319 0.375623 -0.697812 +v 1.130004 0.381037 -0.694810 +v 1.138198 0.389227 -0.689808 +v 1.145589 0.399878 -0.682997 +v 1.151890 0.412581 -0.674640 +v 1.156861 0.426847 -0.665058 +v 1.073303 0.453636 -0.646114 +v 1.074082 0.442850 -0.661207 +v 1.076520 0.432465 -0.675592 +v 1.080524 0.422879 -0.688714 +v 1.085940 0.414462 -0.700070 +v 1.092559 0.407535 -0.709224 +v 1.100128 0.402366 -0.715823 +v 1.108355 0.399153 -0.719615 +v 1.116925 0.398020 -0.720452 +v 1.125507 0.399010 -0.718304 +v 1.133773 0.402085 -0.713252 +v 1.141404 0.407126 -0.705492 +v 1.148107 0.413942 -0.695320 +v 1.153625 0.422268 -0.683128 +v 1.157746 0.431786 -0.669385 +v 1.074254 0.458980 -0.649865 +v 1.075948 0.453333 -0.668565 +v 1.079229 0.447684 -0.686273 +v 1.083971 0.442249 -0.702309 +v 1.089994 0.437238 -0.716057 +v 1.097064 0.432843 -0.726987 +v 1.104910 0.429232 -0.734680 +v 1.113231 0.426546 -0.738841 +v 1.121707 0.424886 -0.739309 +v 1.130012 0.424317 -0.736067 +v 1.137827 0.424861 -0.729239 +v 1.144851 0.426496 -0.719087 +v 1.150816 0.429160 -0.706001 +v 1.155491 0.432751 -0.690486 +v 1.158697 0.437130 -0.673136 +v 1.075235 0.464524 -0.652895 +v 1.077873 0.464209 -0.674509 +v 1.082023 0.463473 -0.694903 +v 1.087528 0.462345 -0.713293 +v 1.094176 0.460868 -0.728972 +v 1.101711 0.459099 -0.741338 +v 1.109844 0.457106 -0.749916 +v 1.118261 0.454966 -0.754375 +v 1.126640 0.452760 -0.754545 +v 1.134659 0.450574 -0.750418 +v 1.142009 0.448491 -0.742154 +v 1.148408 0.446592 -0.730071 +v 1.153611 0.444949 -0.714632 +v 1.157416 0.443626 -0.696430 +v 1.159678 0.442674 -0.676166 +v 1.076209 0.470056 -0.655089 +v 1.079783 0.475059 -0.678813 +v 1.084797 0.479226 -0.701150 +v 1.091058 0.482394 -0.721244 +v 1.098327 0.484444 -0.738322 +v 1.106323 0.485295 -0.751727 +v 1.114740 0.484916 -0.760944 +v 1.123253 0.483320 -0.765619 +v 1.131536 0.480569 -0.765573 +v 1.139271 0.476770 -0.760807 +v 1.146160 0.472067 -0.751504 +v 1.151938 0.466641 -0.738022 +v 1.156384 0.460702 -0.720879 +v 1.159326 0.454477 -0.700733 +v 1.160652 0.448206 -0.678360 +v 1.077138 0.475362 -0.656361 +v 1.081605 0.485468 -0.681309 +v 1.087442 0.494337 -0.704774 +v 1.094425 0.501627 -0.725857 +v 1.102286 0.507059 -0.743745 +v 1.110722 0.510424 -0.757753 +v 1.119410 0.511593 -0.767341 +v 1.128015 0.510520 -0.772142 +v 1.136207 0.507246 -0.771970 +v 1.143670 0.501899 -0.766833 +v 1.150119 0.494682 -0.756927 +v 1.155306 0.485874 -0.742634 +v 1.159030 0.475813 -0.724503 +v 1.161149 0.464886 -0.703229 +v 1.161581 0.453512 -0.679632 +v 1.077987 0.480239 -0.656664 +v 1.083269 0.495035 -0.681902 +v 1.089858 0.508226 -0.705636 +v 1.097500 0.519305 -0.726953 +v 1.105902 0.527846 -0.745034 +v 1.114740 0.533521 -0.759185 +v 1.123675 0.536112 -0.768862 +v 1.132364 0.535519 -0.773692 +v 1.140472 0.531765 -0.773491 +v 1.147688 0.524995 -0.768265 +v 1.153735 0.515469 -0.758216 +v 1.158380 0.503552 -0.743730 +v 1.161445 0.489702 -0.725364 +v 1.162813 0.474453 -0.703823 +v 1.162430 0.458389 -0.679935 +v 1.078722 0.484500 -0.655985 +v 1.084711 0.503392 -0.680570 +v 1.091952 0.520359 -0.703701 +v 1.100165 0.534747 -0.724491 +v 1.109035 0.546004 -0.742140 +v 1.118221 0.553697 -0.755969 +v 1.127371 0.557530 -0.765448 +v 1.136132 0.557357 -0.770211 +v 1.144168 0.553184 -0.770076 +v 1.151169 0.545171 -0.765049 +v 1.156868 0.533627 -0.755322 +v 1.161045 0.518994 -0.741269 +v 1.163539 0.501835 -0.723430 +v 1.164255 0.482810 -0.702490 +v 1.163165 0.462650 -0.679256 +v 1.079315 0.487980 -0.654350 +v 1.085876 0.510219 -0.677363 +v 1.093642 0.530269 -0.699046 +v 1.102317 0.547360 -0.718566 +v 1.111565 0.560836 -0.735172 +v 1.121033 0.570177 -0.748227 +v 1.130355 0.575026 -0.757229 +v 1.139175 0.575196 -0.761832 +v 1.147152 0.570680 -0.761858 +v 1.153981 0.561652 -0.757307 +v 1.159398 0.548459 -0.748354 +v 1.163197 0.531607 -0.735343 +v 1.165230 0.511746 -0.718774 +v 1.165419 0.489637 -0.699284 +v 1.163758 0.466130 -0.677621 +v 1.079745 0.490546 -0.651822 +v 1.086718 0.515252 -0.672405 +v 1.094865 0.537576 -0.691848 +v 1.103873 0.556661 -0.709405 +v 1.113395 0.571772 -0.724400 +v 1.123066 0.582329 -0.736258 +v 1.132514 0.587926 -0.744522 +v 1.141376 0.588349 -0.748876 +v 1.149311 0.583580 -0.749151 +v 1.156014 0.573803 -0.745338 +v 1.161228 0.559395 -0.737582 +v 1.164753 0.540908 -0.726182 +v 1.166453 0.519053 -0.711577 +v 1.166262 0.494670 -0.694326 +v 1.164188 0.468696 -0.675093 +v 1.079993 0.492099 -0.648499 +v 1.087206 0.518299 -0.665887 +v 1.095573 0.542000 -0.682385 +v 1.104774 0.562291 -0.697360 +v 1.114455 0.578392 -0.710237 +v 1.124243 0.589685 -0.720521 +v 1.133764 0.595735 -0.727816 +v 1.142650 0.596310 -0.731842 +v 1.150560 0.591389 -0.732445 +v 1.157191 0.581159 -0.729601 +v 1.162288 0.566015 -0.723419 +v 1.165654 0.546538 -0.714138 +v 1.167160 0.523476 -0.702113 +v 1.166749 0.497717 -0.687807 +v 1.164436 0.470249 -0.671770 +v 1.080052 0.492580 -0.644508 +v 1.087320 0.519242 -0.658058 +v 1.095739 0.543369 -0.671019 +v 1.104985 0.564033 -0.682895 +v 1.114703 0.580441 -0.693228 +v 1.124519 0.591962 -0.701621 +v 1.134057 0.598152 -0.707752 +v 1.142949 0.598775 -0.711385 +v 1.150853 0.593806 -0.712381 +v 1.157467 0.583436 -0.710701 +v 1.162536 0.568064 -0.706410 +v 1.165865 0.548280 -0.699672 +v 1.167326 0.524845 -0.690748 +v 1.166864 0.498660 -0.679979 +v 1.164495 0.470730 -0.667779 +v 1.079917 0.491970 -0.640003 +v 1.087057 0.518046 -0.649220 +v 1.095356 0.541632 -0.658189 +v 1.104498 0.561822 -0.666564 +v 1.114131 0.577841 -0.674025 +v 1.123883 0.589073 -0.680284 +v 1.133381 0.595085 -0.685101 +v 1.142260 0.595648 -0.688290 +v 1.150178 0.590739 -0.689730 +v 1.156831 0.580547 -0.689364 +v 1.161964 0.565464 -0.687207 +v 1.165378 0.546069 -0.683342 +v 1.166944 0.523108 -0.677917 +v 1.166600 0.497463 -0.671141 +v 1.164360 0.470120 -0.663274 +v 1.079596 0.490292 -0.635156 +v 1.086425 0.514755 -0.639712 +v 1.094440 0.536855 -0.644386 +v 1.103332 0.555742 -0.648996 +v 1.112759 0.570692 -0.653367 +v 1.122360 0.581128 -0.657331 +v 1.131764 0.586652 -0.660733 +v 1.140611 0.587049 -0.663445 +v 1.148561 0.582306 -0.665362 +v 1.155308 0.572603 -0.666410 +v 1.160592 0.558315 -0.666549 +v 1.164212 0.539989 -0.665774 +v 1.166028 0.518331 -0.664114 +v 1.165969 0.494173 -0.661633 +v 1.164039 0.468442 -0.658427 +v 1.079099 0.487612 -0.630154 +v 1.085451 0.509497 -0.629900 +v 1.093026 0.529221 -0.630141 +v 1.101532 0.546027 -0.630866 +v 1.110642 0.559267 -0.632049 +v 1.120007 0.568435 -0.633642 +v 1.129266 0.573176 -0.635586 +v 1.138065 0.573309 -0.637806 +v 1.146063 0.568830 -0.640215 +v 1.152955 0.559909 -0.642722 +v 1.158475 0.546890 -0.645231 +v 1.162411 0.530274 -0.647644 +v 1.164613 0.510698 -0.649869 +v 1.164994 0.488915 -0.651821 +v 1.163542 0.465762 -0.653425 +v 1.078446 0.484031 -0.625189 +v 1.084170 0.502474 -0.620161 +v 1.091167 0.519025 -0.616002 +v 1.099166 0.533049 -0.612871 +v 1.107860 0.544007 -0.610888 +v 1.116916 0.551479 -0.610130 +v 1.125985 0.555176 -0.610626 +v 1.134719 0.554956 -0.612356 +v 1.142781 0.550829 -0.615255 +v 1.149864 0.542953 -0.619210 +v 1.155693 0.531630 -0.624070 +v 1.160046 0.517296 -0.629648 +v 1.162754 0.500501 -0.635730 +v 1.163714 0.481891 -0.642082 +v 1.162889 0.462181 -0.648460 +v 1.160311 0.442129 -0.654618 +v 1.077662 0.479688 -0.620452 +v 1.082633 0.493955 -0.610869 +v 1.088935 0.506657 -0.602512 +v 1.096325 0.517308 -0.595701 +v 1.104520 0.525498 -0.590699 +v 1.113205 0.530912 -0.587697 +v 1.122045 0.533343 -0.586811 +v 1.130702 0.532696 -0.588075 +v 1.138842 0.528996 -0.591440 +v 1.146153 0.522387 -0.596777 +v 1.152353 0.513121 -0.603881 +v 1.157205 0.501555 -0.612479 +v 1.160522 0.488134 -0.622240 +v 1.162177 0.473372 -0.632790 +v 1.162105 0.457838 -0.643723 +v 1.076778 0.474750 -0.616124 +v 1.080899 0.484268 -0.602381 +v 1.086416 0.492594 -0.590189 +v 1.093120 0.499409 -0.580018 +v 1.100751 0.504451 -0.572257 +v 1.109017 0.507526 -0.567205 +v 1.117599 0.508516 -0.565057 +v 1.126169 0.507383 -0.565895 +v 1.134396 0.504170 -0.569686 +v 1.141965 0.499001 -0.576285 +v 1.148584 0.492074 -0.585439 +v 1.154000 0.483656 -0.596795 +v 1.158004 0.474071 -0.609918 +v 1.160442 0.463686 -0.624302 +v 1.161221 0.452900 -0.639395 +v 1.075827 0.469406 -0.612374 +v 1.079033 0.473785 -0.595023 +v 1.083708 0.477376 -0.579508 +v 1.089672 0.480040 -0.566422 +v 1.096697 0.481675 -0.556271 +v 1.104512 0.482218 -0.549442 +v 1.112817 0.481649 -0.546200 +v 1.121293 0.479990 -0.546668 +v 1.129614 0.477303 -0.550829 +v 1.137460 0.473693 -0.558522 +v 1.144530 0.469298 -0.569453 +v 1.150552 0.464287 -0.583200 +v 1.155295 0.458852 -0.599236 +v 1.158576 0.453203 -0.616944 +v 1.160270 0.447556 -0.635645 +v 1.074845 0.463862 -0.609343 +v 1.077108 0.462909 -0.589079 +v 1.080913 0.461586 -0.570878 +v 1.086115 0.459944 -0.555438 +v 1.092515 0.458045 -0.543355 +v 1.099865 0.455962 -0.535091 +v 1.107883 0.453776 -0.530965 +v 1.116263 0.451570 -0.531134 +v 1.124680 0.449430 -0.535594 +v 1.132813 0.447437 -0.544171 +v 1.140348 0.445668 -0.556537 +v 1.146995 0.444191 -0.572216 +v 1.152500 0.443063 -0.590606 +v 1.156651 0.442327 -0.611000 +v 1.159288 0.442012 -0.632614 +v 1.073872 0.458330 -0.607149 +v 1.075197 0.452059 -0.584776 +v 1.078140 0.445834 -0.564631 +v 1.082585 0.439894 -0.547487 +v 1.088364 0.434469 -0.534005 +v 1.095253 0.429766 -0.524702 +v 1.102987 0.425966 -0.519936 +v 1.111271 0.423216 -0.519890 +v 1.119784 0.421620 -0.524565 +v 1.128201 0.421241 -0.533782 +v 1.136197 0.422092 -0.547187 +v 1.143465 0.424141 -0.564265 +v 1.149727 0.427310 -0.584359 +v 1.154741 0.431476 -0.606697 +v 1.158315 0.436480 -0.630420 +v 1.072943 0.453024 -0.605877 +v 1.073375 0.441650 -0.582280 +v 1.075494 0.430722 -0.561007 +v 1.079218 0.420661 -0.542875 +v 1.084404 0.411853 -0.528582 +v 1.090853 0.404637 -0.518676 +v 1.098317 0.399289 -0.513539 +v 1.106509 0.396016 -0.513367 +v 1.115114 0.394943 -0.518168 +v 1.123801 0.396112 -0.527756 +v 1.132238 0.399476 -0.541764 +v 1.140098 0.404908 -0.559653 +v 1.147081 0.412199 -0.580735 +v 1.152919 0.421067 -0.604201 +v 1.157386 0.431174 -0.629148 +v 1.072094 0.448146 -0.605574 +v 1.071711 0.432083 -0.581686 +v 1.073078 0.416833 -0.560145 +v 1.076143 0.402984 -0.541779 +v 1.080789 0.391067 -0.527293 +v 1.086836 0.381541 -0.517244 +v 1.094052 0.374770 -0.512018 +v 1.102160 0.371017 -0.511817 +v 1.110849 0.370424 -0.516647 +v 1.119784 0.373015 -0.526324 +v 1.128622 0.378690 -0.540475 +v 1.137023 0.387231 -0.558556 +v 1.144665 0.398310 -0.579874 +v 1.151255 0.411501 -0.603607 +v 1.156537 0.426296 -0.628845 +v 1.071359 0.443886 -0.606254 +v 1.070269 0.423726 -0.583019 +v 1.070985 0.404701 -0.562080 +v 1.073479 0.387542 -0.544241 +v 1.077656 0.372909 -0.530187 +v 1.083354 0.361364 -0.520460 +v 1.090356 0.353352 -0.515433 +v 1.098392 0.349178 -0.515298 +v 1.107153 0.349005 -0.520062 +v 1.116302 0.352839 -0.529540 +v 1.125489 0.360532 -0.543369 +v 1.134359 0.371789 -0.561018 +v 1.142572 0.386177 -0.581808 +v 1.149812 0.403143 -0.604940 +v 1.155802 0.422036 -0.629525 +v 1.074213 0.464407 -0.630891 +v 1.070765 0.440406 -0.607888 +v 1.069104 0.416899 -0.586225 +v 1.069294 0.394790 -0.566735 +v 1.071327 0.374928 -0.550166 +v 1.075125 0.358077 -0.537155 +v 1.080543 0.344884 -0.528202 +v 1.087372 0.335856 -0.523651 +v 1.095349 0.331340 -0.523678 +v 1.104168 0.331510 -0.528280 +v 1.113491 0.336358 -0.537282 +v 1.122959 0.345700 -0.550337 +v 1.132207 0.359175 -0.566943 +v 1.140881 0.376267 -0.586463 +v 1.148648 0.396317 -0.608146 +v 1.155208 0.418556 -0.631159 +v 1.070336 0.437840 -0.610416 +v 1.068262 0.411866 -0.591183 +v 1.068071 0.387483 -0.573933 +v 1.069771 0.365628 -0.559327 +v 1.073295 0.347141 -0.547927 +v 1.078510 0.332732 -0.540171 +v 1.085213 0.322956 -0.536358 +v 1.093148 0.318187 -0.536633 +v 1.102010 0.318610 -0.540987 +v 1.111458 0.324207 -0.549251 +v 1.121129 0.334764 -0.561109 +v 1.130651 0.349875 -0.576104 +v 1.139659 0.368959 -0.593661 +v 1.147806 0.391284 -0.613104 +v 1.154779 0.415990 -0.633687 +v 1.075639 0.467351 -0.512964 +v 1.073326 0.439884 -0.496926 +v 1.072915 0.414124 -0.482621 +v 1.074422 0.391063 -0.470596 +v 1.077788 0.371585 -0.461315 +v 1.082884 0.356441 -0.455133 +v 1.089515 0.346212 -0.452289 +v 1.097425 0.341290 -0.452892 +v 1.106312 0.341865 -0.456918 +v 1.115832 0.347916 -0.464213 +v 1.125621 0.359208 -0.474496 +v 1.135301 0.375310 -0.487373 +v 1.144502 0.395600 -0.502349 +v 1.152870 0.419301 -0.518847 +v 1.160082 0.445501 -0.536235 +v 1.075581 0.466870 -0.516955 +v 1.073212 0.438940 -0.504755 +v 1.072749 0.412755 -0.493986 +v 1.074210 0.389320 -0.485061 +v 1.077539 0.369536 -0.478324 +v 1.082608 0.354164 -0.474033 +v 1.089222 0.343794 -0.472353 +v 1.097127 0.338825 -0.473349 +v 1.106019 0.339448 -0.476982 +v 1.115556 0.345639 -0.483113 +v 1.125372 0.357159 -0.491506 +v 1.135090 0.373567 -0.501839 +v 1.144336 0.394231 -0.513714 +v 1.152755 0.418358 -0.526676 +v 1.160024 0.445020 -0.540226 +v 1.075715 0.467480 -0.521460 +v 1.073475 0.440137 -0.513593 +v 1.073132 0.414492 -0.506817 +v 1.074697 0.391531 -0.501392 +v 1.078112 0.372136 -0.497527 +v 1.083244 0.357053 -0.495370 +v 1.089897 0.346861 -0.495004 +v 1.097815 0.341952 -0.496444 +v 1.106694 0.342515 -0.499633 +v 1.116192 0.348528 -0.504450 +v 1.125945 0.359759 -0.510709 +v 1.135577 0.375778 -0.518169 +v 1.144719 0.395968 -0.526545 +v 1.153019 0.419555 -0.535514 +v 1.160158 0.445630 -0.544731 +v 1.076037 0.469158 -0.526307 +v 1.074107 0.443428 -0.523101 +v 1.074048 0.419269 -0.520620 +v 1.075863 0.397611 -0.518960 +v 1.079483 0.379286 -0.518184 +v 1.084768 0.364997 -0.518323 +v 1.091515 0.355295 -0.519371 +v 1.099465 0.350551 -0.521288 +v 1.108312 0.350948 -0.524000 +v 1.117716 0.356472 -0.527403 +v 1.127316 0.366909 -0.531366 +v 1.136743 0.381858 -0.535737 +v 1.145635 0.400746 -0.540348 +v 1.153650 0.422845 -0.545022 +v 1.160480 0.447308 -0.549578 +v 1.076534 0.471838 -0.531309 +v 1.075081 0.448686 -0.532913 +v 1.075463 0.426903 -0.534865 +v 1.077664 0.407327 -0.537090 +v 1.081600 0.390710 -0.539503 +v 1.087121 0.377691 -0.542011 +v 1.094012 0.368770 -0.544519 +v 1.102011 0.364291 -0.546928 +v 1.110809 0.364424 -0.549147 +v 1.120069 0.369166 -0.551091 +v 1.129433 0.378333 -0.552685 +v 1.138544 0.391574 -0.553867 +v 1.147050 0.408379 -0.554593 +v 1.154625 0.428103 -0.554833 +v 1.160977 0.449988 -0.554580 +v 1.077186 0.475419 -0.536274 +v 1.076361 0.455709 -0.542652 +v 1.077322 0.437099 -0.549004 +v 1.080030 0.420304 -0.555085 +v 1.084382 0.405970 -0.560664 +v 1.090212 0.394647 -0.565524 +v 1.097294 0.386771 -0.569479 +v 1.105357 0.382644 -0.572378 +v 1.114091 0.382425 -0.574108 +v 1.123160 0.386122 -0.574604 +v 1.132215 0.393593 -0.573846 +v 1.140910 0.404551 -0.571863 +v 1.148909 0.418575 -0.568732 +v 1.155905 0.435127 -0.564573 +v 1.161629 0.453569 -0.559545 +v 1.077970 0.479762 -0.541011 +v 1.077899 0.464228 -0.551944 +v 1.079553 0.449466 -0.562494 +v 1.082870 0.436045 -0.572255 +v 1.087722 0.424479 -0.580853 +v 1.093923 0.415213 -0.587957 +v 1.101233 0.408604 -0.593294 +v 1.109374 0.404905 -0.596659 +v 1.118030 0.404258 -0.597923 +v 1.126871 0.406688 -0.597037 +v 1.135555 0.412102 -0.594035 +v 1.143750 0.420292 -0.589033 +v 1.151140 0.430943 -0.582222 +v 1.157442 0.443646 -0.573865 +v 1.162413 0.457912 -0.564282 +v 1.078855 0.484700 -0.545338 +v 1.079633 0.473915 -0.560432 +v 1.082072 0.463530 -0.574816 +v 1.086076 0.453944 -0.587939 +v 1.091491 0.445526 -0.599295 +v 1.098111 0.438600 -0.608449 +v 1.105680 0.433431 -0.615048 +v 1.113907 0.430218 -0.618839 +v 1.122476 0.429084 -0.619677 +v 1.131059 0.430074 -0.617529 +v 1.139325 0.433149 -0.612477 +v 1.146956 0.438191 -0.604716 +v 1.153659 0.445006 -0.594545 +v 1.159177 0.453332 -0.582353 +v 1.163297 0.462850 -0.568609 +v 1.079806 0.490044 -0.549089 +v 1.081499 0.484398 -0.567790 +v 1.084780 0.478748 -0.585498 +v 1.089523 0.473314 -0.601534 +v 1.095545 0.468302 -0.615281 +v 1.102615 0.463907 -0.626212 +v 1.110461 0.460297 -0.633905 +v 1.118782 0.457610 -0.638066 +v 1.127258 0.455951 -0.638534 +v 1.135563 0.455382 -0.635291 +v 1.143378 0.455925 -0.628463 +v 1.150403 0.457561 -0.618311 +v 1.156368 0.460225 -0.605226 +v 1.161043 0.463815 -0.589710 +v 1.164249 0.468194 -0.572360 +v 1.080787 0.495589 -0.552120 +v 1.083424 0.495273 -0.573734 +v 1.087575 0.494537 -0.594128 +v 1.093080 0.493409 -0.612518 +v 1.099728 0.491933 -0.628197 +v 1.107263 0.490164 -0.640563 +v 1.115395 0.488171 -0.649140 +v 1.123813 0.486030 -0.653600 +v 1.132192 0.483824 -0.653769 +v 1.140211 0.481638 -0.649643 +v 1.147561 0.479555 -0.641379 +v 1.153960 0.477656 -0.629295 +v 1.159162 0.476014 -0.613856 +v 1.162968 0.474691 -0.595655 +v 1.165230 0.473739 -0.575391 +v 1.081761 0.501120 -0.554313 +v 1.085335 0.506124 -0.578037 +v 1.090348 0.510290 -0.600375 +v 1.096610 0.513459 -0.620469 +v 1.103879 0.515508 -0.637547 +v 1.111875 0.516360 -0.650951 +v 1.120291 0.515980 -0.660169 +v 1.128805 0.514385 -0.664844 +v 1.137088 0.511634 -0.664798 +v 1.144823 0.507834 -0.660031 +v 1.151712 0.503131 -0.650728 +v 1.157490 0.497706 -0.637246 +v 1.161936 0.491767 -0.620103 +v 1.164878 0.485542 -0.599958 +v 1.166204 0.479270 -0.577584 +v 1.082690 0.506427 -0.555586 +v 1.087157 0.516533 -0.580533 +v 1.092994 0.525402 -0.603999 +v 1.099977 0.532692 -0.625081 +v 1.107838 0.538124 -0.642970 +v 1.116274 0.541489 -0.656978 +v 1.124962 0.542657 -0.666566 +v 1.133567 0.541584 -0.671367 +v 1.141758 0.538311 -0.671195 +v 1.149222 0.532963 -0.666058 +v 1.155671 0.525747 -0.656152 +v 1.160857 0.516939 -0.641859 +v 1.164581 0.506878 -0.623727 +v 1.166700 0.495951 -0.602454 +v 1.167133 0.484577 -0.578857 +v 1.083538 0.511304 -0.555888 +v 1.088821 0.526100 -0.581127 +v 1.095410 0.539290 -0.604860 +v 1.103052 0.550369 -0.626178 +v 1.111454 0.558910 -0.644259 +v 1.120292 0.564585 -0.658410 +v 1.129227 0.567176 -0.668087 +v 1.137915 0.566583 -0.672917 +v 1.146023 0.562830 -0.672716 +v 1.153240 0.556060 -0.667490 +v 1.159287 0.546533 -0.657441 +v 1.163932 0.534616 -0.642955 +v 1.166997 0.520767 -0.624589 +v 1.168365 0.505517 -0.603047 +v 1.167981 0.489454 -0.579159 +v 1.084273 0.515564 -0.555209 +v 1.090263 0.534457 -0.579794 +v 1.097503 0.551423 -0.602926 +v 1.105717 0.565811 -0.623716 +v 1.114587 0.577068 -0.641364 +v 1.123773 0.584761 -0.655194 +v 1.132923 0.588595 -0.664672 +v 1.141683 0.588422 -0.669436 +v 1.149719 0.584249 -0.669301 +v 1.156721 0.576236 -0.664274 +v 1.162420 0.564691 -0.654546 +v 1.166597 0.550058 -0.640493 +v 1.169091 0.532900 -0.622654 +v 1.169806 0.513875 -0.601715 +v 1.168716 0.493714 -0.578480 +v 1.084867 0.519044 -0.553575 +v 1.091428 0.541283 -0.576588 +v 1.099194 0.561334 -0.598271 +v 1.107868 0.578425 -0.617791 +v 1.117117 0.591900 -0.634397 +v 1.126584 0.601242 -0.647452 +v 1.135907 0.606091 -0.656454 +v 1.144727 0.606260 -0.661056 +v 1.152704 0.601744 -0.661083 +v 1.159532 0.592716 -0.656532 +v 1.164950 0.579523 -0.647579 +v 1.168748 0.562672 -0.634568 +v 1.170781 0.542810 -0.617999 +v 1.170971 0.520701 -0.598508 +v 1.169310 0.497194 -0.576846 +v 1.085297 0.521610 -0.551047 +v 1.092270 0.546317 -0.571630 +v 1.100417 0.568641 -0.591073 +v 1.109425 0.587725 -0.608630 +v 1.118947 0.602836 -0.623625 +v 1.128618 0.613393 -0.635483 +v 1.138066 0.618991 -0.643747 +v 1.146927 0.619413 -0.648101 +v 1.154862 0.614645 -0.648376 +v 1.161566 0.604868 -0.644563 +v 1.166780 0.590459 -0.636807 +v 1.170305 0.571972 -0.625407 +v 1.172004 0.550117 -0.610801 +v 1.171813 0.525734 -0.593551 +v 1.169739 0.499760 -0.574318 +v 1.085545 0.523164 -0.547724 +v 1.092757 0.549364 -0.565111 +v 1.101125 0.573064 -0.581610 +v 1.110326 0.593355 -0.596585 +v 1.120007 0.609456 -0.609462 +v 1.129795 0.620749 -0.619746 +v 1.139315 0.626799 -0.627041 +v 1.148202 0.627375 -0.631067 +v 1.156112 0.622453 -0.631669 +v 1.162743 0.612224 -0.628825 +v 1.167840 0.597079 -0.622644 +v 1.171206 0.577602 -0.613362 +v 1.172712 0.554541 -0.601338 +v 1.172301 0.528781 -0.587032 +v 1.169988 0.501314 -0.570995 +v 1.085603 0.523645 -0.543733 +v 1.092872 0.550307 -0.557283 +v 1.101291 0.574434 -0.570244 +v 1.110537 0.595098 -0.582119 +v 1.120255 0.611506 -0.592452 +v 1.130071 0.623026 -0.600845 +v 1.139608 0.629217 -0.606976 +v 1.148500 0.629840 -0.610610 +v 1.156405 0.624871 -0.611605 +v 1.163019 0.614501 -0.609925 +v 1.168088 0.599129 -0.605634 +v 1.171417 0.579345 -0.598897 +v 1.172878 0.555910 -0.589972 +v 1.172415 0.529724 -0.579203 +v 1.170046 0.501794 -0.567004 +v 1.085469 0.523034 -0.539227 +v 1.092608 0.549110 -0.548445 +v 1.100908 0.572696 -0.557413 +v 1.110050 0.592887 -0.565789 +v 1.119682 0.608906 -0.573250 +v 1.129435 0.620137 -0.579509 +v 1.138933 0.626150 -0.584325 +v 1.147812 0.626713 -0.587515 +v 1.155730 0.621804 -0.588954 +v 1.162383 0.611612 -0.588589 +v 1.167515 0.596529 -0.586432 +v 1.170930 0.577134 -0.582566 +v 1.172495 0.554173 -0.577142 +v 1.172152 0.528528 -0.570365 +v 1.169912 0.501184 -0.562498 +v 1.085147 0.521357 -0.534380 +v 1.091977 0.545820 -0.538937 +v 1.099992 0.567919 -0.543610 +v 1.108884 0.586807 -0.548221 +v 1.118311 0.601756 -0.552592 +v 1.127911 0.612193 -0.556555 +v 1.137316 0.617716 -0.559958 +v 1.146163 0.618114 -0.562670 +v 1.154112 0.613370 -0.564587 +v 1.160859 0.603668 -0.565635 +v 1.166144 0.589379 -0.565774 +v 1.169764 0.571054 -0.564999 +v 1.171579 0.549396 -0.563339 +v 1.171521 0.525237 -0.560858 +v 1.169590 0.499507 -0.557651 +v 1.084651 0.518676 -0.529378 +v 1.091003 0.540561 -0.529125 +v 1.098577 0.560286 -0.529366 +v 1.107083 0.577091 -0.530091 +v 1.116194 0.590332 -0.531273 +v 1.125559 0.599499 -0.532867 +v 1.134818 0.604241 -0.534811 +v 1.143616 0.604374 -0.537030 +v 1.151615 0.599894 -0.539440 +v 1.158507 0.590974 -0.541947 +v 1.164027 0.577955 -0.544455 +v 1.167963 0.561338 -0.546869 +v 1.170165 0.541762 -0.549094 +v 1.170546 0.519979 -0.551046 +v 1.169093 0.496826 -0.552649 +v 1.083998 0.515096 -0.524413 +v 1.089722 0.533538 -0.519386 +v 1.096718 0.550089 -0.515227 +v 1.104717 0.564114 -0.512096 +v 1.113412 0.575072 -0.510113 +v 1.122468 0.582543 -0.509355 +v 1.131536 0.586240 -0.509850 +v 1.140270 0.586021 -0.511581 +v 1.148333 0.581894 -0.514479 +v 1.155415 0.574018 -0.518435 +v 1.161245 0.562695 -0.523295 +v 1.165597 0.548361 -0.528873 +v 1.168306 0.531566 -0.534955 +v 1.169266 0.512956 -0.541307 +v 1.168441 0.493246 -0.547684 +v 1.165862 0.473193 -0.553843 +v 1.083214 0.510753 -0.519676 +v 1.088185 0.525019 -0.510094 +v 1.094487 0.537722 -0.501737 +v 1.101877 0.548373 -0.494926 +v 1.110072 0.556563 -0.489924 +v 1.118756 0.561977 -0.486922 +v 1.127597 0.564407 -0.486036 +v 1.136253 0.563760 -0.487299 +v 1.144394 0.560061 -0.490664 +v 1.151704 0.553451 -0.496002 +v 1.157905 0.544186 -0.503106 +v 1.162757 0.532620 -0.511703 +v 1.166074 0.519198 -0.521465 +v 1.167729 0.504437 -0.532015 +v 1.167657 0.488903 -0.542947 +v 1.082330 0.505815 -0.515349 +v 1.086450 0.515332 -0.501606 +v 1.091968 0.523659 -0.489414 +v 1.098672 0.530474 -0.479242 +v 1.106303 0.535516 -0.471482 +v 1.114568 0.538591 -0.466430 +v 1.123151 0.539580 -0.464282 +v 1.131720 0.538447 -0.465119 +v 1.139948 0.535234 -0.468911 +v 1.147516 0.530065 -0.475510 +v 1.154136 0.523139 -0.484663 +v 1.159552 0.514721 -0.496020 +v 1.163556 0.505135 -0.509142 +v 1.165994 0.494750 -0.523527 +v 1.166773 0.483965 -0.538620 +v 1.081379 0.500471 -0.511598 +v 1.084584 0.504850 -0.494248 +v 1.089260 0.508440 -0.478732 +v 1.095224 0.511104 -0.465647 +v 1.102249 0.512739 -0.455495 +v 1.110064 0.513283 -0.448667 +v 1.118369 0.512714 -0.445425 +v 1.126845 0.511054 -0.445893 +v 1.135166 0.508368 -0.450054 +v 1.143012 0.504758 -0.457747 +v 1.150082 0.500362 -0.468677 +v 1.156104 0.495351 -0.482425 +v 1.160847 0.489917 -0.498461 +v 1.164128 0.484267 -0.516169 +v 1.165822 0.478621 -0.534869 +v 1.080397 0.494926 -0.508568 +v 1.082659 0.493974 -0.488304 +v 1.086465 0.492651 -0.470102 +v 1.091667 0.491008 -0.454663 +v 1.098066 0.489109 -0.442579 +v 1.105416 0.487027 -0.434316 +v 1.113435 0.484840 -0.430189 +v 1.121814 0.482635 -0.430359 +v 1.130232 0.480494 -0.434818 +v 1.138364 0.478501 -0.443396 +v 1.145899 0.476732 -0.455761 +v 1.152547 0.475255 -0.471441 +v 1.158052 0.474127 -0.489830 +v 1.162203 0.473392 -0.510224 +v 1.164840 0.473076 -0.531839 +v 1.079423 0.489395 -0.506374 +v 1.080749 0.483123 -0.484001 +v 1.083691 0.476898 -0.463855 +v 1.088137 0.470959 -0.446712 +v 1.093915 0.465534 -0.433230 +v 1.100804 0.460831 -0.423927 +v 1.108539 0.457031 -0.419161 +v 1.116822 0.454280 -0.419115 +v 1.125336 0.452685 -0.423790 +v 1.133752 0.452305 -0.433007 +v 1.141749 0.453157 -0.446412 +v 1.149017 0.455206 -0.463490 +v 1.155279 0.458375 -0.483583 +v 1.160293 0.462541 -0.505921 +v 1.163866 0.467545 -0.529645 +v 1.078494 0.484088 -0.505102 +v 1.078927 0.472714 -0.481504 +v 1.081046 0.461787 -0.460231 +v 1.084770 0.451726 -0.442100 +v 1.089956 0.442918 -0.427807 +v 1.096405 0.435702 -0.417901 +v 1.103869 0.430354 -0.412764 +v 1.112061 0.427081 -0.412592 +v 1.120666 0.426008 -0.417392 +v 1.129353 0.427176 -0.426981 +v 1.137789 0.430541 -0.440989 +v 1.145650 0.435973 -0.458877 +v 1.152633 0.443263 -0.479960 +v 1.158470 0.452132 -0.503425 +v 1.162937 0.462238 -0.528373 +v 1.077646 0.479211 -0.504799 +v 1.077263 0.463147 -0.480911 +v 1.078630 0.447898 -0.459370 +v 1.081695 0.434049 -0.441004 +v 1.086341 0.422132 -0.426517 +v 1.092388 0.412605 -0.416469 +v 1.099604 0.405835 -0.411243 +v 1.107712 0.402081 -0.411041 +v 1.116400 0.401489 -0.415872 +v 1.125335 0.404080 -0.425548 +v 1.134174 0.409755 -0.439699 +v 1.142575 0.418296 -0.457781 +v 1.150217 0.429374 -0.479098 +v 1.156806 0.442565 -0.502832 +v 1.162089 0.457361 -0.528070 +v 1.076911 0.474951 -0.505478 +v 1.075821 0.454790 -0.482243 +v 1.076536 0.435765 -0.461304 +v 1.079031 0.418607 -0.443465 +v 1.083207 0.403974 -0.429412 +v 1.088906 0.392429 -0.419685 +v 1.095908 0.384416 -0.414658 +v 1.103944 0.380243 -0.414523 +v 1.112705 0.380070 -0.419286 +v 1.121854 0.383904 -0.428765 +v 1.131040 0.391597 -0.442594 +v 1.139911 0.402854 -0.460243 +v 1.148124 0.417242 -0.481032 +v 1.155364 0.434208 -0.504164 +v 1.161354 0.453101 -0.528749 +v 1.079765 0.495471 -0.530116 +v 1.076317 0.471470 -0.507113 +v 1.074656 0.447964 -0.485450 +v 1.074846 0.425855 -0.465960 +v 1.076879 0.405993 -0.449390 +v 1.080677 0.389142 -0.436379 +v 1.086095 0.375948 -0.427427 +v 1.092923 0.366920 -0.422876 +v 1.100901 0.362405 -0.422902 +v 1.109720 0.362574 -0.427505 +v 1.119043 0.367423 -0.436507 +v 1.128510 0.376765 -0.449561 +v 1.137759 0.390240 -0.466168 +v 1.146433 0.407331 -0.485688 +v 1.154200 0.427381 -0.507371 +v 1.160760 0.449620 -0.530384 +v 1.075888 0.468904 -0.509640 +v 1.073814 0.442930 -0.490408 +v 1.073623 0.418547 -0.473157 +v 1.075323 0.396692 -0.458551 +v 1.078847 0.378205 -0.447152 +v 1.084061 0.363797 -0.439396 +v 1.090765 0.354020 -0.435583 +v 1.098700 0.349252 -0.435858 +v 1.107561 0.349674 -0.440212 +v 1.117009 0.355271 -0.448476 +v 1.126680 0.365828 -0.460334 +v 1.136203 0.380939 -0.475329 +v 1.145210 0.400024 -0.492886 +v 1.153357 0.422348 -0.512329 +v 1.160331 0.447054 -0.532911 +vn -0.681265 -0.692312 0.237709 +vn -0.904202 -0.398114 0.154515 +vn -0.899167 -0.437422 -0.010163 +vn -0.997864 0.060305 0.024537 +vn -0.993133 0.116459 0.008606 +vn -0.994049 0.108585 -0.008240 +vn 0.937773 -0.342936 0.054415 +vn 0.903439 -0.421674 0.077029 +vn 0.928129 -0.372173 0.000702 +vn -0.163366 -0.944243 0.285836 +vn -0.237678 -0.971313 0.003082 +vn -0.999023 -0.005646 0.043184 +vn -0.998962 0.044557 -0.009156 +vn 0.959319 -0.279885 0.036439 +vn 0.954558 -0.297952 0.002503 +vn 0.400891 -0.887326 0.227851 +vn 0.306772 -0.951720 -0.008209 +vn -0.993652 -0.090213 0.066988 +vn -0.999512 -0.029389 -0.010102 +vn 0.974090 -0.225135 0.020844 +vn 0.972289 -0.233711 0.003906 +vn 0.710898 -0.685812 0.155644 +vn 0.649068 -0.760643 -0.009552 +vn -0.972472 -0.209967 0.100833 +vn -0.992462 -0.122013 -0.011048 +vn 0.841639 -0.529069 0.108188 +vn 0.808283 -0.588733 -0.005341 +vn -0.968505 -0.248695 -0.011597 +vn 0.885464 -0.464644 -0.001770 +vn -0.697470 -0.716575 -0.002472 +vn -0.882015 -0.447066 -0.148717 +vn -0.994324 0.103427 -0.024293 +vn 0.918058 -0.392804 -0.053377 +vn -0.286966 -0.931303 -0.224189 +vn -0.998535 0.034150 -0.041353 +vn 0.949950 -0.310739 -0.031312 +vn 0.221259 -0.951018 -0.215766 +vn -0.997162 -0.044527 -0.060366 +vn 0.970763 -0.239570 -0.012604 +vn 0.583178 -0.794702 -0.168218 +vn -0.986541 -0.140751 -0.083010 +vn 0.770867 -0.625782 -0.118748 +vn -0.956969 -0.267769 -0.111606 +vn 0.865627 -0.494003 -0.081301 +vn 0.734123 -0.640522 -0.225196 +vn -0.942198 -0.270577 -0.197516 +vn 0.846126 -0.509140 -0.157476 +vn -0.691702 -0.696066 -0.192328 +vn -0.860988 -0.436171 -0.261513 +vn -0.994110 0.100864 -0.039064 +vn 0.908505 -0.404279 -0.105411 +vn -0.316630 -0.862697 -0.394269 +vn -0.997040 0.028993 -0.071017 +vn 0.945952 -0.317942 -0.063692 +vn 0.152104 -0.910764 -0.383831 +vn -0.993011 -0.051424 -0.106113 +vn 0.969665 -0.242744 -0.028199 +vn 0.522294 -0.794671 -0.309305 +vn -0.978027 -0.147618 -0.147038 +vn 0.969024 -0.243233 -0.042268 +vn 0.472671 -0.769616 -0.429243 +vn -0.968688 -0.143742 -0.202338 +vn 0.702658 -0.635334 -0.320322 +vn -0.927183 -0.259926 -0.269662 +vn 0.829463 -0.510239 -0.227088 +vn -0.677541 -0.653829 -0.336711 +vn -0.840815 -0.410779 -0.352489 +vn -0.993530 0.100803 -0.052217 +vn 0.900723 -0.406415 -0.153264 +vn -0.333079 -0.785394 -0.521683 +vn -0.994812 0.028932 -0.097415 +vn 0.942961 -0.319437 -0.093387 +vn 0.101444 -0.850185 -0.516587 +vn -0.987945 -0.050478 -0.146306 +vn -0.992187 0.033753 -0.119938 +vn 0.941465 -0.315226 -0.119297 +vn 0.068545 -0.779717 -0.622333 +vn -0.982665 -0.042177 -0.180364 +vn 0.968963 -0.241066 -0.054415 +vn 0.437788 -0.726981 -0.528947 +vn -0.959807 -0.130222 -0.248573 +vn 0.680013 -0.613208 -0.401868 +vn -0.913846 -0.237892 -0.329020 +vn 0.817866 -0.498276 -0.287698 +vn -0.662252 -0.601062 -0.447310 +vn -0.823817 -0.374310 -0.425642 +vn -0.992615 0.103183 -0.063448 +vn 0.895749 -0.399396 -0.195105 +vn -0.340922 -0.706229 -0.620441 +vn -0.648854 -0.541978 -0.534043 +vn -0.810968 -0.328440 -0.484146 +vn -0.991516 0.107791 -0.072451 +vn 0.894436 -0.383801 -0.229408 +vn -0.342784 -0.625996 -0.700430 +vn -0.989471 0.043184 -0.138096 +vn 0.941710 -0.305643 -0.140446 +vn 0.051912 -0.703543 -0.708731 +vn -0.977783 -0.027100 -0.207801 +vn 0.969512 -0.236396 -0.064272 +vn 0.419446 -0.671529 -0.610767 +vn -0.952208 -0.108005 -0.285684 +vn 0.668722 -0.576891 -0.468978 +vn -0.903226 -0.205908 -0.376507 +vn 0.812922 -0.474502 -0.337535 +vn 0.670217 -0.528398 -0.521104 +vn -0.802545 -0.273659 -0.530045 +vn 0.815699 -0.440138 -0.375317 +vn -0.638386 -0.477462 -0.603687 +vn -0.631031 -0.406751 -0.660512 +vn -0.990265 0.114475 -0.079134 +vn 0.897214 -0.360424 -0.255074 +vn -0.339854 -0.542741 -0.768029 +vn -0.986785 0.056887 -0.151585 +vn 0.943846 -0.291116 -0.156133 +vn 0.050569 -0.622059 -0.781304 +vn -0.973571 -0.005737 -0.228248 +vn 0.970641 -0.229530 -0.071535 +vn 0.418561 -0.605487 -0.676870 +vn -0.946348 -0.077731 -0.313608 +vn 0.947844 -0.272134 -0.165868 +vn 0.064547 -0.533372 -0.843379 +vn -0.895779 -0.164769 -0.412793 +vn -0.891568 -0.114872 -0.438032 +vn 0.435743 -0.529191 -0.728050 +vn -0.798425 -0.209632 -0.564379 +vn 0.685110 -0.468764 -0.557512 +vn -0.626576 -0.327891 -0.706992 +vn -0.984283 0.074465 -0.160100 +vn 0.826380 -0.396283 -0.399976 +vn -0.332224 -0.453230 -0.827143 +vn -0.970183 0.021363 -0.241371 +vn 0.904172 -0.329997 -0.271218 +vn -0.942381 -0.040010 -0.332102 +vn 0.914914 -0.293435 -0.277139 +vn -0.319071 -0.352641 -0.879665 +vn -0.940092 0.004639 -0.340831 +vn 0.972381 -0.220557 -0.076113 +vn 0.953520 -0.249214 -0.169256 +vn 0.095004 -0.433637 -0.896054 +vn -0.890225 -0.056246 -0.451949 +vn 0.471389 -0.441481 -0.763451 +vn -0.798059 -0.135380 -0.587115 +vn 0.712973 -0.398541 -0.576861 +vn -0.624378 -0.237892 -0.743980 +vn -0.988861 0.123081 -0.083377 +vn -0.981903 0.095523 -0.163366 +vn 0.844539 -0.343883 -0.410413 +vn -0.967559 0.053652 -0.246834 +vn -0.987396 0.133366 -0.085025 +vn -0.979644 0.119510 -0.161260 +vn 0.868831 -0.284005 -0.405469 +vn -0.298257 -0.234230 -0.925291 +vn -0.965423 0.090487 -0.244331 +vn 0.928678 -0.251717 -0.272256 +vn -0.939055 0.055696 -0.339213 +vn 0.974639 -0.209693 -0.077792 +vn 0.960540 -0.223090 -0.166021 +vn 0.144200 -0.317118 -0.937346 +vn -0.891079 0.011109 -0.453688 +vn 0.525285 -0.340129 -0.779962 +vn -0.800623 -0.049318 -0.597125 +vn 0.752373 -0.317942 -0.576891 +vn -0.623463 -0.132572 -0.770501 +vn -0.804498 0.050356 -0.591754 +vn 0.800348 -0.227638 -0.554613 +vn -0.621754 -0.006378 -0.783166 +vn -0.985809 0.145207 -0.083987 +vn -0.977294 0.145787 -0.153600 +vn 0.897092 -0.218238 -0.384136 +vn -0.265938 -0.088595 -0.959899 +vn -0.963439 0.131077 -0.233558 +vn 0.944273 -0.206336 -0.256355 +vn -0.938444 0.112522 -0.326518 +vn 0.977355 -0.197211 -0.076449 +vn 0.968352 -0.194678 -0.156072 +vn 0.214881 -0.176305 -0.960570 +vn -0.892880 0.087313 -0.441694 +vn 0.595965 -0.222633 -0.771508 +vn 0.308267 -0.003754 -0.951262 +vn -0.893918 0.171911 -0.413892 +vn 0.678854 -0.088473 -0.728874 +vn -0.807123 0.165288 -0.566729 +vn 0.852046 -0.129795 -0.507065 +vn -0.615253 0.147099 -0.774438 +vn -0.984130 0.158269 -0.080172 +vn -0.974731 0.173650 -0.140385 +vn 0.926298 -0.148839 -0.346110 +vn -0.216071 0.095767 -0.971648 +vn -0.961058 0.174444 -0.214240 +vn 0.960173 -0.158940 -0.229743 +vn -0.937284 0.174139 -0.301889 +vn 0.980346 -0.183538 -0.071993 +vn 0.976318 -0.165014 -0.139683 +vn 0.974761 -0.111576 -0.193213 +vn -0.141850 0.325968 -0.934660 +vn -0.934263 0.239021 -0.264534 +vn 0.983459 -0.169134 -0.064486 +vn 0.983795 -0.135289 -0.117374 +vn 0.419752 0.200537 -0.885189 +vn -0.891812 0.263436 -0.367748 +vn 0.764458 0.057344 -0.642079 +vn -0.804285 0.295297 -0.515641 +vn 0.900937 -0.029054 -0.432966 +vn -0.596942 0.332255 -0.730216 +vn -0.982299 0.172155 -0.073550 +vn -0.971709 0.202277 -0.121677 +vn 0.953093 -0.079043 -0.292154 +vn -0.957671 0.219337 -0.186254 +vn -0.980346 0.186499 -0.064180 +vn -0.968108 0.230628 -0.097659 +vn 0.974364 -0.012909 -0.224555 +vn -0.557085 0.541917 -0.629231 +vn -0.952788 0.264077 -0.149632 +vn 0.986694 -0.066561 -0.148259 +vn -0.043062 0.584490 -0.810236 +vn -0.928129 0.304666 -0.213874 +vn 0.986511 -0.154393 -0.054079 +vn 0.990204 -0.106845 -0.089846 +vn 0.534135 0.415540 -0.736198 +vn -0.883724 0.358348 -0.300974 +vn 0.838252 0.200598 -0.506974 +vn -0.790246 0.435530 -0.431013 +vn 0.939940 0.066958 -0.334666 +vn -0.867275 0.449873 -0.213080 +vn 0.964049 0.148991 -0.219916 +vn -0.759606 0.572436 -0.308664 +vn -0.978240 0.200751 -0.052004 +vn -0.963927 0.257057 -0.068789 +vn 0.988037 0.044771 -0.147496 +vn -0.489608 0.743217 -0.455947 +vn -0.946135 0.306223 -0.105045 +vn 0.994903 -0.026673 -0.097140 +vn 0.065615 0.812037 -0.579852 +vn -0.917905 0.367138 -0.150456 +vn 0.989288 -0.140049 -0.040925 +vn 0.994964 -0.081301 -0.058260 +vn 0.627491 0.593371 -0.504105 +vn 0.886288 0.319407 -0.335276 +vn 0.681265 0.692312 -0.237678 +vn -0.903439 0.421705 -0.077029 +vn 0.972472 0.209998 -0.100833 +vn -0.841639 0.529069 -0.108188 +vn 0.993652 0.090213 -0.066988 +vn -0.710898 0.685812 -0.155644 +vn -0.976104 0.213996 -0.037294 +vn -0.974090 0.225166 -0.020844 +vn 0.999023 0.005646 -0.043153 +vn -0.400891 0.887326 -0.227821 +vn -0.959319 0.279885 -0.036439 +vn 0.997864 -0.060305 -0.024537 +vn 0.163366 0.944243 -0.285806 +vn -0.937773 0.342936 -0.054415 +vn 0.991546 -0.127049 -0.025422 +vn 0.993133 -0.116428 -0.008606 +vn 0.998962 -0.044557 0.009156 +vn 0.237678 0.971313 -0.003082 +vn -0.928129 0.372173 -0.000702 +vn 0.994049 -0.108585 0.008240 +vn 0.904202 0.398114 -0.154515 +vn 0.899167 0.437422 0.010163 +vn -0.885464 0.464644 0.001770 +vn 0.968505 0.248695 0.011597 +vn -0.808283 0.588733 0.005341 +vn 0.992462 0.122013 0.011048 +vn -0.649068 0.760643 0.009552 +vn -0.972289 0.233711 -0.003906 +vn 0.999512 0.029389 0.010102 +vn -0.306772 0.951720 0.008209 +vn -0.954558 0.297952 -0.002503 +vn 0.997162 0.044527 0.060366 +vn -0.221259 0.951018 0.215766 +vn -0.949950 0.310739 0.031312 +vn 0.998535 -0.034150 0.041353 +vn 0.697470 0.716575 0.002472 +vn 0.286966 0.931303 0.224189 +vn -0.918058 0.392804 0.053377 +vn 0.994324 -0.103427 0.024293 +vn 0.882015 0.447066 0.148717 +vn -0.865627 0.494003 0.081301 +vn 0.956969 0.267769 0.111606 +vn -0.770867 0.625782 0.118748 +vn 0.986541 0.140751 0.083010 +vn -0.583209 0.794702 0.168218 +vn -0.970763 0.239570 0.012604 +vn 0.978027 0.147618 0.147038 +vn -0.522294 0.794671 0.309305 +vn -0.969665 0.242744 0.028199 +vn 0.993011 0.051424 0.106113 +vn -0.152104 0.910764 0.383831 +vn -0.945952 0.317942 0.063692 +vn 0.997040 -0.028993 0.071017 +vn 0.691702 0.696066 0.192328 +vn 0.316630 0.862697 0.394269 +vn -0.908505 0.404279 0.105411 +vn 0.994110 -0.100864 0.039064 +vn 0.860988 0.436171 0.261513 +vn -0.846126 0.509140 0.157476 +vn 0.942198 0.270577 0.197516 +vn -0.734123 0.640522 0.225196 +vn -0.829463 0.510239 0.227088 +vn 0.927183 0.259926 0.269662 +vn -0.702658 0.635334 0.320322 +vn 0.968688 0.143742 0.202338 +vn -0.472671 0.769616 0.429243 +vn -0.969024 0.243233 0.042268 +vn 0.987945 0.050478 0.146336 +vn -0.101444 0.850185 0.516587 +vn -0.942961 0.319437 0.093387 +vn 0.994812 -0.028901 0.097415 +vn 0.677572 0.653829 0.336711 +vn 0.333079 0.785394 0.521683 +vn -0.900723 0.406384 0.153264 +vn 0.993530 -0.100803 0.052217 +vn 0.840815 0.410779 0.352489 +vn 0.662252 0.601062 0.447310 +vn 0.340922 0.706229 0.620441 +vn -0.895749 0.399396 0.195105 +vn 0.992615 -0.103183 0.063417 +vn 0.823817 0.374310 0.425642 +vn -0.817835 0.498306 0.287698 +vn 0.913846 0.237892 0.329020 +vn -0.680013 0.613208 0.401868 +vn 0.959807 0.130222 0.248573 +vn -0.437788 0.726981 0.528947 +vn -0.968963 0.241066 0.054415 +vn 0.982665 0.042177 0.180364 +vn -0.068545 0.779717 0.622333 +vn -0.941465 0.315226 0.119297 +vn 0.992187 -0.033753 0.119938 +vn 0.977783 0.027100 0.207801 +vn -0.051912 0.703543 0.708731 +vn -0.941710 0.305643 0.140446 +vn 0.989471 -0.043214 0.138096 +vn 0.648854 0.541978 0.534043 +vn 0.342784 0.625996 0.700430 +vn -0.894436 0.383801 0.229408 +vn 0.991516 -0.107791 0.072451 +vn 0.810968 0.328440 0.484146 +vn -0.812922 0.474502 0.337535 +vn 0.903226 0.205908 0.376507 +vn -0.668722 0.576891 0.468978 +vn 0.952208 0.108005 0.285684 +vn -0.419446 0.671529 0.610767 +vn -0.969512 0.236427 0.064272 +vn 0.946348 0.077731 0.313608 +vn -0.418561 0.605487 0.676870 +vn -0.970641 0.229530 0.071535 +vn 0.973571 0.005707 0.228248 +vn -0.050569 0.622059 0.781304 +vn -0.943846 0.291116 0.156133 +vn 0.986785 -0.056887 0.151585 +vn 0.638386 0.477493 0.603687 +vn 0.339854 0.542741 0.768029 +vn -0.897214 0.360424 0.255074 +vn 0.990265 -0.114444 0.079134 +vn 0.631062 0.406751 0.660512 +vn -0.815699 0.440138 0.375317 +vn 0.802545 0.273659 0.530045 +vn -0.670217 0.528398 0.521104 +vn -0.685110 0.468764 0.557512 +vn 0.895779 0.164800 0.412793 +vn 0.798425 0.209632 0.564379 +vn -0.435743 0.529191 0.728050 +vn 0.891568 0.114872 0.438032 +vn -0.064547 0.533372 0.843410 +vn -0.947844 0.272134 0.165868 +vn 0.942381 0.040010 0.332102 +vn -0.904172 0.329997 0.271218 +vn 0.970183 -0.021363 0.241371 +vn 0.332224 0.453230 0.827143 +vn -0.826380 0.396283 0.399976 +vn 0.984283 -0.074465 0.160100 +vn 0.626545 0.327891 0.706992 +vn 0.319071 0.352641 0.879665 +vn -0.844539 0.343883 0.410413 +vn 0.988861 -0.123051 0.083377 +vn 0.981903 -0.095523 0.163366 +vn 0.624378 0.237892 0.743980 +vn -0.712973 0.398541 0.576861 +vn 0.798059 0.135380 0.587115 +vn -0.471389 0.441481 0.763451 +vn 0.890225 0.056246 0.451979 +vn -0.095004 0.433637 0.896054 +vn -0.972381 0.220557 0.076113 +vn -0.953520 0.249214 0.169256 +vn 0.940092 -0.004639 0.340831 +vn -0.914914 0.293405 0.277139 +vn 0.967559 -0.053652 0.246834 +vn 0.939055 -0.055696 0.339213 +vn 0.298257 0.234230 0.925291 +vn -0.928678 0.251717 0.272256 +vn 0.965423 -0.090487 0.244362 +vn -0.868831 0.284005 0.405469 +vn 0.987396 -0.133396 0.085055 +vn 0.979644 -0.119510 0.161260 +vn 0.623463 0.132572 0.770501 +vn -0.752373 0.317942 0.576891 +vn 0.800623 0.049318 0.597125 +vn -0.525285 0.340098 0.779962 +vn 0.891079 -0.011109 0.453688 +vn -0.144200 0.317118 0.937346 +vn -0.974639 0.209693 0.077792 +vn -0.960540 0.223060 0.166021 +vn 0.892880 -0.087313 0.441694 +vn -0.214881 0.176305 0.960570 +vn -0.977355 0.197211 0.076449 +vn -0.968352 0.194678 0.156072 +vn 0.938444 -0.112522 0.326518 +vn 0.265938 0.088595 0.959899 +vn -0.944273 0.206336 0.256355 +vn 0.963439 -0.131077 0.233558 +vn -0.897092 0.218238 0.384136 +vn 0.985809 -0.145207 0.083987 +vn 0.977294 -0.145787 0.153600 +vn 0.621754 0.006378 0.783166 +vn -0.800348 0.227638 0.554613 +vn 0.804498 -0.050356 0.591754 +vn -0.595965 0.222633 0.771508 +vn 0.807123 -0.165288 0.566729 +vn -0.678854 0.088473 0.728874 +vn 0.893918 -0.171911 0.413892 +vn -0.308267 0.003754 0.951262 +vn -0.980346 0.183538 0.071993 +vn -0.976318 0.165014 0.139683 +vn 0.937284 -0.174169 0.301889 +vn 0.216071 -0.095767 0.971648 +vn -0.960173 0.158940 0.229743 +vn 0.961058 -0.174444 0.214240 +vn -0.926298 0.148839 0.346110 +vn 0.984130 -0.158269 0.080172 +vn 0.974731 -0.173650 0.140385 +vn 0.615253 -0.147099 0.774438 +vn -0.852046 0.129795 0.507065 +vn -0.953063 0.079043 0.292154 +vn 0.982299 -0.172155 0.073550 +vn 0.971709 -0.202277 0.121677 +vn 0.596942 -0.332255 0.730216 +vn -0.900937 0.029054 0.432966 +vn 0.804285 -0.295297 0.515641 +vn -0.764458 -0.057344 0.642079 +vn 0.891812 -0.263436 0.367748 +vn -0.419752 -0.200537 0.885189 +vn -0.983459 0.169103 0.064486 +vn -0.983795 0.135289 0.117374 +vn 0.934263 -0.239021 0.264534 +vn 0.141850 -0.325968 0.934660 +vn -0.974761 0.111576 0.193213 +vn 0.957671 -0.219337 0.186254 +vn 0.043062 -0.584490 0.810236 +vn -0.986694 0.066561 0.148259 +vn 0.952788 -0.264077 0.149632 +vn 0.557085 -0.541887 0.629231 +vn -0.974364 0.012909 0.224555 +vn 0.980346 -0.186499 0.064180 +vn 0.968108 -0.230628 0.097659 +vn -0.939940 -0.066958 0.334666 +vn 0.790246 -0.435530 0.431013 +vn -0.838282 -0.200598 0.506974 +vn 0.883724 -0.358348 0.300974 +vn -0.534104 -0.415571 0.736198 +vn -0.986511 0.154393 0.054079 +vn -0.990204 0.106815 0.089846 +vn 0.928129 -0.304666 0.213874 +vn 0.867275 -0.449873 0.213080 +vn -0.627491 -0.593371 0.504135 +vn -0.989288 0.140049 0.040925 +vn -0.994964 0.081301 0.058260 +vn 0.917905 -0.367138 0.150456 +vn -0.065615 -0.812037 0.579882 +vn -0.994903 0.026673 0.097140 +vn 0.946135 -0.306223 0.105045 +vn 0.489608 -0.743217 0.455947 +vn -0.988037 -0.044771 0.147496 +vn 0.978240 -0.200751 0.052004 +vn 0.963927 -0.257057 0.068789 +vn 0.759606 -0.572436 0.308664 +vn -0.964049 -0.148991 0.219916 +vn -0.886288 -0.319407 0.335276 +vn 0.985198 -0.171270 0.005707 +vn -0.985198 0.171270 -0.005707 +vn 0.976104 -0.213996 0.037294 +vn -0.991546 0.127079 0.025422 +vn -0.993133 0.116428 0.008606 +vn 0.928159 -0.372173 0.000702 +vn 0.974090 -0.225166 0.020814 +vn 0.841609 -0.529069 0.108188 +vn 0.583209 -0.794702 -0.168218 +vn 0.865627 -0.494034 -0.081301 +vn 0.846126 -0.509110 -0.157476 +vn -0.994110 0.100864 -0.039094 +vn 0.152074 -0.910764 -0.383831 +vn 0.969665 -0.242744 -0.028169 +vn 0.472640 -0.769616 -0.429243 +vn 0.702658 -0.635304 -0.320322 +vn -0.927183 -0.259896 -0.269662 +vn -0.987945 -0.050478 -0.146336 +vn -0.982665 -0.042207 -0.180364 +vn -0.959807 -0.130253 -0.248573 +vn -0.992615 0.103183 -0.063417 +vn -0.340922 -0.706259 -0.620441 +vn -0.342784 -0.625965 -0.700430 +vn 0.969512 -0.236427 -0.064272 +vn -0.952208 -0.107974 -0.285684 +vn -0.638386 -0.477462 -0.603656 +vn -0.339824 -0.542741 -0.768029 +vn 0.970641 -0.229499 -0.071535 +vn 0.064547 -0.533372 -0.843410 +vn -0.798425 -0.209662 -0.564379 +vn -0.626545 -0.327891 -0.707022 +vn -0.984283 0.074465 -0.160070 +vn 0.914914 -0.293405 -0.277139 +vn -0.940092 0.004608 -0.340831 +vn -0.890225 -0.056246 -0.451979 +vn -0.967559 0.053682 -0.246834 +vn -0.987396 0.133396 -0.085025 +vn -0.979644 0.119480 -0.161260 +vn -0.965423 0.090487 -0.244362 +vn 0.144200 -0.317148 -0.937346 +vn 0.525285 -0.340098 -0.779962 +vn -0.800623 -0.049348 -0.597125 +vn -0.621723 -0.006378 -0.783166 +vn -0.985809 0.145268 -0.083987 +vn -0.938444 0.112552 -0.326487 +vn 0.595935 -0.222633 -0.771508 +vn 0.852046 -0.129765 -0.507065 +vn 0.926267 -0.148869 -0.346110 +vn -0.961058 0.174413 -0.214240 +vn -0.937284 0.174169 -0.301889 +vn 0.983459 -0.169073 -0.064516 +vn -0.982299 0.172124 -0.073550 +vn -0.971709 0.202307 -0.121677 +vn 0.953063 -0.079043 -0.292154 +vn -0.957701 0.219337 -0.186254 +vn -0.557085 0.541887 -0.629231 +vn 0.990173 -0.106845 -0.089846 +vn 0.534104 0.415571 -0.736198 +vn 0.838282 0.200568 -0.506974 +vn 0.988037 0.044771 -0.147465 +vn -0.489578 0.743217 -0.455947 +vn 0.989288 -0.140080 -0.040925 +vn 0.627461 0.593371 -0.504135 +vn 0.972472 0.209967 -0.100833 +vn -0.976104 0.213996 -0.037263 +vn 0.999023 0.005646 -0.043184 +vn -0.959319 0.279885 -0.036409 +vn 0.998962 -0.044588 0.009156 +vn 0.237678 0.971313 -0.003113 +vn -0.928159 0.372173 -0.000702 +vn -0.808283 0.588733 0.005310 +vn -0.972259 0.233741 -0.003906 +vn 0.993011 0.051424 0.106082 +vn -0.152104 0.910764 0.383862 +vn 0.316630 0.862697 0.394299 +vn 0.860988 0.436201 0.261513 +vn -0.846126 0.509110 0.157476 +vn -0.829463 0.510239 0.227119 +vn 0.927183 0.259896 0.269662 +vn -0.702658 0.635304 0.320322 +vn -0.472640 0.769616 0.429243 +vn 0.987945 0.050478 0.146306 +vn 0.994812 -0.028932 0.097415 +vn 0.677541 0.653829 0.336711 +vn -0.900723 0.406415 0.153264 +vn 0.340922 0.706259 0.620441 +vn -0.817866 0.498276 0.287698 +vn 0.982665 0.042177 0.180395 +vn 0.989471 -0.043184 0.138096 +vn 0.342784 0.625965 0.700430 +vn 0.952208 0.107974 0.285684 +vn -0.970641 0.229499 0.071535 +vn 0.973571 0.005737 0.228248 +vn 0.638386 0.477462 0.603656 +vn 0.339824 0.542741 0.768029 +vn -0.897214 0.360424 0.255043 +vn 0.990265 -0.114475 0.079134 +vn 0.631031 0.406751 0.660512 +vn -0.670217 0.528367 0.521104 +vn 0.895779 0.164769 0.412793 +vn 0.798425 0.209662 0.564379 +vn -0.904141 0.330027 0.271218 +vn 0.984283 -0.074496 0.160100 +vn 0.626545 0.327891 0.707022 +vn 0.890225 0.056246 0.451949 +vn 0.940092 -0.004608 0.340831 +vn 0.967559 -0.053682 0.246834 +vn 0.987396 -0.133366 0.085055 +vn 0.979644 -0.119480 0.161260 +vn -0.960540 0.223090 0.166021 +vn -0.977355 0.197180 0.076449 +vn -0.944273 0.206336 0.256386 +vn 0.985809 -0.145238 0.083987 +vn -0.976318 0.165044 0.139683 +vn -0.926298 0.148869 0.346110 +vn 0.974731 -0.173681 0.140385 +vn 0.615253 -0.147099 0.774468 +vn -0.852046 0.129765 0.507065 +vn 0.971709 -0.202307 0.121677 +vn -0.974761 0.111545 0.193213 +vn 0.957701 -0.219306 0.186254 +vn 0.043092 -0.584490 0.810236 +vn -0.990204 0.106845 0.089846 +vn 0.928098 -0.304666 0.213874 +vn -0.065615 -0.812037 0.579852 +vn 0.978240 -0.200751 0.052034 +usemtl SkinColor +s 1 +f 1453//1107 1452//1108 1467//1109 +f 1448//1110 1447//1111 1462//1112 +f 1459//1113 1458//1114 1474//1115 +f 1454//1116 1453//1107 1469//1117 +f 1449//1118 1448//1110 1463//1119 +f 1460//1120 1459//1113 1475//1121 +f 1455//1122 1454//1116 1470//1123 +f 1450//1124 1449//1118 1464//1125 +f 1461//1126 1460//1120 1476//1127 +f 1456//1128 1455//1122 1471//1129 +f 1451//1130 1450//1124 1465//1131 +f 1457//1132 1456//1128 1472//1133 +f 1452//1108 1451//1130 1466//1134 +f 1458//1114 1457//1132 1473//1135 +f 1468//1136 1467//1109 1482//1137 +f 1463//1119 1462//1112 1477//1138 +f 1474//1115 1473//1135 1489//1139 +f 1469//1117 1468//1136 1484//1140 +f 1464//1125 1463//1119 1478//1141 +f 1475//1121 1474//1115 1490//1142 +f 1470//1123 1469//1117 1485//1143 +f 1465//1131 1464//1125 1479//1144 +f 1476//1127 1475//1121 1491//1145 +f 1471//1129 1470//1123 1486//1146 +f 1466//1134 1465//1131 1480//1147 +f 1472//1133 1471//1129 1487//1148 +f 1467//1109 1466//1134 1481//1149 +f 1473//1135 1472//1133 1488//1150 +f 1487//1148 1486//1146 1502//1151 +f 1482//1137 1481//1149 1496//1152 +f 1488//1150 1487//1148 1503//1153 +f 1483//1154 1482//1137 1497//1155 +f 1478//1141 1477//1138 1492//1156 +f 1489//1139 1488//1150 1504//1157 +f 1484//1140 1483//1154 1499//1158 +f 1479//1144 1478//1141 1493//1159 +f 1490//1142 1489//1139 1505//1160 +f 1485//1143 1484//1140 1500//1161 +f 1480//1147 1479//1144 1494//1162 +f 1491//1145 1490//1142 1506//1163 +f 1486//1146 1485//1143 1501//1164 +f 1481//1149 1480//1147 1495//1165 +f 1506//1163 1505//1160 1521//1166 +f 1501//1164 1500//1161 1516//1167 +f 1496//1152 1495//1165 1510//1168 +f 1502//1151 1501//1164 1517//1169 +f 1497//1155 1496//1152 1511//1170 +f 1503//1153 1502//1151 1518//1171 +f 1498//1172 1497//1155 1512//1173 +f 1493//1159 1492//1156 1507//1174 +f 1504//1157 1503//1153 1519//1175 +f 1499//1158 1498//1172 1514//1176 +f 1494//1162 1493//1159 1508//1177 +f 1505//1160 1504//1157 1520//1178 +f 1500//1161 1499//1158 1515//1179 +f 1495//1165 1494//1162 1509//1180 +f 1509//1180 1508//1177 1523//1181 +f 1520//1178 1519//1175 1535//1182 +f 1515//1179 1514//1176 1530//1183 +f 1510//1168 1509//1180 1524//1184 +f 1521//1166 1520//1178 1536//1185 +f 1516//1167 1515//1179 1531//1186 +f 1511//1170 1510//1168 1525//1187 +f 1517//1169 1516//1167 1532//1188 +f 1512//1173 1511//1170 1526//1189 +f 1518//1171 1517//1169 1533//1190 +f 1513//1191 1512//1173 1527//1192 +f 1508//1177 1507//1174 1522//1193 +f 1519//1175 1518//1171 1534//1194 +f 1514//1176 1513//1191 1529//1195 +f 1528//1196 1527//1192 1542//1197 +f 1523//1181 1522//1193 1537//1198 +f 1534//1194 1533//1190 1549//1199 +f 1529//1195 1528//1196 1544//1200 +f 1524//1184 1523//1181 1538//1201 +f 1535//1182 1534//1194 1550//1202 +f 1530//1183 1529//1195 1545//1203 +f 1525//1187 1524//1184 1539//1204 +f 1536//1185 1535//1182 1551//1205 +f 1531//1186 1530//1183 1546//1206 +f 1526//1189 1525//1187 1540//1207 +f 1532//1188 1531//1186 1547//1208 +f 1527//1192 1526//1189 1541//1209 +f 1533//1190 1532//1188 1548//1210 +f 1547//1208 1546//1206 1562//1211 +f 1542//1197 1541//1209 1557//1212 +f 1548//1210 1547//1208 1563//1213 +f 1543//1214 1542//1197 1558//1215 +f 1538//1201 1537//1198 1552//1216 +f 1549//1199 1548//1210 1564//1217 +f 1544//1200 1543//1214 1559//1218 +f 1539//1204 1538//1201 1553//1219 +f 1550//1202 1549//1199 1565//1220 +f 1545//1203 1544//1200 1560//1221 +f 1540//1207 1539//1204 1554//1222 +f 1551//1205 1550//1202 1566//1223 +f 1546//1206 1545//1203 1561//1224 +f 1541//1209 1540//1207 1555//1225 +f 1566//1223 1565//1220 1580//1226 +f 1561//1224 1560//1221 1575//1227 +f 1556//1228 1555//1225 1571//1229 +f 1562//1211 1561//1224 1576//1230 +f 1557//1212 1556//1228 1572//1231 +f 1563//1213 1562//1211 1577//1232 +f 1558//1215 1557//1212 1573//1233 +f 1553//1219 1552//1216 1568//1234 +f 1564//1217 1563//1213 1578//1235 +f 1559//1218 1558//1215 1574//1236 +f 1554//1222 1553//1219 1569//1237 +f 1565//1220 1564//1217 1579//1238 +f 1560//1221 1559//1218 1575//1227 +f 1555//1225 1554//1222 1570//1239 +f 1580//1226 1579//1238 1594//1240 +f 1575//1227 1574//1236 1589//1241 +f 1570//1239 1569//1237 1585//1242 +f 1581//1243 1580//1226 1595//1244 +f 1576//1230 1575//1227 1590//1245 +f 1571//1229 1570//1239 1586//1246 +f 1577//1232 1576//1230 1591//1247 +f 1572//1231 1571//1229 1587//1248 +f 1578//1235 1577//1232 1592//1249 +f 1573//1233 1572//1231 1588//1250 +f 1568//1234 1567//1251 1583//1252 +f 1579//1238 1578//1235 1593//1253 +f 1574//1236 1573//1233 1589//1241 +f 1569//1237 1568//1234 1584//1254 +f 1583//1252 1582//1255 1598//1256 +f 1594//1240 1593//1253 1608//1257 +f 1589//1241 1588//1250 1604//1258 +f 1584//1254 1583//1252 1599//1259 +f 1595//1244 1594//1240 1609//1260 +f 1590//1245 1589//1241 1604//1258 +f 1585//1242 1584//1254 1600//1261 +f 1596//1262 1595//1244 1610//1263 +f 1591//1247 1590//1245 1605//1264 +f 1586//1246 1585//1242 1601//1265 +f 1592//1249 1591//1247 1606//1266 +f 1587//1248 1586//1246 1602//1267 +f 1593//1253 1592//1249 1607//1268 +f 1588//1250 1587//1248 1603//1269 +f 1602//1267 1601//1265 1617//1270 +f 1608//1257 1607//1268 1622//1271 +f 1603//1269 1602//1267 1618//1272 +f 1598//1256 1597//1273 1613//1274 +f 1609//1260 1608//1257 1623//1275 +f 1604//1258 1603//1269 1619//1276 +f 1599//1259 1598//1256 1614//1277 +f 1610//1263 1609//1260 1624//1278 +f 1605//1264 1604//1258 1619//1276 +f 1600//1261 1599//1259 1615//1279 +f 1611//1280 1610//1263 1625//1281 +f 1606//1266 1605//1264 1620//1282 +f 1601//1265 1600//1261 1616//1283 +f 1607//1268 1606//1266 1621//1284 +f 1621//1284 1620//1282 1635//1285 +f 1616//1283 1615//1279 1631//1286 +f 1622//1271 1621//1284 1636//1287 +f 1617//1270 1616//1283 1632//1288 +f 1623//1275 1622//1271 1637//1289 +f 1618//1272 1617//1270 1633//1290 +f 1613//1274 1612//1291 1628//1292 +f 1624//1278 1623//1275 1638//1293 +f 1619//1276 1618//1272 1634//1294 +f 1614//1277 1613//1274 1629//1295 +f 1625//1281 1624//1278 1639//1296 +f 1620//1282 1619//1276 1634//1294 +f 1615//1279 1614//1277 1630//1297 +f 1626//1298 1625//1281 1640//1299 +f 1640//1299 1639//1296 1654//1300 +f 1635//1285 1634//1294 1649//1301 +f 1630//1297 1629//1295 1645//1302 +f 1641//1303 1640//1299 1655//1304 +f 1636//1287 1635//1285 1650//1305 +f 1631//1286 1630//1297 1646//1306 +f 1637//1289 1636//1287 1651//1307 +f 1632//1288 1631//1286 1647//1308 +f 1638//1293 1637//1289 1652//1309 +f 1633//1290 1632//1288 1648//1310 +f 1628//1292 1627//1311 1643//1312 +f 1639//1296 1638//1293 1653//1313 +f 1634//1294 1633//1290 1649//1301 +f 1629//1295 1628//1292 1644//1314 +f 1643//1312 1642//1315 1658//1316 +f 1654//1300 1653//1313 1668//1317 +f 1649//1301 1648//1310 1663//1318 +f 1644//1314 1643//1312 1659//1319 +f 1655//1304 1654//1300 1669//1320 +f 1650//1305 1649//1301 1664//1321 +f 1645//1302 1644//1314 1660//1322 +f 1656//1323 1655//1304 1670//1324 +f 1651//1307 1650//1305 1665//1325 +f 1646//1306 1645//1302 1661//1326 +f 1652//1309 1651//1307 1666//1327 +f 1647//1308 1646//1306 1662//1328 +f 1653//1313 1652//1309 1667//1329 +f 1648//1310 1647//1308 1663//1318 +f 1662//1328 1661//1326 1676//1330 +f 1668//1317 1667//1329 1682//1331 +f 1663//1318 1662//1328 1677//1332 +f 1658//1316 1657//1333 1673//1334 +f 1669//1320 1668//1317 1683//1335 +f 1664//1321 1663//1318 1678//1336 +f 1659//1319 1658//1316 1674//1337 +f 1670//1324 1669//1320 1684//1338 +f 1665//1325 1664//1321 1679//1339 +f 1660//1322 1659//1319 1675//1340 +f 1671//1341 1670//1324 1685//1342 +f 1666//1327 1665//1325 1680//1343 +f 1661//1326 1660//1322 1676//1330 +f 1667//1329 1666//1327 1681//1344 +f 1681//1344 1680//1343 1695//1345 +f 1676//1330 1675//1340 1690//1346 +f 1682//1331 1681//1344 1697//1347 +f 1677//1332 1676//1330 1691//1348 +f 1683//1335 1682//1331 1698//1349 +f 1678//1336 1677//1332 1692//1350 +f 1673//1334 1672//1351 1687//1352 +f 1684//1338 1683//1335 1699//1353 +f 1679//1339 1678//1336 1693//1354 +f 1674//1337 1673//1334 1688//1355 +f 1685//1342 1684//1338 1700//1356 +f 1680//1343 1679//1339 1694//1357 +f 1675//1340 1674//1337 1689//1358 +f 1686//1359 1685//1342 1701//1360 +f 1700//1356 1699//1353 1715//1361 +f 1695//1345 1694//1357 1709//1362 +f 1690//1346 1689//1358 1704//1363 +f 1701//1360 1700//1356 1716//1364 +f 1696//1365 1695//1345 1711//1366 +f 1691//1348 1690//1346 1705//1367 +f 1697//1347 1696//1365 1712//1368 +f 1692//1350 1691//1348 1706//1369 +f 1698//1349 1697//1347 1713//1370 +f 1693//1354 1692//1350 1707//1371 +f 1688//1355 1687//1352 1702//1372 +f 1699//1353 1698//1349 1714//1373 +f 1694//1357 1693//1354 1708//1374 +f 1689//1358 1688//1355 1703//1375 +f 1714//1373 1713//1370 1729//1376 +f 1709//1362 1708//1374 1723//1377 +f 1704//1363 1703//1375 1718//1378 +f 1715//1361 1714//1373 1730//1379 +f 1710//1380 1709//1362 1724//1381 +f 1705//1367 1704//1363 1719//1382 +f 1716//1364 1715//1361 1731//1383 +f 1711//1366 1710//1380 1726//1384 +f 1706//1369 1705//1367 1720//1385 +f 1712//1368 1711//1366 1727//1386 +f 1707//1371 1706//1369 1721//1387 +f 1713//1370 1712//1368 1728//1388 +f 1708//1374 1707//1371 1722//1389 +f 1703//1375 1702//1372 1717//1390 +f 1728//1388 1727//1386 1743//1391 +f 1723//1377 1722//1389 1737//1392 +f 1718//1378 1717//1390 1732//1393 +f 1729//1376 1728//1388 1744//1394 +f 1724//1381 1723//1377 1738//1395 +f 1719//1382 1718//1378 1733//1396 +f 1730//1379 1729//1376 1745//1397 +f 1725//1398 1724//1381 1739//1399 +f 1720//1385 1719//1382 1734//1400 +f 1731//1383 1730//1379 1746//1401 +f 1726//1384 1725//1398 1741//1402 +f 1721//1387 1720//1385 1735//1403 +f 1727//1386 1726//1384 1742//1404 +f 1722//1389 1721//1387 1736//1405 +f 1736//1405 1735//1403 1750//1406 +f 1742//1404 1741//1402 1757//1407 +f 1737//1392 1736//1405 1751//1408 +f 1743//1391 1742//1404 1758//1409 +f 1738//1395 1737//1392 1752//1410 +f 1733//1396 1732//1393 1747//1411 +f 1744//1394 1743//1391 1759//1412 +f 1739//1399 1738//1395 1753//1413 +f 1734//1400 1733//1396 1748//1414 +f 1745//1397 1744//1394 1760//1415 +f 1740//1416 1739//1399 1754//1417 +f 1735//1403 1734//1400 1749//1418 +f 1746//1401 1745//1397 1761//1419 +f 1741//1402 1740//1416 1756//1420 +f 1755//1421 1754//1417 1769//1422 +f 1750//1406 1749//1418 1764//1423 +f 1761//1419 1760//1415 1776//1424 +f 1756//1420 1755//1421 1771//1425 +f 1751//1408 1750//1406 1765//1426 +f 1757//1407 1756//1420 1772//1427 +f 1752//1410 1751//1408 1766//1428 +f 1758//1409 1757//1407 1773//1429 +f 1753//1413 1752//1410 1767//1430 +f 1748//1414 1747//1411 1762//1431 +f 1759//1412 1758//1409 1774//1432 +f 1754//1417 1753//1413 1768//1433 +f 1749//1418 1748//1414 1763//1434 +f 1760//1415 1759//1412 1775//1435 +f 1774//1432 1773//1429 1790//1436 +f 1769//1422 1768//1433 1784//1437 +f 1764//1423 1763//1434 1779//1438 +f 1775//1435 1774//1432 1791//1439 +f 1770//1440 1769//1422 1785//1441 +f 1765//1426 1764//1423 1780//1442 +f 1776//1424 1775//1435 1792//1443 +f 1771//1425 1770//1440 1787//1444 +f 1766//1428 1765//1426 1781//1445 +f 1772//1427 1771//1425 1788//1446 +f 1767//1430 1766//1428 1782//1447 +f 1773//1429 1772//1427 1789//1448 +f 1768//1433 1767//1430 1783//1449 +f 1763//1434 1762//1431 1778//1450 +f 1789//1448 1788//1446 1804//1451 +f 1784//1437 1783//1449 1798//1452 +f 1779//1438 1778//1450 1793//1453 +f 1790//1436 1789//1448 1805//1454 +f 1785//1441 1784//1437 1799//1455 +f 1780//1442 1779//1438 1794//1456 +f 1791//1439 1790//1436 1806//1457 +f 1786//1458 1785//1441 1800//1459 +f 1781//1445 1780//1442 1795//1460 +f 1792//1443 1791//1439 1807//1461 +f 1787//1444 1786//1458 1801//1462 +f 1782//1447 1781//1445 1796//1463 +f 1788//1446 1787//1444 1802//1464 +f 1783//1449 1782//1447 1797//1465 +f 1797//1465 1796//1463 1812//1466 +f 1803//1467 1802//1464 1817//1468 +f 1798//1452 1797//1465 1813//1469 +f 1804//1451 1803//1467 1818//1470 +f 1799//1455 1798//1452 1814//1471 +f 1794//1456 1793//1453 1809//1472 +f 1805//1454 1804//1451 1819//1473 +f 1800//1459 1799//1455 1814//1471 +f 1795//1460 1794//1456 1810//1474 +f 1806//1457 1805//1454 1820//1475 +f 1801//1462 1800//1459 1815//1476 +f 1796//1463 1795//1460 1811//1477 +f 1807//1461 1806//1457 1821//1478 +f 1802//1464 1801//1462 1816//1479 +f 1816//1479 1815//1476 1830//1480 +f 1811//1477 1810//1474 1826//1481 +f 1822//1482 1821//1478 1836//1483 +f 1817//1468 1816//1479 1831//1484 +f 1812//1466 1811//1477 1827//1485 +f 1818//1470 1817//1468 1832//1486 +f 1813//1469 1812//1466 1828//1487 +f 1819//1473 1818//1470 1833//1488 +f 1814//1471 1813//1469 1829//1489 +f 1809//1472 1808//1490 1824//1491 +f 1820//1475 1819//1473 1834//1492 +f 1815//1476 1814//1471 1830//1480 +f 1810//1474 1809//1472 1825//1493 +f 1821//1478 1820//1475 1835//1494 +f 1835//1494 1834//1492 1849//1495 +f 1830//1480 1829//1489 1845//1496 +f 1825//1493 1824//1491 1840//1497 +f 1836//1483 1835//1494 1850//1498 +f 1831//1484 1830//1480 1845//1496 +f 1826//1481 1825//1493 1841//1499 +f 1837//1500 1836//1483 1851//1501 +f 1832//1486 1831//1484 1846//1502 +f 1827//1485 1826//1481 1842//1503 +f 1833//1488 1832//1486 1847//1504 +f 1828//1487 1827//1485 1843//1505 +f 1834//1492 1833//1488 1848//1506 +f 1829//1489 1828//1487 1844//1507 +f 1824//1491 1823//1508 1839//1509 +f 1849//1495 1848//1506 1863//1510 +f 1844//1507 1843//1505 1859//1511 +f 1839//1509 1838//1512 1854//1513 +f 1850//1498 1849//1495 1864//1514 +f 1845//1496 1844//1507 1860//1515 +f 1840//1497 1839//1509 1855//1516 +f 1851//1501 1850//1498 1865//1517 +f 1846//1502 1845//1496 1860//1515 +f 1841//1499 1840//1497 1856//1518 +f 1852//1519 1851//1501 1866//1520 +f 1847//1504 1846//1502 1861//1521 +f 1842//1503 1841//1499 1857//1522 +f 1848//1506 1847//1504 1862//1523 +f 1843//1505 1842//1503 1858//1524 +f 1863//1510 1862//1523 1877//1525 +f 1858//1524 1857//1522 1873//1526 +f 1864//1514 1863//1510 1878//1527 +f 1859//1511 1858//1524 1874//1528 +f 1854//1513 1853//1529 1869//1530 +f 1865//1517 1864//1514 1879//1531 +f 1860//1515 1859//1511 1875//1532 +f 1855//1516 1854//1513 1870//1533 +f 1866//1520 1865//1517 1880//1534 +f 1861//1521 1860//1515 1875//1532 +f 1856//1518 1855//1516 1871//1535 +f 1867//1536 1866//1520 1881//1537 +f 1862//1523 1861//1521 1876//1538 +f 1857//1522 1856//1518 1872//1539 +f 1871//1535 1870//1533 1886//1540 +f 1882//1541 1881//1537 1896//1542 +f 1877//1525 1876//1538 1891//1543 +f 1872//1539 1871//1535 1887//1544 +f 1878//1527 1877//1525 1892//1545 +f 1873//1526 1872//1539 1888//1546 +f 1879//1531 1878//1527 1893//1547 +f 1874//1528 1873//1526 1889//1548 +f 1869//1530 1868//1549 1884//1550 +f 1880//1534 1879//1531 1894//1551 +f 1875//1532 1874//1528 1890//1552 +f 1870//1533 1869//1530 1885//1553 +f 1881//1537 1880//1534 1895//1554 +f 1876//1538 1875//1532 1890//1552 +f 1890//1552 1889//1548 1906//1555 +f 1885//1553 1884//1550 1901//1556 +f 1896//1542 1895//1554 1911//1557 +f 1891//1543 1890//1552 1907//1558 +f 1886//1540 1885//1553 1902//1559 +f 1897//1560 1896//1542 1912//1561 +f 1892//1545 1891//1543 1907//1558 +f 1887//1544 1886//1540 1903//1562 +f 1893//1547 1892//1545 1908//1563 +f 1888//1546 1887//1544 1904//1564 +f 1894//1551 1893//1547 1909//1565 +f 1889//1548 1888//1546 1905//1566 +f 1884//1550 1883//1567 1900//1568 +f 1895//1554 1894//1551 1910//1569 +f 1910//1569 1909//1565 1924//1570 +f 1905//1566 1904//1564 1920//1571 +f 1900//1568 1899//1572 1915//1573 +f 1911//1557 1910//1569 1925//1574 +f 1906//1555 1905//1566 1921//1575 +f 1901//1556 1900//1568 1916//1576 +f 1912//1561 1911//1557 1926//1577 +f 1907//1558 1906//1555 1922//1578 +f 1902//1559 1901//1556 1917//1579 +f 1913//1580 1912//1561 1927//1581 +f 1908//1563 1907//1558 1923//1582 +f 1903//1562 1902//1559 1918//1583 +f 1909//1565 1908//1563 1924//1570 +f 1904//1564 1903//1562 1919//1584 +f 1777//1585 1461//1126 1476//1127 +f 1447//1111 1898//1586 1462//1112 +f 1777//1585 1476//1127 1491//1145 +f 1462//1112 1898//1586 1477//1138 +f 1477//1138 1898//1586 1492//1156 +f 1777//1585 1491//1145 1506//1163 +f 1777//1585 1506//1163 1521//1166 +f 1492//1156 1898//1586 1507//1174 +f 1777//1585 1521//1166 1536//1185 +f 1507//1174 1898//1586 1522//1193 +f 1777//1585 1536//1185 1551//1205 +f 1522//1193 1898//1586 1537//1198 +f 1537//1198 1898//1586 1552//1216 +f 1777//1585 1551//1205 1566//1223 +f 1777//1585 1566//1223 1581//1243 +f 1552//1216 1898//1586 1567//1251 +f 1777//1585 1581//1243 1596//1262 +f 1567//1251 1898//1586 1582//1255 +f 1777//1585 1596//1262 1611//1280 +f 1582//1255 1898//1586 1597//1273 +f 1597//1273 1898//1586 1612//1291 +f 1777//1585 1611//1280 1626//1298 +f 1777//1585 1626//1298 1641//1303 +f 1612//1291 1898//1586 1627//1311 +f 1777//1585 1641//1303 1656//1323 +f 1627//1311 1898//1586 1642//1315 +f 1777//1585 1656//1323 1671//1341 +f 1642//1315 1898//1586 1657//1333 +f 1657//1333 1898//1586 1672//1351 +f 1777//1585 1671//1341 1686//1359 +f 1777//1585 1686//1359 1701//1360 +f 1672//1351 1898//1586 1687//1352 +f 1777//1585 1701//1360 1716//1364 +f 1687//1352 1898//1586 1702//1372 +f 1777//1585 1716//1364 1731//1383 +f 1702//1372 1898//1586 1717//1390 +f 1717//1390 1898//1586 1732//1393 +f 1777//1585 1731//1383 1746//1401 +f 1777//1585 1746//1401 1761//1419 +f 1732//1393 1898//1586 1747//1411 +f 1777//1585 1761//1419 1776//1424 +f 1747//1411 1898//1586 1762//1431 +f 1777//1585 1776//1424 1792//1443 +f 1762//1431 1898//1586 1778//1450 +f 1778//1450 1898//1586 1793//1453 +f 1777//1585 1792//1443 1807//1461 +f 1777//1585 1807//1461 1822//1482 +f 1793//1453 1898//1586 1808//1490 +f 1777//1585 1822//1482 1837//1500 +f 1808//1490 1898//1586 1823//1508 +f 1777//1585 1837//1500 1852//1519 +f 1823//1508 1898//1586 1838//1512 +f 1777//1585 1852//1519 1867//1536 +f 1838//1512 1898//1586 1853//1529 +f 1777//1585 1867//1536 1882//1541 +f 1853//1529 1898//1586 1868//1549 +f 1777//1585 1882//1541 1897//1560 +f 1868//1549 1898//1586 1883//1567 +f 1777//1585 1897//1560 1913//1580 +f 1883//1567 1898//1586 1899//1572 +f 1777//1585 1913//1580 1928//1587 +f 1899//1572 1898//1586 1914//1588 +f 1777//1585 1928//1587 1461//1126 +f 1924//1570 1923//1582 1457//1132 +f 1919//1584 1918//1583 1451//1130 +f 1914//1588 1898//1586 1447//1111 +f 1925//1574 1924//1570 1458//1114 +f 1920//1571 1919//1584 1453//1107 +f 1915//1573 1914//1588 1447//1111 +f 1926//1577 1925//1574 1459//1113 +f 1921//1575 1920//1571 1454//1116 +f 1916//1576 1915//1573 1448//1110 +f 1927//1581 1926//1577 1460//1120 +f 1922//1578 1921//1575 1455//1122 +f 1917//1579 1916//1576 1449//1118 +f 1928//1587 1927//1581 1461//1126 +f 1923//1582 1922//1578 1456//1128 +f 1918//1583 1917//1579 1450//1124 +f 1935//1107 1934//1108 1949//1109 +f 1930//1110 1929//1589 1944//1112 +f 1941//1113 1940//1114 1956//1590 +f 1936//1116 1935//1107 1951//1117 +f 1931//1118 1930//1110 1945//1119 +f 1942//1120 1941//1113 1957//1121 +f 1937//1122 1936//1116 1952//1123 +f 1932//1124 1931//1118 1946//1125 +f 1943//1591 1942//1120 1958//1127 +f 1938//1128 1937//1122 1953//1129 +f 1933//1130 1932//1124 1947//1131 +f 1939//1592 1938//1128 1954//1133 +f 1934//1108 1933//1130 1948//1134 +f 1940//1114 1939//1592 1955//1135 +f 1950//1136 1949//1109 1964//1137 +f 1945//1119 1944//1112 1959//1138 +f 1956//1590 1955//1135 1971//1139 +f 1951//1117 1950//1136 1966//1140 +f 1946//1125 1945//1119 1960//1141 +f 1957//1121 1956//1590 1972//1142 +f 1952//1123 1951//1117 1967//1143 +f 1947//1131 1946//1125 1961//1144 +f 1958//1127 1957//1121 1973//1145 +f 1953//1129 1952//1123 1968//1593 +f 1948//1134 1947//1131 1962//1147 +f 1954//1133 1953//1129 1969//1148 +f 1949//1109 1948//1134 1963//1149 +f 1955//1135 1954//1133 1970//1594 +f 1969//1148 1968//1593 1984//1151 +f 1964//1137 1963//1149 1978//1152 +f 1970//1594 1969//1148 1985//1595 +f 1965//1154 1964//1137 1979//1155 +f 1960//1141 1959//1138 1974//1596 +f 1971//1139 1970//1594 1986//1157 +f 1966//1140 1965//1154 1981//1158 +f 1961//1144 1960//1141 1975//1159 +f 1972//1142 1971//1139 1987//1160 +f 1967//1143 1966//1140 1982//1597 +f 1962//1147 1961//1144 1976//1162 +f 1973//1145 1972//1142 1988//1598 +f 1968//1593 1967//1143 1983//1164 +f 1963//1149 1962//1147 1977//1165 +f 1988//1598 1987//1160 2003//1166 +f 1983//1164 1982//1597 1998//1599 +f 1978//1152 1977//1165 1992//1168 +f 1984//1151 1983//1164 1999//1600 +f 1979//1155 1978//1152 1993//1601 +f 1985//1595 1984//1151 2000//1171 +f 1980//1172 1979//1155 1994//1173 +f 1975//1159 1974//1596 1989//1174 +f 1986//1157 1985//1595 2001//1175 +f 1981//1158 1980//1172 1996//1176 +f 1976//1162 1975//1159 1990//1177 +f 1987//1160 1986//1157 2002//1178 +f 1982//1597 1981//1158 1997//1179 +f 1977//1165 1976//1162 1991//1602 +f 1991//1602 1990//1177 2005//1181 +f 2002//1178 2001//1175 2017//1182 +f 1997//1179 1996//1176 2012//1183 +f 1992//1168 1991//1602 2006//1603 +f 2003//1166 2002//1178 2018//1185 +f 1998//1599 1997//1179 2013//1186 +f 1993//1601 1992//1168 2007//1604 +f 1999//1600 1998//1599 2014//1188 +f 1994//1173 1993//1601 2008//1189 +f 2000//1171 1999//1600 2015//1190 +f 1995//1191 1994//1173 2009//1192 +f 1990//1177 1989//1174 2004//1605 +f 2001//1175 2000//1171 2016//1194 +f 1996//1176 1995//1191 2011//1606 +f 2010//1196 2009//1192 2024//1197 +f 2005//1181 2004//1605 2019//1198 +f 2016//1194 2015//1190 2031//1199 +f 2011//1606 2010//1196 2026//1607 +f 2006//1603 2005//1181 2020//1201 +f 2017//1182 2016//1194 2032//1202 +f 2012//1183 2011//1606 2027//1203 +f 2007//1604 2006//1603 2021//1204 +f 2018//1185 2017//1182 2033//1608 +f 2013//1186 2012//1183 2028//1206 +f 2008//1189 2007//1604 2022//1609 +f 2014//1188 2013//1186 2029//1208 +f 2009//1192 2008//1189 2023//1209 +f 2015//1190 2014//1188 2030//1210 +f 2029//1208 2028//1206 2044//1211 +f 2024//1197 2023//1209 2039//1212 +f 2030//1210 2029//1208 2045//1213 +f 2025//1610 2024//1197 2040//1215 +f 2020//1201 2019//1198 2034//1216 +f 2031//1199 2030//1210 2046//1217 +f 2026//1607 2025//1610 2041//1611 +f 2021//1204 2020//1201 2035//1219 +f 2032//1202 2031//1199 2047//1220 +f 2027//1203 2026//1607 2042//1221 +f 2022//1609 2021//1204 2036//1222 +f 2033//1608 2032//1202 2048//1612 +f 2028//1206 2027//1203 2043//1224 +f 2023//1209 2022//1609 2037//1225 +f 2048//1612 2047//1220 2062//1226 +f 2043//1224 2042//1221 2057//1613 +f 2038//1228 2037//1225 2053//1229 +f 2044//1211 2043//1224 2058//1230 +f 2039//1212 2038//1228 2054//1614 +f 2045//1213 2044//1211 2059//1232 +f 2040//1215 2039//1212 2055//1615 +f 2035//1219 2034//1216 2050//1616 +f 2046//1217 2045//1213 2060//1235 +f 2041//1611 2040//1215 2056//1236 +f 2036//1222 2035//1219 2051//1237 +f 2047//1220 2046//1217 2061//1238 +f 2042//1221 2041//1611 2057//1613 +f 2037//1225 2036//1222 2052//1239 +f 2062//1226 2061//1238 2076//1617 +f 2057//1613 2056//1236 2071//1241 +f 2052//1239 2051//1237 2067//1618 +f 2063//1243 2062//1226 2077//1244 +f 2058//1230 2057//1613 2072//1245 +f 2053//1229 2052//1239 2068//1619 +f 2059//1232 2058//1230 2073//1247 +f 2054//1614 2053//1229 2069//1248 +f 2060//1235 2059//1232 2074//1249 +f 2055//1615 2054//1614 2070//1250 +f 2050//1616 2049//1251 2065//1252 +f 2061//1238 2060//1235 2075//1253 +f 2056//1236 2055//1615 2071//1241 +f 2051//1237 2050//1616 2066//1620 +f 2065//1252 2064//1621 2080//1622 +f 2076//1617 2075//1253 2090//1257 +f 2071//1241 2070//1250 2086//1258 +f 2066//1620 2065//1252 2081//1623 +f 2077//1244 2076//1617 2091//1260 +f 2072//1245 2071//1241 2086//1258 +f 2067//1618 2066//1620 2082//1261 +f 2078//1262 2077//1244 2092//1263 +f 2073//1247 2072//1245 2087//1624 +f 2068//1619 2067//1618 2083//1265 +f 2074//1249 2073//1247 2088//1625 +f 2069//1248 2068//1619 2084//1626 +f 2075//1253 2074//1249 2089//1268 +f 2070//1250 2069//1248 2085//1269 +f 2084//1626 2083//1265 2099//1270 +f 2090//1257 2089//1268 2104//1271 +f 2085//1269 2084//1626 2100//1627 +f 2080//1622 2079//1628 2095//1274 +f 2091//1260 2090//1257 2105//1275 +f 2086//1258 2085//1269 2101//1276 +f 2081//1623 2080//1622 2096//1277 +f 2092//1263 2091//1260 2106//1278 +f 2087//1624 2086//1258 2101//1276 +f 2082//1261 2081//1623 2097//1629 +f 2093//1280 2092//1263 2107//1281 +f 2088//1625 2087//1624 2102//1282 +f 2083//1265 2082//1261 2098//1283 +f 2089//1268 2088//1625 2103//1630 +f 2103//1630 2102//1282 2117//1285 +f 2098//1283 2097//1629 2113//1286 +f 2104//1271 2103//1630 2118//1287 +f 2099//1270 2098//1283 2114//1288 +f 2105//1275 2104//1271 2119//1631 +f 2100//1627 2099//1270 2115//1290 +f 2095//1274 2094//1291 2110//1292 +f 2106//1278 2105//1275 2120//1632 +f 2101//1276 2100//1627 2116//1294 +f 2096//1277 2095//1274 2111//1633 +f 2107//1281 2106//1278 2121//1296 +f 2102//1282 2101//1276 2116//1294 +f 2097//1629 2096//1277 2112//1634 +f 2108//1298 2107//1281 2122//1299 +f 2122//1299 2121//1296 2136//1300 +f 2117//1285 2116//1294 2131//1301 +f 2112//1634 2111//1633 2127//1302 +f 2123//1635 2122//1299 2137//1304 +f 2118//1287 2117//1285 2132//1305 +f 2113//1286 2112//1634 2128//1306 +f 2119//1631 2118//1287 2133//1307 +f 2114//1288 2113//1286 2129//1308 +f 2120//1632 2119//1631 2134//1309 +f 2115//1290 2114//1288 2130//1310 +f 2110//1292 2109//1636 2125//1637 +f 2121//1296 2120//1632 2135//1638 +f 2116//1294 2115//1290 2131//1301 +f 2111//1633 2110//1292 2126//1639 +f 2125//1637 2124//1315 2140//1316 +f 2136//1300 2135//1638 2150//1317 +f 2131//1301 2130//1310 2145//1640 +f 2126//1639 2125//1637 2141//1319 +f 2137//1304 2136//1300 2151//1320 +f 2132//1305 2131//1301 2146//1321 +f 2127//1302 2126//1639 2142//1322 +f 2138//1323 2137//1304 2152//1641 +f 2133//1307 2132//1305 2147//1642 +f 2128//1306 2127//1302 2143//1326 +f 2134//1309 2133//1307 2148//1643 +f 2129//1308 2128//1306 2144//1328 +f 2135//1638 2134//1309 2149//1329 +f 2130//1310 2129//1308 2145//1640 +f 2144//1328 2143//1326 2158//1330 +f 2150//1317 2149//1329 2164//1331 +f 2145//1640 2144//1328 2159//1332 +f 2140//1316 2139//1333 2155//1334 +f 2151//1320 2150//1317 2165//1644 +f 2146//1321 2145//1640 2160//1645 +f 2141//1319 2140//1316 2156//1337 +f 2152//1641 2151//1320 2166//1338 +f 2147//1642 2146//1321 2161//1339 +f 2142//1322 2141//1319 2157//1340 +f 2153//1646 2152//1641 2167//1342 +f 2148//1643 2147//1642 2162//1647 +f 2143//1326 2142//1322 2158//1330 +f 2149//1329 2148//1643 2163//1344 +f 2163//1344 2162//1647 2177//1345 +f 2158//1330 2157//1340 2172//1346 +f 2164//1331 2163//1344 2179//1648 +f 2159//1332 2158//1330 2173//1348 +f 2165//1644 2164//1331 2180//1349 +f 2160//1645 2159//1332 2174//1350 +f 2155//1334 2154//1649 2169//1352 +f 2166//1338 2165//1644 2181//1650 +f 2161//1339 2160//1645 2175//1354 +f 2156//1337 2155//1334 2170//1651 +f 2167//1342 2166//1338 2182//1356 +f 2162//1647 2161//1339 2176//1357 +f 2157//1340 2156//1337 2171//1358 +f 2168//1359 2167//1342 2183//1360 +f 2182//1356 2181//1650 2197//1652 +f 2177//1345 2176//1357 2191//1653 +f 2172//1346 2171//1358 2186//1654 +f 2183//1360 2182//1356 2198//1364 +f 2178//1365 2177//1345 2193//1366 +f 2173//1348 2172//1346 2187//1367 +f 2179//1648 2178//1365 2194//1368 +f 2174//1350 2173//1348 2188//1655 +f 2180//1349 2179//1648 2195//1370 +f 2175//1354 2174//1350 2189//1371 +f 2170//1651 2169//1352 2184//1656 +f 2181//1650 2180//1349 2196//1373 +f 2176//1357 2175//1354 2190//1374 +f 2171//1358 2170//1651 2185//1375 +f 2196//1373 2195//1370 2211//1376 +f 2191//1653 2190//1374 2205//1377 +f 2186//1654 2185//1375 2200//1378 +f 2197//1652 2196//1373 2212//1379 +f 2192//1380 2191//1653 2206//1381 +f 2187//1367 2186//1654 2201//1382 +f 2198//1364 2197//1652 2213//1383 +f 2193//1366 2192//1380 2208//1384 +f 2188//1655 2187//1367 2202//1385 +f 2194//1368 2193//1366 2209//1386 +f 2189//1371 2188//1655 2203//1387 +f 2195//1370 2194//1368 2210//1388 +f 2190//1374 2189//1371 2204//1389 +f 2185//1375 2184//1656 2199//1390 +f 2210//1388 2209//1386 2225//1391 +f 2205//1377 2204//1389 2219//1392 +f 2200//1378 2199//1390 2214//1393 +f 2211//1376 2210//1388 2226//1657 +f 2206//1381 2205//1377 2220//1658 +f 2201//1382 2200//1378 2215//1396 +f 2212//1379 2211//1376 2227//1397 +f 2207//1398 2206//1381 2221//1659 +f 2202//1385 2201//1382 2216//1400 +f 2213//1383 2212//1379 2228//1401 +f 2208//1384 2207//1398 2223//1660 +f 2203//1387 2202//1385 2217//1661 +f 2209//1386 2208//1384 2224//1404 +f 2204//1389 2203//1387 2218//1405 +f 2218//1405 2217//1661 2232//1662 +f 2224//1404 2223//1660 2239//1663 +f 2219//1392 2218//1405 2233//1664 +f 2225//1391 2224//1404 2240//1409 +f 2220//1658 2219//1392 2234//1665 +f 2215//1396 2214//1393 2229//1411 +f 2226//1657 2225//1391 2241//1666 +f 2221//1659 2220//1658 2235//1413 +f 2216//1400 2215//1396 2230//1414 +f 2227//1397 2226//1657 2242//1667 +f 2222//1668 2221//1659 2236//1417 +f 2217//1661 2216//1400 2231//1669 +f 2228//1401 2227//1397 2243//1419 +f 2223//1660 2222//1668 2238//1420 +f 2237//1421 2236//1417 2251//1670 +f 2232//1662 2231//1669 2246//1423 +f 2243//1419 2242//1667 2258//1424 +f 2238//1420 2237//1421 2253//1425 +f 2233//1664 2232//1662 2247//1671 +f 2239//1663 2238//1420 2254//1427 +f 2234//1665 2233//1664 2248//1428 +f 2240//1409 2239//1663 2255//1429 +f 2235//1413 2234//1665 2249//1430 +f 2230//1414 2229//1411 2244//1431 +f 2241//1666 2240//1409 2256//1672 +f 2236//1417 2235//1413 2250//1433 +f 2231//1669 2230//1414 2245//1434 +f 2242//1667 2241//1666 2257//1435 +f 2256//1672 2255//1429 2272//1436 +f 2251//1670 2250//1433 2266//1437 +f 2246//1423 2245//1434 2261//1438 +f 2257//1435 2256//1672 2273//1673 +f 2252//1440 2251//1670 2267//1674 +f 2247//1671 2246//1423 2262//1442 +f 2258//1424 2257//1435 2274//1443 +f 2253//1425 2252//1440 2269//1444 +f 2248//1428 2247//1671 2263//1445 +f 2254//1427 2253//1425 2270//1446 +f 2249//1430 2248//1428 2264//1447 +f 2255//1429 2254//1427 2271//1675 +f 2250//1433 2249//1430 2265//1449 +f 2245//1434 2244//1431 2260//1450 +f 2271//1675 2270//1446 2286//1451 +f 2266//1437 2265//1449 2280//1452 +f 2261//1438 2260//1450 2275//1676 +f 2272//1436 2271//1675 2287//1677 +f 2267//1674 2266//1437 2281//1455 +f 2262//1442 2261//1438 2276//1456 +f 2273//1673 2272//1436 2288//1457 +f 2268//1678 2267//1674 2282//1679 +f 2263//1445 2262//1442 2277//1680 +f 2274//1443 2273//1673 2289//1681 +f 2269//1444 2268//1678 2283//1682 +f 2264//1447 2263//1445 2278//1463 +f 2270//1446 2269//1444 2284//1464 +f 2265//1449 2264//1447 2279//1683 +f 2279//1683 2278//1463 2294//1466 +f 2285//1684 2284//1464 2299//1685 +f 2280//1452 2279//1683 2295//1469 +f 2286//1451 2285//1684 2300//1470 +f 2281//1455 2280//1452 2296//1471 +f 2276//1456 2275//1676 2291//1472 +f 2287//1677 2286//1451 2301//1473 +f 2282//1679 2281//1455 2296//1471 +f 2277//1680 2276//1456 2292//1686 +f 2288//1457 2287//1677 2302//1475 +f 2283//1682 2282//1679 2297//1476 +f 2278//1463 2277//1680 2293//1477 +f 2289//1681 2288//1457 2303//1687 +f 2284//1464 2283//1682 2298//1688 +f 2298//1688 2297//1476 2312//1480 +f 2293//1477 2292//1686 2308//1481 +f 2304//1482 2303//1687 2318//1483 +f 2299//1685 2298//1688 2313//1484 +f 2294//1466 2293//1477 2309//1485 +f 2300//1470 2299//1685 2314//1486 +f 2295//1469 2294//1466 2310//1487 +f 2301//1473 2300//1470 2315//1689 +f 2296//1471 2295//1469 2311//1489 +f 2291//1472 2290//1490 2306//1491 +f 2302//1475 2301//1473 2316//1690 +f 2297//1476 2296//1471 2312//1480 +f 2292//1686 2291//1472 2307//1493 +f 2303//1687 2302//1475 2317//1691 +f 2317//1691 2316//1690 2331//1495 +f 2312//1480 2311//1489 2327//1496 +f 2307//1493 2306//1491 2322//1497 +f 2318//1483 2317//1691 2332//1498 +f 2313//1484 2312//1480 2327//1496 +f 2308//1481 2307//1493 2323//1499 +f 2319//1692 2318//1483 2333//1693 +f 2314//1486 2313//1484 2328//1502 +f 2309//1485 2308//1481 2324//1503 +f 2315//1689 2314//1486 2329//1504 +f 2310//1487 2309//1485 2325//1505 +f 2316//1690 2315//1689 2330//1506 +f 2311//1489 2310//1487 2326//1507 +f 2306//1491 2305//1508 2321//1694 +f 2331//1495 2330//1506 2345//1510 +f 2326//1507 2325//1505 2341//1511 +f 2321//1694 2320//1695 2336//1513 +f 2332//1498 2331//1495 2346//1514 +f 2327//1496 2326//1507 2342//1515 +f 2322//1497 2321//1694 2337//1696 +f 2333//1693 2332//1498 2347//1517 +f 2328//1502 2327//1496 2342//1515 +f 2323//1499 2322//1497 2338//1518 +f 2334//1697 2333//1693 2348//1520 +f 2329//1504 2328//1502 2343//1521 +f 2324//1503 2323//1499 2339//1522 +f 2330//1506 2329//1504 2344//1523 +f 2325//1505 2324//1503 2340//1524 +f 2345//1510 2344//1523 2359//1525 +f 2340//1524 2339//1522 2355//1526 +f 2346//1514 2345//1510 2360//1527 +f 2341//1511 2340//1524 2356//1528 +f 2336//1513 2335//1529 2351//1698 +f 2347//1517 2346//1514 2361//1531 +f 2342//1515 2341//1511 2357//1532 +f 2337//1696 2336//1513 2352//1533 +f 2348//1520 2347//1517 2362//1534 +f 2343//1521 2342//1515 2357//1532 +f 2338//1518 2337//1696 2353//1699 +f 2349//1536 2348//1520 2363//1700 +f 2344//1523 2343//1521 2358//1701 +f 2339//1522 2338//1518 2354//1702 +f 2353//1699 2352//1533 2368//1540 +f 2364//1541 2363//1700 2378//1703 +f 2359//1525 2358//1701 2373//1543 +f 2354//1702 2353//1699 2369//1544 +f 2360//1527 2359//1525 2374//1545 +f 2355//1526 2354//1702 2370//1546 +f 2361//1531 2360//1527 2375//1547 +f 2356//1528 2355//1526 2371//1548 +f 2351//1698 2350//1549 2366//1550 +f 2362//1534 2361//1531 2376//1551 +f 2357//1532 2356//1528 2372//1552 +f 2352//1533 2351//1698 2367//1704 +f 2363//1700 2362//1534 2377//1705 +f 2358//1701 2357//1532 2372//1552 +f 2372//1552 2371//1548 2388//1706 +f 2367//1704 2366//1550 2383//1556 +f 2378//1703 2377//1705 2393//1557 +f 2373//1543 2372//1552 2389//1558 +f 2368//1540 2367//1704 2384//1559 +f 2379//1560 2378//1703 2394//1561 +f 2374//1545 2373//1543 2389//1558 +f 2369//1544 2368//1540 2385//1562 +f 2375//1547 2374//1545 2390//1563 +f 2370//1546 2369//1544 2386//1564 +f 2376//1551 2375//1547 2391//1565 +f 2371//1548 2370//1546 2387//1566 +f 2366//1550 2365//1567 2382//1707 +f 2377//1705 2376//1551 2392//1708 +f 2392//1708 2391//1565 2406//1570 +f 2387//1566 2386//1564 2402//1571 +f 2382//1707 2381//1572 2397//1573 +f 2393//1557 2392//1708 2407//1574 +f 2388//1706 2387//1566 2403//1709 +f 2383//1556 2382//1707 2398//1576 +f 2394//1561 2393//1557 2408//1577 +f 2389//1558 2388//1706 2404//1578 +f 2384//1559 2383//1556 2399//1579 +f 2395//1710 2394//1561 2409//1581 +f 2390//1563 2389//1558 2405//1582 +f 2385//1562 2384//1559 2400//1583 +f 2391//1565 2390//1563 2406//1570 +f 2386//1564 2385//1562 2401//1584 +f 2259//1585 1943//1591 1958//1127 +f 1929//1589 2380//1586 1944//1112 +f 2259//1585 1958//1127 1973//1145 +f 1944//1112 2380//1586 1959//1138 +f 1959//1138 2380//1586 1974//1596 +f 2259//1585 1973//1145 1988//1598 +f 2259//1585 1988//1598 2003//1166 +f 1974//1596 2380//1586 1989//1174 +f 2259//1585 2003//1166 2018//1185 +f 1989//1174 2380//1586 2004//1605 +f 2259//1585 2018//1185 2033//1608 +f 2004//1605 2380//1586 2019//1198 +f 2019//1198 2380//1586 2034//1216 +f 2259//1585 2033//1608 2048//1612 +f 2259//1585 2048//1612 2063//1243 +f 2034//1216 2380//1586 2049//1251 +f 2259//1585 2063//1243 2078//1262 +f 2049//1251 2380//1586 2064//1621 +f 2259//1585 2078//1262 2093//1280 +f 2064//1621 2380//1586 2079//1628 +f 2079//1628 2380//1586 2094//1291 +f 2259//1585 2093//1280 2108//1298 +f 2259//1585 2108//1298 2123//1635 +f 2094//1291 2380//1586 2109//1636 +f 2259//1585 2123//1635 2138//1323 +f 2109//1636 2380//1586 2124//1315 +f 2259//1585 2138//1323 2153//1646 +f 2124//1315 2380//1586 2139//1333 +f 2139//1333 2380//1586 2154//1649 +f 2259//1585 2153//1646 2168//1359 +f 2259//1585 2168//1359 2183//1360 +f 2154//1649 2380//1586 2169//1352 +f 2259//1585 2183//1360 2198//1364 +f 2169//1352 2380//1586 2184//1656 +f 2259//1585 2198//1364 2213//1383 +f 2184//1656 2380//1586 2199//1390 +f 2199//1390 2380//1586 2214//1393 +f 2259//1585 2213//1383 2228//1401 +f 2259//1585 2228//1401 2243//1419 +f 2214//1393 2380//1586 2229//1411 +f 2259//1585 2243//1419 2258//1424 +f 2229//1411 2380//1586 2244//1431 +f 2259//1585 2258//1424 2274//1443 +f 2244//1431 2380//1586 2260//1450 +f 2260//1450 2380//1586 2275//1676 +f 2259//1585 2274//1443 2289//1681 +f 2259//1585 2289//1681 2304//1482 +f 2275//1676 2380//1586 2290//1490 +f 2259//1585 2304//1482 2319//1692 +f 2290//1490 2380//1586 2305//1508 +f 2259//1585 2319//1692 2334//1697 +f 2305//1508 2380//1586 2320//1695 +f 2259//1585 2334//1697 2349//1536 +f 2320//1695 2380//1586 2335//1529 +f 2259//1585 2349//1536 2364//1541 +f 2335//1529 2380//1586 2350//1549 +f 2259//1585 2364//1541 2379//1560 +f 2350//1549 2380//1586 2365//1567 +f 2259//1585 2379//1560 2395//1710 +f 2365//1567 2380//1586 2381//1572 +f 2259//1585 2395//1710 2410//1587 +f 2381//1572 2380//1586 2396//1588 +f 2259//1585 2410//1587 1943//1591 +f 2406//1570 2405//1582 1939//1592 +f 2401//1584 2400//1583 1933//1130 +f 2396//1588 2380//1586 1929//1589 +f 2407//1574 2406//1570 1940//1114 +f 2402//1571 2401//1584 1935//1107 +f 2397//1573 2396//1588 1929//1589 +f 2408//1577 2407//1574 1941//1113 +f 2403//1709 2402//1571 1936//1116 +f 2398//1576 2397//1573 1930//1110 +f 2409//1581 2408//1577 1942//1120 +f 2404//1578 2403//1709 1937//1122 +f 2399//1579 2398//1576 1931//1118 +f 2410//1587 2409//1581 1943//1591 +f 2405//1582 2404//1578 1938//1128 +f 2400//1583 2399//1579 1932//1124 +f 1468//1136 1453//1107 1467//1109 +f 1463//1119 1448//1110 1462//1112 +f 1458//1114 1473//1135 1474//1115 +f 1453//1107 1468//1136 1469//1117 +f 1464//1125 1449//1118 1463//1119 +f 1459//1113 1474//1115 1475//1121 +f 1454//1116 1469//1117 1470//1123 +f 1465//1131 1450//1124 1464//1125 +f 1460//1120 1475//1121 1476//1127 +f 1455//1122 1470//1123 1471//1129 +f 1466//1134 1451//1130 1465//1131 +f 1456//1128 1471//1129 1472//1133 +f 1467//1109 1452//1108 1466//1134 +f 1457//1132 1472//1133 1473//1135 +f 1483//1154 1468//1136 1482//1137 +f 1478//1141 1463//1119 1477//1138 +f 1473//1135 1488//1150 1489//1139 +f 1468//1136 1483//1154 1484//1140 +f 1479//1144 1464//1125 1478//1141 +f 1474//1115 1489//1139 1490//1142 +f 1469//1117 1484//1140 1485//1143 +f 1480//1147 1465//1131 1479//1144 +f 1475//1121 1490//1142 1491//1145 +f 1470//1123 1485//1143 1486//1146 +f 1481//1149 1466//1134 1480//1147 +f 1471//1129 1486//1146 1487//1148 +f 1482//1137 1467//1109 1481//1149 +f 1472//1133 1487//1148 1488//1150 +f 1486//1146 1501//1164 1502//1151 +f 1497//1155 1482//1137 1496//1152 +f 1487//1148 1502//1151 1503//1153 +f 1498//1172 1483//1154 1497//1155 +f 1493//1159 1478//1141 1492//1156 +f 1488//1150 1503//1153 1504//1157 +f 1483//1154 1498//1172 1499//1158 +f 1494//1162 1479//1144 1493//1159 +f 1489//1139 1504//1157 1505//1160 +f 1484//1140 1499//1158 1500//1161 +f 1495//1165 1480//1147 1494//1162 +f 1490//1142 1505//1160 1506//1163 +f 1485//1143 1500//1161 1501//1164 +f 1496//1152 1481//1149 1495//1165 +f 1505//1160 1520//1178 1521//1166 +f 1500//1161 1515//1179 1516//1167 +f 1511//1170 1496//1152 1510//1168 +f 1501//1164 1516//1167 1517//1169 +f 1512//1173 1497//1155 1511//1170 +f 1502//1151 1517//1169 1518//1171 +f 1513//1191 1498//1172 1512//1173 +f 1508//1177 1493//1159 1507//1174 +f 1503//1153 1518//1171 1519//1175 +f 1498//1172 1513//1191 1514//1176 +f 1509//1180 1494//1162 1508//1177 +f 1504//1157 1519//1175 1520//1178 +f 1499//1158 1514//1176 1515//1179 +f 1510//1168 1495//1165 1509//1180 +f 1524//1184 1509//1180 1523//1181 +f 1519//1175 1534//1194 1535//1182 +f 1514//1176 1529//1195 1530//1183 +f 1525//1187 1510//1168 1524//1184 +f 1520//1178 1535//1182 1536//1185 +f 1515//1179 1530//1183 1531//1186 +f 1526//1189 1511//1170 1525//1187 +f 1516//1167 1531//1186 1532//1188 +f 1527//1192 1512//1173 1526//1189 +f 1517//1169 1532//1188 1533//1190 +f 1528//1196 1513//1191 1527//1192 +f 1523//1181 1508//1177 1522//1193 +f 1518//1171 1533//1190 1534//1194 +f 1513//1191 1528//1196 1529//1195 +f 1543//1214 1528//1196 1542//1197 +f 1538//1201 1523//1181 1537//1198 +f 1533//1190 1548//1210 1549//1199 +f 1528//1196 1543//1214 1544//1200 +f 1539//1204 1524//1184 1538//1201 +f 1534//1194 1549//1199 1550//1202 +f 1529//1195 1544//1200 1545//1203 +f 1540//1207 1525//1187 1539//1204 +f 1535//1182 1550//1202 1551//1205 +f 1530//1183 1545//1203 1546//1206 +f 1541//1209 1526//1189 1540//1207 +f 1531//1186 1546//1206 1547//1208 +f 1542//1197 1527//1192 1541//1209 +f 1532//1188 1547//1208 1548//1210 +f 1546//1206 1561//1224 1562//1211 +f 1541//1209 1556//1228 1557//1212 +f 1547//1208 1562//1211 1563//1213 +f 1542//1197 1557//1212 1558//1215 +f 1553//1219 1538//1201 1552//1216 +f 1548//1210 1563//1213 1564//1217 +f 1543//1214 1558//1215 1559//1218 +f 1554//1222 1539//1204 1553//1219 +f 1549//1199 1564//1217 1565//1220 +f 1544//1200 1559//1218 1560//1221 +f 1555//1225 1540//1207 1554//1222 +f 1550//1202 1565//1220 1566//1223 +f 1545//1203 1560//1221 1561//1224 +f 1556//1228 1541//1209 1555//1225 +f 1581//1243 1566//1223 1580//1226 +f 1576//1230 1561//1224 1575//1227 +f 1555//1225 1570//1239 1571//1229 +f 1577//1232 1562//1211 1576//1230 +f 1556//1228 1571//1229 1572//1231 +f 1578//1235 1563//1213 1577//1232 +f 1557//1212 1572//1231 1573//1233 +f 1552//1216 1567//1251 1568//1234 +f 1579//1238 1564//1217 1578//1235 +f 1558//1215 1573//1233 1574//1236 +f 1553//1219 1568//1234 1569//1237 +f 1580//1226 1565//1220 1579//1238 +f 1559//1218 1574//1236 1575//1227 +f 1554//1222 1569//1237 1570//1239 +f 1595//1244 1580//1226 1594//1240 +f 1590//1245 1575//1227 1589//1241 +f 1569//1237 1584//1254 1585//1242 +f 1596//1262 1581//1243 1595//1244 +f 1591//1247 1576//1230 1590//1245 +f 1570//1239 1585//1242 1586//1246 +f 1592//1249 1577//1232 1591//1247 +f 1571//1229 1586//1246 1587//1248 +f 1593//1253 1578//1235 1592//1249 +f 1572//1231 1587//1248 1588//1250 +f 1567//1251 1582//1255 1583//1252 +f 1594//1240 1579//1238 1593//1253 +f 1573//1233 1588//1250 1589//1241 +f 1568//1234 1583//1252 1584//1254 +f 1582//1255 1597//1273 1598//1256 +f 1609//1260 1594//1240 1608//1257 +f 1588//1250 1603//1269 1604//1258 +f 1583//1252 1598//1256 1599//1259 +f 1610//1263 1595//1244 1609//1260 +f 1605//1264 1590//1245 1604//1258 +f 1584//1254 1599//1259 1600//1261 +f 1611//1280 1596//1262 1610//1263 +f 1606//1266 1591//1247 1605//1264 +f 1585//1242 1600//1261 1601//1265 +f 1607//1268 1592//1249 1606//1266 +f 1586//1246 1601//1265 1602//1267 +f 1608//1257 1593//1253 1607//1268 +f 1587//1248 1602//1267 1603//1269 +f 1601//1265 1616//1283 1617//1270 +f 1623//1275 1608//1257 1622//1271 +f 1602//1267 1617//1270 1618//1272 +f 1597//1273 1612//1291 1613//1274 +f 1624//1278 1609//1260 1623//1275 +f 1603//1269 1618//1272 1619//1276 +f 1598//1256 1613//1274 1614//1277 +f 1625//1281 1610//1263 1624//1278 +f 1620//1282 1605//1264 1619//1276 +f 1599//1259 1614//1277 1615//1279 +f 1626//1298 1611//1280 1625//1281 +f 1621//1284 1606//1266 1620//1282 +f 1600//1261 1615//1279 1616//1283 +f 1622//1271 1607//1268 1621//1284 +f 1636//1287 1621//1284 1635//1285 +f 1615//1279 1630//1297 1631//1286 +f 1637//1289 1622//1271 1636//1287 +f 1616//1283 1631//1286 1632//1288 +f 1638//1293 1623//1275 1637//1289 +f 1617//1270 1632//1288 1633//1290 +f 1612//1291 1627//1311 1628//1292 +f 1639//1296 1624//1278 1638//1293 +f 1618//1272 1633//1290 1634//1294 +f 1613//1274 1628//1292 1629//1295 +f 1640//1299 1625//1281 1639//1296 +f 1635//1285 1620//1282 1634//1294 +f 1614//1277 1629//1295 1630//1297 +f 1641//1303 1626//1298 1640//1299 +f 1655//1304 1640//1299 1654//1300 +f 1650//1305 1635//1285 1649//1301 +f 1629//1295 1644//1314 1645//1302 +f 1656//1323 1641//1303 1655//1304 +f 1651//1307 1636//1287 1650//1305 +f 1630//1297 1645//1302 1646//1306 +f 1652//1309 1637//1289 1651//1307 +f 1631//1286 1646//1306 1647//1308 +f 1653//1313 1638//1293 1652//1309 +f 1632//1288 1647//1308 1648//1310 +f 1627//1311 1642//1315 1643//1312 +f 1654//1300 1639//1296 1653//1313 +f 1633//1290 1648//1310 1649//1301 +f 1628//1292 1643//1312 1644//1314 +f 1642//1315 1657//1333 1658//1316 +f 1669//1320 1654//1300 1668//1317 +f 1664//1321 1649//1301 1663//1318 +f 1643//1312 1658//1316 1659//1319 +f 1670//1324 1655//1304 1669//1320 +f 1665//1325 1650//1305 1664//1321 +f 1644//1314 1659//1319 1660//1322 +f 1671//1341 1656//1323 1670//1324 +f 1666//1327 1651//1307 1665//1325 +f 1645//1302 1660//1322 1661//1326 +f 1667//1329 1652//1309 1666//1327 +f 1646//1306 1661//1326 1662//1328 +f 1668//1317 1653//1313 1667//1329 +f 1647//1308 1662//1328 1663//1318 +f 1677//1332 1662//1328 1676//1330 +f 1683//1335 1668//1317 1682//1331 +f 1678//1336 1663//1318 1677//1332 +f 1657//1333 1672//1351 1673//1334 +f 1684//1338 1669//1320 1683//1335 +f 1679//1339 1664//1321 1678//1336 +f 1658//1316 1673//1334 1674//1337 +f 1685//1342 1670//1324 1684//1338 +f 1680//1343 1665//1325 1679//1339 +f 1659//1319 1674//1337 1675//1340 +f 1686//1359 1671//1341 1685//1342 +f 1681//1344 1666//1327 1680//1343 +f 1660//1322 1675//1340 1676//1330 +f 1682//1331 1667//1329 1681//1344 +f 1696//1365 1681//1344 1695//1345 +f 1691//1348 1676//1330 1690//1346 +f 1681//1344 1696//1365 1697//1347 +f 1692//1350 1677//1332 1691//1348 +f 1682//1331 1697//1347 1698//1349 +f 1693//1354 1678//1336 1692//1350 +f 1688//1355 1673//1334 1687//1352 +f 1683//1335 1698//1349 1699//1353 +f 1694//1357 1679//1339 1693//1354 +f 1689//1358 1674//1337 1688//1355 +f 1684//1338 1699//1353 1700//1356 +f 1695//1345 1680//1343 1694//1357 +f 1690//1346 1675//1340 1689//1358 +f 1685//1342 1700//1356 1701//1360 +f 1699//1353 1714//1373 1715//1361 +f 1710//1380 1695//1345 1709//1362 +f 1705//1367 1690//1346 1704//1363 +f 1700//1356 1715//1361 1716//1364 +f 1695//1345 1710//1380 1711//1366 +f 1706//1369 1691//1348 1705//1367 +f 1696//1365 1711//1366 1712//1368 +f 1707//1371 1692//1350 1706//1369 +f 1697//1347 1712//1368 1713//1370 +f 1708//1374 1693//1354 1707//1371 +f 1703//1375 1688//1355 1702//1372 +f 1698//1349 1713//1370 1714//1373 +f 1709//1362 1694//1357 1708//1374 +f 1704//1363 1689//1358 1703//1375 +f 1713//1370 1728//1388 1729//1376 +f 1724//1381 1709//1362 1723//1377 +f 1719//1382 1704//1363 1718//1378 +f 1714//1373 1729//1376 1730//1379 +f 1725//1398 1710//1380 1724//1381 +f 1720//1385 1705//1367 1719//1382 +f 1715//1361 1730//1379 1731//1383 +f 1710//1380 1725//1398 1726//1384 +f 1721//1387 1706//1369 1720//1385 +f 1711//1366 1726//1384 1727//1386 +f 1722//1389 1707//1371 1721//1387 +f 1712//1368 1727//1386 1728//1388 +f 1723//1377 1708//1374 1722//1389 +f 1718//1378 1703//1375 1717//1390 +f 1727//1386 1742//1404 1743//1391 +f 1738//1395 1723//1377 1737//1392 +f 1733//1396 1718//1378 1732//1393 +f 1728//1388 1743//1391 1744//1394 +f 1739//1399 1724//1381 1738//1395 +f 1734//1400 1719//1382 1733//1396 +f 1729//1376 1744//1394 1745//1397 +f 1740//1416 1725//1398 1739//1399 +f 1735//1403 1720//1385 1734//1400 +f 1730//1379 1745//1397 1746//1401 +f 1725//1398 1740//1416 1741//1402 +f 1736//1405 1721//1387 1735//1403 +f 1726//1384 1741//1402 1742//1404 +f 1737//1392 1722//1389 1736//1405 +f 1751//1408 1736//1405 1750//1406 +f 1741//1402 1756//1420 1757//1407 +f 1752//1410 1737//1392 1751//1408 +f 1742//1404 1757//1407 1758//1409 +f 1753//1413 1738//1395 1752//1410 +f 1748//1414 1733//1396 1747//1411 +f 1743//1391 1758//1409 1759//1412 +f 1754//1417 1739//1399 1753//1413 +f 1749//1418 1734//1400 1748//1414 +f 1744//1394 1759//1412 1760//1415 +f 1755//1421 1740//1416 1754//1417 +f 1750//1406 1735//1403 1749//1418 +f 1745//1397 1760//1415 1761//1419 +f 1740//1416 1755//1421 1756//1420 +f 1770//1440 1755//1421 1769//1422 +f 1765//1426 1750//1406 1764//1423 +f 1760//1415 1775//1435 1776//1424 +f 1755//1421 1770//1440 1771//1425 +f 1766//1428 1751//1408 1765//1426 +f 1756//1420 1771//1425 1772//1427 +f 1767//1430 1752//1410 1766//1428 +f 1757//1407 1772//1427 1773//1429 +f 1768//1433 1753//1413 1767//1430 +f 1763//1434 1748//1414 1762//1431 +f 1758//1409 1773//1429 1774//1432 +f 1769//1422 1754//1417 1768//1433 +f 1764//1423 1749//1418 1763//1434 +f 1759//1412 1774//1432 1775//1435 +f 1773//1429 1789//1448 1790//1436 +f 1785//1441 1769//1422 1784//1437 +f 1780//1442 1764//1423 1779//1438 +f 1774//1432 1790//1436 1791//1439 +f 1786//1458 1770//1440 1785//1441 +f 1781//1445 1765//1426 1780//1442 +f 1775//1435 1791//1439 1792//1443 +f 1770//1440 1786//1458 1787//1444 +f 1782//1447 1766//1428 1781//1445 +f 1771//1425 1787//1444 1788//1446 +f 1783//1449 1767//1430 1782//1447 +f 1772//1427 1788//1446 1789//1448 +f 1784//1437 1768//1433 1783//1449 +f 1779//1438 1763//1434 1778//1450 +f 1788//1446 1803//1467 1804//1451 +f 1799//1455 1784//1437 1798//1452 +f 1794//1456 1779//1438 1793//1453 +f 1789//1448 1804//1451 1805//1454 +f 1800//1459 1785//1441 1799//1455 +f 1795//1460 1780//1442 1794//1456 +f 1790//1436 1805//1454 1806//1457 +f 1801//1462 1786//1458 1800//1459 +f 1796//1463 1781//1445 1795//1460 +f 1791//1439 1806//1457 1807//1461 +f 1802//1464 1787//1444 1801//1462 +f 1797//1465 1782//1447 1796//1463 +f 1803//1467 1788//1446 1802//1464 +f 1798//1452 1783//1449 1797//1465 +f 1796//1463 1811//1477 1812//1466 +f 1818//1470 1803//1467 1817//1468 +f 1797//1465 1812//1466 1813//1469 +f 1819//1473 1804//1451 1818//1470 +f 1798//1452 1813//1469 1814//1471 +f 1793//1453 1808//1490 1809//1472 +f 1820//1475 1805//1454 1819//1473 +f 1815//1476 1800//1459 1814//1471 +f 1794//1456 1809//1472 1810//1474 +f 1821//1478 1806//1457 1820//1475 +f 1816//1479 1801//1462 1815//1476 +f 1795//1460 1810//1474 1811//1477 +f 1822//1482 1807//1461 1821//1478 +f 1817//1468 1802//1464 1816//1479 +f 1831//1484 1816//1479 1830//1480 +f 1810//1474 1825//1493 1826//1481 +f 1837//1500 1822//1482 1836//1483 +f 1832//1486 1817//1468 1831//1484 +f 1811//1477 1826//1481 1827//1485 +f 1833//1488 1818//1470 1832//1486 +f 1812//1466 1827//1485 1828//1487 +f 1834//1492 1819//1473 1833//1488 +f 1813//1469 1828//1487 1829//1489 +f 1808//1490 1823//1508 1824//1491 +f 1835//1494 1820//1475 1834//1492 +f 1814//1471 1829//1489 1830//1480 +f 1809//1472 1824//1491 1825//1493 +f 1836//1483 1821//1478 1835//1494 +f 1850//1498 1835//1494 1849//1495 +f 1829//1489 1844//1507 1845//1496 +f 1824//1491 1839//1509 1840//1497 +f 1851//1501 1836//1483 1850//1498 +f 1846//1502 1831//1484 1845//1496 +f 1825//1493 1840//1497 1841//1499 +f 1852//1519 1837//1500 1851//1501 +f 1847//1504 1832//1486 1846//1502 +f 1826//1481 1841//1499 1842//1503 +f 1848//1506 1833//1488 1847//1504 +f 1827//1485 1842//1503 1843//1505 +f 1849//1495 1834//1492 1848//1506 +f 1828//1487 1843//1505 1844//1507 +f 1823//1508 1838//1512 1839//1509 +f 1864//1514 1849//1495 1863//1510 +f 1843//1505 1858//1524 1859//1511 +f 1838//1512 1853//1529 1854//1513 +f 1865//1517 1850//1498 1864//1514 +f 1844//1507 1859//1511 1860//1515 +f 1839//1509 1854//1513 1855//1516 +f 1866//1520 1851//1501 1865//1517 +f 1861//1521 1846//1502 1860//1515 +f 1840//1497 1855//1516 1856//1518 +f 1867//1536 1852//1519 1866//1520 +f 1862//1523 1847//1504 1861//1521 +f 1841//1499 1856//1518 1857//1522 +f 1863//1510 1848//1506 1862//1523 +f 1842//1503 1857//1522 1858//1524 +f 1878//1527 1863//1510 1877//1525 +f 1857//1522 1872//1539 1873//1526 +f 1879//1531 1864//1514 1878//1527 +f 1858//1524 1873//1526 1874//1528 +f 1853//1529 1868//1549 1869//1530 +f 1880//1534 1865//1517 1879//1531 +f 1859//1511 1874//1528 1875//1532 +f 1854//1513 1869//1530 1870//1533 +f 1881//1537 1866//1520 1880//1534 +f 1876//1538 1861//1521 1875//1532 +f 1855//1516 1870//1533 1871//1535 +f 1882//1541 1867//1536 1881//1537 +f 1877//1525 1862//1523 1876//1538 +f 1856//1518 1871//1535 1872//1539 +f 1870//1533 1885//1553 1886//1540 +f 1897//1560 1882//1541 1896//1542 +f 1892//1545 1877//1525 1891//1543 +f 1871//1535 1886//1540 1887//1544 +f 1893//1547 1878//1527 1892//1545 +f 1872//1539 1887//1544 1888//1546 +f 1894//1551 1879//1531 1893//1547 +f 1873//1526 1888//1546 1889//1548 +f 1868//1549 1883//1567 1884//1550 +f 1895//1554 1880//1534 1894//1551 +f 1874//1528 1889//1548 1890//1552 +f 1869//1530 1884//1550 1885//1553 +f 1896//1542 1881//1537 1895//1554 +f 1891//1543 1876//1538 1890//1552 +f 1889//1548 1905//1566 1906//1555 +f 1884//1550 1900//1568 1901//1556 +f 1912//1561 1896//1542 1911//1557 +f 1890//1552 1906//1555 1907//1558 +f 1885//1553 1901//1556 1902//1559 +f 1913//1580 1897//1560 1912//1561 +f 1908//1563 1892//1545 1907//1558 +f 1886//1540 1902//1559 1903//1562 +f 1909//1565 1893//1547 1908//1563 +f 1887//1544 1903//1562 1904//1564 +f 1910//1569 1894//1551 1909//1565 +f 1888//1546 1904//1564 1905//1566 +f 1883//1567 1899//1572 1900//1568 +f 1911//1557 1895//1554 1910//1569 +f 1925//1574 1910//1569 1924//1570 +f 1904//1564 1919//1584 1920//1571 +f 1899//1572 1914//1588 1915//1573 +f 1926//1577 1911//1557 1925//1574 +f 1905//1566 1920//1571 1921//1575 +f 1900//1568 1915//1573 1916//1576 +f 1927//1581 1912//1561 1926//1577 +f 1906//1555 1921//1575 1922//1578 +f 1901//1556 1916//1576 1917//1579 +f 1928//1587 1913//1580 1927//1581 +f 1907//1558 1922//1578 1923//1582 +f 1902//1559 1917//1579 1918//1583 +f 1908//1563 1923//1582 1924//1570 +f 1903//1562 1918//1583 1919//1584 +f 1923//1582 1456//1128 1457//1132 +f 1452//1108 1919//1584 1451//1130 +f 1924//1570 1457//1132 1458//1114 +f 1919//1584 1452//1108 1453//1107 +f 1448//1110 1915//1573 1447//1111 +f 1925//1574 1458//1114 1459//1113 +f 1920//1571 1453//1107 1454//1116 +f 1449//1118 1916//1576 1448//1110 +f 1926//1577 1459//1113 1460//1120 +f 1921//1575 1454//1116 1455//1122 +f 1450//1124 1917//1579 1449//1118 +f 1927//1581 1460//1120 1461//1126 +f 1922//1578 1455//1122 1456//1128 +f 1451//1130 1918//1583 1450//1124 +f 1950//1136 1935//1107 1949//1109 +f 1945//1119 1930//1110 1944//1112 +f 1940//1114 1955//1135 1956//1590 +f 1935//1107 1950//1136 1951//1117 +f 1946//1125 1931//1118 1945//1119 +f 1941//1113 1956//1590 1957//1121 +f 1936//1116 1951//1117 1952//1123 +f 1947//1131 1932//1124 1946//1125 +f 1942//1120 1957//1121 1958//1127 +f 1937//1122 1952//1123 1953//1129 +f 1948//1134 1933//1130 1947//1131 +f 1938//1128 1953//1129 1954//1133 +f 1949//1109 1934//1108 1948//1134 +f 1939//1592 1954//1133 1955//1135 +f 1965//1154 1950//1136 1964//1137 +f 1960//1141 1945//1119 1959//1138 +f 1955//1135 1970//1594 1971//1139 +f 1950//1136 1965//1154 1966//1140 +f 1961//1144 1946//1125 1960//1141 +f 1956//1590 1971//1139 1972//1142 +f 1951//1117 1966//1140 1967//1143 +f 1962//1147 1947//1131 1961//1144 +f 1957//1121 1972//1142 1973//1145 +f 1952//1123 1967//1143 1968//1593 +f 1963//1149 1948//1134 1962//1147 +f 1953//1129 1968//1593 1969//1148 +f 1964//1137 1949//1109 1963//1149 +f 1954//1133 1969//1148 1970//1594 +f 1968//1593 1983//1164 1984//1151 +f 1979//1155 1964//1137 1978//1152 +f 1969//1148 1984//1151 1985//1595 +f 1980//1172 1965//1154 1979//1155 +f 1975//1159 1960//1141 1974//1596 +f 1970//1594 1985//1595 1986//1157 +f 1965//1154 1980//1172 1981//1158 +f 1976//1162 1961//1144 1975//1159 +f 1971//1139 1986//1157 1987//1160 +f 1966//1140 1981//1158 1982//1597 +f 1977//1165 1962//1147 1976//1162 +f 1972//1142 1987//1160 1988//1598 +f 1967//1143 1982//1597 1983//1164 +f 1978//1152 1963//1149 1977//1165 +f 1987//1160 2002//1178 2003//1166 +f 1982//1597 1997//1179 1998//1599 +f 1993//1601 1978//1152 1992//1168 +f 1983//1164 1998//1599 1999//1600 +f 1994//1173 1979//1155 1993//1601 +f 1984//1151 1999//1600 2000//1171 +f 1995//1191 1980//1172 1994//1173 +f 1990//1177 1975//1159 1989//1174 +f 1985//1595 2000//1171 2001//1175 +f 1980//1172 1995//1191 1996//1176 +f 1991//1602 1976//1162 1990//1177 +f 1986//1157 2001//1175 2002//1178 +f 1981//1158 1996//1176 1997//1179 +f 1992//1168 1977//1165 1991//1602 +f 2006//1603 1991//1602 2005//1181 +f 2001//1175 2016//1194 2017//1182 +f 1996//1176 2011//1606 2012//1183 +f 2007//1604 1992//1168 2006//1603 +f 2002//1178 2017//1182 2018//1185 +f 1997//1179 2012//1183 2013//1186 +f 2008//1189 1993//1601 2007//1604 +f 1998//1599 2013//1186 2014//1188 +f 2009//1192 1994//1173 2008//1189 +f 1999//1600 2014//1188 2015//1190 +f 2010//1196 1995//1191 2009//1192 +f 2005//1181 1990//1177 2004//1605 +f 2000//1171 2015//1190 2016//1194 +f 1995//1191 2010//1196 2011//1606 +f 2025//1610 2010//1196 2024//1197 +f 2020//1201 2005//1181 2019//1198 +f 2015//1190 2030//1210 2031//1199 +f 2010//1196 2025//1610 2026//1607 +f 2021//1204 2006//1603 2020//1201 +f 2016//1194 2031//1199 2032//1202 +f 2011//1606 2026//1607 2027//1203 +f 2022//1609 2007//1604 2021//1204 +f 2017//1182 2032//1202 2033//1608 +f 2012//1183 2027//1203 2028//1206 +f 2023//1209 2008//1189 2022//1609 +f 2013//1186 2028//1206 2029//1208 +f 2024//1197 2009//1192 2023//1209 +f 2014//1188 2029//1208 2030//1210 +f 2028//1206 2043//1224 2044//1211 +f 2023//1209 2038//1228 2039//1212 +f 2029//1208 2044//1211 2045//1213 +f 2024//1197 2039//1212 2040//1215 +f 2035//1219 2020//1201 2034//1216 +f 2030//1210 2045//1213 2046//1217 +f 2025//1610 2040//1215 2041//1611 +f 2036//1222 2021//1204 2035//1219 +f 2031//1199 2046//1217 2047//1220 +f 2026//1607 2041//1611 2042//1221 +f 2037//1225 2022//1609 2036//1222 +f 2032//1202 2047//1220 2048//1612 +f 2027//1203 2042//1221 2043//1224 +f 2038//1228 2023//1209 2037//1225 +f 2063//1243 2048//1612 2062//1226 +f 2058//1230 2043//1224 2057//1613 +f 2037//1225 2052//1239 2053//1229 +f 2059//1232 2044//1211 2058//1230 +f 2038//1228 2053//1229 2054//1614 +f 2060//1235 2045//1213 2059//1232 +f 2039//1212 2054//1614 2055//1615 +f 2034//1216 2049//1251 2050//1616 +f 2061//1238 2046//1217 2060//1235 +f 2040//1215 2055//1615 2056//1236 +f 2035//1219 2050//1616 2051//1237 +f 2062//1226 2047//1220 2061//1238 +f 2041//1611 2056//1236 2057//1613 +f 2036//1222 2051//1237 2052//1239 +f 2077//1244 2062//1226 2076//1617 +f 2072//1245 2057//1613 2071//1241 +f 2051//1237 2066//1620 2067//1618 +f 2078//1262 2063//1243 2077//1244 +f 2073//1247 2058//1230 2072//1245 +f 2052//1239 2067//1618 2068//1619 +f 2074//1249 2059//1232 2073//1247 +f 2053//1229 2068//1619 2069//1248 +f 2075//1253 2060//1235 2074//1249 +f 2054//1614 2069//1248 2070//1250 +f 2049//1251 2064//1621 2065//1252 +f 2076//1617 2061//1238 2075//1253 +f 2055//1615 2070//1250 2071//1241 +f 2050//1616 2065//1252 2066//1620 +f 2064//1621 2079//1628 2080//1622 +f 2091//1260 2076//1617 2090//1257 +f 2070//1250 2085//1269 2086//1258 +f 2065//1252 2080//1622 2081//1623 +f 2092//1263 2077//1244 2091//1260 +f 2087//1624 2072//1245 2086//1258 +f 2066//1620 2081//1623 2082//1261 +f 2093//1280 2078//1262 2092//1263 +f 2088//1625 2073//1247 2087//1624 +f 2067//1618 2082//1261 2083//1265 +f 2089//1268 2074//1249 2088//1625 +f 2068//1619 2083//1265 2084//1626 +f 2090//1257 2075//1253 2089//1268 +f 2069//1248 2084//1626 2085//1269 +f 2083//1265 2098//1283 2099//1270 +f 2105//1275 2090//1257 2104//1271 +f 2084//1626 2099//1270 2100//1627 +f 2079//1628 2094//1291 2095//1274 +f 2106//1278 2091//1260 2105//1275 +f 2085//1269 2100//1627 2101//1276 +f 2080//1622 2095//1274 2096//1277 +f 2107//1281 2092//1263 2106//1278 +f 2102//1282 2087//1624 2101//1276 +f 2081//1623 2096//1277 2097//1629 +f 2108//1298 2093//1280 2107//1281 +f 2103//1630 2088//1625 2102//1282 +f 2082//1261 2097//1629 2098//1283 +f 2104//1271 2089//1268 2103//1630 +f 2118//1287 2103//1630 2117//1285 +f 2097//1629 2112//1634 2113//1286 +f 2119//1631 2104//1271 2118//1287 +f 2098//1283 2113//1286 2114//1288 +f 2120//1632 2105//1275 2119//1631 +f 2099//1270 2114//1288 2115//1290 +f 2094//1291 2109//1636 2110//1292 +f 2121//1296 2106//1278 2120//1632 +f 2100//1627 2115//1290 2116//1294 +f 2095//1274 2110//1292 2111//1633 +f 2122//1299 2107//1281 2121//1296 +f 2117//1285 2102//1282 2116//1294 +f 2096//1277 2111//1633 2112//1634 +f 2123//1635 2108//1298 2122//1299 +f 2137//1304 2122//1299 2136//1300 +f 2132//1305 2117//1285 2131//1301 +f 2111//1633 2126//1639 2127//1302 +f 2138//1323 2123//1635 2137//1304 +f 2133//1307 2118//1287 2132//1305 +f 2112//1634 2127//1302 2128//1306 +f 2134//1309 2119//1631 2133//1307 +f 2113//1286 2128//1306 2129//1308 +f 2135//1638 2120//1632 2134//1309 +f 2114//1288 2129//1308 2130//1310 +f 2109//1636 2124//1315 2125//1637 +f 2136//1300 2121//1296 2135//1638 +f 2115//1290 2130//1310 2131//1301 +f 2110//1292 2125//1637 2126//1639 +f 2124//1315 2139//1333 2140//1316 +f 2151//1320 2136//1300 2150//1317 +f 2146//1321 2131//1301 2145//1640 +f 2125//1637 2140//1316 2141//1319 +f 2152//1641 2137//1304 2151//1320 +f 2147//1642 2132//1305 2146//1321 +f 2126//1639 2141//1319 2142//1322 +f 2153//1646 2138//1323 2152//1641 +f 2148//1643 2133//1307 2147//1642 +f 2127//1302 2142//1322 2143//1326 +f 2149//1329 2134//1309 2148//1643 +f 2128//1306 2143//1326 2144//1328 +f 2150//1317 2135//1638 2149//1329 +f 2129//1308 2144//1328 2145//1640 +f 2159//1332 2144//1328 2158//1330 +f 2165//1644 2150//1317 2164//1331 +f 2160//1645 2145//1640 2159//1332 +f 2139//1333 2154//1649 2155//1334 +f 2166//1338 2151//1320 2165//1644 +f 2161//1339 2146//1321 2160//1645 +f 2140//1316 2155//1334 2156//1337 +f 2167//1342 2152//1641 2166//1338 +f 2162//1647 2147//1642 2161//1339 +f 2141//1319 2156//1337 2157//1340 +f 2168//1359 2153//1646 2167//1342 +f 2163//1344 2148//1643 2162//1647 +f 2142//1322 2157//1340 2158//1330 +f 2164//1331 2149//1329 2163//1344 +f 2178//1365 2163//1344 2177//1345 +f 2173//1348 2158//1330 2172//1346 +f 2163//1344 2178//1365 2179//1648 +f 2174//1350 2159//1332 2173//1348 +f 2164//1331 2179//1648 2180//1349 +f 2175//1354 2160//1645 2174//1350 +f 2170//1651 2155//1334 2169//1352 +f 2165//1644 2180//1349 2181//1650 +f 2176//1357 2161//1339 2175//1354 +f 2171//1358 2156//1337 2170//1651 +f 2166//1338 2181//1650 2182//1356 +f 2177//1345 2162//1647 2176//1357 +f 2172//1346 2157//1340 2171//1358 +f 2167//1342 2182//1356 2183//1360 +f 2181//1650 2196//1373 2197//1652 +f 2192//1380 2177//1345 2191//1653 +f 2187//1367 2172//1346 2186//1654 +f 2182//1356 2197//1652 2198//1364 +f 2177//1345 2192//1380 2193//1366 +f 2188//1655 2173//1348 2187//1367 +f 2178//1365 2193//1366 2194//1368 +f 2189//1371 2174//1350 2188//1655 +f 2179//1648 2194//1368 2195//1370 +f 2190//1374 2175//1354 2189//1371 +f 2185//1375 2170//1651 2184//1656 +f 2180//1349 2195//1370 2196//1373 +f 2191//1653 2176//1357 2190//1374 +f 2186//1654 2171//1358 2185//1375 +f 2195//1370 2210//1388 2211//1376 +f 2206//1381 2191//1653 2205//1377 +f 2201//1382 2186//1654 2200//1378 +f 2196//1373 2211//1376 2212//1379 +f 2207//1398 2192//1380 2206//1381 +f 2202//1385 2187//1367 2201//1382 +f 2197//1652 2212//1379 2213//1383 +f 2192//1380 2207//1398 2208//1384 +f 2203//1387 2188//1655 2202//1385 +f 2193//1366 2208//1384 2209//1386 +f 2204//1389 2189//1371 2203//1387 +f 2194//1368 2209//1386 2210//1388 +f 2205//1377 2190//1374 2204//1389 +f 2200//1378 2185//1375 2199//1390 +f 2209//1386 2224//1404 2225//1391 +f 2220//1658 2205//1377 2219//1392 +f 2215//1396 2200//1378 2214//1393 +f 2210//1388 2225//1391 2226//1657 +f 2221//1659 2206//1381 2220//1658 +f 2216//1400 2201//1382 2215//1396 +f 2211//1376 2226//1657 2227//1397 +f 2222//1668 2207//1398 2221//1659 +f 2217//1661 2202//1385 2216//1400 +f 2212//1379 2227//1397 2228//1401 +f 2207//1398 2222//1668 2223//1660 +f 2218//1405 2203//1387 2217//1661 +f 2208//1384 2223//1660 2224//1404 +f 2219//1392 2204//1389 2218//1405 +f 2233//1664 2218//1405 2232//1662 +f 2223//1660 2238//1420 2239//1663 +f 2234//1665 2219//1392 2233//1664 +f 2224//1404 2239//1663 2240//1409 +f 2235//1413 2220//1658 2234//1665 +f 2230//1414 2215//1396 2229//1411 +f 2225//1391 2240//1409 2241//1666 +f 2236//1417 2221//1659 2235//1413 +f 2231//1669 2216//1400 2230//1414 +f 2226//1657 2241//1666 2242//1667 +f 2237//1421 2222//1668 2236//1417 +f 2232//1662 2217//1661 2231//1669 +f 2227//1397 2242//1667 2243//1419 +f 2222//1668 2237//1421 2238//1420 +f 2252//1440 2237//1421 2251//1670 +f 2247//1671 2232//1662 2246//1423 +f 2242//1667 2257//1435 2258//1424 +f 2237//1421 2252//1440 2253//1425 +f 2248//1428 2233//1664 2247//1671 +f 2238//1420 2253//1425 2254//1427 +f 2249//1430 2234//1665 2248//1428 +f 2239//1663 2254//1427 2255//1429 +f 2250//1433 2235//1413 2249//1430 +f 2245//1434 2230//1414 2244//1431 +f 2240//1409 2255//1429 2256//1672 +f 2251//1670 2236//1417 2250//1433 +f 2246//1423 2231//1669 2245//1434 +f 2241//1666 2256//1672 2257//1435 +f 2255//1429 2271//1675 2272//1436 +f 2267//1674 2251//1670 2266//1437 +f 2262//1442 2246//1423 2261//1438 +f 2256//1672 2272//1436 2273//1673 +f 2268//1678 2252//1440 2267//1674 +f 2263//1445 2247//1671 2262//1442 +f 2257//1435 2273//1673 2274//1443 +f 2252//1440 2268//1678 2269//1444 +f 2264//1447 2248//1428 2263//1445 +f 2253//1425 2269//1444 2270//1446 +f 2265//1449 2249//1430 2264//1447 +f 2254//1427 2270//1446 2271//1675 +f 2266//1437 2250//1433 2265//1449 +f 2261//1438 2245//1434 2260//1450 +f 2270//1446 2285//1684 2286//1451 +f 2281//1455 2266//1437 2280//1452 +f 2276//1456 2261//1438 2275//1676 +f 2271//1675 2286//1451 2287//1677 +f 2282//1679 2267//1674 2281//1455 +f 2277//1680 2262//1442 2276//1456 +f 2272//1436 2287//1677 2288//1457 +f 2283//1682 2268//1678 2282//1679 +f 2278//1463 2263//1445 2277//1680 +f 2273//1673 2288//1457 2289//1681 +f 2284//1464 2269//1444 2283//1682 +f 2279//1683 2264//1447 2278//1463 +f 2285//1684 2270//1446 2284//1464 +f 2280//1452 2265//1449 2279//1683 +f 2278//1463 2293//1477 2294//1466 +f 2300//1470 2285//1684 2299//1685 +f 2279//1683 2294//1466 2295//1469 +f 2301//1473 2286//1451 2300//1470 +f 2280//1452 2295//1469 2296//1471 +f 2275//1676 2290//1490 2291//1472 +f 2302//1475 2287//1677 2301//1473 +f 2297//1476 2282//1679 2296//1471 +f 2276//1456 2291//1472 2292//1686 +f 2303//1687 2288//1457 2302//1475 +f 2298//1688 2283//1682 2297//1476 +f 2277//1680 2292//1686 2293//1477 +f 2304//1482 2289//1681 2303//1687 +f 2299//1685 2284//1464 2298//1688 +f 2313//1484 2298//1688 2312//1480 +f 2292//1686 2307//1493 2308//1481 +f 2319//1692 2304//1482 2318//1483 +f 2314//1486 2299//1685 2313//1484 +f 2293//1477 2308//1481 2309//1485 +f 2315//1689 2300//1470 2314//1486 +f 2294//1466 2309//1485 2310//1487 +f 2316//1690 2301//1473 2315//1689 +f 2295//1469 2310//1487 2311//1489 +f 2290//1490 2305//1508 2306//1491 +f 2317//1691 2302//1475 2316//1690 +f 2296//1471 2311//1489 2312//1480 +f 2291//1472 2306//1491 2307//1493 +f 2318//1483 2303//1687 2317//1691 +f 2332//1498 2317//1691 2331//1495 +f 2311//1489 2326//1507 2327//1496 +f 2306//1491 2321//1694 2322//1497 +f 2333//1693 2318//1483 2332//1498 +f 2328//1502 2313//1484 2327//1496 +f 2307//1493 2322//1497 2323//1499 +f 2334//1697 2319//1692 2333//1693 +f 2329//1504 2314//1486 2328//1502 +f 2308//1481 2323//1499 2324//1503 +f 2330//1506 2315//1689 2329//1504 +f 2309//1485 2324//1503 2325//1505 +f 2331//1495 2316//1690 2330//1506 +f 2310//1487 2325//1505 2326//1507 +f 2305//1508 2320//1695 2321//1694 +f 2346//1514 2331//1495 2345//1510 +f 2325//1505 2340//1524 2341//1511 +f 2320//1695 2335//1529 2336//1513 +f 2347//1517 2332//1498 2346//1514 +f 2326//1507 2341//1511 2342//1515 +f 2321//1694 2336//1513 2337//1696 +f 2348//1520 2333//1693 2347//1517 +f 2343//1521 2328//1502 2342//1515 +f 2322//1497 2337//1696 2338//1518 +f 2349//1536 2334//1697 2348//1520 +f 2344//1523 2329//1504 2343//1521 +f 2323//1499 2338//1518 2339//1522 +f 2345//1510 2330//1506 2344//1523 +f 2324//1503 2339//1522 2340//1524 +f 2360//1527 2345//1510 2359//1525 +f 2339//1522 2354//1702 2355//1526 +f 2361//1531 2346//1514 2360//1527 +f 2340//1524 2355//1526 2356//1528 +f 2335//1529 2350//1549 2351//1698 +f 2362//1534 2347//1517 2361//1531 +f 2341//1511 2356//1528 2357//1532 +f 2336//1513 2351//1698 2352//1533 +f 2363//1700 2348//1520 2362//1534 +f 2358//1701 2343//1521 2357//1532 +f 2337//1696 2352//1533 2353//1699 +f 2364//1541 2349//1536 2363//1700 +f 2359//1525 2344//1523 2358//1701 +f 2338//1518 2353//1699 2354//1702 +f 2352//1533 2367//1704 2368//1540 +f 2379//1560 2364//1541 2378//1703 +f 2374//1545 2359//1525 2373//1543 +f 2353//1699 2368//1540 2369//1544 +f 2375//1547 2360//1527 2374//1545 +f 2354//1702 2369//1544 2370//1546 +f 2376//1551 2361//1531 2375//1547 +f 2355//1526 2370//1546 2371//1548 +f 2350//1549 2365//1567 2366//1550 +f 2377//1705 2362//1534 2376//1551 +f 2356//1528 2371//1548 2372//1552 +f 2351//1698 2366//1550 2367//1704 +f 2378//1703 2363//1700 2377//1705 +f 2373//1543 2358//1701 2372//1552 +f 2371//1548 2387//1566 2388//1706 +f 2366//1550 2382//1707 2383//1556 +f 2394//1561 2378//1703 2393//1557 +f 2372//1552 2388//1706 2389//1558 +f 2367//1704 2383//1556 2384//1559 +f 2395//1710 2379//1560 2394//1561 +f 2390//1563 2374//1545 2389//1558 +f 2368//1540 2384//1559 2385//1562 +f 2391//1565 2375//1547 2390//1563 +f 2369//1544 2385//1562 2386//1564 +f 2392//1708 2376//1551 2391//1565 +f 2370//1546 2386//1564 2387//1566 +f 2365//1567 2381//1572 2382//1707 +f 2393//1557 2377//1705 2392//1708 +f 2407//1574 2392//1708 2406//1570 +f 2386//1564 2401//1584 2402//1571 +f 2381//1572 2396//1588 2397//1573 +f 2408//1577 2393//1557 2407//1574 +f 2387//1566 2402//1571 2403//1709 +f 2382//1707 2397//1573 2398//1576 +f 2409//1581 2394//1561 2408//1577 +f 2388//1706 2403//1709 2404//1578 +f 2383//1556 2398//1576 2399//1579 +f 2410//1587 2395//1710 2409//1581 +f 2389//1558 2404//1578 2405//1582 +f 2384//1559 2399//1579 2400//1583 +f 2390//1563 2405//1582 2406//1570 +f 2385//1562 2400//1583 2401//1584 +f 2405//1582 1938//1128 1939//1592 +f 1934//1108 2401//1584 1933//1130 +f 2406//1570 1939//1592 1940//1114 +f 2401//1584 1934//1108 1935//1107 +f 1930//1110 2397//1573 1929//1589 +f 2407//1574 1940//1114 1941//1113 +f 2402//1571 1935//1107 1936//1116 +f 1931//1118 2398//1576 1930//1110 +f 2408//1577 1941//1113 1942//1120 +f 2403//1709 1936//1116 1937//1122 +f 1932//1124 2399//1579 1931//1118 +f 2409//1581 1942//1120 1943//1591 +f 2404//1578 1937//1122 1938//1128 +f 1933//1130 2400//1583 1932//1124 +o Hnad_L_Sphere.012 +v 0.398410 0.221774 0.909033 +v 0.378940 0.206049 0.909266 +v 0.360366 0.192203 0.911041 +v 0.343400 0.180768 0.914290 +v 0.328695 0.172185 0.918888 +v 0.316816 0.166782 0.924658 +v 0.308220 0.164768 0.931379 +v 0.303236 0.166220 0.938792 +v 0.302057 0.171081 0.946613 +v 0.304727 0.179166 0.954540 +v 0.311144 0.190164 0.962270 +v 0.321062 0.203651 0.969505 +v 0.334099 0.219110 0.975966 +v 0.349754 0.235947 0.981407 +v 0.367426 0.253514 0.985617 +v 0.400727 0.220453 0.910024 +v 0.383486 0.203457 0.911210 +v 0.366965 0.188440 0.913864 +v 0.351800 0.175979 0.917884 +v 0.338572 0.166554 0.923114 +v 0.327791 0.160525 0.929354 +v 0.319871 0.158126 0.936364 +v 0.315115 0.159447 0.943874 +v 0.313708 0.164439 0.951597 +v 0.315702 0.172909 0.959235 +v 0.321021 0.184533 0.966495 +v 0.329462 0.198862 0.973098 +v 0.340698 0.215347 0.978790 +v 0.354300 0.233355 0.983352 +v 0.369743 0.252192 0.986609 +v 0.403698 0.219848 0.911057 +v 0.389313 0.202270 0.913236 +v 0.375425 0.186717 0.916806 +v 0.362567 0.173786 0.921627 +v 0.351233 0.163974 0.927515 +v 0.341859 0.157659 0.934245 +v 0.334805 0.155083 0.941556 +v 0.330342 0.156345 0.949168 +v 0.328642 0.161396 0.956790 +v 0.329770 0.170043 0.964126 +v 0.333682 0.181953 0.970897 +v 0.340229 0.196669 0.976842 +v 0.349158 0.213624 0.981731 +v 0.360127 0.232168 0.985378 +v 0.372714 0.251587 0.987642 +v 0.407207 0.219982 0.912091 +v 0.396197 0.202533 0.915266 +v 0.385419 0.187098 0.919752 +v 0.375287 0.174272 0.925376 +v 0.366191 0.164546 0.931924 +v 0.358479 0.158294 0.939144 +v 0.352449 0.155757 0.946757 +v 0.348332 0.157032 0.954471 +v 0.346286 0.162070 0.961990 +v 0.346390 0.170678 0.969025 +v 0.348640 0.182524 0.975306 +v 0.352949 0.197154 0.980591 +v 0.359152 0.214006 0.984677 +v 0.367011 0.232431 0.987407 +v 0.376223 0.251721 0.988676 +v 0.411121 0.220850 0.913088 +v 0.403874 0.204236 0.917220 +v 0.396564 0.189571 0.922589 +v 0.389472 0.177418 0.928988 +v 0.382871 0.168246 0.936171 +v 0.377013 0.162405 0.943862 +v 0.372124 0.160122 0.951766 +v 0.368392 0.161482 0.959579 +v 0.365961 0.166435 0.967000 +v 0.364923 0.174790 0.973744 +v 0.365320 0.186225 0.979553 +v 0.367134 0.200301 0.984203 +v 0.370298 0.216478 0.987515 +v 0.374688 0.234134 0.989362 +v 0.380137 0.252589 0.989673 +v 0.415288 0.222419 0.914008 +v 0.412049 0.207314 0.919025 +v 0.408432 0.194039 0.925209 +v 0.404577 0.183105 0.932323 +v 0.400632 0.174933 0.940092 +v 0.396748 0.169836 0.948219 +v 0.393075 0.168010 0.956392 +v 0.389753 0.169525 0.964295 +v 0.386912 0.174323 0.971625 +v 0.384659 0.182220 0.978101 +v 0.383081 0.192912 0.983474 +v 0.382239 0.205988 0.987537 +v 0.382165 0.220946 0.990135 +v 0.382863 0.237211 0.991166 +v 0.384304 0.254158 0.990593 +v 0.419549 0.224628 0.914816 +v 0.420407 0.211648 0.920611 +v 0.420566 0.200331 0.927511 +v 0.420021 0.191114 0.935253 +v 0.418792 0.184350 0.943538 +v 0.416926 0.180299 0.952047 +v 0.414496 0.179117 0.960455 +v 0.411594 0.180850 0.968438 +v 0.408333 0.185431 0.975689 +v 0.404837 0.192683 0.981929 +v 0.401241 0.202329 0.986919 +v 0.397682 0.213997 0.990467 +v 0.394299 0.227238 0.992437 +v 0.391221 0.241545 0.992752 +v 0.388565 0.256368 0.991401 +v 0.423740 0.227394 0.915482 +v 0.428627 0.217072 0.921916 +v 0.432500 0.208205 0.929407 +v 0.435210 0.201136 0.937665 +v 0.436652 0.196134 0.946374 +v 0.436772 0.193394 0.955199 +v 0.435564 0.193018 0.963801 +v 0.433075 0.195024 0.971850 +v 0.429401 0.199332 0.979035 +v 0.424682 0.205778 0.985081 +v 0.419101 0.214113 0.989756 +v 0.412872 0.224019 0.992880 +v 0.406233 0.235113 0.994332 +v 0.399441 0.246969 0.994058 +v 0.392756 0.259133 0.992067 +v 0.427699 0.230608 0.915979 +v 0.436394 0.223377 0.922891 +v 0.443776 0.217359 0.930822 +v 0.449561 0.212786 0.939467 +v 0.453527 0.209834 0.948493 +v 0.455522 0.208616 0.957554 +v 0.455469 0.209178 0.966301 +v 0.453370 0.211500 0.974398 +v 0.449306 0.215492 0.981535 +v 0.443433 0.221000 0.987436 +v 0.435976 0.227813 0.991875 +v 0.427223 0.235669 0.994682 +v 0.417509 0.244267 0.995748 +v 0.407208 0.253275 0.995033 +v 0.396715 0.262347 0.992564 +v 0.431275 0.234148 0.916289 +v 0.443409 0.230321 0.923499 +v 0.453959 0.227441 0.931704 +v 0.462522 0.225618 0.940590 +v 0.468768 0.224922 0.949813 +v 0.472457 0.225381 0.959021 +v 0.473447 0.226976 0.967858 +v 0.471701 0.229647 0.975986 +v 0.467284 0.233289 0.983092 +v 0.460368 0.237765 0.988903 +v 0.451217 0.242901 0.993195 +v 0.440184 0.248501 0.995804 +v 0.427693 0.254348 0.996630 +v 0.414222 0.260219 0.995640 +v 0.400291 0.265888 0.992873 +v 0.434331 0.237878 0.916399 +v 0.449402 0.237638 0.923715 +v 0.462660 0.238063 0.932019 +v 0.473596 0.239137 0.940990 +v 0.481790 0.240819 0.950284 +v 0.486926 0.243045 0.959543 +v 0.488807 0.245728 0.968413 +v 0.487361 0.248766 0.976551 +v 0.482644 0.252041 0.983646 +v 0.474836 0.255429 0.989425 +v 0.464239 0.258798 0.993665 +v 0.451258 0.262020 0.996204 +v 0.436393 0.264970 0.996944 +v 0.420215 0.267536 0.995857 +v 0.403347 0.269618 0.992984 +v 0.436748 0.241655 0.916306 +v 0.454143 0.245045 0.923533 +v 0.469543 0.248817 0.931753 +v 0.482356 0.252825 0.940652 +v 0.492091 0.256914 0.949886 +v 0.498372 0.260928 0.959102 +v 0.500958 0.264713 0.967944 +v 0.499750 0.268122 0.976073 +v 0.494795 0.271026 0.983178 +v 0.486282 0.273312 0.988983 +v 0.474540 0.274893 0.993268 +v 0.460018 0.275707 0.995866 +v 0.443276 0.275724 0.996679 +v 0.424956 0.274943 0.995674 +v 0.405764 0.273394 0.992891 +v 0.438433 0.245332 0.916012 +v 0.457450 0.252259 0.922957 +v 0.474344 0.259290 0.930918 +v 0.488467 0.266154 0.939589 +v 0.499276 0.272588 0.948636 +v 0.506355 0.278344 0.957713 +v 0.509433 0.283202 0.966470 +v 0.508391 0.286973 0.974570 +v 0.503270 0.289515 0.981703 +v 0.494266 0.290728 0.987595 +v 0.481725 0.290567 0.992018 +v 0.466128 0.289037 0.994803 +v 0.448077 0.286197 0.995843 +v 0.428263 0.282157 0.995099 +v 0.407449 0.277072 0.992597 +v 0.439323 0.248770 0.915530 +v 0.459195 0.259002 0.922012 +v 0.476878 0.269079 0.929545 +v 0.491692 0.278614 0.937841 +v 0.503068 0.287239 0.946582 +v 0.510569 0.294623 0.955430 +v 0.513907 0.300483 0.964046 +v 0.512953 0.304594 0.972099 +v 0.507744 0.306797 0.979280 +v 0.498480 0.307007 0.985312 +v 0.485517 0.305218 0.989963 +v 0.469354 0.301497 0.993056 +v 0.450611 0.295987 0.994471 +v 0.430009 0.288900 0.994153 +v 0.408339 0.280509 0.992115 +v 0.439383 0.251835 0.914878 +v 0.459313 0.265015 0.920732 +v 0.477048 0.277809 0.927688 +v 0.491909 0.289724 0.935477 +v 0.503323 0.300304 0.943802 +v 0.510853 0.309140 0.952341 +v 0.514208 0.315894 0.960767 +v 0.513260 0.320307 0.968756 +v 0.508045 0.322208 0.976001 +v 0.498763 0.321524 0.982223 +v 0.485772 0.318283 0.987183 +v 0.469571 0.312607 0.990692 +v 0.450782 0.304716 0.992613 +v 0.430126 0.294913 0.992874 +v 0.408399 0.283575 0.991463 +v 0.438611 0.254411 0.914081 +v 0.457797 0.270067 0.919168 +v 0.474848 0.285143 0.925417 +v 0.489109 0.299059 0.932587 +v 0.500031 0.311280 0.940403 +v 0.507194 0.321337 0.948565 +v 0.510324 0.328842 0.956758 +v 0.509300 0.333508 0.964668 +v 0.504161 0.335156 0.971992 +v 0.495105 0.333721 0.978446 +v 0.482480 0.329259 0.983785 +v 0.466771 0.321942 0.987802 +v 0.448581 0.312051 0.990342 +v 0.428611 0.299965 0.991309 +v 0.407627 0.286150 0.990665 +v 0.437035 0.256397 0.913169 +v 0.454707 0.273964 0.917379 +v 0.470362 0.290801 0.922820 +v 0.483399 0.306260 0.929282 +v 0.493317 0.319747 0.936516 +v 0.499734 0.330744 0.944246 +v 0.502404 0.338829 0.952173 +v 0.501225 0.343691 0.959994 +v 0.496241 0.345143 0.967407 +v 0.487645 0.343129 0.974128 +v 0.475766 0.337726 0.979898 +v 0.461061 0.329142 0.984496 +v 0.444095 0.317708 0.987745 +v 0.425521 0.303862 0.989520 +v 0.406051 0.288137 0.989754 +v 0.434718 0.257719 0.912177 +v 0.450161 0.276556 0.915434 +v 0.463763 0.294563 0.919996 +v 0.474999 0.311049 0.925688 +v 0.483440 0.325378 0.932291 +v 0.488759 0.337002 0.939551 +v 0.490753 0.345472 0.947189 +v 0.489346 0.350464 0.954912 +v 0.484590 0.351785 0.962422 +v 0.476670 0.349386 0.969433 +v 0.465889 0.343357 0.975673 +v 0.452661 0.333931 0.980903 +v 0.437496 0.321471 0.984922 +v 0.420975 0.306454 0.987576 +v 0.403734 0.289458 0.988762 +v 0.431747 0.258324 0.911144 +v 0.444334 0.277743 0.913408 +v 0.455303 0.296287 0.917055 +v 0.464232 0.313242 0.921945 +v 0.470779 0.327958 0.927889 +v 0.474691 0.339868 0.934660 +v 0.475819 0.348515 0.941997 +v 0.474119 0.353566 0.949618 +v 0.469656 0.354828 0.957230 +v 0.462602 0.352252 0.964542 +v 0.453228 0.345937 0.971271 +v 0.441894 0.336125 0.977159 +v 0.429036 0.323194 0.981981 +v 0.415148 0.307641 0.985550 +v 0.400763 0.290063 0.987729 +v 0.428238 0.258190 0.910110 +v 0.437450 0.277480 0.911379 +v 0.445309 0.295905 0.914109 +v 0.451512 0.312756 0.918195 +v 0.455821 0.327386 0.923480 +v 0.458071 0.339233 0.929761 +v 0.458175 0.347841 0.936796 +v 0.456129 0.352879 0.944315 +v 0.452012 0.354154 0.952029 +v 0.445982 0.351617 0.959643 +v 0.438270 0.345365 0.966862 +v 0.429174 0.335639 0.973410 +v 0.419042 0.322812 0.979035 +v 0.408264 0.307378 0.983520 +v 0.397254 0.289929 0.986695 +v 0.424324 0.257321 0.909114 +v 0.429773 0.275777 0.909425 +v 0.434163 0.293433 0.911272 +v 0.437327 0.309610 0.914584 +v 0.439141 0.323686 0.919233 +v 0.439537 0.335121 0.925042 +v 0.438500 0.343476 0.931786 +v 0.436069 0.348429 0.939208 +v 0.432337 0.349789 0.947020 +v 0.427448 0.347505 0.954924 +v 0.421590 0.341665 0.962615 +v 0.414989 0.332492 0.969798 +v 0.407896 0.320340 0.976197 +v 0.400587 0.305675 0.981566 +v 0.393340 0.289061 0.985698 +v 0.420157 0.255752 0.908194 +v 0.421598 0.272699 0.907620 +v 0.422296 0.288964 0.908651 +v 0.422222 0.303923 0.911249 +v 0.421380 0.316999 0.915312 +v 0.419802 0.327691 0.920685 +v 0.417549 0.335588 0.927161 +v 0.414707 0.340386 0.934491 +v 0.411386 0.341901 0.942395 +v 0.407713 0.340075 0.950567 +v 0.403829 0.334978 0.958694 +v 0.399884 0.326805 0.966463 +v 0.396029 0.315872 0.973577 +v 0.392412 0.302597 0.979761 +v 0.389173 0.287492 0.984778 +v 0.386435 0.271136 0.988436 +v 0.415896 0.253543 0.907385 +v 0.413240 0.268365 0.906034 +v 0.410162 0.282672 0.906349 +v 0.406778 0.295914 0.908319 +v 0.403220 0.307582 0.911867 +v 0.399624 0.317228 0.916857 +v 0.396128 0.324480 0.923097 +v 0.392867 0.329061 0.930348 +v 0.389965 0.330793 0.938331 +v 0.387535 0.329612 0.946739 +v 0.385669 0.325561 0.955249 +v 0.384440 0.318797 0.963533 +v 0.383895 0.309580 0.971275 +v 0.384054 0.298263 0.978176 +v 0.384912 0.285282 0.983970 +v 0.411705 0.250778 0.906720 +v 0.405020 0.262941 0.904729 +v 0.398228 0.274798 0.904454 +v 0.391589 0.285892 0.905907 +v 0.385360 0.295797 0.909030 +v 0.379779 0.304133 0.913705 +v 0.375060 0.310579 0.919751 +v 0.371386 0.314887 0.926937 +v 0.368897 0.316892 0.934985 +v 0.367689 0.316517 0.943587 +v 0.367809 0.313776 0.952412 +v 0.369251 0.308775 0.961121 +v 0.371961 0.301705 0.969380 +v 0.375834 0.292839 0.976870 +v 0.380721 0.282517 0.983304 +v 0.407746 0.247563 0.906222 +v 0.397253 0.256636 0.903753 +v 0.386952 0.265644 0.903038 +v 0.377238 0.274242 0.904104 +v 0.368485 0.282098 0.906911 +v 0.361028 0.288911 0.911350 +v 0.355155 0.294419 0.917252 +v 0.351091 0.298411 0.924388 +v 0.348992 0.300732 0.932485 +v 0.348939 0.301295 0.941232 +v 0.350934 0.300077 0.950293 +v 0.354900 0.297124 0.959319 +v 0.360685 0.292552 0.967964 +v 0.368067 0.286534 0.975895 +v 0.376762 0.279303 0.982807 +v 0.404169 0.244023 0.905913 +v 0.390239 0.249692 0.903146 +v 0.376768 0.255563 0.902156 +v 0.364277 0.261410 0.902982 +v 0.353244 0.267010 0.905591 +v 0.344093 0.272146 0.909884 +v 0.337177 0.276621 0.915694 +v 0.332760 0.280264 0.922800 +v 0.331014 0.282935 0.930928 +v 0.332004 0.284530 0.939766 +v 0.335693 0.284988 0.948973 +v 0.341939 0.284293 0.958196 +v 0.350501 0.282470 0.967082 +v 0.361052 0.279590 0.975287 +v 0.373186 0.275763 0.982498 +v 0.401114 0.240293 0.905802 +v 0.384246 0.242375 0.902929 +v 0.368068 0.244941 0.901842 +v 0.353203 0.247891 0.902582 +v 0.340222 0.251113 0.905121 +v 0.329625 0.254482 0.909361 +v 0.321817 0.257870 0.915140 +v 0.317100 0.261145 0.922235 +v 0.315654 0.264183 0.930373 +v 0.317535 0.266866 0.939243 +v 0.322671 0.269092 0.948503 +v 0.330865 0.270774 0.957796 +v 0.341801 0.271848 0.966767 +v 0.355059 0.272273 0.975071 +v 0.370130 0.272033 0.982387 +v 0.398697 0.236517 0.905896 +v 0.379504 0.234968 0.903112 +v 0.361185 0.234187 0.902108 +v 0.344443 0.234203 0.902920 +v 0.329921 0.235018 0.905518 +v 0.318179 0.236599 0.909803 +v 0.309666 0.238885 0.915609 +v 0.304711 0.241788 0.922713 +v 0.303503 0.245198 0.930842 +v 0.306089 0.248983 0.939685 +v 0.312370 0.252997 0.948900 +v 0.322105 0.257086 0.958134 +v 0.334918 0.261094 0.967033 +v 0.350318 0.264866 0.975254 +v 0.367713 0.268256 0.982480 +v 0.397011 0.232839 0.906189 +v 0.376198 0.227754 0.903688 +v 0.356384 0.223713 0.902943 +v 0.338332 0.220874 0.903983 +v 0.322736 0.219344 0.906768 +v 0.310195 0.219183 0.911192 +v 0.301191 0.220396 0.917083 +v 0.296070 0.222937 0.924216 +v 0.295028 0.226709 0.932317 +v 0.298106 0.231567 0.941073 +v 0.305185 0.237323 0.950150 +v 0.315994 0.243757 0.959198 +v 0.330117 0.250621 0.967868 +v 0.347011 0.257652 0.975829 +v 0.366028 0.264579 0.982774 +v 0.396122 0.229402 0.906671 +v 0.374452 0.221011 0.904633 +v 0.353850 0.213924 0.904315 +v 0.335107 0.208414 0.905730 +v 0.318944 0.204693 0.908823 +v 0.305981 0.202903 0.913474 +v 0.296717 0.203114 0.919506 +v 0.291508 0.205317 0.926687 +v 0.290554 0.209427 0.934740 +v 0.293892 0.215287 0.943356 +v 0.301392 0.222672 0.952204 +v 0.312769 0.231297 0.960945 +v 0.327583 0.240831 0.969241 +v 0.345266 0.250908 0.976774 +v 0.365138 0.261141 0.983256 +v 0.418026 0.238775 0.910350 +v 0.396062 0.226336 0.907323 +v 0.374335 0.214998 0.905913 +v 0.353679 0.205194 0.906173 +v 0.334890 0.197304 0.908094 +v 0.318689 0.191628 0.911603 +v 0.305698 0.188387 0.916563 +v 0.296416 0.187703 0.922786 +v 0.291201 0.189604 0.930030 +v 0.290253 0.194016 0.938019 +v 0.293608 0.200771 0.946445 +v 0.301138 0.209607 0.954984 +v 0.312552 0.220186 0.963309 +v 0.327412 0.232102 0.971098 +v 0.345148 0.244895 0.978054 +v 0.365078 0.258076 0.983908 +v 0.396834 0.223761 0.908121 +v 0.375850 0.209946 0.907477 +v 0.355880 0.197860 0.908444 +v 0.337690 0.187969 0.910985 +v 0.321981 0.180652 0.915001 +v 0.309356 0.176190 0.920340 +v 0.300300 0.174755 0.926795 +v 0.295161 0.176403 0.934118 +v 0.294137 0.181069 0.942028 +v 0.297267 0.188574 0.950222 +v 0.304430 0.198631 0.958383 +v 0.315352 0.210852 0.966199 +v 0.329613 0.224767 0.973369 +v 0.346664 0.239843 0.979618 +v 0.365850 0.255500 0.984705 +v 0.345359 0.270175 0.883207 +v 0.325889 0.254450 0.883440 +v 0.307315 0.240604 0.885215 +v 0.290349 0.229170 0.888464 +v 0.275644 0.220586 0.893062 +v 0.263765 0.215183 0.898832 +v 0.255169 0.213169 0.905553 +v 0.250185 0.214621 0.912967 +v 0.249006 0.219483 0.920787 +v 0.251676 0.227568 0.928714 +v 0.258093 0.238565 0.936444 +v 0.268011 0.252052 0.943679 +v 0.281048 0.267511 0.950141 +v 0.296703 0.284348 0.955581 +v 0.314375 0.301915 0.959791 +v 0.347676 0.268854 0.884198 +v 0.330435 0.251858 0.885385 +v 0.313914 0.236841 0.888038 +v 0.298749 0.224381 0.892058 +v 0.285521 0.214955 0.897288 +v 0.274740 0.208926 0.903528 +v 0.266820 0.206527 0.910538 +v 0.262064 0.207848 0.918049 +v 0.260657 0.212840 0.925771 +v 0.262651 0.221310 0.933410 +v 0.267970 0.232934 0.940669 +v 0.276411 0.247263 0.947272 +v 0.287647 0.263749 0.952964 +v 0.301249 0.281756 0.957526 +v 0.316692 0.300593 0.960783 +v 0.350647 0.268249 0.885231 +v 0.336262 0.250671 0.887411 +v 0.322374 0.235118 0.890980 +v 0.309516 0.222187 0.895801 +v 0.298182 0.212375 0.901689 +v 0.288808 0.206060 0.908419 +v 0.281754 0.203484 0.915730 +v 0.277291 0.204746 0.923343 +v 0.275591 0.209797 0.930964 +v 0.276719 0.218444 0.938301 +v 0.280631 0.230354 0.945071 +v 0.287178 0.245070 0.951016 +v 0.296107 0.262025 0.955905 +v 0.307076 0.280569 0.959552 +v 0.319663 0.299988 0.961816 +v 0.354156 0.268383 0.886265 +v 0.343146 0.250934 0.889440 +v 0.332368 0.235499 0.893926 +v 0.322236 0.222673 0.899551 +v 0.313140 0.212947 0.906098 +v 0.305428 0.206695 0.913318 +v 0.299398 0.204158 0.920931 +v 0.295281 0.205433 0.928645 +v 0.293235 0.210471 0.936164 +v 0.293339 0.219079 0.943200 +v 0.295589 0.230926 0.949480 +v 0.299898 0.245556 0.954765 +v 0.306101 0.262407 0.958851 +v 0.313960 0.280832 0.961581 +v 0.323172 0.300122 0.962850 +v 0.358070 0.269251 0.887262 +v 0.350823 0.252637 0.891394 +v 0.343513 0.237972 0.896763 +v 0.336421 0.225820 0.903162 +v 0.329820 0.216647 0.910345 +v 0.323962 0.210807 0.918036 +v 0.319073 0.208523 0.925940 +v 0.315341 0.209883 0.933753 +v 0.312910 0.214836 0.941174 +v 0.311872 0.223191 0.947918 +v 0.312269 0.234626 0.953727 +v 0.314083 0.248702 0.958377 +v 0.317247 0.264879 0.961689 +v 0.321637 0.282535 0.963536 +v 0.327086 0.300991 0.963847 +v 0.362237 0.270820 0.888182 +v 0.358998 0.255715 0.893199 +v 0.355381 0.242440 0.899383 +v 0.351526 0.231507 0.906497 +v 0.347581 0.223334 0.914267 +v 0.343697 0.218237 0.922394 +v 0.340024 0.216411 0.930566 +v 0.336702 0.217926 0.938469 +v 0.333861 0.222724 0.945799 +v 0.331608 0.230621 0.952275 +v 0.330030 0.241313 0.957648 +v 0.329188 0.254389 0.961711 +v 0.329114 0.269347 0.964309 +v 0.329812 0.285613 0.965340 +v 0.331253 0.302560 0.964767 +v 0.366498 0.273030 0.888990 +v 0.367356 0.260049 0.894785 +v 0.367515 0.248732 0.901685 +v 0.366970 0.239515 0.909427 +v 0.365741 0.232751 0.917712 +v 0.363875 0.228700 0.926222 +v 0.361445 0.227519 0.934629 +v 0.358543 0.229251 0.942612 +v 0.355282 0.233832 0.949863 +v 0.351786 0.241084 0.956103 +v 0.348190 0.250730 0.961093 +v 0.344631 0.262398 0.964641 +v 0.341248 0.275640 0.966611 +v 0.338170 0.289947 0.966926 +v 0.335514 0.304769 0.965575 +v 0.370689 0.275795 0.889656 +v 0.375576 0.265473 0.896090 +v 0.379449 0.256607 0.903581 +v 0.382159 0.249537 0.911839 +v 0.383601 0.244536 0.920548 +v 0.383721 0.241795 0.929373 +v 0.382513 0.241420 0.937975 +v 0.380024 0.243425 0.946024 +v 0.376350 0.247733 0.953209 +v 0.371631 0.254179 0.959255 +v 0.366050 0.262515 0.963930 +v 0.359821 0.272420 0.967054 +v 0.353182 0.283514 0.968506 +v 0.346390 0.295371 0.968232 +v 0.339705 0.307534 0.966241 +v 0.374648 0.279009 0.890153 +v 0.383343 0.271778 0.897066 +v 0.390725 0.265760 0.904997 +v 0.396510 0.261188 0.913641 +v 0.400476 0.258235 0.922667 +v 0.402471 0.257017 0.931728 +v 0.402418 0.257580 0.940475 +v 0.400319 0.259901 0.948572 +v 0.396255 0.263893 0.955709 +v 0.390382 0.269401 0.961610 +v 0.382925 0.276214 0.966049 +v 0.374172 0.284070 0.968856 +v 0.364458 0.292668 0.969922 +v 0.354157 0.301676 0.969207 +v 0.343664 0.310749 0.966738 +v 0.378224 0.282549 0.890463 +v 0.390358 0.278722 0.897673 +v 0.400909 0.275842 0.905879 +v 0.409471 0.274019 0.914764 +v 0.415717 0.273324 0.923987 +v 0.419406 0.273782 0.933195 +v 0.420396 0.275377 0.942032 +v 0.418650 0.278048 0.950160 +v 0.414233 0.281691 0.957266 +v 0.407317 0.286166 0.963077 +v 0.398166 0.291302 0.967369 +v 0.387133 0.296902 0.969978 +v 0.374642 0.302749 0.970804 +v 0.361171 0.308620 0.969814 +v 0.347240 0.314289 0.967048 +v 0.381280 0.286279 0.890573 +v 0.396351 0.286039 0.897890 +v 0.409609 0.286464 0.906193 +v 0.420545 0.287538 0.915164 +v 0.428739 0.289220 0.924458 +v 0.433875 0.291446 0.933717 +v 0.435756 0.294129 0.942587 +v 0.434310 0.297167 0.950726 +v 0.429593 0.300442 0.957821 +v 0.421785 0.303830 0.963599 +v 0.411188 0.307199 0.967839 +v 0.398207 0.310421 0.970378 +v 0.383342 0.313371 0.971118 +v 0.367164 0.315937 0.970031 +v 0.350296 0.318019 0.967158 +v 0.383697 0.290056 0.890480 +v 0.401092 0.293446 0.897707 +v 0.416492 0.297218 0.905927 +v 0.429305 0.301226 0.914826 +v 0.439040 0.305315 0.924060 +v 0.445321 0.309329 0.933276 +v 0.447907 0.313114 0.942118 +v 0.446699 0.316524 0.950248 +v 0.441744 0.319427 0.957352 +v 0.433231 0.321713 0.963158 +v 0.421489 0.323294 0.967442 +v 0.406967 0.324109 0.970040 +v 0.390225 0.324125 0.970853 +v 0.371905 0.323344 0.969848 +v 0.352713 0.321795 0.967065 +v 0.385382 0.293733 0.890187 +v 0.404399 0.300660 0.897131 +v 0.421293 0.307691 0.905092 +v 0.435416 0.314555 0.913763 +v 0.446225 0.320989 0.922810 +v 0.453304 0.326745 0.931887 +v 0.456382 0.331603 0.940644 +v 0.455340 0.335375 0.948744 +v 0.450219 0.337916 0.955877 +v 0.441215 0.339129 0.961769 +v 0.428674 0.338968 0.966192 +v 0.413078 0.337438 0.968977 +v 0.395026 0.334599 0.970017 +v 0.375212 0.330558 0.969273 +v 0.354398 0.325473 0.966771 +v 0.386272 0.297171 0.889705 +v 0.406144 0.307403 0.896186 +v 0.423827 0.317481 0.903719 +v 0.438641 0.327015 0.912016 +v 0.450017 0.335640 0.920756 +v 0.457518 0.343025 0.929604 +v 0.460856 0.348885 0.938220 +v 0.459902 0.352995 0.946273 +v 0.454693 0.355198 0.953454 +v 0.445429 0.355409 0.959486 +v 0.432466 0.353619 0.964138 +v 0.416303 0.349898 0.967230 +v 0.397560 0.344388 0.968645 +v 0.376958 0.337301 0.968327 +v 0.355288 0.328910 0.966289 +v 0.386332 0.300236 0.889052 +v 0.406262 0.313417 0.894906 +v 0.423997 0.326210 0.901862 +v 0.438858 0.338126 0.909651 +v 0.450272 0.348705 0.917976 +v 0.457802 0.357541 0.926515 +v 0.461157 0.364296 0.934941 +v 0.460209 0.368708 0.942930 +v 0.454994 0.370609 0.950175 +v 0.445712 0.369925 0.956397 +v 0.432721 0.366684 0.961358 +v 0.416520 0.361008 0.964866 +v 0.397731 0.353118 0.966787 +v 0.377075 0.343314 0.967048 +v 0.355348 0.331976 0.965637 +v 0.385560 0.302812 0.888255 +v 0.404746 0.318469 0.893342 +v 0.421797 0.333545 0.899591 +v 0.436058 0.347460 0.906761 +v 0.446980 0.359681 0.914577 +v 0.454143 0.369738 0.922739 +v 0.457273 0.377243 0.930932 +v 0.456248 0.381909 0.938842 +v 0.451110 0.383557 0.946166 +v 0.442054 0.382122 0.952621 +v 0.429429 0.377660 0.957959 +v 0.413720 0.370343 0.961976 +v 0.395530 0.360452 0.964516 +v 0.375560 0.348366 0.965483 +v 0.354576 0.334551 0.964840 +v 0.383984 0.304798 0.887343 +v 0.401656 0.322365 0.891553 +v 0.417311 0.339202 0.896994 +v 0.430348 0.354661 0.903456 +v 0.440266 0.368148 0.910690 +v 0.446683 0.379146 0.918420 +v 0.449353 0.387230 0.926347 +v 0.448174 0.392092 0.934168 +v 0.443190 0.393544 0.941581 +v 0.434594 0.391530 0.948302 +v 0.422715 0.386127 0.954072 +v 0.408010 0.377544 0.958670 +v 0.391044 0.366109 0.961919 +v 0.372470 0.352263 0.963695 +v 0.353000 0.336538 0.963928 +v 0.381667 0.306120 0.886351 +v 0.397110 0.324957 0.889608 +v 0.410712 0.342964 0.894170 +v 0.421948 0.359450 0.899862 +v 0.430389 0.373779 0.906465 +v 0.435708 0.385403 0.913725 +v 0.437702 0.393873 0.921363 +v 0.436295 0.398865 0.929086 +v 0.431539 0.400186 0.936597 +v 0.423619 0.397787 0.943607 +v 0.412838 0.391758 0.949847 +v 0.399610 0.382333 0.955077 +v 0.384445 0.369872 0.959096 +v 0.367924 0.354855 0.961750 +v 0.350683 0.337859 0.962936 +v 0.378696 0.306725 0.885319 +v 0.391283 0.326144 0.887582 +v 0.402252 0.344688 0.891229 +v 0.411181 0.361643 0.896119 +v 0.417728 0.376359 0.902063 +v 0.421640 0.388269 0.908834 +v 0.422768 0.396916 0.916171 +v 0.421068 0.401967 0.923792 +v 0.416605 0.403229 0.931404 +v 0.409551 0.400653 0.938716 +v 0.400177 0.394338 0.945445 +v 0.388843 0.384526 0.951333 +v 0.375985 0.371595 0.956155 +v 0.362097 0.356042 0.959724 +v 0.347712 0.338464 0.961903 +v 0.375187 0.306591 0.884284 +v 0.384399 0.325881 0.885553 +v 0.392258 0.344306 0.888283 +v 0.398461 0.361158 0.892369 +v 0.402770 0.375788 0.897654 +v 0.405020 0.387634 0.903935 +v 0.405124 0.396242 0.910970 +v 0.403078 0.401280 0.918489 +v 0.398961 0.402555 0.926204 +v 0.392931 0.400018 0.933817 +v 0.385219 0.393766 0.941036 +v 0.376123 0.384040 0.947584 +v 0.365991 0.371214 0.953209 +v 0.355213 0.355779 0.957695 +v 0.344203 0.338330 0.960869 +v 0.371273 0.305723 0.883288 +v 0.376722 0.324178 0.883599 +v 0.381112 0.341834 0.885446 +v 0.384276 0.358011 0.888758 +v 0.386090 0.372087 0.893407 +v 0.386487 0.383522 0.899216 +v 0.385449 0.391877 0.905961 +v 0.383018 0.396830 0.913382 +v 0.379286 0.398190 0.921194 +v 0.374397 0.395907 0.929098 +v 0.368539 0.390066 0.936789 +v 0.361938 0.380893 0.943972 +v 0.354845 0.368741 0.950371 +v 0.347536 0.354076 0.955740 +v 0.340289 0.337462 0.959872 +v 0.367106 0.304154 0.882368 +v 0.368547 0.321101 0.881794 +v 0.369245 0.337366 0.882826 +v 0.369171 0.352324 0.885423 +v 0.368329 0.365400 0.889486 +v 0.366751 0.376092 0.894859 +v 0.364498 0.383989 0.901335 +v 0.361656 0.388787 0.908666 +v 0.358335 0.390302 0.916569 +v 0.354662 0.388476 0.924741 +v 0.350778 0.383379 0.932868 +v 0.346833 0.375207 0.940637 +v 0.342978 0.364273 0.947751 +v 0.339361 0.350998 0.953935 +v 0.336122 0.335893 0.958952 +v 0.333384 0.319537 0.962610 +v 0.362845 0.301944 0.881559 +v 0.360189 0.316766 0.880208 +v 0.357111 0.331074 0.880524 +v 0.353727 0.344315 0.882493 +v 0.350169 0.355983 0.886041 +v 0.346573 0.365629 0.891031 +v 0.343077 0.372881 0.897271 +v 0.339816 0.377462 0.904522 +v 0.336914 0.379194 0.912505 +v 0.334484 0.378013 0.920913 +v 0.332618 0.373962 0.929423 +v 0.331389 0.367198 0.937708 +v 0.330844 0.357981 0.945449 +v 0.331003 0.346664 0.952350 +v 0.331861 0.333683 0.958144 +v 0.358654 0.299179 0.880894 +v 0.351969 0.311343 0.878903 +v 0.345177 0.323199 0.878628 +v 0.338538 0.334293 0.880081 +v 0.332309 0.344199 0.883204 +v 0.326728 0.352534 0.887879 +v 0.322009 0.358980 0.893925 +v 0.318335 0.363288 0.901111 +v 0.315846 0.365293 0.909159 +v 0.314638 0.364918 0.917761 +v 0.314758 0.362177 0.926586 +v 0.316200 0.357176 0.935295 +v 0.318910 0.350107 0.943554 +v 0.322783 0.341240 0.951044 +v 0.327670 0.330918 0.957479 +v 0.354695 0.295965 0.880396 +v 0.344202 0.305037 0.877927 +v 0.333901 0.314045 0.877212 +v 0.324187 0.322643 0.878279 +v 0.315434 0.330499 0.881085 +v 0.307977 0.337312 0.885525 +v 0.302104 0.342820 0.891426 +v 0.298040 0.346812 0.898562 +v 0.295941 0.349134 0.906659 +v 0.295888 0.349696 0.915406 +v 0.297883 0.348478 0.924467 +v 0.301849 0.345526 0.933493 +v 0.307634 0.340953 0.942138 +v 0.315016 0.334935 0.950069 +v 0.323711 0.327704 0.956981 +v 0.351119 0.292424 0.880087 +v 0.337188 0.298093 0.877320 +v 0.323717 0.303964 0.876330 +v 0.311226 0.309811 0.877156 +v 0.300193 0.315411 0.879765 +v 0.291042 0.320547 0.884058 +v 0.284126 0.325022 0.889869 +v 0.279709 0.328665 0.896974 +v 0.277963 0.331336 0.905102 +v 0.278953 0.332931 0.913940 +v 0.282642 0.333390 0.923147 +v 0.288888 0.332694 0.932371 +v 0.297450 0.330871 0.941256 +v 0.308001 0.327991 0.949461 +v 0.320135 0.324164 0.956672 +v 0.348063 0.288694 0.879976 +v 0.331195 0.290776 0.877103 +v 0.315017 0.293342 0.876016 +v 0.300152 0.296292 0.876756 +v 0.287171 0.299514 0.879295 +v 0.276574 0.302883 0.883535 +v 0.268766 0.306271 0.889314 +v 0.264049 0.309546 0.896409 +v 0.262603 0.312584 0.904547 +v 0.264484 0.315267 0.913417 +v 0.269620 0.317493 0.922677 +v 0.277814 0.319175 0.931971 +v 0.288750 0.320249 0.940942 +v 0.302008 0.320674 0.949245 +v 0.317079 0.320434 0.956561 +v 0.345646 0.284918 0.880070 +v 0.326453 0.283369 0.877286 +v 0.308134 0.282588 0.876282 +v 0.291392 0.282605 0.877094 +v 0.276870 0.283419 0.879692 +v 0.265128 0.285000 0.883977 +v 0.256615 0.287286 0.889783 +v 0.251660 0.290189 0.896887 +v 0.250452 0.293599 0.905016 +v 0.253038 0.297384 0.913859 +v 0.259319 0.301398 0.923074 +v 0.269054 0.305487 0.932309 +v 0.281867 0.309495 0.941207 +v 0.297267 0.313267 0.949428 +v 0.314662 0.316657 0.956654 +v 0.343960 0.281240 0.880363 +v 0.323147 0.276155 0.877862 +v 0.303333 0.272115 0.877117 +v 0.285281 0.269275 0.878157 +v 0.269685 0.267745 0.880942 +v 0.257144 0.267584 0.885366 +v 0.248140 0.268797 0.891257 +v 0.243019 0.271339 0.898390 +v 0.241977 0.275110 0.906491 +v 0.245055 0.279968 0.915248 +v 0.252134 0.285724 0.924324 +v 0.262943 0.292158 0.933372 +v 0.277066 0.299022 0.942042 +v 0.293960 0.306053 0.950003 +v 0.312976 0.312980 0.956948 +v 0.343071 0.277803 0.880845 +v 0.321401 0.269412 0.878807 +v 0.300799 0.262325 0.878490 +v 0.282056 0.256815 0.879904 +v 0.265893 0.253094 0.882997 +v 0.252930 0.251305 0.887648 +v 0.243666 0.251515 0.893680 +v 0.238457 0.253718 0.900861 +v 0.237503 0.257829 0.908914 +v 0.240840 0.263689 0.917530 +v 0.248342 0.271073 0.926379 +v 0.259718 0.279698 0.935119 +v 0.274532 0.289233 0.943415 +v 0.292215 0.299310 0.950949 +v 0.312087 0.309542 0.957430 +v 0.364975 0.287176 0.884525 +v 0.343011 0.274737 0.881497 +v 0.321284 0.263399 0.880087 +v 0.300628 0.253596 0.880347 +v 0.281839 0.245705 0.882268 +v 0.265638 0.240029 0.885777 +v 0.252647 0.236788 0.890737 +v 0.243365 0.236104 0.896960 +v 0.238150 0.238005 0.904204 +v 0.237202 0.242418 0.912193 +v 0.240557 0.249172 0.920619 +v 0.248087 0.258008 0.929159 +v 0.259501 0.268588 0.937483 +v 0.274361 0.280503 0.945273 +v 0.292097 0.293297 0.952228 +v 0.312027 0.306477 0.958082 +v 0.343783 0.272162 0.882295 +v 0.322799 0.258347 0.881651 +v 0.302829 0.246261 0.882618 +v 0.284639 0.236370 0.885159 +v 0.268930 0.229053 0.889175 +v 0.256305 0.224591 0.894514 +v 0.247249 0.223156 0.900969 +v 0.242110 0.224804 0.908292 +v 0.241086 0.229470 0.916202 +v 0.244216 0.236975 0.924396 +v 0.251379 0.247032 0.932557 +v 0.262301 0.259253 0.940373 +v 0.276562 0.273169 0.947544 +v 0.293613 0.288245 0.953792 +v 0.312799 0.303901 0.958880 +vn -0.457839 -0.781518 -0.423750 +vn -0.223029 -0.673574 -0.704642 +vn -0.075198 -0.813440 -0.576739 +vn 0.188421 -0.315073 -0.930143 +vn 0.237678 -0.259987 -0.935881 +vn 0.254982 -0.277749 -0.926176 +vn -0.419538 0.028382 0.907285 +vn -0.475234 -0.052797 0.878231 +vn -0.363811 -0.022614 0.931181 +vn -0.664296 -0.746788 0.031007 +vn -0.251381 -0.932798 -0.258187 +vn 0.129276 -0.377697 -0.916837 +vn 0.222175 -0.351207 -0.909513 +vn -0.371807 0.093417 0.923582 +vn -0.336650 0.059999 0.939695 +vn -0.701468 -0.541581 0.463240 +vn -0.416791 -0.889676 0.186377 +vn 0.052278 -0.453749 -0.889584 +vn 0.181555 -0.434950 -0.881954 +vn -0.328257 0.149602 0.932646 +vn -0.310587 0.132694 0.941221 +vn -0.627064 -0.321024 0.709708 +vn -0.460280 -0.434584 0.774102 +vn -0.057039 -0.551073 -0.832484 +vn 0.127140 -0.535997 -0.834559 +vn -0.543626 -0.162542 0.823389 +vn -0.426374 -0.254494 0.867977 +vn 0.047731 -0.662618 -0.747398 +vn -0.393414 -0.123234 0.911039 +vn 0.075259 -0.892026 -0.445631 +vn 0.273049 -0.291879 -0.916623 +vn -0.306375 -0.062563 0.949828 +vn -0.049165 -0.992737 -0.109500 +vn 0.257790 -0.380444 -0.888119 +vn -0.300272 0.033357 0.953246 +vn -0.476608 -0.671621 0.567186 +vn -0.265786 -0.729972 0.629627 +vn 0.236885 -0.480453 -0.844386 +vn -0.292428 0.119358 0.948790 +vn -0.299600 -0.502945 0.810694 +vn 0.206091 -0.598498 -0.774132 +vn -0.309793 -0.318613 0.895810 +vn 0.157018 -0.739464 -0.654622 +vn -0.310251 -0.176244 0.934141 +vn -0.201758 -0.357830 0.911710 +vn 0.261330 -0.782128 -0.565630 +vn -0.230537 -0.212165 0.949614 +vn 0.211371 -0.920133 -0.329600 +vn 0.290933 -0.302255 -0.907712 +vn -0.250252 -0.091128 0.963866 +vn -0.182501 -0.935881 0.301279 +vn 0.121921 -0.992492 0.006439 +vn 0.293588 -0.401959 -0.867275 +vn -0.264290 0.013825 0.964324 +vn -0.090060 -0.742607 0.663594 +vn 0.292306 -0.512894 -0.807123 +vn -0.274606 0.109653 0.955260 +vn -0.157903 -0.536241 0.829127 +vn 0.283914 -0.639729 -0.714194 +vn -0.257668 0.103580 0.960662 +vn -0.037233 -0.544359 0.838008 +vn 0.357402 -0.660604 -0.660146 +vn -0.105411 -0.376049 0.920560 +vn 0.356365 -0.796319 -0.488723 +vn -0.157109 -0.232185 0.959868 +vn 0.328745 -0.914212 -0.236793 +vn 0.308145 -0.308756 -0.899808 +vn -0.197333 -0.108432 0.974303 +vn 0.008362 -0.926206 0.376843 +vn 0.260598 -0.961241 0.089969 +vn 0.328257 -0.415357 -0.848323 +vn -0.230018 0.001556 0.973174 +vn 0.051912 -0.729331 0.682150 +vn 0.345622 -0.531938 -0.773003 +vn 0.360698 -0.420545 -0.832453 +vn -0.198431 -0.003418 0.980102 +vn 0.158483 -0.891140 0.425092 +vn 0.167791 -0.700797 0.693319 +vn 0.395276 -0.537950 -0.744530 +vn -0.242073 0.101138 0.964965 +vn 0.064638 -0.534104 0.842921 +vn 0.424818 -0.663442 -0.615925 +vn -0.021363 -0.376843 0.926023 +vn 0.441206 -0.788537 -0.428358 +vn -0.091342 -0.237709 0.967009 +vn 0.429548 -0.887173 -0.168432 +vn 0.324137 -0.311350 -0.893277 +vn -0.149113 -0.114780 0.982116 +vn 0.374584 -0.915433 0.147099 +vn 0.517838 -0.846583 -0.122929 +vn 0.338359 -0.310068 -0.888424 +vn -0.106632 -0.110660 0.988098 +vn 0.279061 -0.844997 0.456160 +vn 0.472060 -0.862178 0.183752 +vn 0.389935 -0.417707 -0.820612 +vn -0.170385 -0.001251 0.985351 +vn 0.264748 -0.661702 0.701437 +vn 0.440077 -0.531754 -0.723563 +vn -0.228248 0.102268 0.968200 +vn 0.151006 -0.509445 0.847133 +vn 0.485336 -0.650594 -0.584033 +vn 0.050935 -0.362682 0.930509 +vn 0.516709 -0.764000 -0.386303 +vn -0.033998 -0.229957 0.972594 +vn 0.112369 -0.335002 0.935453 +vn 0.584063 -0.725913 -0.363140 +vn 0.014618 -0.209815 0.977599 +vn 0.597247 -0.795984 -0.098361 +vn 0.350505 -0.305155 -0.885433 +vn -0.070589 -0.096500 0.992798 +vn 0.380108 -0.792871 0.476272 +vn 0.559313 -0.803491 0.203864 +vn 0.415113 -0.407239 -0.813501 +vn -0.146611 0.007843 0.989135 +vn 0.348430 -0.613514 0.708609 +vn 0.479049 -0.514359 -0.711264 +vn -0.216559 0.106845 0.970397 +vn 0.224677 -0.472274 0.852321 +vn 0.538652 -0.624134 -0.565935 +vn -0.127567 0.023591 0.991516 +vn 0.287759 -0.422712 0.859340 +vn 0.643910 -0.675680 -0.358867 +vn 0.163396 -0.294351 0.941618 +vn 0.670370 -0.736045 -0.093600 +vn 0.054231 -0.177770 0.982543 +vn 0.640919 -0.738456 0.209418 +vn 0.435621 -0.389691 -0.811365 +vn 0.468917 -0.735588 0.488845 +vn 0.550737 -0.671651 0.495499 +vn 0.511429 -0.486648 -0.708213 +vn -0.041597 -0.072756 0.996460 +vn 0.422803 -0.555620 0.715873 +vn 0.584277 -0.585253 -0.562151 +vn -0.020203 -0.039766 0.998993 +vn 0.490616 -0.485641 0.723472 +vn 0.621326 -0.534745 -0.572680 +vn -0.207160 0.114658 0.971526 +vn -0.113773 0.045656 0.992431 +vn 0.695944 -0.613361 -0.373333 +vn 0.341441 -0.359630 0.868343 +vn 0.738456 -0.665487 -0.108493 +vn 0.204230 -0.240364 0.948943 +vn 0.720023 -0.664296 0.200598 +vn 0.360271 -0.296823 -0.884335 +vn 0.450880 -0.365551 -0.814264 +vn 0.084384 -0.134068 0.987365 +vn 0.629322 -0.597919 0.496384 +vn 0.536363 -0.449324 -0.714408 +vn 0.367504 -0.285287 -0.885159 +vn 0.460250 -0.335429 -0.821955 +vn 0.104526 -0.078646 0.991394 +vn 0.707297 -0.509049 0.490463 +vn 0.552690 -0.403119 -0.729362 +vn -0.006989 0.002045 0.999969 +vn 0.648244 -0.472793 -0.596789 +vn -0.200323 0.125614 0.971618 +vn -0.105625 0.073611 0.991668 +vn 0.553362 -0.399365 0.730918 +vn 0.738609 -0.537919 -0.406262 +vn 0.385968 -0.280496 0.878811 +vn 0.800958 -0.581164 -0.143803 +vn 0.234352 -0.172124 0.956786 +vn 0.798212 -0.576128 0.175756 +vn 0.854823 -0.478378 -0.201025 +vn 0.252510 -0.088015 0.963561 +vn 0.874722 -0.466475 0.131260 +vn 0.371868 -0.270699 -0.887906 +vn 0.463027 -0.300119 -0.833949 +vn 0.113620 -0.011383 0.993439 +vn 0.785638 -0.396802 0.474624 +vn 0.559221 -0.348979 -0.751946 +vn -0.002594 0.052187 0.998627 +vn 0.662862 -0.399701 -0.633106 +vn -0.196204 0.139500 0.970580 +vn -0.103458 0.106906 0.988861 +vn 0.611103 -0.290201 0.736412 +vn 0.768639 -0.447645 -0.456893 +vn 0.420148 -0.181494 0.889096 +vn 0.660878 -0.148473 0.735649 +vn 0.780847 -0.341227 -0.523240 +vn 0.440870 -0.057497 0.895688 +vn 0.892788 -0.351787 -0.281289 +vn 0.256417 0.013520 0.966460 +vn 0.943632 -0.325144 0.061708 +vn 0.373089 -0.253456 -0.892483 +vn 0.458846 -0.260781 -0.849361 +vn 0.110446 0.067568 0.991577 +vn 0.861446 -0.248756 0.442701 +vn 0.554765 -0.288247 -0.780450 +vn -0.007538 0.109897 0.993896 +vn 0.662343 -0.316202 -0.679159 +vn -0.195044 0.156041 0.968291 +vn -0.107578 0.144688 0.983581 +vn -0.022462 0.173925 0.984497 +vn 0.693655 0.037599 0.719291 +vn 0.644032 -0.224311 -0.731346 +vn -0.196966 0.174841 0.964660 +vn -0.118107 0.186041 0.975402 +vn 0.768395 -0.219398 -0.601154 +vn 0.441908 0.096377 0.891842 +vn 0.902219 -0.197851 -0.383190 +vn 0.242653 0.133396 0.960875 +vn 0.989196 -0.141240 -0.038545 +vn 0.370983 -0.234107 -0.898618 +vn 0.447462 -0.218635 -0.867153 +vn 0.093448 0.157414 0.983093 +vn 0.921995 -0.049165 0.384014 +vn 0.538438 -0.222785 -0.812677 +vn 0.365520 -0.213202 -0.906034 +vn 0.428846 -0.175268 -0.886196 +vn 0.061007 0.255684 0.964812 +vn 0.935392 0.209876 0.284555 +vn 0.509842 -0.155156 -0.846126 +vn -0.047792 0.242317 0.968993 +vn 0.688955 0.274575 0.670766 +vn 0.606037 -0.127842 -0.785089 +vn -0.202094 0.195410 0.959655 +vn -0.135166 0.229621 0.963836 +vn 0.724845 -0.087039 -0.683370 +vn 0.412915 0.281045 0.866298 +vn 0.866146 -0.020386 -0.499344 +vn 0.206793 0.269601 0.940489 +vn 0.981506 0.086917 -0.170507 +vn 0.771966 0.162420 -0.614521 +vn 0.144810 0.414136 0.898587 +vn 0.886258 0.333201 -0.321696 +vn 0.356548 -0.191351 -0.914457 +vn 0.403302 -0.132633 -0.905393 +vn 0.012055 0.357280 0.933897 +vn 0.854671 0.500107 0.139195 +vn 0.469527 -0.088870 -0.878414 +vn -0.083712 0.311838 0.946410 +vn 0.615253 0.542741 0.571703 +vn 0.548509 -0.032929 -0.835475 +vn -0.210547 0.217200 0.953124 +vn -0.158818 0.273598 0.948637 +vn 0.647847 0.045106 -0.760430 +vn 0.341319 0.484207 0.805597 +vn 0.223029 0.673574 0.704642 +vn 0.543626 0.162572 -0.823389 +vn 0.057039 0.551073 0.832484 +vn 0.627064 0.321024 -0.709708 +vn -0.052278 0.453749 0.889584 +vn 0.701468 0.541581 -0.463240 +vn 0.344005 -0.169622 -0.923490 +vn 0.328257 -0.149602 -0.932646 +vn -0.129276 0.377697 0.916837 +vn 0.664296 0.746788 -0.031007 +vn 0.419538 -0.028382 -0.907254 +vn -0.188421 0.315073 0.930143 +vn 0.457839 0.781518 0.423750 +vn 0.475234 0.052797 -0.878231 +vn -0.222480 0.239265 0.945097 +vn -0.237678 0.259987 0.935881 +vn -0.222175 0.351238 0.909513 +vn 0.251381 0.932798 0.258187 +vn 0.363811 0.022614 -0.931181 +vn -0.254982 0.277718 0.926176 +vn 0.075198 0.813440 0.576739 +vn 0.393414 0.123234 -0.911039 +vn -0.047731 0.662618 0.747398 +vn 0.426374 0.254494 -0.867977 +vn -0.127140 0.535997 0.834559 +vn 0.460280 0.434584 -0.774102 +vn 0.371807 -0.093417 -0.923582 +vn 0.310587 -0.132664 -0.941221 +vn -0.181555 0.434950 0.881954 +vn 0.416791 0.889676 -0.186377 +vn 0.336650 -0.059999 -0.939695 +vn -0.236885 0.480453 0.844386 +vn 0.476608 0.671621 -0.567186 +vn 0.265786 0.729972 -0.629658 +vn 0.300241 -0.033357 -0.953246 +vn -0.257790 0.380444 0.888119 +vn 0.049165 0.992737 0.109531 +vn 0.306406 0.062563 -0.949828 +vn -0.273019 0.291879 0.916623 +vn -0.075259 0.892026 0.445631 +vn 0.310221 0.176244 -0.934141 +vn -0.157018 0.739433 0.654622 +vn 0.309793 0.318613 -0.895810 +vn -0.206091 0.598498 0.774132 +vn 0.299600 0.502945 -0.810694 +vn 0.292428 -0.119358 -0.948790 +vn -0.283914 0.639729 0.714225 +vn 0.157903 0.536241 -0.829127 +vn 0.274606 -0.109653 -0.955260 +vn -0.292306 0.512894 0.807123 +vn 0.182501 0.935881 -0.301248 +vn 0.090060 0.742607 -0.663594 +vn 0.264290 -0.013825 -0.964324 +vn -0.293588 0.401959 0.867306 +vn -0.121921 0.992492 -0.006439 +vn 0.250252 0.091128 -0.963866 +vn -0.290963 0.302255 0.907712 +vn -0.211371 0.920133 0.329600 +vn 0.230537 0.212165 -0.949614 +vn -0.261330 0.782128 0.565630 +vn 0.201758 0.357799 -0.911710 +vn 0.157109 0.232185 -0.959868 +vn -0.356334 0.796319 0.488723 +vn 0.105411 0.376049 -0.920560 +vn -0.357402 0.660604 0.660146 +vn 0.037202 0.544359 -0.838008 +vn 0.257637 -0.103580 -0.960662 +vn -0.345653 0.531938 0.773003 +vn -0.008362 0.926206 -0.376843 +vn -0.051943 0.729331 -0.682150 +vn 0.230018 -0.001556 -0.973174 +vn -0.328257 0.415357 0.848323 +vn -0.260598 0.961241 -0.089969 +vn 0.197333 0.108432 -0.974303 +vn -0.308176 0.308756 0.899808 +vn -0.328745 0.914212 0.236793 +vn -0.158483 0.891140 -0.425092 +vn -0.374584 0.915433 -0.147099 +vn 0.149144 0.114780 -0.982116 +vn -0.324137 0.311350 0.893277 +vn -0.429548 0.887173 0.168432 +vn 0.091342 0.237709 -0.967009 +vn -0.441206 0.788568 0.428327 +vn 0.021363 0.376843 -0.926023 +vn -0.424818 0.663442 0.615894 +vn -0.064638 0.534104 -0.842921 +vn 0.242073 -0.101138 -0.964965 +vn -0.395276 0.537950 0.744530 +vn -0.167791 0.700797 -0.693319 +vn 0.198431 0.003418 -0.980102 +vn -0.360698 0.420545 0.832453 +vn -0.440077 0.531754 0.723563 +vn -0.279061 0.844997 -0.456160 +vn -0.264748 0.661702 -0.701437 +vn 0.170385 0.001251 -0.985351 +vn -0.389935 0.417707 0.820643 +vn -0.472060 0.862178 -0.183752 +vn 0.106632 0.110660 -0.988098 +vn -0.338359 0.310068 0.888424 +vn -0.517808 0.846583 0.122929 +vn 0.033998 0.229957 -0.972594 +vn -0.516709 0.764000 0.386303 +vn -0.050935 0.362682 -0.930509 +vn -0.485336 0.650594 0.584033 +vn -0.151006 0.509445 -0.847133 +vn 0.228248 -0.102268 -0.968200 +vn -0.538652 0.624134 0.565935 +vn -0.224677 0.472274 -0.852321 +vn 0.216559 -0.106845 -0.970397 +vn -0.479049 0.514359 0.711264 +vn -0.380108 0.792871 -0.476272 +vn -0.348430 0.613514 -0.708609 +vn 0.146611 -0.007843 -0.989135 +vn -0.415113 0.407239 0.813501 +vn -0.559313 0.803491 -0.203833 +vn 0.070589 0.096500 -0.992798 +vn -0.350505 0.305155 0.885433 +vn -0.597247 0.795984 0.098361 +vn -0.014618 0.209815 -0.977599 +vn -0.584063 0.725913 0.363140 +vn -0.112369 0.335002 -0.935453 +vn -0.054231 0.177770 -0.982543 +vn -0.670370 0.736045 0.093600 +vn -0.163396 0.294351 -0.941618 +vn -0.643910 0.675680 0.358867 +vn -0.287759 0.422712 -0.859340 +vn 0.127598 -0.023591 -0.991516 +vn -0.584277 0.585253 0.562151 +vn -0.468947 0.735588 -0.488845 +vn -0.422803 0.555620 -0.715873 +vn 0.041597 0.072756 -0.996460 +vn -0.511429 0.486648 0.708213 +vn -0.550737 0.671651 -0.495499 +vn -0.435621 0.389691 0.811365 +vn -0.640919 0.738456 -0.209418 +vn -0.629322 0.597919 -0.496384 +vn -0.084384 0.134068 -0.987365 +vn -0.360271 0.296823 0.884335 +vn -0.450880 0.365551 0.814264 +vn -0.720023 0.664296 -0.200598 +vn -0.204230 0.240364 -0.948943 +vn -0.738456 0.665487 0.108493 +vn -0.341441 0.359630 -0.868343 +vn -0.695944 0.613361 0.373333 +vn -0.490616 0.485641 -0.723472 +vn 0.207160 -0.114658 -0.971557 +vn 0.113773 -0.045656 -0.992431 +vn -0.621326 0.534745 0.572680 +vn 0.020203 0.039766 -0.998993 +vn -0.536363 0.449324 0.714408 +vn -0.648244 0.472793 0.596789 +vn -0.707297 0.509049 -0.490463 +vn 0.007019 -0.002045 -0.999969 +vn -0.552690 0.403119 0.729362 +vn -0.104495 0.078646 -0.991394 +vn -0.367504 0.285287 0.885159 +vn -0.460219 0.335429 0.821955 +vn -0.798212 0.576098 -0.175756 +vn -0.234352 0.172124 -0.956786 +vn -0.800958 0.581164 0.143803 +vn -0.385968 0.280496 -0.878811 +vn -0.738609 0.537919 0.406262 +vn -0.553392 0.399365 -0.730888 +vn 0.200323 -0.125614 -0.971618 +vn 0.105625 -0.073641 -0.991668 +vn -0.768639 0.447645 0.456893 +vn -0.611103 0.290201 -0.736412 +vn 0.196204 -0.139500 -0.970580 +vn 0.103458 -0.106906 -0.988861 +vn -0.662862 0.399701 0.633106 +vn -0.785638 0.396802 -0.474593 +vn 0.002594 -0.052187 -0.998627 +vn -0.559221 0.348979 0.751946 +vn -0.113620 0.011383 -0.993439 +vn -0.371868 0.270699 0.887906 +vn -0.463027 0.300119 0.833949 +vn -0.874722 0.466475 -0.131260 +vn -0.252510 0.088015 -0.963561 +vn -0.854793 0.478378 0.201025 +vn -0.420179 0.181463 -0.889096 +vn -0.892788 0.351787 0.281289 +vn -0.440870 0.057497 -0.895688 +vn -0.780847 0.341227 0.523240 +vn -0.660878 0.148442 -0.735649 +vn 0.195044 -0.156041 -0.968291 +vn 0.107578 -0.144688 -0.983581 +vn -0.662374 0.316202 0.679159 +vn -0.861446 0.248756 -0.442701 +vn 0.007538 -0.109897 -0.993896 +vn -0.554765 0.288247 0.780450 +vn -0.110446 -0.067598 -0.991577 +vn -0.373089 0.253456 0.892483 +vn -0.458846 0.260781 0.849361 +vn -0.943632 0.325144 -0.061708 +vn -0.256417 -0.013520 -0.966460 +vn -0.093448 -0.157414 -0.983093 +vn -0.371014 0.234107 0.898618 +vn -0.447462 0.218635 0.867153 +vn -0.989196 0.141240 0.038575 +vn -0.242653 -0.133396 -0.960875 +vn -0.902219 0.197851 0.383190 +vn -0.441908 -0.096377 -0.891842 +vn -0.768395 0.219398 0.601154 +vn -0.693655 -0.037599 -0.719291 +vn 0.196966 -0.174841 -0.964660 +vn 0.118107 -0.186041 -0.975402 +vn -0.644032 0.224311 0.731346 +vn 0.022462 -0.173925 -0.984497 +vn -0.538408 0.222785 0.812677 +vn -0.921995 0.049165 -0.384014 +vn -0.688955 -0.274575 -0.670766 +vn 0.047792 -0.242317 -0.968993 +vn -0.509842 0.155156 0.846126 +vn -0.935392 -0.209876 -0.284555 +vn -0.061007 -0.255684 -0.964812 +vn -0.365520 0.213202 0.906034 +vn -0.428877 0.175268 0.886196 +vn -0.981506 -0.086917 0.170507 +vn -0.206824 -0.269601 -0.940489 +vn -0.866146 0.020386 0.499344 +vn -0.412946 -0.281045 -0.866298 +vn -0.724845 0.087039 0.683370 +vn 0.202094 -0.195410 -0.959655 +vn 0.135166 -0.229621 -0.963836 +vn -0.606037 0.127842 0.785089 +vn -0.647816 -0.045106 0.760430 +vn -0.615253 -0.542711 -0.571703 +vn 0.210547 -0.217200 -0.953124 +vn 0.158788 -0.273598 -0.948637 +vn -0.548509 0.032929 0.835475 +vn 0.083712 -0.311838 -0.946410 +vn -0.469527 0.088870 0.878414 +vn -0.854671 -0.500107 -0.139195 +vn -0.012055 -0.357280 -0.933897 +vn -0.356548 0.191382 0.914457 +vn -0.403302 0.132633 0.905393 +vn -0.886258 -0.333201 0.321696 +vn -0.144810 -0.414136 -0.898587 +vn -0.771966 -0.162420 0.614521 +vn -0.341319 -0.484207 -0.805597 +vn -0.284280 0.205390 0.936460 +vn 0.284280 -0.205390 -0.936460 +vn -0.344005 0.169622 0.923490 +vn 0.222480 -0.239265 -0.945097 +vn -0.223060 -0.673574 -0.704642 +vn 0.254982 -0.277718 -0.926176 +vn -0.419538 0.028382 0.907254 +vn 0.222175 -0.351207 -0.909543 +vn 0.181555 -0.434950 -0.881924 +vn -0.328288 0.149602 0.932646 +vn -0.310617 0.132664 0.941221 +vn -0.543626 -0.162572 0.823389 +vn 0.273049 -0.291849 -0.916623 +vn -0.306406 -0.062563 0.949828 +vn -0.300241 0.033357 0.953246 +vn 0.157018 -0.739433 -0.654622 +vn -0.310221 -0.176244 0.934141 +vn -0.201758 -0.357799 0.911710 +vn -0.230537 -0.212165 0.949644 +vn 0.290994 -0.302255 -0.907712 +vn -0.182501 -0.935881 0.301248 +vn 0.293588 -0.401959 -0.867306 +vn -0.274575 0.109653 0.955260 +vn -0.157872 -0.536241 0.829127 +vn 0.283914 -0.639729 -0.714225 +vn -0.037202 -0.544359 0.838008 +vn -0.105441 -0.376049 0.920560 +vn 0.308176 -0.308756 -0.899808 +vn 0.051943 -0.729331 0.682150 +vn 0.345653 -0.531938 -0.773003 +vn 0.395306 -0.537919 -0.744530 +vn -0.242103 0.101138 0.964934 +vn 0.441206 -0.788568 -0.428358 +vn -0.149144 -0.114780 0.982116 +vn -0.228278 0.102268 0.968200 +vn 0.112339 -0.335002 0.935453 +vn -0.127598 0.023591 0.991516 +vn 0.468947 -0.735588 0.488845 +vn 0.695944 -0.613361 -0.373363 +vn 0.341472 -0.359630 0.868343 +vn 0.629322 -0.597919 0.496414 +vn 0.104495 -0.078646 0.991394 +vn -0.007019 0.002045 0.999969 +vn 0.553392 -0.399365 0.730918 +vn 0.800958 -0.581133 -0.143803 +vn 0.798212 -0.576098 0.175756 +vn 0.785638 -0.396802 0.474593 +vn -0.002564 0.052187 0.998627 +vn 0.420148 -0.181463 0.889096 +vn 0.660878 -0.148442 0.735649 +vn 0.780847 -0.341227 -0.523270 +vn 0.371014 -0.234107 -0.898618 +vn 0.538408 -0.222785 -0.812677 +vn 0.365520 -0.213172 -0.906034 +vn 0.428846 -0.175237 -0.886196 +vn 0.606006 -0.127842 -0.785089 +vn 0.412946 0.281045 0.866298 +vn 0.356517 -0.191382 -0.914457 +vn -0.210517 0.217200 0.953124 +vn 0.647816 0.045106 -0.760430 +vn 0.627033 0.321024 -0.709708 +vn 0.344005 -0.169652 -0.923490 +vn 0.328288 -0.149602 -0.932646 +vn -0.222449 0.239265 0.945097 +vn -0.222144 0.351238 0.909543 +vn 0.426405 0.254494 -0.867977 +vn 0.265786 0.729972 -0.629627 +vn 0.049165 0.992737 0.109500 +vn -0.273049 0.291879 0.916623 +vn 0.310251 0.176244 -0.934141 +vn -0.283914 0.639729 0.714194 +vn 0.157872 0.536241 -0.829127 +vn 0.182501 0.935881 -0.301279 +vn 0.090030 0.742607 -0.663594 +vn -0.293588 0.401959 0.867275 +vn 0.250221 0.091128 -0.963866 +vn 0.201758 0.357830 -0.911710 +vn -0.356365 0.796319 0.488723 +vn 0.105441 0.376049 -0.920560 +vn 0.257668 -0.103580 -0.960631 +vn -0.051943 0.729362 -0.682150 +vn 0.197363 0.108432 -0.974303 +vn -0.324107 0.311350 0.893277 +vn -0.424818 0.663442 0.615925 +vn 0.242103 -0.101138 -0.964934 +vn -0.395306 0.537950 0.744530 +vn -0.360729 0.420545 0.832453 +vn -0.440046 0.531754 0.723563 +vn -0.389935 0.417707 0.820612 +vn -0.338359 0.310068 0.888455 +vn 0.216529 -0.106845 -0.970397 +vn -0.350475 0.305155 0.885433 +vn -0.112339 0.335002 -0.935453 +vn 0.127567 -0.023591 -0.991516 +vn -0.629322 0.597919 -0.496414 +vn -0.360271 0.296854 0.884335 +vn 0.006989 -0.002045 -0.999969 +vn -0.798212 0.576128 -0.175756 +vn -0.553362 0.399365 -0.730918 +vn -0.768670 0.447645 0.456862 +vn -0.854823 0.478378 0.201025 +vn -0.420179 0.181494 -0.889096 +vn -0.660878 0.148473 -0.735649 +vn -0.662343 0.316202 0.679159 +vn -0.110446 -0.067568 -0.991577 +vn -0.538438 0.222785 0.812647 +vn -0.365520 0.213172 0.906034 +vn -0.428846 0.175268 0.886196 +vn -0.412915 -0.281045 -0.866298 +vn -0.606006 0.127842 0.785089 +vn -0.615253 -0.542711 -0.571734 +vn 0.158818 -0.273598 -0.948637 +vn -0.403272 0.132633 0.905393 +vn 0.222480 -0.239296 -0.945097 +usemtl SkinColor +s 1 +f 2417//1711 2416//1712 2431//1713 +f 2412//1714 2411//1715 2426//1716 +f 2423//1717 2422//1718 2438//1719 +f 2418//1720 2417//1711 2432//1721 +f 2413//1722 2412//1714 2427//1723 +f 2424//1724 2423//1717 2439//1725 +f 2419//1726 2418//1720 2433//1727 +f 2414//1728 2413//1722 2428//1729 +f 2425//1730 2424//1724 2440//1731 +f 2420//1732 2419//1726 2435//1733 +f 2415//1734 2414//1728 2429//1735 +f 2421//1736 2420//1732 2436//1737 +f 2416//1712 2415//1734 2430//1738 +f 2422//1718 2421//1736 2437//1739 +f 2432//1721 2431//1713 2446//1740 +f 2427//1723 2426//1716 2441//1741 +f 2438//1719 2437//1739 2453//1742 +f 2433//1727 2432//1721 2447//1743 +f 2428//1729 2427//1723 2442//1744 +f 2439//1725 2438//1719 2454//1745 +f 2434//1746 2433//1727 2449//1747 +f 2429//1735 2428//1729 2443//1748 +f 2440//1731 2439//1725 2455//1749 +f 2435//1733 2434//1746 2450//1750 +f 2430//1738 2429//1735 2444//1751 +f 2436//1737 2435//1733 2451//1752 +f 2431//1713 2430//1738 2445//1753 +f 2437//1739 2436//1737 2452//1754 +f 2451//1752 2450//1750 2466//1755 +f 2446//1740 2445//1753 2460//1756 +f 2452//1754 2451//1752 2467//1757 +f 2447//1743 2446//1740 2461//1758 +f 2442//1744 2441//1741 2456//1759 +f 2453//1742 2452//1754 2468//1760 +f 2448//1761 2447//1743 2462//1762 +f 2443//1748 2442//1744 2457//1763 +f 2454//1745 2453//1742 2469//1764 +f 2449//1747 2448//1761 2464//1765 +f 2444//1751 2443//1748 2458//1766 +f 2455//1749 2454//1745 2470//1767 +f 2450//1750 2449//1747 2465//1768 +f 2445//1753 2444//1751 2459//1769 +f 2470//1767 2469//1764 2485//1770 +f 2465//1768 2464//1765 2480//1771 +f 2460//1756 2459//1769 2474//1772 +f 2466//1755 2465//1768 2481//1773 +f 2461//1758 2460//1756 2475//1774 +f 2467//1757 2466//1755 2482//1775 +f 2462//1762 2461//1758 2476//1776 +f 2457//1763 2456//1759 2471//1777 +f 2468//1760 2467//1757 2483//1778 +f 2463//1779 2462//1762 2477//1780 +f 2458//1766 2457//1763 2472//1781 +f 2469//1764 2468//1760 2484//1782 +f 2464//1765 2463//1779 2479//1783 +f 2459//1769 2458//1766 2473//1784 +f 2473//1784 2472//1781 2487//1785 +f 2484//1782 2483//1778 2499//1786 +f 2479//1783 2478//1787 2494//1788 +f 2474//1772 2473//1784 2488//1789 +f 2485//1770 2484//1782 2500//1790 +f 2480//1771 2479//1783 2495//1791 +f 2475//1774 2474//1772 2489//1792 +f 2481//1773 2480//1771 2496//1793 +f 2476//1776 2475//1774 2490//1794 +f 2482//1775 2481//1773 2497//1795 +f 2477//1780 2476//1776 2491//1796 +f 2472//1781 2471//1777 2486//1797 +f 2483//1778 2482//1775 2498//1798 +f 2478//1787 2477//1780 2492//1799 +f 2492//1799 2491//1796 2506//1800 +f 2487//1785 2486//1797 2501//1801 +f 2498//1798 2497//1795 2513//1802 +f 2493//1803 2492//1799 2507//1804 +f 2488//1789 2487//1785 2502//1805 +f 2499//1786 2498//1798 2514//1806 +f 2494//1788 2493//1803 2509//1807 +f 2489//1792 2488//1789 2503//1808 +f 2500//1790 2499//1786 2515//1809 +f 2495//1791 2494//1788 2510//1810 +f 2490//1794 2489//1792 2504//1811 +f 2496//1793 2495//1791 2511//1812 +f 2491//1796 2490//1794 2505//1813 +f 2497//1795 2496//1793 2512//1814 +f 2511//1812 2510//1810 2526//1815 +f 2506//1800 2505//1813 2520//1816 +f 2512//1814 2511//1812 2527//1817 +f 2507//1804 2506//1800 2521//1818 +f 2502//1805 2501//1801 2516//1819 +f 2513//1802 2512//1814 2528//1820 +f 2508//1821 2507//1804 2522//1822 +f 2503//1808 2502//1805 2517//1823 +f 2514//1806 2513//1802 2529//1824 +f 2509//1807 2508//1821 2524//1825 +f 2504//1811 2503//1808 2518//1826 +f 2515//1809 2514//1806 2530//1827 +f 2510//1810 2509//1807 2525//1828 +f 2505//1813 2504//1811 2519//1829 +f 2530//1827 2529//1824 2544//1830 +f 2525//1828 2524//1825 2540//1831 +f 2520//1816 2519//1829 2535//1832 +f 2526//1815 2525//1828 2541//1833 +f 2521//1818 2520//1816 2536//1834 +f 2527//1817 2526//1815 2542//1835 +f 2522//1822 2521//1818 2537//1836 +f 2517//1823 2516//1819 2532//1837 +f 2528//1820 2527//1817 2542//1835 +f 2523//1838 2522//1822 2538//1839 +f 2518//1826 2517//1823 2533//1840 +f 2529//1824 2528//1820 2543//1841 +f 2524//1825 2523//1838 2539//1842 +f 2519//1829 2518//1826 2534//1843 +f 2544//1830 2543//1841 2558//1844 +f 2539//1842 2538//1839 2554//1845 +f 2534//1843 2533//1840 2549//1846 +f 2545//1847 2544//1830 2559//1848 +f 2540//1831 2539//1842 2554//1845 +f 2535//1832 2534//1843 2550//1849 +f 2541//1833 2540//1831 2555//1850 +f 2536//1834 2535//1832 2551//1851 +f 2542//1835 2541//1833 2556//1852 +f 2537//1836 2536//1834 2552//1853 +f 2532//1837 2531//1854 2547//1855 +f 2543//1841 2542//1835 2557//1856 +f 2538//1839 2537//1836 2553//1857 +f 2533//1840 2532//1837 2548//1858 +f 2547//1855 2546//1859 2562//1860 +f 2558//1844 2557//1856 2572//1861 +f 2553//1857 2552//1853 2568//1862 +f 2548//1858 2547//1855 2563//1863 +f 2559//1848 2558//1844 2573//1864 +f 2554//1845 2553//1857 2568//1862 +f 2549//1846 2548//1858 2564//1865 +f 2560//1866 2559//1848 2574//1867 +f 2555//1850 2554//1845 2569//1868 +f 2550//1849 2549//1846 2565//1869 +f 2556//1852 2555//1850 2570//1870 +f 2551//1851 2550//1849 2566//1871 +f 2557//1856 2556//1852 2571//1872 +f 2552//1853 2551//1851 2567//1873 +f 2566//1871 2565//1869 2581//1874 +f 2572//1861 2571//1872 2586//1875 +f 2567//1873 2566//1871 2582//1876 +f 2562//1860 2561//1877 2577//1878 +f 2573//1864 2572//1861 2587//1879 +f 2568//1862 2567//1873 2583//1880 +f 2563//1863 2562//1860 2578//1881 +f 2574//1867 2573//1864 2588//1882 +f 2569//1868 2568//1862 2583//1880 +f 2564//1865 2563//1863 2579//1883 +f 2575//1884 2574//1867 2589//1885 +f 2570//1870 2569//1868 2584//1886 +f 2565//1869 2564//1865 2580//1887 +f 2571//1872 2570//1870 2585//1888 +f 2585//1888 2584//1886 2599//1889 +f 2580//1887 2579//1883 2595//1890 +f 2586//1875 2585//1888 2600//1891 +f 2581//1874 2580//1887 2596//1892 +f 2587//1879 2586//1875 2601//1893 +f 2582//1876 2581//1874 2597//1894 +f 2577//1878 2576//1895 2592//1896 +f 2588//1882 2587//1879 2602//1897 +f 2583//1880 2582//1876 2598//1898 +f 2578//1881 2577//1878 2593//1899 +f 2589//1885 2588//1882 2603//1900 +f 2584//1886 2583//1880 2598//1898 +f 2579//1883 2578//1881 2594//1901 +f 2590//1902 2589//1885 2604//1903 +f 2604//1903 2603//1900 2618//1904 +f 2599//1889 2598//1898 2614//1905 +f 2594//1901 2593//1899 2609//1906 +f 2605//1907 2604//1903 2619//1908 +f 2600//1891 2599//1889 2614//1905 +f 2595//1890 2594//1901 2610//1909 +f 2601//1893 2600//1891 2615//1910 +f 2596//1892 2595//1890 2611//1911 +f 2602//1897 2601//1893 2616//1912 +f 2597//1894 2596//1892 2612//1913 +f 2592//1896 2591//1914 2607//1915 +f 2603//1900 2602//1897 2617//1916 +f 2598//1898 2597//1894 2613//1917 +f 2593//1899 2592//1896 2608//1918 +f 2607//1915 2606//1919 2622//1920 +f 2618//1904 2617//1916 2632//1921 +f 2613//1917 2612//1913 2628//1922 +f 2608//1918 2607//1915 2623//1923 +f 2619//1908 2618//1904 2633//1924 +f 2614//1905 2613//1917 2629//1925 +f 2609//1906 2608//1918 2624//1926 +f 2620//1927 2619//1908 2634//1928 +f 2615//1910 2614//1905 2629//1925 +f 2610//1909 2609//1906 2625//1929 +f 2616//1912 2615//1910 2630//1930 +f 2611//1911 2610//1909 2626//1931 +f 2617//1916 2616//1912 2631//1932 +f 2612//1913 2611//1911 2627//1933 +f 2626//1931 2625//1929 2641//1934 +f 2632//1921 2631//1932 2646//1935 +f 2627//1933 2626//1931 2642//1936 +f 2622//1920 2621//1937 2637//1938 +f 2633//1924 2632//1921 2647//1939 +f 2628//1922 2627//1933 2643//1940 +f 2623//1923 2622//1920 2638//1941 +f 2634//1928 2633//1924 2648//1942 +f 2629//1925 2628//1922 2644//1943 +f 2624//1926 2623//1923 2639//1944 +f 2635//1945 2634//1928 2649//1946 +f 2630//1930 2629//1925 2644//1943 +f 2625//1929 2624//1926 2640//1947 +f 2631//1932 2630//1930 2645//1948 +f 2645//1948 2644//1943 2660//1949 +f 2640//1947 2639//1944 2655//1950 +f 2646//1935 2645//1948 2661//1951 +f 2641//1934 2640//1947 2656//1952 +f 2647//1939 2646//1935 2662//1953 +f 2642//1936 2641//1934 2657//1954 +f 2637//1938 2636//1955 2651//1956 +f 2648//1942 2647//1939 2663//1957 +f 2643//1940 2642//1936 2658//1958 +f 2638//1941 2637//1938 2653//1959 +f 2649//1946 2648//1942 2664//1960 +f 2644//1943 2643//1940 2659//1961 +f 2639//1944 2638//1941 2654//1962 +f 2650//1963 2649//1946 2665//1964 +f 2664//1960 2663//1957 2679//1965 +f 2659//1961 2658//1958 2674//1966 +f 2654//1962 2653//1959 2668//1967 +f 2665//1964 2664//1960 2680//1968 +f 2660//1949 2659//1961 2675//1969 +f 2655//1950 2654//1962 2669//1970 +f 2661//1951 2660//1949 2676//1971 +f 2656//1952 2655//1950 2670//1972 +f 2662//1953 2661//1951 2677//1973 +f 2657//1954 2656//1952 2671//1974 +f 2652//1975 2651//1956 2666//1976 +f 2663//1957 2662//1953 2678//1977 +f 2658//1958 2657//1954 2673//1978 +f 2653//1959 2652//1975 2667//1979 +f 2678//1977 2677//1973 2693//1980 +f 2673//1978 2672//1981 2687//1982 +f 2668//1967 2667//1979 2682//1983 +f 2679//1965 2678//1977 2694//1984 +f 2674//1966 2673//1978 2689//1985 +f 2669//1970 2668//1967 2683//1986 +f 2680//1968 2679//1965 2695//1987 +f 2675//1969 2674//1966 2690//1988 +f 2670//1972 2669//1970 2684//1989 +f 2676//1971 2675//1969 2691//1990 +f 2671//1974 2670//1972 2685//1991 +f 2677//1973 2676//1971 2692//1992 +f 2672//1981 2671//1974 2686//1993 +f 2667//1979 2666//1976 2681//1994 +f 2692//1992 2691//1990 2707//1995 +f 2687//1982 2686//1993 2701//1996 +f 2682//1983 2681//1994 2696//1997 +f 2693//1980 2692//1992 2708//1998 +f 2688//1999 2687//1982 2702//2000 +f 2683//1986 2682//1983 2697//2001 +f 2694//1984 2693//1980 2709//2002 +f 2689//1985 2688//1999 2704//2003 +f 2684//1989 2683//1986 2698//2004 +f 2695//1987 2694//1984 2710//2005 +f 2690//1988 2689//1985 2705//2006 +f 2685//1991 2684//1989 2699//2007 +f 2691//1990 2690//1988 2706//2008 +f 2686//1993 2685//1991 2700//2009 +f 2700//2009 2699//2007 2714//2010 +f 2706//2008 2705//2006 2721//2011 +f 2701//1996 2700//2009 2715//2012 +f 2707//1995 2706//2008 2722//2013 +f 2702//2000 2701//1996 2716//2014 +f 2697//2001 2696//1997 2711//2015 +f 2708//1998 2707//1995 2723//2016 +f 2703//2017 2702//2000 2717//2018 +f 2698//2004 2697//2001 2712//2019 +f 2709//2002 2708//1998 2724//2020 +f 2704//2003 2703//2017 2719//2021 +f 2699//2007 2698//2004 2713//2022 +f 2710//2005 2709//2002 2725//2023 +f 2705//2006 2704//2003 2720//2024 +f 2719//2021 2718//2025 2734//2026 +f 2714//2010 2713//2022 2728//2027 +f 2725//2023 2724//2020 2740//2028 +f 2720//2024 2719//2021 2735//2029 +f 2715//2012 2714//2010 2729//2030 +f 2721//2011 2720//2024 2736//2031 +f 2716//2014 2715//2012 2730//2032 +f 2722//2013 2721//2011 2737//2033 +f 2717//2018 2716//2014 2731//2034 +f 2712//2019 2711//2015 2726//2035 +f 2723//2016 2722//2013 2738//2036 +f 2718//2025 2717//2018 2732//2037 +f 2713//2022 2712//2019 2727//2038 +f 2724//2020 2723//2016 2739//2039 +f 2738//2036 2737//2033 2754//2040 +f 2733//2041 2732//2037 2748//2042 +f 2728//2027 2727//2038 2743//2043 +f 2739//2039 2738//2036 2755//2044 +f 2734//2026 2733//2041 2750//2045 +f 2729//2030 2728//2027 2744//2046 +f 2740//2028 2739//2039 2756//2047 +f 2735//2029 2734//2026 2751//2048 +f 2730//2032 2729//2030 2745//2049 +f 2736//2031 2735//2029 2752//2050 +f 2731//2034 2730//2032 2746//2051 +f 2737//2033 2736//2031 2753//2052 +f 2732//2037 2731//2034 2747//2053 +f 2727//2038 2726//2035 2742//2054 +f 2753//2052 2752//2050 2768//2055 +f 2748//2042 2747//2053 2762//2056 +f 2743//2043 2742//2054 2757//2057 +f 2754//2040 2753//2052 2769//2058 +f 2749//2059 2748//2042 2763//2060 +f 2744//2046 2743//2043 2758//2061 +f 2755//2044 2754//2040 2770//2062 +f 2750//2045 2749//2059 2765//2063 +f 2745//2049 2744//2046 2759//2064 +f 2756//2047 2755//2044 2771//2065 +f 2751//2048 2750//2045 2766//2066 +f 2746//2051 2745//2049 2760//2067 +f 2752//2050 2751//2048 2767//2068 +f 2747//2053 2746//2051 2761//2069 +f 2761//2069 2760//2067 2775//2070 +f 2767//2068 2766//2066 2781//2071 +f 2762//2056 2761//2069 2776//2072 +f 2768//2055 2767//2068 2782//2073 +f 2763//2060 2762//2056 2777//2074 +f 2758//2061 2757//2057 2773//2075 +f 2769//2058 2768//2055 2783//2076 +f 2764//2077 2763//2060 2778//2078 +f 2759//2064 2758//2061 2774//2079 +f 2770//2062 2769//2058 2784//2080 +f 2765//2063 2764//2077 2779//2081 +f 2760//2067 2759//2064 2775//2070 +f 2771//2065 2770//2062 2785//2082 +f 2766//2066 2765//2063 2780//2083 +f 2780//2083 2779//2081 2794//2084 +f 2775//2070 2774//2079 2790//2085 +f 2786//2086 2785//2082 2800//2087 +f 2781//2071 2780//2083 2795//2088 +f 2776//2072 2775//2070 2791//2089 +f 2782//2073 2781//2071 2796//2090 +f 2777//2074 2776//2072 2792//2091 +f 2783//2076 2782//2073 2797//2092 +f 2778//2078 2777//2074 2793//2093 +f 2773//2075 2772//2094 2788//2095 +f 2784//2080 2783//2076 2798//2096 +f 2779//2081 2778//2078 2793//2093 +f 2774//2079 2773//2075 2789//2097 +f 2785//2082 2784//2080 2799//2098 +f 2799//2098 2798//2096 2813//2099 +f 2794//2084 2793//2093 2809//2100 +f 2789//2097 2788//2095 2804//2101 +f 2800//2087 2799//2098 2814//2102 +f 2795//2088 2794//2084 2809//2100 +f 2790//2085 2789//2097 2805//2103 +f 2801//2104 2800//2087 2815//2105 +f 2796//2090 2795//2088 2810//2106 +f 2791//2089 2790//2085 2806//2107 +f 2797//2092 2796//2090 2811//2108 +f 2792//2091 2791//2089 2807//2109 +f 2798//2096 2797//2092 2812//2110 +f 2793//2093 2792//2091 2808//2111 +f 2788//2095 2787//2112 2803//2113 +f 2813//2099 2812//2110 2827//2114 +f 2808//2111 2807//2109 2823//2115 +f 2803//2113 2802//2116 2818//2117 +f 2814//2102 2813//2099 2828//2118 +f 2809//2100 2808//2111 2824//2119 +f 2804//2101 2803//2113 2819//2120 +f 2815//2105 2814//2102 2829//2121 +f 2810//2106 2809//2100 2824//2119 +f 2805//2103 2804//2101 2820//2122 +f 2816//2123 2815//2105 2830//2124 +f 2811//2108 2810//2106 2825//2125 +f 2806//2107 2805//2103 2821//2126 +f 2812//2110 2811//2108 2826//2127 +f 2807//2109 2806//2107 2822//2128 +f 2827//2114 2826//2127 2841//2129 +f 2822//2128 2821//2126 2837//2130 +f 2828//2118 2827//2114 2842//2131 +f 2823//2115 2822//2128 2838//2132 +f 2818//2117 2817//2133 2833//2134 +f 2829//2121 2828//2118 2843//2135 +f 2824//2119 2823//2115 2839//2136 +f 2819//2120 2818//2117 2834//2137 +f 2830//2124 2829//2121 2844//2138 +f 2825//2125 2824//2119 2839//2136 +f 2820//2122 2819//2120 2835//2139 +f 2831//2140 2830//2124 2845//2141 +f 2826//2127 2825//2125 2840//2142 +f 2821//2126 2820//2122 2836//2143 +f 2835//2139 2834//2137 2850//2144 +f 2846//2145 2845//2141 2860//2146 +f 2841//2129 2840//2142 2855//2147 +f 2836//2143 2835//2139 2851//2148 +f 2842//2131 2841//2129 2856//2149 +f 2837//2130 2836//2143 2852//2150 +f 2843//2135 2842//2131 2857//2151 +f 2838//2132 2837//2130 2853//2152 +f 2833//2134 2832//2153 2848//2154 +f 2844//2138 2843//2135 2858//2155 +f 2839//2136 2838//2132 2853//2152 +f 2834//2137 2833//2134 2849//2156 +f 2845//2141 2844//2138 2859//2157 +f 2840//2142 2839//2136 2854//2158 +f 2854//2158 2853//2152 2869//2159 +f 2849//2156 2848//2154 2865//2160 +f 2860//2146 2859//2157 2875//2161 +f 2855//2147 2854//2158 2870//2162 +f 2850//2144 2849//2156 2866//2163 +f 2861//2164 2860//2146 2876//2165 +f 2856//2149 2855//2147 2871//2166 +f 2851//2148 2850//2144 2867//2167 +f 2857//2151 2856//2149 2872//2168 +f 2852//2150 2851//2148 2868//2169 +f 2858//2155 2857//2151 2873//2170 +f 2853//2152 2852//2150 2869//2159 +f 2848//2154 2847//2171 2864//2172 +f 2859//2157 2858//2155 2874//2173 +f 2874//2173 2873//2170 2888//2174 +f 2869//2159 2868//2169 2884//2175 +f 2864//2172 2863//2176 2879//2177 +f 2875//2161 2874//2173 2889//2178 +f 2870//2162 2869//2159 2884//2175 +f 2865//2160 2864//2172 2880//2179 +f 2876//2165 2875//2161 2890//2180 +f 2871//2166 2870//2162 2885//2181 +f 2866//2163 2865//2160 2881//2182 +f 2877//2183 2876//2165 2891//2184 +f 2872//2168 2871//2166 2886//2185 +f 2867//2167 2866//2163 2882//2186 +f 2873//2170 2872//2168 2887//2187 +f 2868//2169 2867//2167 2883//2188 +f 2741//2189 2425//1730 2440//1731 +f 2411//1715 2862//2190 2426//1716 +f 2741//2189 2440//1731 2455//1749 +f 2426//1716 2862//2190 2441//1741 +f 2441//1741 2862//2190 2456//1759 +f 2741//2189 2455//1749 2470//1767 +f 2741//2189 2470//1767 2485//1770 +f 2456//1759 2862//2190 2471//1777 +f 2741//2189 2485//1770 2500//1790 +f 2471//1777 2862//2190 2486//1797 +f 2741//2189 2500//1790 2515//1809 +f 2486//1797 2862//2190 2501//1801 +f 2501//1801 2862//2190 2516//1819 +f 2741//2189 2515//1809 2530//1827 +f 2741//2189 2530//1827 2545//1847 +f 2516//1819 2862//2190 2531//1854 +f 2741//2189 2545//1847 2560//1866 +f 2531//1854 2862//2190 2546//1859 +f 2741//2189 2560//1866 2575//1884 +f 2546//1859 2862//2190 2561//1877 +f 2561//1877 2862//2190 2576//1895 +f 2741//2189 2575//1884 2590//1902 +f 2741//2189 2590//1902 2605//1907 +f 2576//1895 2862//2190 2591//1914 +f 2741//2189 2605//1907 2620//1927 +f 2591//1914 2862//2190 2606//1919 +f 2741//2189 2620//1927 2635//1945 +f 2606//1919 2862//2190 2621//1937 +f 2621//1937 2862//2190 2636//1955 +f 2741//2189 2635//1945 2650//1963 +f 2741//2189 2650//1963 2665//1964 +f 2636//1955 2862//2190 2651//1956 +f 2741//2189 2665//1964 2680//1968 +f 2651//1956 2862//2190 2666//1976 +f 2741//2189 2680//1968 2695//1987 +f 2666//1976 2862//2190 2681//1994 +f 2681//1994 2862//2190 2696//1997 +f 2741//2189 2695//1987 2710//2005 +f 2741//2189 2710//2005 2725//2023 +f 2696//1997 2862//2190 2711//2015 +f 2741//2189 2725//2023 2740//2028 +f 2711//2015 2862//2190 2726//2035 +f 2741//2189 2740//2028 2756//2047 +f 2726//2035 2862//2190 2742//2054 +f 2742//2054 2862//2190 2757//2057 +f 2741//2189 2756//2047 2771//2065 +f 2741//2189 2771//2065 2786//2086 +f 2757//2057 2862//2190 2772//2094 +f 2741//2189 2786//2086 2801//2104 +f 2772//2094 2862//2190 2787//2112 +f 2741//2189 2801//2104 2816//2123 +f 2787//2112 2862//2190 2802//2116 +f 2741//2189 2816//2123 2831//2140 +f 2802//2116 2862//2190 2817//2133 +f 2741//2189 2831//2140 2846//2145 +f 2817//2133 2862//2190 2832//2153 +f 2741//2189 2846//2145 2861//2164 +f 2832//2153 2862//2190 2847//2171 +f 2741//2189 2861//2164 2877//2183 +f 2847//2171 2862//2190 2863//2176 +f 2741//2189 2877//2183 2892//2191 +f 2863//2176 2862//2190 2878//2192 +f 2741//2189 2892//2191 2425//1730 +f 2888//2174 2887//2187 2420//1732 +f 2883//2188 2882//2186 2415//1734 +f 2878//2192 2862//2190 2411//1715 +f 2889//2178 2888//2174 2421//1736 +f 2884//2175 2883//2188 2416//1712 +f 2879//2177 2878//2192 2411//1715 +f 2890//2180 2889//2178 2422//1718 +f 2885//2181 2884//2175 2417//1711 +f 2880//2179 2879//2177 2412//1714 +f 2891//2184 2890//2180 2423//1717 +f 2886//2185 2885//2181 2418//1720 +f 2881//2182 2880//2179 2413//1722 +f 2892//2191 2891//2184 2425//1730 +f 2887//2187 2886//2185 2419//1726 +f 2882//2186 2881//2182 2414//1728 +f 2899//1711 2898//2193 2913//1713 +f 2894//1714 2893//1715 2908//2194 +f 2905//2195 2904//1718 2920//1719 +f 2900//1720 2899//1711 2914//1721 +f 2895//1722 2894//1714 2909//2196 +f 2906//1724 2905//2195 2921//1725 +f 2901//1726 2900//1720 2915//1727 +f 2896//1728 2895//1722 2910//2197 +f 2907//2198 2906//1724 2922//2199 +f 2902//1732 2901//1726 2917//1733 +f 2897//1734 2896//1728 2911//1735 +f 2903//2200 2902//1732 2918//1737 +f 2898//2193 2897//1734 2912//1738 +f 2904//1718 2903//2200 2919//1739 +f 2914//1721 2913//1713 2928//1740 +f 2909//2196 2908//2194 2923//2201 +f 2920//1719 2919//1739 2935//2202 +f 2915//1727 2914//1721 2929//1743 +f 2910//2197 2909//2196 2924//1744 +f 2921//1725 2920//1719 2936//2203 +f 2916//1746 2915//1727 2931//1747 +f 2911//1735 2910//2197 2925//1748 +f 2922//2199 2921//1725 2937//1749 +f 2917//1733 2916//1746 2932//1750 +f 2912//1738 2911//1735 2926//1751 +f 2918//1737 2917//1733 2933//1752 +f 2913//1713 2912//1738 2927//2204 +f 2919//1739 2918//1737 2934//2205 +f 2933//1752 2932//1750 2948//2206 +f 2928//1740 2927//2204 2942//1756 +f 2934//2205 2933//1752 2949//2207 +f 2929//1743 2928//1740 2943//1758 +f 2924//1744 2923//2201 2938//2208 +f 2935//2202 2934//2205 2950//1760 +f 2930//2209 2929//1743 2944//1762 +f 2925//1748 2924//1744 2939//2210 +f 2936//2203 2935//2202 2951//1764 +f 2931//1747 2930//2209 2946//1765 +f 2926//1751 2925//1748 2940//1766 +f 2937//1749 2936//2203 2952//2211 +f 2932//1750 2931//1747 2947//2212 +f 2927//2204 2926//1751 2941//2213 +f 2952//2211 2951//1764 2967//1770 +f 2947//2212 2946//1765 2962//2214 +f 2942//1756 2941//2213 2956//1772 +f 2948//2206 2947//2212 2963//2215 +f 2943//1758 2942//1756 2957//1774 +f 2949//2207 2948//2206 2964//1775 +f 2944//1762 2943//1758 2958//1776 +f 2939//2210 2938//2208 2953//2216 +f 2950//1760 2949//2207 2965//1778 +f 2945//1779 2944//1762 2959//1780 +f 2940//1766 2939//2210 2954//1781 +f 2951//1764 2950//1760 2966//1782 +f 2946//1765 2945//1779 2961//2217 +f 2941//2213 2940//1766 2955//2218 +f 2955//2218 2954//1781 2969//1785 +f 2966//1782 2965//1778 2981//1786 +f 2961//2217 2960//1787 2976//1788 +f 2956//1772 2955//2218 2970//2219 +f 2967//1770 2966//1782 2982//2220 +f 2962//2214 2961//2217 2977//1791 +f 2957//1774 2956//1772 2971//1792 +f 2963//2215 2962//2214 2978//1793 +f 2958//1776 2957//1774 2972//2221 +f 2964//1775 2963//2215 2979//1795 +f 2959//1780 2958//1776 2973//1796 +f 2954//1781 2953//2216 2968//1797 +f 2965//1778 2964//1775 2980//2222 +f 2960//1787 2959//1780 2974//1799 +f 2974//1799 2973//1796 2988//1800 +f 2969//1785 2968//1797 2983//1801 +f 2980//2222 2979//1795 2995//1802 +f 2975//1803 2974//1799 2989//1804 +f 2970//2219 2969//1785 2984//1805 +f 2981//1786 2980//2222 2996//1806 +f 2976//1788 2975//1803 2991//1807 +f 2971//1792 2970//2219 2985//1808 +f 2982//2220 2981//1786 2997//2223 +f 2977//1791 2976//1788 2992//1810 +f 2972//2221 2971//1792 2986//1811 +f 2978//1793 2977//1791 2993//1812 +f 2973//1796 2972//2221 2987//1813 +f 2979//1795 2978//1793 2994//1814 +f 2993//1812 2992//1810 3008//2224 +f 2988//1800 2987//1813 3002//1816 +f 2994//1814 2993//1812 3009//1817 +f 2989//1804 2988//1800 3003//1818 +f 2984//1805 2983//1801 2998//1819 +f 2995//1802 2994//1814 3010//1820 +f 2990//1821 2989//1804 3004//1822 +f 2985//1808 2984//1805 2999//1823 +f 2996//1806 2995//1802 3011//1824 +f 2991//1807 2990//1821 3006//1825 +f 2986//1811 2985//1808 3000//1826 +f 2997//2223 2996//1806 3012//1827 +f 2992//1810 2991//1807 3007//1828 +f 2987//1813 2986//1811 3001//1829 +f 3012//1827 3011//1824 3026//2225 +f 3007//1828 3006//1825 3022//1831 +f 3002//1816 3001//1829 3017//1832 +f 3008//2224 3007//1828 3023//1833 +f 3003//1818 3002//1816 3018//1834 +f 3009//1817 3008//2224 3024//1835 +f 3004//1822 3003//1818 3019//1836 +f 2999//1823 2998//1819 3014//1837 +f 3010//1820 3009//1817 3024//1835 +f 3005//2226 3004//1822 3020//1839 +f 3000//1826 2999//1823 3015//1840 +f 3011//1824 3010//1820 3025//1841 +f 3006//1825 3005//2226 3021//1842 +f 3001//1829 3000//1826 3016//1843 +f 3026//2225 3025//1841 3040//1844 +f 3021//1842 3020//1839 3036//1845 +f 3016//1843 3015//1840 3031//1846 +f 3027//1847 3026//2225 3041//1848 +f 3022//1831 3021//1842 3036//1845 +f 3017//1832 3016//1843 3032//2227 +f 3023//1833 3022//1831 3037//2228 +f 3018//1834 3017//1832 3033//1851 +f 3024//1835 3023//1833 3038//1852 +f 3019//1836 3018//1834 3034//1853 +f 3014//1837 3013//1854 3029//1855 +f 3025//1841 3024//1835 3039//1856 +f 3020//1839 3019//1836 3035//2229 +f 3015//1840 3014//1837 3030//1858 +f 3029//1855 3028//1859 3044//1860 +f 3040//1844 3039//1856 3054//2230 +f 3035//2229 3034//1853 3050//1862 +f 3030//1858 3029//1855 3045//1863 +f 3041//1848 3040//1844 3055//2231 +f 3036//1845 3035//2229 3050//1862 +f 3031//1846 3030//1858 3046//1865 +f 3042//1866 3041//1848 3056//1867 +f 3037//2228 3036//1845 3051//2232 +f 3032//2227 3031//1846 3047//1869 +f 3038//1852 3037//2228 3052//1870 +f 3033//1851 3032//2227 3048//2233 +f 3039//1856 3038//1852 3053//1872 +f 3034//1853 3033//1851 3049//2234 +f 3048//2233 3047//1869 3063//1874 +f 3054//2230 3053//1872 3068//1875 +f 3049//2234 3048//2233 3064//1876 +f 3044//1860 3043//1877 3059//1878 +f 3055//2231 3054//2230 3069//1879 +f 3050//1862 3049//2234 3065//2235 +f 3045//1863 3044//1860 3060//1881 +f 3056//1867 3055//2231 3070//2236 +f 3051//2232 3050//1862 3065//2235 +f 3046//1865 3045//1863 3061//1883 +f 3057//1884 3056//1867 3071//1885 +f 3052//1870 3051//2232 3066//1886 +f 3047//1869 3046//1865 3062//1887 +f 3053//1872 3052//1870 3067//2237 +f 3067//2237 3066//1886 3081//2238 +f 3062//1887 3061//1883 3077//2239 +f 3068//1875 3067//2237 3082//1891 +f 3063//1874 3062//1887 3078//1892 +f 3069//1879 3068//1875 3083//1893 +f 3064//1876 3063//1874 3079//1894 +f 3059//1878 3058//1895 3074//1896 +f 3070//2236 3069//1879 3084//1897 +f 3065//2235 3064//1876 3080//1898 +f 3060//1881 3059//1878 3075//1899 +f 3071//1885 3070//2236 3085//1900 +f 3066//1886 3065//2235 3080//1898 +f 3061//1883 3060//1881 3076//1901 +f 3072//1902 3071//1885 3086//1903 +f 3086//1903 3085//1900 3100//1904 +f 3081//2238 3080//1898 3096//1905 +f 3076//1901 3075//1899 3091//1906 +f 3087//1907 3086//1903 3101//1908 +f 3082//1891 3081//2238 3096//1905 +f 3077//2239 3076//1901 3092//1909 +f 3083//1893 3082//1891 3097//1910 +f 3078//1892 3077//2239 3093//1911 +f 3084//1897 3083//1893 3098//1912 +f 3079//1894 3078//1892 3094//1913 +f 3074//1896 3073//2240 3089//1915 +f 3085//1900 3084//1897 3099//1916 +f 3080//1898 3079//1894 3095//1917 +f 3075//1899 3074//1896 3090//2241 +f 3089//1915 3088//2242 3104//2243 +f 3100//1904 3099//1916 3114//1921 +f 3095//1917 3094//1913 3110//1922 +f 3090//2241 3089//1915 3105//1923 +f 3101//1908 3100//1904 3115//1924 +f 3096//1905 3095//1917 3111//1925 +f 3091//1906 3090//2241 3106//2244 +f 3102//1927 3101//1908 3116//1928 +f 3097//1910 3096//1905 3111//1925 +f 3092//1909 3091//1906 3107//1929 +f 3098//1912 3097//1910 3112//2245 +f 3093//1911 3092//1909 3108//1931 +f 3099//1916 3098//1912 3113//1932 +f 3094//1913 3093//1911 3109//1933 +f 3108//1931 3107//1929 3123//1934 +f 3114//1921 3113//1932 3128//1935 +f 3109//1933 3108//1931 3124//1936 +f 3104//2243 3103//2246 3119//1938 +f 3115//1924 3114//1921 3129//1939 +f 3110//1922 3109//1933 3125//1940 +f 3105//1923 3104//2243 3120//1941 +f 3116//1928 3115//1924 3130//1942 +f 3111//1925 3110//1922 3126//1943 +f 3106//2244 3105//1923 3121//1944 +f 3117//2247 3116//1928 3131//1946 +f 3112//2245 3111//1925 3126//1943 +f 3107//1929 3106//2244 3122//2248 +f 3113//1932 3112//2245 3127//1948 +f 3127//1948 3126//1943 3142//1949 +f 3122//2248 3121//1944 3137//1950 +f 3128//1935 3127//1948 3143//1951 +f 3123//1934 3122//2248 3138//2249 +f 3129//1939 3128//1935 3144//1953 +f 3124//1936 3123//1934 3139//1954 +f 3119//1938 3118//2250 3133//2251 +f 3130//1942 3129//1939 3145//1957 +f 3125//1940 3124//1936 3140//1958 +f 3120//1941 3119//1938 3135//1959 +f 3131//1946 3130//1942 3146//1960 +f 3126//1943 3125//1940 3141//1961 +f 3121//1944 3120//1941 3136//1962 +f 3132//2252 3131//1946 3147//1964 +f 3146//1960 3145//1957 3161//2253 +f 3141//1961 3140//1958 3156//1966 +f 3136//1962 3135//1959 3150//1967 +f 3147//1964 3146//1960 3162//1968 +f 3142//1949 3141//1961 3157//1969 +f 3137//1950 3136//1962 3151//1970 +f 3143//1951 3142//1949 3158//1971 +f 3138//2249 3137//1950 3152//2254 +f 3144//1953 3143//1951 3159//1973 +f 3139//1954 3138//2249 3153//1974 +f 3134//1975 3133//2251 3148//1976 +f 3145//1957 3144//1953 3160//1977 +f 3140//1958 3139//1954 3155//1978 +f 3135//1959 3134//1975 3149//1979 +f 3160//1977 3159//1973 3175//1980 +f 3155//1978 3154//1981 3169//2255 +f 3150//1967 3149//1979 3164//1983 +f 3161//2253 3160//1977 3176//1984 +f 3156//1966 3155//1978 3171//2256 +f 3151//1970 3150//1967 3165//1986 +f 3162//1968 3161//2253 3177//2257 +f 3157//1969 3156//1966 3172//1988 +f 3152//2254 3151//1970 3166//2258 +f 3158//1971 3157//1969 3173//1990 +f 3153//1974 3152//2254 3167//1991 +f 3159//1973 3158//1971 3174//1992 +f 3154//1981 3153//1974 3168//1993 +f 3149//1979 3148//1976 3163//1994 +f 3174//1992 3173//1990 3189//2259 +f 3169//2255 3168//1993 3183//2260 +f 3164//1983 3163//1994 3178//1997 +f 3175//1980 3174//1992 3190//1998 +f 3170//2261 3169//2255 3184//2262 +f 3165//1986 3164//1983 3179//2001 +f 3176//1984 3175//1980 3191//2263 +f 3171//2256 3170//2261 3186//2003 +f 3166//2258 3165//1986 3180//2264 +f 3177//2257 3176//1984 3192//2005 +f 3172//1988 3171//2256 3187//2006 +f 3167//1991 3166//2258 3181//2007 +f 3173//1990 3172//1988 3188//2008 +f 3168//1993 3167//1991 3182//2265 +f 3182//2265 3181//2007 3196//2010 +f 3188//2008 3187//2006 3203//2266 +f 3183//2260 3182//2265 3197//2267 +f 3189//2259 3188//2008 3204//2013 +f 3184//2262 3183//2260 3198//2014 +f 3179//2001 3178//1997 3193//2268 +f 3190//1998 3189//2259 3205//2016 +f 3185//2017 3184//2262 3199//2269 +f 3180//2264 3179//2001 3194//2019 +f 3191//2263 3190//1998 3206//2020 +f 3186//2003 3185//2017 3201//2021 +f 3181//2007 3180//2264 3195//2270 +f 3192//2005 3191//2263 3207//2023 +f 3187//2006 3186//2003 3202//2024 +f 3201//2021 3200//2025 3216//2026 +f 3196//2010 3195//2270 3210//2027 +f 3207//2023 3206//2020 3222//2271 +f 3202//2024 3201//2021 3217//2029 +f 3197//2267 3196//2010 3211//2030 +f 3203//2266 3202//2024 3218//2031 +f 3198//2014 3197//2267 3212//2032 +f 3204//2013 3203//2266 3219//2272 +f 3199//2269 3198//2014 3213//2034 +f 3194//2019 3193//2268 3208//2273 +f 3205//2016 3204//2013 3220//2274 +f 3200//2025 3199//2269 3214//2037 +f 3195//2270 3194//2019 3209//2038 +f 3206//2020 3205//2016 3221//2275 +f 3220//2274 3219//2272 3236//2276 +f 3215//2041 3214//2037 3230//2042 +f 3210//2027 3209//2038 3225//2043 +f 3221//2275 3220//2274 3237//2277 +f 3216//2026 3215//2041 3232//2045 +f 3211//2030 3210//2027 3226//2046 +f 3222//2271 3221//2275 3238//2278 +f 3217//2029 3216//2026 3233//2048 +f 3212//2032 3211//2030 3227//2049 +f 3218//2031 3217//2029 3234//2050 +f 3213//2034 3212//2032 3228//2051 +f 3219//2272 3218//2031 3235//2052 +f 3214//2037 3213//2034 3229//2053 +f 3209//2038 3208//2273 3224//2054 +f 3235//2052 3234//2050 3250//2055 +f 3230//2042 3229//2053 3244//2056 +f 3225//2043 3224//2054 3239//2279 +f 3236//2276 3235//2052 3251//2058 +f 3231//2059 3230//2042 3245//2060 +f 3226//2046 3225//2043 3240//2061 +f 3237//2277 3236//2276 3252//2062 +f 3232//2045 3231//2059 3247//2063 +f 3227//2049 3226//2046 3241//2064 +f 3238//2278 3237//2277 3253//2280 +f 3233//2048 3232//2045 3248//2066 +f 3228//2051 3227//2049 3242//2067 +f 3234//2050 3233//2048 3249//2068 +f 3229//2053 3228//2051 3243//2281 +f 3243//2281 3242//2067 3257//2070 +f 3249//2068 3248//2066 3263//2071 +f 3244//2056 3243//2281 3258//2072 +f 3250//2055 3249//2068 3264//2073 +f 3245//2060 3244//2056 3259//2074 +f 3240//2061 3239//2279 3255//2282 +f 3251//2058 3250//2055 3265//2076 +f 3246//2077 3245//2060 3260//2078 +f 3241//2064 3240//2061 3256//2079 +f 3252//2062 3251//2058 3266//2080 +f 3247//2063 3246//2077 3261//2081 +f 3242//2067 3241//2064 3257//2070 +f 3253//2280 3252//2062 3267//2082 +f 3248//2066 3247//2063 3262//2083 +f 3262//2083 3261//2081 3276//2283 +f 3257//2070 3256//2079 3272//2085 +f 3268//2284 3267//2082 3282//2087 +f 3263//2071 3262//2083 3277//2088 +f 3258//2072 3257//2070 3273//2089 +f 3264//2073 3263//2071 3278//2090 +f 3259//2074 3258//2072 3274//2091 +f 3265//2076 3264//2073 3279//2092 +f 3260//2078 3259//2074 3275//2093 +f 3255//2282 3254//2094 3270//2095 +f 3266//2080 3265//2076 3280//2096 +f 3261//2081 3260//2078 3275//2093 +f 3256//2079 3255//2282 3271//2097 +f 3267//2082 3266//2080 3281//2098 +f 3281//2098 3280//2096 3295//2099 +f 3276//2283 3275//2093 3291//2100 +f 3271//2097 3270//2095 3286//2285 +f 3282//2087 3281//2098 3296//2102 +f 3277//2088 3276//2283 3291//2100 +f 3272//2085 3271//2097 3287//2103 +f 3283//2104 3282//2087 3297//2105 +f 3278//2090 3277//2088 3292//2286 +f 3273//2089 3272//2085 3288//2107 +f 3279//2092 3278//2090 3293//2108 +f 3274//2091 3273//2089 3289//2109 +f 3280//2096 3279//2092 3294//2110 +f 3275//2093 3274//2091 3290//2287 +f 3270//2095 3269//2112 3285//2113 +f 3295//2099 3294//2110 3309//2288 +f 3290//2287 3289//2109 3305//2115 +f 3285//2113 3284//2116 3300//2117 +f 3296//2102 3295//2099 3310//2118 +f 3291//2100 3290//2287 3306//2119 +f 3286//2285 3285//2113 3301//2120 +f 3297//2105 3296//2102 3311//2121 +f 3292//2286 3291//2100 3306//2119 +f 3287//2103 3286//2285 3302//2122 +f 3298//2123 3297//2105 3312//2124 +f 3293//2108 3292//2286 3307//2125 +f 3288//2107 3287//2103 3303//2126 +f 3294//2110 3293//2108 3308//2289 +f 3289//2109 3288//2107 3304//2290 +f 3309//2288 3308//2289 3323//2129 +f 3304//2290 3303//2126 3319//2130 +f 3310//2118 3309//2288 3324//2131 +f 3305//2115 3304//2290 3320//2291 +f 3300//2117 3299//2133 3315//2134 +f 3311//2121 3310//2118 3325//2292 +f 3306//2119 3305//2115 3321//2136 +f 3301//2120 3300//2117 3316//2137 +f 3312//2124 3311//2121 3326//2138 +f 3307//2125 3306//2119 3321//2136 +f 3302//2122 3301//2120 3317//2293 +f 3313//2140 3312//2124 3327//2141 +f 3308//2289 3307//2125 3322//2142 +f 3303//2126 3302//2122 3318//2143 +f 3317//2293 3316//2137 3332//2144 +f 3328//2145 3327//2141 3342//2146 +f 3323//2129 3322//2142 3337//2147 +f 3318//2143 3317//2293 3333//2148 +f 3324//2131 3323//2129 3338//2149 +f 3319//2130 3318//2143 3334//2150 +f 3325//2292 3324//2131 3339//2151 +f 3320//2291 3319//2130 3335//2152 +f 3315//2134 3314//2153 3330//2154 +f 3326//2138 3325//2292 3340//2155 +f 3321//2136 3320//2291 3335//2152 +f 3316//2137 3315//2134 3331//2156 +f 3327//2141 3326//2138 3341//2294 +f 3322//2142 3321//2136 3336//2158 +f 3336//2158 3335//2152 3351//2159 +f 3331//2156 3330//2154 3347//2160 +f 3342//2146 3341//2294 3357//2161 +f 3337//2147 3336//2158 3352//2162 +f 3332//2144 3331//2156 3348//2163 +f 3343//2295 3342//2146 3358//2296 +f 3338//2149 3337//2147 3353//2166 +f 3333//2148 3332//2144 3349//2167 +f 3339//2151 3338//2149 3354//2168 +f 3334//2150 3333//2148 3350//2297 +f 3340//2155 3339//2151 3355//2170 +f 3335//2152 3334//2150 3351//2159 +f 3330//2154 3329//2171 3346//2172 +f 3341//2294 3340//2155 3356//2298 +f 3356//2298 3355//2170 3370//2174 +f 3351//2159 3350//2297 3366//2299 +f 3346//2172 3345//2176 3361//2300 +f 3357//2161 3356//2298 3371//2178 +f 3352//2162 3351//2159 3366//2299 +f 3347//2160 3346//2172 3362//2179 +f 3358//2296 3357//2161 3372//2180 +f 3353//2166 3352//2162 3367//2181 +f 3348//2163 3347//2160 3363//2182 +f 3359//2183 3358//2296 3373//2301 +f 3354//2168 3353//2166 3368//2185 +f 3349//2167 3348//2163 3364//2186 +f 3355//2170 3354//2168 3369//2187 +f 3350//2297 3349//2167 3365//2188 +f 3223//2189 2907//2198 2922//2199 +f 2893//1715 3344//2190 2908//2194 +f 3223//2189 2922//2199 2937//1749 +f 2908//2194 3344//2190 2923//2201 +f 2923//2201 3344//2190 2938//2208 +f 3223//2189 2937//1749 2952//2211 +f 3223//2189 2952//2211 2967//1770 +f 2938//2208 3344//2190 2953//2216 +f 3223//2189 2967//1770 2982//2220 +f 2953//2216 3344//2190 2968//1797 +f 3223//2189 2982//2220 2997//2223 +f 2968//1797 3344//2190 2983//1801 +f 2983//1801 3344//2190 2998//1819 +f 3223//2189 2997//2223 3012//1827 +f 3223//2189 3012//1827 3027//1847 +f 2998//1819 3344//2190 3013//1854 +f 3223//2189 3027//1847 3042//1866 +f 3013//1854 3344//2190 3028//1859 +f 3223//2189 3042//1866 3057//1884 +f 3028//1859 3344//2190 3043//1877 +f 3043//1877 3344//2190 3058//1895 +f 3223//2189 3057//1884 3072//1902 +f 3223//2189 3072//1902 3087//1907 +f 3058//1895 3344//2190 3073//2240 +f 3223//2189 3087//1907 3102//1927 +f 3073//2240 3344//2190 3088//2242 +f 3223//2189 3102//1927 3117//2247 +f 3088//2242 3344//2190 3103//2246 +f 3103//2246 3344//2190 3118//2250 +f 3223//2189 3117//2247 3132//2252 +f 3223//2189 3132//2252 3147//1964 +f 3118//2250 3344//2190 3133//2251 +f 3223//2189 3147//1964 3162//1968 +f 3133//2251 3344//2190 3148//1976 +f 3223//2189 3162//1968 3177//2257 +f 3148//1976 3344//2190 3163//1994 +f 3163//1994 3344//2190 3178//1997 +f 3223//2189 3177//2257 3192//2005 +f 3223//2189 3192//2005 3207//2023 +f 3178//1997 3344//2190 3193//2268 +f 3223//2189 3207//2023 3222//2271 +f 3193//2268 3344//2190 3208//2273 +f 3223//2189 3222//2271 3238//2278 +f 3208//2273 3344//2190 3224//2054 +f 3224//2054 3344//2190 3239//2279 +f 3223//2189 3238//2278 3253//2280 +f 3223//2189 3253//2280 3268//2284 +f 3239//2279 3344//2190 3254//2094 +f 3223//2189 3268//2284 3283//2104 +f 3254//2094 3344//2190 3269//2112 +f 3223//2189 3283//2104 3298//2123 +f 3269//2112 3344//2190 3284//2116 +f 3223//2189 3298//2123 3313//2140 +f 3284//2116 3344//2190 3299//2133 +f 3223//2189 3313//2140 3328//2145 +f 3299//2133 3344//2190 3314//2153 +f 3223//2189 3328//2145 3343//2295 +f 3314//2153 3344//2190 3329//2171 +f 3223//2189 3343//2295 3359//2183 +f 3329//2171 3344//2190 3345//2176 +f 3223//2189 3359//2183 3374//2191 +f 3345//2176 3344//2190 3360//2302 +f 3223//2189 3374//2191 2907//2198 +f 3370//2174 3369//2187 2902//1732 +f 3365//2188 3364//2186 2897//1734 +f 3360//2302 3344//2190 2893//1715 +f 3371//2178 3370//2174 2903//2200 +f 3366//2299 3365//2188 2898//2193 +f 3361//2300 3360//2302 2893//1715 +f 3372//2180 3371//2178 2904//1718 +f 3367//2181 3366//2299 2899//1711 +f 3362//2179 3361//2300 2894//1714 +f 3373//2301 3372//2180 2905//2195 +f 3368//2185 3367//2181 2900//1720 +f 3363//2182 3362//2179 2895//1722 +f 3374//2191 3373//2301 2907//2198 +f 3369//2187 3368//2185 2901//1726 +f 3364//2186 3363//2182 2896//1728 +f 2432//1721 2417//1711 2431//1713 +f 2427//1723 2412//1714 2426//1716 +f 2422//1718 2437//1739 2438//1719 +f 2433//1727 2418//1720 2432//1721 +f 2428//1729 2413//1722 2427//1723 +f 2423//1717 2438//1719 2439//1725 +f 2434//1746 2419//1726 2433//1727 +f 2429//1735 2414//1728 2428//1729 +f 2424//1724 2439//1725 2440//1731 +f 2419//1726 2434//1746 2435//1733 +f 2430//1738 2415//1734 2429//1735 +f 2420//1732 2435//1733 2436//1737 +f 2431//1713 2416//1712 2430//1738 +f 2421//1736 2436//1737 2437//1739 +f 2447//1743 2432//1721 2446//1740 +f 2442//1744 2427//1723 2441//1741 +f 2437//1739 2452//1754 2453//1742 +f 2448//1761 2433//1727 2447//1743 +f 2443//1748 2428//1729 2442//1744 +f 2438//1719 2453//1742 2454//1745 +f 2433//1727 2448//1761 2449//1747 +f 2444//1751 2429//1735 2443//1748 +f 2439//1725 2454//1745 2455//1749 +f 2434//1746 2449//1747 2450//1750 +f 2445//1753 2430//1738 2444//1751 +f 2435//1733 2450//1750 2451//1752 +f 2446//1740 2431//1713 2445//1753 +f 2436//1737 2451//1752 2452//1754 +f 2450//1750 2465//1768 2466//1755 +f 2461//1758 2446//1740 2460//1756 +f 2451//1752 2466//1755 2467//1757 +f 2462//1762 2447//1743 2461//1758 +f 2457//1763 2442//1744 2456//1759 +f 2452//1754 2467//1757 2468//1760 +f 2463//1779 2448//1761 2462//1762 +f 2458//1766 2443//1748 2457//1763 +f 2453//1742 2468//1760 2469//1764 +f 2448//1761 2463//1779 2464//1765 +f 2459//1769 2444//1751 2458//1766 +f 2454//1745 2469//1764 2470//1767 +f 2449//1747 2464//1765 2465//1768 +f 2460//1756 2445//1753 2459//1769 +f 2469//1764 2484//1782 2485//1770 +f 2464//1765 2479//1783 2480//1771 +f 2475//1774 2460//1756 2474//1772 +f 2465//1768 2480//1771 2481//1773 +f 2476//1776 2461//1758 2475//1774 +f 2466//1755 2481//1773 2482//1775 +f 2477//1780 2462//1762 2476//1776 +f 2472//1781 2457//1763 2471//1777 +f 2467//1757 2482//1775 2483//1778 +f 2478//1787 2463//1779 2477//1780 +f 2473//1784 2458//1766 2472//1781 +f 2468//1760 2483//1778 2484//1782 +f 2463//1779 2478//1787 2479//1783 +f 2474//1772 2459//1769 2473//1784 +f 2488//1789 2473//1784 2487//1785 +f 2483//1778 2498//1798 2499//1786 +f 2478//1787 2493//1803 2494//1788 +f 2489//1792 2474//1772 2488//1789 +f 2484//1782 2499//1786 2500//1790 +f 2479//1783 2494//1788 2495//1791 +f 2490//1794 2475//1774 2489//1792 +f 2480//1771 2495//1791 2496//1793 +f 2491//1796 2476//1776 2490//1794 +f 2481//1773 2496//1793 2497//1795 +f 2492//1799 2477//1780 2491//1796 +f 2487//1785 2472//1781 2486//1797 +f 2482//1775 2497//1795 2498//1798 +f 2493//1803 2478//1787 2492//1799 +f 2507//1804 2492//1799 2506//1800 +f 2502//1805 2487//1785 2501//1801 +f 2497//1795 2512//1814 2513//1802 +f 2508//1821 2493//1803 2507//1804 +f 2503//1808 2488//1789 2502//1805 +f 2498//1798 2513//1802 2514//1806 +f 2493//1803 2508//1821 2509//1807 +f 2504//1811 2489//1792 2503//1808 +f 2499//1786 2514//1806 2515//1809 +f 2494//1788 2509//1807 2510//1810 +f 2505//1813 2490//1794 2504//1811 +f 2495//1791 2510//1810 2511//1812 +f 2506//1800 2491//1796 2505//1813 +f 2496//1793 2511//1812 2512//1814 +f 2510//1810 2525//1828 2526//1815 +f 2521//1818 2506//1800 2520//1816 +f 2511//1812 2526//1815 2527//1817 +f 2522//1822 2507//1804 2521//1818 +f 2517//1823 2502//1805 2516//1819 +f 2512//1814 2527//1817 2528//1820 +f 2523//1838 2508//1821 2522//1822 +f 2518//1826 2503//1808 2517//1823 +f 2513//1802 2528//1820 2529//1824 +f 2508//1821 2523//1838 2524//1825 +f 2519//1829 2504//1811 2518//1826 +f 2514//1806 2529//1824 2530//1827 +f 2509//1807 2524//1825 2525//1828 +f 2520//1816 2505//1813 2519//1829 +f 2545//1847 2530//1827 2544//1830 +f 2524//1825 2539//1842 2540//1831 +f 2519//1829 2534//1843 2535//1832 +f 2525//1828 2540//1831 2541//1833 +f 2520//1816 2535//1832 2536//1834 +f 2526//1815 2541//1833 2542//1835 +f 2521//1818 2536//1834 2537//1836 +f 2516//1819 2531//1854 2532//1837 +f 2543//1841 2528//1820 2542//1835 +f 2522//1822 2537//1836 2538//1839 +f 2517//1823 2532//1837 2533//1840 +f 2544//1830 2529//1824 2543//1841 +f 2523//1838 2538//1839 2539//1842 +f 2518//1826 2533//1840 2534//1843 +f 2559//1848 2544//1830 2558//1844 +f 2538//1839 2553//1857 2554//1845 +f 2533//1840 2548//1858 2549//1846 +f 2560//1866 2545//1847 2559//1848 +f 2555//1850 2540//1831 2554//1845 +f 2534//1843 2549//1846 2550//1849 +f 2556//1852 2541//1833 2555//1850 +f 2535//1832 2550//1849 2551//1851 +f 2557//1856 2542//1835 2556//1852 +f 2536//1834 2551//1851 2552//1853 +f 2531//1854 2546//1859 2547//1855 +f 2558//1844 2543//1841 2557//1856 +f 2537//1836 2552//1853 2553//1857 +f 2532//1837 2547//1855 2548//1858 +f 2546//1859 2561//1877 2562//1860 +f 2573//1864 2558//1844 2572//1861 +f 2552//1853 2567//1873 2568//1862 +f 2547//1855 2562//1860 2563//1863 +f 2574//1867 2559//1848 2573//1864 +f 2569//1868 2554//1845 2568//1862 +f 2548//1858 2563//1863 2564//1865 +f 2575//1884 2560//1866 2574//1867 +f 2570//1870 2555//1850 2569//1868 +f 2549//1846 2564//1865 2565//1869 +f 2571//1872 2556//1852 2570//1870 +f 2550//1849 2565//1869 2566//1871 +f 2572//1861 2557//1856 2571//1872 +f 2551//1851 2566//1871 2567//1873 +f 2565//1869 2580//1887 2581//1874 +f 2587//1879 2572//1861 2586//1875 +f 2566//1871 2581//1874 2582//1876 +f 2561//1877 2576//1895 2577//1878 +f 2588//1882 2573//1864 2587//1879 +f 2567//1873 2582//1876 2583//1880 +f 2562//1860 2577//1878 2578//1881 +f 2589//1885 2574//1867 2588//1882 +f 2584//1886 2569//1868 2583//1880 +f 2563//1863 2578//1881 2579//1883 +f 2590//1902 2575//1884 2589//1885 +f 2585//1888 2570//1870 2584//1886 +f 2564//1865 2579//1883 2580//1887 +f 2586//1875 2571//1872 2585//1888 +f 2600//1891 2585//1888 2599//1889 +f 2579//1883 2594//1901 2595//1890 +f 2601//1893 2586//1875 2600//1891 +f 2580//1887 2595//1890 2596//1892 +f 2602//1897 2587//1879 2601//1893 +f 2581//1874 2596//1892 2597//1894 +f 2576//1895 2591//1914 2592//1896 +f 2603//1900 2588//1882 2602//1897 +f 2582//1876 2597//1894 2598//1898 +f 2577//1878 2592//1896 2593//1899 +f 2604//1903 2589//1885 2603//1900 +f 2599//1889 2584//1886 2598//1898 +f 2578//1881 2593//1899 2594//1901 +f 2605//1907 2590//1902 2604//1903 +f 2619//1908 2604//1903 2618//1904 +f 2598//1898 2613//1917 2614//1905 +f 2593//1899 2608//1918 2609//1906 +f 2620//1927 2605//1907 2619//1908 +f 2615//1910 2600//1891 2614//1905 +f 2594//1901 2609//1906 2610//1909 +f 2616//1912 2601//1893 2615//1910 +f 2595//1890 2610//1909 2611//1911 +f 2617//1916 2602//1897 2616//1912 +f 2596//1892 2611//1911 2612//1913 +f 2591//1914 2606//1919 2607//1915 +f 2618//1904 2603//1900 2617//1916 +f 2597//1894 2612//1913 2613//1917 +f 2592//1896 2607//1915 2608//1918 +f 2606//1919 2621//1937 2622//1920 +f 2633//1924 2618//1904 2632//1921 +f 2612//1913 2627//1933 2628//1922 +f 2607//1915 2622//1920 2623//1923 +f 2634//1928 2619//1908 2633//1924 +f 2613//1917 2628//1922 2629//1925 +f 2608//1918 2623//1923 2624//1926 +f 2635//1945 2620//1927 2634//1928 +f 2630//1930 2615//1910 2629//1925 +f 2609//1906 2624//1926 2625//1929 +f 2631//1932 2616//1912 2630//1930 +f 2610//1909 2625//1929 2626//1931 +f 2632//1921 2617//1916 2631//1932 +f 2611//1911 2626//1931 2627//1933 +f 2625//1929 2640//1947 2641//1934 +f 2647//1939 2632//1921 2646//1935 +f 2626//1931 2641//1934 2642//1936 +f 2621//1937 2636//1955 2637//1938 +f 2648//1942 2633//1924 2647//1939 +f 2627//1933 2642//1936 2643//1940 +f 2622//1920 2637//1938 2638//1941 +f 2649//1946 2634//1928 2648//1942 +f 2628//1922 2643//1940 2644//1943 +f 2623//1923 2638//1941 2639//1944 +f 2650//1963 2635//1945 2649//1946 +f 2645//1948 2630//1930 2644//1943 +f 2624//1926 2639//1944 2640//1947 +f 2646//1935 2631//1932 2645//1948 +f 2644//1943 2659//1961 2660//1949 +f 2639//1944 2654//1962 2655//1950 +f 2645//1948 2660//1949 2661//1951 +f 2640//1947 2655//1950 2656//1952 +f 2646//1935 2661//1951 2662//1953 +f 2641//1934 2656//1952 2657//1954 +f 2652//1975 2637//1938 2651//1956 +f 2647//1939 2662//1953 2663//1957 +f 2642//1936 2657//1954 2658//1958 +f 2637//1938 2652//1975 2653//1959 +f 2648//1942 2663//1957 2664//1960 +f 2643//1940 2658//1958 2659//1961 +f 2638//1941 2653//1959 2654//1962 +f 2649//1946 2664//1960 2665//1964 +f 2663//1957 2678//1977 2679//1965 +f 2658//1958 2673//1978 2674//1966 +f 2669//1970 2654//1962 2668//1967 +f 2664//1960 2679//1965 2680//1968 +f 2659//1961 2674//1966 2675//1969 +f 2670//1972 2655//1950 2669//1970 +f 2660//1949 2675//1969 2676//1971 +f 2671//1974 2656//1952 2670//1972 +f 2661//1951 2676//1971 2677//1973 +f 2672//1981 2657//1954 2671//1974 +f 2667//1979 2652//1975 2666//1976 +f 2662//1953 2677//1973 2678//1977 +f 2657//1954 2672//1981 2673//1978 +f 2668//1967 2653//1959 2667//1979 +f 2677//1973 2692//1992 2693//1980 +f 2688//1999 2673//1978 2687//1982 +f 2683//1986 2668//1967 2682//1983 +f 2678//1977 2693//1980 2694//1984 +f 2673//1978 2688//1999 2689//1985 +f 2684//1989 2669//1970 2683//1986 +f 2679//1965 2694//1984 2695//1987 +f 2674//1966 2689//1985 2690//1988 +f 2685//1991 2670//1972 2684//1989 +f 2675//1969 2690//1988 2691//1990 +f 2686//1993 2671//1974 2685//1991 +f 2676//1971 2691//1990 2692//1992 +f 2687//1982 2672//1981 2686//1993 +f 2682//1983 2667//1979 2681//1994 +f 2691//1990 2706//2008 2707//1995 +f 2702//2000 2687//1982 2701//1996 +f 2697//2001 2682//1983 2696//1997 +f 2692//1992 2707//1995 2708//1998 +f 2703//2017 2688//1999 2702//2000 +f 2698//2004 2683//1986 2697//2001 +f 2693//1980 2708//1998 2709//2002 +f 2688//1999 2703//2017 2704//2003 +f 2699//2007 2684//1989 2698//2004 +f 2694//1984 2709//2002 2710//2005 +f 2689//1985 2704//2003 2705//2006 +f 2700//2009 2685//1991 2699//2007 +f 2690//1988 2705//2006 2706//2008 +f 2701//1996 2686//1993 2700//2009 +f 2715//2012 2700//2009 2714//2010 +f 2705//2006 2720//2024 2721//2011 +f 2716//2014 2701//1996 2715//2012 +f 2706//2008 2721//2011 2722//2013 +f 2717//2018 2702//2000 2716//2014 +f 2712//2019 2697//2001 2711//2015 +f 2707//1995 2722//2013 2723//2016 +f 2718//2025 2703//2017 2717//2018 +f 2713//2022 2698//2004 2712//2019 +f 2708//1998 2723//2016 2724//2020 +f 2703//2017 2718//2025 2719//2021 +f 2714//2010 2699//2007 2713//2022 +f 2709//2002 2724//2020 2725//2023 +f 2704//2003 2719//2021 2720//2024 +f 2718//2025 2733//2041 2734//2026 +f 2729//2030 2714//2010 2728//2027 +f 2724//2020 2739//2039 2740//2028 +f 2719//2021 2734//2026 2735//2029 +f 2730//2032 2715//2012 2729//2030 +f 2720//2024 2735//2029 2736//2031 +f 2731//2034 2716//2014 2730//2032 +f 2721//2011 2736//2031 2737//2033 +f 2732//2037 2717//2018 2731//2034 +f 2727//2038 2712//2019 2726//2035 +f 2722//2013 2737//2033 2738//2036 +f 2733//2041 2718//2025 2732//2037 +f 2728//2027 2713//2022 2727//2038 +f 2723//2016 2738//2036 2739//2039 +f 2737//2033 2753//2052 2754//2040 +f 2749//2059 2733//2041 2748//2042 +f 2744//2046 2728//2027 2743//2043 +f 2738//2036 2754//2040 2755//2044 +f 2733//2041 2749//2059 2750//2045 +f 2745//2049 2729//2030 2744//2046 +f 2739//2039 2755//2044 2756//2047 +f 2734//2026 2750//2045 2751//2048 +f 2746//2051 2730//2032 2745//2049 +f 2735//2029 2751//2048 2752//2050 +f 2747//2053 2731//2034 2746//2051 +f 2736//2031 2752//2050 2753//2052 +f 2748//2042 2732//2037 2747//2053 +f 2743//2043 2727//2038 2742//2054 +f 2752//2050 2767//2068 2768//2055 +f 2763//2060 2748//2042 2762//2056 +f 2758//2061 2743//2043 2757//2057 +f 2753//2052 2768//2055 2769//2058 +f 2764//2077 2749//2059 2763//2060 +f 2759//2064 2744//2046 2758//2061 +f 2754//2040 2769//2058 2770//2062 +f 2749//2059 2764//2077 2765//2063 +f 2760//2067 2745//2049 2759//2064 +f 2755//2044 2770//2062 2771//2065 +f 2750//2045 2765//2063 2766//2066 +f 2761//2069 2746//2051 2760//2067 +f 2751//2048 2766//2066 2767//2068 +f 2762//2056 2747//2053 2761//2069 +f 2776//2072 2761//2069 2775//2070 +f 2782//2073 2767//2068 2781//2071 +f 2777//2074 2762//2056 2776//2072 +f 2783//2076 2768//2055 2782//2073 +f 2778//2078 2763//2060 2777//2074 +f 2757//2057 2772//2094 2773//2075 +f 2784//2080 2769//2058 2783//2076 +f 2779//2081 2764//2077 2778//2078 +f 2758//2061 2773//2075 2774//2079 +f 2785//2082 2770//2062 2784//2080 +f 2780//2083 2765//2063 2779//2081 +f 2759//2064 2774//2079 2775//2070 +f 2786//2086 2771//2065 2785//2082 +f 2781//2071 2766//2066 2780//2083 +f 2795//2088 2780//2083 2794//2084 +f 2774//2079 2789//2097 2790//2085 +f 2801//2104 2786//2086 2800//2087 +f 2796//2090 2781//2071 2795//2088 +f 2775//2070 2790//2085 2791//2089 +f 2797//2092 2782//2073 2796//2090 +f 2776//2072 2791//2089 2792//2091 +f 2798//2096 2783//2076 2797//2092 +f 2777//2074 2792//2091 2793//2093 +f 2772//2094 2787//2112 2788//2095 +f 2799//2098 2784//2080 2798//2096 +f 2794//2084 2779//2081 2793//2093 +f 2773//2075 2788//2095 2789//2097 +f 2800//2087 2785//2082 2799//2098 +f 2814//2102 2799//2098 2813//2099 +f 2793//2093 2808//2111 2809//2100 +f 2788//2095 2803//2113 2804//2101 +f 2815//2105 2800//2087 2814//2102 +f 2810//2106 2795//2088 2809//2100 +f 2789//2097 2804//2101 2805//2103 +f 2816//2123 2801//2104 2815//2105 +f 2811//2108 2796//2090 2810//2106 +f 2790//2085 2805//2103 2806//2107 +f 2812//2110 2797//2092 2811//2108 +f 2791//2089 2806//2107 2807//2109 +f 2813//2099 2798//2096 2812//2110 +f 2792//2091 2807//2109 2808//2111 +f 2787//2112 2802//2116 2803//2113 +f 2828//2118 2813//2099 2827//2114 +f 2807//2109 2822//2128 2823//2115 +f 2802//2116 2817//2133 2818//2117 +f 2829//2121 2814//2102 2828//2118 +f 2808//2111 2823//2115 2824//2119 +f 2803//2113 2818//2117 2819//2120 +f 2830//2124 2815//2105 2829//2121 +f 2825//2125 2810//2106 2824//2119 +f 2804//2101 2819//2120 2820//2122 +f 2831//2140 2816//2123 2830//2124 +f 2826//2127 2811//2108 2825//2125 +f 2805//2103 2820//2122 2821//2126 +f 2827//2114 2812//2110 2826//2127 +f 2806//2107 2821//2126 2822//2128 +f 2842//2131 2827//2114 2841//2129 +f 2821//2126 2836//2143 2837//2130 +f 2843//2135 2828//2118 2842//2131 +f 2822//2128 2837//2130 2838//2132 +f 2817//2133 2832//2153 2833//2134 +f 2844//2138 2829//2121 2843//2135 +f 2823//2115 2838//2132 2839//2136 +f 2818//2117 2833//2134 2834//2137 +f 2845//2141 2830//2124 2844//2138 +f 2840//2142 2825//2125 2839//2136 +f 2819//2120 2834//2137 2835//2139 +f 2846//2145 2831//2140 2845//2141 +f 2841//2129 2826//2127 2840//2142 +f 2820//2122 2835//2139 2836//2143 +f 2834//2137 2849//2156 2850//2144 +f 2861//2164 2846//2145 2860//2146 +f 2856//2149 2841//2129 2855//2147 +f 2835//2139 2850//2144 2851//2148 +f 2857//2151 2842//2131 2856//2149 +f 2836//2143 2851//2148 2852//2150 +f 2858//2155 2843//2135 2857//2151 +f 2837//2130 2852//2150 2853//2152 +f 2832//2153 2847//2171 2848//2154 +f 2859//2157 2844//2138 2858//2155 +f 2854//2158 2839//2136 2853//2152 +f 2833//2134 2848//2154 2849//2156 +f 2860//2146 2845//2141 2859//2157 +f 2855//2147 2840//2142 2854//2158 +f 2870//2162 2854//2158 2869//2159 +f 2848//2154 2864//2172 2865//2160 +f 2876//2165 2860//2146 2875//2161 +f 2871//2166 2855//2147 2870//2162 +f 2849//2156 2865//2160 2866//2163 +f 2877//2183 2861//2164 2876//2165 +f 2872//2168 2856//2149 2871//2166 +f 2850//2144 2866//2163 2867//2167 +f 2873//2170 2857//2151 2872//2168 +f 2851//2148 2867//2167 2868//2169 +f 2874//2173 2858//2155 2873//2170 +f 2852//2150 2868//2169 2869//2159 +f 2847//2171 2863//2176 2864//2172 +f 2875//2161 2859//2157 2874//2173 +f 2889//2178 2874//2173 2888//2174 +f 2868//2169 2883//2188 2884//2175 +f 2863//2176 2878//2192 2879//2177 +f 2890//2180 2875//2161 2889//2178 +f 2885//2181 2870//2162 2884//2175 +f 2864//2172 2879//2177 2880//2179 +f 2891//2184 2876//2165 2890//2180 +f 2886//2185 2871//2166 2885//2181 +f 2865//2160 2880//2179 2881//2182 +f 2892//2191 2877//2183 2891//2184 +f 2887//2187 2872//2168 2886//2185 +f 2866//2163 2881//2182 2882//2186 +f 2888//2174 2873//2170 2887//2187 +f 2867//2167 2882//2186 2883//2188 +f 2421//1736 2888//2174 2420//1732 +f 2416//1712 2883//2188 2415//1734 +f 2422//1718 2889//2178 2421//1736 +f 2417//1711 2884//2175 2416//1712 +f 2412//1714 2879//2177 2411//1715 +f 2423//1717 2890//2180 2422//1718 +f 2418//1720 2885//2181 2417//1711 +f 2413//1722 2880//2179 2412//1714 +f 2424//1724 2891//2184 2423//1717 +f 2419//1726 2886//2185 2418//1720 +f 2414//1728 2881//2182 2413//1722 +f 2891//2184 2424//1724 2425//1730 +f 2420//1732 2887//2187 2419//1726 +f 2415//1734 2882//2186 2414//1728 +f 2914//1721 2899//1711 2913//1713 +f 2909//2196 2894//1714 2908//2194 +f 2904//1718 2919//1739 2920//1719 +f 2915//1727 2900//1720 2914//1721 +f 2910//2197 2895//1722 2909//2196 +f 2905//2195 2920//1719 2921//1725 +f 2916//1746 2901//1726 2915//1727 +f 2911//1735 2896//1728 2910//2197 +f 2906//1724 2921//1725 2922//2199 +f 2901//1726 2916//1746 2917//1733 +f 2912//1738 2897//1734 2911//1735 +f 2902//1732 2917//1733 2918//1737 +f 2913//1713 2898//2193 2912//1738 +f 2903//2200 2918//1737 2919//1739 +f 2929//1743 2914//1721 2928//1740 +f 2924//1744 2909//2196 2923//2201 +f 2919//1739 2934//2205 2935//2202 +f 2930//2209 2915//1727 2929//1743 +f 2925//1748 2910//2197 2924//1744 +f 2920//1719 2935//2202 2936//2203 +f 2915//1727 2930//2209 2931//1747 +f 2926//1751 2911//1735 2925//1748 +f 2921//1725 2936//2203 2937//1749 +f 2916//1746 2931//1747 2932//1750 +f 2927//2204 2912//1738 2926//1751 +f 2917//1733 2932//1750 2933//1752 +f 2928//1740 2913//1713 2927//2204 +f 2918//1737 2933//1752 2934//2205 +f 2932//1750 2947//2212 2948//2206 +f 2943//1758 2928//1740 2942//1756 +f 2933//1752 2948//2206 2949//2207 +f 2944//1762 2929//1743 2943//1758 +f 2939//2210 2924//1744 2938//2208 +f 2934//2205 2949//2207 2950//1760 +f 2945//1779 2930//2209 2944//1762 +f 2940//1766 2925//1748 2939//2210 +f 2935//2202 2950//1760 2951//1764 +f 2930//2209 2945//1779 2946//1765 +f 2941//2213 2926//1751 2940//1766 +f 2936//2203 2951//1764 2952//2211 +f 2931//1747 2946//1765 2947//2212 +f 2942//1756 2927//2204 2941//2213 +f 2951//1764 2966//1782 2967//1770 +f 2946//1765 2961//2217 2962//2214 +f 2957//1774 2942//1756 2956//1772 +f 2947//2212 2962//2214 2963//2215 +f 2958//1776 2943//1758 2957//1774 +f 2948//2206 2963//2215 2964//1775 +f 2959//1780 2944//1762 2958//1776 +f 2954//1781 2939//2210 2953//2216 +f 2949//2207 2964//1775 2965//1778 +f 2960//1787 2945//1779 2959//1780 +f 2955//2218 2940//1766 2954//1781 +f 2950//1760 2965//1778 2966//1782 +f 2945//1779 2960//1787 2961//2217 +f 2956//1772 2941//2213 2955//2218 +f 2970//2219 2955//2218 2969//1785 +f 2965//1778 2980//2222 2981//1786 +f 2960//1787 2975//1803 2976//1788 +f 2971//1792 2956//1772 2970//2219 +f 2966//1782 2981//1786 2982//2220 +f 2961//2217 2976//1788 2977//1791 +f 2972//2221 2957//1774 2971//1792 +f 2962//2214 2977//1791 2978//1793 +f 2973//1796 2958//1776 2972//2221 +f 2963//2215 2978//1793 2979//1795 +f 2974//1799 2959//1780 2973//1796 +f 2969//1785 2954//1781 2968//1797 +f 2964//1775 2979//1795 2980//2222 +f 2975//1803 2960//1787 2974//1799 +f 2989//1804 2974//1799 2988//1800 +f 2984//1805 2969//1785 2983//1801 +f 2979//1795 2994//1814 2995//1802 +f 2990//1821 2975//1803 2989//1804 +f 2985//1808 2970//2219 2984//1805 +f 2980//2222 2995//1802 2996//1806 +f 2975//1803 2990//1821 2991//1807 +f 2986//1811 2971//1792 2985//1808 +f 2981//1786 2996//1806 2997//2223 +f 2976//1788 2991//1807 2992//1810 +f 2987//1813 2972//2221 2986//1811 +f 2977//1791 2992//1810 2993//1812 +f 2988//1800 2973//1796 2987//1813 +f 2978//1793 2993//1812 2994//1814 +f 2992//1810 3007//1828 3008//2224 +f 3003//1818 2988//1800 3002//1816 +f 2993//1812 3008//2224 3009//1817 +f 3004//1822 2989//1804 3003//1818 +f 2999//1823 2984//1805 2998//1819 +f 2994//1814 3009//1817 3010//1820 +f 3005//2226 2990//1821 3004//1822 +f 3000//1826 2985//1808 2999//1823 +f 2995//1802 3010//1820 3011//1824 +f 2990//1821 3005//2226 3006//1825 +f 3001//1829 2986//1811 3000//1826 +f 2996//1806 3011//1824 3012//1827 +f 2991//1807 3006//1825 3007//1828 +f 3002//1816 2987//1813 3001//1829 +f 3027//1847 3012//1827 3026//2225 +f 3006//1825 3021//1842 3022//1831 +f 3001//1829 3016//1843 3017//1832 +f 3007//1828 3022//1831 3023//1833 +f 3002//1816 3017//1832 3018//1834 +f 3008//2224 3023//1833 3024//1835 +f 3003//1818 3018//1834 3019//1836 +f 2998//1819 3013//1854 3014//1837 +f 3025//1841 3010//1820 3024//1835 +f 3004//1822 3019//1836 3020//1839 +f 2999//1823 3014//1837 3015//1840 +f 3026//2225 3011//1824 3025//1841 +f 3005//2226 3020//1839 3021//1842 +f 3000//1826 3015//1840 3016//1843 +f 3041//1848 3026//2225 3040//1844 +f 3020//1839 3035//2229 3036//1845 +f 3015//1840 3030//1858 3031//1846 +f 3042//1866 3027//1847 3041//1848 +f 3037//2228 3022//1831 3036//1845 +f 3016//1843 3031//1846 3032//2227 +f 3038//1852 3023//1833 3037//2228 +f 3017//1832 3032//2227 3033//1851 +f 3039//1856 3024//1835 3038//1852 +f 3018//1834 3033//1851 3034//1853 +f 3013//1854 3028//1859 3029//1855 +f 3040//1844 3025//1841 3039//1856 +f 3019//1836 3034//1853 3035//2229 +f 3014//1837 3029//1855 3030//1858 +f 3028//1859 3043//1877 3044//1860 +f 3055//2231 3040//1844 3054//2230 +f 3034//1853 3049//2234 3050//1862 +f 3029//1855 3044//1860 3045//1863 +f 3056//1867 3041//1848 3055//2231 +f 3051//2232 3036//1845 3050//1862 +f 3030//1858 3045//1863 3046//1865 +f 3057//1884 3042//1866 3056//1867 +f 3052//1870 3037//2228 3051//2232 +f 3031//1846 3046//1865 3047//1869 +f 3053//1872 3038//1852 3052//1870 +f 3032//2227 3047//1869 3048//2233 +f 3054//2230 3039//1856 3053//1872 +f 3033//1851 3048//2233 3049//2234 +f 3047//1869 3062//1887 3063//1874 +f 3069//1879 3054//2230 3068//1875 +f 3048//2233 3063//1874 3064//1876 +f 3043//1877 3058//1895 3059//1878 +f 3070//2236 3055//2231 3069//1879 +f 3049//2234 3064//1876 3065//2235 +f 3044//1860 3059//1878 3060//1881 +f 3071//1885 3056//1867 3070//2236 +f 3066//1886 3051//2232 3065//2235 +f 3045//1863 3060//1881 3061//1883 +f 3072//1902 3057//1884 3071//1885 +f 3067//2237 3052//1870 3066//1886 +f 3046//1865 3061//1883 3062//1887 +f 3068//1875 3053//1872 3067//2237 +f 3082//1891 3067//2237 3081//2238 +f 3061//1883 3076//1901 3077//2239 +f 3083//1893 3068//1875 3082//1891 +f 3062//1887 3077//2239 3078//1892 +f 3084//1897 3069//1879 3083//1893 +f 3063//1874 3078//1892 3079//1894 +f 3058//1895 3073//2240 3074//1896 +f 3085//1900 3070//2236 3084//1897 +f 3064//1876 3079//1894 3080//1898 +f 3059//1878 3074//1896 3075//1899 +f 3086//1903 3071//1885 3085//1900 +f 3081//2238 3066//1886 3080//1898 +f 3060//1881 3075//1899 3076//1901 +f 3087//1907 3072//1902 3086//1903 +f 3101//1908 3086//1903 3100//1904 +f 3080//1898 3095//1917 3096//1905 +f 3075//1899 3090//2241 3091//1906 +f 3102//1927 3087//1907 3101//1908 +f 3097//1910 3082//1891 3096//1905 +f 3076//1901 3091//1906 3092//1909 +f 3098//1912 3083//1893 3097//1910 +f 3077//2239 3092//1909 3093//1911 +f 3099//1916 3084//1897 3098//1912 +f 3078//1892 3093//1911 3094//1913 +f 3073//2240 3088//2242 3089//1915 +f 3100//1904 3085//1900 3099//1916 +f 3079//1894 3094//1913 3095//1917 +f 3074//1896 3089//1915 3090//2241 +f 3088//2242 3103//2246 3104//2243 +f 3115//1924 3100//1904 3114//1921 +f 3094//1913 3109//1933 3110//1922 +f 3089//1915 3104//2243 3105//1923 +f 3116//1928 3101//1908 3115//1924 +f 3095//1917 3110//1922 3111//1925 +f 3090//2241 3105//1923 3106//2244 +f 3117//2247 3102//1927 3116//1928 +f 3112//2245 3097//1910 3111//1925 +f 3091//1906 3106//2244 3107//1929 +f 3113//1932 3098//1912 3112//2245 +f 3092//1909 3107//1929 3108//1931 +f 3114//1921 3099//1916 3113//1932 +f 3093//1911 3108//1931 3109//1933 +f 3107//1929 3122//2248 3123//1934 +f 3129//1939 3114//1921 3128//1935 +f 3108//1931 3123//1934 3124//1936 +f 3103//2246 3118//2250 3119//1938 +f 3130//1942 3115//1924 3129//1939 +f 3109//1933 3124//1936 3125//1940 +f 3104//2243 3119//1938 3120//1941 +f 3131//1946 3116//1928 3130//1942 +f 3110//1922 3125//1940 3126//1943 +f 3105//1923 3120//1941 3121//1944 +f 3132//2252 3117//2247 3131//1946 +f 3127//1948 3112//2245 3126//1943 +f 3106//2244 3121//1944 3122//2248 +f 3128//1935 3113//1932 3127//1948 +f 3126//1943 3141//1961 3142//1949 +f 3121//1944 3136//1962 3137//1950 +f 3127//1948 3142//1949 3143//1951 +f 3122//2248 3137//1950 3138//2249 +f 3128//1935 3143//1951 3144//1953 +f 3123//1934 3138//2249 3139//1954 +f 3134//1975 3119//1938 3133//2251 +f 3129//1939 3144//1953 3145//1957 +f 3124//1936 3139//1954 3140//1958 +f 3119//1938 3134//1975 3135//1959 +f 3130//1942 3145//1957 3146//1960 +f 3125//1940 3140//1958 3141//1961 +f 3120//1941 3135//1959 3136//1962 +f 3131//1946 3146//1960 3147//1964 +f 3145//1957 3160//1977 3161//2253 +f 3140//1958 3155//1978 3156//1966 +f 3151//1970 3136//1962 3150//1967 +f 3146//1960 3161//2253 3162//1968 +f 3141//1961 3156//1966 3157//1969 +f 3152//2254 3137//1950 3151//1970 +f 3142//1949 3157//1969 3158//1971 +f 3153//1974 3138//2249 3152//2254 +f 3143//1951 3158//1971 3159//1973 +f 3154//1981 3139//1954 3153//1974 +f 3149//1979 3134//1975 3148//1976 +f 3144//1953 3159//1973 3160//1977 +f 3139//1954 3154//1981 3155//1978 +f 3150//1967 3135//1959 3149//1979 +f 3159//1973 3174//1992 3175//1980 +f 3170//2261 3155//1978 3169//2255 +f 3165//1986 3150//1967 3164//1983 +f 3160//1977 3175//1980 3176//1984 +f 3155//1978 3170//2261 3171//2256 +f 3166//2258 3151//1970 3165//1986 +f 3161//2253 3176//1984 3177//2257 +f 3156//1966 3171//2256 3172//1988 +f 3167//1991 3152//2254 3166//2258 +f 3157//1969 3172//1988 3173//1990 +f 3168//1993 3153//1974 3167//1991 +f 3158//1971 3173//1990 3174//1992 +f 3169//2255 3154//1981 3168//1993 +f 3164//1983 3149//1979 3163//1994 +f 3173//1990 3188//2008 3189//2259 +f 3184//2262 3169//2255 3183//2260 +f 3179//2001 3164//1983 3178//1997 +f 3174//1992 3189//2259 3190//1998 +f 3185//2017 3170//2261 3184//2262 +f 3180//2264 3165//1986 3179//2001 +f 3175//1980 3190//1998 3191//2263 +f 3170//2261 3185//2017 3186//2003 +f 3181//2007 3166//2258 3180//2264 +f 3176//1984 3191//2263 3192//2005 +f 3171//2256 3186//2003 3187//2006 +f 3182//2265 3167//1991 3181//2007 +f 3172//1988 3187//2006 3188//2008 +f 3183//2260 3168//1993 3182//2265 +f 3197//2267 3182//2265 3196//2010 +f 3187//2006 3202//2024 3203//2266 +f 3198//2014 3183//2260 3197//2267 +f 3188//2008 3203//2266 3204//2013 +f 3199//2269 3184//2262 3198//2014 +f 3194//2019 3179//2001 3193//2268 +f 3189//2259 3204//2013 3205//2016 +f 3200//2025 3185//2017 3199//2269 +f 3195//2270 3180//2264 3194//2019 +f 3190//1998 3205//2016 3206//2020 +f 3185//2017 3200//2025 3201//2021 +f 3196//2010 3181//2007 3195//2270 +f 3191//2263 3206//2020 3207//2023 +f 3186//2003 3201//2021 3202//2024 +f 3200//2025 3215//2041 3216//2026 +f 3211//2030 3196//2010 3210//2027 +f 3206//2020 3221//2275 3222//2271 +f 3201//2021 3216//2026 3217//2029 +f 3212//2032 3197//2267 3211//2030 +f 3202//2024 3217//2029 3218//2031 +f 3213//2034 3198//2014 3212//2032 +f 3203//2266 3218//2031 3219//2272 +f 3214//2037 3199//2269 3213//2034 +f 3209//2038 3194//2019 3208//2273 +f 3204//2013 3219//2272 3220//2274 +f 3215//2041 3200//2025 3214//2037 +f 3210//2027 3195//2270 3209//2038 +f 3205//2016 3220//2274 3221//2275 +f 3219//2272 3235//2052 3236//2276 +f 3231//2059 3215//2041 3230//2042 +f 3226//2046 3210//2027 3225//2043 +f 3220//2274 3236//2276 3237//2277 +f 3215//2041 3231//2059 3232//2045 +f 3227//2049 3211//2030 3226//2046 +f 3221//2275 3237//2277 3238//2278 +f 3216//2026 3232//2045 3233//2048 +f 3228//2051 3212//2032 3227//2049 +f 3217//2029 3233//2048 3234//2050 +f 3229//2053 3213//2034 3228//2051 +f 3218//2031 3234//2050 3235//2052 +f 3230//2042 3214//2037 3229//2053 +f 3225//2043 3209//2038 3224//2054 +f 3234//2050 3249//2068 3250//2055 +f 3245//2060 3230//2042 3244//2056 +f 3240//2061 3225//2043 3239//2279 +f 3235//2052 3250//2055 3251//2058 +f 3246//2077 3231//2059 3245//2060 +f 3241//2064 3226//2046 3240//2061 +f 3236//2276 3251//2058 3252//2062 +f 3231//2059 3246//2077 3247//2063 +f 3242//2067 3227//2049 3241//2064 +f 3237//2277 3252//2062 3253//2280 +f 3232//2045 3247//2063 3248//2066 +f 3243//2281 3228//2051 3242//2067 +f 3233//2048 3248//2066 3249//2068 +f 3244//2056 3229//2053 3243//2281 +f 3258//2072 3243//2281 3257//2070 +f 3264//2073 3249//2068 3263//2071 +f 3259//2074 3244//2056 3258//2072 +f 3265//2076 3250//2055 3264//2073 +f 3260//2078 3245//2060 3259//2074 +f 3239//2279 3254//2094 3255//2282 +f 3266//2080 3251//2058 3265//2076 +f 3261//2081 3246//2077 3260//2078 +f 3240//2061 3255//2282 3256//2079 +f 3267//2082 3252//2062 3266//2080 +f 3262//2083 3247//2063 3261//2081 +f 3241//2064 3256//2079 3257//2070 +f 3268//2284 3253//2280 3267//2082 +f 3263//2071 3248//2066 3262//2083 +f 3277//2088 3262//2083 3276//2283 +f 3256//2079 3271//2097 3272//2085 +f 3283//2104 3268//2284 3282//2087 +f 3278//2090 3263//2071 3277//2088 +f 3257//2070 3272//2085 3273//2089 +f 3279//2092 3264//2073 3278//2090 +f 3258//2072 3273//2089 3274//2091 +f 3280//2096 3265//2076 3279//2092 +f 3259//2074 3274//2091 3275//2093 +f 3254//2094 3269//2112 3270//2095 +f 3281//2098 3266//2080 3280//2096 +f 3276//2283 3261//2081 3275//2093 +f 3255//2282 3270//2095 3271//2097 +f 3282//2087 3267//2082 3281//2098 +f 3296//2102 3281//2098 3295//2099 +f 3275//2093 3290//2287 3291//2100 +f 3270//2095 3285//2113 3286//2285 +f 3297//2105 3282//2087 3296//2102 +f 3292//2286 3277//2088 3291//2100 +f 3271//2097 3286//2285 3287//2103 +f 3298//2123 3283//2104 3297//2105 +f 3293//2108 3278//2090 3292//2286 +f 3272//2085 3287//2103 3288//2107 +f 3294//2110 3279//2092 3293//2108 +f 3273//2089 3288//2107 3289//2109 +f 3295//2099 3280//2096 3294//2110 +f 3274//2091 3289//2109 3290//2287 +f 3269//2112 3284//2116 3285//2113 +f 3310//2118 3295//2099 3309//2288 +f 3289//2109 3304//2290 3305//2115 +f 3284//2116 3299//2133 3300//2117 +f 3311//2121 3296//2102 3310//2118 +f 3290//2287 3305//2115 3306//2119 +f 3285//2113 3300//2117 3301//2120 +f 3312//2124 3297//2105 3311//2121 +f 3307//2125 3292//2286 3306//2119 +f 3286//2285 3301//2120 3302//2122 +f 3313//2140 3298//2123 3312//2124 +f 3308//2289 3293//2108 3307//2125 +f 3287//2103 3302//2122 3303//2126 +f 3309//2288 3294//2110 3308//2289 +f 3288//2107 3303//2126 3304//2290 +f 3324//2131 3309//2288 3323//2129 +f 3303//2126 3318//2143 3319//2130 +f 3325//2292 3310//2118 3324//2131 +f 3304//2290 3319//2130 3320//2291 +f 3299//2133 3314//2153 3315//2134 +f 3326//2138 3311//2121 3325//2292 +f 3305//2115 3320//2291 3321//2136 +f 3300//2117 3315//2134 3316//2137 +f 3327//2141 3312//2124 3326//2138 +f 3322//2142 3307//2125 3321//2136 +f 3301//2120 3316//2137 3317//2293 +f 3328//2145 3313//2140 3327//2141 +f 3323//2129 3308//2289 3322//2142 +f 3302//2122 3317//2293 3318//2143 +f 3316//2137 3331//2156 3332//2144 +f 3343//2295 3328//2145 3342//2146 +f 3338//2149 3323//2129 3337//2147 +f 3317//2293 3332//2144 3333//2148 +f 3339//2151 3324//2131 3338//2149 +f 3318//2143 3333//2148 3334//2150 +f 3340//2155 3325//2292 3339//2151 +f 3319//2130 3334//2150 3335//2152 +f 3314//2153 3329//2171 3330//2154 +f 3341//2294 3326//2138 3340//2155 +f 3336//2158 3321//2136 3335//2152 +f 3315//2134 3330//2154 3331//2156 +f 3342//2146 3327//2141 3341//2294 +f 3337//2147 3322//2142 3336//2158 +f 3352//2162 3336//2158 3351//2159 +f 3330//2154 3346//2172 3347//2160 +f 3358//2296 3342//2146 3357//2161 +f 3353//2166 3337//2147 3352//2162 +f 3331//2156 3347//2160 3348//2163 +f 3359//2183 3343//2295 3358//2296 +f 3354//2168 3338//2149 3353//2166 +f 3332//2144 3348//2163 3349//2167 +f 3355//2170 3339//2151 3354//2168 +f 3333//2148 3349//2167 3350//2297 +f 3356//2298 3340//2155 3355//2170 +f 3334//2150 3350//2297 3351//2159 +f 3329//2171 3345//2176 3346//2172 +f 3357//2161 3341//2294 3356//2298 +f 3371//2178 3356//2298 3370//2174 +f 3350//2297 3365//2188 3366//2299 +f 3345//2176 3360//2302 3361//2300 +f 3372//2180 3357//2161 3371//2178 +f 3367//2181 3352//2162 3366//2299 +f 3346//2172 3361//2300 3362//2179 +f 3373//2301 3358//2296 3372//2180 +f 3368//2185 3353//2166 3367//2181 +f 3347//2160 3362//2179 3363//2182 +f 3374//2191 3359//2183 3373//2301 +f 3369//2187 3354//2168 3368//2185 +f 3348//2163 3363//2182 3364//2186 +f 3370//2174 3355//2170 3369//2187 +f 3349//2167 3364//2186 3365//2188 +f 2903//2200 3370//2174 2902//1732 +f 2898//2193 3365//2188 2897//1734 +f 2904//1718 3371//2178 2903//2200 +f 2899//1711 3366//2299 2898//2193 +f 2894//1714 3361//2300 2893//1715 +f 2905//2195 3372//2180 2904//1718 +f 2900//1720 3367//2181 2899//1711 +f 2895//1722 3362//2179 2894//1714 +f 2906//1724 3373//2301 2905//2195 +f 2901//1726 3368//2185 2900//1720 +f 2896//1728 3363//2182 2895//1722 +f 3373//2301 2906//1724 2907//2198 +f 2902//1732 3369//2187 2901//1726 +f 2897//1734 3364//2186 2896//1728 +o Hand_R_Sphere.011 +v 0.276990 0.207506 -0.985293 +v 0.262213 0.191256 -0.973294 +v 0.249047 0.176916 -0.960609 +v 0.238000 0.165034 -0.947728 +v 0.229496 0.156070 -0.935144 +v 0.223861 0.150366 -0.923341 +v 0.221312 0.148142 -0.912773 +v 0.221947 0.149484 -0.903846 +v 0.225742 0.154339 -0.896902 +v 0.232551 0.162523 -0.892210 +v 0.242112 0.173718 -0.889948 +v 0.254057 0.187497 -0.890205 +v 0.267928 0.203329 -0.892970 +v 0.283192 0.220605 -0.898136 +v 0.299262 0.238662 -0.905506 +v 0.279455 0.206252 -0.985965 +v 0.267048 0.188797 -0.974612 +v 0.256066 0.173344 -0.962524 +v 0.246934 0.160489 -0.950164 +v 0.240001 0.150725 -0.938009 +v 0.235533 0.144427 -0.926524 +v 0.233703 0.141838 -0.916152 +v 0.234581 0.143056 -0.907291 +v 0.238133 0.148035 -0.900282 +v 0.244223 0.156584 -0.895393 +v 0.252616 0.168374 -0.892813 +v 0.262991 0.182952 -0.892641 +v 0.274947 0.199757 -0.894884 +v 0.288027 0.218145 -0.899455 +v 0.301727 0.237408 -0.906178 +v 0.282442 0.205732 -0.986998 +v 0.272906 0.187776 -0.976639 +v 0.264571 0.171863 -0.965467 +v 0.257758 0.158603 -0.953910 +v 0.252729 0.148507 -0.942413 +v 0.249676 0.141963 -0.931418 +v 0.248717 0.139222 -0.921348 +v 0.249889 0.140389 -0.912589 +v 0.253147 0.145419 -0.905477 +v 0.258366 0.154120 -0.900287 +v 0.265344 0.166156 -0.897218 +v 0.273815 0.181066 -0.896387 +v 0.283452 0.198276 -0.897827 +v 0.293885 0.217125 -0.901482 +v 0.304713 0.236888 -0.907212 +v 0.285835 0.205965 -0.988353 +v 0.279562 0.188234 -0.979297 +v 0.274235 0.172527 -0.969325 +v 0.270057 0.159449 -0.958821 +v 0.267191 0.149502 -0.948188 +v 0.265746 0.143068 -0.937835 +v 0.265777 0.140395 -0.928160 +v 0.267283 0.141585 -0.919534 +v 0.270207 0.146593 -0.912289 +v 0.274436 0.155225 -0.906704 +v 0.279807 0.167151 -0.902993 +v 0.286114 0.181912 -0.901298 +v 0.293115 0.198940 -0.901685 +v 0.300541 0.217582 -0.904140 +v 0.308106 0.237121 -0.908567 +v 0.289505 0.206943 -0.989978 +v 0.286761 0.190152 -0.982483 +v 0.284686 0.175313 -0.973951 +v 0.283359 0.162995 -0.964709 +v 0.282832 0.153671 -0.955111 +v 0.283125 0.147701 -0.945527 +v 0.284226 0.145313 -0.936326 +v 0.286094 0.146599 -0.927860 +v 0.288657 0.151510 -0.920455 +v 0.291815 0.159857 -0.914396 +v 0.295448 0.171320 -0.909916 +v 0.299416 0.185457 -0.907186 +v 0.303566 0.201726 -0.906311 +v 0.307740 0.219501 -0.907326 +v 0.311776 0.238100 -0.910191 +v 0.293310 0.208629 -0.991809 +v 0.294225 0.193458 -0.986076 +v 0.295522 0.180112 -0.979166 +v 0.297152 0.169103 -0.971346 +v 0.299050 0.160854 -0.962916 +v 0.301146 0.155682 -0.954200 +v 0.303357 0.153786 -0.945533 +v 0.305600 0.155238 -0.937247 +v 0.307787 0.159983 -0.929662 +v 0.309836 0.167838 -0.923069 +v 0.311666 0.178503 -0.917721 +v 0.313208 0.191566 -0.913823 +v 0.314403 0.206525 -0.911527 +v 0.315204 0.222807 -0.910919 +v 0.315582 0.239785 -0.912023 +v 0.297105 0.210956 -0.993777 +v 0.301669 0.198024 -0.989936 +v 0.306329 0.186741 -0.984771 +v 0.310905 0.177540 -0.978479 +v 0.315223 0.170775 -0.971304 +v 0.319116 0.166705 -0.963520 +v 0.322434 0.165488 -0.955427 +v 0.325051 0.167169 -0.947335 +v 0.326864 0.171685 -0.939556 +v 0.327806 0.178862 -0.932389 +v 0.327839 0.188423 -0.926108 +v 0.326962 0.200003 -0.920957 +v 0.325209 0.213154 -0.917131 +v 0.322648 0.227373 -0.914779 +v 0.319376 0.242113 -0.913991 +v 0.300743 0.213837 -0.995806 +v 0.308805 0.203675 -0.993916 +v 0.316689 0.194945 -0.990549 +v 0.324091 0.187981 -0.985834 +v 0.330728 0.183052 -0.979951 +v 0.336344 0.180347 -0.973128 +v 0.340724 0.179970 -0.965627 +v 0.343699 0.181935 -0.957735 +v 0.345154 0.186167 -0.949757 +v 0.345034 0.192504 -0.941997 +v 0.343344 0.200701 -0.934756 +v 0.340148 0.210444 -0.928311 +v 0.335570 0.221358 -0.922909 +v 0.329784 0.233024 -0.918759 +v 0.323014 0.244993 -0.916020 +v 0.304085 0.217160 -0.997818 +v 0.315360 0.210193 -0.997863 +v 0.326205 0.204408 -0.996279 +v 0.336203 0.200025 -0.993126 +v 0.344970 0.197214 -0.988527 +v 0.352169 0.196083 -0.982657 +v 0.357524 0.196675 -0.975742 +v 0.360827 0.198968 -0.968049 +v 0.361954 0.202873 -0.959872 +v 0.360859 0.208240 -0.951526 +v 0.357586 0.214863 -0.943331 +v 0.352260 0.222488 -0.935603 +v 0.345086 0.230821 -0.928639 +v 0.336339 0.239542 -0.922706 +v 0.326356 0.248316 -0.918032 +v 0.307001 0.220797 -0.999736 +v 0.321082 0.217328 -1.001625 +v 0.334512 0.214766 -1.001740 +v 0.346776 0.213209 -1.000077 +v 0.357402 0.212717 -0.996700 +v 0.365983 0.213309 -0.991738 +v 0.372188 0.214962 -0.985383 +v 0.375779 0.217613 -0.977879 +v 0.376618 0.221160 -0.969513 +v 0.374673 0.225466 -0.960607 +v 0.370018 0.230366 -0.951505 +v 0.362832 0.235672 -0.942554 +v 0.353392 0.241179 -0.934100 +v 0.342061 0.246677 -0.926467 +v 0.329273 0.251954 -0.919949 +v 0.309381 0.224610 -1.001486 +v 0.325750 0.224806 -1.005057 +v 0.341289 0.225623 -1.006723 +v 0.355402 0.227027 -1.006419 +v 0.367545 0.228965 -1.004157 +v 0.377253 0.231363 -1.000025 +v 0.384153 0.234128 -0.994180 +v 0.387978 0.237154 -0.986847 +v 0.388583 0.240325 -0.978309 +v 0.385943 0.243519 -0.968893 +v 0.380161 0.246614 -0.958962 +v 0.371459 0.249489 -0.948896 +v 0.360170 0.252036 -0.939083 +v 0.346729 0.254155 -0.929900 +v 0.331653 0.255766 -0.921699 +v 0.311133 0.228450 -1.003000 +v 0.329186 0.232340 -1.008028 +v 0.346277 0.236559 -1.011036 +v 0.361750 0.240947 -1.011908 +v 0.375011 0.245333 -1.010612 +v 0.385548 0.249550 -1.007197 +v 0.392959 0.253435 -1.001794 +v 0.396957 0.256840 -0.994611 +v 0.397389 0.259633 -0.985923 +v 0.394238 0.261706 -0.976066 +v 0.387626 0.262982 -0.965417 +v 0.377807 0.263409 -0.954385 +v 0.365158 0.262972 -0.943396 +v 0.350165 0.261688 -0.932871 +v 0.333404 0.259606 -0.923214 +v 0.312189 0.232171 -1.004221 +v 0.331257 0.239639 -1.010423 +v 0.349284 0.247156 -1.014513 +v 0.365578 0.254434 -1.016334 +v 0.379511 0.261192 -1.015816 +v 0.390549 0.267172 -1.012979 +v 0.398267 0.272143 -1.007932 +v 0.402369 0.275914 -1.000870 +v 0.402697 0.278340 -0.992062 +v 0.399239 0.279329 -0.981848 +v 0.392127 0.278841 -0.970621 +v 0.381635 0.276896 -0.958811 +v 0.368165 0.273569 -0.946873 +v 0.352236 0.268988 -0.935266 +v 0.334460 0.263328 -0.924435 +v 0.312509 0.235630 -1.005102 +v 0.331884 0.246424 -1.012151 +v 0.350195 0.257006 -1.017021 +v 0.366737 0.266971 -1.019526 +v 0.380874 0.275934 -1.019570 +v 0.392063 0.283552 -1.017150 +v 0.399874 0.289531 -1.012360 +v 0.404008 0.293643 -1.005384 +v 0.404305 0.295729 -0.996490 +v 0.400753 0.295708 -0.986019 +v 0.393489 0.293582 -0.974374 +v 0.382793 0.289433 -0.962003 +v 0.369076 0.283419 -0.949381 +v 0.352864 0.275773 -0.936993 +v 0.334780 0.266786 -0.925315 +v 0.312080 0.238694 -1.005608 +v 0.331043 0.252433 -1.013144 +v 0.348974 0.265731 -1.018463 +v 0.365182 0.278074 -1.021362 +v 0.379046 0.288991 -1.021729 +v 0.390032 0.298060 -1.019549 +v 0.397719 0.304933 -1.014906 +v 0.401810 0.309346 -1.007980 +v 0.402149 0.311130 -0.999036 +v 0.398722 0.310216 -0.988418 +v 0.391662 0.306639 -0.976533 +v 0.381239 0.300537 -0.963839 +v 0.367854 0.292144 -0.950824 +v 0.352022 0.281782 -0.937987 +v 0.334351 0.269850 -0.925822 +v 0.310919 0.241244 -1.005721 +v 0.328766 0.257436 -1.013366 +v 0.345668 0.272994 -1.018785 +v 0.360975 0.287319 -1.021771 +v 0.374098 0.299861 -1.022209 +v 0.384535 0.310138 -1.020083 +v 0.391882 0.317756 -1.015474 +v 0.395859 0.322420 -1.008559 +v 0.396312 0.323953 -0.999603 +v 0.393224 0.322295 -0.988952 +v 0.386714 0.317510 -0.977014 +v 0.377031 0.309782 -0.964248 +v 0.364548 0.299407 -0.951145 +v 0.349745 0.286785 -0.938208 +v 0.333190 0.272401 -0.925935 +v 0.309071 0.243184 -1.005436 +v 0.325140 0.261241 -1.012806 +v 0.340404 0.278517 -1.017973 +v 0.354275 0.294349 -1.020737 +v 0.366221 0.308128 -1.020994 +v 0.375781 0.319324 -1.018733 +v 0.382590 0.327507 -1.014040 +v 0.386385 0.332362 -1.007097 +v 0.387020 0.333704 -0.998169 +v 0.384471 0.331480 -0.987601 +v 0.378836 0.325776 -0.975798 +v 0.370332 0.316812 -0.963214 +v 0.359285 0.304931 -0.950333 +v 0.346120 0.290590 -0.937649 +v 0.331342 0.274340 -0.925650 +v 0.306606 0.244438 -1.004764 +v 0.320306 0.263701 -1.011487 +v 0.333385 0.282089 -1.016058 +v 0.345342 0.298894 -1.018301 +v 0.355716 0.313472 -1.018129 +v 0.364109 0.325262 -1.015549 +v 0.370199 0.333811 -1.010660 +v 0.373751 0.338790 -1.003651 +v 0.374629 0.340009 -0.994790 +v 0.372799 0.337419 -0.984418 +v 0.368332 0.331121 -0.972933 +v 0.361398 0.321357 -0.960778 +v 0.352266 0.308502 -0.948419 +v 0.341285 0.293050 -0.936330 +v 0.328877 0.275594 -0.924977 +v 0.303619 0.244958 -1.003730 +v 0.314447 0.264722 -1.009460 +v 0.324880 0.283570 -1.013115 +v 0.334517 0.300780 -1.014555 +v 0.342988 0.315690 -1.013724 +v 0.349967 0.327726 -1.010655 +v 0.355185 0.336427 -1.005465 +v 0.358443 0.341458 -0.998354 +v 0.359615 0.342624 -0.989594 +v 0.358656 0.339883 -0.979524 +v 0.355604 0.333339 -0.968529 +v 0.350574 0.323243 -0.957032 +v 0.343761 0.309984 -0.945476 +v 0.335427 0.294070 -0.934303 +v 0.325891 0.276115 -0.923944 +v 0.300226 0.244725 -1.002375 +v 0.307791 0.264264 -1.006802 +v 0.315217 0.282906 -1.009257 +v 0.322218 0.299934 -1.009644 +v 0.328525 0.314695 -1.007950 +v 0.333897 0.326621 -1.004239 +v 0.338126 0.335254 -0.998653 +v 0.341049 0.340261 -0.991409 +v 0.342556 0.341451 -0.982783 +v 0.342587 0.338778 -0.973107 +v 0.341141 0.332344 -0.962754 +v 0.338275 0.322397 -0.952121 +v 0.334098 0.309319 -0.941617 +v 0.328770 0.293612 -0.931645 +v 0.322497 0.275881 -0.922589 +v 0.296556 0.243747 -1.000751 +v 0.300592 0.262345 -1.003616 +v 0.304766 0.280120 -1.004631 +v 0.308917 0.296389 -1.003757 +v 0.312885 0.310526 -1.001027 +v 0.316517 0.321989 -0.996546 +v 0.319676 0.330336 -0.990487 +v 0.322238 0.335247 -0.983082 +v 0.324106 0.336533 -0.974617 +v 0.325207 0.334145 -0.965415 +v 0.325500 0.328175 -0.955831 +v 0.324973 0.318852 -0.946234 +v 0.323647 0.306533 -0.936991 +v 0.321572 0.291694 -0.928459 +v 0.318828 0.274903 -0.920965 +v 0.292751 0.242061 -0.998920 +v 0.293128 0.259039 -1.000024 +v 0.293929 0.275321 -0.999416 +v 0.295124 0.290281 -0.997119 +v 0.296666 0.303344 -0.993221 +v 0.298497 0.314008 -0.987873 +v 0.300545 0.321863 -0.981280 +v 0.302732 0.326608 -0.973695 +v 0.304975 0.328061 -0.965410 +v 0.307186 0.326164 -0.956742 +v 0.309282 0.320992 -0.948026 +v 0.311181 0.312743 -0.939596 +v 0.312810 0.301734 -0.931776 +v 0.314107 0.288388 -0.924866 +v 0.315022 0.273218 -0.919133 +v 0.315520 0.256806 -0.914796 +v 0.288956 0.239734 -0.996952 +v 0.285684 0.254473 -0.996163 +v 0.283123 0.268692 -0.993811 +v 0.281370 0.281844 -0.989986 +v 0.280494 0.293423 -0.984834 +v 0.280527 0.302984 -0.978554 +v 0.281468 0.310161 -0.971386 +v 0.283282 0.314677 -0.963607 +v 0.285898 0.316358 -0.955516 +v 0.289216 0.315141 -0.947422 +v 0.293109 0.311071 -0.939638 +v 0.297427 0.304306 -0.932463 +v 0.302004 0.295105 -0.926171 +v 0.306664 0.283822 -0.921006 +v 0.311228 0.270890 -0.917165 +v 0.285318 0.236853 -0.994923 +v 0.278548 0.248822 -0.992183 +v 0.272763 0.260488 -0.988033 +v 0.268184 0.271403 -0.982632 +v 0.264988 0.281145 -0.976186 +v 0.263298 0.289342 -0.968945 +v 0.263178 0.295679 -0.961186 +v 0.264634 0.299911 -0.953207 +v 0.267608 0.301876 -0.945315 +v 0.271988 0.301499 -0.937814 +v 0.277604 0.298794 -0.930991 +v 0.284241 0.293865 -0.925109 +v 0.291644 0.286902 -0.920393 +v 0.299527 0.278171 -0.917026 +v 0.307589 0.268009 -0.915136 +v 0.281976 0.233530 -0.992911 +v 0.271993 0.242304 -0.988237 +v 0.263246 0.251026 -0.982303 +v 0.256072 0.259359 -0.975339 +v 0.250746 0.266983 -0.967611 +v 0.247473 0.273606 -0.959417 +v 0.246379 0.278973 -0.951071 +v 0.247505 0.282878 -0.942894 +v 0.250809 0.285171 -0.935200 +v 0.256163 0.285763 -0.928286 +v 0.263362 0.284632 -0.922416 +v 0.272129 0.281821 -0.917816 +v 0.282127 0.277439 -0.914664 +v 0.292972 0.271653 -0.913079 +v 0.304248 0.264686 -0.913124 +v 0.279060 0.229892 -0.990993 +v 0.266272 0.235169 -0.984475 +v 0.254940 0.240667 -0.976842 +v 0.245500 0.246175 -0.968388 +v 0.238315 0.251480 -0.959438 +v 0.233660 0.256380 -0.950335 +v 0.231715 0.260687 -0.941430 +v 0.232554 0.264233 -0.933064 +v 0.236145 0.266884 -0.925559 +v 0.242350 0.268537 -0.919204 +v 0.250930 0.269129 -0.914242 +v 0.261557 0.268637 -0.910865 +v 0.273821 0.267080 -0.909202 +v 0.287251 0.264518 -0.909318 +v 0.301331 0.261049 -0.911206 +v 0.276680 0.226080 -0.989243 +v 0.261603 0.227691 -0.981043 +v 0.248162 0.229811 -0.971859 +v 0.236874 0.232357 -0.962046 +v 0.228171 0.235233 -0.951980 +v 0.222389 0.238327 -0.942049 +v 0.219750 0.241521 -0.932633 +v 0.220354 0.244692 -0.924095 +v 0.224180 0.247719 -0.916763 +v 0.231079 0.250484 -0.910918 +v 0.240787 0.252881 -0.906785 +v 0.252931 0.254820 -0.904523 +v 0.267043 0.256224 -0.904220 +v 0.282582 0.257040 -0.905885 +v 0.298951 0.257237 -0.909457 +v 0.274928 0.222240 -0.987729 +v 0.258167 0.220158 -0.978072 +v 0.243174 0.218874 -0.967546 +v 0.230525 0.218437 -0.956557 +v 0.220706 0.218865 -0.945526 +v 0.214094 0.220140 -0.934877 +v 0.210944 0.222214 -0.925019 +v 0.211376 0.225007 -0.916332 +v 0.215374 0.228411 -0.909149 +v 0.222784 0.232296 -0.903746 +v 0.233322 0.236513 -0.900330 +v 0.246582 0.240900 -0.899034 +v 0.262055 0.245287 -0.899907 +v 0.279146 0.249506 -0.902915 +v 0.297199 0.253396 -0.907942 +v 0.273872 0.218519 -0.986508 +v 0.256096 0.212858 -0.975677 +v 0.240167 0.208277 -0.964069 +v 0.226698 0.204950 -0.952131 +v 0.216205 0.203005 -0.940322 +v 0.209094 0.202518 -0.929094 +v 0.205635 0.203506 -0.918880 +v 0.205963 0.205932 -0.910073 +v 0.210065 0.209704 -0.903010 +v 0.217783 0.214674 -0.897963 +v 0.228821 0.220654 -0.895126 +v 0.242755 0.227412 -0.894608 +v 0.259048 0.234690 -0.896429 +v 0.277075 0.242207 -0.900519 +v 0.296143 0.249675 -0.906721 +v 0.273552 0.215060 -0.985627 +v 0.255469 0.206074 -0.973949 +v 0.239257 0.198427 -0.961561 +v 0.225539 0.192413 -0.948939 +v 0.214843 0.188264 -0.936568 +v 0.207580 0.186138 -0.924923 +v 0.204028 0.186117 -0.914453 +v 0.204324 0.188203 -0.905558 +v 0.208458 0.192315 -0.898582 +v 0.216269 0.198295 -0.893792 +v 0.227459 0.205912 -0.891373 +v 0.241596 0.214876 -0.891416 +v 0.258137 0.224840 -0.893921 +v 0.276448 0.235422 -0.898792 +v 0.295824 0.246216 -0.905840 +v 0.292812 0.225040 -0.996146 +v 0.273981 0.211996 -0.985120 +v 0.256310 0.200064 -0.972956 +v 0.240478 0.189703 -0.960119 +v 0.227093 0.181309 -0.947103 +v 0.216671 0.175207 -0.934409 +v 0.209610 0.171630 -0.922525 +v 0.206184 0.170716 -0.911906 +v 0.206523 0.172500 -0.902962 +v 0.210614 0.176913 -0.896036 +v 0.218300 0.183787 -0.891394 +v 0.229286 0.192856 -0.889214 +v 0.243150 0.203772 -0.889580 +v 0.259359 0.216116 -0.892479 +v 0.277289 0.229413 -0.897798 +v 0.296253 0.243153 -0.905334 +v 0.275142 0.209446 -0.985008 +v 0.258587 0.195061 -0.972734 +v 0.243784 0.182439 -0.959797 +v 0.231301 0.172065 -0.946694 +v 0.221618 0.164336 -0.933928 +v 0.215108 0.159551 -0.921991 +v 0.212020 0.157893 -0.911339 +v 0.212473 0.159426 -0.902384 +v 0.216450 0.164090 -0.895469 +v 0.223798 0.171708 -0.890859 +v 0.234234 0.181985 -0.888733 +v 0.247358 0.194527 -0.889171 +v 0.262665 0.208852 -0.892158 +v 0.279566 0.224410 -0.897577 +v 0.297413 0.240602 -0.905221 +v 0.218203 0.254350 -0.972109 +v 0.203426 0.238100 -0.960110 +v 0.190261 0.223760 -0.947426 +v 0.179213 0.211878 -0.934544 +v 0.170709 0.202914 -0.921960 +v 0.165074 0.197210 -0.910158 +v 0.162525 0.194986 -0.899589 +v 0.163160 0.196328 -0.890662 +v 0.166955 0.201183 -0.883719 +v 0.173764 0.209366 -0.879026 +v 0.183325 0.220562 -0.876765 +v 0.195270 0.234341 -0.877021 +v 0.209141 0.250173 -0.879786 +v 0.224405 0.267449 -0.884953 +v 0.240475 0.285506 -0.892323 +v 0.220668 0.253096 -0.972782 +v 0.208261 0.235641 -0.961429 +v 0.197280 0.220188 -0.949340 +v 0.188147 0.207333 -0.936981 +v 0.181214 0.197569 -0.924825 +v 0.176746 0.191271 -0.913341 +v 0.174916 0.188682 -0.902969 +v 0.175794 0.189900 -0.894108 +v 0.179346 0.194879 -0.887098 +v 0.185436 0.203428 -0.882210 +v 0.193829 0.215218 -0.879630 +v 0.204204 0.229796 -0.879458 +v 0.216160 0.246601 -0.881701 +v 0.229240 0.264989 -0.886271 +v 0.242940 0.284252 -0.892995 +v 0.223655 0.252576 -0.973815 +v 0.214119 0.234620 -0.963456 +v 0.205784 0.218707 -0.952283 +v 0.198971 0.205447 -0.940727 +v 0.193942 0.195351 -0.929230 +v 0.190889 0.188807 -0.918235 +v 0.189930 0.186066 -0.908164 +v 0.191102 0.187233 -0.899405 +v 0.194360 0.192263 -0.892294 +v 0.199579 0.200964 -0.887104 +v 0.206557 0.213000 -0.884034 +v 0.215028 0.227910 -0.883204 +v 0.224665 0.245120 -0.884644 +v 0.235098 0.263969 -0.888299 +v 0.245926 0.283732 -0.894028 +v 0.227048 0.252809 -0.975170 +v 0.220775 0.235078 -0.966114 +v 0.215448 0.219371 -0.956142 +v 0.211271 0.206293 -0.945638 +v 0.208404 0.196346 -0.935005 +v 0.206959 0.189912 -0.924652 +v 0.206990 0.187239 -0.914976 +v 0.208496 0.188429 -0.906350 +v 0.211420 0.193437 -0.899106 +v 0.215649 0.202069 -0.893520 +v 0.221020 0.213995 -0.889809 +v 0.227327 0.228756 -0.888115 +v 0.234328 0.245784 -0.888502 +v 0.241754 0.264426 -0.890956 +v 0.249319 0.283965 -0.895383 +v 0.230718 0.253787 -0.976794 +v 0.227974 0.236996 -0.969300 +v 0.225899 0.222157 -0.960768 +v 0.224572 0.209839 -0.951525 +v 0.224045 0.200515 -0.941928 +v 0.224338 0.194545 -0.932344 +v 0.225440 0.192157 -0.923142 +v 0.227307 0.193443 -0.914677 +v 0.229870 0.198354 -0.907272 +v 0.233028 0.206701 -0.901213 +v 0.236661 0.218164 -0.896732 +v 0.240629 0.232301 -0.894002 +v 0.244779 0.248570 -0.893128 +v 0.248953 0.266345 -0.894143 +v 0.252989 0.284944 -0.897008 +v 0.234523 0.255472 -0.978626 +v 0.235438 0.240302 -0.972892 +v 0.236735 0.226956 -0.965983 +v 0.238365 0.215947 -0.958163 +v 0.240264 0.207698 -0.949733 +v 0.242359 0.202526 -0.941017 +v 0.244570 0.200629 -0.932349 +v 0.246813 0.202082 -0.924064 +v 0.249001 0.206827 -0.916479 +v 0.251049 0.214682 -0.909886 +v 0.252879 0.225347 -0.904537 +v 0.254422 0.238410 -0.900640 +v 0.255616 0.253369 -0.898343 +v 0.256418 0.269651 -0.897735 +v 0.256795 0.286629 -0.898839 +v 0.238318 0.257800 -0.980594 +v 0.242882 0.244868 -0.976753 +v 0.247542 0.233585 -0.971587 +v 0.252118 0.224384 -0.965296 +v 0.256436 0.217619 -0.958120 +v 0.260329 0.213549 -0.950336 +v 0.263647 0.212332 -0.942243 +v 0.266264 0.214013 -0.934152 +v 0.268077 0.218529 -0.926373 +v 0.269019 0.225706 -0.919205 +v 0.269052 0.235267 -0.912925 +v 0.268175 0.246847 -0.907773 +v 0.266422 0.259998 -0.903948 +v 0.263861 0.274217 -0.901596 +v 0.260589 0.288957 -0.900807 +v 0.241956 0.260681 -0.982623 +v 0.250018 0.250519 -0.980733 +v 0.257902 0.241789 -0.977365 +v 0.265305 0.234825 -0.972650 +v 0.271941 0.229896 -0.966768 +v 0.277558 0.227191 -0.959945 +v 0.281937 0.226814 -0.952444 +v 0.284912 0.228779 -0.944552 +v 0.286367 0.233011 -0.936573 +v 0.286247 0.239348 -0.928814 +v 0.284557 0.247545 -0.921573 +v 0.281361 0.257288 -0.915127 +v 0.276783 0.268202 -0.909726 +v 0.270997 0.279868 -0.905576 +v 0.264227 0.291837 -0.902836 +v 0.245298 0.264004 -0.984635 +v 0.256573 0.257037 -0.984680 +v 0.267418 0.251252 -0.983095 +v 0.277416 0.246869 -0.979943 +v 0.286184 0.244058 -0.975343 +v 0.293383 0.242927 -0.969473 +v 0.298737 0.243519 -0.962559 +v 0.302041 0.245812 -0.954865 +v 0.303167 0.249717 -0.946688 +v 0.302072 0.255084 -0.938342 +v 0.298799 0.261707 -0.930148 +v 0.293473 0.269332 -0.922420 +v 0.286299 0.277665 -0.915456 +v 0.277552 0.286386 -0.909522 +v 0.267569 0.295160 -0.904848 +v 0.248215 0.267641 -0.986552 +v 0.262295 0.264172 -0.988441 +v 0.275725 0.261610 -0.988557 +v 0.287989 0.260053 -0.986894 +v 0.298615 0.259561 -0.983517 +v 0.307196 0.260153 -0.978555 +v 0.313401 0.261806 -0.972200 +v 0.316992 0.264457 -0.964695 +v 0.317831 0.268004 -0.956329 +v 0.315886 0.272310 -0.947424 +v 0.311231 0.277210 -0.938321 +v 0.304045 0.282516 -0.929371 +v 0.294606 0.288023 -0.920917 +v 0.283274 0.293521 -0.913284 +v 0.270486 0.298798 -0.906766 +v 0.250594 0.271454 -0.988302 +v 0.266963 0.271650 -0.991874 +v 0.282502 0.272467 -0.993539 +v 0.296615 0.273871 -0.993236 +v 0.308758 0.275809 -0.990974 +v 0.318466 0.278207 -0.986841 +v 0.325366 0.280972 -0.980996 +v 0.329191 0.283998 -0.973664 +v 0.329796 0.287169 -0.965126 +v 0.327156 0.290363 -0.955710 +v 0.321374 0.293457 -0.945778 +v 0.312672 0.296333 -0.935713 +v 0.301383 0.298880 -0.925900 +v 0.287942 0.300999 -0.916716 +v 0.272866 0.302610 -0.908516 +v 0.252346 0.275294 -0.989817 +v 0.270399 0.279184 -0.994844 +v 0.287490 0.283403 -0.997852 +v 0.302964 0.287791 -0.998725 +v 0.316224 0.292177 -0.997429 +v 0.326762 0.296394 -0.994013 +v 0.334172 0.300279 -0.988610 +v 0.338170 0.303684 -0.981427 +v 0.338602 0.306476 -0.972740 +v 0.335451 0.308550 -0.962882 +v 0.328840 0.309826 -0.952233 +v 0.319020 0.310253 -0.941202 +v 0.306371 0.309816 -0.930213 +v 0.291378 0.308532 -0.919687 +v 0.274617 0.306450 -0.910030 +v 0.253402 0.279015 -0.991038 +v 0.272470 0.286483 -0.997240 +v 0.290498 0.294000 -1.001330 +v 0.306791 0.301278 -1.003151 +v 0.320724 0.308036 -1.002633 +v 0.331762 0.314016 -0.999796 +v 0.339480 0.318987 -0.994749 +v 0.343582 0.322758 -0.987686 +v 0.343910 0.325184 -0.978878 +v 0.340452 0.326172 -0.968665 +v 0.333340 0.325685 -0.957437 +v 0.322848 0.323740 -0.945628 +v 0.309378 0.320413 -0.933690 +v 0.293450 0.315832 -0.922082 +v 0.275673 0.310172 -0.911251 +v 0.253722 0.282474 -0.991919 +v 0.273097 0.293268 -0.998967 +v 0.291408 0.303850 -1.003838 +v 0.307950 0.313814 -1.006343 +v 0.322087 0.322778 -1.006386 +v 0.333276 0.330396 -1.003967 +v 0.341088 0.336375 -0.999177 +v 0.345221 0.340487 -0.992200 +v 0.345518 0.342573 -0.983306 +v 0.341966 0.342552 -0.972835 +v 0.334702 0.340426 -0.961191 +v 0.324006 0.336277 -0.948820 +v 0.310289 0.330263 -0.936198 +v 0.294077 0.322616 -0.923810 +v 0.275993 0.313630 -0.912132 +v 0.253293 0.285538 -0.992425 +v 0.272256 0.299277 -0.999961 +v 0.290187 0.312575 -1.005280 +v 0.306395 0.324918 -1.008179 +v 0.320259 0.335835 -1.008545 +v 0.331245 0.344904 -1.006365 +v 0.338932 0.351777 -1.001723 +v 0.343023 0.356190 -0.994797 +v 0.343362 0.357974 -0.985852 +v 0.339935 0.357060 -0.975234 +v 0.332875 0.353483 -0.963350 +v 0.322452 0.347381 -0.950656 +v 0.309068 0.338988 -0.937640 +v 0.293235 0.328626 -0.924803 +v 0.275564 0.316694 -0.912638 +v 0.252132 0.288088 -0.992538 +v 0.269979 0.304280 -1.000182 +v 0.286881 0.319838 -1.005601 +v 0.302188 0.334163 -1.008588 +v 0.315311 0.346705 -1.009026 +v 0.325748 0.356982 -1.006900 +v 0.333095 0.364600 -1.002290 +v 0.337072 0.369264 -0.995375 +v 0.337525 0.370797 -0.986420 +v 0.334438 0.369139 -0.975768 +v 0.327927 0.364354 -0.963830 +v 0.318244 0.356626 -0.951065 +v 0.305762 0.346251 -0.937962 +v 0.290958 0.333629 -0.925025 +v 0.274403 0.319245 -0.912751 +v 0.250284 0.290028 -0.992253 +v 0.266353 0.308085 -0.999623 +v 0.281617 0.325361 -1.004789 +v 0.295488 0.341193 -1.007554 +v 0.307434 0.354972 -1.007810 +v 0.316995 0.366168 -1.005549 +v 0.323803 0.374351 -1.000857 +v 0.327598 0.379206 -0.993913 +v 0.328233 0.380548 -0.984986 +v 0.325684 0.378324 -0.974418 +v 0.320050 0.372620 -0.962615 +v 0.311545 0.363656 -0.950031 +v 0.300498 0.351775 -0.937149 +v 0.287333 0.337434 -0.924465 +v 0.272555 0.321184 -0.912466 +v 0.247819 0.291282 -0.991580 +v 0.261519 0.310545 -0.998304 +v 0.274598 0.328933 -1.002875 +v 0.286555 0.345738 -1.005117 +v 0.296929 0.360316 -1.004946 +v 0.305322 0.372106 -1.002366 +v 0.311412 0.380655 -0.997477 +v 0.314964 0.385634 -0.990468 +v 0.315842 0.386853 -0.981607 +v 0.314012 0.384263 -0.971235 +v 0.309545 0.377965 -0.959750 +v 0.302612 0.368201 -0.947595 +v 0.293479 0.355346 -0.935235 +v 0.282498 0.339894 -0.923147 +v 0.270090 0.322438 -0.911794 +v 0.244833 0.291802 -0.990547 +v 0.255661 0.311566 -0.996277 +v 0.266094 0.330414 -0.999932 +v 0.275730 0.347624 -1.001372 +v 0.284201 0.362534 -1.000541 +v 0.291180 0.374570 -0.997472 +v 0.296398 0.383271 -0.992282 +v 0.299656 0.388301 -0.985170 +v 0.300828 0.389468 -0.976411 +v 0.299870 0.386727 -0.966341 +v 0.296817 0.380183 -0.955346 +v 0.291787 0.370087 -0.943849 +v 0.284974 0.356828 -0.932292 +v 0.276640 0.340914 -0.921120 +v 0.267104 0.322959 -0.910760 +v 0.241439 0.291569 -0.989192 +v 0.249004 0.311108 -0.993619 +v 0.256430 0.329750 -0.996073 +v 0.263431 0.346778 -0.996461 +v 0.269739 0.361539 -0.994766 +v 0.275110 0.373465 -0.991055 +v 0.279339 0.382098 -0.985470 +v 0.282262 0.387105 -0.978225 +v 0.283769 0.388295 -0.969599 +v 0.283800 0.385622 -0.959924 +v 0.282354 0.379188 -0.949571 +v 0.279488 0.369241 -0.938938 +v 0.275311 0.356163 -0.928434 +v 0.269983 0.340456 -0.918462 +v 0.263711 0.322725 -0.909405 +v 0.237769 0.290591 -0.987568 +v 0.241805 0.309189 -0.990433 +v 0.245979 0.326964 -0.991448 +v 0.250130 0.343233 -0.990573 +v 0.254098 0.357370 -0.987843 +v 0.257731 0.368833 -0.983363 +v 0.260889 0.377180 -0.977304 +v 0.263451 0.382091 -0.969899 +v 0.265319 0.383377 -0.961433 +v 0.266420 0.380989 -0.952232 +v 0.266713 0.375019 -0.942648 +v 0.266186 0.365695 -0.933050 +v 0.264860 0.353377 -0.923808 +v 0.262785 0.338538 -0.915275 +v 0.260041 0.321747 -0.907781 +v 0.233964 0.288905 -0.985736 +v 0.234341 0.305883 -0.986840 +v 0.235142 0.322165 -0.986232 +v 0.236337 0.337124 -0.983935 +v 0.237879 0.350187 -0.980038 +v 0.239710 0.360852 -0.974690 +v 0.241758 0.368707 -0.968097 +v 0.243945 0.373452 -0.960512 +v 0.246188 0.374905 -0.952226 +v 0.248400 0.373008 -0.943559 +v 0.250495 0.367836 -0.934843 +v 0.252394 0.359587 -0.926413 +v 0.254023 0.348578 -0.918593 +v 0.255320 0.335232 -0.911683 +v 0.256235 0.320062 -0.905950 +v 0.256733 0.303650 -0.901613 +v 0.230169 0.286578 -0.983768 +v 0.226898 0.301317 -0.982980 +v 0.224336 0.315536 -0.980628 +v 0.222583 0.328688 -0.976802 +v 0.221707 0.340267 -0.971650 +v 0.221740 0.349828 -0.965370 +v 0.222681 0.357005 -0.958203 +v 0.224495 0.361521 -0.950424 +v 0.227111 0.363202 -0.942332 +v 0.230430 0.361985 -0.934239 +v 0.234322 0.357915 -0.926455 +v 0.238640 0.351150 -0.919279 +v 0.243217 0.341949 -0.912988 +v 0.247877 0.330666 -0.907823 +v 0.252441 0.317734 -0.903982 +v 0.226531 0.283697 -0.981739 +v 0.219761 0.295666 -0.979000 +v 0.213976 0.307332 -0.974850 +v 0.209397 0.318247 -0.969448 +v 0.206201 0.327989 -0.963003 +v 0.204511 0.336186 -0.955762 +v 0.204391 0.342523 -0.948002 +v 0.205847 0.346755 -0.940024 +v 0.208822 0.348720 -0.932132 +v 0.213201 0.348343 -0.924630 +v 0.218817 0.345638 -0.917808 +v 0.225454 0.340709 -0.911925 +v 0.232857 0.333746 -0.907210 +v 0.240740 0.325015 -0.903843 +v 0.248803 0.314853 -0.901953 +v 0.223190 0.280374 -0.979727 +v 0.213206 0.289148 -0.975053 +v 0.204460 0.297870 -0.969120 +v 0.197285 0.306203 -0.962156 +v 0.191959 0.313827 -0.954428 +v 0.188686 0.320450 -0.946233 +v 0.187592 0.325817 -0.937887 +v 0.188718 0.329722 -0.929710 +v 0.192022 0.332015 -0.922017 +v 0.197376 0.332607 -0.915102 +v 0.204575 0.331476 -0.909232 +v 0.213342 0.328665 -0.904633 +v 0.223340 0.324283 -0.901480 +v 0.234186 0.318497 -0.899896 +v 0.245461 0.311530 -0.899941 +v 0.220273 0.276736 -0.977810 +v 0.207485 0.282013 -0.971291 +v 0.196153 0.287511 -0.963659 +v 0.186713 0.293018 -0.955205 +v 0.179528 0.298324 -0.946254 +v 0.174873 0.303224 -0.937152 +v 0.172928 0.307530 -0.928246 +v 0.173767 0.311077 -0.919880 +v 0.177358 0.313728 -0.912376 +v 0.183563 0.315381 -0.906020 +v 0.192143 0.315973 -0.901059 +v 0.202770 0.315481 -0.897682 +v 0.215034 0.313924 -0.896019 +v 0.228464 0.311362 -0.896134 +v 0.242544 0.307893 -0.898023 +v 0.217893 0.272924 -0.976060 +v 0.202816 0.274535 -0.967859 +v 0.189375 0.276655 -0.958676 +v 0.178087 0.279201 -0.948863 +v 0.169384 0.282077 -0.938797 +v 0.163602 0.285171 -0.928865 +v 0.160963 0.288365 -0.919450 +v 0.161567 0.291536 -0.910912 +v 0.165393 0.294562 -0.903579 +v 0.172292 0.297328 -0.897734 +v 0.182000 0.299725 -0.893602 +v 0.194144 0.301664 -0.891340 +v 0.208256 0.303068 -0.891036 +v 0.223795 0.303884 -0.892702 +v 0.240164 0.304081 -0.896273 +v 0.216141 0.269084 -0.974545 +v 0.199380 0.267002 -0.964888 +v 0.184387 0.265718 -0.954363 +v 0.171738 0.265281 -0.943374 +v 0.161919 0.265709 -0.932342 +v 0.155307 0.266984 -0.921693 +v 0.152157 0.269058 -0.911836 +v 0.152589 0.271851 -0.903148 +v 0.156587 0.275255 -0.895965 +v 0.163997 0.279140 -0.890562 +v 0.174535 0.283357 -0.887147 +v 0.187795 0.287744 -0.885851 +v 0.203268 0.292131 -0.886723 +v 0.220360 0.296350 -0.889731 +v 0.238412 0.300240 -0.894759 +v 0.215085 0.265363 -0.973324 +v 0.197309 0.259702 -0.962493 +v 0.181380 0.255121 -0.950886 +v 0.167911 0.251794 -0.938948 +v 0.157419 0.249849 -0.927138 +v 0.150307 0.249362 -0.915911 +v 0.146848 0.250350 -0.905697 +v 0.147176 0.252776 -0.896889 +v 0.151278 0.256547 -0.889826 +v 0.158996 0.261518 -0.884780 +v 0.170034 0.267498 -0.881943 +v 0.183968 0.274256 -0.881425 +v 0.200261 0.281534 -0.883246 +v 0.218288 0.289051 -0.887336 +v 0.237357 0.296519 -0.893538 +v 0.214765 0.261904 -0.972444 +v 0.196682 0.252918 -0.960766 +v 0.180470 0.245271 -0.948378 +v 0.166752 0.239257 -0.935756 +v 0.156056 0.235108 -0.923385 +v 0.148793 0.232982 -0.911740 +v 0.145241 0.232961 -0.901269 +v 0.145538 0.235047 -0.892375 +v 0.149671 0.239159 -0.885399 +v 0.157483 0.245138 -0.880609 +v 0.168672 0.252756 -0.878189 +v 0.182809 0.261720 -0.878233 +v 0.199351 0.271684 -0.880738 +v 0.217661 0.282266 -0.885608 +v 0.237037 0.293060 -0.892657 +v 0.234025 0.271884 -0.982963 +v 0.215194 0.258840 -0.971937 +v 0.197523 0.246908 -0.959772 +v 0.181691 0.236547 -0.946935 +v 0.168306 0.228153 -0.933920 +v 0.157884 0.222051 -0.921226 +v 0.150824 0.218474 -0.909341 +v 0.147397 0.217560 -0.898723 +v 0.147736 0.219344 -0.889779 +v 0.151827 0.223757 -0.882853 +v 0.159513 0.230630 -0.878210 +v 0.170500 0.239699 -0.876030 +v 0.184363 0.250616 -0.876397 +v 0.200572 0.262960 -0.879295 +v 0.218502 0.276257 -0.884615 +v 0.237466 0.289997 -0.892151 +v 0.216355 0.256290 -0.971824 +v 0.199800 0.241905 -0.959551 +v 0.184997 0.229283 -0.946614 +v 0.172514 0.218909 -0.933511 +v 0.162831 0.211180 -0.920745 +v 0.156321 0.206395 -0.908807 +v 0.153233 0.204737 -0.898156 +v 0.153686 0.206270 -0.889201 +v 0.157663 0.210934 -0.882285 +v 0.165011 0.218552 -0.877676 +v 0.175447 0.228829 -0.875550 +v 0.188571 0.241371 -0.875988 +v 0.203878 0.255696 -0.878974 +v 0.220779 0.271254 -0.884393 +v 0.238627 0.287446 -0.892038 +vn -0.603229 -0.795221 -0.060915 +vn -0.595019 -0.681906 -0.425306 +vn -0.396496 -0.817225 -0.418165 +vn -0.419721 -0.313150 -0.851894 +vn -0.385907 -0.256752 -0.886074 +vn -0.365856 -0.273995 -0.889401 +vn 0.230811 0.020173 0.972777 +vn 0.171026 -0.062593 0.983245 +vn 0.290597 -0.029206 0.956389 +vn -0.484970 -0.764519 0.424574 +vn -0.335093 -0.940214 -0.060579 +vn -0.456465 -0.377300 -0.805750 +vn -0.379620 -0.348277 -0.857051 +vn 0.276864 0.086550 0.956999 +vn 0.315195 0.054170 0.947447 +vn -0.251717 -0.558855 0.790124 +vn -0.191076 -0.900021 0.391644 +vn -0.498306 -0.455336 -0.737785 +vn -0.392468 -0.432966 -0.811457 +vn 0.315348 0.143895 0.937986 +vn 0.334941 0.127537 0.933561 +vn -0.046052 -0.335459 0.940916 +vn 0.127384 -0.444197 0.886807 +vn -0.546587 -0.555406 -0.626667 +vn -0.403516 -0.535295 -0.741997 +vn 0.085971 -0.174383 0.980895 +vn 0.207831 -0.262917 0.942137 +vn -0.409009 -0.663747 -0.626179 +vn 0.257241 -0.130680 0.957457 +vn -0.195349 -0.891232 -0.409284 +vn -0.345470 -0.287576 -0.893246 +vn 0.348155 -0.067507 0.934965 +vn -0.082888 -0.994110 -0.069613 +vn -0.337718 -0.376446 -0.862667 +vn 0.352824 0.028565 0.935240 +vn -0.007752 -0.682333 0.730949 +vn 0.197821 -0.734703 0.648885 +vn -0.324717 -0.476821 -0.816797 +vn 0.354167 0.114750 0.928098 +vn 0.277871 -0.508042 0.815271 +vn -0.302683 -0.595416 -0.744194 +vn 0.318125 -0.323740 0.891018 +vn -0.263985 -0.737236 -0.621906 +vn 0.338145 -0.181310 0.923460 +vn 0.413770 -0.359905 0.836177 +vn -0.126011 -0.776727 -0.617084 +vn 0.411145 -0.214972 0.885830 +vn -0.016022 -0.915189 -0.402661 +vn -0.325632 -0.297433 -0.897458 +vn 0.401624 -0.094485 0.910886 +vn 0.065065 -0.939421 0.336436 +vn 0.123203 -0.988769 -0.084262 +vn -0.296182 -0.396893 -0.868740 +vn 0.388409 0.010071 0.921415 +vn 0.357158 -0.742424 0.566729 +vn -0.257363 -0.507614 -0.822199 +vn 0.372417 0.105533 0.922025 +vn 0.401379 -0.537400 0.741661 +vn -0.203497 -0.634297 -0.745811 +vn 0.389233 0.099948 0.915677 +vn 0.501846 -0.542161 0.673910 +vn -0.111850 -0.652974 -0.749046 +vn 0.495315 -0.375500 0.783319 +vn -0.003479 -0.788049 -0.615589 +vn 0.475661 -0.232948 0.848201 +vn 0.133396 -0.905759 -0.402203 +vn -0.307016 -0.303446 -0.902005 +vn 0.450026 -0.110294 0.886166 +vn 0.261513 -0.924284 0.277963 +vn 0.283059 -0.953429 -0.103916 +vn -0.256935 -0.409284 -0.875454 +vn 0.421064 -0.001221 0.907010 +vn 0.479873 -0.725211 0.493698 +vn -0.193945 -0.525071 -0.828639 +vn -0.221473 -0.413526 -0.883114 +vn 0.450270 -0.005341 0.892850 +vn 0.408460 -0.884945 0.223548 +vn 0.577136 -0.693472 0.431257 +vn -0.137181 -0.529618 -0.837062 +vn 0.404187 0.097934 0.909391 +vn 0.584674 -0.529099 0.614917 +vn -0.031495 -0.653798 -0.755974 +vn 0.564745 -0.373974 0.735618 +vn 0.100314 -0.777764 -0.620472 +vn 0.531846 -0.236641 0.813074 +vn 0.254219 -0.875729 -0.410413 +vn -0.290414 -0.305582 -0.906766 +vn 0.492874 -0.115299 0.862392 +vn 0.406873 -0.904324 -0.128819 +vn 0.350749 -0.832575 -0.428632 +vn -0.276254 -0.303903 -0.911740 +vn 0.529862 -0.109989 0.840877 +vn 0.521287 -0.835414 0.174047 +vn 0.504807 -0.848323 -0.159551 +vn -0.191290 -0.409833 -0.891842 +vn 0.475509 -0.002380 0.879696 +vn 0.657369 -0.651723 0.378216 +vn -0.089175 -0.522141 -0.848170 +vn 0.417005 0.099460 0.903439 +vn 0.654500 -0.502121 0.565203 +vn 0.035432 -0.639210 -0.768181 +vn 0.624012 -0.357830 0.694632 +vn 0.185034 -0.751030 -0.633778 +vn 0.580157 -0.227332 0.782098 +vn 0.674673 -0.328471 0.660970 +vn 0.251381 -0.711020 -0.656697 +vn 0.620991 -0.205847 0.756279 +vn 0.427107 -0.779748 -0.457747 +vn -0.264992 -0.298654 -0.916807 +vn 0.560778 -0.094852 0.822504 +vn 0.611866 -0.780511 0.128117 +vn 0.584399 -0.787194 -0.196875 +vn -0.167364 -0.398694 -0.901669 +vn 0.496323 0.007355 0.868068 +vn 0.726402 -0.601245 0.332804 +vn -0.051393 -0.503647 -0.862362 +vn 0.427442 0.104373 0.897977 +vn 0.714713 -0.462905 0.524247 +vn 0.087893 -0.611225 -0.786523 +vn 0.512375 0.023652 0.858425 +vn 0.767449 -0.411634 0.491470 +vn 0.299844 -0.659139 -0.689627 +vn 0.717612 -0.286416 0.634785 +vn 0.486099 -0.717826 -0.498367 +vn 0.654408 -0.172735 0.736106 +vn 0.650410 -0.719962 -0.242042 +vn -0.150334 -0.380566 -0.912412 +vn 0.688040 -0.720756 0.083895 +vn 0.754906 -0.654622 0.039430 +vn -0.024689 -0.475051 -0.879604 +vn 0.585253 -0.070284 0.807764 +vn 0.787957 -0.541307 0.293374 +vn 0.125156 -0.571123 -0.811243 +vn 0.602832 -0.036714 0.796991 +vn 0.844264 -0.469497 0.258400 +vn 0.146550 -0.519639 -0.841700 +vn 0.435347 0.112461 0.893185 +vn 0.523240 0.046083 0.850917 +vn 0.330271 -0.595477 -0.732292 +vn 0.813715 -0.347056 0.466231 +vn 0.528672 -0.645497 -0.551164 +vn 0.752922 -0.231330 0.616077 +vn 0.705344 -0.643696 -0.296823 +vn -0.256844 -0.290048 -0.921873 +vn -0.140690 -0.356029 -0.923795 +vn 0.680044 -0.128208 0.721854 +vn 0.815455 -0.578753 -0.007355 +vn -0.009857 -0.437086 -0.899350 +vn -0.251930 -0.278298 -0.926847 +vn -0.138829 -0.325694 -0.935209 +vn 0.697043 -0.072237 0.713370 +vn 0.870937 -0.487808 -0.058992 +vn -0.007324 -0.390484 -0.920560 +vn 0.612812 0.005432 0.790185 +vn 0.151311 -0.457076 -0.876431 +vn 0.440504 0.123569 0.889187 +vn 0.528520 0.074252 0.845637 +vn 0.896115 -0.381512 0.226630 +vn 0.341655 -0.519028 -0.783471 +vn 0.853267 -0.266732 0.448042 +vn 0.553972 -0.559618 -0.616382 +vn 0.779809 -0.162236 0.604572 +vn 0.749321 -0.553514 -0.363475 +vn 0.558458 -0.455611 -0.693167 +vn 0.796289 -0.077670 0.599872 +vn 0.779290 -0.442000 -0.444166 +vn -0.250557 -0.263619 -0.931486 +vn -0.144871 -0.290384 -0.945860 +vn 0.703879 -0.004730 0.710288 +vn 0.920011 -0.373547 -0.118320 +vn -0.017457 -0.336283 -0.941588 +vn 0.614246 0.055666 0.787103 +vn 0.138585 -0.383740 -0.912961 +vn 0.442763 0.137577 0.885983 +vn 0.527696 0.107578 0.842586 +vn 0.942289 -0.270791 0.196814 +vn 0.331828 -0.428144 -0.840541 +vn 0.884152 -0.166784 0.436384 +vn 0.977538 -0.127750 0.167425 +vn 0.297830 -0.321696 -0.898770 +vn 0.901578 -0.042238 0.430494 +vn 0.535630 -0.328318 -0.777978 +vn 0.798761 0.023988 0.601123 +vn 0.787103 -0.299081 -0.539445 +vn -0.252815 -0.246376 -0.935575 +vn -0.158635 -0.251198 -0.954833 +vn 0.698355 0.074129 0.711875 +vn 0.956328 -0.223579 -0.188147 +vn -0.040010 -0.275796 -0.960356 +vn 0.606067 0.113224 0.787286 +vn 0.107761 -0.300455 -0.947661 +vn 0.441877 0.154118 0.883694 +vn 0.520310 0.145207 0.841517 +vn 0.587024 0.176763 0.790002 +vn 0.988800 0.059053 0.136937 +vn 0.058931 -0.209296 -0.976043 +vn 0.437696 0.172826 0.882321 +vn 0.505997 0.186224 0.842158 +vn 0.237007 -0.200537 -0.950560 +vn 0.896359 0.111576 0.428999 +vn 0.476394 -0.174535 -0.861721 +vn 0.781671 0.143406 0.606952 +vn 0.756523 -0.114353 -0.643880 +vn -0.258705 -0.227119 -0.938841 +vn -0.179571 -0.209449 -0.961180 +vn 0.677633 0.163427 0.717002 +vn 0.962889 -0.022645 -0.268929 +vn -0.074343 -0.210913 -0.974639 +vn -0.268136 -0.206397 -0.941008 +vn -0.206977 -0.166662 -0.964019 +vn 0.638508 0.260689 0.724082 +vn 0.905759 0.236335 -0.351726 +vn -0.119053 -0.144200 -0.982330 +vn 0.555925 0.244392 0.794458 +vn 0.949492 0.295633 0.105014 +vn -0.006409 -0.114078 -0.993439 +vn 0.430067 0.193243 0.881832 +vn 0.484390 0.229316 0.844234 +vn 0.148839 -0.069704 -0.986389 +vn 0.853420 0.295297 0.429426 +vn 0.372051 0.001404 -0.928190 +vn 0.737663 0.278512 0.615009 +vn 0.663472 0.113041 -0.739586 +vn 0.222510 0.181219 -0.957915 +vn 0.659658 0.421155 0.622456 +vn 0.489334 0.356090 -0.796045 +vn -0.280892 -0.184851 -0.941740 +vn -0.239967 -0.124821 -0.962706 +vn 0.578539 0.360820 0.731468 +vn 0.745598 0.523728 -0.411969 +vn -0.172246 -0.079196 -0.981842 +vn 0.512131 0.312815 0.799890 +vn 0.824000 0.561357 0.076510 +vn -0.084994 -0.020936 -0.996155 +vn 0.418897 0.214789 0.882229 +vn 0.455397 0.272561 0.847530 +vn 0.037568 0.060030 -0.997467 +vn 0.754845 0.496200 0.428877 +vn 0.595019 0.681936 0.425306 +vn -0.086001 0.174383 -0.980895 +vn 0.546587 0.555406 0.626667 +vn 0.046052 0.335459 -0.940916 +vn 0.498306 0.455336 0.737785 +vn 0.251717 0.558855 -0.790094 +vn -0.296823 -0.163488 -0.940825 +vn -0.315348 -0.143925 -0.937986 +vn 0.456465 0.377300 0.805750 +vn 0.484970 0.764519 -0.424574 +vn -0.230811 -0.020173 -0.972777 +vn 0.419721 0.313120 0.851894 +vn 0.603229 0.795221 0.060915 +vn -0.171026 0.062593 -0.983245 +vn 0.404035 0.236488 0.883633 +vn 0.385876 0.256752 0.886074 +vn 0.379620 0.348277 0.857051 +vn 0.335063 0.940214 0.060549 +vn -0.290597 0.029206 -0.956389 +vn 0.365856 0.273995 0.889401 +vn 0.396496 0.817225 0.418165 +vn -0.257241 0.130680 -0.957457 +vn 0.409009 0.663747 0.626179 +vn -0.207831 0.262917 -0.942137 +vn 0.403546 0.535325 0.741997 +vn -0.127384 0.444197 -0.886807 +vn -0.276864 -0.086550 -0.956969 +vn -0.334910 -0.127537 -0.933561 +vn 0.392468 0.432966 0.811457 +vn 0.191076 0.900021 -0.391644 +vn -0.315226 -0.054170 -0.947447 +vn 0.324717 0.476821 0.816797 +vn 0.007721 0.682333 -0.730949 +vn -0.197821 0.734703 -0.648885 +vn -0.352824 -0.028565 -0.935240 +vn 0.337718 0.376446 0.862667 +vn 0.082888 0.994110 0.069613 +vn -0.348155 0.067507 -0.934996 +vn 0.345470 0.287576 0.893246 +vn 0.195349 0.891232 0.409284 +vn -0.338145 0.181310 -0.923429 +vn 0.263985 0.737236 0.621906 +vn -0.318125 0.323740 -0.891018 +vn 0.302683 0.595416 0.744163 +vn -0.277840 0.508042 -0.815271 +vn -0.354167 -0.114750 -0.928098 +vn 0.203497 0.634297 0.745811 +vn -0.401379 0.537400 -0.741661 +vn -0.372417 -0.105533 -0.922025 +vn 0.257363 0.507614 0.822230 +vn -0.065035 0.939451 -0.336436 +vn -0.357158 0.742424 -0.566729 +vn -0.388379 -0.010071 -0.921415 +vn 0.296213 0.396893 0.868740 +vn -0.123203 0.988769 0.084262 +vn -0.401624 0.094485 -0.910886 +vn 0.325632 0.297433 0.897458 +vn 0.016022 0.915189 0.402661 +vn -0.411145 0.214972 -0.885830 +vn 0.126011 0.776727 0.617084 +vn -0.413770 0.359905 -0.836177 +vn -0.475661 0.232948 -0.848201 +vn 0.003479 0.788049 0.615589 +vn -0.495315 0.375500 -0.783319 +vn 0.111850 0.652974 0.749046 +vn -0.501846 0.542161 -0.673910 +vn -0.389233 -0.099948 -0.915677 +vn 0.193945 0.525071 0.828639 +vn -0.261513 0.924284 -0.277963 +vn -0.479873 0.725211 -0.493698 +vn -0.421064 0.001221 -0.907010 +vn 0.256905 0.409284 0.875454 +vn -0.283059 0.953429 0.103916 +vn -0.450026 0.110294 -0.886166 +vn 0.307047 0.303446 0.901975 +vn -0.133396 0.905759 0.402203 +vn -0.408460 0.884945 -0.223548 +vn -0.406873 0.904324 0.128849 +vn -0.492874 0.115299 -0.862392 +vn 0.290414 0.305582 0.906766 +vn -0.254219 0.875729 0.410413 +vn -0.531846 0.236641 -0.813074 +vn -0.100314 0.777764 0.620472 +vn -0.564745 0.373974 -0.735618 +vn 0.031495 0.653798 0.755974 +vn -0.584674 0.529099 -0.614917 +vn -0.404187 -0.097934 -0.909391 +vn 0.137181 0.529618 0.837031 +vn -0.577105 0.693472 -0.431257 +vn -0.450270 0.005341 -0.892850 +vn 0.221473 0.413526 0.883114 +vn 0.089175 0.522141 0.848170 +vn -0.521287 0.835414 -0.174047 +vn -0.657369 0.651723 -0.378216 +vn -0.475509 0.002380 -0.879696 +vn 0.191290 0.409833 0.891842 +vn -0.504807 0.848323 0.159551 +vn -0.529893 0.109989 -0.840877 +vn 0.276254 0.303903 0.911740 +vn -0.350749 0.832575 0.428632 +vn -0.580157 0.227302 -0.782098 +vn -0.185034 0.751030 0.633778 +vn -0.624012 0.357830 -0.694632 +vn -0.035432 0.639210 0.768181 +vn -0.654500 0.502121 -0.565203 +vn -0.417005 -0.099460 -0.903439 +vn -0.087893 0.611225 0.786523 +vn -0.714713 0.462905 -0.524247 +vn -0.427442 -0.104373 -0.897977 +vn 0.051363 0.503647 0.862362 +vn -0.611866 0.780480 -0.128117 +vn -0.726402 0.601245 -0.332835 +vn -0.496323 -0.007355 -0.868068 +vn 0.167333 0.398694 0.901669 +vn -0.584399 0.787194 0.196875 +vn -0.560778 0.094852 -0.822504 +vn 0.264992 0.298654 0.916807 +vn -0.427107 0.779748 0.457717 +vn -0.620991 0.205847 -0.756279 +vn -0.251381 0.710990 0.656697 +vn -0.674673 0.328471 -0.660970 +vn -0.654408 0.172735 -0.736106 +vn -0.486099 0.717826 0.498367 +vn -0.717612 0.286416 -0.634785 +vn -0.299844 0.659139 0.689627 +vn -0.767449 0.411634 -0.491470 +vn -0.512375 -0.023652 -0.858425 +vn -0.125156 0.571123 0.811243 +vn -0.688040 0.720756 -0.083895 +vn -0.787957 0.541337 -0.293344 +vn -0.585253 0.070284 -0.807764 +vn 0.024689 0.475051 0.879604 +vn -0.754906 0.654622 -0.039430 +vn 0.150334 0.380566 0.912412 +vn -0.650410 0.719962 0.242042 +vn -0.815455 0.578753 0.007355 +vn -0.680044 0.128178 -0.721854 +vn 0.256844 0.290048 0.921873 +vn 0.140690 0.356029 0.923795 +vn -0.705344 0.643696 0.296823 +vn -0.752922 0.231330 -0.616077 +vn -0.528703 0.645497 0.551164 +vn -0.813715 0.347087 -0.466231 +vn -0.330271 0.595508 0.732292 +vn -0.844264 0.469497 -0.258400 +vn -0.435347 -0.112461 -0.893185 +vn -0.523240 -0.046083 -0.850917 +vn -0.146550 0.519639 0.841700 +vn -0.602832 0.036714 -0.796991 +vn 0.009857 0.437056 0.899350 +vn -0.151311 0.457076 0.876431 +vn -0.870937 0.487808 0.058992 +vn -0.612812 -0.005432 -0.790185 +vn 0.007355 0.390515 0.920560 +vn -0.697043 0.072237 -0.713370 +vn 0.251930 0.278298 0.926847 +vn 0.138829 0.325694 0.935209 +vn -0.749321 0.553514 0.363475 +vn -0.779809 0.162236 -0.604572 +vn -0.553972 0.559618 0.616382 +vn -0.853267 0.266732 -0.448042 +vn -0.341655 0.519028 0.783471 +vn -0.896115 0.381512 -0.226630 +vn -0.440504 -0.123569 -0.889187 +vn -0.528520 -0.074282 -0.845637 +vn -0.331828 0.428144 0.840571 +vn -0.942289 0.270791 -0.196783 +vn -0.442763 -0.137577 -0.885983 +vn -0.527696 -0.107578 -0.842586 +vn -0.138615 0.383740 0.912961 +vn -0.920011 0.373547 0.118320 +vn -0.614277 -0.055666 -0.787103 +vn 0.017457 0.336283 0.941588 +vn -0.703879 0.004730 -0.710288 +vn 0.250557 0.263619 0.931486 +vn 0.144871 0.290384 0.945860 +vn -0.779290 0.442000 0.444166 +vn -0.796289 0.077670 -0.599872 +vn -0.558458 0.455611 0.693167 +vn -0.884152 0.166784 -0.436384 +vn -0.535661 0.328318 0.777978 +vn -0.901578 0.042268 -0.430494 +vn -0.297830 0.321696 0.898770 +vn -0.977538 0.127750 -0.167425 +vn -0.441877 -0.154118 -0.883724 +vn -0.520310 -0.145207 -0.841517 +vn -0.107761 0.300455 0.947661 +vn -0.956328 0.223579 0.188147 +vn -0.606067 -0.113224 -0.787286 +vn 0.040010 0.275796 0.960356 +vn -0.698355 -0.074129 -0.711875 +vn 0.252815 0.246376 0.935606 +vn 0.158635 0.251198 0.954833 +vn -0.787072 0.299081 0.539445 +vn -0.798761 -0.023957 -0.601154 +vn -0.677633 -0.163427 -0.717002 +vn 0.258736 0.227119 0.938841 +vn 0.179601 0.209449 0.961150 +vn -0.756523 0.114353 0.643880 +vn -0.781671 -0.143406 -0.606952 +vn -0.476394 0.174535 0.861721 +vn -0.896359 -0.111576 -0.428999 +vn -0.237007 0.200537 0.950560 +vn -0.988800 -0.059084 -0.136937 +vn -0.437666 -0.172857 -0.882351 +vn -0.505997 -0.186224 -0.842158 +vn -0.058931 0.209296 0.976074 +vn -0.587024 -0.176763 -0.790002 +vn 0.074343 0.210913 0.974639 +vn -0.962889 0.022645 0.268929 +vn -0.949492 -0.295633 -0.105014 +vn -0.555956 -0.244392 -0.794458 +vn 0.119053 0.144230 0.982330 +vn -0.905759 -0.236305 0.351726 +vn -0.638508 -0.260689 -0.724082 +vn 0.268105 0.206397 0.941008 +vn 0.206977 0.166662 0.964019 +vn -0.663472 -0.113041 0.739586 +vn -0.737663 -0.278512 -0.615009 +vn -0.372021 -0.001404 0.928190 +vn -0.853420 -0.295297 -0.429426 +vn -0.148808 0.069704 0.986389 +vn -0.430067 -0.193243 -0.881863 +vn -0.484390 -0.229316 -0.844234 +vn 0.006409 0.114078 0.993439 +vn -0.037568 -0.060030 0.997467 +vn -0.824030 -0.561327 -0.076510 +vn -0.418897 -0.214789 -0.882229 +vn -0.455397 -0.272561 -0.847530 +vn 0.084994 0.020936 0.996155 +vn -0.512131 -0.312815 -0.799890 +vn 0.172246 0.079196 0.981842 +vn -0.745628 -0.523728 0.411969 +vn -0.578539 -0.360820 -0.731468 +vn 0.280862 0.184851 0.941771 +vn 0.239937 0.124821 0.962706 +vn -0.489334 -0.356090 0.796045 +vn -0.659658 -0.421155 -0.622456 +vn -0.222510 -0.181219 0.957915 +vn -0.754845 -0.496200 -0.428877 +vn 0.350932 0.200903 0.914579 +vn -0.350932 -0.200903 -0.914579 +vn 0.296823 0.163488 0.940794 +vn -0.404035 -0.236488 -0.883633 +vn -0.595019 -0.681936 -0.425306 +vn -0.385876 -0.256752 -0.886074 +vn 0.290567 -0.029206 0.956389 +vn -0.335063 -0.940214 -0.060579 +vn 0.276864 0.086550 0.956969 +vn 0.315226 0.054170 0.947447 +vn 0.315348 0.143925 0.937986 +vn 0.334910 0.127537 0.933561 +vn -0.403546 -0.535295 -0.741997 +vn 0.207801 -0.262917 0.942137 +vn -0.345439 -0.287576 -0.893246 +vn 0.354198 0.114750 0.928098 +vn -0.302652 -0.595447 -0.744194 +vn 0.413770 -0.359935 0.836177 +vn 0.065035 -0.939421 0.336436 +vn -0.296213 -0.396893 -0.868740 +vn 0.388379 0.010071 0.921415 +vn -0.257393 -0.507614 -0.822199 +vn 0.389203 0.099948 0.915677 +vn -0.307047 -0.303446 -0.901975 +vn -0.256905 -0.409284 -0.875454 +vn 0.421094 -0.001221 0.907010 +vn -0.221503 -0.413526 -0.883114 +vn 0.450301 -0.005341 0.892850 +vn 0.577105 -0.693472 0.431257 +vn -0.137181 -0.529618 -0.837031 +vn 0.404157 0.097934 0.909391 +vn 0.564745 -0.373974 0.735649 +vn -0.290445 -0.305582 -0.906766 +vn 0.406873 -0.904324 -0.128849 +vn -0.276284 -0.303903 -0.911740 +vn 0.657399 -0.651723 0.378216 +vn 0.417005 0.099460 0.903409 +vn 0.654530 -0.502121 0.565172 +vn 0.580157 -0.227302 0.782098 +vn 0.251381 -0.711020 -0.656667 +vn 0.560778 -0.094852 0.822474 +vn -0.167333 -0.398694 -0.901669 +vn 0.787957 -0.541307 0.293344 +vn 0.330302 -0.595477 -0.732292 +vn 0.813715 -0.347087 0.466231 +vn 0.528703 -0.645497 -0.551164 +vn 0.680044 -0.128178 0.721854 +vn -0.251961 -0.278298 -0.926847 +vn -0.007324 -0.390515 -0.920560 +vn 0.612812 0.005402 0.790185 +vn 0.440535 0.123569 0.889157 +vn 0.558458 -0.455611 -0.693197 +vn -0.144902 -0.290384 -0.945860 +vn 0.614277 0.055666 0.787103 +vn 0.138615 -0.383740 -0.912961 +vn 0.331828 -0.428144 -0.840571 +vn 0.798761 0.023957 0.601154 +vn 0.787072 -0.299081 -0.539445 +vn -0.252815 -0.246376 -0.935606 +vn -0.040040 -0.275796 -0.960356 +vn 0.988800 0.059084 0.136937 +vn 0.058931 -0.209296 -0.976074 +vn 0.437666 0.172857 0.882351 +vn 0.962889 -0.022614 -0.268929 +vn -0.074343 -0.210913 -0.974670 +vn 0.905759 0.236305 -0.351726 +vn 0.555956 0.244392 0.794458 +vn 0.430036 0.193243 0.881863 +vn 0.484390 0.229286 0.844234 +vn 0.148808 -0.069704 -0.986389 +vn 0.372021 0.001404 -0.928190 +vn 0.659658 0.421155 0.622425 +vn -0.239937 -0.124821 -0.962706 +vn 0.745628 0.523728 -0.411969 +vn -0.172277 -0.079196 -0.981842 +vn 0.037538 0.060030 -0.997467 +vn 0.251717 0.558855 -0.790124 +vn -0.296854 -0.163488 -0.940794 +vn 0.484970 0.764519 -0.424604 +vn 0.419721 0.313150 0.851894 +vn 0.365886 0.273995 0.889401 +vn 0.403516 0.535325 0.741997 +vn 0.007752 0.682333 -0.730949 +vn -0.352824 -0.028596 -0.935240 +vn -0.338115 0.181310 -0.923460 +vn 0.302683 0.595416 0.744194 +vn -0.277871 0.508042 -0.815271 +vn 0.257393 0.507614 0.822199 +vn -0.357189 0.742424 -0.566729 +vn 0.296182 0.396893 0.868740 +vn 0.003449 0.788049 0.615589 +vn -0.389203 -0.099948 -0.915708 +vn 0.256874 0.409284 0.875454 +vn -0.450026 0.110294 -0.886135 +vn -0.408460 0.884976 -0.223548 +vn -0.564745 0.373974 -0.735649 +vn -0.404157 -0.097934 -0.909421 +vn -0.450301 0.005341 -0.892850 +vn 0.276284 0.303903 0.911740 +vn -0.580157 0.227332 -0.782098 +vn -0.654530 0.502121 -0.565172 +vn -0.417005 -0.099460 -0.903409 +vn -0.611866 0.780511 -0.128117 +vn -0.726402 0.601245 -0.332804 +vn -0.427137 0.779748 0.457747 +vn -0.251381 0.711020 0.656667 +vn -0.787957 0.541307 -0.293344 +vn -0.528672 0.645497 0.551164 +vn -0.612812 -0.005402 -0.790185 +vn 0.007324 0.390515 0.920560 +vn 0.251961 0.278329 0.926817 +vn -0.440535 -0.123569 -0.889157 +vn -0.528520 -0.074252 -0.845637 +vn -0.331828 0.428144 0.840541 +vn -0.138585 0.383740 0.912961 +vn -0.614246 -0.055666 -0.787103 +vn -0.535630 0.328318 0.777978 +vn 0.258705 0.227119 0.938841 +vn 0.179571 0.209449 0.961150 +vn -0.988800 -0.059053 -0.136937 +vn 0.074313 0.210913 0.974639 +vn -0.430067 -0.193243 -0.881832 +vn -0.824000 -0.561327 -0.076510 +vn -0.418867 -0.214789 -0.882260 +vn 0.280892 0.184851 0.941740 +vn 0.239967 0.124821 0.962706 +vn 0.296854 0.163488 0.940794 +vn -0.404004 -0.236488 -0.883633 +usemtl SkinColor +s 1 +f 3381//2303 3380//2304 3395//2305 +f 3376//2306 3375//2307 3390//2308 +f 3387//2309 3386//2310 3402//2311 +f 3382//2312 3381//2303 3396//2313 +f 3377//2314 3376//2306 3391//2315 +f 3388//2316 3387//2309 3403//2317 +f 3383//2318 3382//2312 3397//2319 +f 3378//2320 3377//2314 3392//2321 +f 3389//2322 3388//2316 3404//2323 +f 3384//2324 3383//2318 3399//2325 +f 3379//2326 3378//2320 3393//2327 +f 3385//2328 3384//2324 3400//2329 +f 3380//2304 3379//2326 3394//2330 +f 3386//2310 3385//2328 3401//2331 +f 3396//2313 3395//2305 3410//2332 +f 3391//2315 3390//2308 3405//2333 +f 3402//2311 3401//2331 3417//2334 +f 3397//2319 3396//2313 3411//2335 +f 3392//2321 3391//2315 3406//2336 +f 3403//2317 3402//2311 3418//2337 +f 3398//2338 3397//2319 3413//2339 +f 3393//2327 3392//2321 3407//2340 +f 3404//2323 3403//2317 3419//2341 +f 3399//2325 3398//2338 3414//2342 +f 3394//2330 3393//2327 3408//2343 +f 3400//2329 3399//2325 3415//2344 +f 3395//2305 3394//2330 3409//2345 +f 3401//2331 3400//2329 3416//2346 +f 3415//2344 3414//2342 3430//2347 +f 3410//2332 3409//2345 3424//2348 +f 3416//2346 3415//2344 3431//2349 +f 3411//2335 3410//2332 3425//2350 +f 3406//2336 3405//2333 3420//2351 +f 3417//2334 3416//2346 3432//2352 +f 3412//2353 3411//2335 3426//2354 +f 3407//2340 3406//2336 3421//2355 +f 3418//2337 3417//2334 3433//2356 +f 3413//2339 3412//2353 3428//2357 +f 3408//2343 3407//2340 3422//2358 +f 3419//2341 3418//2337 3434//2359 +f 3414//2342 3413//2339 3429//2360 +f 3409//2345 3408//2343 3423//2361 +f 3434//2359 3433//2356 3449//2362 +f 3429//2360 3428//2357 3444//2363 +f 3424//2348 3423//2361 3438//2364 +f 3430//2347 3429//2360 3445//2365 +f 3425//2350 3424//2348 3439//2366 +f 3431//2349 3430//2347 3446//2367 +f 3426//2354 3425//2350 3440//2368 +f 3421//2355 3420//2351 3435//2369 +f 3432//2352 3431//2349 3447//2370 +f 3427//2371 3426//2354 3441//2372 +f 3422//2358 3421//2355 3436//2373 +f 3433//2356 3432//2352 3448//2374 +f 3428//2357 3427//2371 3443//2375 +f 3423//2361 3422//2358 3437//2376 +f 3437//2376 3436//2373 3451//2377 +f 3448//2374 3447//2370 3463//2378 +f 3443//2375 3442//2379 3458//2380 +f 3438//2364 3437//2376 3452//2381 +f 3449//2362 3448//2374 3464//2382 +f 3444//2363 3443//2375 3459//2383 +f 3439//2366 3438//2364 3453//2384 +f 3445//2365 3444//2363 3460//2385 +f 3440//2368 3439//2366 3454//2386 +f 3446//2367 3445//2365 3461//2387 +f 3441//2372 3440//2368 3455//2388 +f 3436//2373 3435//2369 3450//2389 +f 3447//2370 3446//2367 3462//2390 +f 3442//2379 3441//2372 3456//2391 +f 3456//2391 3455//2388 3470//2392 +f 3451//2377 3450//2389 3465//2393 +f 3462//2390 3461//2387 3477//2394 +f 3457//2395 3456//2391 3471//2396 +f 3452//2381 3451//2377 3466//2397 +f 3463//2378 3462//2390 3478//2398 +f 3458//2380 3457//2395 3473//2399 +f 3453//2384 3452//2381 3467//2400 +f 3464//2382 3463//2378 3479//2401 +f 3459//2383 3458//2380 3474//2402 +f 3454//2386 3453//2384 3468//2403 +f 3460//2385 3459//2383 3475//2404 +f 3455//2388 3454//2386 3469//2405 +f 3461//2387 3460//2385 3476//2406 +f 3475//2404 3474//2402 3490//2407 +f 3470//2392 3469//2405 3484//2408 +f 3476//2406 3475//2404 3491//2409 +f 3471//2396 3470//2392 3485//2410 +f 3466//2397 3465//2393 3480//2411 +f 3477//2394 3476//2406 3492//2412 +f 3472//2413 3471//2396 3486//2414 +f 3467//2400 3466//2397 3481//2415 +f 3478//2398 3477//2394 3493//2416 +f 3473//2399 3472//2413 3488//2417 +f 3468//2403 3467//2400 3482//2418 +f 3479//2401 3478//2398 3494//2419 +f 3474//2402 3473//2399 3489//2420 +f 3469//2405 3468//2403 3483//2421 +f 3494//2419 3493//2416 3508//2422 +f 3489//2420 3488//2417 3504//2423 +f 3484//2408 3483//2421 3499//2424 +f 3490//2407 3489//2420 3505//2425 +f 3485//2410 3484//2408 3500//2426 +f 3491//2409 3490//2407 3506//2427 +f 3486//2414 3485//2410 3501//2428 +f 3481//2415 3480//2411 3496//2429 +f 3492//2412 3491//2409 3506//2427 +f 3487//2430 3486//2414 3502//2431 +f 3482//2418 3481//2415 3497//2432 +f 3493//2416 3492//2412 3507//2433 +f 3488//2417 3487//2430 3503//2434 +f 3483//2421 3482//2418 3498//2435 +f 3508//2422 3507//2433 3522//2436 +f 3503//2434 3502//2431 3518//2437 +f 3498//2435 3497//2432 3513//2438 +f 3509//2439 3508//2422 3523//2440 +f 3504//2423 3503//2434 3518//2437 +f 3499//2424 3498//2435 3514//2441 +f 3505//2425 3504//2423 3519//2442 +f 3500//2426 3499//2424 3515//2443 +f 3506//2427 3505//2425 3520//2444 +f 3501//2428 3500//2426 3516//2445 +f 3496//2429 3495//2446 3511//2447 +f 3507//2433 3506//2427 3521//2448 +f 3502//2431 3501//2428 3517//2449 +f 3497//2432 3496//2429 3512//2450 +f 3511//2447 3510//2451 3526//2452 +f 3522//2436 3521//2448 3536//2453 +f 3517//2449 3516//2445 3532//2454 +f 3512//2450 3511//2447 3527//2455 +f 3523//2440 3522//2436 3537//2456 +f 3518//2437 3517//2449 3532//2454 +f 3513//2438 3512//2450 3528//2457 +f 3524//2458 3523//2440 3538//2459 +f 3519//2442 3518//2437 3533//2460 +f 3514//2441 3513//2438 3529//2461 +f 3520//2444 3519//2442 3534//2462 +f 3515//2443 3514//2441 3530//2463 +f 3521//2448 3520//2444 3535//2464 +f 3516//2445 3515//2443 3531//2465 +f 3530//2463 3529//2461 3545//2466 +f 3536//2453 3535//2464 3550//2467 +f 3531//2465 3530//2463 3546//2468 +f 3526//2452 3525//2469 3541//2470 +f 3537//2456 3536//2453 3551//2471 +f 3532//2454 3531//2465 3547//2472 +f 3527//2455 3526//2452 3542//2473 +f 3538//2459 3537//2456 3552//2474 +f 3533//2460 3532//2454 3547//2472 +f 3528//2457 3527//2455 3543//2475 +f 3539//2476 3538//2459 3553//2477 +f 3534//2462 3533//2460 3548//2478 +f 3529//2461 3528//2457 3544//2479 +f 3535//2464 3534//2462 3549//2480 +f 3549//2480 3548//2478 3563//2481 +f 3544//2479 3543//2475 3559//2482 +f 3550//2467 3549//2480 3564//2483 +f 3545//2466 3544//2479 3560//2484 +f 3551//2471 3550//2467 3565//2485 +f 3546//2468 3545//2466 3561//2486 +f 3541//2470 3540//2487 3556//2488 +f 3552//2474 3551//2471 3566//2489 +f 3547//2472 3546//2468 3562//2490 +f 3542//2473 3541//2470 3557//2491 +f 3553//2477 3552//2474 3567//2492 +f 3548//2478 3547//2472 3562//2490 +f 3543//2475 3542//2473 3558//2493 +f 3554//2494 3553//2477 3568//2495 +f 3568//2495 3567//2492 3582//2496 +f 3563//2481 3562//2490 3578//2497 +f 3558//2493 3557//2491 3573//2498 +f 3569//2499 3568//2495 3583//2500 +f 3564//2483 3563//2481 3578//2497 +f 3559//2482 3558//2493 3574//2501 +f 3565//2485 3564//2483 3579//2502 +f 3560//2484 3559//2482 3575//2503 +f 3566//2489 3565//2485 3580//2504 +f 3561//2486 3560//2484 3576//2505 +f 3556//2488 3555//2506 3571//2507 +f 3567//2492 3566//2489 3581//2508 +f 3562//2490 3561//2486 3577//2509 +f 3557//2491 3556//2488 3572//2510 +f 3571//2507 3570//2511 3586//2512 +f 3582//2496 3581//2508 3596//2513 +f 3577//2509 3576//2505 3592//2514 +f 3572//2510 3571//2507 3587//2515 +f 3583//2500 3582//2496 3597//2516 +f 3578//2497 3577//2509 3593//2517 +f 3573//2498 3572//2510 3588//2518 +f 3584//2519 3583//2500 3598//2520 +f 3579//2502 3578//2497 3593//2517 +f 3574//2501 3573//2498 3589//2521 +f 3580//2504 3579//2502 3594//2522 +f 3575//2503 3574//2501 3590//2523 +f 3581//2508 3580//2504 3595//2524 +f 3576//2505 3575//2503 3591//2525 +f 3590//2523 3589//2521 3605//2526 +f 3596//2513 3595//2524 3610//2527 +f 3591//2525 3590//2523 3606//2528 +f 3586//2512 3585//2529 3601//2530 +f 3597//2516 3596//2513 3611//2531 +f 3592//2514 3591//2525 3607//2532 +f 3587//2515 3586//2512 3602//2533 +f 3598//2520 3597//2516 3612//2534 +f 3593//2517 3592//2514 3608//2535 +f 3588//2518 3587//2515 3603//2536 +f 3599//2537 3598//2520 3613//2538 +f 3594//2522 3593//2517 3608//2535 +f 3589//2521 3588//2518 3604//2539 +f 3595//2524 3594//2522 3609//2540 +f 3609//2540 3608//2535 3624//2541 +f 3604//2539 3603//2536 3619//2542 +f 3610//2527 3609//2540 3625//2543 +f 3605//2526 3604//2539 3620//2544 +f 3611//2531 3610//2527 3626//2545 +f 3606//2528 3605//2526 3621//2546 +f 3601//2530 3600//2547 3615//2548 +f 3612//2534 3611//2531 3627//2549 +f 3607//2532 3606//2528 3622//2550 +f 3602//2533 3601//2530 3617//2551 +f 3613//2538 3612//2534 3628//2552 +f 3608//2535 3607//2532 3623//2553 +f 3603//2536 3602//2533 3618//2554 +f 3614//2555 3613//2538 3629//2556 +f 3628//2552 3627//2549 3643//2557 +f 3623//2553 3622//2550 3638//2558 +f 3618//2554 3617//2551 3632//2559 +f 3629//2556 3628//2552 3644//2560 +f 3624//2541 3623//2553 3639//2561 +f 3619//2542 3618//2554 3633//2562 +f 3625//2543 3624//2541 3640//2563 +f 3620//2544 3619//2542 3634//2564 +f 3626//2545 3625//2543 3641//2565 +f 3621//2546 3620//2544 3635//2566 +f 3616//2567 3615//2548 3630//2568 +f 3627//2549 3626//2545 3642//2569 +f 3622//2550 3621//2546 3637//2570 +f 3617//2551 3616//2567 3631//2571 +f 3642//2569 3641//2565 3657//2572 +f 3637//2570 3636//2573 3651//2574 +f 3632//2559 3631//2571 3646//2575 +f 3643//2557 3642//2569 3658//2576 +f 3638//2558 3637//2570 3653//2577 +f 3633//2562 3632//2559 3647//2578 +f 3644//2560 3643//2557 3659//2579 +f 3639//2561 3638//2558 3654//2580 +f 3634//2564 3633//2562 3648//2581 +f 3640//2563 3639//2561 3655//2582 +f 3635//2566 3634//2564 3649//2583 +f 3641//2565 3640//2563 3656//2584 +f 3636//2573 3635//2566 3650//2585 +f 3631//2571 3630//2568 3645//2586 +f 3656//2584 3655//2582 3671//2587 +f 3651//2574 3650//2585 3665//2588 +f 3646//2575 3645//2586 3660//2589 +f 3657//2572 3656//2584 3672//2590 +f 3652//2591 3651//2574 3666//2592 +f 3647//2578 3646//2575 3661//2593 +f 3658//2576 3657//2572 3673//2594 +f 3653//2577 3652//2591 3668//2595 +f 3648//2581 3647//2578 3662//2596 +f 3659//2579 3658//2576 3674//2597 +f 3654//2580 3653//2577 3669//2598 +f 3649//2583 3648//2581 3663//2599 +f 3655//2582 3654//2580 3670//2600 +f 3650//2585 3649//2583 3664//2601 +f 3664//2601 3663//2599 3678//2602 +f 3670//2600 3669//2598 3685//2603 +f 3665//2588 3664//2601 3679//2604 +f 3671//2587 3670//2600 3686//2605 +f 3666//2592 3665//2588 3680//2606 +f 3661//2593 3660//2589 3675//2607 +f 3672//2590 3671//2587 3687//2608 +f 3667//2609 3666//2592 3681//2610 +f 3662//2596 3661//2593 3676//2611 +f 3673//2594 3672//2590 3688//2612 +f 3668//2595 3667//2609 3683//2613 +f 3663//2599 3662//2596 3677//2614 +f 3674//2597 3673//2594 3689//2615 +f 3669//2598 3668//2595 3684//2616 +f 3683//2613 3682//2617 3698//2618 +f 3678//2602 3677//2614 3692//2619 +f 3689//2615 3688//2612 3704//2620 +f 3684//2616 3683//2613 3699//2621 +f 3679//2604 3678//2602 3693//2622 +f 3685//2603 3684//2616 3700//2623 +f 3680//2606 3679//2604 3694//2624 +f 3686//2605 3685//2603 3701//2625 +f 3681//2610 3680//2606 3695//2626 +f 3676//2611 3675//2607 3690//2627 +f 3687//2608 3686//2605 3702//2628 +f 3682//2617 3681//2610 3696//2629 +f 3677//2614 3676//2611 3691//2630 +f 3688//2612 3687//2608 3703//2631 +f 3702//2628 3701//2625 3718//2632 +f 3697//2633 3696//2629 3712//2634 +f 3692//2619 3691//2630 3707//2635 +f 3703//2631 3702//2628 3719//2636 +f 3698//2618 3697//2633 3714//2637 +f 3693//2622 3692//2619 3708//2638 +f 3704//2620 3703//2631 3720//2639 +f 3699//2621 3698//2618 3715//2640 +f 3694//2624 3693//2622 3709//2641 +f 3700//2623 3699//2621 3716//2642 +f 3695//2626 3694//2624 3710//2643 +f 3701//2625 3700//2623 3717//2644 +f 3696//2629 3695//2626 3711//2645 +f 3691//2630 3690//2627 3706//2646 +f 3717//2644 3716//2642 3732//2647 +f 3712//2634 3711//2645 3726//2648 +f 3707//2635 3706//2646 3721//2649 +f 3718//2632 3717//2644 3733//2650 +f 3713//2651 3712//2634 3727//2652 +f 3708//2638 3707//2635 3722//2653 +f 3719//2636 3718//2632 3734//2654 +f 3714//2637 3713//2651 3729//2655 +f 3709//2641 3708//2638 3723//2656 +f 3720//2639 3719//2636 3735//2657 +f 3715//2640 3714//2637 3730//2658 +f 3710//2643 3709//2641 3724//2659 +f 3716//2642 3715//2640 3731//2660 +f 3711//2645 3710//2643 3725//2661 +f 3725//2661 3724//2659 3739//2662 +f 3731//2660 3730//2658 3745//2663 +f 3726//2648 3725//2661 3740//2664 +f 3732//2647 3731//2660 3746//2665 +f 3727//2652 3726//2648 3741//2666 +f 3722//2653 3721//2649 3737//2667 +f 3733//2650 3732//2647 3747//2668 +f 3728//2669 3727//2652 3742//2670 +f 3723//2656 3722//2653 3738//2671 +f 3734//2654 3733//2650 3748//2672 +f 3729//2655 3728//2669 3743//2673 +f 3724//2659 3723//2656 3739//2662 +f 3735//2657 3734//2654 3749//2674 +f 3730//2658 3729//2655 3744//2675 +f 3744//2675 3743//2673 3758//2676 +f 3739//2662 3738//2671 3754//2677 +f 3750//2678 3749//2674 3764//2679 +f 3745//2663 3744//2675 3759//2680 +f 3740//2664 3739//2662 3755//2681 +f 3746//2665 3745//2663 3760//2682 +f 3741//2666 3740//2664 3756//2683 +f 3747//2668 3746//2665 3761//2684 +f 3742//2670 3741//2666 3757//2685 +f 3737//2667 3736//2686 3752//2687 +f 3748//2672 3747//2668 3762//2688 +f 3743//2673 3742//2670 3757//2685 +f 3738//2671 3737//2667 3753//2689 +f 3749//2674 3748//2672 3763//2690 +f 3763//2690 3762//2688 3777//2691 +f 3758//2676 3757//2685 3773//2692 +f 3753//2689 3752//2687 3768//2693 +f 3764//2679 3763//2690 3778//2694 +f 3759//2680 3758//2676 3773//2692 +f 3754//2677 3753//2689 3769//2695 +f 3765//2696 3764//2679 3779//2697 +f 3760//2682 3759//2680 3774//2698 +f 3755//2681 3754//2677 3770//2699 +f 3761//2684 3760//2682 3775//2700 +f 3756//2683 3755//2681 3771//2701 +f 3762//2688 3761//2684 3776//2702 +f 3757//2685 3756//2683 3772//2703 +f 3752//2687 3751//2704 3767//2705 +f 3777//2691 3776//2702 3791//2706 +f 3772//2703 3771//2701 3787//2707 +f 3767//2705 3766//2708 3782//2709 +f 3778//2694 3777//2691 3792//2710 +f 3773//2692 3772//2703 3788//2711 +f 3768//2693 3767//2705 3783//2712 +f 3779//2697 3778//2694 3793//2713 +f 3774//2698 3773//2692 3788//2711 +f 3769//2695 3768//2693 3784//2714 +f 3780//2715 3779//2697 3794//2716 +f 3775//2700 3774//2698 3789//2717 +f 3770//2699 3769//2695 3785//2718 +f 3776//2702 3775//2700 3790//2719 +f 3771//2701 3770//2699 3786//2720 +f 3791//2706 3790//2719 3805//2721 +f 3786//2720 3785//2718 3801//2722 +f 3792//2710 3791//2706 3806//2723 +f 3787//2707 3786//2720 3802//2724 +f 3782//2709 3781//2725 3797//2726 +f 3793//2713 3792//2710 3807//2727 +f 3788//2711 3787//2707 3803//2728 +f 3783//2712 3782//2709 3798//2729 +f 3794//2716 3793//2713 3808//2730 +f 3789//2717 3788//2711 3803//2728 +f 3784//2714 3783//2712 3799//2731 +f 3795//2732 3794//2716 3809//2733 +f 3790//2719 3789//2717 3804//2734 +f 3785//2718 3784//2714 3800//2735 +f 3799//2731 3798//2729 3814//2736 +f 3810//2737 3809//2733 3824//2738 +f 3805//2721 3804//2734 3819//2739 +f 3800//2735 3799//2731 3815//2740 +f 3806//2723 3805//2721 3820//2741 +f 3801//2722 3800//2735 3816//2742 +f 3807//2727 3806//2723 3821//2743 +f 3802//2724 3801//2722 3817//2744 +f 3797//2726 3796//2745 3812//2746 +f 3808//2730 3807//2727 3822//2747 +f 3803//2728 3802//2724 3817//2744 +f 3798//2729 3797//2726 3813//2748 +f 3809//2733 3808//2730 3823//2749 +f 3804//2734 3803//2728 3818//2750 +f 3818//2750 3817//2744 3833//2751 +f 3813//2748 3812//2746 3829//2752 +f 3824//2738 3823//2749 3839//2753 +f 3819//2739 3818//2750 3834//2754 +f 3814//2736 3813//2748 3830//2755 +f 3825//2756 3824//2738 3840//2757 +f 3820//2741 3819//2739 3835//2758 +f 3815//2740 3814//2736 3831//2759 +f 3821//2743 3820//2741 3836//2760 +f 3816//2742 3815//2740 3832//2761 +f 3822//2747 3821//2743 3837//2762 +f 3817//2744 3816//2742 3833//2751 +f 3812//2746 3811//2763 3828//2764 +f 3823//2749 3822//2747 3838//2765 +f 3838//2765 3837//2762 3852//2766 +f 3833//2751 3832//2761 3848//2767 +f 3828//2764 3827//2768 3843//2769 +f 3839//2753 3838//2765 3853//2770 +f 3834//2754 3833//2751 3848//2767 +f 3829//2752 3828//2764 3844//2771 +f 3840//2757 3839//2753 3854//2772 +f 3835//2758 3834//2754 3849//2773 +f 3830//2755 3829//2752 3845//2774 +f 3841//2775 3840//2757 3855//2776 +f 3836//2760 3835//2758 3850//2777 +f 3831//2759 3830//2755 3846//2778 +f 3837//2762 3836//2760 3851//2779 +f 3832//2761 3831//2759 3847//2780 +f 3705//2781 3389//2322 3404//2323 +f 3375//2307 3826//2782 3390//2308 +f 3705//2781 3404//2323 3419//2341 +f 3390//2308 3826//2782 3405//2333 +f 3405//2333 3826//2782 3420//2351 +f 3705//2781 3419//2341 3434//2359 +f 3705//2781 3434//2359 3449//2362 +f 3420//2351 3826//2782 3435//2369 +f 3705//2781 3449//2362 3464//2382 +f 3435//2369 3826//2782 3450//2389 +f 3705//2781 3464//2382 3479//2401 +f 3450//2389 3826//2782 3465//2393 +f 3465//2393 3826//2782 3480//2411 +f 3705//2781 3479//2401 3494//2419 +f 3705//2781 3494//2419 3509//2439 +f 3480//2411 3826//2782 3495//2446 +f 3705//2781 3509//2439 3524//2458 +f 3495//2446 3826//2782 3510//2451 +f 3705//2781 3524//2458 3539//2476 +f 3510//2451 3826//2782 3525//2469 +f 3525//2469 3826//2782 3540//2487 +f 3705//2781 3539//2476 3554//2494 +f 3705//2781 3554//2494 3569//2499 +f 3540//2487 3826//2782 3555//2506 +f 3705//2781 3569//2499 3584//2519 +f 3555//2506 3826//2782 3570//2511 +f 3705//2781 3584//2519 3599//2537 +f 3570//2511 3826//2782 3585//2529 +f 3585//2529 3826//2782 3600//2547 +f 3705//2781 3599//2537 3614//2555 +f 3705//2781 3614//2555 3629//2556 +f 3600//2547 3826//2782 3615//2548 +f 3705//2781 3629//2556 3644//2560 +f 3615//2548 3826//2782 3630//2568 +f 3705//2781 3644//2560 3659//2579 +f 3630//2568 3826//2782 3645//2586 +f 3645//2586 3826//2782 3660//2589 +f 3705//2781 3659//2579 3674//2597 +f 3705//2781 3674//2597 3689//2615 +f 3660//2589 3826//2782 3675//2607 +f 3705//2781 3689//2615 3704//2620 +f 3675//2607 3826//2782 3690//2627 +f 3705//2781 3704//2620 3720//2639 +f 3690//2627 3826//2782 3706//2646 +f 3706//2646 3826//2782 3721//2649 +f 3705//2781 3720//2639 3735//2657 +f 3705//2781 3735//2657 3750//2678 +f 3721//2649 3826//2782 3736//2686 +f 3705//2781 3750//2678 3765//2696 +f 3736//2686 3826//2782 3751//2704 +f 3705//2781 3765//2696 3780//2715 +f 3751//2704 3826//2782 3766//2708 +f 3705//2781 3780//2715 3795//2732 +f 3766//2708 3826//2782 3781//2725 +f 3705//2781 3795//2732 3810//2737 +f 3781//2725 3826//2782 3796//2745 +f 3705//2781 3810//2737 3825//2756 +f 3796//2745 3826//2782 3811//2763 +f 3705//2781 3825//2756 3841//2775 +f 3811//2763 3826//2782 3827//2768 +f 3705//2781 3841//2775 3856//2783 +f 3827//2768 3826//2782 3842//2784 +f 3705//2781 3856//2783 3389//2322 +f 3852//2766 3851//2779 3384//2324 +f 3847//2780 3846//2778 3379//2326 +f 3842//2784 3826//2782 3375//2307 +f 3853//2770 3852//2766 3385//2328 +f 3848//2767 3847//2780 3380//2304 +f 3843//2769 3842//2784 3375//2307 +f 3854//2772 3853//2770 3386//2310 +f 3849//2773 3848//2767 3381//2303 +f 3844//2771 3843//2769 3376//2306 +f 3855//2776 3854//2772 3387//2309 +f 3850//2777 3849//2773 3382//2312 +f 3845//2774 3844//2771 3377//2314 +f 3856//2783 3855//2776 3389//2322 +f 3851//2779 3850//2777 3383//2318 +f 3846//2778 3845//2774 3378//2320 +f 3863//2303 3862//2785 3877//2305 +f 3858//2306 3857//2786 3872//2308 +f 3869//2309 3868//2310 3884//2787 +f 3864//2312 3863//2303 3878//2788 +f 3859//2314 3858//2306 3873//2315 +f 3870//2789 3869//2309 3885//2790 +f 3865//2318 3864//2312 3879//2319 +f 3860//2320 3859//2314 3874//2321 +f 3871//2791 3870//2789 3886//2792 +f 3866//2324 3865//2318 3881//2325 +f 3861//2326 3860//2320 3875//2793 +f 3867//2328 3866//2324 3882//2794 +f 3862//2785 3861//2326 3876//2330 +f 3868//2310 3867//2328 3883//2331 +f 3878//2788 3877//2305 3892//2332 +f 3873//2315 3872//2308 3887//2795 +f 3884//2787 3883//2331 3899//2334 +f 3879//2319 3878//2788 3893//2335 +f 3874//2321 3873//2315 3888//2336 +f 3885//2790 3884//2787 3900//2337 +f 3880//2338 3879//2319 3895//2339 +f 3875//2793 3874//2321 3889//2340 +f 3886//2792 3885//2790 3901//2796 +f 3881//2325 3880//2338 3896//2342 +f 3876//2330 3875//2793 3890//2797 +f 3882//2794 3881//2325 3897//2344 +f 3877//2305 3876//2330 3891//2345 +f 3883//2331 3882//2794 3898//2346 +f 3897//2344 3896//2342 3912//2798 +f 3892//2332 3891//2345 3906//2348 +f 3898//2346 3897//2344 3913//2349 +f 3893//2335 3892//2332 3907//2350 +f 3888//2336 3887//2795 3902//2351 +f 3899//2334 3898//2346 3914//2352 +f 3894//2799 3893//2335 3908//2354 +f 3889//2340 3888//2336 3903//2800 +f 3900//2337 3899//2334 3915//2801 +f 3895//2339 3894//2799 3910//2357 +f 3890//2797 3889//2340 3904//2802 +f 3901//2796 3900//2337 3916//2359 +f 3896//2342 3895//2339 3911//2360 +f 3891//2345 3890//2797 3905//2361 +f 3916//2359 3915//2801 3931//2803 +f 3911//2360 3910//2357 3926//2363 +f 3906//2348 3905//2361 3920//2364 +f 3912//2798 3911//2360 3927//2365 +f 3907//2350 3906//2348 3921//2366 +f 3913//2349 3912//2798 3928//2367 +f 3908//2354 3907//2350 3922//2368 +f 3903//2800 3902//2351 3917//2804 +f 3914//2352 3913//2349 3929//2370 +f 3909//2371 3908//2354 3923//2372 +f 3904//2802 3903//2800 3918//2805 +f 3915//2801 3914//2352 3930//2806 +f 3910//2357 3909//2371 3925//2375 +f 3905//2361 3904//2802 3919//2376 +f 3919//2376 3918//2805 3933//2807 +f 3930//2806 3929//2370 3945//2808 +f 3925//2375 3924//2379 3940//2809 +f 3920//2364 3919//2376 3934//2810 +f 3931//2803 3930//2806 3946//2811 +f 3926//2363 3925//2375 3941//2383 +f 3921//2366 3920//2364 3935//2384 +f 3927//2365 3926//2363 3942//2812 +f 3922//2368 3921//2366 3936//2386 +f 3928//2367 3927//2365 3943//2387 +f 3923//2372 3922//2368 3937//2388 +f 3918//2805 3917//2804 3932//2813 +f 3929//2370 3928//2367 3944//2390 +f 3924//2379 3923//2372 3938//2814 +f 3938//2814 3937//2388 3952//2392 +f 3933//2807 3932//2813 3947//2815 +f 3944//2390 3943//2387 3959//2394 +f 3939//2395 3938//2814 3953//2396 +f 3934//2810 3933//2807 3948//2397 +f 3945//2808 3944//2390 3960//2398 +f 3940//2809 3939//2395 3955//2816 +f 3935//2384 3934//2810 3949//2400 +f 3946//2811 3945//2808 3961//2817 +f 3941//2383 3940//2809 3956//2818 +f 3936//2386 3935//2384 3950//2403 +f 3942//2812 3941//2383 3957//2404 +f 3937//2388 3936//2386 3951//2405 +f 3943//2387 3942//2812 3958//2819 +f 3957//2404 3956//2818 3972//2407 +f 3952//2392 3951//2405 3966//2820 +f 3958//2819 3957//2404 3973//2409 +f 3953//2396 3952//2392 3967//2410 +f 3948//2397 3947//2815 3962//2411 +f 3959//2394 3958//2819 3974//2821 +f 3954//2413 3953//2396 3968//2414 +f 3949//2400 3948//2397 3963//2822 +f 3960//2398 3959//2394 3975//2416 +f 3955//2816 3954//2413 3970//2417 +f 3950//2403 3949//2400 3964//2418 +f 3961//2817 3960//2398 3976//2419 +f 3956//2818 3955//2816 3971//2420 +f 3951//2405 3950//2403 3965//2421 +f 3976//2419 3975//2416 3990//2422 +f 3971//2420 3970//2417 3986//2423 +f 3966//2820 3965//2421 3981//2424 +f 3972//2407 3971//2420 3987//2425 +f 3967//2410 3966//2820 3982//2426 +f 3973//2409 3972//2407 3988//2427 +f 3968//2414 3967//2410 3983//2428 +f 3963//2822 3962//2411 3978//2429 +f 3974//2821 3973//2409 3988//2427 +f 3969//2430 3968//2414 3984//2431 +f 3964//2418 3963//2822 3979//2432 +f 3975//2416 3974//2821 3989//2433 +f 3970//2417 3969//2430 3985//2823 +f 3965//2421 3964//2418 3980//2435 +f 3990//2422 3989//2433 4004//2436 +f 3985//2823 3984//2431 4000//2437 +f 3980//2435 3979//2432 3995//2438 +f 3991//2439 3990//2422 4005//2440 +f 3986//2423 3985//2823 4000//2437 +f 3981//2424 3980//2435 3996//2824 +f 3987//2425 3986//2423 4001//2825 +f 3982//2426 3981//2424 3997//2826 +f 3988//2427 3987//2425 4002//2444 +f 3983//2428 3982//2426 3998//2445 +f 3978//2429 3977//2446 3993//2447 +f 3989//2433 3988//2427 4003//2827 +f 3984//2431 3983//2428 3999//2449 +f 3979//2432 3978//2429 3994//2450 +f 3993//2447 3992//2828 4008//2452 +f 4004//2436 4003//2827 4018//2453 +f 3999//2449 3998//2445 4014//2454 +f 3994//2450 3993//2447 4009//2829 +f 4005//2440 4004//2436 4019//2830 +f 4000//2437 3999//2449 4014//2454 +f 3995//2438 3994//2450 4010//2457 +f 4006//2831 4005//2440 4020//2459 +f 4001//2825 4000//2437 4015//2460 +f 3996//2824 3995//2438 4011//2461 +f 4002//2444 4001//2825 4016//2462 +f 3997//2826 3996//2824 4012//2463 +f 4003//2827 4002//2444 4017//2464 +f 3998//2445 3997//2826 4013//2465 +f 4012//2463 4011//2461 4027//2832 +f 4018//2453 4017//2464 4032//2467 +f 4013//2465 4012//2463 4028//2468 +f 4008//2452 4007//2469 4023//2833 +f 4019//2830 4018//2453 4033//2471 +f 4014//2454 4013//2465 4029//2472 +f 4009//2829 4008//2452 4024//2473 +f 4020//2459 4019//2830 4034//2834 +f 4015//2460 4014//2454 4029//2472 +f 4010//2457 4009//2829 4025//2835 +f 4021//2476 4020//2459 4035//2477 +f 4016//2462 4015//2460 4030//2478 +f 4011//2461 4010//2457 4026//2836 +f 4017//2464 4016//2462 4031//2480 +f 4031//2480 4030//2478 4045//2481 +f 4026//2836 4025//2835 4041//2482 +f 4032//2467 4031//2480 4046//2483 +f 4027//2832 4026//2836 4042//2484 +f 4033//2471 4032//2467 4047//2837 +f 4028//2468 4027//2832 4043//2838 +f 4023//2833 4022//2839 4038//2488 +f 4034//2834 4033//2471 4048//2489 +f 4029//2472 4028//2468 4044//2490 +f 4024//2473 4023//2833 4039//2840 +f 4035//2477 4034//2834 4049//2492 +f 4030//2478 4029//2472 4044//2490 +f 4025//2835 4024//2473 4040//2493 +f 4036//2494 4035//2477 4050//2495 +f 4050//2495 4049//2492 4064//2496 +f 4045//2481 4044//2490 4060//2841 +f 4040//2493 4039//2840 4055//2842 +f 4051//2843 4050//2495 4065//2500 +f 4046//2483 4045//2481 4060//2841 +f 4041//2482 4040//2493 4056//2501 +f 4047//2837 4046//2483 4061//2502 +f 4042//2484 4041//2482 4057//2503 +f 4048//2489 4047//2837 4062//2504 +f 4043//2838 4042//2484 4058//2505 +f 4038//2488 4037//2506 4053//2507 +f 4049//2492 4048//2489 4063//2508 +f 4044//2490 4043//2838 4059//2844 +f 4039//2840 4038//2488 4054//2845 +f 4053//2507 4052//2511 4068//2512 +f 4064//2496 4063//2508 4078//2513 +f 4059//2844 4058//2505 4074//2846 +f 4054//2845 4053//2507 4069//2515 +f 4065//2500 4064//2496 4079//2847 +f 4060//2841 4059//2844 4075//2517 +f 4055//2842 4054//2845 4070//2518 +f 4066//2848 4065//2500 4080//2849 +f 4061//2502 4060//2841 4075//2517 +f 4056//2501 4055//2842 4071//2850 +f 4062//2504 4061//2502 4076//2522 +f 4057//2503 4056//2501 4072//2851 +f 4063//2508 4062//2504 4077//2524 +f 4058//2505 4057//2503 4073//2525 +f 4072//2851 4071//2850 4087//2526 +f 4078//2513 4077//2524 4092//2852 +f 4073//2525 4072//2851 4088//2528 +f 4068//2512 4067//2529 4083//2853 +f 4079//2847 4078//2513 4093//2531 +f 4074//2846 4073//2525 4089//2854 +f 4069//2515 4068//2512 4084//2855 +f 4080//2849 4079//2847 4094//2534 +f 4075//2517 4074//2846 4090//2535 +f 4070//2518 4069//2515 4085//2536 +f 4081//2537 4080//2849 4095//2538 +f 4076//2522 4075//2517 4090//2535 +f 4071//2850 4070//2518 4086//2856 +f 4077//2524 4076//2522 4091//2540 +f 4091//2540 4090//2535 4106//2541 +f 4086//2856 4085//2536 4101//2542 +f 4092//2852 4091//2540 4107//2543 +f 4087//2526 4086//2856 4102//2544 +f 4093//2531 4092//2852 4108//2545 +f 4088//2528 4087//2526 4103//2857 +f 4083//2853 4082//2858 4097//2548 +f 4094//2534 4093//2531 4109//2549 +f 4089//2854 4088//2528 4104//2859 +f 4084//2855 4083//2853 4099//2551 +f 4095//2538 4094//2534 4110//2860 +f 4090//2535 4089//2854 4105//2553 +f 4085//2536 4084//2855 4100//2554 +f 4096//2555 4095//2538 4111//2556 +f 4110//2860 4109//2549 4125//2557 +f 4105//2553 4104//2859 4120//2558 +f 4100//2554 4099//2551 4114//2559 +f 4111//2556 4110//2860 4126//2861 +f 4106//2541 4105//2553 4121//2561 +f 4101//2542 4100//2554 4115//2562 +f 4107//2543 4106//2541 4122//2563 +f 4102//2544 4101//2542 4116//2564 +f 4108//2545 4107//2543 4123//2862 +f 4103//2857 4102//2544 4117//2566 +f 4098//2567 4097//2548 4112//2568 +f 4109//2549 4108//2545 4124//2569 +f 4104//2859 4103//2857 4119//2570 +f 4099//2551 4098//2567 4113//2571 +f 4124//2569 4123//2862 4139//2572 +f 4119//2570 4118//2863 4133//2574 +f 4114//2559 4113//2571 4128//2864 +f 4125//2557 4124//2569 4140//2576 +f 4120//2558 4119//2570 4135//2577 +f 4115//2562 4114//2559 4129//2578 +f 4126//2861 4125//2557 4141//2579 +f 4121//2561 4120//2558 4136//2580 +f 4116//2564 4115//2562 4130//2865 +f 4122//2563 4121//2561 4137//2582 +f 4117//2566 4116//2564 4131//2583 +f 4123//2862 4122//2563 4138//2866 +f 4118//2863 4117//2566 4132//2867 +f 4113//2571 4112//2568 4127//2586 +f 4138//2866 4137//2582 4153//2587 +f 4133//2574 4132//2867 4147//2588 +f 4128//2864 4127//2586 4142//2589 +f 4139//2572 4138//2866 4154//2868 +f 4134//2591 4133//2574 4148//2869 +f 4129//2578 4128//2864 4143//2593 +f 4140//2576 4139//2572 4155//2870 +f 4135//2577 4134//2591 4150//2595 +f 4130//2865 4129//2578 4144//2596 +f 4141//2579 4140//2576 4156//2597 +f 4136//2580 4135//2577 4151//2598 +f 4131//2583 4130//2865 4145//2599 +f 4137//2582 4136//2580 4152//2600 +f 4132//2867 4131//2583 4146//2601 +f 4146//2601 4145//2599 4160//2602 +f 4152//2600 4151//2598 4167//2871 +f 4147//2588 4146//2601 4161//2604 +f 4153//2587 4152//2600 4168//2605 +f 4148//2869 4147//2588 4162//2606 +f 4143//2593 4142//2589 4157//2872 +f 4154//2868 4153//2587 4169//2608 +f 4149//2609 4148//2869 4163//2610 +f 4144//2596 4143//2593 4158//2611 +f 4155//2870 4154//2868 4170//2873 +f 4150//2595 4149//2609 4165//2613 +f 4145//2599 4144//2596 4159//2874 +f 4156//2597 4155//2870 4171//2615 +f 4151//2598 4150//2595 4166//2616 +f 4165//2613 4164//2875 4180//2618 +f 4160//2602 4159//2874 4174//2619 +f 4171//2615 4170//2873 4186//2620 +f 4166//2616 4165//2613 4181//2621 +f 4161//2604 4160//2602 4175//2622 +f 4167//2871 4166//2616 4182//2623 +f 4162//2606 4161//2604 4176//2876 +f 4168//2605 4167//2871 4183//2625 +f 4163//2610 4162//2606 4177//2626 +f 4158//2611 4157//2872 4172//2877 +f 4169//2608 4168//2605 4184//2628 +f 4164//2875 4163//2610 4178//2629 +f 4159//2874 4158//2611 4173//2878 +f 4170//2873 4169//2608 4185//2631 +f 4184//2628 4183//2625 4200//2632 +f 4179//2633 4178//2629 4194//2634 +f 4174//2619 4173//2878 4189//2635 +f 4185//2631 4184//2628 4201//2636 +f 4180//2618 4179//2633 4196//2637 +f 4175//2622 4174//2619 4190//2638 +f 4186//2620 4185//2631 4202//2879 +f 4181//2621 4180//2618 4197//2640 +f 4176//2876 4175//2622 4191//2880 +f 4182//2623 4181//2621 4198//2642 +f 4177//2626 4176//2876 4192//2643 +f 4183//2625 4182//2623 4199//2644 +f 4178//2629 4177//2626 4193//2881 +f 4173//2878 4172//2877 4188//2882 +f 4199//2644 4198//2642 4214//2647 +f 4194//2634 4193//2881 4208//2648 +f 4189//2635 4188//2882 4203//2649 +f 4200//2632 4199//2644 4215//2650 +f 4195//2883 4194//2634 4209//2884 +f 4190//2638 4189//2635 4204//2653 +f 4201//2636 4200//2632 4216//2654 +f 4196//2637 4195//2883 4211//2655 +f 4191//2880 4190//2638 4205//2656 +f 4202//2879 4201//2636 4217//2657 +f 4197//2640 4196//2637 4212//2885 +f 4192//2643 4191//2880 4206//2659 +f 4198//2642 4197//2640 4213//2886 +f 4193//2881 4192//2643 4207//2661 +f 4207//2661 4206//2659 4221//2662 +f 4213//2886 4212//2885 4227//2663 +f 4208//2648 4207//2661 4222//2664 +f 4214//2647 4213//2886 4228//2665 +f 4209//2884 4208//2648 4223//2666 +f 4204//2653 4203//2649 4219//2667 +f 4215//2650 4214//2647 4229//2668 +f 4210//2669 4209//2884 4224//2887 +f 4205//2656 4204//2653 4220//2671 +f 4216//2654 4215//2650 4230//2672 +f 4211//2655 4210//2669 4225//2673 +f 4206//2659 4205//2656 4221//2662 +f 4217//2657 4216//2654 4231//2674 +f 4212//2885 4211//2655 4226//2675 +f 4226//2675 4225//2673 4240//2676 +f 4221//2662 4220//2671 4236//2677 +f 4232//2678 4231//2674 4246//2679 +f 4227//2663 4226//2675 4241//2680 +f 4222//2664 4221//2662 4237//2681 +f 4228//2665 4227//2663 4242//2888 +f 4223//2666 4222//2664 4238//2683 +f 4229//2668 4228//2665 4243//2684 +f 4224//2887 4223//2666 4239//2685 +f 4219//2667 4218//2686 4234//2687 +f 4230//2672 4229//2668 4244//2688 +f 4225//2673 4224//2887 4239//2685 +f 4220//2671 4219//2667 4235//2689 +f 4231//2674 4230//2672 4245//2690 +f 4245//2690 4244//2688 4259//2691 +f 4240//2676 4239//2685 4255//2692 +f 4235//2689 4234//2687 4250//2889 +f 4246//2679 4245//2690 4260//2890 +f 4241//2680 4240//2676 4255//2692 +f 4236//2677 4235//2689 4251//2695 +f 4247//2891 4246//2679 4261//2697 +f 4242//2888 4241//2680 4256//2698 +f 4237//2681 4236//2677 4252//2699 +f 4243//2684 4242//2888 4257//2700 +f 4238//2683 4237//2681 4253//2701 +f 4244//2688 4243//2684 4258//2702 +f 4239//2685 4238//2683 4254//2703 +f 4234//2687 4233//2892 4249//2893 +f 4259//2691 4258//2702 4273//2894 +f 4254//2703 4253//2701 4269//2707 +f 4249//2893 4248//2708 4264//2709 +f 4260//2890 4259//2691 4274//2895 +f 4255//2692 4254//2703 4270//2711 +f 4250//2889 4249//2893 4265//2896 +f 4261//2697 4260//2890 4275//2713 +f 4256//2698 4255//2692 4270//2711 +f 4251//2695 4250//2889 4266//2714 +f 4262//2715 4261//2697 4276//2716 +f 4257//2700 4256//2698 4271//2717 +f 4252//2699 4251//2695 4267//2718 +f 4258//2702 4257//2700 4272//2719 +f 4253//2701 4252//2699 4268//2720 +f 4273//2894 4272//2719 4287//2897 +f 4268//2720 4267//2718 4283//2722 +f 4274//2895 4273//2894 4288//2723 +f 4269//2707 4268//2720 4284//2724 +f 4264//2709 4263//2725 4279//2726 +f 4275//2713 4274//2895 4289//2727 +f 4270//2711 4269//2707 4285//2728 +f 4265//2896 4264//2709 4280//2729 +f 4276//2716 4275//2713 4290//2730 +f 4271//2717 4270//2711 4285//2728 +f 4266//2714 4265//2896 4281//2731 +f 4277//2732 4276//2716 4291//2733 +f 4272//2719 4271//2717 4286//2734 +f 4267//2718 4266//2714 4282//2735 +f 4281//2731 4280//2729 4296//2736 +f 4292//2898 4291//2733 4306//2899 +f 4287//2897 4286//2734 4301//2739 +f 4282//2735 4281//2731 4297//2740 +f 4288//2723 4287//2897 4302//2741 +f 4283//2722 4282//2735 4298//2742 +f 4289//2727 4288//2723 4303//2743 +f 4284//2724 4283//2722 4299//2900 +f 4279//2726 4278//2745 4294//2746 +f 4290//2730 4289//2727 4304//2747 +f 4285//2728 4284//2724 4299//2900 +f 4280//2729 4279//2726 4295//2748 +f 4291//2733 4290//2730 4305//2901 +f 4286//2734 4285//2728 4300//2750 +f 4300//2750 4299//2900 4315//2751 +f 4295//2748 4294//2746 4311//2752 +f 4306//2899 4305//2901 4321//2753 +f 4301//2739 4300//2750 4316//2754 +f 4296//2736 4295//2748 4312//2755 +f 4307//2756 4306//2899 4322//2757 +f 4302//2741 4301//2739 4317//2758 +f 4297//2740 4296//2736 4313//2759 +f 4303//2743 4302//2741 4318//2760 +f 4298//2742 4297//2740 4314//2761 +f 4304//2747 4303//2743 4319//2762 +f 4299//2900 4298//2742 4315//2751 +f 4294//2746 4293//2902 4310//2764 +f 4305//2901 4304//2747 4320//2765 +f 4320//2765 4319//2762 4334//2766 +f 4315//2751 4314//2761 4330//2903 +f 4310//2764 4309//2904 4325//2769 +f 4321//2753 4320//2765 4335//2770 +f 4316//2754 4315//2751 4330//2903 +f 4311//2752 4310//2764 4326//2771 +f 4322//2757 4321//2753 4336//2772 +f 4317//2758 4316//2754 4331//2773 +f 4312//2755 4311//2752 4327//2774 +f 4323//2905 4322//2757 4337//2906 +f 4318//2760 4317//2758 4332//2777 +f 4313//2759 4312//2755 4328//2778 +f 4319//2762 4318//2760 4333//2779 +f 4314//2761 4313//2759 4329//2780 +f 4187//2781 3871//2791 3886//2792 +f 3857//2786 4308//2782 3872//2308 +f 4187//2781 3886//2792 3901//2796 +f 3872//2308 4308//2782 3887//2795 +f 3887//2795 4308//2782 3902//2351 +f 4187//2781 3901//2796 3916//2359 +f 4187//2781 3916//2359 3931//2803 +f 3902//2351 4308//2782 3917//2804 +f 4187//2781 3931//2803 3946//2811 +f 3917//2804 4308//2782 3932//2813 +f 4187//2781 3946//2811 3961//2817 +f 3932//2813 4308//2782 3947//2815 +f 3947//2815 4308//2782 3962//2411 +f 4187//2781 3961//2817 3976//2419 +f 4187//2781 3976//2419 3991//2439 +f 3962//2411 4308//2782 3977//2446 +f 4187//2781 3991//2439 4006//2831 +f 3977//2446 4308//2782 3992//2828 +f 4187//2781 4006//2831 4021//2476 +f 3992//2828 4308//2782 4007//2469 +f 4007//2469 4308//2782 4022//2839 +f 4187//2781 4021//2476 4036//2494 +f 4187//2781 4036//2494 4051//2843 +f 4022//2839 4308//2782 4037//2506 +f 4187//2781 4051//2843 4066//2848 +f 4037//2506 4308//2782 4052//2511 +f 4187//2781 4066//2848 4081//2537 +f 4052//2511 4308//2782 4067//2529 +f 4067//2529 4308//2782 4082//2858 +f 4187//2781 4081//2537 4096//2555 +f 4187//2781 4096//2555 4111//2556 +f 4082//2858 4308//2782 4097//2548 +f 4187//2781 4111//2556 4126//2861 +f 4097//2548 4308//2782 4112//2568 +f 4187//2781 4126//2861 4141//2579 +f 4112//2568 4308//2782 4127//2586 +f 4127//2586 4308//2782 4142//2589 +f 4187//2781 4141//2579 4156//2597 +f 4187//2781 4156//2597 4171//2615 +f 4142//2589 4308//2782 4157//2872 +f 4187//2781 4171//2615 4186//2620 +f 4157//2872 4308//2782 4172//2877 +f 4187//2781 4186//2620 4202//2879 +f 4172//2877 4308//2782 4188//2882 +f 4188//2882 4308//2782 4203//2649 +f 4187//2781 4202//2879 4217//2657 +f 4187//2781 4217//2657 4232//2678 +f 4203//2649 4308//2782 4218//2686 +f 4187//2781 4232//2678 4247//2891 +f 4218//2686 4308//2782 4233//2892 +f 4187//2781 4247//2891 4262//2715 +f 4233//2892 4308//2782 4248//2708 +f 4187//2781 4262//2715 4277//2732 +f 4248//2708 4308//2782 4263//2725 +f 4187//2781 4277//2732 4292//2898 +f 4263//2725 4308//2782 4278//2745 +f 4187//2781 4292//2898 4307//2756 +f 4278//2745 4308//2782 4293//2902 +f 4187//2781 4307//2756 4323//2905 +f 4293//2902 4308//2782 4309//2904 +f 4187//2781 4323//2905 4338//2907 +f 4309//2904 4308//2782 4324//2908 +f 4187//2781 4338//2907 3871//2791 +f 4334//2766 4333//2779 3866//2324 +f 4329//2780 4328//2778 3861//2326 +f 4324//2908 4308//2782 3857//2786 +f 4335//2770 4334//2766 3867//2328 +f 4330//2903 4329//2780 3862//2785 +f 4325//2769 4324//2908 3857//2786 +f 4336//2772 4335//2770 3868//2310 +f 4331//2773 4330//2903 3863//2303 +f 4326//2771 4325//2769 3858//2306 +f 4337//2906 4336//2772 3869//2309 +f 4332//2777 4331//2773 3864//2312 +f 4327//2774 4326//2771 3859//2314 +f 4338//2907 4337//2906 3871//2791 +f 4333//2779 4332//2777 3865//2318 +f 4328//2778 4327//2774 3860//2320 +f 3396//2313 3381//2303 3395//2305 +f 3391//2315 3376//2306 3390//2308 +f 3386//2310 3401//2331 3402//2311 +f 3397//2319 3382//2312 3396//2313 +f 3392//2321 3377//2314 3391//2315 +f 3387//2309 3402//2311 3403//2317 +f 3398//2338 3383//2318 3397//2319 +f 3393//2327 3378//2320 3392//2321 +f 3388//2316 3403//2317 3404//2323 +f 3383//2318 3398//2338 3399//2325 +f 3394//2330 3379//2326 3393//2327 +f 3384//2324 3399//2325 3400//2329 +f 3395//2305 3380//2304 3394//2330 +f 3385//2328 3400//2329 3401//2331 +f 3411//2335 3396//2313 3410//2332 +f 3406//2336 3391//2315 3405//2333 +f 3401//2331 3416//2346 3417//2334 +f 3412//2353 3397//2319 3411//2335 +f 3407//2340 3392//2321 3406//2336 +f 3402//2311 3417//2334 3418//2337 +f 3397//2319 3412//2353 3413//2339 +f 3408//2343 3393//2327 3407//2340 +f 3403//2317 3418//2337 3419//2341 +f 3398//2338 3413//2339 3414//2342 +f 3409//2345 3394//2330 3408//2343 +f 3399//2325 3414//2342 3415//2344 +f 3410//2332 3395//2305 3409//2345 +f 3400//2329 3415//2344 3416//2346 +f 3414//2342 3429//2360 3430//2347 +f 3425//2350 3410//2332 3424//2348 +f 3415//2344 3430//2347 3431//2349 +f 3426//2354 3411//2335 3425//2350 +f 3421//2355 3406//2336 3420//2351 +f 3416//2346 3431//2349 3432//2352 +f 3427//2371 3412//2353 3426//2354 +f 3422//2358 3407//2340 3421//2355 +f 3417//2334 3432//2352 3433//2356 +f 3412//2353 3427//2371 3428//2357 +f 3423//2361 3408//2343 3422//2358 +f 3418//2337 3433//2356 3434//2359 +f 3413//2339 3428//2357 3429//2360 +f 3424//2348 3409//2345 3423//2361 +f 3433//2356 3448//2374 3449//2362 +f 3428//2357 3443//2375 3444//2363 +f 3439//2366 3424//2348 3438//2364 +f 3429//2360 3444//2363 3445//2365 +f 3440//2368 3425//2350 3439//2366 +f 3430//2347 3445//2365 3446//2367 +f 3441//2372 3426//2354 3440//2368 +f 3436//2373 3421//2355 3435//2369 +f 3431//2349 3446//2367 3447//2370 +f 3442//2379 3427//2371 3441//2372 +f 3437//2376 3422//2358 3436//2373 +f 3432//2352 3447//2370 3448//2374 +f 3427//2371 3442//2379 3443//2375 +f 3438//2364 3423//2361 3437//2376 +f 3452//2381 3437//2376 3451//2377 +f 3447//2370 3462//2390 3463//2378 +f 3442//2379 3457//2395 3458//2380 +f 3453//2384 3438//2364 3452//2381 +f 3448//2374 3463//2378 3464//2382 +f 3443//2375 3458//2380 3459//2383 +f 3454//2386 3439//2366 3453//2384 +f 3444//2363 3459//2383 3460//2385 +f 3455//2388 3440//2368 3454//2386 +f 3445//2365 3460//2385 3461//2387 +f 3456//2391 3441//2372 3455//2388 +f 3451//2377 3436//2373 3450//2389 +f 3446//2367 3461//2387 3462//2390 +f 3457//2395 3442//2379 3456//2391 +f 3471//2396 3456//2391 3470//2392 +f 3466//2397 3451//2377 3465//2393 +f 3461//2387 3476//2406 3477//2394 +f 3472//2413 3457//2395 3471//2396 +f 3467//2400 3452//2381 3466//2397 +f 3462//2390 3477//2394 3478//2398 +f 3457//2395 3472//2413 3473//2399 +f 3468//2403 3453//2384 3467//2400 +f 3463//2378 3478//2398 3479//2401 +f 3458//2380 3473//2399 3474//2402 +f 3469//2405 3454//2386 3468//2403 +f 3459//2383 3474//2402 3475//2404 +f 3470//2392 3455//2388 3469//2405 +f 3460//2385 3475//2404 3476//2406 +f 3474//2402 3489//2420 3490//2407 +f 3485//2410 3470//2392 3484//2408 +f 3475//2404 3490//2407 3491//2409 +f 3486//2414 3471//2396 3485//2410 +f 3481//2415 3466//2397 3480//2411 +f 3476//2406 3491//2409 3492//2412 +f 3487//2430 3472//2413 3486//2414 +f 3482//2418 3467//2400 3481//2415 +f 3477//2394 3492//2412 3493//2416 +f 3472//2413 3487//2430 3488//2417 +f 3483//2421 3468//2403 3482//2418 +f 3478//2398 3493//2416 3494//2419 +f 3473//2399 3488//2417 3489//2420 +f 3484//2408 3469//2405 3483//2421 +f 3509//2439 3494//2419 3508//2422 +f 3488//2417 3503//2434 3504//2423 +f 3483//2421 3498//2435 3499//2424 +f 3489//2420 3504//2423 3505//2425 +f 3484//2408 3499//2424 3500//2426 +f 3490//2407 3505//2425 3506//2427 +f 3485//2410 3500//2426 3501//2428 +f 3480//2411 3495//2446 3496//2429 +f 3507//2433 3492//2412 3506//2427 +f 3486//2414 3501//2428 3502//2431 +f 3481//2415 3496//2429 3497//2432 +f 3508//2422 3493//2416 3507//2433 +f 3487//2430 3502//2431 3503//2434 +f 3482//2418 3497//2432 3498//2435 +f 3523//2440 3508//2422 3522//2436 +f 3502//2431 3517//2449 3518//2437 +f 3497//2432 3512//2450 3513//2438 +f 3524//2458 3509//2439 3523//2440 +f 3519//2442 3504//2423 3518//2437 +f 3498//2435 3513//2438 3514//2441 +f 3520//2444 3505//2425 3519//2442 +f 3499//2424 3514//2441 3515//2443 +f 3521//2448 3506//2427 3520//2444 +f 3500//2426 3515//2443 3516//2445 +f 3495//2446 3510//2451 3511//2447 +f 3522//2436 3507//2433 3521//2448 +f 3501//2428 3516//2445 3517//2449 +f 3496//2429 3511//2447 3512//2450 +f 3510//2451 3525//2469 3526//2452 +f 3537//2456 3522//2436 3536//2453 +f 3516//2445 3531//2465 3532//2454 +f 3511//2447 3526//2452 3527//2455 +f 3538//2459 3523//2440 3537//2456 +f 3533//2460 3518//2437 3532//2454 +f 3512//2450 3527//2455 3528//2457 +f 3539//2476 3524//2458 3538//2459 +f 3534//2462 3519//2442 3533//2460 +f 3513//2438 3528//2457 3529//2461 +f 3535//2464 3520//2444 3534//2462 +f 3514//2441 3529//2461 3530//2463 +f 3536//2453 3521//2448 3535//2464 +f 3515//2443 3530//2463 3531//2465 +f 3529//2461 3544//2479 3545//2466 +f 3551//2471 3536//2453 3550//2467 +f 3530//2463 3545//2466 3546//2468 +f 3525//2469 3540//2487 3541//2470 +f 3552//2474 3537//2456 3551//2471 +f 3531//2465 3546//2468 3547//2472 +f 3526//2452 3541//2470 3542//2473 +f 3553//2477 3538//2459 3552//2474 +f 3548//2478 3533//2460 3547//2472 +f 3527//2455 3542//2473 3543//2475 +f 3554//2494 3539//2476 3553//2477 +f 3549//2480 3534//2462 3548//2478 +f 3528//2457 3543//2475 3544//2479 +f 3550//2467 3535//2464 3549//2480 +f 3564//2483 3549//2480 3563//2481 +f 3543//2475 3558//2493 3559//2482 +f 3565//2485 3550//2467 3564//2483 +f 3544//2479 3559//2482 3560//2484 +f 3566//2489 3551//2471 3565//2485 +f 3545//2466 3560//2484 3561//2486 +f 3540//2487 3555//2506 3556//2488 +f 3567//2492 3552//2474 3566//2489 +f 3546//2468 3561//2486 3562//2490 +f 3541//2470 3556//2488 3557//2491 +f 3568//2495 3553//2477 3567//2492 +f 3563//2481 3548//2478 3562//2490 +f 3542//2473 3557//2491 3558//2493 +f 3569//2499 3554//2494 3568//2495 +f 3583//2500 3568//2495 3582//2496 +f 3562//2490 3577//2509 3578//2497 +f 3557//2491 3572//2510 3573//2498 +f 3584//2519 3569//2499 3583//2500 +f 3579//2502 3564//2483 3578//2497 +f 3558//2493 3573//2498 3574//2501 +f 3580//2504 3565//2485 3579//2502 +f 3559//2482 3574//2501 3575//2503 +f 3581//2508 3566//2489 3580//2504 +f 3560//2484 3575//2503 3576//2505 +f 3555//2506 3570//2511 3571//2507 +f 3582//2496 3567//2492 3581//2508 +f 3561//2486 3576//2505 3577//2509 +f 3556//2488 3571//2507 3572//2510 +f 3570//2511 3585//2529 3586//2512 +f 3597//2516 3582//2496 3596//2513 +f 3576//2505 3591//2525 3592//2514 +f 3571//2507 3586//2512 3587//2515 +f 3598//2520 3583//2500 3597//2516 +f 3577//2509 3592//2514 3593//2517 +f 3572//2510 3587//2515 3588//2518 +f 3599//2537 3584//2519 3598//2520 +f 3594//2522 3579//2502 3593//2517 +f 3573//2498 3588//2518 3589//2521 +f 3595//2524 3580//2504 3594//2522 +f 3574//2501 3589//2521 3590//2523 +f 3596//2513 3581//2508 3595//2524 +f 3575//2503 3590//2523 3591//2525 +f 3589//2521 3604//2539 3605//2526 +f 3611//2531 3596//2513 3610//2527 +f 3590//2523 3605//2526 3606//2528 +f 3585//2529 3600//2547 3601//2530 +f 3612//2534 3597//2516 3611//2531 +f 3591//2525 3606//2528 3607//2532 +f 3586//2512 3601//2530 3602//2533 +f 3613//2538 3598//2520 3612//2534 +f 3592//2514 3607//2532 3608//2535 +f 3587//2515 3602//2533 3603//2536 +f 3614//2555 3599//2537 3613//2538 +f 3609//2540 3594//2522 3608//2535 +f 3588//2518 3603//2536 3604//2539 +f 3610//2527 3595//2524 3609//2540 +f 3608//2535 3623//2553 3624//2541 +f 3603//2536 3618//2554 3619//2542 +f 3609//2540 3624//2541 3625//2543 +f 3604//2539 3619//2542 3620//2544 +f 3610//2527 3625//2543 3626//2545 +f 3605//2526 3620//2544 3621//2546 +f 3616//2567 3601//2530 3615//2548 +f 3611//2531 3626//2545 3627//2549 +f 3606//2528 3621//2546 3622//2550 +f 3601//2530 3616//2567 3617//2551 +f 3612//2534 3627//2549 3628//2552 +f 3607//2532 3622//2550 3623//2553 +f 3602//2533 3617//2551 3618//2554 +f 3613//2538 3628//2552 3629//2556 +f 3627//2549 3642//2569 3643//2557 +f 3622//2550 3637//2570 3638//2558 +f 3633//2562 3618//2554 3632//2559 +f 3628//2552 3643//2557 3644//2560 +f 3623//2553 3638//2558 3639//2561 +f 3634//2564 3619//2542 3633//2562 +f 3624//2541 3639//2561 3640//2563 +f 3635//2566 3620//2544 3634//2564 +f 3625//2543 3640//2563 3641//2565 +f 3636//2573 3621//2546 3635//2566 +f 3631//2571 3616//2567 3630//2568 +f 3626//2545 3641//2565 3642//2569 +f 3621//2546 3636//2573 3637//2570 +f 3632//2559 3617//2551 3631//2571 +f 3641//2565 3656//2584 3657//2572 +f 3652//2591 3637//2570 3651//2574 +f 3647//2578 3632//2559 3646//2575 +f 3642//2569 3657//2572 3658//2576 +f 3637//2570 3652//2591 3653//2577 +f 3648//2581 3633//2562 3647//2578 +f 3643//2557 3658//2576 3659//2579 +f 3638//2558 3653//2577 3654//2580 +f 3649//2583 3634//2564 3648//2581 +f 3639//2561 3654//2580 3655//2582 +f 3650//2585 3635//2566 3649//2583 +f 3640//2563 3655//2582 3656//2584 +f 3651//2574 3636//2573 3650//2585 +f 3646//2575 3631//2571 3645//2586 +f 3655//2582 3670//2600 3671//2587 +f 3666//2592 3651//2574 3665//2588 +f 3661//2593 3646//2575 3660//2589 +f 3656//2584 3671//2587 3672//2590 +f 3667//2609 3652//2591 3666//2592 +f 3662//2596 3647//2578 3661//2593 +f 3657//2572 3672//2590 3673//2594 +f 3652//2591 3667//2609 3668//2595 +f 3663//2599 3648//2581 3662//2596 +f 3658//2576 3673//2594 3674//2597 +f 3653//2577 3668//2595 3669//2598 +f 3664//2601 3649//2583 3663//2599 +f 3654//2580 3669//2598 3670//2600 +f 3665//2588 3650//2585 3664//2601 +f 3679//2604 3664//2601 3678//2602 +f 3669//2598 3684//2616 3685//2603 +f 3680//2606 3665//2588 3679//2604 +f 3670//2600 3685//2603 3686//2605 +f 3681//2610 3666//2592 3680//2606 +f 3676//2611 3661//2593 3675//2607 +f 3671//2587 3686//2605 3687//2608 +f 3682//2617 3667//2609 3681//2610 +f 3677//2614 3662//2596 3676//2611 +f 3672//2590 3687//2608 3688//2612 +f 3667//2609 3682//2617 3683//2613 +f 3678//2602 3663//2599 3677//2614 +f 3673//2594 3688//2612 3689//2615 +f 3668//2595 3683//2613 3684//2616 +f 3682//2617 3697//2633 3698//2618 +f 3693//2622 3678//2602 3692//2619 +f 3688//2612 3703//2631 3704//2620 +f 3683//2613 3698//2618 3699//2621 +f 3694//2624 3679//2604 3693//2622 +f 3684//2616 3699//2621 3700//2623 +f 3695//2626 3680//2606 3694//2624 +f 3685//2603 3700//2623 3701//2625 +f 3696//2629 3681//2610 3695//2626 +f 3691//2630 3676//2611 3690//2627 +f 3686//2605 3701//2625 3702//2628 +f 3697//2633 3682//2617 3696//2629 +f 3692//2619 3677//2614 3691//2630 +f 3687//2608 3702//2628 3703//2631 +f 3701//2625 3717//2644 3718//2632 +f 3713//2651 3697//2633 3712//2634 +f 3708//2638 3692//2619 3707//2635 +f 3702//2628 3718//2632 3719//2636 +f 3697//2633 3713//2651 3714//2637 +f 3709//2641 3693//2622 3708//2638 +f 3703//2631 3719//2636 3720//2639 +f 3698//2618 3714//2637 3715//2640 +f 3710//2643 3694//2624 3709//2641 +f 3699//2621 3715//2640 3716//2642 +f 3711//2645 3695//2626 3710//2643 +f 3700//2623 3716//2642 3717//2644 +f 3712//2634 3696//2629 3711//2645 +f 3707//2635 3691//2630 3706//2646 +f 3716//2642 3731//2660 3732//2647 +f 3727//2652 3712//2634 3726//2648 +f 3722//2653 3707//2635 3721//2649 +f 3717//2644 3732//2647 3733//2650 +f 3728//2669 3713//2651 3727//2652 +f 3723//2656 3708//2638 3722//2653 +f 3718//2632 3733//2650 3734//2654 +f 3713//2651 3728//2669 3729//2655 +f 3724//2659 3709//2641 3723//2656 +f 3719//2636 3734//2654 3735//2657 +f 3714//2637 3729//2655 3730//2658 +f 3725//2661 3710//2643 3724//2659 +f 3715//2640 3730//2658 3731//2660 +f 3726//2648 3711//2645 3725//2661 +f 3740//2664 3725//2661 3739//2662 +f 3746//2665 3731//2660 3745//2663 +f 3741//2666 3726//2648 3740//2664 +f 3747//2668 3732//2647 3746//2665 +f 3742//2670 3727//2652 3741//2666 +f 3721//2649 3736//2686 3737//2667 +f 3748//2672 3733//2650 3747//2668 +f 3743//2673 3728//2669 3742//2670 +f 3722//2653 3737//2667 3738//2671 +f 3749//2674 3734//2654 3748//2672 +f 3744//2675 3729//2655 3743//2673 +f 3723//2656 3738//2671 3739//2662 +f 3750//2678 3735//2657 3749//2674 +f 3745//2663 3730//2658 3744//2675 +f 3759//2680 3744//2675 3758//2676 +f 3738//2671 3753//2689 3754//2677 +f 3765//2696 3750//2678 3764//2679 +f 3760//2682 3745//2663 3759//2680 +f 3739//2662 3754//2677 3755//2681 +f 3761//2684 3746//2665 3760//2682 +f 3740//2664 3755//2681 3756//2683 +f 3762//2688 3747//2668 3761//2684 +f 3741//2666 3756//2683 3757//2685 +f 3736//2686 3751//2704 3752//2687 +f 3763//2690 3748//2672 3762//2688 +f 3758//2676 3743//2673 3757//2685 +f 3737//2667 3752//2687 3753//2689 +f 3764//2679 3749//2674 3763//2690 +f 3778//2694 3763//2690 3777//2691 +f 3757//2685 3772//2703 3773//2692 +f 3752//2687 3767//2705 3768//2693 +f 3779//2697 3764//2679 3778//2694 +f 3774//2698 3759//2680 3773//2692 +f 3753//2689 3768//2693 3769//2695 +f 3780//2715 3765//2696 3779//2697 +f 3775//2700 3760//2682 3774//2698 +f 3754//2677 3769//2695 3770//2699 +f 3776//2702 3761//2684 3775//2700 +f 3755//2681 3770//2699 3771//2701 +f 3777//2691 3762//2688 3776//2702 +f 3756//2683 3771//2701 3772//2703 +f 3751//2704 3766//2708 3767//2705 +f 3792//2710 3777//2691 3791//2706 +f 3771//2701 3786//2720 3787//2707 +f 3766//2708 3781//2725 3782//2709 +f 3793//2713 3778//2694 3792//2710 +f 3772//2703 3787//2707 3788//2711 +f 3767//2705 3782//2709 3783//2712 +f 3794//2716 3779//2697 3793//2713 +f 3789//2717 3774//2698 3788//2711 +f 3768//2693 3783//2712 3784//2714 +f 3795//2732 3780//2715 3794//2716 +f 3790//2719 3775//2700 3789//2717 +f 3769//2695 3784//2714 3785//2718 +f 3791//2706 3776//2702 3790//2719 +f 3770//2699 3785//2718 3786//2720 +f 3806//2723 3791//2706 3805//2721 +f 3785//2718 3800//2735 3801//2722 +f 3807//2727 3792//2710 3806//2723 +f 3786//2720 3801//2722 3802//2724 +f 3781//2725 3796//2745 3797//2726 +f 3808//2730 3793//2713 3807//2727 +f 3787//2707 3802//2724 3803//2728 +f 3782//2709 3797//2726 3798//2729 +f 3809//2733 3794//2716 3808//2730 +f 3804//2734 3789//2717 3803//2728 +f 3783//2712 3798//2729 3799//2731 +f 3810//2737 3795//2732 3809//2733 +f 3805//2721 3790//2719 3804//2734 +f 3784//2714 3799//2731 3800//2735 +f 3798//2729 3813//2748 3814//2736 +f 3825//2756 3810//2737 3824//2738 +f 3820//2741 3805//2721 3819//2739 +f 3799//2731 3814//2736 3815//2740 +f 3821//2743 3806//2723 3820//2741 +f 3800//2735 3815//2740 3816//2742 +f 3822//2747 3807//2727 3821//2743 +f 3801//2722 3816//2742 3817//2744 +f 3796//2745 3811//2763 3812//2746 +f 3823//2749 3808//2730 3822//2747 +f 3818//2750 3803//2728 3817//2744 +f 3797//2726 3812//2746 3813//2748 +f 3824//2738 3809//2733 3823//2749 +f 3819//2739 3804//2734 3818//2750 +f 3834//2754 3818//2750 3833//2751 +f 3812//2746 3828//2764 3829//2752 +f 3840//2757 3824//2738 3839//2753 +f 3835//2758 3819//2739 3834//2754 +f 3813//2748 3829//2752 3830//2755 +f 3841//2775 3825//2756 3840//2757 +f 3836//2760 3820//2741 3835//2758 +f 3814//2736 3830//2755 3831//2759 +f 3837//2762 3821//2743 3836//2760 +f 3815//2740 3831//2759 3832//2761 +f 3838//2765 3822//2747 3837//2762 +f 3816//2742 3832//2761 3833//2751 +f 3811//2763 3827//2768 3828//2764 +f 3839//2753 3823//2749 3838//2765 +f 3853//2770 3838//2765 3852//2766 +f 3832//2761 3847//2780 3848//2767 +f 3827//2768 3842//2784 3843//2769 +f 3854//2772 3839//2753 3853//2770 +f 3849//2773 3834//2754 3848//2767 +f 3828//2764 3843//2769 3844//2771 +f 3855//2776 3840//2757 3854//2772 +f 3850//2777 3835//2758 3849//2773 +f 3829//2752 3844//2771 3845//2774 +f 3856//2783 3841//2775 3855//2776 +f 3851//2779 3836//2760 3850//2777 +f 3830//2755 3845//2774 3846//2778 +f 3852//2766 3837//2762 3851//2779 +f 3831//2759 3846//2778 3847//2780 +f 3385//2328 3852//2766 3384//2324 +f 3380//2304 3847//2780 3379//2326 +f 3386//2310 3853//2770 3385//2328 +f 3381//2303 3848//2767 3380//2304 +f 3376//2306 3843//2769 3375//2307 +f 3387//2309 3854//2772 3386//2310 +f 3382//2312 3849//2773 3381//2303 +f 3377//2314 3844//2771 3376//2306 +f 3388//2316 3855//2776 3387//2309 +f 3383//2318 3850//2777 3382//2312 +f 3378//2320 3845//2774 3377//2314 +f 3855//2776 3388//2316 3389//2322 +f 3384//2324 3851//2779 3383//2318 +f 3379//2326 3846//2778 3378//2320 +f 3878//2788 3863//2303 3877//2305 +f 3873//2315 3858//2306 3872//2308 +f 3868//2310 3883//2331 3884//2787 +f 3879//2319 3864//2312 3878//2788 +f 3874//2321 3859//2314 3873//2315 +f 3869//2309 3884//2787 3885//2790 +f 3880//2338 3865//2318 3879//2319 +f 3875//2793 3860//2320 3874//2321 +f 3870//2789 3885//2790 3886//2792 +f 3865//2318 3880//2338 3881//2325 +f 3876//2330 3861//2326 3875//2793 +f 3866//2324 3881//2325 3882//2794 +f 3877//2305 3862//2785 3876//2330 +f 3867//2328 3882//2794 3883//2331 +f 3893//2335 3878//2788 3892//2332 +f 3888//2336 3873//2315 3887//2795 +f 3883//2331 3898//2346 3899//2334 +f 3894//2799 3879//2319 3893//2335 +f 3889//2340 3874//2321 3888//2336 +f 3884//2787 3899//2334 3900//2337 +f 3879//2319 3894//2799 3895//2339 +f 3890//2797 3875//2793 3889//2340 +f 3885//2790 3900//2337 3901//2796 +f 3880//2338 3895//2339 3896//2342 +f 3891//2345 3876//2330 3890//2797 +f 3881//2325 3896//2342 3897//2344 +f 3892//2332 3877//2305 3891//2345 +f 3882//2794 3897//2344 3898//2346 +f 3896//2342 3911//2360 3912//2798 +f 3907//2350 3892//2332 3906//2348 +f 3897//2344 3912//2798 3913//2349 +f 3908//2354 3893//2335 3907//2350 +f 3903//2800 3888//2336 3902//2351 +f 3898//2346 3913//2349 3914//2352 +f 3909//2371 3894//2799 3908//2354 +f 3904//2802 3889//2340 3903//2800 +f 3899//2334 3914//2352 3915//2801 +f 3894//2799 3909//2371 3910//2357 +f 3905//2361 3890//2797 3904//2802 +f 3900//2337 3915//2801 3916//2359 +f 3895//2339 3910//2357 3911//2360 +f 3906//2348 3891//2345 3905//2361 +f 3915//2801 3930//2806 3931//2803 +f 3910//2357 3925//2375 3926//2363 +f 3921//2366 3906//2348 3920//2364 +f 3911//2360 3926//2363 3927//2365 +f 3922//2368 3907//2350 3921//2366 +f 3912//2798 3927//2365 3928//2367 +f 3923//2372 3908//2354 3922//2368 +f 3918//2805 3903//2800 3917//2804 +f 3913//2349 3928//2367 3929//2370 +f 3924//2379 3909//2371 3923//2372 +f 3919//2376 3904//2802 3918//2805 +f 3914//2352 3929//2370 3930//2806 +f 3909//2371 3924//2379 3925//2375 +f 3920//2364 3905//2361 3919//2376 +f 3934//2810 3919//2376 3933//2807 +f 3929//2370 3944//2390 3945//2808 +f 3924//2379 3939//2395 3940//2809 +f 3935//2384 3920//2364 3934//2810 +f 3930//2806 3945//2808 3946//2811 +f 3925//2375 3940//2809 3941//2383 +f 3936//2386 3921//2366 3935//2384 +f 3926//2363 3941//2383 3942//2812 +f 3937//2388 3922//2368 3936//2386 +f 3927//2365 3942//2812 3943//2387 +f 3938//2814 3923//2372 3937//2388 +f 3933//2807 3918//2805 3932//2813 +f 3928//2367 3943//2387 3944//2390 +f 3939//2395 3924//2379 3938//2814 +f 3953//2396 3938//2814 3952//2392 +f 3948//2397 3933//2807 3947//2815 +f 3943//2387 3958//2819 3959//2394 +f 3954//2413 3939//2395 3953//2396 +f 3949//2400 3934//2810 3948//2397 +f 3944//2390 3959//2394 3960//2398 +f 3939//2395 3954//2413 3955//2816 +f 3950//2403 3935//2384 3949//2400 +f 3945//2808 3960//2398 3961//2817 +f 3940//2809 3955//2816 3956//2818 +f 3951//2405 3936//2386 3950//2403 +f 3941//2383 3956//2818 3957//2404 +f 3952//2392 3937//2388 3951//2405 +f 3942//2812 3957//2404 3958//2819 +f 3956//2818 3971//2420 3972//2407 +f 3967//2410 3952//2392 3966//2820 +f 3957//2404 3972//2407 3973//2409 +f 3968//2414 3953//2396 3967//2410 +f 3963//2822 3948//2397 3962//2411 +f 3958//2819 3973//2409 3974//2821 +f 3969//2430 3954//2413 3968//2414 +f 3964//2418 3949//2400 3963//2822 +f 3959//2394 3974//2821 3975//2416 +f 3954//2413 3969//2430 3970//2417 +f 3965//2421 3950//2403 3964//2418 +f 3960//2398 3975//2416 3976//2419 +f 3955//2816 3970//2417 3971//2420 +f 3966//2820 3951//2405 3965//2421 +f 3991//2439 3976//2419 3990//2422 +f 3970//2417 3985//2823 3986//2423 +f 3965//2421 3980//2435 3981//2424 +f 3971//2420 3986//2423 3987//2425 +f 3966//2820 3981//2424 3982//2426 +f 3972//2407 3987//2425 3988//2427 +f 3967//2410 3982//2426 3983//2428 +f 3962//2411 3977//2446 3978//2429 +f 3989//2433 3974//2821 3988//2427 +f 3968//2414 3983//2428 3984//2431 +f 3963//2822 3978//2429 3979//2432 +f 3990//2422 3975//2416 3989//2433 +f 3969//2430 3984//2431 3985//2823 +f 3964//2418 3979//2432 3980//2435 +f 4005//2440 3990//2422 4004//2436 +f 3984//2431 3999//2449 4000//2437 +f 3979//2432 3994//2450 3995//2438 +f 4006//2831 3991//2439 4005//2440 +f 4001//2825 3986//2423 4000//2437 +f 3980//2435 3995//2438 3996//2824 +f 4002//2444 3987//2425 4001//2825 +f 3981//2424 3996//2824 3997//2826 +f 4003//2827 3988//2427 4002//2444 +f 3982//2426 3997//2826 3998//2445 +f 3977//2446 3992//2828 3993//2447 +f 4004//2436 3989//2433 4003//2827 +f 3983//2428 3998//2445 3999//2449 +f 3978//2429 3993//2447 3994//2450 +f 3992//2828 4007//2469 4008//2452 +f 4019//2830 4004//2436 4018//2453 +f 3998//2445 4013//2465 4014//2454 +f 3993//2447 4008//2452 4009//2829 +f 4020//2459 4005//2440 4019//2830 +f 4015//2460 4000//2437 4014//2454 +f 3994//2450 4009//2829 4010//2457 +f 4021//2476 4006//2831 4020//2459 +f 4016//2462 4001//2825 4015//2460 +f 3995//2438 4010//2457 4011//2461 +f 4017//2464 4002//2444 4016//2462 +f 3996//2824 4011//2461 4012//2463 +f 4018//2453 4003//2827 4017//2464 +f 3997//2826 4012//2463 4013//2465 +f 4011//2461 4026//2836 4027//2832 +f 4033//2471 4018//2453 4032//2467 +f 4012//2463 4027//2832 4028//2468 +f 4007//2469 4022//2839 4023//2833 +f 4034//2834 4019//2830 4033//2471 +f 4013//2465 4028//2468 4029//2472 +f 4008//2452 4023//2833 4024//2473 +f 4035//2477 4020//2459 4034//2834 +f 4030//2478 4015//2460 4029//2472 +f 4009//2829 4024//2473 4025//2835 +f 4036//2494 4021//2476 4035//2477 +f 4031//2480 4016//2462 4030//2478 +f 4010//2457 4025//2835 4026//2836 +f 4032//2467 4017//2464 4031//2480 +f 4046//2483 4031//2480 4045//2481 +f 4025//2835 4040//2493 4041//2482 +f 4047//2837 4032//2467 4046//2483 +f 4026//2836 4041//2482 4042//2484 +f 4048//2489 4033//2471 4047//2837 +f 4027//2832 4042//2484 4043//2838 +f 4022//2839 4037//2506 4038//2488 +f 4049//2492 4034//2834 4048//2489 +f 4028//2468 4043//2838 4044//2490 +f 4023//2833 4038//2488 4039//2840 +f 4050//2495 4035//2477 4049//2492 +f 4045//2481 4030//2478 4044//2490 +f 4024//2473 4039//2840 4040//2493 +f 4051//2843 4036//2494 4050//2495 +f 4065//2500 4050//2495 4064//2496 +f 4044//2490 4059//2844 4060//2841 +f 4039//2840 4054//2845 4055//2842 +f 4066//2848 4051//2843 4065//2500 +f 4061//2502 4046//2483 4060//2841 +f 4040//2493 4055//2842 4056//2501 +f 4062//2504 4047//2837 4061//2502 +f 4041//2482 4056//2501 4057//2503 +f 4063//2508 4048//2489 4062//2504 +f 4042//2484 4057//2503 4058//2505 +f 4037//2506 4052//2511 4053//2507 +f 4064//2496 4049//2492 4063//2508 +f 4043//2838 4058//2505 4059//2844 +f 4038//2488 4053//2507 4054//2845 +f 4052//2511 4067//2529 4068//2512 +f 4079//2847 4064//2496 4078//2513 +f 4058//2505 4073//2525 4074//2846 +f 4053//2507 4068//2512 4069//2515 +f 4080//2849 4065//2500 4079//2847 +f 4059//2844 4074//2846 4075//2517 +f 4054//2845 4069//2515 4070//2518 +f 4081//2537 4066//2848 4080//2849 +f 4076//2522 4061//2502 4075//2517 +f 4055//2842 4070//2518 4071//2850 +f 4077//2524 4062//2504 4076//2522 +f 4056//2501 4071//2850 4072//2851 +f 4078//2513 4063//2508 4077//2524 +f 4057//2503 4072//2851 4073//2525 +f 4071//2850 4086//2856 4087//2526 +f 4093//2531 4078//2513 4092//2852 +f 4072//2851 4087//2526 4088//2528 +f 4067//2529 4082//2858 4083//2853 +f 4094//2534 4079//2847 4093//2531 +f 4073//2525 4088//2528 4089//2854 +f 4068//2512 4083//2853 4084//2855 +f 4095//2538 4080//2849 4094//2534 +f 4074//2846 4089//2854 4090//2535 +f 4069//2515 4084//2855 4085//2536 +f 4096//2555 4081//2537 4095//2538 +f 4091//2540 4076//2522 4090//2535 +f 4070//2518 4085//2536 4086//2856 +f 4092//2852 4077//2524 4091//2540 +f 4090//2535 4105//2553 4106//2541 +f 4085//2536 4100//2554 4101//2542 +f 4091//2540 4106//2541 4107//2543 +f 4086//2856 4101//2542 4102//2544 +f 4092//2852 4107//2543 4108//2545 +f 4087//2526 4102//2544 4103//2857 +f 4098//2567 4083//2853 4097//2548 +f 4093//2531 4108//2545 4109//2549 +f 4088//2528 4103//2857 4104//2859 +f 4083//2853 4098//2567 4099//2551 +f 4094//2534 4109//2549 4110//2860 +f 4089//2854 4104//2859 4105//2553 +f 4084//2855 4099//2551 4100//2554 +f 4095//2538 4110//2860 4111//2556 +f 4109//2549 4124//2569 4125//2557 +f 4104//2859 4119//2570 4120//2558 +f 4115//2562 4100//2554 4114//2559 +f 4110//2860 4125//2557 4126//2861 +f 4105//2553 4120//2558 4121//2561 +f 4116//2564 4101//2542 4115//2562 +f 4106//2541 4121//2561 4122//2563 +f 4117//2566 4102//2544 4116//2564 +f 4107//2543 4122//2563 4123//2862 +f 4118//2863 4103//2857 4117//2566 +f 4113//2571 4098//2567 4112//2568 +f 4108//2545 4123//2862 4124//2569 +f 4103//2857 4118//2863 4119//2570 +f 4114//2559 4099//2551 4113//2571 +f 4123//2862 4138//2866 4139//2572 +f 4134//2591 4119//2570 4133//2574 +f 4129//2578 4114//2559 4128//2864 +f 4124//2569 4139//2572 4140//2576 +f 4119//2570 4134//2591 4135//2577 +f 4130//2865 4115//2562 4129//2578 +f 4125//2557 4140//2576 4141//2579 +f 4120//2558 4135//2577 4136//2580 +f 4131//2583 4116//2564 4130//2865 +f 4121//2561 4136//2580 4137//2582 +f 4132//2867 4117//2566 4131//2583 +f 4122//2563 4137//2582 4138//2866 +f 4133//2574 4118//2863 4132//2867 +f 4128//2864 4113//2571 4127//2586 +f 4137//2582 4152//2600 4153//2587 +f 4148//2869 4133//2574 4147//2588 +f 4143//2593 4128//2864 4142//2589 +f 4138//2866 4153//2587 4154//2868 +f 4149//2609 4134//2591 4148//2869 +f 4144//2596 4129//2578 4143//2593 +f 4139//2572 4154//2868 4155//2870 +f 4134//2591 4149//2609 4150//2595 +f 4145//2599 4130//2865 4144//2596 +f 4140//2576 4155//2870 4156//2597 +f 4135//2577 4150//2595 4151//2598 +f 4146//2601 4131//2583 4145//2599 +f 4136//2580 4151//2598 4152//2600 +f 4147//2588 4132//2867 4146//2601 +f 4161//2604 4146//2601 4160//2602 +f 4151//2598 4166//2616 4167//2871 +f 4162//2606 4147//2588 4161//2604 +f 4152//2600 4167//2871 4168//2605 +f 4163//2610 4148//2869 4162//2606 +f 4158//2611 4143//2593 4157//2872 +f 4153//2587 4168//2605 4169//2608 +f 4164//2875 4149//2609 4163//2610 +f 4159//2874 4144//2596 4158//2611 +f 4154//2868 4169//2608 4170//2873 +f 4149//2609 4164//2875 4165//2613 +f 4160//2602 4145//2599 4159//2874 +f 4155//2870 4170//2873 4171//2615 +f 4150//2595 4165//2613 4166//2616 +f 4164//2875 4179//2633 4180//2618 +f 4175//2622 4160//2602 4174//2619 +f 4170//2873 4185//2631 4186//2620 +f 4165//2613 4180//2618 4181//2621 +f 4176//2876 4161//2604 4175//2622 +f 4166//2616 4181//2621 4182//2623 +f 4177//2626 4162//2606 4176//2876 +f 4167//2871 4182//2623 4183//2625 +f 4178//2629 4163//2610 4177//2626 +f 4173//2878 4158//2611 4172//2877 +f 4168//2605 4183//2625 4184//2628 +f 4179//2633 4164//2875 4178//2629 +f 4174//2619 4159//2874 4173//2878 +f 4169//2608 4184//2628 4185//2631 +f 4183//2625 4199//2644 4200//2632 +f 4195//2883 4179//2633 4194//2634 +f 4190//2638 4174//2619 4189//2635 +f 4184//2628 4200//2632 4201//2636 +f 4179//2633 4195//2883 4196//2637 +f 4191//2880 4175//2622 4190//2638 +f 4185//2631 4201//2636 4202//2879 +f 4180//2618 4196//2637 4197//2640 +f 4192//2643 4176//2876 4191//2880 +f 4181//2621 4197//2640 4198//2642 +f 4193//2881 4177//2626 4192//2643 +f 4182//2623 4198//2642 4199//2644 +f 4194//2634 4178//2629 4193//2881 +f 4189//2635 4173//2878 4188//2882 +f 4198//2642 4213//2886 4214//2647 +f 4209//2884 4194//2634 4208//2648 +f 4204//2653 4189//2635 4203//2649 +f 4199//2644 4214//2647 4215//2650 +f 4210//2669 4195//2883 4209//2884 +f 4205//2656 4190//2638 4204//2653 +f 4200//2632 4215//2650 4216//2654 +f 4195//2883 4210//2669 4211//2655 +f 4206//2659 4191//2880 4205//2656 +f 4201//2636 4216//2654 4217//2657 +f 4196//2637 4211//2655 4212//2885 +f 4207//2661 4192//2643 4206//2659 +f 4197//2640 4212//2885 4213//2886 +f 4208//2648 4193//2881 4207//2661 +f 4222//2664 4207//2661 4221//2662 +f 4228//2665 4213//2886 4227//2663 +f 4223//2666 4208//2648 4222//2664 +f 4229//2668 4214//2647 4228//2665 +f 4224//2887 4209//2884 4223//2666 +f 4203//2649 4218//2686 4219//2667 +f 4230//2672 4215//2650 4229//2668 +f 4225//2673 4210//2669 4224//2887 +f 4204//2653 4219//2667 4220//2671 +f 4231//2674 4216//2654 4230//2672 +f 4226//2675 4211//2655 4225//2673 +f 4205//2656 4220//2671 4221//2662 +f 4232//2678 4217//2657 4231//2674 +f 4227//2663 4212//2885 4226//2675 +f 4241//2680 4226//2675 4240//2676 +f 4220//2671 4235//2689 4236//2677 +f 4247//2891 4232//2678 4246//2679 +f 4242//2888 4227//2663 4241//2680 +f 4221//2662 4236//2677 4237//2681 +f 4243//2684 4228//2665 4242//2888 +f 4222//2664 4237//2681 4238//2683 +f 4244//2688 4229//2668 4243//2684 +f 4223//2666 4238//2683 4239//2685 +f 4218//2686 4233//2892 4234//2687 +f 4245//2690 4230//2672 4244//2688 +f 4240//2676 4225//2673 4239//2685 +f 4219//2667 4234//2687 4235//2689 +f 4246//2679 4231//2674 4245//2690 +f 4260//2890 4245//2690 4259//2691 +f 4239//2685 4254//2703 4255//2692 +f 4234//2687 4249//2893 4250//2889 +f 4261//2697 4246//2679 4260//2890 +f 4256//2698 4241//2680 4255//2692 +f 4235//2689 4250//2889 4251//2695 +f 4262//2715 4247//2891 4261//2697 +f 4257//2700 4242//2888 4256//2698 +f 4236//2677 4251//2695 4252//2699 +f 4258//2702 4243//2684 4257//2700 +f 4237//2681 4252//2699 4253//2701 +f 4259//2691 4244//2688 4258//2702 +f 4238//2683 4253//2701 4254//2703 +f 4233//2892 4248//2708 4249//2893 +f 4274//2895 4259//2691 4273//2894 +f 4253//2701 4268//2720 4269//2707 +f 4248//2708 4263//2725 4264//2709 +f 4275//2713 4260//2890 4274//2895 +f 4254//2703 4269//2707 4270//2711 +f 4249//2893 4264//2709 4265//2896 +f 4276//2716 4261//2697 4275//2713 +f 4271//2717 4256//2698 4270//2711 +f 4250//2889 4265//2896 4266//2714 +f 4277//2732 4262//2715 4276//2716 +f 4272//2719 4257//2700 4271//2717 +f 4251//2695 4266//2714 4267//2718 +f 4273//2894 4258//2702 4272//2719 +f 4252//2699 4267//2718 4268//2720 +f 4288//2723 4273//2894 4287//2897 +f 4267//2718 4282//2735 4283//2722 +f 4289//2727 4274//2895 4288//2723 +f 4268//2720 4283//2722 4284//2724 +f 4263//2725 4278//2745 4279//2726 +f 4290//2730 4275//2713 4289//2727 +f 4269//2707 4284//2724 4285//2728 +f 4264//2709 4279//2726 4280//2729 +f 4291//2733 4276//2716 4290//2730 +f 4286//2734 4271//2717 4285//2728 +f 4265//2896 4280//2729 4281//2731 +f 4292//2898 4277//2732 4291//2733 +f 4287//2897 4272//2719 4286//2734 +f 4266//2714 4281//2731 4282//2735 +f 4280//2729 4295//2748 4296//2736 +f 4307//2756 4292//2898 4306//2899 +f 4302//2741 4287//2897 4301//2739 +f 4281//2731 4296//2736 4297//2740 +f 4303//2743 4288//2723 4302//2741 +f 4282//2735 4297//2740 4298//2742 +f 4304//2747 4289//2727 4303//2743 +f 4283//2722 4298//2742 4299//2900 +f 4278//2745 4293//2902 4294//2746 +f 4305//2901 4290//2730 4304//2747 +f 4300//2750 4285//2728 4299//2900 +f 4279//2726 4294//2746 4295//2748 +f 4306//2899 4291//2733 4305//2901 +f 4301//2739 4286//2734 4300//2750 +f 4316//2754 4300//2750 4315//2751 +f 4294//2746 4310//2764 4311//2752 +f 4322//2757 4306//2899 4321//2753 +f 4317//2758 4301//2739 4316//2754 +f 4295//2748 4311//2752 4312//2755 +f 4323//2905 4307//2756 4322//2757 +f 4318//2760 4302//2741 4317//2758 +f 4296//2736 4312//2755 4313//2759 +f 4319//2762 4303//2743 4318//2760 +f 4297//2740 4313//2759 4314//2761 +f 4320//2765 4304//2747 4319//2762 +f 4298//2742 4314//2761 4315//2751 +f 4293//2902 4309//2904 4310//2764 +f 4321//2753 4305//2901 4320//2765 +f 4335//2770 4320//2765 4334//2766 +f 4314//2761 4329//2780 4330//2903 +f 4309//2904 4324//2908 4325//2769 +f 4336//2772 4321//2753 4335//2770 +f 4331//2773 4316//2754 4330//2903 +f 4310//2764 4325//2769 4326//2771 +f 4337//2906 4322//2757 4336//2772 +f 4332//2777 4317//2758 4331//2773 +f 4311//2752 4326//2771 4327//2774 +f 4338//2907 4323//2905 4337//2906 +f 4333//2779 4318//2760 4332//2777 +f 4312//2755 4327//2774 4328//2778 +f 4334//2766 4319//2762 4333//2779 +f 4313//2759 4328//2778 4329//2780 +f 3867//2328 4334//2766 3866//2324 +f 3862//2785 4329//2780 3861//2326 +f 3868//2310 4335//2770 3867//2328 +f 3863//2303 4330//2903 3862//2785 +f 3858//2306 4325//2769 3857//2786 +f 3869//2309 4336//2772 3868//2310 +f 3864//2312 4331//2773 3863//2303 +f 3859//2314 4326//2771 3858//2306 +f 3870//2789 4337//2906 3869//2309 +f 3865//2318 4332//2777 3864//2312 +f 3860//2320 4327//2774 3859//2314 +f 4337//2906 3870//2789 3871//2791 +f 3866//2324 4333//2779 3865//2318 +f 3861//2326 4328//2778 3860//2320 +o Tooth_Sphere.009 +v -0.011752 1.034128 -0.041332 +v -0.030343 1.032763 -0.041332 +v -0.047476 1.030545 -0.041332 +v -0.062494 1.027561 -0.041332 +v -0.074818 1.023925 -0.041332 +v -0.083976 1.019777 -0.041332 +v -0.089616 1.015275 -0.041332 +v -0.091520 1.010594 -0.041332 +v -0.089616 1.005913 -0.041332 +v -0.083976 1.001411 -0.041332 +v -0.074818 0.997263 -0.041332 +v -0.062494 0.993627 -0.041332 +v -0.047476 0.990643 -0.041332 +v -0.030343 0.988425 -0.041332 +v -0.011752 0.987060 -0.041332 +v -0.011380 1.034128 -0.043251 +v -0.029614 1.032763 -0.045097 +v -0.046418 1.030545 -0.046797 +v -0.061147 1.027561 -0.048288 +v -0.073235 1.023925 -0.049511 +v -0.082217 1.019777 -0.050420 +v -0.087748 1.015275 -0.050980 +v -0.089616 1.010594 -0.051169 +v -0.087748 1.005913 -0.050980 +v -0.082217 1.001411 -0.050420 +v -0.073235 0.997263 -0.049511 +v -0.061147 0.993627 -0.048288 +v -0.046418 0.990643 -0.046797 +v -0.029614 0.988425 -0.045097 +v -0.011380 0.987060 -0.043251 +v -0.010280 1.034128 -0.045097 +v -0.027456 1.032763 -0.048716 +v -0.043285 1.030545 -0.052052 +v -0.057159 1.027561 -0.054976 +v -0.068546 1.023925 -0.057376 +v -0.077007 1.019777 -0.059159 +v -0.082217 1.015275 -0.060257 +v -0.083976 1.010594 -0.060628 +v -0.082217 1.005913 -0.060257 +v -0.077007 1.001411 -0.059159 +v -0.068546 0.997263 -0.057376 +v -0.057159 0.993627 -0.054976 +v -0.043285 0.990643 -0.052052 +v -0.027456 0.988425 -0.048716 +v -0.010280 0.987060 -0.045097 +v -0.008494 1.034128 -0.046797 +v -0.023951 1.032763 -0.052052 +v -0.038197 1.030545 -0.056895 +v -0.050684 1.027561 -0.061140 +v -0.060931 1.023925 -0.064624 +v -0.068546 1.019777 -0.067213 +v -0.073235 1.015275 -0.068807 +v -0.074818 1.010594 -0.069345 +v -0.073235 1.005913 -0.068807 +v -0.068546 1.001411 -0.067213 +v -0.060931 0.997263 -0.064624 +v -0.050684 0.993627 -0.061140 +v -0.038197 0.990643 -0.056895 +v -0.023951 0.988425 -0.052052 +v -0.008494 0.987060 -0.046797 +v -0.006089 1.034128 -0.048288 +v -0.019235 1.032763 -0.054976 +v -0.031350 1.030545 -0.061140 +v -0.041969 1.027561 -0.066543 +v -0.050684 1.023925 -0.070977 +v -0.057159 1.019777 -0.074272 +v -0.061147 1.015275 -0.076301 +v -0.062494 1.010594 -0.076986 +v -0.061147 1.005913 -0.076301 +v -0.057159 1.001411 -0.074272 +v -0.050684 0.997263 -0.070977 +v -0.041969 0.993627 -0.066543 +v -0.031350 0.990643 -0.061140 +v -0.019235 0.988425 -0.054976 +v -0.006089 0.987060 -0.048288 +v -0.003159 1.034128 -0.049511 +v -0.013488 1.032763 -0.057376 +v -0.023007 1.030545 -0.064624 +v -0.031350 1.027561 -0.070977 +v -0.038197 1.023925 -0.076191 +v -0.043285 1.019777 -0.080065 +v -0.046418 1.015275 -0.082451 +v -0.047476 1.010594 -0.083256 +v -0.046418 1.005913 -0.082451 +v -0.043285 1.001411 -0.080065 +v -0.038197 0.997263 -0.076191 +v -0.031350 0.993627 -0.070977 +v -0.023007 0.990643 -0.064624 +v -0.013488 0.988425 -0.057376 +v -0.003159 0.987060 -0.049511 +v 0.000183 1.034128 -0.050420 +v -0.006931 1.032763 -0.059159 +v -0.013488 1.030545 -0.067213 +v -0.019235 1.027561 -0.074272 +v -0.023951 1.023925 -0.080065 +v -0.027456 1.019777 -0.084370 +v -0.029614 1.015275 -0.087020 +v -0.030343 1.010594 -0.087916 +v -0.029614 1.005913 -0.087020 +v -0.027456 1.001411 -0.084370 +v -0.023951 0.997263 -0.080065 +v -0.019235 0.993627 -0.074272 +v -0.013488 0.990643 -0.067213 +v -0.006931 0.988425 -0.059159 +v 0.000183 0.987060 -0.050420 +v 0.003810 1.034128 -0.050980 +v 0.000183 1.032763 -0.060257 +v -0.003159 1.030545 -0.068807 +v -0.006089 1.027561 -0.076301 +v -0.008494 1.023925 -0.082451 +v -0.010280 1.019777 -0.087020 +v -0.011380 1.015275 -0.089835 +v -0.011752 1.010594 -0.090785 +v -0.011380 1.005913 -0.089835 +v -0.010280 1.001411 -0.087020 +v -0.008494 0.997263 -0.082451 +v -0.006089 0.993627 -0.076301 +v -0.003159 0.990643 -0.068807 +v 0.000183 0.988425 -0.060257 +v 0.003810 0.987060 -0.050980 +v 0.007582 1.034128 -0.051169 +v 0.007582 1.032763 -0.060628 +v 0.007582 1.030545 -0.069345 +v 0.007582 1.027561 -0.076986 +v 0.007582 1.023925 -0.083256 +v 0.007582 1.019777 -0.087916 +v 0.007582 1.015275 -0.090785 +v 0.007582 1.010594 -0.091754 +v 0.007582 1.005913 -0.090785 +v 0.007582 1.001411 -0.087916 +v 0.007582 0.997263 -0.083256 +v 0.007582 0.993627 -0.076986 +v 0.007582 0.990643 -0.069345 +v 0.007582 0.988425 -0.060628 +v 0.007582 0.987060 -0.051169 +v 0.011354 1.034128 -0.050980 +v 0.014981 1.032763 -0.060257 +v 0.018323 1.030545 -0.068807 +v 0.021253 1.027561 -0.076301 +v 0.023657 1.023925 -0.082451 +v 0.025444 1.019777 -0.087020 +v 0.026544 1.015275 -0.089835 +v 0.026916 1.010594 -0.090785 +v 0.026544 1.005913 -0.089835 +v 0.025444 1.001411 -0.087020 +v 0.023657 0.997263 -0.082451 +v 0.021253 0.993627 -0.076301 +v 0.018323 0.990643 -0.068807 +v 0.014981 0.988425 -0.060257 +v 0.011354 0.987060 -0.050980 +v 0.014981 1.034128 -0.050420 +v 0.022095 1.032763 -0.059159 +v 0.028652 1.030545 -0.067213 +v 0.034399 1.027561 -0.074272 +v 0.039115 1.023925 -0.080065 +v 0.042620 1.019777 -0.084370 +v 0.044778 1.015275 -0.087020 +v 0.045506 1.010594 -0.087916 +v 0.044778 1.005913 -0.087020 +v 0.042620 1.001411 -0.084370 +v 0.039115 0.997263 -0.080065 +v 0.034399 0.993627 -0.074272 +v 0.028652 0.990643 -0.067213 +v 0.022095 0.988425 -0.059159 +v 0.014981 0.987060 -0.050420 +v 0.018323 1.034128 -0.049511 +v 0.028652 1.032763 -0.057376 +v 0.038170 1.030545 -0.064624 +v 0.046514 1.027561 -0.070977 +v 0.053361 1.023925 -0.076191 +v 0.058449 1.019777 -0.080065 +v 0.061582 1.015275 -0.082451 +v 0.062640 1.010594 -0.083256 +v 0.061582 1.005913 -0.082451 +v 0.058449 1.001411 -0.080065 +v 0.053361 0.997263 -0.076191 +v 0.046514 0.993627 -0.070977 +v 0.038170 0.990643 -0.064624 +v 0.028652 0.988425 -0.057376 +v 0.018323 0.987060 -0.049511 +v 0.021253 1.034128 -0.048288 +v 0.034399 1.032763 -0.054976 +v 0.046514 1.030545 -0.061140 +v 0.057133 1.027561 -0.066543 +v 0.065848 1.023925 -0.070977 +v 0.072323 1.019777 -0.074272 +v 0.076311 1.015275 -0.076301 +v 0.077657 1.010594 -0.076986 +v 0.076311 1.005913 -0.076301 +v 0.072323 1.001411 -0.074272 +v 0.065848 0.997263 -0.070977 +v 0.057133 0.993627 -0.066543 +v 0.046514 0.990643 -0.061140 +v 0.034399 0.988425 -0.054976 +v 0.021253 0.987060 -0.048288 +v 0.023657 1.034128 -0.046797 +v 0.039115 1.032763 -0.052052 +v 0.053361 1.030545 -0.056895 +v 0.065848 1.027561 -0.061140 +v 0.076095 1.023925 -0.064624 +v 0.083710 1.019777 -0.067213 +v 0.088399 1.015275 -0.068807 +v 0.089982 1.010594 -0.069345 +v 0.088399 1.005913 -0.068807 +v 0.083710 1.001411 -0.067213 +v 0.076095 0.997263 -0.064624 +v 0.065848 0.993627 -0.061140 +v 0.053361 0.990643 -0.056895 +v 0.039115 0.988425 -0.052052 +v 0.023657 0.987060 -0.046797 +v 0.025444 1.034128 -0.045097 +v 0.042620 1.032763 -0.048716 +v 0.058449 1.030545 -0.052052 +v 0.072323 1.027561 -0.054976 +v 0.083710 1.023925 -0.057376 +v 0.092170 1.019777 -0.059159 +v 0.097381 1.015275 -0.060257 +v 0.099140 1.010594 -0.060628 +v 0.097381 1.005913 -0.060257 +v 0.092170 1.001411 -0.059159 +v 0.083710 0.997263 -0.057376 +v 0.072323 0.993627 -0.054976 +v 0.058449 0.990643 -0.052052 +v 0.042620 0.988425 -0.048716 +v 0.025444 0.987060 -0.045097 +v 0.026544 1.034128 -0.043251 +v 0.044778 1.032763 -0.045097 +v 0.061582 1.030545 -0.046797 +v 0.076311 1.027561 -0.048288 +v 0.088399 1.023925 -0.049511 +v 0.097381 1.019777 -0.050420 +v 0.102912 1.015275 -0.050980 +v 0.104779 1.010594 -0.051169 +v 0.102912 1.005913 -0.050980 +v 0.097381 1.001411 -0.050420 +v 0.088399 0.997263 -0.049511 +v 0.076311 0.993627 -0.048288 +v 0.061582 0.990643 -0.046797 +v 0.044778 0.988425 -0.045097 +v 0.026544 0.987060 -0.043251 +v 0.026916 1.034128 -0.041332 +v 0.045506 1.032763 -0.041332 +v 0.062640 1.030545 -0.041332 +v 0.077657 1.027561 -0.041332 +v 0.089982 1.023925 -0.041332 +v 0.099140 1.019777 -0.041332 +v 0.104779 1.015275 -0.041332 +v 0.106684 1.010594 -0.041332 +v 0.104779 1.005913 -0.041332 +v 0.099140 1.001411 -0.041332 +v 0.089982 0.997263 -0.041332 +v 0.077657 0.993627 -0.041332 +v 0.062640 0.990643 -0.041332 +v 0.045506 0.988425 -0.041332 +v 0.026916 0.987060 -0.041332 +v 0.026544 1.034128 -0.039413 +v 0.044778 1.032763 -0.037568 +v 0.061582 1.030545 -0.035867 +v 0.076311 1.027561 -0.034377 +v 0.088399 1.023925 -0.033154 +v 0.097381 1.019777 -0.032245 +v 0.102912 1.015275 -0.031685 +v 0.104779 1.010594 -0.031496 +v 0.102912 1.005913 -0.031685 +v 0.097381 1.001411 -0.032245 +v 0.088399 0.997263 -0.033154 +v 0.076311 0.993627 -0.034377 +v 0.061582 0.990643 -0.035867 +v 0.044778 0.988425 -0.037568 +v 0.026544 0.987060 -0.039413 +v 0.025444 1.034128 -0.037568 +v 0.042620 1.032763 -0.033948 +v 0.058449 1.030545 -0.030612 +v 0.072323 1.027561 -0.027689 +v 0.083710 1.023925 -0.025289 +v 0.092170 1.019777 -0.023506 +v 0.097381 1.015275 -0.022408 +v 0.099140 1.010594 -0.022037 +v 0.097381 1.005913 -0.022408 +v 0.092170 1.001411 -0.023506 +v 0.083710 0.997263 -0.025289 +v 0.072323 0.993627 -0.027689 +v 0.058449 0.990643 -0.030612 +v 0.042620 0.988425 -0.033948 +v 0.025444 0.987060 -0.037568 +v 0.023657 1.034128 -0.035867 +v 0.039115 1.032763 -0.030612 +v 0.053361 1.030545 -0.025770 +v 0.065847 1.027561 -0.021525 +v 0.076095 1.023925 -0.018041 +v 0.083710 1.019777 -0.015452 +v 0.088399 1.015275 -0.013858 +v 0.089982 1.010594 -0.013320 +v 0.088399 1.005913 -0.013858 +v 0.083710 1.001411 -0.015452 +v 0.076095 0.997263 -0.018041 +v 0.065847 0.993627 -0.021525 +v 0.053361 0.990643 -0.025770 +v 0.039115 0.988425 -0.030612 +v 0.023657 0.987060 -0.035867 +v 0.021253 1.034128 -0.034377 +v 0.034399 1.032763 -0.027689 +v 0.046514 1.030545 -0.021525 +v 0.057133 1.027561 -0.016122 +v 0.065847 1.023925 -0.011688 +v 0.072323 1.019777 -0.008393 +v 0.076311 1.015275 -0.006364 +v 0.077657 1.010594 -0.005679 +v 0.076311 1.005913 -0.006364 +v 0.072323 1.001411 -0.008393 +v 0.065847 0.997263 -0.011688 +v 0.057133 0.993627 -0.016122 +v 0.046514 0.990643 -0.021525 +v 0.034399 0.988425 -0.027689 +v 0.021253 0.987060 -0.034377 +v 0.018323 1.034128 -0.033154 +v 0.028652 1.032763 -0.025289 +v 0.038170 1.030545 -0.018041 +v 0.046514 1.027561 -0.011688 +v 0.053361 1.023925 -0.006474 +v 0.058449 1.019777 -0.002600 +v 0.061582 1.015275 -0.000214 +v 0.062640 1.010594 0.000591 +v 0.061582 1.005913 -0.000214 +v 0.058449 1.001411 -0.002600 +v 0.053361 0.997263 -0.006474 +v 0.046514 0.993627 -0.011688 +v 0.038170 0.990643 -0.018041 +v 0.028652 0.988425 -0.025289 +v 0.018323 0.987060 -0.033154 +v 0.007582 0.986599 -0.041332 +v 0.014981 1.034128 -0.032245 +v 0.022095 1.032763 -0.023506 +v 0.028652 1.030545 -0.015452 +v 0.034399 1.027561 -0.008393 +v 0.039115 1.023925 -0.002600 +v 0.042620 1.019777 0.001705 +v 0.044778 1.015275 0.004356 +v 0.045506 1.010594 0.005251 +v 0.044778 1.005913 0.004356 +v 0.042620 1.001411 0.001705 +v 0.039115 0.997263 -0.002600 +v 0.034399 0.993627 -0.008393 +v 0.028652 0.990643 -0.015452 +v 0.022095 0.988425 -0.023506 +v 0.014981 0.987060 -0.032245 +v 0.011354 1.034128 -0.031685 +v 0.014981 1.032763 -0.022408 +v 0.018323 1.030545 -0.013858 +v 0.021253 1.027561 -0.006364 +v 0.023657 1.023925 -0.000214 +v 0.025444 1.019777 0.004356 +v 0.026544 1.015275 0.007170 +v 0.026916 1.010594 0.008120 +v 0.026544 1.005913 0.007170 +v 0.025444 1.001411 0.004356 +v 0.023657 0.997263 -0.000214 +v 0.021253 0.993627 -0.006364 +v 0.018323 0.990643 -0.013858 +v 0.014981 0.988425 -0.022408 +v 0.011354 0.987060 -0.031685 +v 0.007582 1.034128 -0.031496 +v 0.007582 1.032763 -0.022037 +v 0.007582 1.030545 -0.013320 +v 0.007582 1.027561 -0.005679 +v 0.007582 1.023925 0.000591 +v 0.007582 1.019777 0.005251 +v 0.007582 1.015275 0.008120 +v 0.007582 1.010594 0.009089 +v 0.007582 1.005913 0.008120 +v 0.007582 1.001411 0.005251 +v 0.007582 0.997263 0.000591 +v 0.007582 0.993627 -0.005679 +v 0.007582 0.990643 -0.013320 +v 0.007582 0.988425 -0.022037 +v 0.007582 0.987060 -0.031496 +v 0.003810 1.034128 -0.031685 +v 0.000183 1.032763 -0.022408 +v -0.003159 1.030545 -0.013858 +v -0.006089 1.027561 -0.006364 +v -0.008494 1.023925 -0.000214 +v -0.010280 1.019777 0.004356 +v -0.011380 1.015275 0.007170 +v -0.011752 1.010594 0.008120 +v -0.011380 1.005913 0.007170 +v -0.010280 1.001411 0.004356 +v -0.008494 0.997263 -0.000214 +v -0.006089 0.993627 -0.006364 +v -0.003159 0.990643 -0.013858 +v 0.000183 0.988425 -0.022408 +v 0.003810 0.987060 -0.031685 +v 0.000183 1.034128 -0.032245 +v -0.006931 1.032763 -0.023506 +v -0.013488 1.030545 -0.015452 +v -0.019235 1.027561 -0.008393 +v -0.023951 1.023925 -0.002600 +v -0.027456 1.019777 0.001705 +v -0.029614 1.015275 0.004356 +v -0.030343 1.010594 0.005251 +v -0.029614 1.005913 0.004356 +v -0.027456 1.001411 0.001705 +v -0.023951 0.997263 -0.002600 +v -0.019235 0.993627 -0.008393 +v -0.013488 0.990643 -0.015452 +v -0.006931 0.988425 -0.023506 +v 0.000183 0.987060 -0.032245 +v -0.003159 1.034128 -0.033154 +v -0.013488 1.032763 -0.025289 +v -0.023007 1.030545 -0.018041 +v -0.031350 1.027561 -0.011688 +v -0.038197 1.023925 -0.006474 +v -0.043285 1.019777 -0.002600 +v -0.046418 1.015275 -0.000214 +v -0.047476 1.010594 0.000591 +v -0.046418 1.005913 -0.000214 +v -0.043285 1.001411 -0.002600 +v -0.038197 0.997263 -0.006474 +v -0.031350 0.993627 -0.011688 +v -0.023007 0.990643 -0.018041 +v -0.013488 0.988425 -0.025289 +v -0.003159 0.987060 -0.033154 +v -0.006089 1.034128 -0.034377 +v -0.019235 1.032763 -0.027689 +v -0.031350 1.030545 -0.021525 +v -0.041969 1.027561 -0.016122 +v -0.050684 1.023925 -0.011688 +v -0.057159 1.019777 -0.008393 +v -0.061147 1.015275 -0.006364 +v -0.062494 1.010594 -0.005679 +v -0.061147 1.005913 -0.006364 +v -0.057159 1.001411 -0.008393 +v -0.050684 0.997263 -0.011688 +v -0.041969 0.993627 -0.016122 +v -0.031350 0.990643 -0.021525 +v -0.019235 0.988425 -0.027689 +v -0.006089 0.987060 -0.034377 +v -0.008494 1.034128 -0.035867 +v -0.023951 1.032763 -0.030613 +v -0.038197 1.030545 -0.025770 +v -0.050684 1.027561 -0.021525 +v -0.060931 1.023925 -0.018041 +v -0.068546 1.019777 -0.015452 +v -0.073235 1.015275 -0.013858 +v -0.074818 1.010594 -0.013320 +v -0.073235 1.005913 -0.013858 +v -0.068546 1.001411 -0.015452 +v -0.060931 0.997263 -0.018041 +v -0.050684 0.993627 -0.021525 +v -0.038197 0.990643 -0.025770 +v -0.023951 0.988425 -0.030613 +v -0.008494 0.987060 -0.035867 +v 0.007582 1.034589 -0.041332 +v -0.010280 1.034128 -0.037568 +v -0.027456 1.032763 -0.033948 +v -0.043285 1.030545 -0.030613 +v -0.057159 1.027561 -0.027689 +v -0.068546 1.023925 -0.025289 +v -0.077007 1.019777 -0.023506 +v -0.082217 1.015275 -0.022408 +v -0.083976 1.010594 -0.022037 +v -0.082217 1.005913 -0.022408 +v -0.077007 1.001411 -0.023506 +v -0.068546 0.997263 -0.025289 +v -0.057159 0.993627 -0.027689 +v -0.043285 0.990643 -0.030613 +v -0.027456 0.988425 -0.033948 +v -0.010280 0.987060 -0.037568 +v -0.011380 1.034128 -0.039413 +v -0.029614 1.032763 -0.037568 +v -0.046418 1.030545 -0.035867 +v -0.061147 1.027561 -0.034377 +v -0.073235 1.023925 -0.033154 +v -0.082217 1.019777 -0.032245 +v -0.087748 1.015275 -0.031685 +v -0.089615 1.010594 -0.031496 +v -0.087748 1.005913 -0.031685 +v -0.082217 1.001411 -0.032245 +v -0.073235 0.997263 -0.033154 +v -0.061147 0.993627 -0.034377 +v -0.046418 0.990643 -0.035867 +v -0.029614 0.988425 -0.037568 +v -0.011380 0.987060 -0.039413 +v -0.009875 1.033703 0.012545 +v -0.028466 1.032337 0.012545 +v -0.045600 1.030120 0.012545 +v -0.060617 1.027136 0.012545 +v -0.072942 1.023500 0.012545 +v -0.082100 1.019351 0.012545 +v -0.087739 1.014850 0.012545 +v -0.089643 1.010168 0.012545 +v -0.087739 1.005487 0.012545 +v -0.082100 1.000986 0.012545 +v -0.072942 0.996837 0.012545 +v -0.060617 0.993201 0.012545 +v -0.045600 0.990217 0.012545 +v -0.028466 0.988000 0.012545 +v -0.009875 0.986634 0.012545 +v -0.009504 1.033703 0.010626 +v -0.027738 1.032337 0.008781 +v -0.044542 1.030120 0.007080 +v -0.059271 1.027136 0.005589 +v -0.071358 1.023500 0.004366 +v -0.080340 1.019351 0.003457 +v -0.085871 1.014850 0.002897 +v -0.087739 1.010168 0.002708 +v -0.085871 1.005487 0.002897 +v -0.080340 1.000986 0.003457 +v -0.071358 0.996837 0.004366 +v -0.059271 0.993201 0.005589 +v -0.044542 0.990217 0.007080 +v -0.027737 0.988000 0.008781 +v -0.009504 0.986634 0.010626 +v -0.008404 1.033703 0.008780 +v -0.025579 1.032337 0.005161 +v -0.041409 1.030120 0.001825 +v -0.055283 1.027136 -0.001099 +v -0.066669 1.023500 -0.003499 +v -0.075130 1.019351 -0.005282 +v -0.080340 1.014850 -0.006380 +v -0.082100 1.010168 -0.006751 +v -0.080340 1.005487 -0.006380 +v -0.075130 1.000986 -0.005282 +v -0.066669 0.996837 -0.003499 +v -0.055283 0.993201 -0.001099 +v -0.041409 0.990217 0.001825 +v -0.025579 0.988000 0.005161 +v -0.008404 0.986634 0.008781 +v -0.006617 1.033703 0.007080 +v -0.022075 1.032337 0.001825 +v -0.036321 1.030120 -0.003018 +v -0.048807 1.027136 -0.007263 +v -0.059055 1.023500 -0.010747 +v -0.066669 1.019351 -0.013335 +v -0.071358 1.014850 -0.014929 +v -0.072942 1.010168 -0.015468 +v -0.071358 1.005487 -0.014929 +v -0.066669 1.000986 -0.013335 +v -0.059055 0.996837 -0.010747 +v -0.048807 0.993201 -0.007263 +v -0.036321 0.990217 -0.003018 +v -0.022075 0.988000 0.001825 +v -0.006617 0.986634 0.007080 +v -0.004213 1.033703 0.005589 +v -0.017358 1.032337 -0.001099 +v -0.029473 1.030120 -0.007263 +v -0.040092 1.027136 -0.012666 +v -0.048807 1.023500 -0.017100 +v -0.055283 1.019351 -0.020394 +v -0.059271 1.014850 -0.022423 +v -0.060617 1.010168 -0.023108 +v -0.059271 1.005487 -0.022423 +v -0.055283 1.000986 -0.020394 +v -0.048807 0.996837 -0.017100 +v -0.040092 0.993201 -0.012666 +v -0.029473 0.990217 -0.007263 +v -0.017358 0.988000 -0.001099 +v -0.004213 0.986634 0.005589 +v -0.001283 1.033703 0.004366 +v -0.011611 1.032337 -0.003499 +v -0.021130 1.030120 -0.010747 +v -0.029473 1.027136 -0.017100 +v -0.036321 1.023500 -0.022313 +v -0.041409 1.019351 -0.026188 +v -0.044542 1.014850 -0.028573 +v -0.045600 1.010168 -0.029379 +v -0.044542 1.005487 -0.028573 +v -0.041409 1.000986 -0.026188 +v -0.036321 0.996837 -0.022313 +v -0.029473 0.993201 -0.017100 +v -0.021130 0.990217 -0.010747 +v -0.011611 0.988000 -0.003499 +v -0.001283 0.986634 0.004366 +v 0.002060 1.033703 0.003457 +v -0.005055 1.032337 -0.005282 +v -0.011611 1.030120 -0.013335 +v -0.017358 1.027136 -0.020394 +v -0.022075 1.023500 -0.026188 +v -0.025579 1.019351 -0.030492 +v -0.027737 1.014850 -0.033143 +v -0.028466 1.010168 -0.034038 +v -0.027737 1.005487 -0.033143 +v -0.025579 1.000986 -0.030492 +v -0.022075 0.996837 -0.026188 +v -0.017358 0.993201 -0.020394 +v -0.011611 0.990217 -0.013335 +v -0.005055 0.988000 -0.005282 +v 0.002060 0.986634 0.003457 +v 0.005687 1.033703 0.002897 +v 0.002060 1.032337 -0.006380 +v -0.001283 1.030120 -0.014929 +v -0.004213 1.027136 -0.022423 +v -0.006617 1.023500 -0.028573 +v -0.008404 1.019351 -0.033143 +v -0.009504 1.014850 -0.035957 +v -0.009875 1.010168 -0.036908 +v -0.009504 1.005487 -0.035957 +v -0.008404 1.000986 -0.033143 +v -0.006617 0.996837 -0.028573 +v -0.004213 0.993201 -0.022423 +v -0.001283 0.990217 -0.014929 +v 0.002060 0.988000 -0.006380 +v 0.005687 0.986634 0.002897 +v 0.009458 1.033703 0.002708 +v 0.009458 1.032337 -0.006751 +v 0.009458 1.030120 -0.015468 +v 0.009458 1.027136 -0.023108 +v 0.009458 1.023500 -0.029379 +v 0.009458 1.019351 -0.034038 +v 0.009458 1.014850 -0.036908 +v 0.009458 1.010168 -0.037876 +v 0.009458 1.005487 -0.036908 +v 0.009458 1.000986 -0.034038 +v 0.009458 0.996837 -0.029379 +v 0.009458 0.993201 -0.023108 +v 0.009458 0.990217 -0.015468 +v 0.009458 0.988000 -0.006751 +v 0.009458 0.986634 0.002708 +v 0.013230 1.033703 0.002897 +v 0.016857 1.032337 -0.006380 +v 0.020200 1.030120 -0.014929 +v 0.023129 1.027136 -0.022423 +v 0.025534 1.023500 -0.028573 +v 0.027320 1.019351 -0.033143 +v 0.028421 1.014850 -0.035957 +v 0.028792 1.010168 -0.036908 +v 0.028421 1.005487 -0.035957 +v 0.027320 1.000986 -0.033143 +v 0.025534 0.996837 -0.028573 +v 0.023129 0.993201 -0.022423 +v 0.020200 0.990217 -0.014929 +v 0.016857 0.988000 -0.006380 +v 0.013230 0.986634 0.002897 +v 0.016857 1.033703 0.003457 +v 0.023971 1.032337 -0.005282 +v 0.030528 1.030120 -0.013335 +v 0.036275 1.027136 -0.020394 +v 0.040992 1.023500 -0.026188 +v 0.044496 1.019351 -0.030492 +v 0.046654 1.014850 -0.033143 +v 0.047383 1.010168 -0.034038 +v 0.046654 1.005487 -0.033143 +v 0.044496 1.000986 -0.030492 +v 0.040992 0.996837 -0.026188 +v 0.036275 0.993201 -0.020394 +v 0.030528 0.990217 -0.013335 +v 0.023971 0.988000 -0.005282 +v 0.016857 0.986634 0.003457 +v 0.020200 1.033703 0.004366 +v 0.030528 1.032337 -0.003499 +v 0.040047 1.030120 -0.010747 +v 0.048390 1.027136 -0.017100 +v 0.055237 1.023500 -0.022313 +v 0.060325 1.019351 -0.026188 +v 0.063458 1.014850 -0.028573 +v 0.064516 1.010168 -0.029379 +v 0.063458 1.005487 -0.028573 +v 0.060325 1.000986 -0.026188 +v 0.055237 0.996837 -0.022313 +v 0.048390 0.993201 -0.017100 +v 0.040047 0.990217 -0.010747 +v 0.030528 0.988000 -0.003499 +v 0.020200 0.986634 0.004366 +v 0.023129 1.033703 0.005589 +v 0.036275 1.032337 -0.001099 +v 0.048390 1.030120 -0.007263 +v 0.059009 1.027136 -0.012666 +v 0.067724 1.023500 -0.017100 +v 0.074200 1.019351 -0.020394 +v 0.078187 1.014850 -0.022423 +v 0.079534 1.010168 -0.023108 +v 0.078187 1.005487 -0.022423 +v 0.074200 1.000986 -0.020394 +v 0.067724 0.996837 -0.017100 +v 0.059009 0.993201 -0.012666 +v 0.048390 0.990217 -0.007263 +v 0.036275 0.988000 -0.001099 +v 0.023129 0.986634 0.005589 +v 0.025534 1.033703 0.007080 +v 0.040992 1.032337 0.001825 +v 0.055237 1.030120 -0.003018 +v 0.067724 1.027136 -0.007263 +v 0.077971 1.023500 -0.010747 +v 0.085586 1.019351 -0.013335 +v 0.090275 1.014850 -0.014929 +v 0.091858 1.010168 -0.015468 +v 0.090275 1.005487 -0.014929 +v 0.085586 1.000986 -0.013335 +v 0.077971 0.996837 -0.010747 +v 0.067724 0.993201 -0.007263 +v 0.055237 0.990217 -0.003018 +v 0.040991 0.988000 0.001825 +v 0.025534 0.986634 0.007080 +v 0.027320 1.033703 0.008781 +v 0.044496 1.032337 0.005161 +v 0.060325 1.030120 0.001825 +v 0.074200 1.027136 -0.001099 +v 0.085586 1.023500 -0.003499 +v 0.094047 1.019351 -0.005282 +v 0.099257 1.014850 -0.006380 +v 0.101016 1.010168 -0.006751 +v 0.099257 1.005487 -0.006380 +v 0.094047 1.000986 -0.005282 +v 0.085586 0.996837 -0.003499 +v 0.074200 0.993201 -0.001099 +v 0.060325 0.990217 0.001825 +v 0.044496 0.988000 0.005161 +v 0.027320 0.986634 0.008781 +v 0.028421 1.033703 0.010626 +v 0.046654 1.032337 0.008781 +v 0.063458 1.030120 0.007080 +v 0.078187 1.027136 0.005589 +v 0.090275 1.023500 0.004366 +v 0.099257 1.019351 0.003457 +v 0.104788 1.014850 0.002897 +v 0.106656 1.010168 0.002708 +v 0.104788 1.005487 0.002897 +v 0.099257 1.000986 0.003457 +v 0.090275 0.996837 0.004366 +v 0.078187 0.993201 0.005589 +v 0.063458 0.990217 0.007080 +v 0.046654 0.988000 0.008781 +v 0.028421 0.986634 0.010626 +v 0.028792 1.033703 0.012545 +v 0.047383 1.032337 0.012545 +v 0.064516 1.030120 0.012545 +v 0.079534 1.027136 0.012545 +v 0.091858 1.023500 0.012545 +v 0.101016 1.019351 0.012545 +v 0.106656 1.014850 0.012545 +v 0.108560 1.010168 0.012545 +v 0.106656 1.005487 0.012545 +v 0.101016 1.000986 0.012545 +v 0.091858 0.996837 0.012545 +v 0.079534 0.993201 0.012545 +v 0.064516 0.990217 0.012545 +v 0.047383 0.988000 0.012545 +v 0.028792 0.986634 0.012545 +v 0.028421 1.033703 0.014464 +v 0.046654 1.032337 0.016309 +v 0.063458 1.030120 0.018010 +v 0.078187 1.027136 0.019500 +v 0.090275 1.023500 0.020724 +v 0.099257 1.019351 0.021633 +v 0.104788 1.014850 0.022193 +v 0.106656 1.010168 0.022382 +v 0.104788 1.005487 0.022193 +v 0.099257 1.000986 0.021633 +v 0.090275 0.996837 0.020724 +v 0.078187 0.993201 0.019500 +v 0.063458 0.990217 0.018010 +v 0.046654 0.988000 0.016309 +v 0.028421 0.986634 0.014464 +v 0.027320 1.033703 0.016309 +v 0.044496 1.032337 0.019929 +v 0.060325 1.030120 0.023265 +v 0.074200 1.027136 0.026189 +v 0.085586 1.023500 0.028588 +v 0.094047 1.019351 0.030371 +v 0.099257 1.014850 0.031469 +v 0.101016 1.010168 0.031840 +v 0.099257 1.005487 0.031469 +v 0.094047 1.000986 0.030371 +v 0.085586 0.996837 0.028588 +v 0.074200 0.993201 0.026189 +v 0.060325 0.990217 0.023265 +v 0.044496 0.988000 0.019929 +v 0.027320 0.986634 0.016309 +v 0.025534 1.033703 0.018010 +v 0.040991 1.032337 0.023265 +v 0.055237 1.030120 0.028108 +v 0.067724 1.027136 0.032353 +v 0.077971 1.023500 0.035836 +v 0.085586 1.019351 0.038425 +v 0.090275 1.014850 0.040019 +v 0.091858 1.010168 0.040557 +v 0.090275 1.005487 0.040019 +v 0.085586 1.000986 0.038425 +v 0.077971 0.996837 0.035836 +v 0.067724 0.993201 0.032353 +v 0.055237 0.990217 0.028108 +v 0.040991 0.988000 0.023265 +v 0.025534 0.986634 0.018010 +v 0.023129 1.033703 0.019500 +v 0.036275 1.032337 0.026189 +v 0.048390 1.030120 0.032353 +v 0.059009 1.027136 0.037755 +v 0.067724 1.023500 0.042189 +v 0.074200 1.019351 0.045484 +v 0.078187 1.014850 0.047513 +v 0.079534 1.010168 0.048198 +v 0.078187 1.005487 0.047513 +v 0.074200 1.000986 0.045484 +v 0.067724 0.996837 0.042189 +v 0.059009 0.993201 0.037755 +v 0.048390 0.990217 0.032353 +v 0.036275 0.988000 0.026189 +v 0.023129 0.986634 0.019500 +v 0.020200 1.033703 0.020724 +v 0.030528 1.032337 0.028588 +v 0.040047 1.030120 0.035836 +v 0.048390 1.027136 0.042189 +v 0.055237 1.023500 0.047403 +v 0.060325 1.019351 0.051277 +v 0.063458 1.014850 0.053663 +v 0.064516 1.010168 0.054469 +v 0.063458 1.005487 0.053663 +v 0.060325 1.000986 0.051277 +v 0.055237 0.996837 0.047403 +v 0.048390 0.993201 0.042189 +v 0.040047 0.990217 0.035836 +v 0.030528 0.988000 0.028588 +v 0.020200 0.986634 0.020724 +v 0.009458 0.986173 0.012545 +v 0.016857 1.033703 0.021633 +v 0.023971 1.032337 0.030371 +v 0.030528 1.030120 0.038425 +v 0.036275 1.027136 0.045484 +v 0.040991 1.023500 0.051277 +v 0.044496 1.019351 0.055582 +v 0.046654 1.014850 0.058233 +v 0.047383 1.010168 0.059128 +v 0.046654 1.005487 0.058233 +v 0.044496 1.000986 0.055582 +v 0.040991 0.996837 0.051277 +v 0.036275 0.993201 0.045484 +v 0.030528 0.990217 0.038425 +v 0.023971 0.988000 0.030371 +v 0.016857 0.986634 0.021633 +v 0.013230 1.033703 0.022193 +v 0.016857 1.032337 0.031469 +v 0.020200 1.030120 0.040019 +v 0.023129 1.027136 0.047513 +v 0.025534 1.023500 0.053663 +v 0.027320 1.019351 0.058233 +v 0.028421 1.014850 0.061047 +v 0.028792 1.010168 0.061997 +v 0.028421 1.005487 0.061047 +v 0.027320 1.000986 0.058233 +v 0.025534 0.996837 0.053663 +v 0.023129 0.993201 0.047513 +v 0.020200 0.990217 0.040019 +v 0.016857 0.988000 0.031469 +v 0.013230 0.986634 0.022193 +v 0.009458 1.033703 0.022382 +v 0.009458 1.032337 0.031840 +v 0.009458 1.030120 0.040557 +v 0.009458 1.027136 0.048198 +v 0.009458 1.023500 0.054469 +v 0.009458 1.019351 0.059128 +v 0.009458 1.014850 0.061997 +v 0.009458 1.010168 0.062966 +v 0.009458 1.005487 0.061997 +v 0.009458 1.000986 0.059128 +v 0.009458 0.996837 0.054469 +v 0.009458 0.993201 0.048198 +v 0.009458 0.990217 0.040557 +v 0.009458 0.988000 0.031840 +v 0.009458 0.986634 0.022382 +v 0.005687 1.033703 0.022193 +v 0.002060 1.032337 0.031469 +v -0.001283 1.030120 0.040019 +v -0.004213 1.027136 0.047513 +v -0.006617 1.023500 0.053663 +v -0.008404 1.019351 0.058233 +v -0.009504 1.014850 0.061047 +v -0.009875 1.010168 0.061997 +v -0.009504 1.005487 0.061047 +v -0.008404 1.000986 0.058233 +v -0.006617 0.996837 0.053663 +v -0.004213 0.993201 0.047513 +v -0.001283 0.990217 0.040019 +v 0.002060 0.988000 0.031469 +v 0.005687 0.986634 0.022193 +v 0.002060 1.033703 0.021633 +v -0.005055 1.032337 0.030371 +v -0.011611 1.030120 0.038425 +v -0.017358 1.027136 0.045484 +v -0.022075 1.023500 0.051277 +v -0.025579 1.019351 0.055582 +v -0.027737 1.014850 0.058233 +v -0.028466 1.010168 0.059128 +v -0.027737 1.005487 0.058233 +v -0.025579 1.000986 0.055582 +v -0.022075 0.996837 0.051277 +v -0.017358 0.993201 0.045484 +v -0.011611 0.990217 0.038425 +v -0.005055 0.988000 0.030371 +v 0.002060 0.986634 0.021633 +v -0.001283 1.033703 0.020724 +v -0.011611 1.032337 0.028588 +v -0.021130 1.030120 0.035836 +v -0.029473 1.027136 0.042189 +v -0.036321 1.023500 0.047403 +v -0.041409 1.019351 0.051277 +v -0.044542 1.014850 0.053663 +v -0.045600 1.010168 0.054468 +v -0.044542 1.005487 0.053663 +v -0.041408 1.000986 0.051277 +v -0.036321 0.996837 0.047403 +v -0.029473 0.993201 0.042189 +v -0.021130 0.990217 0.035836 +v -0.011611 0.988000 0.028588 +v -0.001283 0.986634 0.020724 +v -0.004213 1.033703 0.019500 +v -0.017358 1.032337 0.026189 +v -0.029473 1.030120 0.032353 +v -0.040092 1.027136 0.037755 +v -0.048807 1.023500 0.042189 +v -0.055283 1.019351 0.045484 +v -0.059271 1.014850 0.047513 +v -0.060617 1.010168 0.048198 +v -0.059271 1.005487 0.047513 +v -0.055283 1.000986 0.045484 +v -0.048807 0.996837 0.042189 +v -0.040092 0.993201 0.037755 +v -0.029473 0.990217 0.032353 +v -0.017358 0.988000 0.026189 +v -0.004213 0.986634 0.019500 +v -0.006617 1.033703 0.018010 +v -0.022075 1.032337 0.023265 +v -0.036321 1.030120 0.028108 +v -0.048807 1.027136 0.032353 +v -0.059055 1.023500 0.035836 +v -0.066669 1.019351 0.038425 +v -0.071358 1.014850 0.040019 +v -0.072942 1.010168 0.040557 +v -0.071358 1.005487 0.040019 +v -0.066669 1.000986 0.038425 +v -0.059055 0.996837 0.035836 +v -0.048807 0.993201 0.032353 +v -0.036321 0.990217 0.028108 +v -0.022075 0.988000 0.023265 +v -0.006617 0.986634 0.018010 +v 0.009458 1.034164 0.012545 +v -0.008404 1.033703 0.016309 +v -0.025579 1.032337 0.019929 +v -0.041408 1.030120 0.023265 +v -0.055283 1.027136 0.026189 +v -0.066669 1.023500 0.028588 +v -0.075130 1.019351 0.030371 +v -0.080340 1.014850 0.031469 +v -0.082100 1.010168 0.031840 +v -0.080340 1.005487 0.031469 +v -0.075130 1.000986 0.030371 +v -0.066669 0.996837 0.028588 +v -0.055283 0.993201 0.026189 +v -0.041408 0.990217 0.023265 +v -0.025579 0.988000 0.019929 +v -0.008404 0.986634 0.016309 +v -0.009504 1.033703 0.014464 +v -0.027737 1.032337 0.016309 +v -0.044542 1.030120 0.018010 +v -0.059271 1.027136 0.019500 +v -0.071358 1.023500 0.020724 +v -0.080340 1.019351 0.021633 +v -0.085871 1.014850 0.022193 +v -0.087739 1.010168 0.022382 +v -0.085871 1.005487 0.022192 +v -0.080340 1.000986 0.021633 +v -0.071358 0.996837 0.020724 +v -0.059271 0.993201 0.019500 +v -0.044542 0.990217 0.018010 +v -0.027737 0.988000 0.016309 +v -0.009504 0.986634 0.014464 +vn -0.811518 0.584307 0.000000 +vn -0.533006 0.846095 0.000000 +vn -0.513047 0.834559 -0.200568 +vn -0.104160 0.994537 0.000000 +vn -0.051546 0.998657 0.000031 +vn -0.050203 0.998505 -0.020386 +vn -0.165685 -0.986145 0.000000 +vn -0.244362 -0.969665 0.000000 +vn -0.161748 -0.984710 -0.064211 +vn -1.000000 0.000000 0.000000 +vn -0.767876 0.569903 -0.292459 +vn -0.165685 0.986145 0.000000 +vn -0.101688 0.993957 -0.040651 +vn -0.104160 -0.994537 0.000000 +vn -0.101688 -0.993957 -0.040620 +vn -0.811518 -0.584307 0.000000 +vn -0.767876 -0.569903 -0.292459 +vn -0.244362 0.969665 0.000000 +vn -0.161779 0.984710 -0.064211 +vn -0.051546 -0.998657 0.000000 +vn -0.050203 -0.998505 -0.020417 +vn -0.533006 -0.846095 0.000000 +vn -0.513047 -0.834559 -0.200598 +vn -0.355968 0.934477 0.000000 +vn -0.238197 0.966613 -0.094272 +vn -0.355968 -0.934477 0.000000 +vn -0.345683 -0.928373 -0.136296 +vn -0.345683 0.928373 -0.136296 +vn -0.238197 -0.966613 -0.094241 +vn -0.460768 0.804498 -0.374737 +vn -0.046510 0.998138 -0.039369 +vn -0.150700 -0.980682 -0.124516 +vn -0.937864 0.000000 -0.346965 +vn -0.662038 0.533647 -0.526200 +vn -0.094790 0.992340 -0.078829 +vn -0.094790 -0.992370 -0.078799 +vn -0.662038 -0.533647 -0.526200 +vn -0.150700 0.980682 -0.124516 +vn -0.046510 -0.998138 -0.039369 +vn -0.460738 -0.804498 -0.374737 +vn -0.220954 0.958129 -0.181921 +vn -0.317423 -0.911802 -0.260384 +vn -0.317423 0.911802 -0.260353 +vn -0.220954 -0.958129 -0.181951 +vn -0.276437 -0.888882 -0.365307 +vn -0.276437 0.888882 -0.365307 +vn -0.195044 -0.946013 -0.258797 +vn -0.390362 0.765465 -0.511521 +vn -0.041139 0.997559 -0.056124 +vn -0.133854 -0.974822 -0.178289 +vn -0.789727 0.000000 -0.613422 +vn -0.535539 0.489547 -0.688101 +vn -0.084323 0.989990 -0.113010 +vn -0.084323 -0.989990 -0.112980 +vn -0.535539 -0.489547 -0.688101 +vn -0.133854 0.974822 -0.178259 +vn -0.041139 -0.997559 -0.056124 +vn -0.390362 -0.765435 -0.511521 +vn -0.195044 0.946013 -0.258827 +vn -0.034425 -0.996918 -0.070345 +vn -0.312601 -0.726188 -0.612293 +vn -0.162603 0.932432 -0.322642 +vn -0.227241 -0.864162 -0.448927 +vn -0.227241 0.864162 -0.448927 +vn -0.162603 -0.932432 -0.322642 +vn -0.312601 0.726188 -0.612293 +vn -0.034425 0.996918 -0.070345 +vn -0.112369 -0.968108 -0.223853 +vn -0.620777 0.000000 -0.783959 +vn -0.411817 0.448561 -0.793207 +vn -0.070925 0.987274 -0.142216 +vn -0.070925 -0.987274 -0.142186 +vn -0.411817 -0.448561 -0.793176 +vn -0.112369 0.968108 -0.223853 +vn -0.055177 0.984619 -0.165685 +vn -0.055177 -0.984619 -0.165654 +vn -0.465529 0.000000 -0.885006 +vn -0.297830 -0.415754 -0.859310 +vn -0.087252 0.961608 -0.260109 +vn -0.026673 -0.996277 -0.081698 +vn -0.233192 -0.692373 -0.682791 +vn -0.125462 0.919523 -0.372417 +vn -0.173223 -0.841548 -0.511643 +vn -0.173223 0.841548 -0.511612 +vn -0.125462 -0.919523 -0.372417 +vn -0.233192 0.692373 -0.682791 +vn -0.026673 0.996277 -0.081698 +vn -0.087252 -0.961608 -0.260140 +vn -0.297830 0.415754 -0.859310 +vn -0.154454 0.667013 -0.728843 +vn -0.018159 0.995758 -0.089908 +vn -0.059511 -0.956236 -0.286386 +vn -0.330424 0.000000 -0.943815 +vn -0.193091 0.392499 -0.899228 +vn -0.037690 0.982421 -0.182775 +vn -0.037690 -0.982421 -0.182745 +vn -0.193121 -0.392499 -0.899228 +vn -0.059511 0.956236 -0.286355 +vn -0.018159 -0.995758 -0.089908 +vn -0.154454 -0.667013 -0.728843 +vn -0.085177 0.909055 -0.407819 +vn -0.116550 -0.823725 -0.554826 +vn -0.116550 0.823725 -0.554857 +vn -0.085177 -0.909055 -0.407819 +vn -0.058535 -0.812433 -0.580096 +vn -0.058535 0.812433 -0.580065 +vn -0.043031 -0.902280 -0.428938 +vn -0.076876 0.651418 -0.754784 +vn -0.009156 0.995422 -0.094852 +vn -0.030152 -0.952757 -0.302225 +vn -0.211585 0.000000 -0.977355 +vn -0.094913 0.378796 -0.920560 +vn -0.019105 0.980956 -0.193121 +vn -0.019105 -0.980956 -0.193121 +vn -0.094913 -0.378796 -0.920591 +vn -0.030152 0.952757 -0.302225 +vn -0.009156 -0.995422 -0.094821 +vn -0.076876 -0.651418 -0.754784 +vn -0.043031 0.902280 -0.428938 +vn 0.000000 -0.995331 -0.096469 +vn 0.000000 -0.646168 -0.763176 +vn 0.000000 0.899930 -0.435957 +vn 0.000000 -0.808557 -0.588366 +vn 0.000000 0.808557 -0.588366 +vn 0.000000 -0.899960 -0.435957 +vn 0.000000 0.646168 -0.763176 +vn 0.000000 0.995331 -0.096469 +vn 0.000000 -0.951537 -0.307505 +vn -0.103244 0.000000 -0.994629 +vn 0.000000 0.374279 -0.927305 +vn 0.000000 0.980468 -0.196570 +vn 0.000000 -0.980468 -0.196570 +vn 0.000000 -0.374248 -0.927305 +vn 0.000000 0.951537 -0.307505 +vn 0.030152 -0.952727 -0.302225 +vn 0.000000 0.000000 -0.999969 +vn 0.103244 0.000000 -0.994629 +vn 0.043031 0.902280 -0.428938 +vn 0.019105 -0.980956 -0.193121 +vn 0.094913 -0.378796 -0.920591 +vn 0.058535 0.812433 -0.580065 +vn 0.076876 -0.651418 -0.754784 +vn 0.076876 0.651418 -0.754784 +vn 0.058535 -0.812433 -0.580096 +vn 0.094913 0.378796 -0.920591 +vn 0.019105 0.980956 -0.193121 +vn 0.043031 -0.902280 -0.428938 +vn 0.030152 0.952757 -0.302225 +vn 0.009156 0.995422 -0.094852 +vn 0.037690 0.982421 -0.182775 +vn 0.085177 -0.909055 -0.407819 +vn 0.211585 0.000000 -0.977355 +vn 0.059511 0.956236 -0.286355 +vn 0.059511 -0.956236 -0.286386 +vn 0.085177 0.909055 -0.407819 +vn 0.009156 -0.995422 -0.094821 +vn 0.037690 -0.982421 -0.182745 +vn 0.193121 -0.392499 -0.899228 +vn 0.116550 0.823725 -0.554857 +vn 0.154454 -0.667013 -0.728843 +vn 0.154454 0.667013 -0.728813 +vn 0.116550 -0.823725 -0.554857 +vn 0.193121 0.392499 -0.899228 +vn 0.233192 0.692373 -0.682791 +vn 0.173223 -0.841548 -0.511643 +vn 0.297830 0.415754 -0.859310 +vn 0.018159 0.995758 -0.089908 +vn 0.055177 0.984619 -0.165654 +vn 0.125462 -0.919523 -0.372417 +vn 0.330424 0.000000 -0.943815 +vn 0.087252 0.961608 -0.260109 +vn 0.087252 -0.961608 -0.260109 +vn 0.125462 0.919523 -0.372417 +vn 0.018159 -0.995758 -0.089908 +vn 0.055177 -0.984619 -0.165654 +vn 0.297830 -0.415754 -0.859310 +vn 0.173223 0.841548 -0.511643 +vn 0.233192 -0.692373 -0.682791 +vn 0.411817 -0.448561 -0.793176 +vn 0.227241 0.864162 -0.448927 +vn 0.312601 -0.726188 -0.612262 +vn 0.312601 0.726188 -0.612293 +vn 0.227241 -0.864162 -0.448927 +vn 0.411817 0.448561 -0.793176 +vn 0.026673 0.996277 -0.081698 +vn 0.070925 0.987274 -0.142216 +vn 0.162603 -0.932432 -0.322642 +vn 0.465529 0.000000 -0.885006 +vn 0.112369 0.968108 -0.223853 +vn 0.112369 -0.968108 -0.223853 +vn 0.162603 0.932432 -0.322642 +vn 0.026673 -0.996277 -0.081668 +vn 0.070925 -0.987274 -0.142216 +vn 0.133854 -0.974822 -0.178289 +vn 0.620777 0.000000 -0.783959 +vn 0.195044 0.946013 -0.258797 +vn 0.034425 -0.996918 -0.070345 +vn 0.084323 -0.989990 -0.112980 +vn 0.535539 -0.489547 -0.688101 +vn 0.276437 0.888882 -0.365307 +vn 0.390362 -0.765465 -0.511521 +vn 0.390362 0.765465 -0.511521 +vn 0.276437 -0.888882 -0.365307 +vn 0.535539 0.489547 -0.688101 +vn 0.034425 0.996918 -0.070376 +vn 0.084323 0.989990 -0.113010 +vn 0.195044 -0.946013 -0.258797 +vn 0.133854 0.974822 -0.178259 +vn 0.041139 0.997559 -0.056124 +vn 0.094790 0.992370 -0.078799 +vn 0.220954 -0.958129 -0.181921 +vn 0.789727 0.000000 -0.613422 +vn 0.150700 0.980682 -0.124516 +vn 0.150700 -0.980682 -0.124546 +vn 0.220954 0.958129 -0.181921 +vn 0.041139 -0.997559 -0.056124 +vn 0.094790 -0.992370 -0.078799 +vn 0.662038 -0.533647 -0.526200 +vn 0.317423 0.911802 -0.260353 +vn 0.460738 -0.804498 -0.374737 +vn 0.460768 0.804498 -0.374737 +vn 0.317423 -0.911802 -0.260384 +vn 0.662038 0.533647 -0.526200 +vn 0.513047 0.834559 -0.200568 +vn 0.345683 -0.928373 -0.136296 +vn 0.767876 0.569903 -0.292459 +vn 0.046510 0.998138 -0.039399 +vn 0.101688 0.993957 -0.040620 +vn 0.238197 -0.966613 -0.094241 +vn 0.937864 0.000000 -0.346965 +vn 0.161779 0.984710 -0.064241 +vn 0.161748 -0.984710 -0.064241 +vn 0.238197 0.966613 -0.094241 +vn 0.046510 -0.998138 -0.039369 +vn 0.101688 -0.993957 -0.040620 +vn 0.767876 -0.569903 -0.292459 +vn 0.345683 0.928373 -0.136296 +vn 0.513047 -0.834559 -0.200598 +vn 0.811518 -0.584307 0.000000 +vn 0.355968 0.934477 0.000000 +vn 0.533006 -0.846065 0.000000 +vn 0.533006 0.846095 0.000000 +vn 0.355968 -0.934477 0.000000 +vn 0.811518 0.584307 0.000000 +vn 0.050203 0.998505 -0.020447 +vn 0.104160 0.994537 0.000000 +vn 0.244362 -0.969665 0.000000 +vn 0.165685 0.986145 0.000000 +vn 0.165685 -0.986145 0.000000 +vn 0.244362 0.969665 0.000000 +vn 0.050203 -0.998505 -0.020417 +vn 0.104160 -0.994537 0.000000 +vn 0.101688 -0.993957 0.040620 +vn 0.767876 -0.569903 0.292459 +vn 0.161779 0.984710 0.064241 +vn 0.051546 -0.998657 0.000000 +vn 0.050203 -0.998505 0.020417 +vn 0.513047 -0.834559 0.200598 +vn 0.238197 0.966613 0.094241 +vn 0.345683 -0.928373 0.136296 +vn 0.345683 0.928373 0.136296 +vn 0.238197 -0.966613 0.094241 +vn 0.513047 0.834559 0.200568 +vn 0.051546 0.998657 0.000000 +vn 0.050203 0.998505 0.020386 +vn 0.161748 -0.984710 0.064211 +vn 0.767876 0.569903 0.292459 +vn 0.101688 0.993957 0.040620 +vn 0.150700 -0.980682 0.124516 +vn 0.937864 0.000000 0.346965 +vn 0.662038 0.533647 0.526200 +vn 0.094790 0.992340 0.078829 +vn 0.094790 -0.992370 0.078799 +vn 0.662038 -0.533647 0.526200 +vn 0.150700 0.980682 0.124516 +vn 0.046510 -0.998138 0.039369 +vn 0.460738 -0.804498 0.374737 +vn 0.220954 0.958129 0.181951 +vn 0.317423 -0.911802 0.260384 +vn 0.317423 0.911802 0.260384 +vn 0.220954 -0.958129 0.181951 +vn 0.460768 0.804498 0.374737 +vn 0.046510 0.998138 0.039369 +vn 0.195044 -0.946013 0.258797 +vn 0.390362 0.765465 0.511521 +vn 0.041139 0.997559 0.056124 +vn 0.133854 -0.974822 0.178289 +vn 0.789727 0.000000 0.613422 +vn 0.535539 0.489547 0.688101 +vn 0.084323 0.989990 0.113010 +vn 0.084323 -0.989990 0.112980 +vn 0.535539 -0.489547 0.688101 +vn 0.133854 0.974822 0.178259 +vn 0.041139 -0.997559 0.056124 +vn 0.390362 -0.765465 0.511521 +vn 0.195044 0.946013 0.258797 +vn 0.276437 -0.888882 0.365307 +vn 0.276437 0.888882 0.365307 +vn 0.162603 0.932432 0.322642 +vn 0.227241 -0.864162 0.448927 +vn 0.227241 0.864162 0.448927 +vn 0.162603 -0.932432 0.322642 +vn 0.312601 0.726188 0.612293 +vn 0.034425 0.996918 0.070345 +vn 0.112369 -0.968108 0.223884 +vn 0.620777 0.000000 0.783959 +vn 0.411817 0.448561 0.793176 +vn 0.070925 0.987274 0.142216 +vn 0.070925 -0.987274 0.142186 +vn 0.411817 -0.448561 0.793176 +vn 0.112369 0.968108 0.223853 +vn 0.034425 -0.996918 0.070345 +vn 0.312601 -0.726188 0.612293 +vn 0.465529 0.000000 0.885006 +vn 0.297830 -0.415754 0.859310 +vn 0.087252 0.961608 0.260109 +vn 0.026673 -0.996277 0.081668 +vn 0.233192 -0.692373 0.682791 +vn 0.125462 0.919523 0.372417 +vn 0.173223 -0.841548 0.511643 +vn 0.173223 0.841517 0.511643 +vn 0.125462 -0.919523 0.372417 +vn 0.233192 0.692373 0.682791 +vn 0.026673 0.996277 0.081698 +vn 0.087252 -0.961608 0.260109 +vn 0.297830 0.415723 0.859310 +vn 0.055177 0.984619 0.165685 +vn 0.055177 -0.984619 0.165654 +vn 0.059511 -0.956236 0.286386 +vn 0.330393 0.000000 0.943815 +vn 0.193121 0.392499 0.899228 +vn 0.037690 0.982421 0.182775 +vn 0.037690 -0.982421 0.182775 +vn 0.193121 -0.392499 0.899228 +vn 0.059511 0.956236 0.286386 +vn 0.018159 -0.995758 0.089877 +vn 0.154454 -0.667013 0.728843 +vn 0.085177 0.909055 0.407819 +vn 0.116550 -0.823725 0.554826 +vn 0.116550 0.823725 0.554857 +vn 0.085177 -0.909055 0.407819 +vn 0.154454 0.667013 0.728843 +vn 0.018159 0.995758 0.089908 +vn 0.043031 -0.902280 0.428938 +vn 0.076876 0.651418 0.754784 +vn 0.009156 0.995422 0.094852 +vn 0.030152 -0.952757 0.302225 +vn 0.211585 0.000000 0.977355 +vn 0.094913 0.378796 0.920591 +vn 0.019105 0.980956 0.193121 +vn 0.019105 -0.980956 0.193121 +vn 0.094913 -0.378796 0.920591 +vn 0.030152 0.952727 0.302225 +vn 0.009156 -0.995422 0.094821 +vn 0.076876 -0.651418 0.754784 +vn 0.043031 0.902280 0.428938 +vn 0.058535 -0.812433 0.580065 +vn 0.058535 0.812433 0.580096 +vn 0.000000 0.899960 0.435957 +vn 0.000000 -0.808557 0.588366 +vn 0.000000 0.808557 0.588366 +vn 0.000000 -0.899930 0.435957 +vn 0.000000 0.646168 0.763176 +vn 0.000000 0.995331 0.096469 +vn 0.000000 -0.951537 0.307505 +vn 0.103244 0.000000 0.994629 +vn 0.000000 0.374279 0.927305 +vn 0.000000 0.980468 0.196570 +vn 0.000000 -0.980468 0.196570 +vn 0.000000 -0.374279 0.927305 +vn 0.000000 0.951537 0.307505 +vn 0.000000 -0.995331 0.096469 +vn 0.000000 -0.646168 0.763146 +vn 0.000000 0.000000 1.000000 +vn -0.103244 0.000000 0.994629 +vn -0.043031 0.902280 0.428938 +vn -0.019105 -0.980956 0.193121 +vn -0.094913 -0.378796 0.920591 +vn -0.058535 0.812433 0.580096 +vn -0.076876 -0.651418 0.754784 +vn -0.076876 0.651418 0.754784 +vn -0.058535 -0.812433 0.580096 +vn -0.094913 0.378796 0.920591 +vn -0.019105 0.980956 0.193121 +vn -0.043031 -0.902280 0.428938 +vn -0.030152 0.952757 0.302225 +vn -0.030152 -0.952727 0.302225 +vn -0.085177 -0.909055 0.407819 +vn -0.211585 0.000000 0.977355 +vn -0.059511 0.956236 0.286386 +vn -0.059511 -0.956236 0.286386 +vn -0.085177 0.909055 0.407819 +vn -0.009156 -0.995422 0.094821 +vn -0.037690 -0.982421 0.182745 +vn -0.193121 -0.392499 0.899228 +vn -0.116550 0.823725 0.554857 +vn -0.154454 -0.667013 0.728843 +vn -0.154454 0.667013 0.728843 +vn -0.116550 -0.823725 0.554857 +vn -0.193121 0.392499 0.899228 +vn -0.009156 0.995422 0.094852 +vn -0.037690 0.982421 0.182775 +vn -0.173223 -0.841548 0.511643 +vn -0.297830 0.415723 0.859310 +vn -0.018159 0.995758 0.089908 +vn -0.055177 0.984619 0.165685 +vn -0.125462 -0.919523 0.372417 +vn -0.330424 0.000000 0.943815 +vn -0.087252 0.961608 0.260109 +vn -0.087252 -0.961608 0.260109 +vn -0.125462 0.919523 0.372417 +vn -0.018159 -0.995758 0.089908 +vn -0.055177 -0.984619 0.165654 +vn -0.297830 -0.415754 0.859310 +vn -0.173223 0.841548 0.511643 +vn -0.233192 -0.692373 0.682760 +vn -0.233192 0.692373 0.682791 +vn -0.312601 -0.726188 0.612262 +vn -0.312601 0.726188 0.612293 +vn -0.227241 -0.864162 0.448927 +vn -0.411817 0.448561 0.793176 +vn -0.026673 0.996277 0.081698 +vn -0.070925 0.987274 0.142216 +vn -0.162603 -0.932432 0.322642 +vn -0.465529 0.000000 0.885006 +vn -0.112369 0.968108 0.223853 +vn -0.112369 -0.968108 0.223884 +vn -0.162603 0.932432 0.322642 +vn -0.026673 -0.996277 0.081698 +vn -0.070925 -0.987274 0.142247 +vn -0.411817 -0.448561 0.793176 +vn -0.227241 0.864162 0.448927 +vn -0.195044 0.946013 0.258797 +vn -0.034425 -0.996918 0.070345 +vn -0.084323 -0.989990 0.112980 +vn -0.535539 -0.489547 0.688101 +vn -0.276437 0.888882 0.365307 +vn -0.390362 -0.765465 0.511521 +vn -0.390362 0.765435 0.511521 +vn -0.276437 -0.888882 0.365307 +vn -0.535539 0.489547 0.688101 +vn -0.034425 0.996918 0.070345 +vn -0.084323 0.989990 0.113010 +vn -0.195044 -0.946013 0.258797 +vn -0.620777 0.000000 0.783959 +vn -0.133854 0.974822 0.178259 +vn -0.133854 -0.974822 0.178289 +vn -0.789727 0.000000 0.613422 +vn -0.150700 0.980682 0.124516 +vn -0.150700 -0.980682 0.124516 +vn -0.220954 0.958129 0.181921 +vn -0.041139 -0.997559 0.056124 +vn -0.094790 -0.992370 0.078799 +vn -0.662038 -0.533647 0.526200 +vn -0.317423 0.911802 0.260353 +vn -0.460738 -0.804498 0.374737 +vn -0.460738 0.804498 0.374737 +vn -0.317423 -0.911802 0.260384 +vn -0.662038 0.533647 0.526200 +vn -0.041139 0.997559 0.056093 +vn -0.094790 0.992370 0.078799 +vn -0.220954 -0.958129 0.181951 +vn -0.345683 -0.928373 0.136296 +vn -0.767876 0.569903 0.292459 +vn -0.046510 0.998138 0.039369 +vn -0.101688 0.993957 0.040620 +vn -0.238197 -0.966613 0.094241 +vn -0.937864 0.000000 0.346965 +vn -0.161779 0.984710 0.064241 +vn -0.161748 -0.984710 0.064211 +vn -0.238197 0.966613 0.094272 +vn -0.046510 -0.998138 0.039369 +vn -0.101688 -0.993957 0.040620 +vn -0.767876 -0.569903 0.292459 +vn -0.345683 0.928373 0.136296 +vn -0.513047 -0.834559 0.200568 +vn -0.513047 0.834559 0.200598 +vn -0.050203 -0.998505 0.020417 +vn -0.050203 0.998505 0.020447 +vn -0.513047 0.834559 -0.200598 +vn -0.051546 0.998657 0.000000 +vn -0.050203 0.998505 -0.020417 +vn -0.101688 -0.993957 -0.040651 +vn -0.161779 0.984710 -0.064241 +vn -0.050203 -0.998505 -0.020447 +vn -0.513047 -0.834559 -0.200568 +vn -0.460738 0.804498 -0.374737 +vn -0.094790 0.992370 -0.078799 +vn -0.220954 0.958129 -0.181951 +vn -0.317423 0.911802 -0.260384 +vn -0.220954 -0.958129 -0.181921 +vn -0.041139 0.997559 -0.056154 +vn -0.133854 -0.974822 -0.178259 +vn -0.390362 -0.765465 -0.511521 +vn -0.195044 0.946013 -0.258797 +vn -0.034425 -0.996918 -0.070376 +vn -0.312601 -0.726188 -0.612262 +vn -0.162603 -0.932432 -0.322672 +vn -0.312601 0.726188 -0.612262 +vn -0.034425 0.996918 -0.070376 +vn -0.411817 0.448561 -0.793176 +vn -0.070925 -0.987274 -0.142216 +vn -0.055177 0.984619 -0.165654 +vn -0.297830 -0.415723 -0.859310 +vn -0.173223 0.841548 -0.511643 +vn -0.087252 -0.961608 -0.260109 +vn -0.297830 0.415723 -0.859310 +vn -0.330393 0.000000 -0.943815 +vn -0.193121 0.392499 -0.899228 +vn -0.059511 0.956236 -0.286386 +vn -0.018159 -0.995758 -0.089938 +vn -0.154454 -0.667013 -0.728813 +vn -0.116550 0.823725 -0.554826 +vn -0.009156 0.995422 -0.094821 +vn -0.211554 0.000000 -0.977355 +vn -0.094913 0.378796 -0.920591 +vn -0.019105 -0.980987 -0.193121 +vn -0.030152 0.952757 -0.302194 +vn 0.000000 -0.646168 -0.763146 +vn 0.000000 0.646168 -0.763146 +vn 0.000000 -0.374279 -0.927305 +vn 0.030152 -0.952757 -0.302225 +vn 0.019105 -0.980987 -0.193121 +vn 0.058535 0.812433 -0.580096 +vn 0.059511 0.956236 -0.286386 +vn 0.154454 -0.667013 -0.728813 +vn 0.154454 0.667013 -0.728843 +vn 0.116550 -0.823725 -0.554826 +vn 0.297830 0.415723 -0.859310 +vn 0.087252 -0.961608 -0.260140 +vn 0.297830 -0.415723 -0.859310 +vn 0.312601 -0.726188 -0.612293 +vn 0.026673 -0.996277 -0.081698 +vn 0.133854 -0.974822 -0.178259 +vn 0.195044 0.946013 -0.258827 +vn 0.034425 -0.996918 -0.070376 +vn 0.276437 0.888852 -0.365307 +vn 0.535539 0.489547 -0.688131 +vn 0.034425 0.996918 -0.070345 +vn 0.084323 0.989990 -0.112980 +vn 0.041139 0.997559 -0.056154 +vn 0.220954 -0.958129 -0.181951 +vn 0.150700 -0.980682 -0.124516 +vn 0.317423 0.911802 -0.260384 +vn 0.046510 0.998138 -0.039369 +vn 0.101688 0.993957 -0.040651 +vn 0.161748 -0.984710 -0.064211 +vn 0.513047 -0.834559 -0.200568 +vn 0.533006 0.846065 0.000000 +vn 0.050203 0.998505 -0.020417 +vn 0.050203 -0.998505 -0.020447 +vn 0.101688 -0.993957 0.040651 +vn 0.050203 -0.998505 0.020447 +vn 0.513047 -0.834559 0.200568 +vn 0.513047 0.834559 0.200598 +vn 0.050203 0.998505 0.020417 +vn 0.101688 0.993957 0.040651 +vn 0.662038 0.533647 0.526231 +vn 0.094790 0.992370 0.078799 +vn 0.220954 -0.958129 0.181921 +vn 0.460738 0.804498 0.374737 +vn 0.046510 0.998138 0.039399 +vn 0.041139 0.997559 0.056154 +vn 0.133854 -0.974822 0.178259 +vn 0.133854 0.974822 0.178289 +vn 0.195044 0.946013 0.258827 +vn 0.312601 0.726188 0.612262 +vn 0.112369 -0.968108 0.223853 +vn 0.411817 0.448561 0.793207 +vn 0.070925 -0.987274 0.142216 +vn 0.034425 -0.996918 0.070376 +vn 0.312601 -0.726188 0.612262 +vn 0.297830 -0.415723 0.859310 +vn 0.026673 -0.996277 0.081698 +vn 0.173223 0.841548 0.511643 +vn 0.087252 -0.961608 0.260140 +vn 0.055177 0.984619 0.165654 +vn 0.059511 -0.956236 0.286355 +vn 0.018159 -0.995758 0.089908 +vn 0.154454 -0.667013 0.728813 +vn 0.116550 -0.823725 0.554857 +vn 0.116550 0.823725 0.554826 +vn 0.043031 -0.902280 0.428968 +vn 0.030152 0.952757 0.302225 +vn 0.058535 -0.812433 0.580096 +vn 0.000000 -0.899960 0.435957 +vn 0.000000 0.646168 0.763146 +vn -0.058535 0.812433 0.580065 +vn -0.030152 -0.952757 0.302225 +vn -0.059511 0.956236 0.286355 +vn -0.116550 0.823725 0.554826 +vn -0.154454 -0.667013 0.728813 +vn -0.173223 -0.841548 0.511612 +vn -0.018159 0.995758 0.089877 +vn -0.330393 0.000000 0.943815 +vn -0.087252 -0.961608 0.260140 +vn -0.297830 -0.415723 0.859310 +vn -0.233192 -0.692373 0.682791 +vn -0.312601 -0.726188 0.612293 +vn -0.026673 0.996277 0.081668 +vn -0.162603 -0.932432 0.322672 +vn -0.112369 -0.968108 0.223853 +vn -0.070925 -0.987274 0.142216 +vn -0.195044 0.946013 0.258827 +vn -0.034425 -0.996918 0.070315 +vn -0.390362 0.765465 0.511521 +vn -0.084323 0.989990 0.112980 +vn -0.133854 0.974822 0.178289 +vn -0.133854 -0.974822 0.178259 +vn -0.150700 0.980682 0.124546 +vn -0.220954 0.958129 0.181951 +vn -0.317454 -0.911802 0.260353 +vn -0.041139 0.997559 0.056124 +vn -0.046510 0.998138 0.039399 +vn -0.101688 0.993957 0.040651 +vn -0.238197 -0.966613 0.094272 +vn -0.238197 0.966613 0.094241 +vn -0.513047 -0.834559 0.200598 +vn -0.050203 -0.998505 0.020447 +vn -0.050203 0.998505 0.020417 +usemtl Tooth +s 1 +f 4345//2909 4344//2910 4359//2911 +f 4340//2912 4339//2913 4354//2914 +f 4351//2915 4350//2916 4366//2917 +f 4346//2918 4345//2909 4360//2919 +f 4341//2920 4340//2912 4355//2921 +f 4352//2922 4351//2915 4367//2923 +f 4347//2924 4346//2918 4362//2925 +f 4342//2926 4341//2920 4356//2927 +f 4353//2928 4352//2922 4368//2929 +f 4348//2930 4347//2924 4363//2931 +f 4343//2932 4342//2926 4357//2933 +f 4349//2934 4348//2930 4364//2935 +f 4344//2910 4343//2932 4358//2936 +f 4350//2916 4349//2934 4365//2937 +f 4360//2919 4359//2911 4374//2938 +f 4355//2921 4354//2914 4369//2939 +f 4366//2917 4365//2937 4381//2940 +f 4361//2941 4360//2919 4375//2942 +f 4356//2927 4355//2921 4370//2943 +f 4367//2923 4366//2917 4382//2944 +f 4362//2925 4361//2941 4377//2945 +f 4357//2933 4356//2927 4371//2946 +f 4368//2929 4367//2923 4383//2947 +f 4363//2931 4362//2925 4378//2948 +f 4358//2936 4357//2933 4372//2949 +f 4364//2935 4363//2931 4379//2950 +f 4359//2911 4358//2936 4373//2951 +f 4365//2937 4364//2935 4380//2952 +f 4379//2950 4378//2948 4394//2953 +f 4374//2938 4373//2951 4388//2954 +f 4380//2952 4379//2950 4395//2955 +f 4375//2942 4374//2938 4389//2956 +f 4370//2943 4369//2939 4384//2957 +f 4381//2940 4380//2952 4396//2958 +f 4376//2959 4375//2942 4390//2960 +f 4371//2946 4370//2943 4385//2961 +f 4382//2944 4381//2940 4397//2962 +f 4377//2945 4376//2959 4392//2963 +f 4372//2949 4371//2946 4386//2964 +f 4383//2947 4382//2944 4398//2965 +f 4378//2948 4377//2945 4393//2966 +f 4373//2951 4372//2949 4387//2967 +f 4398//2965 4397//2962 4413//2968 +f 4393//2966 4392//2963 4408//2969 +f 4388//2954 4387//2967 4402//2970 +f 4394//2953 4393//2966 4409//2971 +f 4389//2956 4388//2954 4403//2972 +f 4395//2955 4394//2953 4410//2973 +f 4390//2960 4389//2956 4404//2974 +f 4385//2961 4384//2957 4399//2975 +f 4396//2958 4395//2955 4411//2976 +f 4391//2977 4390//2960 4405//2978 +f 4386//2964 4385//2961 4400//2979 +f 4397//2962 4396//2958 4412//2980 +f 4392//2963 4391//2977 4407//2981 +f 4387//2967 4386//2964 4401//2982 +f 4401//2982 4400//2979 4415//2983 +f 4412//2980 4411//2976 4427//2984 +f 4407//2981 4406//2985 4422//2986 +f 4402//2970 4401//2982 4416//2987 +f 4413//2968 4412//2980 4428//2988 +f 4408//2969 4407//2981 4423//2989 +f 4403//2972 4402//2970 4417//2990 +f 4409//2971 4408//2969 4424//2991 +f 4404//2974 4403//2972 4418//2992 +f 4410//2973 4409//2971 4425//2993 +f 4405//2978 4404//2974 4419//2994 +f 4400//2979 4399//2975 4414//2995 +f 4411//2976 4410//2973 4426//2996 +f 4406//2985 4405//2978 4420//2997 +f 4420//2997 4419//2994 4434//2998 +f 4415//2983 4414//2995 4429//2999 +f 4426//2996 4425//2993 4441//3000 +f 4421//3001 4420//2997 4435//3002 +f 4416//2987 4415//2983 4430//3003 +f 4427//2984 4426//2996 4442//3004 +f 4422//2986 4421//3001 4437//3005 +f 4417//2990 4416//2987 4431//3006 +f 4428//2988 4427//2984 4443//3007 +f 4423//2989 4422//2986 4438//3008 +f 4418//2992 4417//2990 4432//3009 +f 4424//2991 4423//2989 4439//3010 +f 4419//2994 4418//2992 4433//3011 +f 4425//2993 4424//2991 4440//3012 +f 4439//3010 4438//3008 4454//3013 +f 4434//2998 4433//3011 4448//3014 +f 4440//3012 4439//3010 4455//3015 +f 4435//3002 4434//2998 4449//3016 +f 4430//3003 4429//2999 4444//3017 +f 4441//3000 4440//3012 4456//3018 +f 4436//3019 4435//3002 4450//3020 +f 4431//3006 4430//3003 4445//3021 +f 4442//3004 4441//3000 4457//3022 +f 4437//3005 4436//3019 4452//3023 +f 4432//3009 4431//3006 4446//3024 +f 4443//3007 4442//3004 4458//3025 +f 4438//3008 4437//3005 4453//3026 +f 4433//3011 4432//3009 4447//3027 +f 4458//3025 4457//3022 4473//3028 +f 4453//3026 4452//3023 4468//3029 +f 4448//3014 4447//3027 4462//3030 +f 4454//3013 4453//3026 4469//3031 +f 4449//3016 4448//3014 4463//3032 +f 4455//3015 4454//3013 4470//3033 +f 4450//3020 4449//3016 4464//3034 +f 4445//3021 4444//3017 4459//3035 +f 4456//3018 4455//3015 4471//3036 +f 4451//3037 4450//3020 4465//3038 +f 4446//3024 4445//3021 4460//3039 +f 4457//3022 4456//3018 4472//3040 +f 4452//3023 4451//3037 4467//3041 +f 4447//3027 4446//3024 4461//3042 +f 4472//3040 4471//3036 4486//3043 +f 4467//3041 4466//3044 4481//3045 +f 4462//3030 4461//3042 4477//3046 +f 4473//3028 4472//3040 4487//3047 +f 4468//3029 4467//3041 4482//3048 +f 4463//3032 4462//3030 4478//3049 +f 4469//3031 4468//3029 4483//3050 +f 4464//3034 4463//3032 4479//3051 +f 4470//3033 4469//3031 4484//3052 +f 4465//3038 4464//3034 4480//3053 +f 4460//3039 4459//3035 4475//3054 +f 4471//3036 4470//3033 4485//3055 +f 4466//3044 4465//3038 4481//3045 +f 4461//3042 4460//3039 4476//3056 +f 4475//3054 4474//3057 4490//3058 +f 4486//3043 4485//3055 4500//3059 +f 4481//3045 4480//3053 4496//3060 +f 4476//3056 4475//3054 4491//3061 +f 4487//3047 4486//3043 4501//3062 +f 4482//3048 4481//3045 4496//3060 +f 4477//3046 4476//3056 4492//3063 +f 4488//3064 4487//3047 4502//3065 +f 4483//3050 4482//3048 4497//3066 +f 4478//3049 4477//3046 4493//3067 +f 4484//3052 4483//3050 4498//3068 +f 4479//3051 4478//3049 4494//3069 +f 4485//3055 4484//3052 4499//3070 +f 4480//3053 4479//3051 4495//3071 +f 4494//3069 4493//3067 4509//3072 +f 4500//3059 4499//3070 4514//3073 +f 4495//3071 4494//3069 4510//3074 +f 4490//3058 4489//3075 4505//3076 +f 4501//3062 4500//3059 4515//3077 +f 4496//3060 4495//3071 4511//3078 +f 4491//3061 4490//3058 4506//3079 +f 4502//3065 4501//3062 4516//3080 +f 4497//3066 4496//3060 4511//3078 +f 4492//3063 4491//3061 4507//3081 +f 4503//3082 4502//3065 4517//3083 +f 4498//3068 4497//3066 4512//3084 +f 4493//3067 4492//3063 4508//3085 +f 4499//3070 4498//3068 4513//3086 +f 4513//3086 4512//3084 4527//3087 +f 4508//3085 4507//3081 4523//3088 +f 4514//3073 4513//3086 4528//3089 +f 4509//3072 4508//3085 4524//3090 +f 4515//3077 4514//3073 4529//3091 +f 4510//3074 4509//3072 4525//3092 +f 4505//3076 4504//3093 4520//3094 +f 4516//3080 4515//3077 4530//3095 +f 4511//3078 4510//3074 4526//3096 +f 4506//3079 4505//3076 4521//3097 +f 4517//3083 4516//3080 4531//3098 +f 4512//3084 4511//3078 4526//3096 +f 4507//3081 4506//3079 4522//3099 +f 4518//3100 4517//3083 4532//3101 +f 4532//3101 4531//3098 4546//3102 +f 4527//3087 4526//3096 4541//3103 +f 4522//3099 4521//3097 4537//3104 +f 4533//3105 4532//3101 4547//3106 +f 4528//3089 4527//3087 4542//3107 +f 4523//3088 4522//3099 4538//3108 +f 4529//3091 4528//3089 4543//3109 +f 4524//3090 4523//3088 4539//3110 +f 4530//3095 4529//3091 4544//3111 +f 4525//3092 4524//3090 4540//3112 +f 4520//3094 4519//3113 4535//3114 +f 4531//3098 4530//3095 4545//3115 +f 4526//3096 4525//3092 4541//3103 +f 4521//3097 4520//3094 4536//3116 +f 4535//3114 4534//3117 4550//3118 +f 4546//3102 4545//3115 4560//3119 +f 4541//3103 4540//3112 4556//3120 +f 4536//3116 4535//3114 4551//3121 +f 4547//3106 4546//3102 4561//3122 +f 4542//3107 4541//3103 4556//3120 +f 4537//3104 4536//3116 4552//3123 +f 4548//3124 4547//3106 4562//3125 +f 4543//3109 4542//3107 4557//3126 +f 4538//3108 4537//3104 4553//3127 +f 4544//3111 4543//3109 4558//3128 +f 4539//3110 4538//3108 4554//3129 +f 4545//3115 4544//3111 4559//3130 +f 4540//3112 4539//3110 4555//3131 +f 4554//3129 4553//3127 4569//3132 +f 4560//3119 4559//3130 4574//3133 +f 4555//3131 4554//3129 4570//3134 +f 4550//3118 4549//3135 4565//3136 +f 4561//3122 4560//3119 4575//3137 +f 4556//3120 4555//3131 4571//3138 +f 4551//3121 4550//3118 4566//3139 +f 4562//3125 4561//3122 4576//3140 +f 4557//3126 4556//3120 4571//3138 +f 4552//3123 4551//3121 4567//3141 +f 4563//3142 4562//3125 4577//3143 +f 4558//3128 4557//3126 4572//3144 +f 4553//3127 4552//3123 4568//3145 +f 4559//3130 4558//3128 4573//3146 +f 4573//3146 4572//3144 4587//3147 +f 4568//3145 4567//3141 4583//3148 +f 4574//3133 4573//3146 4588//3149 +f 4569//3132 4568//3145 4584//3150 +f 4575//3137 4574//3133 4589//3151 +f 4570//3134 4569//3132 4585//3152 +f 4565//3136 4564//3153 4580//3154 +f 4576//3140 4575//3137 4590//3155 +f 4571//3138 4570//3134 4586//261 +f 4566//3139 4565//3136 4581//3156 +f 4577//3143 4576//3140 4591//3157 +f 4572//3144 4571//3138 4586//261 +f 4567//3141 4566//3139 4582//3158 +f 4578//3159 4577//3143 4592//3160 +f 4592//3160 4591//3157 4607//3161 +f 4587//3147 4586//261 4602//3162 +f 4582//3158 4581//3156 4596//3163 +f 4593//3164 4592//3160 4608//3165 +f 4588//3149 4587//3147 4603//3166 +f 4583//3148 4582//3158 4597//3167 +f 4589//3151 4588//3149 4604//3168 +f 4584//3150 4583//3148 4598//3169 +f 4590//3155 4589//3151 4605//3170 +f 4585//3152 4584//3150 4599//3171 +f 4580//3154 4579//3172 4594//3173 +f 4591//3157 4590//3155 4606//3174 +f 4586//261 4585//3152 4600//3175 +f 4581//3156 4580//3154 4595//3176 +f 4606//3174 4605//3170 4621//3177 +f 4601//3178 4600//3175 4615//3179 +f 4596//3163 4595//3176 4610//3180 +f 4607//3161 4606//3174 4622//3181 +f 4602//3162 4601//3178 4617//3182 +f 4597//3167 4596//3163 4611//3183 +f 4608//3165 4607//3161 4623//3184 +f 4603//3166 4602//3162 4618//3185 +f 4598//3169 4597//3167 4612//3186 +f 4604//3168 4603//3166 4619//3187 +f 4599//3171 4598//3169 4613//3188 +f 4605//3170 4604//3168 4620//3189 +f 4600//3175 4599//3171 4614//3190 +f 4595//3176 4594//3173 4609//3191 +f 4620//3189 4619//3187 4635//3192 +f 4615//3179 4614//3190 4629//3193 +f 4610//3180 4609//3191 4624//3194 +f 4621//3177 4620//3189 4636//3195 +f 4616//3196 4615//3179 4630//3197 +f 4611//3183 4610//3180 4625//3198 +f 4622//3181 4621//3177 4637//3199 +f 4617//3182 4616//3196 4632//3200 +f 4612//3186 4611//3183 4626//3201 +f 4623//3184 4622//3181 4638//3202 +f 4618//3185 4617//3182 4633//3203 +f 4613//3188 4612//3186 4627//3204 +f 4619//3187 4618//3185 4634//3205 +f 4614//3190 4613//3188 4628//3206 +f 4628//3206 4627//3204 4642//3207 +f 4634//3205 4633//3203 4649//3208 +f 4629//3193 4628//3206 4643//3209 +f 4635//3192 4634//3205 4650//3210 +f 4630//3197 4629//3193 4644//3211 +f 4625//3198 4624//3194 4639//3212 +f 4636//3195 4635//3192 4651//3213 +f 4631//3214 4630//3197 4645//3215 +f 4626//3201 4625//3198 4640//3216 +f 4637//3199 4636//3195 4652//3217 +f 4632//3200 4631//3214 4647//3218 +f 4627//3204 4626//3201 4641//3219 +f 4638//3202 4637//3199 4653//3220 +f 4633//3203 4632//3200 4648//3221 +f 4647//3218 4646//3222 4662//3223 +f 4642//3207 4641//3219 4656//3224 +f 4653//3220 4652//3217 4668//3225 +f 4648//3221 4647//3218 4663//3226 +f 4643//3209 4642//3207 4657//3227 +f 4649//3208 4648//3221 4664//3228 +f 4644//3211 4643//3209 4658//3229 +f 4650//3210 4649//3208 4665//3230 +f 4645//3215 4644//3211 4659//3231 +f 4640//3216 4639//3212 4654//3232 +f 4651//3213 4650//3210 4666//3233 +f 4646//3222 4645//3215 4660//3234 +f 4641//3219 4640//3216 4655//3235 +f 4652//3217 4651//3213 4667//3236 +f 4666//3233 4665//3230 4682//3237 +f 4661//3238 4660//3234 4676//3239 +f 4656//3224 4655//3235 4671//3240 +f 4667//3236 4666//3233 4683//3241 +f 4662//3223 4661//3238 4678//3242 +f 4657//3227 4656//3224 4672//3243 +f 4668//3225 4667//3236 4684//3244 +f 4663//3226 4662//3223 4679//3245 +f 4658//3229 4657//3227 4673//3246 +f 4664//3228 4663//3226 4680//3247 +f 4659//3231 4658//3229 4674//3248 +f 4665//3230 4664//3228 4681//3249 +f 4660//3234 4659//3231 4675//3250 +f 4655//3235 4654//3232 4670//3251 +f 4681//3249 4680//3247 4696//3252 +f 4676//3239 4675//3250 4690//3253 +f 4671//3240 4670//3251 4685//3254 +f 4682//3237 4681//3249 4697//3255 +f 4677//3256 4676//3239 4691//3257 +f 4672//3243 4671//3240 4686//3258 +f 4683//3241 4682//3237 4698//3259 +f 4678//3242 4677//3256 4693//3260 +f 4673//3246 4672//3243 4687//3261 +f 4684//3244 4683//3241 4699//3262 +f 4679//3245 4678//3242 4694//3263 +f 4674//3248 4673//3246 4688//3264 +f 4680//3247 4679//3245 4695//3265 +f 4675//3250 4674//3248 4689//3266 +f 4689//3266 4688//3264 4703//3267 +f 4695//3265 4694//3263 4710//3268 +f 4690//3253 4689//3266 4704//3269 +f 4696//3252 4695//3265 4711//3270 +f 4691//3257 4690//3253 4705//3271 +f 4686//3258 4685//3254 4700//3272 +f 4697//3255 4696//3252 4712//3273 +f 4692//3274 4691//3257 4706//3275 +f 4687//3261 4686//3258 4701//3276 +f 4698//3259 4697//3255 4713//3277 +f 4693//3260 4692//3274 4708//3278 +f 4688//3264 4687//3261 4702//3279 +f 4699//3262 4698//3259 4714//3280 +f 4694//3263 4693//3260 4709//3281 +f 4708//3278 4707//3282 4722//3283 +f 4703//3267 4702//3279 4718//3284 +f 4714//3280 4713//3277 4728//3285 +f 4709//3281 4708//3278 4723//3286 +f 4704//3269 4703//3267 4719//3287 +f 4710//3268 4709//3281 4724//3288 +f 4705//3271 4704//3269 4720//3289 +f 4711//3270 4710//3268 4725//3290 +f 4706//3275 4705//3271 4721//3291 +f 4701//3276 4700//3272 4716//3292 +f 4712//3273 4711//3270 4726//3293 +f 4707//3282 4706//3275 4722//3283 +f 4702//3279 4701//3276 4717//3294 +f 4713//3277 4712//3273 4727//3295 +f 4727//3295 4726//3293 4741//3296 +f 4722//3283 4721//3291 4737//3297 +f 4717//3294 4716//3292 4732//3298 +f 4728//3285 4727//3295 4742//3299 +f 4723//3286 4722//3283 4737//3297 +f 4718//3284 4717//3294 4733//3300 +f 4729//3301 4728//3285 4743//3302 +f 4724//3288 4723//3286 4738//3303 +f 4719//3287 4718//3284 4734//3304 +f 4725//3290 4724//3288 4739//3305 +f 4720//3289 4719//3287 4735//3306 +f 4726//3293 4725//3290 4740//3307 +f 4721//3291 4720//3289 4736//3308 +f 4716//3292 4715//3309 4731//3310 +f 4741//3296 4740//3307 4755//3311 +f 4736//3308 4735//3306 4751//3312 +f 4731//3310 4730//3313 4746//3314 +f 4742//3299 4741//3296 4756//3315 +f 4737//3297 4736//3308 4752//3316 +f 4732//3298 4731//3310 4747//3317 +f 4743//3302 4742//3299 4757//3318 +f 4738//3303 4737//3297 4752//3316 +f 4733//3300 4732//3298 4748//3319 +f 4744//3320 4743//3302 4758//3321 +f 4739//3305 4738//3303 4753//3322 +f 4734//3304 4733//3300 4749//3323 +f 4740//3307 4739//3305 4754//3324 +f 4735//3306 4734//3304 4750//3325 +f 4755//3311 4754//3324 4769//3326 +f 4750//3325 4749//3323 4765//3327 +f 4756//3315 4755//3311 4770//3328 +f 4751//3312 4750//3325 4766//3329 +f 4746//3314 4745//3330 4761//3331 +f 4757//3318 4756//3315 4771//3332 +f 4752//3316 4751//3312 4767//3333 +f 4747//3317 4746//3314 4762//3334 +f 4758//3321 4757//3318 4772//3335 +f 4753//3322 4752//3316 4767//3333 +f 4748//3319 4747//3317 4763//3336 +f 4759//3337 4758//3321 4773//3338 +f 4754//3324 4753//3322 4768//3339 +f 4749//3323 4748//3319 4764//3340 +f 4763//3336 4762//3334 4778//3341 +f 4774//3342 4773//3338 4788//3343 +f 4769//3326 4768//3339 4783//3344 +f 4764//3340 4763//3336 4779//3345 +f 4770//3328 4769//3326 4784//3346 +f 4765//3327 4764//3340 4780//3347 +f 4771//3332 4770//3328 4785//3348 +f 4766//3329 4765//3327 4781//3349 +f 4761//3331 4760//3350 4776//3351 +f 4772//3335 4771//3332 4786//3352 +f 4767//3333 4766//3329 4782//3353 +f 4762//3334 4761//3331 4777//3354 +f 4773//3338 4772//3335 4787//3355 +f 4768//3339 4767//3333 4782//3353 +f 4782//3353 4781//3349 4798//3356 +f 4777//3354 4776//3351 4793//3357 +f 4788//3343 4787//3355 4803//3358 +f 4783//3344 4782//3353 4798//3356 +f 4778//3341 4777//3354 4794//3359 +f 4789//3360 4788//3343 4804//3361 +f 4784//3346 4783//3344 4799//3362 +f 4779//3345 4778//3341 4795//3363 +f 4785//3348 4784//3346 4800//3364 +f 4780//3347 4779//3345 4796//3365 +f 4786//3352 4785//3348 4801//3366 +f 4781//3349 4780//3347 4797//3367 +f 4776//3351 4775//3368 4792//3369 +f 4787//3355 4786//3352 4802//3370 +f 4802//3370 4801//3366 4816//3371 +f 4797//3367 4796//3365 4812//3372 +f 4792//3369 4791//3373 4807//3374 +f 4803//3358 4802//3370 4817//3375 +f 4798//3356 4797//3367 4813//3376 +f 4793//3357 4792//3369 4808//3377 +f 4804//3361 4803//3358 4818//3378 +f 4799//3362 4798//3356 4813//3376 +f 4794//3359 4793//3357 4809//3379 +f 4805//3380 4804//3361 4819//3381 +f 4800//3364 4799//3362 4814//3382 +f 4795//3363 4794//3359 4810//3383 +f 4801//3366 4800//3364 4815//3384 +f 4796//3365 4795//3363 4811//3385 +f 4669//364 4353//2928 4368//2929 +f 4339//2913 4790//124 4354//2914 +f 4669//364 4368//2929 4383//2947 +f 4354//2914 4790//124 4369//2939 +f 4369//2939 4790//124 4384//2957 +f 4669//364 4383//2947 4398//2965 +f 4669//364 4398//2965 4413//2968 +f 4384//2957 4790//124 4399//2975 +f 4669//364 4413//2968 4428//2988 +f 4399//2975 4790//124 4414//2995 +f 4669//364 4428//2988 4443//3007 +f 4414//2995 4790//124 4429//2999 +f 4429//2999 4790//124 4444//3017 +f 4669//364 4443//3007 4458//3025 +f 4669//364 4458//3025 4473//3028 +f 4444//3017 4790//124 4459//3035 +f 4669//364 4473//3028 4488//3064 +f 4459//3035 4790//124 4474//3057 +f 4669//364 4488//3064 4503//3082 +f 4474//3057 4790//124 4489//3075 +f 4489//3075 4790//124 4504//3093 +f 4669//364 4503//3082 4518//3100 +f 4669//364 4518//3100 4533//3105 +f 4504//3093 4790//124 4519//3113 +f 4669//364 4533//3105 4548//3124 +f 4519//3113 4790//124 4534//3117 +f 4669//364 4548//3124 4563//3142 +f 4534//3117 4790//124 4549//3135 +f 4549//3135 4790//124 4564//3153 +f 4669//364 4563//3142 4578//3159 +f 4669//364 4578//3159 4593//3164 +f 4564//3153 4790//124 4579//3172 +f 4669//364 4593//3164 4608//3165 +f 4579//3172 4790//124 4594//3173 +f 4669//364 4608//3165 4623//3184 +f 4594//3173 4790//124 4609//3191 +f 4609//3191 4790//124 4624//3194 +f 4669//364 4623//3184 4638//3202 +f 4669//364 4638//3202 4653//3220 +f 4624//3194 4790//124 4639//3212 +f 4669//364 4653//3220 4668//3225 +f 4639//3212 4790//124 4654//3232 +f 4669//364 4668//3225 4684//3244 +f 4654//3232 4790//124 4670//3251 +f 4670//3251 4790//124 4685//3254 +f 4669//364 4684//3244 4699//3262 +f 4669//364 4699//3262 4714//3280 +f 4685//3254 4790//124 4700//3272 +f 4669//364 4714//3280 4729//3301 +f 4700//3272 4790//124 4715//3309 +f 4669//364 4729//3301 4744//3320 +f 4715//3309 4790//124 4730//3313 +f 4669//364 4744//3320 4759//3337 +f 4730//3313 4790//124 4745//3330 +f 4669//364 4759//3337 4774//3342 +f 4745//3330 4790//124 4760//3350 +f 4669//364 4774//3342 4789//3360 +f 4760//3350 4790//124 4775//3368 +f 4669//364 4789//3360 4805//3380 +f 4775//3368 4790//124 4791//3373 +f 4669//364 4805//3380 4820//3386 +f 4791//3373 4790//124 4806//3387 +f 4669//364 4820//3386 4353//2928 +f 4816//3371 4815//3384 4348//2930 +f 4811//3385 4810//3383 4344//2910 +f 4806//3387 4790//124 4339//2913 +f 4817//3375 4816//3371 4349//2934 +f 4812//3372 4811//3385 4345//2909 +f 4807//3374 4806//3387 4340//2912 +f 4818//3378 4817//3375 4350//2916 +f 4813//3376 4812//3372 4346//2918 +f 4808//3377 4807//3374 4341//2920 +f 4819//3381 4818//3378 4351//2915 +f 4814//3382 4813//3376 4346//2918 +f 4809//3379 4808//3377 4342//2926 +f 4820//3386 4819//3381 4352//2922 +f 4815//3384 4814//3382 4347//2924 +f 4810//3383 4809//3379 4343//2932 +f 4827//2909 4826//2910 4841//3388 +f 4822//2912 4821//3389 4836//3390 +f 4833//2915 4832//2916 4848//2917 +f 4828//5 4827//2909 4842//2919 +f 4823//2920 4822//2912 4837//2921 +f 4834//2922 4833//2915 4849//3391 +f 4829//2924 4828//5 4844//2925 +f 4824//2926 4823//2920 4838//3392 +f 4835//2928 4834//2922 4850//3393 +f 4830//2930 4829//2924 4845//3394 +f 4825//2932 4824//2926 4839//2933 +f 4831//2934 4830//2930 4846//2935 +f 4826//2910 4825//2932 4840//2936 +f 4832//2916 4831//2934 4847//2937 +f 4842//2919 4841//3388 4856//3395 +f 4837//2921 4836//3390 4851//2939 +f 4848//2917 4847//2937 4863//2940 +f 4843//2941 4842//2919 4857//2942 +f 4838//3392 4837//2921 4852//3396 +f 4849//3391 4848//2917 4864//2944 +f 4844//2925 4843//2941 4859//2945 +f 4839//2933 4838//3392 4853//2946 +f 4850//3393 4849//3391 4865//2947 +f 4845//3394 4844//2925 4860//2948 +f 4840//2936 4839//2933 4854//3397 +f 4846//2935 4845//3394 4861//2950 +f 4841//3388 4840//2936 4855//3398 +f 4847//2937 4846//2935 4862//3399 +f 4861//2950 4860//2948 4876//2953 +f 4856//3395 4855//3398 4870//2954 +f 4862//3399 4861//2950 4877//2955 +f 4857//2942 4856//3395 4871//2956 +f 4852//3396 4851//2939 4866//3400 +f 4863//2940 4862//3399 4878//3401 +f 4858//2959 4857//2942 4872//2960 +f 4853//2946 4852//3396 4867//2961 +f 4864//2944 4863//2940 4879//2962 +f 4859//2945 4858//2959 4874//2963 +f 4854//3397 4853//2946 4868//2964 +f 4865//2947 4864//2944 4880//2965 +f 4860//2948 4859//2945 4875//3402 +f 4855//3398 4854//3397 4869//3403 +f 4880//2965 4879//2962 4895//3404 +f 4875//3402 4874//2963 4890//3405 +f 4870//2954 4869//3403 4884//2970 +f 4876//2953 4875//3402 4891//2971 +f 4871//2956 4870//2954 4885//2972 +f 4877//2955 4876//2953 4892//3406 +f 4872//2960 4871//2956 4886//3407 +f 4867//2961 4866//3400 4881//3408 +f 4878//3401 4877//2955 4893//2976 +f 4873//2977 4872//2960 4887//3409 +f 4868//2964 4867//2961 4882//2979 +f 4879//2962 4878//3401 4894//3410 +f 4874//2963 4873//2977 4889//2981 +f 4869//3403 4868//2964 4883//2982 +f 4883//2982 4882//2979 4897//3411 +f 4894//3410 4893//2976 4909//2984 +f 4889//2981 4888//2985 4904//3412 +f 4884//2970 4883//2982 4898//2987 +f 4895//3404 4894//3410 4910//2988 +f 4890//3405 4889//2981 4905//2989 +f 4885//2972 4884//2970 4899//2990 +f 4891//2971 4890//3405 4906//2991 +f 4886//3407 4885//2972 4900//3413 +f 4892//3406 4891//2971 4907//2993 +f 4887//3409 4886//3407 4901//2994 +f 4882//2979 4881//3408 4896//2995 +f 4893//2976 4892//3406 4908//3414 +f 4888//2985 4887//3409 4902//3415 +f 4902//3415 4901//2994 4916//2998 +f 4897//3411 4896//2995 4911//2999 +f 4908//3414 4907//2993 4923//3000 +f 4903//3416 4902//3415 4917//3417 +f 4898//2987 4897//3411 4912//3003 +f 4909//2984 4908//3414 4924//3004 +f 4904//3412 4903//3416 4919//3005 +f 4899//2990 4898//2987 4913//3418 +f 4910//2988 4909//2984 4925//3419 +f 4905//2989 4904//3412 4920//3420 +f 4900//3413 4899//2990 4914//3009 +f 4906//2991 4905//2989 4921//3010 +f 4901//2994 4900//3413 4915//3421 +f 4907//2993 4906//2991 4922//3012 +f 4921//3010 4920//3420 4936//3013 +f 4916//2998 4915//3421 4930//3014 +f 4922//3012 4921//3010 4937//3015 +f 4917//3417 4916//2998 4931//3016 +f 4912//3003 4911//2999 4926//3422 +f 4923//3000 4922//3012 4938//3018 +f 4918//3423 4917//3417 4932//3424 +f 4913//3418 4912//3003 4927//3021 +f 4924//3004 4923//3000 4939//3425 +f 4919//3005 4918//3423 4934//3023 +f 4914//3009 4913//3418 4928//3426 +f 4925//3419 4924//3004 4940//3025 +f 4920//3420 4919//3005 4935//3026 +f 4915//3421 4914//3009 4929//3027 +f 4940//3025 4939//3425 4955//3028 +f 4935//3026 4934//3023 4950//3427 +f 4930//3014 4929//3027 4944//3030 +f 4936//3013 4935//3026 4951//3031 +f 4931//3016 4930//3014 4945//3032 +f 4937//3015 4936//3013 4952//3033 +f 4932//3424 4931//3016 4946//3428 +f 4927//3021 4926//3422 4941//3035 +f 4938//3018 4937//3015 4953//3036 +f 4933//3037 4932//3424 4947//3038 +f 4928//3426 4927//3021 4942//3039 +f 4939//3425 4938//3018 4954//3040 +f 4934//3023 4933//3037 4949//3429 +f 4929//3027 4928//3426 4943//3042 +f 4954//3040 4953//3036 4968//3430 +f 4949//3429 4948//480 4963//3045 +f 4944//3030 4943//3042 4959//3046 +f 4955//3028 4954//3040 4969//3431 +f 4950//3427 4949//3429 4964//3048 +f 4945//3032 4944//3030 4960//3432 +f 4951//3031 4950//3427 4965//3050 +f 4946//3428 4945//3032 4961//3051 +f 4952//3033 4951//3031 4966//3052 +f 4947//3038 4946//3428 4962//3053 +f 4942//3039 4941//3035 4957//3054 +f 4953//3036 4952//3033 4967//3055 +f 4948//480 4947//3038 4963//3045 +f 4943//3042 4942//3039 4958//3056 +f 4957//3054 4956//3057 4972//3058 +f 4968//3430 4967//3055 4982//3059 +f 4963//3045 4962//3053 4978//3060 +f 4958//3056 4957//3054 4973//3433 +f 4969//3431 4968//3430 4983//3062 +f 4964//3048 4963//3045 4978//3060 +f 4959//3046 4958//3056 4974//3063 +f 4970//3064 4969//3431 4984//3065 +f 4965//3050 4964//3048 4979//3066 +f 4960//3432 4959//3046 4975//3067 +f 4966//3052 4965//3050 4980//3434 +f 4961//3051 4960//3432 4976//3435 +f 4967//3055 4966//3052 4981//3436 +f 4962//3053 4961//3051 4977//3071 +f 4976//3435 4975//3067 4991//3072 +f 4982//3059 4981//3436 4996//3073 +f 4977//3071 4976//3435 4992//3437 +f 4972//3058 4971//3075 4987//3076 +f 4983//3062 4982//3059 4997//3077 +f 4978//3060 4977//3071 4993//3078 +f 4973//3433 4972//3058 4988//3079 +f 4984//3065 4983//3062 4998//3438 +f 4979//3066 4978//3060 4993//3078 +f 4974//3063 4973//3433 4989//3081 +f 4985//3082 4984//3065 4999//3083 +f 4980//3434 4979//3066 4994//3439 +f 4975//3067 4974//3063 4990//3085 +f 4981//3436 4980//3434 4995//3086 +f 4995//3086 4994//3439 5009//3087 +f 4990//3085 4989//3081 5005//3088 +f 4996//3073 4995//3086 5010//3440 +f 4991//3072 4990//3085 5006//3090 +f 4997//3077 4996//3073 5011//3091 +f 4992//3437 4991//3072 5007//3092 +f 4987//3076 4986//3093 5002//3094 +f 4998//3438 4997//3077 5012//3095 +f 4993//3078 4992//3437 5008//3096 +f 4988//3079 4987//3076 5003//3097 +f 4999//3083 4998//3438 5013//3098 +f 4994//3439 4993//3078 5008//3096 +f 4989//3081 4988//3079 5004//3099 +f 5000//3441 4999//3083 5014//3101 +f 5014//3101 5013//3098 5028//3442 +f 5009//3087 5008//3096 5023//3103 +f 5004//3099 5003//3097 5019//3443 +f 5015//3444 5014//3101 5029//3106 +f 5010//3440 5009//3087 5024//3107 +f 5005//3088 5004//3099 5020//3445 +f 5011//3091 5010//3440 5025//3109 +f 5006//3090 5005//3088 5021//3110 +f 5012//3095 5011//3091 5026//3111 +f 5007//3092 5006//3090 5022//3446 +f 5002//3094 5001//3447 5017//3448 +f 5013//3098 5012//3095 5027//3115 +f 5008//3096 5007//3092 5023//3103 +f 5003//3097 5002//3094 5018//3116 +f 5017//3448 5016//3449 5032//3118 +f 5028//3442 5027//3115 5042//3450 +f 5023//3103 5022//3446 5038//3120 +f 5018//3116 5017//3448 5033//3121 +f 5029//3106 5028//3442 5043//3451 +f 5024//3107 5023//3103 5038//3120 +f 5019//3443 5018//3116 5034//3123 +f 5030//3124 5029//3106 5044//3125 +f 5025//3109 5024//3107 5039//3126 +f 5020//3445 5019//3443 5035//3452 +f 5026//3111 5025//3109 5040//3128 +f 5021//3110 5020//3445 5036//3129 +f 5027//3115 5026//3111 5041//3130 +f 5022//3446 5021//3110 5037//3131 +f 5036//3129 5035//3452 5051//3132 +f 5042//3450 5041//3130 5056//3133 +f 5037//3131 5036//3129 5052//3134 +f 5032//3118 5031//3453 5047//3454 +f 5043//3451 5042//3450 5057//3137 +f 5038//3120 5037//3131 5053//3138 +f 5033//3121 5032//3118 5048//3139 +f 5044//3125 5043//3451 5058//3455 +f 5039//3126 5038//3120 5053//3138 +f 5034//3123 5033//3121 5049//3141 +f 5045//3142 5044//3125 5059//3143 +f 5040//3128 5039//3126 5054//3144 +f 5035//3452 5034//3123 5050//3145 +f 5041//3130 5040//3128 5055//3456 +f 5055//3456 5054//3144 5069//3147 +f 5050//3145 5049//3141 5065//3148 +f 5056//3133 5055//3456 5070//3149 +f 5051//3132 5050//3145 5066//3457 +f 5057//3137 5056//3133 5071//3151 +f 5052//3134 5051//3132 5067//3152 +f 5047//3454 5046//3458 5062//3154 +f 5058//3455 5057//3137 5072//3155 +f 5053//3138 5052//3134 5068//261 +f 5048//3139 5047//3454 5063//3156 +f 5059//3143 5058//3455 5073//3157 +f 5054//3144 5053//3138 5068//261 +f 5049//3141 5048//3139 5064//3158 +f 5060//3459 5059//3143 5074//3160 +f 5074//3160 5073//3157 5089//3460 +f 5069//3147 5068//261 5084//3162 +f 5064//3158 5063//3156 5078//3163 +f 5075//3164 5074//3160 5090//3461 +f 5070//3149 5069//3147 5085//3462 +f 5065//3148 5064//3158 5079//3167 +f 5071//3151 5070//3149 5086//3168 +f 5066//3457 5065//3148 5080//3169 +f 5072//3155 5071//3151 5087//3170 +f 5067//3152 5066//3457 5081//3463 +f 5062//3154 5061//3172 5076//3464 +f 5073//3157 5072//3155 5088//3174 +f 5068//261 5067//3152 5082//3175 +f 5063//3156 5062//3154 5077//3465 +f 5088//3174 5087//3170 5103//3177 +f 5083//3178 5082//3175 5097//3466 +f 5078//3163 5077//3465 5092//3467 +f 5089//3460 5088//3174 5104//3181 +f 5084//3162 5083//3178 5099//3182 +f 5079//3167 5078//3163 5093//3183 +f 5090//3461 5089//3460 5105//3184 +f 5085//3462 5084//3162 5100//3185 +f 5080//3169 5079//3167 5094//3186 +f 5086//3168 5085//3462 5101//3187 +f 5081//3463 5080//3169 5095//3188 +f 5087//3170 5086//3168 5102//3468 +f 5082//3175 5081//3463 5096//3469 +f 5077//3465 5076//3464 5091//3470 +f 5102//3468 5101//3187 5117//3192 +f 5097//3466 5096//3469 5111//3193 +f 5092//3467 5091//3470 5106//3471 +f 5103//3177 5102//3468 5118//3472 +f 5098//3196 5097//3466 5112//3197 +f 5093//3183 5092//3467 5107//3198 +f 5104//3181 5103//3177 5119//3199 +f 5099//3182 5098//3196 5114//3200 +f 5094//3186 5093//3183 5108//3473 +f 5105//3184 5104//3181 5120//3202 +f 5100//3185 5099//3182 5115//3203 +f 5095//3188 5094//3186 5109//3474 +f 5101//3187 5100//3185 5116//3205 +f 5096//3469 5095//3188 5110//3206 +f 5110//3206 5109//3474 5124//3207 +f 5116//3205 5115//3203 5131//3208 +f 5111//3193 5110//3206 5125//3209 +f 5117//3192 5116//3205 5132//3210 +f 5112//3197 5111//3193 5126//3475 +f 5107//3198 5106//3471 5121//3212 +f 5118//3472 5117//3192 5133//3476 +f 5113//3214 5112//3197 5127//3477 +f 5108//3473 5107//3198 5122//3216 +f 5119//3199 5118//3472 5134//3478 +f 5114//3200 5113//3214 5129//3218 +f 5109//3474 5108//3473 5123//3219 +f 5120//3202 5119//3199 5135//3479 +f 5115//3203 5114//3200 5130//3480 +f 5129//3218 5128//3222 5144//3481 +f 5124//3207 5123//3219 5138//3224 +f 5135//3479 5134//3478 5150//3482 +f 5130//3480 5129//3218 5145//3226 +f 5125//3209 5124//3207 5139//3227 +f 5131//3208 5130//3480 5146//3228 +f 5126//3475 5125//3209 5140//3483 +f 5132//3210 5131//3208 5147//3230 +f 5127//3477 5126//3475 5141//3231 +f 5122//3216 5121//3212 5136//3232 +f 5133//3476 5132//3210 5148//3484 +f 5128//3222 5127//3477 5142//3234 +f 5123//3219 5122//3216 5137//3485 +f 5134//3478 5133//3476 5149//3236 +f 5148//3484 5147//3230 5164//3486 +f 5143//3238 5142//3234 5158//3239 +f 5138//3224 5137//3485 5153//3240 +f 5149//3236 5148//3484 5165//3241 +f 5144//3481 5143//3238 5160//3242 +f 5139//3227 5138//3224 5154//3243 +f 5150//3482 5149//3236 5166//3487 +f 5145//3226 5144//3481 5161//3488 +f 5140//3483 5139//3227 5155//3246 +f 5146//3228 5145//3226 5162//3489 +f 5141//3231 5140//3483 5156//3490 +f 5147//3230 5146//3228 5163//3249 +f 5142//3234 5141//3231 5157//3250 +f 5137//3485 5136//3232 5152//3251 +f 5163//3249 5162//3489 5178//3491 +f 5158//3239 5157//3250 5172//3253 +f 5153//3240 5152//3251 5167//3254 +f 5164//3486 5163//3249 5179//3255 +f 5159//3256 5158//3239 5173//3257 +f 5154//3243 5153//3240 5168//3258 +f 5165//3241 5164//3486 5180//3259 +f 5160//3242 5159//3256 5175//3260 +f 5155//3246 5154//3243 5169//3492 +f 5166//3487 5165//3241 5181//3262 +f 5161//3488 5160//3242 5176//3263 +f 5156//3490 5155//3246 5170//3264 +f 5162//3489 5161//3488 5177//3493 +f 5157//3250 5156//3490 5171//3266 +f 5171//3266 5170//3264 5185//3267 +f 5177//3493 5176//3263 5192//3268 +f 5172//3253 5171//3266 5186//3269 +f 5178//3491 5177//3493 5193//3494 +f 5173//3257 5172//3253 5187//3495 +f 5168//3258 5167//3254 5182//3272 +f 5179//3255 5178//3491 5194//3273 +f 5174//3274 5173//3257 5188//3275 +f 5169//3492 5168//3258 5183//3276 +f 5180//3259 5179//3255 5195//3277 +f 5175//3260 5174//3274 5190//3278 +f 5170//3264 5169//3492 5184//3279 +f 5181//3262 5180//3259 5196//3280 +f 5176//3263 5175//3260 5191//3281 +f 5190//3278 5189//3282 5204//3283 +f 5185//3267 5184//3279 5200//3284 +f 5196//3280 5195//3277 5210//3285 +f 5191//3281 5190//3278 5205//3286 +f 5186//3269 5185//3267 5201//3496 +f 5192//3268 5191//3281 5206//3288 +f 5187//3495 5186//3269 5202//3289 +f 5193//3494 5192//3268 5207//3290 +f 5188//3275 5187//3495 5203//3291 +f 5183//3276 5182//3272 5198//3292 +f 5194//3273 5193//3494 5208//3293 +f 5189//3282 5188//3275 5204//3283 +f 5184//3279 5183//3276 5199//3294 +f 5195//3277 5194//3273 5209//3497 +f 5209//3497 5208//3293 5223//3296 +f 5204//3283 5203//3291 5219//3297 +f 5199//3294 5198//3292 5214//3498 +f 5210//3285 5209//3497 5224//3299 +f 5205//3286 5204//3283 5219//3297 +f 5200//3284 5199//3294 5215//3300 +f 5211//3301 5210//3285 5225//3302 +f 5206//3288 5205//3286 5220//3303 +f 5201//3496 5200//3284 5216//3499 +f 5207//3290 5206//3288 5221//3500 +f 5202//3289 5201//3496 5217//3306 +f 5208//3293 5207//3290 5222//3307 +f 5203//3291 5202//3289 5218//3308 +f 5198//3292 5197//3309 5213//3310 +f 5223//3296 5222//3307 5237//3501 +f 5218//3308 5217//3306 5233//3312 +f 5213//3310 5212//3502 5228//3314 +f 5224//3299 5223//3296 5238//3315 +f 5219//3297 5218//3308 5234//3503 +f 5214//3498 5213//3310 5229//3317 +f 5225//3302 5224//3299 5239//3504 +f 5220//3303 5219//3297 5234//3503 +f 5215//3300 5214//3498 5230//3319 +f 5226//3320 5225//3302 5240//3321 +f 5221//3500 5220//3303 5235//3505 +f 5216//3499 5215//3300 5231//3323 +f 5222//3307 5221//3500 5236//3506 +f 5217//3306 5216//3499 5232//3325 +f 5237//3501 5236//3506 5251//3507 +f 5232//3325 5231//3323 5247//3327 +f 5238//3315 5237//3501 5252//3328 +f 5233//3312 5232//3325 5248//3329 +f 5228//3314 5227//3508 5243//3331 +f 5239//3504 5238//3315 5253//3509 +f 5234//3503 5233//3312 5249//3333 +f 5229//3317 5228//3314 5244//3334 +f 5240//3321 5239//3504 5254//3510 +f 5235//3505 5234//3503 5249//3333 +f 5230//3319 5229//3317 5245//3336 +f 5241//3337 5240//3321 5255//3511 +f 5236//3506 5235//3505 5250//3339 +f 5231//3323 5230//3319 5246//3340 +f 5245//3336 5244//3334 5260//3512 +f 5256//3513 5255//3511 5270//3343 +f 5251//3507 5250//3339 5265//3344 +f 5246//3340 5245//3336 5261//3345 +f 5252//3328 5251//3507 5266//3346 +f 5247//3327 5246//3340 5262//3514 +f 5253//3509 5252//3328 5267//3348 +f 5248//3329 5247//3327 5263//3349 +f 5243//3331 5242//3350 5258//3515 +f 5254//3510 5253//3509 5268//3352 +f 5249//3333 5248//3329 5264//3353 +f 5244//3334 5243//3331 5259//3516 +f 5255//3511 5254//3510 5269//3517 +f 5250//3339 5249//3333 5264//3353 +f 5264//3353 5263//3349 5280//3356 +f 5259//3516 5258//3515 5275//3518 +f 5270//3343 5269//3517 5285//3358 +f 5265//3344 5264//3353 5280//3356 +f 5260//3512 5259//3516 5276//3519 +f 5271//3360 5270//3343 5286//3361 +f 5266//3346 5265//3344 5281//3362 +f 5261//3345 5260//3512 5277//3363 +f 5267//3348 5266//3346 5282//3364 +f 5262//3514 5261//3345 5278//3365 +f 5268//3352 5267//3348 5283//3520 +f 5263//3349 5262//3514 5279//3367 +f 5258//3515 5257//3521 5274//3369 +f 5269//3517 5268//3352 5284//3370 +f 5284//3370 5283//3520 5298//3371 +f 5279//3367 5278//3365 5294//3372 +f 5274//3369 5273//3522 5289//3523 +f 5285//3358 5284//3370 5299//3524 +f 5280//3356 5279//3367 5295//3376 +f 5275//3518 5274//3369 5290//3377 +f 5286//3361 5285//3358 5300//3378 +f 5281//3362 5280//3356 5295//3376 +f 5276//3519 5275//3518 5291//3525 +f 5287//3380 5286//3361 5301//3381 +f 5282//3364 5281//3362 5296//3382 +f 5277//3363 5276//3519 5292//3383 +f 5283//3520 5282//3364 5297//3526 +f 5278//3365 5277//3363 5293//3385 +f 5151//364 4835//2928 4850//3393 +f 4821//3389 5272//124 4836//3390 +f 5151//364 4850//3393 4865//2947 +f 4836//3390 5272//124 4851//2939 +f 4851//2939 5272//124 4866//3400 +f 5151//364 4865//2947 4880//2965 +f 5151//364 4880//2965 4895//3404 +f 4866//3400 5272//124 4881//3408 +f 5151//364 4895//3404 4910//2988 +f 4881//3408 5272//124 4896//2995 +f 5151//364 4910//2988 4925//3419 +f 4896//2995 5272//124 4911//2999 +f 4911//2999 5272//124 4926//3422 +f 5151//364 4925//3419 4940//3025 +f 5151//364 4940//3025 4955//3028 +f 4926//3422 5272//124 4941//3035 +f 5151//364 4955//3028 4970//3064 +f 4941//3035 5272//124 4956//3057 +f 5151//364 4970//3064 4985//3082 +f 4956//3057 5272//124 4971//3075 +f 4971//3075 5272//124 4986//3093 +f 5151//364 4985//3082 5000//3441 +f 5151//364 5000//3441 5015//3444 +f 4986//3093 5272//124 5001//3447 +f 5151//364 5015//3444 5030//3124 +f 5001//3447 5272//124 5016//3449 +f 5151//364 5030//3124 5045//3142 +f 5016//3449 5272//124 5031//3453 +f 5031//3453 5272//124 5046//3458 +f 5151//364 5045//3142 5060//3459 +f 5151//364 5060//3459 5075//3164 +f 5046//3458 5272//124 5061//3172 +f 5151//364 5075//3164 5090//3461 +f 5061//3172 5272//124 5076//3464 +f 5151//364 5090//3461 5105//3184 +f 5076//3464 5272//124 5091//3470 +f 5091//3470 5272//124 5106//3471 +f 5151//364 5105//3184 5120//3202 +f 5151//364 5120//3202 5135//3479 +f 5106//3471 5272//124 5121//3212 +f 5151//364 5135//3479 5150//3482 +f 5121//3212 5272//124 5136//3232 +f 5151//364 5150//3482 5166//3487 +f 5136//3232 5272//124 5152//3251 +f 5152//3251 5272//124 5167//3254 +f 5151//364 5166//3487 5181//3262 +f 5151//364 5181//3262 5196//3280 +f 5167//3254 5272//124 5182//3272 +f 5151//364 5196//3280 5211//3301 +f 5182//3272 5272//124 5197//3309 +f 5151//364 5211//3301 5226//3320 +f 5197//3309 5272//124 5212//3502 +f 5151//364 5226//3320 5241//3337 +f 5212//3502 5272//124 5227//3508 +f 5151//364 5241//3337 5256//3513 +f 5227//3508 5272//124 5242//3350 +f 5151//364 5256//3513 5271//3360 +f 5242//3350 5272//124 5257//3521 +f 5151//364 5271//3360 5287//3380 +f 5257//3521 5272//124 5273//3522 +f 5151//364 5287//3380 5302//3527 +f 5273//3522 5272//124 5288//3528 +f 5151//364 5302//3527 4835//2928 +f 5298//3371 5297//3526 4830//2930 +f 5293//3385 5292//3383 4826//2910 +f 5288//3528 5272//124 4821//3389 +f 5299//3524 5298//3371 4831//2934 +f 5294//3372 5293//3385 4827//2909 +f 5289//3523 5288//3528 4822//2912 +f 5300//3378 5299//3524 4832//2916 +f 5295//3376 5294//3372 4828//5 +f 5290//3377 5289//3523 4823//2920 +f 5301//3381 5300//3378 4833//2915 +f 5296//3382 5295//3376 4828//5 +f 5291//3525 5290//3377 4824//2926 +f 5302//3527 5301//3381 4834//2922 +f 5297//3526 5296//3382 4829//2924 +f 5292//3383 5291//3525 4825//2932 +f 4360//2919 4345//2909 4359//2911 +f 4355//2921 4340//2912 4354//2914 +f 4350//2916 4365//2937 4366//2917 +f 4361//2941 4346//2918 4360//2919 +f 4356//2927 4341//2920 4355//2921 +f 4351//2915 4366//2917 4367//2923 +f 4346//2918 4361//2941 4362//2925 +f 4357//2933 4342//2926 4356//2927 +f 4352//2922 4367//2923 4368//2929 +f 4347//2924 4362//2925 4363//2931 +f 4358//2936 4343//2932 4357//2933 +f 4348//2930 4363//2931 4364//2935 +f 4359//2911 4344//2910 4358//2936 +f 4349//2934 4364//2935 4365//2937 +f 4375//2942 4360//2919 4374//2938 +f 4370//2943 4355//2921 4369//2939 +f 4365//2937 4380//2952 4381//2940 +f 4376//2959 4361//2941 4375//2942 +f 4371//2946 4356//2927 4370//2943 +f 4366//2917 4381//2940 4382//2944 +f 4361//2941 4376//2959 4377//2945 +f 4372//2949 4357//2933 4371//2946 +f 4367//2923 4382//2944 4383//2947 +f 4362//2925 4377//2945 4378//2948 +f 4373//2951 4358//2936 4372//2949 +f 4363//2931 4378//2948 4379//2950 +f 4374//2938 4359//2911 4373//2951 +f 4364//2935 4379//2950 4380//2952 +f 4378//2948 4393//2966 4394//2953 +f 4389//2956 4374//2938 4388//2954 +f 4379//2950 4394//2953 4395//2955 +f 4390//2960 4375//2942 4389//2956 +f 4385//2961 4370//2943 4384//2957 +f 4380//2952 4395//2955 4396//2958 +f 4391//2977 4376//2959 4390//2960 +f 4386//2964 4371//2946 4385//2961 +f 4381//2940 4396//2958 4397//2962 +f 4376//2959 4391//2977 4392//2963 +f 4387//2967 4372//2949 4386//2964 +f 4382//2944 4397//2962 4398//2965 +f 4377//2945 4392//2963 4393//2966 +f 4388//2954 4373//2951 4387//2967 +f 4397//2962 4412//2980 4413//2968 +f 4392//2963 4407//2981 4408//2969 +f 4403//2972 4388//2954 4402//2970 +f 4393//2966 4408//2969 4409//2971 +f 4404//2974 4389//2956 4403//2972 +f 4394//2953 4409//2971 4410//2973 +f 4405//2978 4390//2960 4404//2974 +f 4400//2979 4385//2961 4399//2975 +f 4395//2955 4410//2973 4411//2976 +f 4406//2985 4391//2977 4405//2978 +f 4401//2982 4386//2964 4400//2979 +f 4396//2958 4411//2976 4412//2980 +f 4391//2977 4406//2985 4407//2981 +f 4402//2970 4387//2967 4401//2982 +f 4416//2987 4401//2982 4415//2983 +f 4411//2976 4426//2996 4427//2984 +f 4406//2985 4421//3001 4422//2986 +f 4417//2990 4402//2970 4416//2987 +f 4412//2980 4427//2984 4428//2988 +f 4407//2981 4422//2986 4423//2989 +f 4418//2992 4403//2972 4417//2990 +f 4408//2969 4423//2989 4424//2991 +f 4419//2994 4404//2974 4418//2992 +f 4409//2971 4424//2991 4425//2993 +f 4420//2997 4405//2978 4419//2994 +f 4415//2983 4400//2979 4414//2995 +f 4410//2973 4425//2993 4426//2996 +f 4421//3001 4406//2985 4420//2997 +f 4435//3002 4420//2997 4434//2998 +f 4430//3003 4415//2983 4429//2999 +f 4425//2993 4440//3012 4441//3000 +f 4436//3019 4421//3001 4435//3002 +f 4431//3006 4416//2987 4430//3003 +f 4426//2996 4441//3000 4442//3004 +f 4421//3001 4436//3019 4437//3005 +f 4432//3009 4417//2990 4431//3006 +f 4427//2984 4442//3004 4443//3007 +f 4422//2986 4437//3005 4438//3008 +f 4433//3011 4418//2992 4432//3009 +f 4423//2989 4438//3008 4439//3010 +f 4434//2998 4419//2994 4433//3011 +f 4424//2991 4439//3010 4440//3012 +f 4438//3008 4453//3026 4454//3013 +f 4449//3016 4434//2998 4448//3014 +f 4439//3010 4454//3013 4455//3015 +f 4450//3020 4435//3002 4449//3016 +f 4445//3021 4430//3003 4444//3017 +f 4440//3012 4455//3015 4456//3018 +f 4451//3037 4436//3019 4450//3020 +f 4446//3024 4431//3006 4445//3021 +f 4441//3000 4456//3018 4457//3022 +f 4436//3019 4451//3037 4452//3023 +f 4447//3027 4432//3009 4446//3024 +f 4442//3004 4457//3022 4458//3025 +f 4437//3005 4452//3023 4453//3026 +f 4448//3014 4433//3011 4447//3027 +f 4457//3022 4472//3040 4473//3028 +f 4452//3023 4467//3041 4468//3029 +f 4463//3032 4448//3014 4462//3030 +f 4453//3026 4468//3029 4469//3031 +f 4464//3034 4449//3016 4463//3032 +f 4454//3013 4469//3031 4470//3033 +f 4465//3038 4450//3020 4464//3034 +f 4460//3039 4445//3021 4459//3035 +f 4455//3015 4470//3033 4471//3036 +f 4466//3044 4451//3037 4465//3038 +f 4461//3042 4446//3024 4460//3039 +f 4456//3018 4471//3036 4472//3040 +f 4451//3037 4466//3044 4467//3041 +f 4462//3030 4447//3027 4461//3042 +f 4487//3047 4472//3040 4486//3043 +f 4482//3048 4467//3041 4481//3045 +f 4461//3042 4476//3056 4477//3046 +f 4488//3064 4473//3028 4487//3047 +f 4483//3050 4468//3029 4482//3048 +f 4462//3030 4477//3046 4478//3049 +f 4484//3052 4469//3031 4483//3050 +f 4463//3032 4478//3049 4479//3051 +f 4485//3055 4470//3033 4484//3052 +f 4464//3034 4479//3051 4480//3053 +f 4459//3035 4474//3057 4475//3054 +f 4486//3043 4471//3036 4485//3055 +f 4465//3038 4480//3053 4481//3045 +f 4460//3039 4475//3054 4476//3056 +f 4474//3057 4489//3075 4490//3058 +f 4501//3062 4486//3043 4500//3059 +f 4480//3053 4495//3071 4496//3060 +f 4475//3054 4490//3058 4491//3061 +f 4502//3065 4487//3047 4501//3062 +f 4497//3066 4482//3048 4496//3060 +f 4476//3056 4491//3061 4492//3063 +f 4503//3082 4488//3064 4502//3065 +f 4498//3068 4483//3050 4497//3066 +f 4477//3046 4492//3063 4493//3067 +f 4499//3070 4484//3052 4498//3068 +f 4478//3049 4493//3067 4494//3069 +f 4500//3059 4485//3055 4499//3070 +f 4479//3051 4494//3069 4495//3071 +f 4493//3067 4508//3085 4509//3072 +f 4515//3077 4500//3059 4514//3073 +f 4494//3069 4509//3072 4510//3074 +f 4489//3075 4504//3093 4505//3076 +f 4516//3080 4501//3062 4515//3077 +f 4495//3071 4510//3074 4511//3078 +f 4490//3058 4505//3076 4506//3079 +f 4517//3083 4502//3065 4516//3080 +f 4512//3084 4497//3066 4511//3078 +f 4491//3061 4506//3079 4507//3081 +f 4518//3100 4503//3082 4517//3083 +f 4513//3086 4498//3068 4512//3084 +f 4492//3063 4507//3081 4508//3085 +f 4514//3073 4499//3070 4513//3086 +f 4528//3089 4513//3086 4527//3087 +f 4507//3081 4522//3099 4523//3088 +f 4529//3091 4514//3073 4528//3089 +f 4508//3085 4523//3088 4524//3090 +f 4530//3095 4515//3077 4529//3091 +f 4509//3072 4524//3090 4525//3092 +f 4504//3093 4519//3113 4520//3094 +f 4531//3098 4516//3080 4530//3095 +f 4510//3074 4525//3092 4526//3096 +f 4505//3076 4520//3094 4521//3097 +f 4532//3101 4517//3083 4531//3098 +f 4527//3087 4512//3084 4526//3096 +f 4506//3079 4521//3097 4522//3099 +f 4533//3105 4518//3100 4532//3101 +f 4547//3106 4532//3101 4546//3102 +f 4542//3107 4527//3087 4541//3103 +f 4521//3097 4536//3116 4537//3104 +f 4548//3124 4533//3105 4547//3106 +f 4543//3109 4528//3089 4542//3107 +f 4522//3099 4537//3104 4538//3108 +f 4544//3111 4529//3091 4543//3109 +f 4523//3088 4538//3108 4539//3110 +f 4545//3115 4530//3095 4544//3111 +f 4524//3090 4539//3110 4540//3112 +f 4519//3113 4534//3117 4535//3114 +f 4546//3102 4531//3098 4545//3115 +f 4525//3092 4540//3112 4541//3103 +f 4520//3094 4535//3114 4536//3116 +f 4534//3117 4549//3135 4550//3118 +f 4561//3122 4546//3102 4560//3119 +f 4540//3112 4555//3131 4556//3120 +f 4535//3114 4550//3118 4551//3121 +f 4562//3125 4547//3106 4561//3122 +f 4557//3126 4542//3107 4556//3120 +f 4536//3116 4551//3121 4552//3123 +f 4563//3142 4548//3124 4562//3125 +f 4558//3128 4543//3109 4557//3126 +f 4537//3104 4552//3123 4553//3127 +f 4559//3130 4544//3111 4558//3128 +f 4538//3108 4553//3127 4554//3129 +f 4560//3119 4545//3115 4559//3130 +f 4539//3110 4554//3129 4555//3131 +f 4553//3127 4568//3145 4569//3132 +f 4575//3137 4560//3119 4574//3133 +f 4554//3129 4569//3132 4570//3134 +f 4549//3135 4564//3153 4565//3136 +f 4576//3140 4561//3122 4575//3137 +f 4555//3131 4570//3134 4571//3138 +f 4550//3118 4565//3136 4566//3139 +f 4577//3143 4562//3125 4576//3140 +f 4572//3144 4557//3126 4571//3138 +f 4551//3121 4566//3139 4567//3141 +f 4578//3159 4563//3142 4577//3143 +f 4573//3146 4558//3128 4572//3144 +f 4552//3123 4567//3141 4568//3145 +f 4574//3133 4559//3130 4573//3146 +f 4588//3149 4573//3146 4587//3147 +f 4567//3141 4582//3158 4583//3148 +f 4589//3151 4574//3133 4588//3149 +f 4568//3145 4583//3148 4584//3150 +f 4590//3155 4575//3137 4589//3151 +f 4569//3132 4584//3150 4585//3152 +f 4564//3153 4579//3172 4580//3154 +f 4591//3157 4576//3140 4590//3155 +f 4570//3134 4585//3152 4586//261 +f 4565//3136 4580//3154 4581//3156 +f 4592//3160 4577//3143 4591//3157 +f 4587//3147 4572//3144 4586//261 +f 4566//3139 4581//3156 4582//3158 +f 4593//3164 4578//3159 4592//3160 +f 4591//3157 4606//3174 4607//3161 +f 4586//261 4601//3178 4602//3162 +f 4597//3167 4582//3158 4596//3163 +f 4592//3160 4607//3161 4608//3165 +f 4587//3147 4602//3162 4603//3166 +f 4598//3169 4583//3148 4597//3167 +f 4588//3149 4603//3166 4604//3168 +f 4599//3171 4584//3150 4598//3169 +f 4589//3151 4604//3168 4605//3170 +f 4600//3175 4585//3152 4599//3171 +f 4595//3176 4580//3154 4594//3173 +f 4590//3155 4605//3170 4606//3174 +f 4601//3178 4586//261 4600//3175 +f 4596//3163 4581//3156 4595//3176 +f 4605//3170 4620//3189 4621//3177 +f 4616//3196 4601//3178 4615//3179 +f 4611//3183 4596//3163 4610//3180 +f 4606//3174 4621//3177 4622//3181 +f 4601//3178 4616//3196 4617//3182 +f 4612//3186 4597//3167 4611//3183 +f 4607//3161 4622//3181 4623//3184 +f 4602//3162 4617//3182 4618//3185 +f 4613//3188 4598//3169 4612//3186 +f 4603//3166 4618//3185 4619//3187 +f 4614//3190 4599//3171 4613//3188 +f 4604//3168 4619//3187 4620//3189 +f 4615//3179 4600//3175 4614//3190 +f 4610//3180 4595//3176 4609//3191 +f 4619//3187 4634//3205 4635//3192 +f 4630//3197 4615//3179 4629//3193 +f 4625//3198 4610//3180 4624//3194 +f 4620//3189 4635//3192 4636//3195 +f 4631//3214 4616//3196 4630//3197 +f 4626//3201 4611//3183 4625//3198 +f 4621//3177 4636//3195 4637//3199 +f 4616//3196 4631//3214 4632//3200 +f 4627//3204 4612//3186 4626//3201 +f 4622//3181 4637//3199 4638//3202 +f 4617//3182 4632//3200 4633//3203 +f 4628//3206 4613//3188 4627//3204 +f 4618//3185 4633//3203 4634//3205 +f 4629//3193 4614//3190 4628//3206 +f 4643//3209 4628//3206 4642//3207 +f 4633//3203 4648//3221 4649//3208 +f 4644//3211 4629//3193 4643//3209 +f 4634//3205 4649//3208 4650//3210 +f 4645//3215 4630//3197 4644//3211 +f 4640//3216 4625//3198 4639//3212 +f 4635//3192 4650//3210 4651//3213 +f 4646//3222 4631//3214 4645//3215 +f 4641//3219 4626//3201 4640//3216 +f 4636//3195 4651//3213 4652//3217 +f 4631//3214 4646//3222 4647//3218 +f 4642//3207 4627//3204 4641//3219 +f 4637//3199 4652//3217 4653//3220 +f 4632//3200 4647//3218 4648//3221 +f 4646//3222 4661//3238 4662//3223 +f 4657//3227 4642//3207 4656//3224 +f 4652//3217 4667//3236 4668//3225 +f 4647//3218 4662//3223 4663//3226 +f 4658//3229 4643//3209 4657//3227 +f 4648//3221 4663//3226 4664//3228 +f 4659//3231 4644//3211 4658//3229 +f 4649//3208 4664//3228 4665//3230 +f 4660//3234 4645//3215 4659//3231 +f 4655//3235 4640//3216 4654//3232 +f 4650//3210 4665//3230 4666//3233 +f 4661//3238 4646//3222 4660//3234 +f 4656//3224 4641//3219 4655//3235 +f 4651//3213 4666//3233 4667//3236 +f 4665//3230 4681//3249 4682//3237 +f 4677//3256 4661//3238 4676//3239 +f 4672//3243 4656//3224 4671//3240 +f 4666//3233 4682//3237 4683//3241 +f 4661//3238 4677//3256 4678//3242 +f 4673//3246 4657//3227 4672//3243 +f 4667//3236 4683//3241 4684//3244 +f 4662//3223 4678//3242 4679//3245 +f 4674//3248 4658//3229 4673//3246 +f 4663//3226 4679//3245 4680//3247 +f 4675//3250 4659//3231 4674//3248 +f 4664//3228 4680//3247 4681//3249 +f 4676//3239 4660//3234 4675//3250 +f 4671//3240 4655//3235 4670//3251 +f 4680//3247 4695//3265 4696//3252 +f 4691//3257 4676//3239 4690//3253 +f 4686//3258 4671//3240 4685//3254 +f 4681//3249 4696//3252 4697//3255 +f 4692//3274 4677//3256 4691//3257 +f 4687//3261 4672//3243 4686//3258 +f 4682//3237 4697//3255 4698//3259 +f 4677//3256 4692//3274 4693//3260 +f 4688//3264 4673//3246 4687//3261 +f 4683//3241 4698//3259 4699//3262 +f 4678//3242 4693//3260 4694//3263 +f 4689//3266 4674//3248 4688//3264 +f 4679//3245 4694//3263 4695//3265 +f 4690//3253 4675//3250 4689//3266 +f 4704//3269 4689//3266 4703//3267 +f 4694//3263 4709//3281 4710//3268 +f 4705//3271 4690//3253 4704//3269 +f 4695//3265 4710//3268 4711//3270 +f 4706//3275 4691//3257 4705//3271 +f 4701//3276 4686//3258 4700//3272 +f 4696//3252 4711//3270 4712//3273 +f 4707//3282 4692//3274 4706//3275 +f 4702//3279 4687//3261 4701//3276 +f 4697//3255 4712//3273 4713//3277 +f 4692//3274 4707//3282 4708//3278 +f 4703//3267 4688//3264 4702//3279 +f 4698//3259 4713//3277 4714//3280 +f 4693//3260 4708//3278 4709//3281 +f 4723//3286 4708//3278 4722//3283 +f 4702//3279 4717//3294 4718//3284 +f 4729//3301 4714//3280 4728//3285 +f 4724//3288 4709//3281 4723//3286 +f 4703//3267 4718//3284 4719//3287 +f 4725//3290 4710//3268 4724//3288 +f 4704//3269 4719//3287 4720//3289 +f 4726//3293 4711//3270 4725//3290 +f 4705//3271 4720//3289 4721//3291 +f 4700//3272 4715//3309 4716//3292 +f 4727//3295 4712//3273 4726//3293 +f 4706//3275 4721//3291 4722//3283 +f 4701//3276 4716//3292 4717//3294 +f 4728//3285 4713//3277 4727//3295 +f 4742//3299 4727//3295 4741//3296 +f 4721//3291 4736//3308 4737//3297 +f 4716//3292 4731//3310 4732//3298 +f 4743//3302 4728//3285 4742//3299 +f 4738//3303 4723//3286 4737//3297 +f 4717//3294 4732//3298 4733//3300 +f 4744//3320 4729//3301 4743//3302 +f 4739//3305 4724//3288 4738//3303 +f 4718//3284 4733//3300 4734//3304 +f 4740//3307 4725//3290 4739//3305 +f 4719//3287 4734//3304 4735//3306 +f 4741//3296 4726//3293 4740//3307 +f 4720//3289 4735//3306 4736//3308 +f 4715//3309 4730//3313 4731//3310 +f 4756//3315 4741//3296 4755//3311 +f 4735//3306 4750//3325 4751//3312 +f 4730//3313 4745//3330 4746//3314 +f 4757//3318 4742//3299 4756//3315 +f 4736//3308 4751//3312 4752//3316 +f 4731//3310 4746//3314 4747//3317 +f 4758//3321 4743//3302 4757//3318 +f 4753//3322 4738//3303 4752//3316 +f 4732//3298 4747//3317 4748//3319 +f 4759//3337 4744//3320 4758//3321 +f 4754//3324 4739//3305 4753//3322 +f 4733//3300 4748//3319 4749//3323 +f 4755//3311 4740//3307 4754//3324 +f 4734//3304 4749//3323 4750//3325 +f 4770//3328 4755//3311 4769//3326 +f 4749//3323 4764//3340 4765//3327 +f 4771//3332 4756//3315 4770//3328 +f 4750//3325 4765//3327 4766//3329 +f 4745//3330 4760//3350 4761//3331 +f 4772//3335 4757//3318 4771//3332 +f 4751//3312 4766//3329 4767//3333 +f 4746//3314 4761//3331 4762//3334 +f 4773//3338 4758//3321 4772//3335 +f 4768//3339 4753//3322 4767//3333 +f 4747//3317 4762//3334 4763//3336 +f 4774//3342 4759//3337 4773//3338 +f 4769//3326 4754//3324 4768//3339 +f 4748//3319 4763//3336 4764//3340 +f 4762//3334 4777//3354 4778//3341 +f 4789//3360 4774//3342 4788//3343 +f 4784//3346 4769//3326 4783//3344 +f 4763//3336 4778//3341 4779//3345 +f 4785//3348 4770//3328 4784//3346 +f 4764//3340 4779//3345 4780//3347 +f 4786//3352 4771//3332 4785//3348 +f 4765//3327 4780//3347 4781//3349 +f 4760//3350 4775//3368 4776//3351 +f 4787//3355 4772//3335 4786//3352 +f 4766//3329 4781//3349 4782//3353 +f 4761//3331 4776//3351 4777//3354 +f 4788//3343 4773//3338 4787//3355 +f 4783//3344 4768//3339 4782//3353 +f 4781//3349 4797//3367 4798//3356 +f 4776//3351 4792//3369 4793//3357 +f 4804//3361 4788//3343 4803//3358 +f 4799//3362 4783//3344 4798//3356 +f 4777//3354 4793//3357 4794//3359 +f 4805//3380 4789//3360 4804//3361 +f 4800//3364 4784//3346 4799//3362 +f 4778//3341 4794//3359 4795//3363 +f 4801//3366 4785//3348 4800//3364 +f 4779//3345 4795//3363 4796//3365 +f 4802//3370 4786//3352 4801//3366 +f 4780//3347 4796//3365 4797//3367 +f 4775//3368 4791//3373 4792//3369 +f 4803//3358 4787//3355 4802//3370 +f 4817//3375 4802//3370 4816//3371 +f 4796//3365 4811//3385 4812//3372 +f 4791//3373 4806//3387 4807//3374 +f 4818//3378 4803//3358 4817//3375 +f 4797//3367 4812//3372 4813//3376 +f 4792//3369 4807//3374 4808//3377 +f 4819//3381 4804//3361 4818//3378 +f 4814//3382 4799//3362 4813//3376 +f 4793//3357 4808//3377 4809//3379 +f 4820//3386 4805//3380 4819//3381 +f 4815//3384 4800//3364 4814//3382 +f 4794//3359 4809//3379 4810//3383 +f 4816//3371 4801//3366 4815//3384 +f 4795//3363 4810//3383 4811//3385 +f 4349//2934 4816//3371 4348//2930 +f 4810//3383 4343//2932 4344//2910 +f 4350//2916 4817//3375 4349//2934 +f 4811//3385 4344//2910 4345//2909 +f 4806//3387 4339//2913 4340//2912 +f 4351//2915 4818//3378 4350//2916 +f 4812//3372 4345//2909 4346//2918 +f 4807//3374 4340//2912 4341//2920 +f 4352//2922 4819//3381 4351//2915 +f 4347//2924 4814//3382 4346//2918 +f 4808//3377 4341//2920 4342//2926 +f 4353//2928 4820//3386 4352//2922 +f 4348//2930 4815//3384 4347//2924 +f 4809//3379 4342//2926 4343//2932 +f 4842//2919 4827//2909 4841//3388 +f 4837//2921 4822//2912 4836//3390 +f 4832//2916 4847//2937 4848//2917 +f 4843//2941 4828//5 4842//2919 +f 4838//3392 4823//2920 4837//2921 +f 4833//2915 4848//2917 4849//3391 +f 4828//5 4843//2941 4844//2925 +f 4839//2933 4824//2926 4838//3392 +f 4834//2922 4849//3391 4850//3393 +f 4829//2924 4844//2925 4845//3394 +f 4840//2936 4825//2932 4839//2933 +f 4830//2930 4845//3394 4846//2935 +f 4841//3388 4826//2910 4840//2936 +f 4831//2934 4846//2935 4847//2937 +f 4857//2942 4842//2919 4856//3395 +f 4852//3396 4837//2921 4851//2939 +f 4847//2937 4862//3399 4863//2940 +f 4858//2959 4843//2941 4857//2942 +f 4853//2946 4838//3392 4852//3396 +f 4848//2917 4863//2940 4864//2944 +f 4843//2941 4858//2959 4859//2945 +f 4854//3397 4839//2933 4853//2946 +f 4849//3391 4864//2944 4865//2947 +f 4844//2925 4859//2945 4860//2948 +f 4855//3398 4840//2936 4854//3397 +f 4845//3394 4860//2948 4861//2950 +f 4856//3395 4841//3388 4855//3398 +f 4846//2935 4861//2950 4862//3399 +f 4860//2948 4875//3402 4876//2953 +f 4871//2956 4856//3395 4870//2954 +f 4861//2950 4876//2953 4877//2955 +f 4872//2960 4857//2942 4871//2956 +f 4867//2961 4852//3396 4866//3400 +f 4862//3399 4877//2955 4878//3401 +f 4873//2977 4858//2959 4872//2960 +f 4868//2964 4853//2946 4867//2961 +f 4863//2940 4878//3401 4879//2962 +f 4858//2959 4873//2977 4874//2963 +f 4869//3403 4854//3397 4868//2964 +f 4864//2944 4879//2962 4880//2965 +f 4859//2945 4874//2963 4875//3402 +f 4870//2954 4855//3398 4869//3403 +f 4879//2962 4894//3410 4895//3404 +f 4874//2963 4889//2981 4890//3405 +f 4885//2972 4870//2954 4884//2970 +f 4875//3402 4890//3405 4891//2971 +f 4886//3407 4871//2956 4885//2972 +f 4876//2953 4891//2971 4892//3406 +f 4887//3409 4872//2960 4886//3407 +f 4882//2979 4867//2961 4881//3408 +f 4877//2955 4892//3406 4893//2976 +f 4888//2985 4873//2977 4887//3409 +f 4883//2982 4868//2964 4882//2979 +f 4878//3401 4893//2976 4894//3410 +f 4873//2977 4888//2985 4889//2981 +f 4884//2970 4869//3403 4883//2982 +f 4898//2987 4883//2982 4897//3411 +f 4893//2976 4908//3414 4909//2984 +f 4888//2985 4903//3416 4904//3412 +f 4899//2990 4884//2970 4898//2987 +f 4894//3410 4909//2984 4910//2988 +f 4889//2981 4904//3412 4905//2989 +f 4900//3413 4885//2972 4899//2990 +f 4890//3405 4905//2989 4906//2991 +f 4901//2994 4886//3407 4900//3413 +f 4891//2971 4906//2991 4907//2993 +f 4902//3415 4887//3409 4901//2994 +f 4897//3411 4882//2979 4896//2995 +f 4892//3406 4907//2993 4908//3414 +f 4903//3416 4888//2985 4902//3415 +f 4917//3417 4902//3415 4916//2998 +f 4912//3003 4897//3411 4911//2999 +f 4907//2993 4922//3012 4923//3000 +f 4918//3423 4903//3416 4917//3417 +f 4913//3418 4898//2987 4912//3003 +f 4908//3414 4923//3000 4924//3004 +f 4903//3416 4918//3423 4919//3005 +f 4914//3009 4899//2990 4913//3418 +f 4909//2984 4924//3004 4925//3419 +f 4904//3412 4919//3005 4920//3420 +f 4915//3421 4900//3413 4914//3009 +f 4905//2989 4920//3420 4921//3010 +f 4916//2998 4901//2994 4915//3421 +f 4906//2991 4921//3010 4922//3012 +f 4920//3420 4935//3026 4936//3013 +f 4931//3016 4916//2998 4930//3014 +f 4921//3010 4936//3013 4937//3015 +f 4932//3424 4917//3417 4931//3016 +f 4927//3021 4912//3003 4926//3422 +f 4922//3012 4937//3015 4938//3018 +f 4933//3037 4918//3423 4932//3424 +f 4928//3426 4913//3418 4927//3021 +f 4923//3000 4938//3018 4939//3425 +f 4918//3423 4933//3037 4934//3023 +f 4929//3027 4914//3009 4928//3426 +f 4924//3004 4939//3425 4940//3025 +f 4919//3005 4934//3023 4935//3026 +f 4930//3014 4915//3421 4929//3027 +f 4939//3425 4954//3040 4955//3028 +f 4934//3023 4949//3429 4950//3427 +f 4945//3032 4930//3014 4944//3030 +f 4935//3026 4950//3427 4951//3031 +f 4946//3428 4931//3016 4945//3032 +f 4936//3013 4951//3031 4952//3033 +f 4947//3038 4932//3424 4946//3428 +f 4942//3039 4927//3021 4941//3035 +f 4937//3015 4952//3033 4953//3036 +f 4948//480 4933//3037 4947//3038 +f 4943//3042 4928//3426 4942//3039 +f 4938//3018 4953//3036 4954//3040 +f 4933//3037 4948//480 4949//3429 +f 4944//3030 4929//3027 4943//3042 +f 4969//3431 4954//3040 4968//3430 +f 4964//3048 4949//3429 4963//3045 +f 4943//3042 4958//3056 4959//3046 +f 4970//3064 4955//3028 4969//3431 +f 4965//3050 4950//3427 4964//3048 +f 4944//3030 4959//3046 4960//3432 +f 4966//3052 4951//3031 4965//3050 +f 4945//3032 4960//3432 4961//3051 +f 4967//3055 4952//3033 4966//3052 +f 4946//3428 4961//3051 4962//3053 +f 4941//3035 4956//3057 4957//3054 +f 4968//3430 4953//3036 4967//3055 +f 4947//3038 4962//3053 4963//3045 +f 4942//3039 4957//3054 4958//3056 +f 4956//3057 4971//3075 4972//3058 +f 4983//3062 4968//3430 4982//3059 +f 4962//3053 4977//3071 4978//3060 +f 4957//3054 4972//3058 4973//3433 +f 4984//3065 4969//3431 4983//3062 +f 4979//3066 4964//3048 4978//3060 +f 4958//3056 4973//3433 4974//3063 +f 4985//3082 4970//3064 4984//3065 +f 4980//3434 4965//3050 4979//3066 +f 4959//3046 4974//3063 4975//3067 +f 4981//3436 4966//3052 4980//3434 +f 4960//3432 4975//3067 4976//3435 +f 4982//3059 4967//3055 4981//3436 +f 4961//3051 4976//3435 4977//3071 +f 4975//3067 4990//3085 4991//3072 +f 4997//3077 4982//3059 4996//3073 +f 4976//3435 4991//3072 4992//3437 +f 4971//3075 4986//3093 4987//3076 +f 4998//3438 4983//3062 4997//3077 +f 4977//3071 4992//3437 4993//3078 +f 4972//3058 4987//3076 4988//3079 +f 4999//3083 4984//3065 4998//3438 +f 4994//3439 4979//3066 4993//3078 +f 4973//3433 4988//3079 4989//3081 +f 5000//3441 4985//3082 4999//3083 +f 4995//3086 4980//3434 4994//3439 +f 4974//3063 4989//3081 4990//3085 +f 4996//3073 4981//3436 4995//3086 +f 5010//3440 4995//3086 5009//3087 +f 4989//3081 5004//3099 5005//3088 +f 5011//3091 4996//3073 5010//3440 +f 4990//3085 5005//3088 5006//3090 +f 5012//3095 4997//3077 5011//3091 +f 4991//3072 5006//3090 5007//3092 +f 4986//3093 5001//3447 5002//3094 +f 5013//3098 4998//3438 5012//3095 +f 4992//3437 5007//3092 5008//3096 +f 4987//3076 5002//3094 5003//3097 +f 5014//3101 4999//3083 5013//3098 +f 5009//3087 4994//3439 5008//3096 +f 4988//3079 5003//3097 5004//3099 +f 5015//3444 5000//3441 5014//3101 +f 5029//3106 5014//3101 5028//3442 +f 5024//3107 5009//3087 5023//3103 +f 5003//3097 5018//3116 5019//3443 +f 5030//3124 5015//3444 5029//3106 +f 5025//3109 5010//3440 5024//3107 +f 5004//3099 5019//3443 5020//3445 +f 5026//3111 5011//3091 5025//3109 +f 5005//3088 5020//3445 5021//3110 +f 5027//3115 5012//3095 5026//3111 +f 5006//3090 5021//3110 5022//3446 +f 5001//3447 5016//3449 5017//3448 +f 5028//3442 5013//3098 5027//3115 +f 5007//3092 5022//3446 5023//3103 +f 5002//3094 5017//3448 5018//3116 +f 5016//3449 5031//3453 5032//3118 +f 5043//3451 5028//3442 5042//3450 +f 5022//3446 5037//3131 5038//3120 +f 5017//3448 5032//3118 5033//3121 +f 5044//3125 5029//3106 5043//3451 +f 5039//3126 5024//3107 5038//3120 +f 5018//3116 5033//3121 5034//3123 +f 5045//3142 5030//3124 5044//3125 +f 5040//3128 5025//3109 5039//3126 +f 5019//3443 5034//3123 5035//3452 +f 5041//3130 5026//3111 5040//3128 +f 5020//3445 5035//3452 5036//3129 +f 5042//3450 5027//3115 5041//3130 +f 5021//3110 5036//3129 5037//3131 +f 5035//3452 5050//3145 5051//3132 +f 5057//3137 5042//3450 5056//3133 +f 5036//3129 5051//3132 5052//3134 +f 5031//3453 5046//3458 5047//3454 +f 5058//3455 5043//3451 5057//3137 +f 5037//3131 5052//3134 5053//3138 +f 5032//3118 5047//3454 5048//3139 +f 5059//3143 5044//3125 5058//3455 +f 5054//3144 5039//3126 5053//3138 +f 5033//3121 5048//3139 5049//3141 +f 5060//3459 5045//3142 5059//3143 +f 5055//3456 5040//3128 5054//3144 +f 5034//3123 5049//3141 5050//3145 +f 5056//3133 5041//3130 5055//3456 +f 5070//3149 5055//3456 5069//3147 +f 5049//3141 5064//3158 5065//3148 +f 5071//3151 5056//3133 5070//3149 +f 5050//3145 5065//3148 5066//3457 +f 5072//3155 5057//3137 5071//3151 +f 5051//3132 5066//3457 5067//3152 +f 5046//3458 5061//3172 5062//3154 +f 5073//3157 5058//3455 5072//3155 +f 5052//3134 5067//3152 5068//261 +f 5047//3454 5062//3154 5063//3156 +f 5074//3160 5059//3143 5073//3157 +f 5069//3147 5054//3144 5068//261 +f 5048//3139 5063//3156 5064//3158 +f 5075//3164 5060//3459 5074//3160 +f 5073//3157 5088//3174 5089//3460 +f 5068//261 5083//3178 5084//3162 +f 5079//3167 5064//3158 5078//3163 +f 5074//3160 5089//3460 5090//3461 +f 5069//3147 5084//3162 5085//3462 +f 5080//3169 5065//3148 5079//3167 +f 5070//3149 5085//3462 5086//3168 +f 5081//3463 5066//3457 5080//3169 +f 5071//3151 5086//3168 5087//3170 +f 5082//3175 5067//3152 5081//3463 +f 5077//3465 5062//3154 5076//3464 +f 5072//3155 5087//3170 5088//3174 +f 5083//3178 5068//261 5082//3175 +f 5078//3163 5063//3156 5077//3465 +f 5087//3170 5102//3468 5103//3177 +f 5098//3196 5083//3178 5097//3466 +f 5093//3183 5078//3163 5092//3467 +f 5088//3174 5103//3177 5104//3181 +f 5083//3178 5098//3196 5099//3182 +f 5094//3186 5079//3167 5093//3183 +f 5089//3460 5104//3181 5105//3184 +f 5084//3162 5099//3182 5100//3185 +f 5095//3188 5080//3169 5094//3186 +f 5085//3462 5100//3185 5101//3187 +f 5096//3469 5081//3463 5095//3188 +f 5086//3168 5101//3187 5102//3468 +f 5097//3466 5082//3175 5096//3469 +f 5092//3467 5077//3465 5091//3470 +f 5101//3187 5116//3205 5117//3192 +f 5112//3197 5097//3466 5111//3193 +f 5107//3198 5092//3467 5106//3471 +f 5102//3468 5117//3192 5118//3472 +f 5113//3214 5098//3196 5112//3197 +f 5108//3473 5093//3183 5107//3198 +f 5103//3177 5118//3472 5119//3199 +f 5098//3196 5113//3214 5114//3200 +f 5109//3474 5094//3186 5108//3473 +f 5104//3181 5119//3199 5120//3202 +f 5099//3182 5114//3200 5115//3203 +f 5110//3206 5095//3188 5109//3474 +f 5100//3185 5115//3203 5116//3205 +f 5111//3193 5096//3469 5110//3206 +f 5125//3209 5110//3206 5124//3207 +f 5115//3203 5130//3480 5131//3208 +f 5126//3475 5111//3193 5125//3209 +f 5116//3205 5131//3208 5132//3210 +f 5127//3477 5112//3197 5126//3475 +f 5122//3216 5107//3198 5121//3212 +f 5117//3192 5132//3210 5133//3476 +f 5128//3222 5113//3214 5127//3477 +f 5123//3219 5108//3473 5122//3216 +f 5118//3472 5133//3476 5134//3478 +f 5113//3214 5128//3222 5129//3218 +f 5124//3207 5109//3474 5123//3219 +f 5119//3199 5134//3478 5135//3479 +f 5114//3200 5129//3218 5130//3480 +f 5128//3222 5143//3238 5144//3481 +f 5139//3227 5124//3207 5138//3224 +f 5134//3478 5149//3236 5150//3482 +f 5129//3218 5144//3481 5145//3226 +f 5140//3483 5125//3209 5139//3227 +f 5130//3480 5145//3226 5146//3228 +f 5141//3231 5126//3475 5140//3483 +f 5131//3208 5146//3228 5147//3230 +f 5142//3234 5127//3477 5141//3231 +f 5137//3485 5122//3216 5136//3232 +f 5132//3210 5147//3230 5148//3484 +f 5143//3238 5128//3222 5142//3234 +f 5138//3224 5123//3219 5137//3485 +f 5133//3476 5148//3484 5149//3236 +f 5147//3230 5163//3249 5164//3486 +f 5159//3256 5143//3238 5158//3239 +f 5154//3243 5138//3224 5153//3240 +f 5148//3484 5164//3486 5165//3241 +f 5143//3238 5159//3256 5160//3242 +f 5155//3246 5139//3227 5154//3243 +f 5149//3236 5165//3241 5166//3487 +f 5144//3481 5160//3242 5161//3488 +f 5156//3490 5140//3483 5155//3246 +f 5145//3226 5161//3488 5162//3489 +f 5157//3250 5141//3231 5156//3490 +f 5146//3228 5162//3489 5163//3249 +f 5158//3239 5142//3234 5157//3250 +f 5153//3240 5137//3485 5152//3251 +f 5162//3489 5177//3493 5178//3491 +f 5173//3257 5158//3239 5172//3253 +f 5168//3258 5153//3240 5167//3254 +f 5163//3249 5178//3491 5179//3255 +f 5174//3274 5159//3256 5173//3257 +f 5169//3492 5154//3243 5168//3258 +f 5164//3486 5179//3255 5180//3259 +f 5159//3256 5174//3274 5175//3260 +f 5170//3264 5155//3246 5169//3492 +f 5165//3241 5180//3259 5181//3262 +f 5160//3242 5175//3260 5176//3263 +f 5171//3266 5156//3490 5170//3264 +f 5161//3488 5176//3263 5177//3493 +f 5172//3253 5157//3250 5171//3266 +f 5186//3269 5171//3266 5185//3267 +f 5176//3263 5191//3281 5192//3268 +f 5187//3495 5172//3253 5186//3269 +f 5177//3493 5192//3268 5193//3494 +f 5188//3275 5173//3257 5187//3495 +f 5183//3276 5168//3258 5182//3272 +f 5178//3491 5193//3494 5194//3273 +f 5189//3282 5174//3274 5188//3275 +f 5184//3279 5169//3492 5183//3276 +f 5179//3255 5194//3273 5195//3277 +f 5174//3274 5189//3282 5190//3278 +f 5185//3267 5170//3264 5184//3279 +f 5180//3259 5195//3277 5196//3280 +f 5175//3260 5190//3278 5191//3281 +f 5205//3286 5190//3278 5204//3283 +f 5184//3279 5199//3294 5200//3284 +f 5211//3301 5196//3280 5210//3285 +f 5206//3288 5191//3281 5205//3286 +f 5185//3267 5200//3284 5201//3496 +f 5207//3290 5192//3268 5206//3288 +f 5186//3269 5201//3496 5202//3289 +f 5208//3293 5193//3494 5207//3290 +f 5187//3495 5202//3289 5203//3291 +f 5182//3272 5197//3309 5198//3292 +f 5209//3497 5194//3273 5208//3293 +f 5188//3275 5203//3291 5204//3283 +f 5183//3276 5198//3292 5199//3294 +f 5210//3285 5195//3277 5209//3497 +f 5224//3299 5209//3497 5223//3296 +f 5203//3291 5218//3308 5219//3297 +f 5198//3292 5213//3310 5214//3498 +f 5225//3302 5210//3285 5224//3299 +f 5220//3303 5205//3286 5219//3297 +f 5199//3294 5214//3498 5215//3300 +f 5226//3320 5211//3301 5225//3302 +f 5221//3500 5206//3288 5220//3303 +f 5200//3284 5215//3300 5216//3499 +f 5222//3307 5207//3290 5221//3500 +f 5201//3496 5216//3499 5217//3306 +f 5223//3296 5208//3293 5222//3307 +f 5202//3289 5217//3306 5218//3308 +f 5197//3309 5212//3502 5213//3310 +f 5238//3315 5223//3296 5237//3501 +f 5217//3306 5232//3325 5233//3312 +f 5212//3502 5227//3508 5228//3314 +f 5239//3504 5224//3299 5238//3315 +f 5218//3308 5233//3312 5234//3503 +f 5213//3310 5228//3314 5229//3317 +f 5240//3321 5225//3302 5239//3504 +f 5235//3505 5220//3303 5234//3503 +f 5214//3498 5229//3317 5230//3319 +f 5241//3337 5226//3320 5240//3321 +f 5236//3506 5221//3500 5235//3505 +f 5215//3300 5230//3319 5231//3323 +f 5237//3501 5222//3307 5236//3506 +f 5216//3499 5231//3323 5232//3325 +f 5252//3328 5237//3501 5251//3507 +f 5231//3323 5246//3340 5247//3327 +f 5253//3509 5238//3315 5252//3328 +f 5232//3325 5247//3327 5248//3329 +f 5227//3508 5242//3350 5243//3331 +f 5254//3510 5239//3504 5253//3509 +f 5233//3312 5248//3329 5249//3333 +f 5228//3314 5243//3331 5244//3334 +f 5255//3511 5240//3321 5254//3510 +f 5250//3339 5235//3505 5249//3333 +f 5229//3317 5244//3334 5245//3336 +f 5256//3513 5241//3337 5255//3511 +f 5251//3507 5236//3506 5250//3339 +f 5230//3319 5245//3336 5246//3340 +f 5244//3334 5259//3516 5260//3512 +f 5271//3360 5256//3513 5270//3343 +f 5266//3346 5251//3507 5265//3344 +f 5245//3336 5260//3512 5261//3345 +f 5267//3348 5252//3328 5266//3346 +f 5246//3340 5261//3345 5262//3514 +f 5268//3352 5253//3509 5267//3348 +f 5247//3327 5262//3514 5263//3349 +f 5242//3350 5257//3521 5258//3515 +f 5269//3517 5254//3510 5268//3352 +f 5248//3329 5263//3349 5264//3353 +f 5243//3331 5258//3515 5259//3516 +f 5270//3343 5255//3511 5269//3517 +f 5265//3344 5250//3339 5264//3353 +f 5263//3349 5279//3367 5280//3356 +f 5258//3515 5274//3369 5275//3518 +f 5286//3361 5270//3343 5285//3358 +f 5281//3362 5265//3344 5280//3356 +f 5259//3516 5275//3518 5276//3519 +f 5287//3380 5271//3360 5286//3361 +f 5282//3364 5266//3346 5281//3362 +f 5260//3512 5276//3519 5277//3363 +f 5283//3520 5267//3348 5282//3364 +f 5261//3345 5277//3363 5278//3365 +f 5284//3370 5268//3352 5283//3520 +f 5262//3514 5278//3365 5279//3367 +f 5257//3521 5273//3522 5274//3369 +f 5285//3358 5269//3517 5284//3370 +f 5299//3524 5284//3370 5298//3371 +f 5278//3365 5293//3385 5294//3372 +f 5273//3522 5288//3528 5289//3523 +f 5300//3378 5285//3358 5299//3524 +f 5279//3367 5294//3372 5295//3376 +f 5274//3369 5289//3523 5290//3377 +f 5301//3381 5286//3361 5300//3378 +f 5296//3382 5281//3362 5295//3376 +f 5275//3518 5290//3377 5291//3525 +f 5302//3527 5287//3380 5301//3381 +f 5297//3526 5282//3364 5296//3382 +f 5276//3519 5291//3525 5292//3383 +f 5298//3371 5283//3520 5297//3526 +f 5277//3363 5292//3383 5293//3385 +f 4831//2934 5298//3371 4830//2930 +f 5292//3383 4825//2932 4826//2910 +f 4832//2916 5299//3524 4831//2934 +f 5293//3385 4826//2910 4827//2909 +f 5288//3528 4821//3389 4822//2912 +f 4833//2915 5300//3378 4832//2916 +f 5294//3372 4827//2909 4828//5 +f 5289//3523 4822//2912 4823//2920 +f 4834//2922 5301//3381 4833//2915 +f 4829//2924 5296//3382 4828//5 +f 5290//3377 4823//2920 4824//2926 +f 4835//2928 5302//3527 4834//2922 +f 4830//2930 5297//3526 4829//2924 +f 5291//3525 4824//2926 4825//2932 +o Ear_R_Sphere.008 +v -0.942135 0.123766 -0.790557 +v -0.971285 0.138857 -0.773109 +v -1.001178 0.167463 -0.755604 +v -1.023476 0.202632 -0.742670 +v -1.050742 0.188359 -0.726125 +v -1.065738 0.156697 -0.716845 +v -1.074973 0.122343 -0.711131 +v -1.078091 0.086615 -0.709202 +v -1.074973 0.050887 -0.711131 +v -1.065738 0.016532 -0.716845 +v -1.050742 -0.015129 -0.726125 +v -1.030561 -0.042881 -0.738613 +v -1.005970 -0.065656 -0.753829 +v -0.977914 -0.082579 -0.771190 +v -0.947472 -0.093001 -0.790027 +v -0.944261 0.123101 -0.795974 +v -0.975586 0.137204 -0.783938 +v -1.007664 0.166926 -0.771946 +v -1.030584 0.203090 -0.763045 +v -1.060842 0.188359 -0.751290 +v -1.076960 0.156697 -0.744808 +v -1.086886 0.122343 -0.740816 +v -1.090238 0.086615 -0.739468 +v -1.086886 0.050887 -0.740816 +v -1.076960 0.016532 -0.744808 +v -1.060842 -0.015129 -0.751290 +v -1.039150 -0.042881 -0.760014 +v -1.012718 -0.065656 -0.770644 +v -0.982563 -0.082579 -0.782772 +v -0.949842 -0.093001 -0.795932 +v -0.945127 0.122652 -0.801955 +v -0.977082 0.135311 -0.795837 +v -1.008829 0.160888 -0.789698 +v -1.033925 0.195448 -0.784816 +v -1.065368 0.188359 -0.778698 +v -1.081990 0.156697 -0.775261 +v -1.092225 0.122343 -0.773145 +v -1.095681 0.086615 -0.772431 +v -1.092225 0.050887 -0.773145 +v -1.081990 0.016532 -0.775261 +v -1.065368 -0.015129 -0.778698 +v -1.042999 -0.042881 -0.783322 +v -1.015743 -0.065656 -0.788957 +v -0.984646 -0.082579 -0.795386 +v -0.950904 -0.093001 -0.802362 +v -0.944911 0.122893 -0.808257 +v -0.976676 0.135723 -0.808342 +v -1.008549 0.161499 -0.808326 +v -1.033513 0.196247 -0.807634 +v -1.064147 0.188359 -0.807293 +v -1.080633 0.156697 -0.807035 +v -1.090785 0.122343 -0.806876 +v -1.094213 0.086615 -0.806822 +v -1.090785 0.050887 -0.806876 +v -1.080633 0.016532 -0.807035 +v -1.064147 -0.015129 -0.807293 +v -1.041961 -0.042881 -0.807641 +v -1.014927 -0.065656 -0.808064 +v -0.984084 -0.082579 -0.808547 +v -0.950617 -0.093001 -0.809072 +v -0.943535 0.123924 -0.814504 +v -0.973927 0.138486 -0.820733 +v -1.005204 0.165323 -0.826896 +v -1.030109 0.201373 -0.830949 +v -1.057226 0.188359 -0.835978 +v -1.072942 0.156697 -0.838908 +v -1.082621 0.122343 -0.840712 +v -1.085889 0.086615 -0.841321 +v -1.082621 0.050887 -0.840712 +v -1.072942 0.016532 -0.838908 +v -1.057226 -0.015129 -0.835978 +v -1.036075 -0.042881 -0.832035 +v -1.010302 -0.065656 -0.827231 +v -0.980898 -0.082579 -0.821750 +v -0.948993 -0.093001 -0.815802 +v -0.940978 0.125439 -0.820358 +v -0.968637 0.142257 -0.832291 +v -0.996932 0.172381 -0.843906 +v -1.025553 0.216049 -0.855564 +v -1.044870 0.188359 -0.863650 +v -1.059213 0.156697 -0.869655 +v -1.068046 0.122343 -0.873353 +v -1.071028 0.086615 -0.874601 +v -1.068046 0.050887 -0.873353 +v -1.059213 0.016532 -0.869655 +v -1.044870 -0.015129 -0.863650 +v -1.025567 -0.042881 -0.855568 +v -1.002046 -0.065656 -0.845720 +v -0.975212 -0.082579 -0.834485 +v -0.946094 -0.093001 -0.822295 +v -0.937450 0.126946 -0.825647 +v -0.961464 0.145298 -0.842862 +v -0.986055 0.174750 -0.860010 +v -1.010841 0.216110 -0.877335 +v -1.027555 0.188359 -0.889245 +v -1.039974 0.156697 -0.898095 +v -1.047621 0.122343 -0.903544 +v -1.050203 0.086615 -0.905385 +v -1.047621 0.050887 -0.903544 +v -1.039974 0.016532 -0.898095 +v -1.027555 -0.015129 -0.889245 +v -1.010841 -0.042881 -0.877335 +v -0.990476 -0.065656 -0.862823 +v -0.967242 -0.082579 -0.846266 +v -0.942032 -0.093001 -0.828300 +v -0.933134 0.128348 -0.830246 +v -0.952672 0.148285 -0.852147 +v -0.972676 0.179365 -0.874011 +v -0.992464 0.216111 -0.896500 +v -1.005945 0.188359 -0.911780 +v -1.015962 0.156697 -0.923135 +v -1.022131 0.122343 -0.930127 +v -1.024214 0.086615 -0.932487 +v -1.022131 0.050887 -0.930127 +v -1.015962 0.016532 -0.923135 +v -1.005945 -0.015129 -0.911780 +v -0.992464 -0.042881 -0.896500 +v -0.976037 -0.065656 -0.877880 +v -0.957296 -0.082579 -0.856637 +v -0.936961 -0.093001 -0.833588 +v -0.928187 0.129502 -0.834049 +v -0.942604 0.150704 -0.859907 +v -0.957388 0.183964 -0.885989 +v -0.971141 0.216109 -0.912325 +v -0.980872 0.188359 -0.930389 +v -0.988102 0.156697 -0.943812 +v -0.992555 0.122343 -0.952078 +v -0.994059 0.086615 -0.954869 +v -0.992555 0.050887 -0.952078 +v -0.988103 0.016532 -0.943812 +v -0.980872 -0.015129 -0.930389 +v -0.971141 -0.042881 -0.912325 +v -0.959284 -0.065656 -0.890314 +v -0.945756 -0.082579 -0.865202 +v -0.931078 -0.093001 -0.837954 +v -0.922745 0.129042 -0.837001 +v -0.931452 0.151400 -0.865836 +v -0.940188 0.184892 -0.895103 +v -0.947692 0.216111 -0.924204 +v -0.953298 0.188359 -0.944357 +v -0.957465 0.156697 -0.959332 +v -0.960030 0.122343 -0.968554 +v -0.960896 0.086615 -0.971668 +v -0.960030 0.050887 -0.968554 +v -0.957465 0.016532 -0.959332 +v -0.953298 -0.015129 -0.944357 +v -0.947692 -0.042881 -0.924204 +v -0.940860 -0.065656 -0.899647 +v -0.933066 -0.082579 -0.871631 +v -0.924609 -0.093001 -0.841231 +v -0.916880 0.128290 -0.838922 +v -0.919681 0.151673 -0.869631 +v -0.922271 0.186622 -0.900985 +v -0.923018 0.216110 -0.931679 +v -0.924285 0.188359 -0.953147 +v -0.925226 0.156697 -0.969099 +v -0.925806 0.122343 -0.978922 +v -0.926002 0.086615 -0.982239 +v -0.925806 0.050887 -0.978922 +v -0.925226 0.016532 -0.969099 +v -0.924285 -0.015129 -0.953147 +v -0.923018 -0.042881 -0.931679 +v -0.921474 -0.065656 -0.905521 +v -0.919712 -0.082579 -0.875677 +v -0.917801 -0.093001 -0.843294 +v -0.910856 0.127918 -0.839532 +v -0.907678 0.150681 -0.871020 +v -0.904089 0.185445 -0.903392 +v -0.898066 0.216110 -0.934464 +v -0.894945 0.188359 -0.956421 +v -0.892626 0.156697 -0.972737 +v -0.891198 0.122343 -0.982784 +v -0.890715 0.086615 -0.986177 +v -0.891198 0.050887 -0.982784 +v -0.892626 0.016532 -0.972737 +v -0.894945 -0.015129 -0.956421 +v -0.898066 -0.042881 -0.934464 +v -0.901870 -0.065656 -0.907708 +v -0.906209 -0.082579 -0.877184 +v -0.910917 -0.093001 -0.844062 +v -0.904956 0.127171 -0.838878 +v -0.895610 0.147650 -0.869788 +v -0.885492 0.179325 -0.901411 +v -0.873797 0.216110 -0.932450 +v -0.866408 0.188359 -0.954054 +v -0.860917 0.156697 -0.970107 +v -0.857535 0.122343 -0.979992 +v -0.856394 0.086615 -0.983330 +v -0.857535 0.050887 -0.979992 +v -0.860917 0.016532 -0.970107 +v -0.866408 -0.015129 -0.954054 +v -0.873797 -0.042881 -0.932450 +v -0.882801 -0.065656 -0.906127 +v -0.893074 -0.082579 -0.876094 +v -0.904221 -0.093001 -0.843507 +v -0.899294 0.127919 -0.836889 +v -0.884081 0.144468 -0.866086 +v -0.868120 0.174695 -0.895671 +v -0.851143 0.216110 -0.925717 +v -0.839769 0.188359 -0.946136 +v -0.831317 0.156697 -0.961308 +v -0.826113 0.122343 -0.970652 +v -0.824355 0.086615 -0.973807 +v -0.826113 0.050887 -0.970652 +v -0.831317 0.016532 -0.961308 +v -0.839769 -0.015129 -0.946136 +v -0.851143 -0.042881 -0.925717 +v -0.865002 -0.065656 -0.900836 +v -0.880814 -0.082579 -0.872450 +v -0.897971 -0.093001 -0.841649 +v -0.894021 0.126810 -0.833847 +v -0.873585 0.143014 -0.860071 +v -0.852517 0.173311 -0.886802 +v -0.830973 0.216110 -0.914521 +v -0.816052 0.188359 -0.932971 +v -0.804965 0.156697 -0.946681 +v -0.798137 0.122343 -0.955123 +v -0.795832 0.086615 -0.957974 +v -0.798137 0.050887 -0.955123 +v -0.804965 0.016532 -0.946681 +v -0.816052 -0.015129 -0.932971 +v -0.830973 -0.042881 -0.914521 +v -0.849155 -0.065656 -0.892040 +v -0.869898 -0.082579 -0.866391 +v -0.892406 -0.093001 -0.838560 +v -0.889469 0.126849 -0.829710 +v -0.864688 0.144003 -0.851969 +v -0.839410 0.174862 -0.874905 +v -0.814065 0.216110 -0.899294 +v -0.796169 0.188359 -0.915066 +v -0.782872 0.156697 -0.926786 +v -0.774684 0.122343 -0.934003 +v -0.771919 0.086615 -0.936440 +v -0.774684 0.050887 -0.934003 +v -0.782872 0.016532 -0.926786 +v -0.796169 -0.015129 -0.915066 +v -0.814065 -0.042881 -0.899294 +v -0.835870 -0.065656 -0.880076 +v -0.860747 -0.082579 -0.858150 +v -0.887741 -0.093001 -0.834359 +v -0.885964 0.128240 -0.824736 +v -0.857824 0.146043 -0.842318 +v -0.829233 0.178931 -0.860559 +v -0.801066 0.216110 -0.880621 +v -0.780884 0.188359 -0.893109 +v -0.765888 0.156697 -0.902389 +v -0.756654 0.122343 -0.908103 +v -0.753536 0.086615 -0.910032 +v -0.756654 0.050887 -0.908103 +v -0.765888 0.016532 -0.902389 +v -0.780884 -0.015129 -0.893109 +v -0.801066 -0.042881 -0.880621 +v -0.825657 -0.065656 -0.865405 +v -0.853712 -0.082579 -0.848044 +v -0.884154 -0.093001 -0.829207 +v -0.883748 0.130413 -0.819310 +v -0.853554 0.149753 -0.831679 +v -0.822847 0.184895 -0.844910 +v -0.792477 0.216110 -0.859220 +v -0.770785 0.188359 -0.867944 +v -0.754666 0.156697 -0.874426 +v -0.744740 0.122343 -0.878418 +v -0.741389 0.086615 -0.879766 +v -0.744740 0.050887 -0.878418 +v -0.754666 0.016532 -0.874426 +v -0.770785 -0.015129 -0.867944 +v -0.792477 -0.042881 -0.859220 +v -0.818908 -0.065656 -0.848589 +v -0.849064 -0.082579 -0.836462 +v -0.881785 -0.093001 -0.823302 +v -0.882854 0.132691 -0.813648 +v -0.851758 0.151597 -0.820254 +v -0.820580 0.180369 -0.827765 +v -0.788627 0.216110 -0.835912 +v -0.766258 0.188359 -0.840536 +v -0.749637 0.156697 -0.843973 +v -0.739401 0.122343 -0.846089 +v -0.735945 0.086615 -0.846803 +v -0.739401 0.050887 -0.846089 +v -0.749637 0.016532 -0.843973 +v -0.766258 -0.015129 -0.840536 +v -0.788627 -0.042881 -0.835912 +v -0.815884 -0.065656 -0.830277 +v -0.846981 -0.082579 -0.823848 +v -0.880723 -0.093001 -0.816872 +v -0.883030 0.134321 -0.807614 +v -0.852360 0.153154 -0.808200 +v -0.821482 0.179462 -0.809593 +v -0.789666 0.216110 -0.811593 +v -0.767479 0.188359 -0.811941 +v -0.750994 0.156697 -0.812199 +v -0.740842 0.122343 -0.812358 +v -0.737414 0.086615 -0.812412 +v -0.740842 0.050887 -0.812358 +v -0.750994 0.016532 -0.812199 +v -0.767479 -0.015129 -0.811941 +v -0.789666 -0.042881 -0.811593 +v -0.816700 -0.065656 -0.811170 +v -0.847543 -0.082579 -0.810687 +v -0.881009 -0.093001 -0.810162 +v -0.884243 0.136298 -0.801513 +v -0.855270 0.153953 -0.796135 +v -0.825879 0.181847 -0.791462 +v -0.795552 0.216110 -0.787199 +v -0.774401 0.188359 -0.783256 +v -0.758684 0.156697 -0.780326 +v -0.749006 0.122343 -0.778522 +v -0.745738 0.086615 -0.777913 +v -0.749006 0.050887 -0.778522 +v -0.758684 0.016532 -0.780326 +v -0.774401 -0.015129 -0.783256 +v -0.795552 -0.042881 -0.787199 +v -0.821325 -0.065656 -0.792003 +v -0.850728 -0.082579 -0.797484 +v -0.882633 -0.093001 -0.803432 +v -0.886581 0.138241 -0.795686 +v -0.860284 0.155550 -0.784594 +v -0.833500 0.185355 -0.774090 +v -0.806060 0.216110 -0.763666 +v -0.786757 0.188359 -0.755584 +v -0.772413 0.156697 -0.749579 +v -0.763581 0.122343 -0.745881 +v -0.760598 0.086615 -0.744633 +v -0.763581 0.050887 -0.745881 +v -0.772413 0.016532 -0.749579 +v -0.786757 -0.015129 -0.755584 +v -0.806060 -0.042881 -0.763666 +v -0.829580 -0.065656 -0.773514 +v -0.856415 -0.082579 -0.784748 +v -0.885532 -0.093001 -0.796939 +v -0.915813 -0.096520 -0.809617 +v -0.890038 0.139261 -0.790392 +v -0.867286 0.157379 -0.773981 +v -0.844186 0.189447 -0.758088 +v -0.820785 0.216110 -0.741899 +v -0.804072 0.188359 -0.729989 +v -0.791653 0.156697 -0.721139 +v -0.784005 0.122343 -0.715690 +v -0.781423 0.086615 -0.713849 +v -0.784006 0.050887 -0.715690 +v -0.791653 0.016532 -0.721139 +v -0.804072 -0.015129 -0.729989 +v -0.820785 -0.042881 -0.741899 +v -0.841150 -0.065656 -0.756411 +v -0.864384 -0.082579 -0.772968 +v -0.889595 -0.093001 -0.790934 +v -0.894322 0.139212 -0.785920 +v -0.876044 0.159367 -0.764598 +v -0.857691 0.195978 -0.743844 +v -0.839163 0.216110 -0.722734 +v -0.825682 0.188359 -0.707454 +v -0.815664 0.156697 -0.696100 +v -0.809496 0.122343 -0.689107 +v -0.807413 0.086615 -0.686747 +v -0.809496 0.050887 -0.689107 +v -0.815664 0.016532 -0.696100 +v -0.825682 -0.015129 -0.707454 +v -0.839163 -0.042881 -0.722734 +v -0.855589 -0.065656 -0.741354 +v -0.874330 -0.082579 -0.762596 +v -0.894665 -0.093001 -0.785646 +v -0.899407 0.136902 -0.782364 +v -0.886212 0.160376 -0.756934 +v -0.873610 0.206155 -0.731793 +v -0.860485 0.216111 -0.706908 +v -0.850755 0.188359 -0.688845 +v -0.843524 0.156697 -0.675422 +v -0.839072 0.122343 -0.667156 +v -0.837568 0.086615 -0.664366 +v -0.839072 0.050887 -0.667156 +v -0.843524 0.016532 -0.675422 +v -0.850755 -0.015129 -0.688845 +v -0.860486 -0.042881 -0.706909 +v -0.872343 -0.065656 -0.728920 +v -0.885870 -0.082579 -0.754032 +v -0.900548 -0.093001 -0.781280 +v -0.905213 0.133682 -0.779686 +v -0.897519 0.154168 -0.751266 +v -0.891018 0.190104 -0.722776 +v -0.883939 0.216085 -0.695043 +v -0.878328 0.188359 -0.674877 +v -0.874162 0.156697 -0.659902 +v -0.871597 0.122343 -0.650680 +v -0.870730 0.086615 -0.647566 +v -0.871597 0.050887 -0.650680 +v -0.874162 0.016532 -0.659902 +v -0.878328 -0.015129 -0.674877 +v -0.883935 -0.042881 -0.695030 +v -0.890767 -0.065656 -0.719586 +v -0.898561 -0.082579 -0.747603 +v -0.907018 -0.093001 -0.778003 +v -0.911472 0.130539 -0.777970 +v -0.909697 0.147283 -0.747585 +v -0.908971 0.177925 -0.716975 +v -0.908611 0.216063 -0.687581 +v -0.907342 0.188359 -0.666087 +v -0.906401 0.156697 -0.650135 +v -0.905821 0.122343 -0.640312 +v -0.905625 0.086615 -0.636995 +v -0.905821 0.050887 -0.640312 +v -0.906401 0.016532 -0.650135 +v -0.907342 -0.015129 -0.666087 +v -0.908609 -0.042881 -0.687555 +v -0.910153 -0.065656 -0.713713 +v -0.911914 -0.082579 -0.743557 +v -0.913826 -0.093001 -0.775940 +v -0.917902 0.128120 -0.777332 +v -0.922567 0.142034 -0.746162 +v -0.927843 0.174388 -0.715452 +v -0.933559 0.216099 -0.684777 +v -0.936682 0.188359 -0.662813 +v -0.939001 0.156697 -0.646497 +v -0.940429 0.122343 -0.636450 +v -0.940911 0.086615 -0.633057 +v -0.940429 0.050887 -0.636450 +v -0.939001 0.016532 -0.646497 +v -0.936682 -0.015129 -0.662813 +v -0.933560 -0.042881 -0.684770 +v -0.929757 -0.065656 -0.711526 +v -0.925418 -0.082579 -0.742050 +v -0.920710 -0.093001 -0.775172 +v -0.924157 0.126903 -0.777864 +v -0.934944 0.144173 -0.747654 +v -0.946151 0.174107 -0.717342 +v -0.957829 0.216110 -0.686784 +v -0.965219 0.188359 -0.665180 +v -0.970710 0.156697 -0.649127 +v -0.974091 0.122343 -0.639242 +v -0.975233 0.086615 -0.635904 +v -0.974091 0.050887 -0.639242 +v -0.970710 0.016532 -0.649127 +v -0.965219 -0.015129 -0.665180 +v -0.957829 -0.042881 -0.686784 +v -0.948825 -0.065656 -0.713107 +v -0.938552 -0.082579 -0.743140 +v -0.927406 -0.093001 -0.775727 +v -0.929866 0.126199 -0.779497 +v -0.946461 0.143623 -0.750732 +v -0.963214 0.173672 -0.722347 +v -0.980484 0.216110 -0.693517 +v -0.991858 0.188359 -0.673098 +v -1.000310 0.156697 -0.657926 +v -1.005514 0.122343 -0.648582 +v -1.007271 0.086615 -0.645427 +v -1.005514 0.050887 -0.648582 +v -1.000310 0.016532 -0.657925 +v -0.991858 -0.015129 -0.673098 +v -0.980484 -0.042881 -0.693517 +v -0.966625 -0.065656 -0.718398 +v -0.950813 -0.082579 -0.746784 +v -0.933656 -0.093001 -0.777585 +v -0.913940 0.125338 -0.808007 +v -0.934807 0.125877 -0.782239 +v -0.956393 0.142260 -0.756222 +v -0.978324 0.173236 -0.730608 +v -1.000652 0.216104 -0.704714 +v -1.015574 0.188359 -0.686263 +v -1.026662 0.156697 -0.672553 +v -1.033490 0.122343 -0.664111 +v -1.035795 0.086615 -0.661260 +v -1.033490 0.050887 -0.664111 +v -1.026662 0.016532 -0.672553 +v -1.015574 -0.015129 -0.686263 +v -1.000653 -0.042881 -0.704713 +v -0.982472 -0.065656 -0.727194 +v -0.961728 -0.082579 -0.752843 +v -0.939221 -0.093001 -0.780674 +v -0.938915 0.124942 -0.785940 +v -0.964687 0.141063 -0.763793 +v -0.990995 0.171360 -0.741843 +v -1.012732 0.204442 -0.723513 +v -1.035457 0.188359 -0.704168 +v -1.048754 0.156697 -0.692448 +v -1.056943 0.122343 -0.685231 +v -1.059708 0.086615 -0.682794 +v -1.056943 0.050887 -0.685231 +v -1.048754 0.016532 -0.692448 +v -1.035457 -0.015129 -0.704168 +v -1.017562 -0.042881 -0.719940 +v -0.995757 -0.065656 -0.739158 +v -0.970879 -0.082579 -0.761084 +v -0.943886 -0.093001 -0.784875 +vn -0.861873 0.201025 0.465529 +vn -0.809168 0.392834 0.436903 +vn -0.887997 0.386761 0.248665 +vn 0.394879 0.839015 -0.374310 +vn 0.094180 0.969878 -0.224616 +vn 0.142857 0.980804 -0.132603 +vn -0.480361 -0.838008 0.258736 +vn -0.613453 -0.717124 0.330729 +vn -0.532456 -0.833369 0.148076 +vn -0.879818 0.000000 0.475295 +vn -0.943876 0.197516 0.264595 +vn 0.590258 0.691916 -0.415693 +vn 0.474441 0.846034 -0.243110 +vn -0.331217 -0.926572 0.178137 +vn -0.368175 -0.924131 0.101962 +vn -0.861873 -0.201025 0.465529 +vn -0.943907 -0.197516 0.264595 +vn 0.189673 0.975921 -0.107700 +vn 0.702384 0.658223 -0.270852 +vn -0.171422 -0.980865 0.091922 +vn -0.190832 -0.980193 0.052400 +vn -0.809168 -0.392834 0.436903 +vn -0.887997 -0.386761 0.248665 +vn -0.605640 0.725700 0.326365 +vn 0.164586 0.966399 -0.197302 +vn -0.724815 -0.567095 0.391125 +vn -0.797845 -0.560015 0.223029 +vn -0.655782 0.738701 0.155553 +vn -0.677633 -0.710685 0.188971 +vn -0.711539 -0.701315 0.042573 +vn -0.924009 0.378124 0.056398 +vn 0.155950 0.987335 -0.028169 +vn -0.561846 -0.826563 0.033082 +vn -0.962828 0.000000 0.269997 +vn -0.979430 0.192572 0.060091 +vn 0.498184 0.863155 -0.082034 +vn -0.389996 -0.920530 0.022462 +vn -0.979430 -0.192572 0.060091 +vn 0.703879 0.698325 -0.129795 +vn -0.202521 -0.979186 0.011109 +vn -0.924009 -0.378124 0.056398 +vn 0.289987 0.948912 -0.124119 +vn -0.833705 -0.549883 0.050478 +vn -0.624317 0.780145 0.039735 +vn -0.834376 -0.538530 -0.117313 +vn -0.651082 0.755608 -0.071535 +vn -0.715964 -0.690725 -0.101138 +vn -0.920560 0.368603 -0.128971 +vn 0.161199 0.979705 0.118992 +vn -0.568407 -0.818751 -0.080813 +vn -0.998108 0.000000 0.061342 +vn -0.972869 0.187139 -0.135990 +vn 0.502365 0.849117 0.163060 +vn -0.396313 -0.916318 -0.056887 +vn -0.972869 -0.187139 -0.135990 +vn 0.718192 0.680074 0.147099 +vn -0.206183 -0.978027 -0.030183 +vn -0.920560 -0.368603 -0.128971 +vn 0.332011 0.932249 0.143742 +vn -0.202002 -0.976867 -0.069918 +vn -0.883328 -0.359722 -0.300485 +vn 0.224616 0.896847 0.380993 +vn -0.803980 -0.527818 -0.273812 +vn -0.724967 0.662526 -0.188147 +vn -0.693411 -0.680563 -0.236610 +vn -0.883328 0.359722 -0.300485 +vn 0.152043 0.954375 0.256935 +vn -0.553331 -0.811121 -0.189276 +vn -0.990356 0.000000 -0.138340 +vn -0.930937 0.182104 -0.316446 +vn 0.647175 0.650899 0.396802 +vn -0.387463 -0.912198 -0.133030 +vn -0.930937 -0.182104 -0.316446 +vn 0.461715 0.803247 0.376232 +vn 0.588702 0.623493 0.514420 +vn -0.364360 -0.908750 -0.203345 +vn -0.946806 0.000000 -0.321757 +vn -0.860256 -0.178137 -0.477645 +vn -0.084719 0.987396 0.133488 +vn -0.190283 -0.975890 -0.106662 +vn -0.818018 -0.352641 -0.454360 +vn -0.747002 -0.519181 -0.415174 +vn -0.746849 0.519608 -0.414899 +vn -0.646901 -0.672262 -0.359874 +vn -0.818018 0.352641 -0.454360 +vn 0.428510 0.772362 0.468825 +vn -0.518448 -0.804834 -0.288797 +vn -0.860256 0.178137 -0.477645 +vn -0.729270 0.348094 -0.589038 +vn 0.136876 0.934690 0.327982 +vn 0.369884 0.764306 0.528153 +vn -0.465773 -0.800714 -0.376690 +vn -0.874264 0.000000 -0.485366 +vn -0.765893 0.175604 -0.618519 +vn 0.524979 0.645924 0.554186 +vn -0.328166 -0.906461 -0.265633 +vn -0.765893 -0.175604 -0.618519 +vn -0.171667 -0.975249 -0.139225 +vn -0.729270 -0.348094 -0.589038 +vn -0.030244 0.999146 -0.027039 +vn -0.667379 -0.513627 -0.539201 +vn -0.667379 0.513627 -0.539201 +vn -0.579516 -0.666860 -0.468398 +vn -0.568072 -0.511704 -0.644520 +vn -0.568072 0.511704 -0.644520 +vn -0.493789 -0.664968 -0.560259 +vn -0.620228 0.346538 -0.703696 +vn 0.113315 0.925291 0.361888 +vn 0.312662 0.748924 0.584246 +vn -0.397351 -0.799249 -0.450850 +vn -0.777978 0.000000 -0.628254 +vn -0.651021 0.174718 -0.738639 +vn 0.385876 0.662557 0.641926 +vn -0.280313 -0.905667 -0.318033 +vn -0.651021 -0.174718 -0.738639 +vn -0.047487 0.998260 -0.034089 +vn -0.146794 -0.975036 -0.166570 +vn -0.620228 -0.346538 -0.703696 +vn -0.222327 -0.906461 -0.358989 +vn -0.517441 -0.175573 -0.837489 +vn -0.451125 0.513596 -0.729850 +vn -0.492782 -0.348064 -0.797479 +vn -0.492782 0.348064 -0.797479 +vn -0.451125 -0.513565 -0.729850 +vn -0.517441 0.175573 -0.837489 +vn 0.094211 0.919401 0.381848 +vn 0.285684 0.740074 0.608783 +vn -0.391919 -0.666799 -0.633808 +vn -0.661184 0.000000 -0.750175 +vn -0.525559 0.000000 -0.850734 +vn 0.319163 0.676260 0.663900 +vn -0.315226 -0.800653 -0.509445 +vn -0.058168 0.996155 -0.065340 +vn 0.244942 0.685903 0.685171 +vn -0.221473 -0.804743 -0.550707 +vn -0.371807 0.000000 -0.928281 +vn -0.043703 0.994903 -0.090762 +vn -0.116581 -0.975249 -0.187811 +vn -0.156041 -0.908719 -0.387097 +vn -0.365917 -0.178076 -0.913419 +vn -0.318155 0.519089 -0.793268 +vn -0.348125 -0.352550 -0.868618 +vn -0.348125 0.352550 -0.868618 +vn -0.318155 -0.519089 -0.793268 +vn -0.365917 0.178076 -0.913419 +vn 0.166204 0.917997 0.359996 +vn 0.236641 0.738182 0.631703 +vn -0.275857 -0.672170 -0.687063 +vn -0.197211 0.182043 -0.963286 +vn 0.235359 0.912442 0.334666 +vn 0.169317 0.729820 0.662282 +vn -0.147832 -0.680410 -0.717734 +vn -0.200507 0.000000 -0.979675 +vn 0.147557 0.690542 0.708029 +vn -0.118442 -0.811029 -0.572863 +vn -0.033296 0.993622 -0.107547 +vn -0.081942 -0.975890 -0.202216 +vn -0.083438 -0.912137 -0.401227 +vn -0.197211 -0.182043 -0.963286 +vn -0.170873 0.527665 -0.832057 +vn -0.187353 -0.359600 -0.914090 +vn -0.187353 0.359600 -0.914090 +vn -0.170873 -0.527665 -0.832057 +vn -0.012696 -0.368450 -0.929533 +vn -0.012696 0.368450 -0.929533 +vn -0.011902 -0.538347 -0.842616 +vn -0.013123 0.187048 -0.982238 +vn 0.163793 0.919126 0.358226 +vn 0.124119 0.733299 0.668477 +vn -0.010712 -0.690542 -0.723167 +vn -0.013276 0.000000 -0.999908 +vn 0.119846 0.670827 0.731834 +vn -0.009033 -0.818628 -0.574236 +vn -0.004913 0.993805 -0.110752 +vn -0.044038 -0.976836 -0.209235 +vn -0.006806 -0.916257 -0.400464 +vn -0.013123 -0.187048 -0.982238 +vn -0.011902 0.538347 -0.842616 +vn -0.004120 -0.977996 -0.208441 +vn 0.071078 -0.920469 -0.384289 +vn 0.182073 -0.192480 -0.964232 +vn 0.154302 0.549699 -0.820948 +vn 0.171484 -0.378002 -0.909757 +vn 0.171484 0.378002 -0.909757 +vn 0.154302 -0.549699 -0.820948 +vn 0.182073 0.192480 -0.964232 +vn 0.086184 0.925077 0.369793 +vn -0.064669 0.946013 0.317515 +vn 0.131230 -0.701163 -0.700797 +vn 0.185644 0.000000 -0.982604 +vn 0.061098 0.764367 0.641865 +vn 0.103092 -0.826441 -0.553453 +vn 0.023621 0.996399 -0.081210 +vn 0.213416 -0.833277 -0.509964 +vn 0.388104 0.000000 -0.921598 +vn 0.023347 0.660939 0.750053 +vn 0.026734 0.998230 -0.052797 +vn 0.036348 -0.979186 -0.199622 +vn 0.147160 -0.924070 -0.352672 +vn 0.380383 -0.197455 -0.903500 +vn 0.320933 0.559893 -0.763848 +vn 0.357585 -0.386639 -0.850063 +vn 0.357585 0.386639 -0.850063 +vn 0.320933 -0.559893 -0.763848 +vn 0.380383 0.197455 -0.903500 +vn -0.084780 0.949034 0.303476 +vn 0.272164 -0.710532 -0.648854 +vn -0.090457 0.807550 0.582781 +vn -0.091128 0.962859 0.254067 +vn 0.404706 -0.717032 -0.567461 +vn 0.581317 0.000000 -0.813654 +vn -0.194952 0.679647 0.707144 +vn -0.317576 0.829768 0.458876 +vn 0.316660 -0.837947 -0.444411 +vn 0.027711 0.998840 -0.038850 +vn 0.075838 -0.980193 -0.182867 +vn 0.218085 -0.926542 -0.306467 +vn 0.569384 -0.200995 -0.797082 +vn 0.478500 0.567003 -0.670431 +vn 0.534410 -0.392773 -0.748375 +vn 0.534410 0.392773 -0.748375 +vn 0.478500 -0.567003 -0.670431 +vn 0.569384 0.200995 -0.797082 +vn 0.688894 0.395001 -0.607746 +vn 0.616321 -0.569597 -0.543718 +vn 0.734367 0.202277 -0.647877 +vn -0.496139 0.814081 0.301798 +vn 0.520859 -0.719382 -0.459517 +vn 0.749870 0.000000 -0.661550 +vn -0.421827 0.695151 0.582049 +vn -0.596637 0.698996 0.394177 +vn 0.407270 -0.839625 -0.359294 +vn 0.035035 0.998749 -0.034913 +vn 0.112613 -0.980865 -0.158666 +vn 0.280435 -0.927427 -0.247414 +vn 0.734367 -0.202277 -0.647877 +vn 0.616321 0.569597 -0.543718 +vn 0.688894 -0.395001 -0.607746 +vn 0.809168 -0.392834 -0.436903 +vn 0.052553 0.997986 -0.034700 +vn 0.724845 -0.567095 -0.391125 +vn 0.724845 0.567095 -0.391125 +vn 0.613453 -0.717124 -0.330729 +vn 0.809168 0.392834 -0.436903 +vn -0.268136 0.958678 0.094790 +vn -0.612995 0.781426 0.116489 +vn 0.480361 -0.838008 -0.258736 +vn 0.861873 0.201025 -0.465529 +vn -0.699850 0.692343 0.175634 +vn 0.331217 -0.926572 -0.178137 +vn 0.861873 -0.201025 -0.465529 +vn 0.144963 -0.981109 -0.127903 +vn 0.171422 -0.980865 -0.091922 +vn 0.368175 -0.924131 -0.101962 +vn 0.879818 0.000000 -0.475295 +vn 0.943907 -0.197516 -0.264595 +vn 0.078158 0.996704 -0.021363 +vn 0.190832 -0.980193 -0.052400 +vn 0.887997 -0.386761 -0.248665 +vn 0.797845 -0.560015 -0.223029 +vn 0.797845 0.560015 -0.223029 +vn 0.677633 -0.710685 -0.188971 +vn 0.887997 0.386761 -0.248665 +vn -0.388928 0.916501 -0.093387 +vn -0.661489 0.749840 -0.011048 +vn 0.532456 -0.833369 -0.148076 +vn 0.943907 0.197516 -0.264595 +vn -0.682669 0.715537 0.148015 +vn -0.437452 0.870724 -0.224525 +vn -0.430403 0.866634 -0.252235 +vn 0.561846 -0.826563 -0.033082 +vn 0.962828 0.000000 -0.269997 +vn 0.979430 0.192572 -0.060091 +vn -0.628407 0.775262 -0.063478 +vn 0.389996 -0.920530 -0.022462 +vn 0.979430 -0.192572 -0.060091 +vn -0.678762 0.723991 0.122898 +vn 0.202490 -0.979186 -0.011109 +vn 0.924009 -0.378124 -0.056398 +vn 0.075320 0.997131 0.005707 +vn 0.833705 -0.549883 -0.050478 +vn 0.833705 0.549883 -0.050478 +vn 0.711539 -0.701315 -0.042573 +vn 0.924009 0.378124 -0.056398 +vn 0.834376 0.538530 0.117313 +vn 0.715995 -0.690725 0.101138 +vn 0.920560 0.368603 0.128971 +vn -0.399030 0.868129 -0.295114 +vn 0.568407 -0.818751 0.080813 +vn 0.998108 0.000000 -0.061373 +vn 0.972839 0.187139 0.135990 +vn -0.590625 0.791253 -0.158269 +vn 0.396313 -0.916318 0.056887 +vn 0.972839 -0.187139 0.135990 +vn -0.701682 0.700797 -0.128239 +vn 0.206183 -0.978027 0.030183 +vn 0.920560 -0.368603 0.128971 +vn 0.070742 0.997406 0.011719 +vn 0.834376 -0.538530 0.117313 +vn 0.883328 -0.359722 0.300485 +vn 0.082125 0.996277 0.024995 +vn 0.803980 -0.527818 0.273812 +vn 0.803980 0.527818 0.273812 +vn 0.693411 -0.680563 0.236610 +vn 0.883328 0.359722 0.300485 +vn -0.353648 0.861049 -0.365368 +vn 0.553362 -0.811121 0.189276 +vn 0.990356 0.000000 0.138340 +vn 0.930937 0.182104 0.316446 +vn -0.557207 0.784204 -0.272958 +vn 0.387463 -0.912198 0.133030 +vn 0.930937 -0.182104 0.316446 +vn -0.661977 0.674215 -0.327342 +vn 0.202002 -0.976867 0.069918 +vn 0.364360 -0.908750 0.203345 +vn 0.946806 0.000000 0.321757 +vn 0.860256 -0.178137 0.477676 +vn -0.585620 0.668844 -0.457839 +vn 0.190283 -0.975890 0.106662 +vn 0.818018 -0.352641 0.454360 +vn 0.099612 0.993957 0.046022 +vn 0.747002 -0.519181 0.415174 +vn 0.747002 0.519181 0.415174 +vn 0.646901 -0.672262 0.359874 +vn 0.818018 0.352641 0.454360 +vn -0.511399 0.759301 -0.402326 +vn 0.518448 -0.804834 0.288797 +vn 0.860256 0.178137 0.477645 +vn 0.465773 -0.800714 0.376690 +vn 0.874264 0.000000 0.485397 +vn 0.765893 0.175604 0.618519 +vn -0.463149 0.689291 -0.557085 +vn 0.328166 -0.906461 0.265633 +vn 0.765893 -0.175604 0.618519 +vn 0.171667 -0.975249 0.139225 +vn 0.729270 -0.348094 0.589038 +vn 0.099399 0.991485 0.083743 +vn 0.667379 -0.513627 0.539201 +vn 0.667379 0.513627 0.539201 +vn 0.579516 -0.666860 0.468398 +vn 0.729270 0.348094 0.589038 +vn -0.317911 0.862300 -0.394116 +vn -0.449049 0.737602 -0.504227 +vn 0.493789 -0.664998 0.560259 +vn 0.620228 0.346538 0.703696 +vn -0.344127 0.863186 -0.369366 +vn -0.418256 0.689077 -0.591754 +vn 0.397351 -0.799249 0.450850 +vn 0.777978 0.000000 0.628254 +vn 0.651021 0.174718 0.738639 +vn -0.235389 0.724601 -0.647694 +vn 0.280313 -0.905667 0.318033 +vn 0.651021 -0.174718 0.738639 +vn 0.132908 0.984802 0.111545 +vn 0.146794 -0.975036 0.166570 +vn 0.620228 -0.346538 0.703696 +vn 0.568072 -0.511704 0.644520 +vn 0.568072 0.511704 0.644520 +vn 0.451125 0.513565 0.729850 +vn 0.492782 -0.348064 0.797479 +vn 0.492782 0.348064 0.797479 +vn 0.451125 -0.513565 0.729850 +vn 0.517441 0.175573 0.837489 +vn -0.451216 0.846889 -0.281289 +vn -0.526963 0.814142 -0.243812 +vn 0.391919 -0.666799 0.633808 +vn 0.661184 0.000000 0.750175 +vn 0.525559 0.000000 0.850734 +vn -0.366588 0.825587 -0.428938 +vn 0.315226 -0.800653 0.509445 +vn 0.090823 0.976196 0.196814 +vn 0.222327 -0.906461 0.358989 +vn 0.517441 -0.175573 0.837489 +vn 0.371807 0.000000 0.928281 +vn -0.623188 0.634205 -0.457564 +vn 0.116581 -0.975249 0.187811 +vn 0.156041 -0.908719 0.387097 +vn 0.365917 -0.178076 0.913419 +vn 0.318033 0.519303 0.793176 +vn 0.348125 -0.352550 0.868618 +vn 0.348125 0.352550 0.868618 +vn 0.318155 -0.519089 0.793268 +vn 0.365917 0.178076 0.913419 +vn -0.512467 0.624989 -0.588794 +vn -0.520829 0.813623 -0.258309 +vn 0.275857 -0.672170 0.687063 +vn -0.570544 0.649983 -0.501968 +vn 0.221473 -0.804743 0.550707 +vn 0.147832 -0.680410 0.717734 +vn 0.200507 0.000000 0.979675 +vn -0.453413 0.716880 -0.529557 +vn 0.118442 -0.811029 0.572863 +vn -0.000916 0.994751 0.102298 +vn -0.361278 0.629170 -0.688162 +vn 0.081942 -0.975890 0.202246 +vn 0.083438 -0.912137 0.401227 +vn 0.197211 -0.182043 0.963286 +vn 0.170751 0.528184 0.831751 +vn 0.187353 -0.359600 0.914090 +vn 0.187353 0.359600 0.914090 +vn 0.170873 -0.527665 0.832057 +vn 0.197211 0.182043 0.963286 +vn -0.427473 0.859035 -0.281533 +vn 0.011902 -0.538347 0.842616 +vn 0.013123 0.187048 0.982238 +vn -0.241737 0.920347 -0.307382 +vn 0.010712 -0.690542 0.723167 +vn 0.013276 0.000000 0.999908 +vn -0.077853 0.826014 -0.558214 +vn 0.009033 -0.818628 0.574236 +vn 0.016114 0.999054 0.040284 +vn 0.003021 0.999298 0.036927 +vn 0.044038 -0.976836 0.209235 +vn 0.006806 -0.916257 0.400464 +vn 0.013123 -0.187048 0.982238 +vn 0.012024 0.538621 0.842433 +vn 0.012696 -0.368450 0.929533 +vn 0.012696 0.368450 0.929533 +vn -0.154271 0.549730 0.820948 +vn -0.171484 -0.378002 0.909757 +vn -0.171484 0.378002 0.909757 +vn -0.154332 -0.549699 0.820948 +vn -0.182073 0.192480 0.964232 +vn 0.154027 0.811884 -0.563097 +vn -0.131230 -0.701163 0.700797 +vn -0.185675 0.000000 0.982604 +vn -0.054781 0.636555 -0.769250 +vn 0.137852 0.661641 -0.736991 +vn -0.103092 -0.826441 0.553453 +vn 0.002106 0.999268 0.037935 +vn 0.004120 -0.977996 0.208441 +vn -0.071078 -0.920469 0.384289 +vn -0.182073 -0.192480 0.964232 +vn -0.388104 0.000000 0.921598 +vn -0.010132 0.999207 0.038087 +vn -0.036348 -0.979186 0.199622 +vn -0.147160 -0.924070 0.352672 +vn -0.380383 -0.197455 0.903500 +vn -0.320933 0.559893 0.763848 +vn -0.357585 -0.386639 0.850063 +vn -0.357585 0.386639 0.850063 +vn -0.320933 -0.559893 0.763848 +vn -0.380383 0.197455 0.903500 +vn -0.087680 0.942198 -0.323313 +vn 0.161962 0.802240 -0.574541 +vn -0.272134 -0.710532 0.648854 +vn 0.266884 0.674306 -0.688498 +vn -0.213416 -0.833277 0.509964 +vn -0.404706 -0.717032 0.567461 +vn -0.581317 0.000000 0.813654 +vn 0.383526 0.676107 -0.629078 +vn -0.316660 -0.837947 0.444441 +vn -0.134465 0.988800 -0.064394 +vn -0.075838 -0.980193 0.182867 +vn -0.218085 -0.926542 0.306467 +vn -0.569384 -0.200995 0.797082 +vn -0.478500 0.567064 0.670400 +vn -0.534410 -0.392773 0.748375 +vn -0.534410 0.392773 0.748375 +vn -0.478500 -0.567003 0.670431 +vn -0.569384 0.200995 0.797082 +vn 0.022523 0.957884 -0.286233 +vn 0.260842 0.812372 -0.521470 +vn -0.616321 -0.569597 0.543718 +vn -0.734367 0.202277 0.647877 +vn 0.057894 0.960967 -0.270486 +vn 0.049989 0.958129 -0.281869 +vn -0.520829 -0.719382 0.459517 +vn -0.749870 0.000000 0.661550 +vn 0.336131 0.820551 -0.462233 +vn -0.407270 -0.839625 0.359294 +vn 0.446883 0.688650 -0.570971 +vn -0.112613 -0.980865 0.158666 +vn -0.280435 -0.927427 0.247414 +vn -0.734367 -0.202277 0.647877 +vn -0.592700 0.669393 0.447829 +vn -0.688894 -0.395001 0.607746 +vn -0.688894 0.395001 0.607746 +vn -0.159246 0.985504 -0.057985 +vn -0.144963 -0.981109 0.127903 +vn -0.023957 0.937956 -0.345897 +usemtl Body +s 1 +f 5309//3529 5308//3530 5323//3531 +f 5304//3532 5303//3533 5318//3534 +f 5315//3535 5314//3536 5330//3537 +f 5310//3538 5309//3529 5324//3539 +f 5305//3540 5304//3532 5319//3541 +f 5316//3542 5315//3535 5331//3543 +f 5311//3544 5310//3538 5326//3545 +f 5306//3546 5305//3540 5320//3547 +f 5317//3548 5316//3542 5332//3549 +f 5312//3550 5311//3544 5327//3551 +f 5307//3552 5306//3546 5321//3553 +f 5313//3554 5312//3550 5328//3555 +f 5308//3530 5307//3552 5322//3556 +f 5314//3536 5313//3554 5329//3557 +f 5329//3557 5328//3555 5344//3558 +f 5324//3539 5323//3531 5338//3559 +f 5319//3541 5318//3534 5333//3560 +f 5330//3537 5329//3557 5345//3561 +f 5325//3562 5324//3539 5339//3563 +f 5320//3547 5319//3541 5334//3564 +f 5331//3543 5330//3537 5346//3565 +f 5326//3545 5325//3562 5341//3566 +f 5321//3553 5320//3547 5335//3567 +f 5332//3549 5331//3543 5347//3568 +f 5327//3551 5326//3545 5342//3569 +f 5322//3556 5321//3553 5336//3570 +f 5328//3555 5327//3551 5343//3571 +f 5323//3531 5322//3556 5337//3572 +f 5343//3571 5342//3569 5358//3573 +f 5338//3559 5337//3572 5352//3574 +f 5344//3558 5343//3571 5359//3575 +f 5339//3563 5338//3559 5353//3576 +f 5334//3564 5333//3560 5348//3577 +f 5345//3561 5344//3558 5360//3578 +f 5340//3579 5339//3563 5354//3580 +f 5335//3567 5334//3564 5349//3581 +f 5346//3565 5345//3561 5361//3582 +f 5341//3566 5340//3579 5356//3583 +f 5336//3570 5335//3567 5350//3584 +f 5347//3568 5346//3565 5362//3585 +f 5342//3569 5341//3566 5357//3586 +f 5337//3572 5336//3570 5351//3587 +f 5362//3585 5361//3582 5377//3588 +f 5357//3586 5356//3583 5372//3589 +f 5352//3574 5351//3587 5366//3590 +f 5358//3573 5357//3586 5373//3591 +f 5353//3576 5352//3574 5367//3592 +f 5359//3575 5358//3573 5374//3593 +f 5354//3580 5353//3576 5368//3594 +f 5349//3581 5348//3577 5363//3595 +f 5360//3578 5359//3575 5375//3596 +f 5355//3597 5354//3580 5369//3598 +f 5350//3584 5349//3581 5365//3599 +f 5361//3582 5360//3578 5376//3600 +f 5356//3583 5355//3597 5371//3601 +f 5351//3587 5350//3584 5366//3590 +f 5365//3599 5364//3602 5380//3603 +f 5376//3600 5375//3596 5391//3604 +f 5371//3601 5370//3605 5386//3606 +f 5366//3590 5365//3599 5381//3607 +f 5377//3588 5376//3600 5392//3608 +f 5372//3589 5371//3601 5387//3609 +f 5367//3592 5366//3590 5381//3607 +f 5373//3591 5372//3589 5388//3610 +f 5368//3594 5367//3592 5382//3611 +f 5374//3593 5373//3591 5389//3612 +f 5369//3598 5368//3594 5383//3613 +f 5364//3602 5363//3595 5379//3614 +f 5375//3596 5374//3593 5390//3615 +f 5370//3605 5369//3598 5384//3616 +f 5384//3616 5383//3613 5398//3617 +f 5379//3614 5378//3618 5394//3619 +f 5390//3615 5389//3612 5405//3620 +f 5385//3621 5384//3616 5399//3622 +f 5380//3603 5379//3614 5395//3623 +f 5391//3604 5390//3615 5406//3624 +f 5386//3606 5385//3621 5401//3625 +f 5381//3607 5380//3603 5395//3623 +f 5392//3608 5391//3604 5407//3626 +f 5387//3609 5386//3606 5402//3627 +f 5382//3611 5381//3607 5396//3628 +f 5388//3610 5387//3609 5403//3629 +f 5383//3613 5382//3611 5397//3630 +f 5389//3612 5388//3610 5404//3631 +f 5403//3629 5402//3627 5418//3632 +f 5398//3617 5397//3630 5412//3633 +f 5404//3631 5403//3629 5419//3634 +f 5399//3622 5398//3617 5413//3635 +f 5394//3619 5393//3636 5409//3637 +f 5405//3620 5404//3631 5420//3638 +f 5400//3639 5399//3622 5414//3640 +f 5395//3623 5394//3619 5410//3641 +f 5406//3624 5405//3620 5421//3642 +f 5401//3625 5400//3639 5416//3643 +f 5396//3628 5395//3623 5411//3644 +f 5407//3626 5406//3624 5422//3645 +f 5402//3627 5401//3625 5417//3646 +f 5397//3630 5396//3628 5411//3644 +f 5422//3645 5421//3642 5436//3647 +f 5417//3646 5416//3643 5431//3648 +f 5412//3633 5411//3644 5427//3649 +f 5418//3632 5417//3646 5432//3650 +f 5413//3635 5412//3633 5428//3651 +f 5419//3634 5418//3632 5433//3652 +f 5414//3640 5413//3635 5429//3653 +f 5409//3637 5408//3654 5424//3655 +f 5420//3638 5419//3634 5434//3656 +f 5415//3657 5414//3640 5430//3658 +f 5410//3641 5409//3637 5425//3659 +f 5421//3642 5420//3638 5435//3660 +f 5416//3643 5415//3657 5430//3658 +f 5411//3644 5410//3641 5426//3661 +f 5425//3659 5424//3655 5440//3662 +f 5436//3647 5435//3660 5450//3663 +f 5431//3648 5430//3658 5445//3664 +f 5426//3661 5425//3659 5441//3665 +f 5437//3666 5436//3647 5451//3667 +f 5432//3650 5431//3648 5446//3668 +f 5427//3649 5426//3661 5442//3669 +f 5433//3652 5432//3650 5447//3670 +f 5428//3651 5427//3649 5443//3671 +f 5434//3656 5433//3652 5448//3672 +f 5429//3653 5428//3651 5444//3673 +f 5424//3655 5423//3674 5439//3675 +f 5435//3660 5434//3656 5449//3676 +f 5430//3658 5429//3653 5445//3664 +f 5444//3673 5443//3671 5459//3677 +f 5439//3675 5438//3678 5454//3679 +f 5450//3663 5449//3676 5464//3680 +f 5445//3664 5444//3673 5460//3681 +f 5440//3662 5439//3675 5455//3682 +f 5451//3667 5450//3663 5465//3683 +f 5446//3668 5445//3664 5460//3681 +f 5441//3665 5440//3662 5456//3684 +f 5452//3685 5451//3667 5466//3686 +f 5447//3670 5446//3668 5461//3687 +f 5442//3669 5441//3665 5457//3688 +f 5448//3672 5447//3670 5462//3689 +f 5443//3671 5442//3669 5458//3690 +f 5449//3676 5448//3672 5463//3691 +f 5463//3691 5462//3689 5477//3692 +f 5458//3690 5457//3688 5473//3693 +f 5464//3680 5463//3691 5478//3694 +f 5459//3677 5458//3690 5474//3695 +f 5454//3679 5453//3696 5469//3697 +f 5465//3683 5464//3680 5479//3698 +f 5460//3681 5459//3677 5475//3699 +f 5455//3682 5454//3679 5470//3700 +f 5466//3686 5465//3683 5480//3701 +f 5461//3687 5460//3681 5475//3699 +f 5456//3684 5455//3682 5471//3702 +f 5467//3703 5466//3686 5481//3704 +f 5462//3689 5461//3687 5476//3705 +f 5457//3688 5456//3684 5472//3706 +f 5482//3707 5481//3704 5496//3708 +f 5477//3692 5476//3705 5491//3709 +f 5472//3706 5471//3702 5487//3710 +f 5478//3694 5477//3692 5492//3711 +f 5473//3693 5472//3706 5488//3712 +f 5479//3698 5478//3694 5493//3713 +f 5474//3695 5473//3693 5489//3714 +f 5469//3697 5468//3715 5483//3716 +f 5480//3701 5479//3698 5494//3717 +f 5475//3699 5474//3695 5490//3718 +f 5470//3700 5469//3697 5484//3719 +f 5481//3704 5480//3701 5495//3720 +f 5476//3705 5475//3699 5490//3718 +f 5471//3702 5470//3700 5486//3721 +f 5496//3708 5495//3720 5510//3722 +f 5491//3709 5490//3718 5505//3723 +f 5486//3721 5485//3724 5501//3725 +f 5497//3726 5496//3708 5511//3727 +f 5492//3711 5491//3709 5506//3728 +f 5487//3710 5486//3721 5502//3729 +f 5493//3713 5492//3711 5507//3730 +f 5488//3712 5487//3710 5503//3731 +f 5494//3717 5493//3713 5508//3732 +f 5489//3714 5488//3712 5504//3733 +f 5484//3719 5483//3716 5498//3734 +f 5495//3720 5494//3717 5509//3735 +f 5490//3718 5489//3714 5505//3723 +f 5485//3724 5484//3719 5499//3736 +f 5499//3736 5498//3734 5513//3737 +f 5510//3722 5509//3735 5524//3738 +f 5505//3723 5504//3733 5520//3739 +f 5500//3740 5499//3736 5514//3741 +f 5511//3727 5510//3722 5525//3742 +f 5506//3728 5505//3723 5520//3739 +f 5501//3725 5500//3740 5516//3743 +f 5512//3744 5511//3727 5526//3745 +f 5507//3730 5506//3728 5521//3746 +f 5502//3729 5501//3725 5517//3747 +f 5508//3732 5507//3730 5522//3748 +f 5503//3731 5502//3729 5518//3749 +f 5509//3735 5508//3732 5523//3750 +f 5504//3733 5503//3731 5519//3751 +f 5518//3749 5517//3747 5533//3752 +f 5524//3738 5523//3750 5538//3753 +f 5519//3751 5518//3749 5534//3754 +f 5514//3741 5513//3737 5529//3755 +f 5525//3742 5524//3738 5539//3756 +f 5520//3739 5519//3751 5535//3757 +f 5515//3758 5514//3741 5530//3759 +f 5526//3745 5525//3742 5540//3760 +f 5521//3746 5520//3739 5535//3757 +f 5516//3743 5515//3758 5531//3761 +f 5527//3762 5526//3745 5541//3763 +f 5522//3748 5521//3746 5536//3764 +f 5517//3747 5516//3743 5532//3765 +f 5523//3750 5522//3748 5537//3766 +f 5537//3766 5536//3764 5552//3767 +f 5532//3765 5531//3761 5546//3768 +f 5538//3753 5537//3766 5553//3769 +f 5533//3752 5532//3765 5547//3770 +f 5539//3756 5538//3753 5554//3771 +f 5534//3754 5533//3752 5548//3772 +f 5529//3755 5528//3773 5544//3774 +f 5540//3760 5539//3756 5555//3775 +f 5535//3757 5534//3754 5549//3776 +f 5530//3759 5529//3755 5545//3777 +f 5541//3763 5540//3760 5556//3778 +f 5536//3764 5535//3757 5551//3779 +f 5531//3761 5530//3759 5546//3768 +f 5542//3780 5541//3763 5557//3781 +f 5556//3778 5555//3775 5571//3782 +f 5551//3779 5550//3783 5566//3784 +f 5546//3768 5545//3777 5561//3785 +f 5557//3781 5556//3778 5572//3786 +f 5552//3767 5551//3779 5567//3787 +f 5547//3770 5546//3768 5561//3785 +f 5553//3769 5552//3767 5568//3788 +f 5548//3772 5547//3770 5562//3789 +f 5554//3771 5553//3769 5569//3790 +f 5549//3776 5548//3772 5563//3791 +f 5544//3774 5543//3792 5559//3793 +f 5555//3775 5554//3771 5570//3794 +f 5550//3783 5549//3776 5564//3795 +f 5545//3777 5544//3774 5560//3796 +f 5559//3793 5558//3797 5573//3798 +f 5570//3794 5569//3790 5585//3799 +f 5565//3800 5564//3795 5579//3801 +f 5560//3796 5559//3793 5574//3802 +f 5571//3782 5570//3794 5586//3803 +f 5566//3784 5565//3800 5581//3804 +f 5561//3785 5560//3796 5575//3805 +f 5572//3786 5571//3782 5587//3806 +f 5567//3787 5566//3784 5582//3807 +f 5562//3789 5561//3785 5576//3808 +f 5568//3788 5567//3787 5583//3809 +f 5563//3791 5562//3789 5577//3810 +f 5569//3790 5568//3788 5584//3811 +f 5564//3795 5563//3791 5578//3812 +f 5578//3812 5577//3810 5592//3813 +f 5584//3811 5583//3809 5599//3814 +f 5579//3801 5578//3812 5593//3815 +f 5574//3802 5573//3798 5588//3816 +f 5585//3799 5584//3811 5600//3817 +f 5580//3818 5579//3801 5594//3819 +f 5575//3805 5574//3802 5589//3820 +f 5586//3803 5585//3799 5601//3821 +f 5581//3804 5580//3818 5596//3822 +f 5576//3808 5575//3805 5590//3823 +f 5587//3806 5586//3803 5602//3824 +f 5582//3807 5581//3804 5597//3825 +f 5577//3810 5576//3808 5591//3826 +f 5583//3809 5582//3807 5598//3827 +f 5597//3825 5596//3822 5612//3828 +f 5592//3813 5591//3826 5606//3829 +f 5598//3827 5597//3825 5613//3830 +f 5593//3815 5592//3813 5607//3831 +f 5599//3814 5598//3827 5614//3832 +f 5594//3819 5593//3815 5608//3833 +f 5589//3820 5588//3816 5603//3834 +f 5600//3817 5599//3814 5615//3835 +f 5595//3836 5594//3819 5609//3837 +f 5590//3823 5589//3820 5604//3838 +f 5601//3821 5600//3817 5616//3839 +f 5596//3822 5595//3836 5611//3840 +f 5591//3826 5590//3823 5605//3841 +f 5602//3824 5601//3821 5617//3842 +f 5616//3839 5615//3835 5631//3843 +f 5611//3840 5610//3844 5626//3845 +f 5606//3829 5605//3841 5620//3846 +f 5617//3842 5616//3839 5632//3847 +f 5612//3828 5611//3840 5627//3848 +f 5607//3831 5606//3829 5621//3849 +f 5613//3830 5612//3828 5628//3850 +f 5608//3833 5607//3831 5622//3851 +f 5614//3832 5613//3830 5629//3852 +f 5609//3837 5608//3833 5623//3853 +f 5604//3838 5603//3834 5619//3854 +f 5615//3835 5614//3832 5630//3855 +f 5610//3844 5609//3837 5624//3856 +f 5605//3841 5604//3838 5620//3846 +f 5630//3855 5629//3852 5646//3857 +f 5625//3858 5624//3856 5640//3859 +f 5620//3846 5619//3854 5636//3860 +f 5631//3843 5630//3855 5647//3861 +f 5626//3845 5625//3858 5642//3862 +f 5621//3849 5620//3846 5636//3860 +f 5632//3847 5631//3843 5648//3863 +f 5627//3848 5626//3845 5643//3864 +f 5622//3851 5621//3849 5637//3865 +f 5628//3850 5627//3848 5644//3866 +f 5623//3853 5622//3851 5638//3867 +f 5629//3852 5628//3850 5645//3868 +f 5624//3856 5623//3853 5639//3869 +f 5619//3854 5618//3870 5635//3871 +f 5645//3868 5644//3866 5660//3872 +f 5640//3859 5639//3869 5654//3873 +f 5635//3871 5634//3874 5650//3875 +f 5646//3857 5645//3868 5661//3876 +f 5641//3877 5640//3859 5655//3878 +f 5636//3860 5635//3871 5651//3879 +f 5647//3861 5646//3857 5662//3880 +f 5642//3862 5641//3877 5657//3881 +f 5637//3865 5636//3860 5652//3882 +f 5648//3863 5647//3861 5663//3883 +f 5643//3864 5642//3862 5658//3884 +f 5638//3867 5637//3865 5652//3882 +f 5644//3866 5643//3864 5659//3885 +f 5639//3869 5638//3867 5653//3886 +f 5653//3886 5652//3882 5668//3887 +f 5659//3885 5658//3884 5673//3888 +f 5654//3873 5653//3886 5669//3889 +f 5660//3872 5659//3885 5674//3890 +f 5655//3878 5654//3873 5670//3891 +f 5650//3875 5649//3892 5664//3893 +f 5661//3876 5660//3872 5675//3894 +f 5656//3895 5655//3878 5671//3896 +f 5651//3879 5650//3875 5666//3897 +f 5662//3880 5661//3876 5676//3898 +f 5657//3881 5656//3895 5671//3896 +f 5652//3882 5651//3879 5667//3899 +f 5663//3883 5662//3880 5677//3900 +f 5658//3884 5657//3881 5672//3901 +f 5672//3901 5671//3896 5686//3902 +f 5667//3899 5666//3897 5681//3903 +f 5678//3904 5677//3900 5692//3905 +f 5673//3888 5672//3901 5687//3906 +f 5668//3887 5667//3899 5683//3907 +f 5674//3890 5673//3888 5688//3908 +f 5669//3889 5668//3887 5684//3909 +f 5675//3894 5674//3890 5689//3910 +f 5670//3891 5669//3889 5685//3911 +f 5665//3912 5664//3893 5679//3913 +f 5676//3898 5675//3894 5690//3914 +f 5671//3896 5670//3891 5686//3902 +f 5666//3897 5665//3912 5680//3915 +f 5677//3900 5676//3898 5691//3916 +f 5691//3916 5690//3914 5705//3917 +f 5686//3902 5685//3911 5701//3918 +f 5681//3903 5680//3915 5695//3919 +f 5692//3905 5691//3916 5706//3920 +f 5687//3906 5686//3902 5701//3918 +f 5682//3921 5681//3903 5696//3922 +f 5693//3923 5692//3905 5707//3924 +f 5688//3908 5687//3906 5702//3925 +f 5683//3907 5682//3921 5698//3926 +f 5689//3910 5688//3908 5703//3927 +f 5684//3909 5683//3907 5699//3928 +f 5690//3914 5689//3910 5704//3929 +f 5685//3911 5684//3909 5700//3930 +f 5680//3915 5679//3913 5694//3931 +f 5705//3917 5704//3929 5719//3932 +f 5700//3930 5699//3928 5715//3933 +f 5695//3919 5694//3931 5709//3934 +f 5706//3920 5705//3917 5720//3935 +f 5701//3918 5700//3930 5716//3936 +f 5696//3922 5695//3919 5710//3937 +f 5707//3924 5706//3920 5721//3938 +f 5702//3925 5701//3918 5716//3936 +f 5697//3939 5696//3922 5712//3940 +f 5708//3941 5707//3924 5722//3942 +f 5703//3927 5702//3925 5717//3943 +f 5698//3926 5697//3939 5713//3944 +f 5704//3929 5703//3927 5718//3945 +f 5699//3928 5698//3926 5714//3946 +f 5713//3944 5712//3940 5728//3947 +f 5719//3932 5718//3945 5733//3948 +f 5714//3946 5713//3944 5729//3949 +f 5720//3935 5719//3932 5734//3950 +f 5715//3933 5714//3946 5730//3951 +f 5710//3937 5709//3934 5725//3952 +f 5721//3938 5720//3935 5735//3953 +f 5716//3936 5715//3933 5731//3954 +f 5711//3955 5710//3937 5726//3956 +f 5722//3942 5721//3938 5736//3957 +f 5717//3943 5716//3936 5731//3954 +f 5712//3940 5711//3955 5727//3958 +f 5723//3959 5722//3942 5737//3960 +f 5718//3945 5717//3943 5732//3961 +f 5732//3961 5731//3954 5746//3962 +f 5727//3958 5726//3956 5742//3963 +f 5738//3964 5737//3960 5752//3965 +f 5733//3948 5732//3961 5747//3966 +f 5728//3947 5727//3958 5743//3967 +f 5734//3950 5733//3948 5748//3968 +f 5729//3949 5728//3947 5744//3969 +f 5735//3953 5734//3950 5749//3970 +f 5730//3951 5729//3949 5745//3971 +f 5725//3952 5724//3972 5740//3973 +f 5736//3957 5735//3953 5750//3974 +f 5731//3954 5730//3951 5746//3962 +f 5726//3956 5725//3952 5741//3975 +f 5737//3960 5736//3957 5751//3976 +f 5751//3976 5750//3974 5766//3977 +f 5746//3962 5745//3971 5762//3978 +f 5741//3975 5740//3973 5757//3979 +f 5752//3965 5751//3976 5767//3980 +f 5747//3966 5746//3962 5762//3978 +f 5742//3963 5741//3975 5758//3981 +f 5753//3982 5752//3965 5768//3983 +f 5748//3968 5747//3966 5763//3984 +f 5743//3967 5742//3963 5759//3985 +f 5749//3970 5748//3968 5764//3986 +f 5744//3969 5743//3967 5760//3987 +f 5750//3974 5749//3970 5765//3988 +f 5745//3971 5744//3969 5761//3989 +f 5740//3973 5739//3990 5756//3991 +f 5766//3977 5765//3988 5780//3992 +f 5761//3989 5760//3987 5776//3993 +f 5756//3991 5755//3994 5770//3995 +f 5767//3980 5766//3977 5781//3996 +f 5762//3978 5761//3989 5777//3997 +f 5757//3979 5756//3991 5771//3998 +f 5768//3983 5767//3980 5782//3999 +f 5763//3984 5762//3978 5777//3997 +f 5758//3981 5757//3979 5772//4000 +f 5769//4001 5768//3983 5783//4002 +f 5764//3986 5763//3984 5778//4003 +f 5759//3985 5758//3981 5774//4004 +f 5765//3988 5764//3986 5779//4005 +f 5760//3987 5759//3985 5775//4006 +f 5633//364 5317//3548 5332//3549 +f 5303//3533 5754//4007 5318//3534 +f 5633//364 5332//3549 5347//3568 +f 5318//3534 5754//4007 5333//3560 +f 5633//364 5347//3568 5362//3585 +f 5333//3560 5754//4007 5348//3577 +f 5633//364 5362//3585 5377//3588 +f 5348//3577 5754//4007 5363//3595 +f 5633//364 5377//3588 5392//3608 +f 5363//3595 5754//4007 5378//3618 +f 5633//364 5392//3608 5407//3626 +f 5378//3618 5754//4007 5393//3636 +f 5393//3636 5754//4007 5408//3654 +f 5633//364 5407//3626 5422//3645 +f 5633//364 5422//3645 5437//3666 +f 5408//3654 5754//4007 5423//3674 +f 5633//364 5437//3666 5452//3685 +f 5423//3674 5754//4007 5438//3678 +f 5633//364 5452//3685 5467//3703 +f 5438//3678 5754//4007 5453//3696 +f 5453//3696 5754//4007 5468//3715 +f 5633//364 5467//3703 5482//3707 +f 5633//364 5482//3707 5497//3726 +f 5468//3715 5754//4007 5483//3716 +f 5633//364 5497//3726 5512//3744 +f 5483//3716 5754//4007 5498//3734 +f 5633//364 5512//3744 5527//3762 +f 5498//3734 5754//4007 5513//3737 +f 5513//3737 5754//4007 5528//3773 +f 5633//364 5527//3762 5542//3780 +f 5633//364 5542//3780 5557//3781 +f 5528//3773 5754//4007 5543//3792 +f 5633//364 5557//3781 5572//3786 +f 5543//3792 5754//4007 5558//3797 +f 5633//364 5572//3786 5587//3806 +f 5558//3797 5754//4007 5573//3798 +f 5573//3798 5754//4007 5588//3816 +f 5633//364 5587//3806 5602//3824 +f 5633//364 5602//3824 5617//3842 +f 5588//3816 5754//4007 5603//3834 +f 5633//364 5617//3842 5632//3847 +f 5603//3834 5754//4007 5618//3870 +f 5633//364 5632//3847 5648//3863 +f 5618//3870 5754//4007 5634//3874 +f 5634//3874 5754//4007 5649//3892 +f 5633//364 5648//3863 5663//3883 +f 5633//364 5663//3883 5678//3904 +f 5649//3892 5754//4007 5664//3893 +f 5633//364 5678//3904 5693//3923 +f 5664//3893 5754//4007 5679//3913 +f 5633//364 5693//3923 5708//3941 +f 5679//3913 5754//4007 5694//3931 +f 5694//3931 5754//4007 5709//3934 +f 5633//364 5708//3941 5723//3959 +f 5633//364 5723//3959 5738//3964 +f 5709//3934 5754//4007 5724//3972 +f 5633//364 5738//3964 5753//3982 +f 5724//3972 5754//4007 5739//3990 +f 5633//364 5753//3982 5769//4001 +f 5739//3990 5754//4007 5755//3994 +f 5633//364 5769//4001 5784//4008 +f 5755//3994 5754//4007 5770//3995 +f 5633//364 5784//4008 5317//3548 +f 5780//3992 5779//4005 5313//3554 +f 5775//4006 5774//4004 5307//3552 +f 5770//3995 5754//4007 5303//3533 +f 5781//3996 5780//3992 5314//3536 +f 5776//3993 5775//4006 5308//3530 +f 5771//3998 5770//3995 5303//3533 +f 5782//3999 5781//3996 5315//3535 +f 5777//3997 5776//3993 5309//3529 +f 5772//4000 5771//3998 5304//3532 +f 5783//4002 5782//3999 5316//3542 +f 5778//4003 5777//3997 5311//3544 +f 5773//4009 5772//4000 5305//3540 +f 5784//4008 5783//4002 5317//3548 +f 5779//4005 5778//4003 5312//3550 +f 5774//4004 5773//4009 5306//3546 +f 5324//3539 5309//3529 5323//3531 +f 5319//3541 5304//3532 5318//3534 +f 5314//3536 5329//3557 5330//3537 +f 5325//3562 5310//3538 5324//3539 +f 5320//3547 5305//3540 5319//3541 +f 5315//3535 5330//3537 5331//3543 +f 5310//3538 5325//3562 5326//3545 +f 5321//3553 5306//3546 5320//3547 +f 5316//3542 5331//3543 5332//3549 +f 5311//3544 5326//3545 5327//3551 +f 5322//3556 5307//3552 5321//3553 +f 5312//3550 5327//3551 5328//3555 +f 5323//3531 5308//3530 5322//3556 +f 5313//3554 5328//3555 5329//3557 +f 5328//3555 5343//3571 5344//3558 +f 5339//3563 5324//3539 5338//3559 +f 5334//3564 5319//3541 5333//3560 +f 5329//3557 5344//3558 5345//3561 +f 5340//3579 5325//3562 5339//3563 +f 5335//3567 5320//3547 5334//3564 +f 5330//3537 5345//3561 5346//3565 +f 5325//3562 5340//3579 5341//3566 +f 5336//3570 5321//3553 5335//3567 +f 5331//3543 5346//3565 5347//3568 +f 5326//3545 5341//3566 5342//3569 +f 5337//3572 5322//3556 5336//3570 +f 5327//3551 5342//3569 5343//3571 +f 5338//3559 5323//3531 5337//3572 +f 5342//3569 5357//3586 5358//3573 +f 5353//3576 5338//3559 5352//3574 +f 5343//3571 5358//3573 5359//3575 +f 5354//3580 5339//3563 5353//3576 +f 5349//3581 5334//3564 5348//3577 +f 5344//3558 5359//3575 5360//3578 +f 5355//3597 5340//3579 5354//3580 +f 5350//3584 5335//3567 5349//3581 +f 5345//3561 5360//3578 5361//3582 +f 5340//3579 5355//3597 5356//3583 +f 5351//3587 5336//3570 5350//3584 +f 5346//3565 5361//3582 5362//3585 +f 5341//3566 5356//3583 5357//3586 +f 5352//3574 5337//3572 5351//3587 +f 5361//3582 5376//3600 5377//3588 +f 5356//3583 5371//3601 5372//3589 +f 5367//3592 5352//3574 5366//3590 +f 5357//3586 5372//3589 5373//3591 +f 5368//3594 5353//3576 5367//3592 +f 5358//3573 5373//3591 5374//3593 +f 5369//3598 5354//3580 5368//3594 +f 5364//3602 5349//3581 5363//3595 +f 5359//3575 5374//3593 5375//3596 +f 5370//3605 5355//3597 5369//3598 +f 5349//3581 5364//3602 5365//3599 +f 5360//3578 5375//3596 5376//3600 +f 5355//3597 5370//3605 5371//3601 +f 5350//3584 5365//3599 5366//3590 +f 5364//3602 5379//3614 5380//3603 +f 5375//3596 5390//3615 5391//3604 +f 5370//3605 5385//3621 5386//3606 +f 5365//3599 5380//3603 5381//3607 +f 5376//3600 5391//3604 5392//3608 +f 5371//3601 5386//3606 5387//3609 +f 5382//3611 5367//3592 5381//3607 +f 5372//3589 5387//3609 5388//3610 +f 5383//3613 5368//3594 5382//3611 +f 5373//3591 5388//3610 5389//3612 +f 5384//3616 5369//3598 5383//3613 +f 5363//3595 5378//3618 5379//3614 +f 5374//3593 5389//3612 5390//3615 +f 5385//3621 5370//3605 5384//3616 +f 5399//3622 5384//3616 5398//3617 +f 5378//3618 5393//3636 5394//3619 +f 5389//3612 5404//3631 5405//3620 +f 5400//3639 5385//3621 5399//3622 +f 5379//3614 5394//3619 5395//3623 +f 5390//3615 5405//3620 5406//3624 +f 5385//3621 5400//3639 5401//3625 +f 5396//3628 5381//3607 5395//3623 +f 5391//3604 5406//3624 5407//3626 +f 5386//3606 5401//3625 5402//3627 +f 5397//3630 5382//3611 5396//3628 +f 5387//3609 5402//3627 5403//3629 +f 5398//3617 5383//3613 5397//3630 +f 5388//3610 5403//3629 5404//3631 +f 5402//3627 5417//3646 5418//3632 +f 5413//3635 5398//3617 5412//3633 +f 5403//3629 5418//3632 5419//3634 +f 5414//3640 5399//3622 5413//3635 +f 5393//3636 5408//3654 5409//3637 +f 5404//3631 5419//3634 5420//3638 +f 5415//3657 5400//3639 5414//3640 +f 5394//3619 5409//3637 5410//3641 +f 5405//3620 5420//3638 5421//3642 +f 5400//3639 5415//3657 5416//3643 +f 5395//3623 5410//3641 5411//3644 +f 5406//3624 5421//3642 5422//3645 +f 5401//3625 5416//3643 5417//3646 +f 5412//3633 5397//3630 5411//3644 +f 5437//3666 5422//3645 5436//3647 +f 5432//3650 5417//3646 5431//3648 +f 5411//3644 5426//3661 5427//3649 +f 5433//3652 5418//3632 5432//3650 +f 5412//3633 5427//3649 5428//3651 +f 5434//3656 5419//3634 5433//3652 +f 5413//3635 5428//3651 5429//3653 +f 5408//3654 5423//3674 5424//3655 +f 5435//3660 5420//3638 5434//3656 +f 5414//3640 5429//3653 5430//3658 +f 5409//3637 5424//3655 5425//3659 +f 5436//3647 5421//3642 5435//3660 +f 5431//3648 5416//3643 5430//3658 +f 5410//3641 5425//3659 5426//3661 +f 5424//3655 5439//3675 5440//3662 +f 5451//3667 5436//3647 5450//3663 +f 5446//3668 5431//3648 5445//3664 +f 5425//3659 5440//3662 5441//3665 +f 5452//3685 5437//3666 5451//3667 +f 5447//3670 5432//3650 5446//3668 +f 5426//3661 5441//3665 5442//3669 +f 5448//3672 5433//3652 5447//3670 +f 5427//3649 5442//3669 5443//3671 +f 5449//3676 5434//3656 5448//3672 +f 5428//3651 5443//3671 5444//3673 +f 5423//3674 5438//3678 5439//3675 +f 5450//3663 5435//3660 5449//3676 +f 5429//3653 5444//3673 5445//3664 +f 5443//3671 5458//3690 5459//3677 +f 5438//3678 5453//3696 5454//3679 +f 5465//3683 5450//3663 5464//3680 +f 5444//3673 5459//3677 5460//3681 +f 5439//3675 5454//3679 5455//3682 +f 5466//3686 5451//3667 5465//3683 +f 5461//3687 5446//3668 5460//3681 +f 5440//3662 5455//3682 5456//3684 +f 5467//3703 5452//3685 5466//3686 +f 5462//3689 5447//3670 5461//3687 +f 5441//3665 5456//3684 5457//3688 +f 5463//3691 5448//3672 5462//3689 +f 5442//3669 5457//3688 5458//3690 +f 5464//3680 5449//3676 5463//3691 +f 5478//3694 5463//3691 5477//3692 +f 5457//3688 5472//3706 5473//3693 +f 5479//3698 5464//3680 5478//3694 +f 5458//3690 5473//3693 5474//3695 +f 5453//3696 5468//3715 5469//3697 +f 5480//3701 5465//3683 5479//3698 +f 5459//3677 5474//3695 5475//3699 +f 5454//3679 5469//3697 5470//3700 +f 5481//3704 5466//3686 5480//3701 +f 5476//3705 5461//3687 5475//3699 +f 5455//3682 5470//3700 5471//3702 +f 5482//3707 5467//3703 5481//3704 +f 5477//3692 5462//3689 5476//3705 +f 5456//3684 5471//3702 5472//3706 +f 5497//3726 5482//3707 5496//3708 +f 5492//3711 5477//3692 5491//3709 +f 5471//3702 5486//3721 5487//3710 +f 5493//3713 5478//3694 5492//3711 +f 5472//3706 5487//3710 5488//3712 +f 5494//3717 5479//3698 5493//3713 +f 5473//3693 5488//3712 5489//3714 +f 5484//3719 5469//3697 5483//3716 +f 5495//3720 5480//3701 5494//3717 +f 5474//3695 5489//3714 5490//3718 +f 5485//3724 5470//3700 5484//3719 +f 5496//3708 5481//3704 5495//3720 +f 5491//3709 5476//3705 5490//3718 +f 5470//3700 5485//3724 5486//3721 +f 5511//3727 5496//3708 5510//3722 +f 5506//3728 5491//3709 5505//3723 +f 5485//3724 5500//3740 5501//3725 +f 5512//3744 5497//3726 5511//3727 +f 5507//3730 5492//3711 5506//3728 +f 5486//3721 5501//3725 5502//3729 +f 5508//3732 5493//3713 5507//3730 +f 5487//3710 5502//3729 5503//3731 +f 5509//3735 5494//3717 5508//3732 +f 5488//3712 5503//3731 5504//3733 +f 5499//3736 5484//3719 5498//3734 +f 5510//3722 5495//3720 5509//3735 +f 5489//3714 5504//3733 5505//3723 +f 5500//3740 5485//3724 5499//3736 +f 5514//3741 5499//3736 5513//3737 +f 5525//3742 5510//3722 5524//3738 +f 5504//3733 5519//3751 5520//3739 +f 5515//3758 5500//3740 5514//3741 +f 5526//3745 5511//3727 5525//3742 +f 5521//3746 5506//3728 5520//3739 +f 5500//3740 5515//3758 5516//3743 +f 5527//3762 5512//3744 5526//3745 +f 5522//3748 5507//3730 5521//3746 +f 5501//3725 5516//3743 5517//3747 +f 5523//3750 5508//3732 5522//3748 +f 5502//3729 5517//3747 5518//3749 +f 5524//3738 5509//3735 5523//3750 +f 5503//3731 5518//3749 5519//3751 +f 5517//3747 5532//3765 5533//3752 +f 5539//3756 5524//3738 5538//3753 +f 5518//3749 5533//3752 5534//3754 +f 5513//3737 5528//3773 5529//3755 +f 5540//3760 5525//3742 5539//3756 +f 5519//3751 5534//3754 5535//3757 +f 5514//3741 5529//3755 5530//3759 +f 5541//3763 5526//3745 5540//3760 +f 5536//3764 5521//3746 5535//3757 +f 5515//3758 5530//3759 5531//3761 +f 5542//3780 5527//3762 5541//3763 +f 5537//3766 5522//3748 5536//3764 +f 5516//3743 5531//3761 5532//3765 +f 5538//3753 5523//3750 5537//3766 +f 5536//3764 5551//3779 5552//3767 +f 5547//3770 5532//3765 5546//3768 +f 5537//3766 5552//3767 5553//3769 +f 5548//3772 5533//3752 5547//3770 +f 5538//3753 5553//3769 5554//3771 +f 5549//3776 5534//3754 5548//3772 +f 5528//3773 5543//3792 5544//3774 +f 5539//3756 5554//3771 5555//3775 +f 5550//3783 5535//3757 5549//3776 +f 5529//3755 5544//3774 5545//3777 +f 5540//3760 5555//3775 5556//3778 +f 5535//3757 5550//3783 5551//3779 +f 5530//3759 5545//3777 5546//3768 +f 5541//3763 5556//3778 5557//3781 +f 5555//3775 5570//3794 5571//3782 +f 5550//3783 5565//3800 5566//3784 +f 5545//3777 5560//3796 5561//3785 +f 5556//3778 5571//3782 5572//3786 +f 5551//3779 5566//3784 5567//3787 +f 5562//3789 5547//3770 5561//3785 +f 5552//3767 5567//3787 5568//3788 +f 5563//3791 5548//3772 5562//3789 +f 5553//3769 5568//3788 5569//3790 +f 5564//3795 5549//3776 5563//3791 +f 5543//3792 5558//3797 5559//3793 +f 5554//3771 5569//3790 5570//3794 +f 5565//3800 5550//3783 5564//3795 +f 5544//3774 5559//3793 5560//3796 +f 5574//3802 5559//3793 5573//3798 +f 5569//3790 5584//3811 5585//3799 +f 5580//3818 5565//3800 5579//3801 +f 5575//3805 5560//3796 5574//3802 +f 5570//3794 5585//3799 5586//3803 +f 5565//3800 5580//3818 5581//3804 +f 5576//3808 5561//3785 5575//3805 +f 5571//3782 5586//3803 5587//3806 +f 5566//3784 5581//3804 5582//3807 +f 5577//3810 5562//3789 5576//3808 +f 5567//3787 5582//3807 5583//3809 +f 5578//3812 5563//3791 5577//3810 +f 5568//3788 5583//3809 5584//3811 +f 5579//3801 5564//3795 5578//3812 +f 5593//3815 5578//3812 5592//3813 +f 5583//3809 5598//3827 5599//3814 +f 5594//3819 5579//3801 5593//3815 +f 5589//3820 5574//3802 5588//3816 +f 5584//3811 5599//3814 5600//3817 +f 5595//3836 5580//3818 5594//3819 +f 5590//3823 5575//3805 5589//3820 +f 5585//3799 5600//3817 5601//3821 +f 5580//3818 5595//3836 5596//3822 +f 5591//3826 5576//3808 5590//3823 +f 5586//3803 5601//3821 5602//3824 +f 5581//3804 5596//3822 5597//3825 +f 5592//3813 5577//3810 5591//3826 +f 5582//3807 5597//3825 5598//3827 +f 5596//3822 5611//3840 5612//3828 +f 5607//3831 5592//3813 5606//3829 +f 5597//3825 5612//3828 5613//3830 +f 5608//3833 5593//3815 5607//3831 +f 5598//3827 5613//3830 5614//3832 +f 5609//3837 5594//3819 5608//3833 +f 5604//3838 5589//3820 5603//3834 +f 5599//3814 5614//3832 5615//3835 +f 5610//3844 5595//3836 5609//3837 +f 5605//3841 5590//3823 5604//3838 +f 5600//3817 5615//3835 5616//3839 +f 5595//3836 5610//3844 5611//3840 +f 5606//3829 5591//3826 5605//3841 +f 5601//3821 5616//3839 5617//3842 +f 5615//3835 5630//3855 5631//3843 +f 5610//3844 5625//3858 5626//3845 +f 5621//3849 5606//3829 5620//3846 +f 5616//3839 5631//3843 5632//3847 +f 5611//3840 5626//3845 5627//3848 +f 5622//3851 5607//3831 5621//3849 +f 5612//3828 5627//3848 5628//3850 +f 5623//3853 5608//3833 5622//3851 +f 5613//3830 5628//3850 5629//3852 +f 5624//3856 5609//3837 5623//3853 +f 5603//3834 5618//3870 5619//3854 +f 5614//3832 5629//3852 5630//3855 +f 5625//3858 5610//3844 5624//3856 +f 5604//3838 5619//3854 5620//3846 +f 5629//3852 5645//3868 5646//3857 +f 5641//3877 5625//3858 5640//3859 +f 5619//3854 5635//3871 5636//3860 +f 5630//3855 5646//3857 5647//3861 +f 5625//3858 5641//3877 5642//3862 +f 5637//3865 5621//3849 5636//3860 +f 5631//3843 5647//3861 5648//3863 +f 5626//3845 5642//3862 5643//3864 +f 5638//3867 5622//3851 5637//3865 +f 5627//3848 5643//3864 5644//3866 +f 5639//3869 5623//3853 5638//3867 +f 5628//3850 5644//3866 5645//3868 +f 5640//3859 5624//3856 5639//3869 +f 5618//3870 5634//3874 5635//3871 +f 5644//3866 5659//3885 5660//3872 +f 5655//3878 5640//3859 5654//3873 +f 5634//3874 5649//3892 5650//3875 +f 5645//3868 5660//3872 5661//3876 +f 5656//3895 5641//3877 5655//3878 +f 5635//3871 5650//3875 5651//3879 +f 5646//3857 5661//3876 5662//3880 +f 5641//3877 5656//3895 5657//3881 +f 5636//3860 5651//3879 5652//3882 +f 5647//3861 5662//3880 5663//3883 +f 5642//3862 5657//3881 5658//3884 +f 5653//3886 5638//3867 5652//3882 +f 5643//3864 5658//3884 5659//3885 +f 5654//3873 5639//3869 5653//3886 +f 5652//3882 5667//3899 5668//3887 +f 5674//3890 5659//3885 5673//3888 +f 5653//3886 5668//3887 5669//3889 +f 5675//3894 5660//3872 5674//3890 +f 5654//3873 5669//3889 5670//3891 +f 5665//3912 5650//3875 5664//3893 +f 5676//3898 5661//3876 5675//3894 +f 5655//3878 5670//3891 5671//3896 +f 5650//3875 5665//3912 5666//3897 +f 5677//3900 5662//3880 5676//3898 +f 5672//3901 5657//3881 5671//3896 +f 5651//3879 5666//3897 5667//3899 +f 5678//3904 5663//3883 5677//3900 +f 5673//3888 5658//3884 5672//3901 +f 5687//3906 5672//3901 5686//3902 +f 5682//3921 5667//3899 5681//3903 +f 5693//3923 5678//3904 5692//3905 +f 5688//3908 5673//3888 5687//3906 +f 5667//3899 5682//3921 5683//3907 +f 5689//3910 5674//3890 5688//3908 +f 5668//3887 5683//3907 5684//3909 +f 5690//3914 5675//3894 5689//3910 +f 5669//3889 5684//3909 5685//3911 +f 5680//3915 5665//3912 5679//3913 +f 5691//3916 5676//3898 5690//3914 +f 5670//3891 5685//3911 5686//3902 +f 5681//3903 5666//3897 5680//3915 +f 5692//3905 5677//3900 5691//3916 +f 5706//3920 5691//3916 5705//3917 +f 5685//3911 5700//3930 5701//3918 +f 5696//3922 5681//3903 5695//3919 +f 5707//3924 5692//3905 5706//3920 +f 5702//3925 5687//3906 5701//3918 +f 5697//3939 5682//3921 5696//3922 +f 5708//3941 5693//3923 5707//3924 +f 5703//3927 5688//3908 5702//3925 +f 5682//3921 5697//3939 5698//3926 +f 5704//3929 5689//3910 5703//3927 +f 5683//3907 5698//3926 5699//3928 +f 5705//3917 5690//3914 5704//3929 +f 5684//3909 5699//3928 5700//3930 +f 5695//3919 5680//3915 5694//3931 +f 5720//3935 5705//3917 5719//3932 +f 5699//3928 5714//3946 5715//3933 +f 5710//3937 5695//3919 5709//3934 +f 5721//3938 5706//3920 5720//3935 +f 5700//3930 5715//3933 5716//3936 +f 5711//3955 5696//3922 5710//3937 +f 5722//3942 5707//3924 5721//3938 +f 5717//3943 5702//3925 5716//3936 +f 5696//3922 5711//3955 5712//3940 +f 5723//3959 5708//3941 5722//3942 +f 5718//3945 5703//3927 5717//3943 +f 5697//3939 5712//3940 5713//3944 +f 5719//3932 5704//3929 5718//3945 +f 5698//3926 5713//3944 5714//3946 +f 5712//3940 5727//3958 5728//3947 +f 5734//3950 5719//3932 5733//3948 +f 5713//3944 5728//3947 5729//3949 +f 5735//3953 5720//3935 5734//3950 +f 5714//3946 5729//3949 5730//3951 +f 5709//3934 5724//3972 5725//3952 +f 5736//3957 5721//3938 5735//3953 +f 5715//3933 5730//3951 5731//3954 +f 5710//3937 5725//3952 5726//3956 +f 5737//3960 5722//3942 5736//3957 +f 5732//3961 5717//3943 5731//3954 +f 5711//3955 5726//3956 5727//3958 +f 5738//3964 5723//3959 5737//3960 +f 5733//3948 5718//3945 5732//3961 +f 5747//3966 5732//3961 5746//3962 +f 5726//3956 5741//3975 5742//3963 +f 5753//3982 5738//3964 5752//3965 +f 5748//3968 5733//3948 5747//3966 +f 5727//3958 5742//3963 5743//3967 +f 5749//3970 5734//3950 5748//3968 +f 5728//3947 5743//3967 5744//3969 +f 5750//3974 5735//3953 5749//3970 +f 5729//3949 5744//3969 5745//3971 +f 5724//3972 5739//3990 5740//3973 +f 5751//3976 5736//3957 5750//3974 +f 5730//3951 5745//3971 5746//3962 +f 5725//3952 5740//3973 5741//3975 +f 5752//3965 5737//3960 5751//3976 +f 5767//3980 5751//3976 5766//3977 +f 5745//3971 5761//3989 5762//3978 +f 5740//3973 5756//3991 5757//3979 +f 5768//3983 5752//3965 5767//3980 +f 5763//3984 5747//3966 5762//3978 +f 5741//3975 5757//3979 5758//3981 +f 5769//4001 5753//3982 5768//3983 +f 5764//3986 5748//3968 5763//3984 +f 5742//3963 5758//3981 5759//3985 +f 5765//3988 5749//3970 5764//3986 +f 5743//3967 5759//3985 5760//3987 +f 5766//3977 5750//3974 5765//3988 +f 5744//3969 5760//3987 5761//3989 +f 5739//3990 5755//3994 5756//3991 +f 5781//3996 5766//3977 5780//3992 +f 5760//3987 5775//4006 5776//3993 +f 5771//3998 5756//3991 5770//3995 +f 5782//3999 5767//3980 5781//3996 +f 5761//3989 5776//3993 5777//3997 +f 5772//4000 5757//3979 5771//3998 +f 5783//4002 5768//3983 5782//3999 +f 5778//4003 5763//3984 5777//3997 +f 5773//4009 5758//3981 5772//4000 +f 5784//4008 5769//4001 5783//4002 +f 5779//4005 5764//3986 5778//4003 +f 5758//3981 5773//4009 5774//4004 +f 5780//3992 5765//3988 5779//4005 +f 5759//3985 5774//4004 5775//4006 +f 5779//4005 5312//3550 5313//3554 +f 5308//3530 5775//4006 5307//3552 +f 5780//3992 5313//3554 5314//3536 +f 5309//3529 5776//3993 5308//3530 +f 5304//3532 5771//3998 5303//3533 +f 5781//3996 5314//3536 5315//3535 +f 5310//3538 5777//3997 5309//3529 +f 5305//3540 5772//4000 5304//3532 +f 5782//3999 5315//3535 5316//3542 +f 5777//3997 5310//3538 5311//3544 +f 5306//3546 5773//4009 5305//3540 +f 5783//4002 5316//3542 5317//3548 +f 5778//4003 5311//3544 5312//3550 +f 5307//3552 5774//4004 5306//3546 +o Ear_L_Sphere.007 +v -0.915017 0.106478 0.822725 +v -0.944167 0.121570 0.840173 +v -0.974060 0.150175 0.857679 +v -0.996357 0.185345 0.870613 +v -1.023624 0.171071 0.887158 +v -1.038620 0.139410 0.896437 +v -1.047854 0.105055 0.902151 +v -1.050972 0.069327 0.904081 +v -1.047854 0.033599 0.902151 +v -1.038620 -0.000755 0.896437 +v -1.023624 -0.032417 0.887158 +v -1.003443 -0.060169 0.874670 +v -0.978852 -0.082944 0.859453 +v -0.950796 -0.099867 0.842093 +v -0.920354 -0.110289 0.823256 +v -0.917142 0.105813 0.817309 +v -0.948467 0.119916 0.829345 +v -0.980546 0.149639 0.841337 +v -1.003465 0.185802 0.850238 +v -1.033723 0.171071 0.861992 +v -1.049842 0.139410 0.868475 +v -1.059768 0.105055 0.872466 +v -1.063119 0.069327 0.873814 +v -1.059768 0.033599 0.872466 +v -1.049842 -0.000755 0.868475 +v -1.033723 -0.032417 0.861992 +v -1.012032 -0.060169 0.853268 +v -0.985600 -0.082944 0.842638 +v -0.955444 -0.099867 0.830510 +v -0.922723 -0.110289 0.817351 +v -0.918009 0.105364 0.811327 +v -0.949964 0.118024 0.817446 +v -0.981711 0.143600 0.823584 +v -1.006807 0.178160 0.828467 +v -1.038250 0.171071 0.834585 +v -1.054871 0.139410 0.838021 +v -1.065107 0.105055 0.840137 +v -1.068563 0.069327 0.840852 +v -1.065107 0.033599 0.840137 +v -1.054871 -0.000755 0.838021 +v -1.038250 -0.032417 0.834585 +v -1.015881 -0.060169 0.829960 +v -0.988624 -0.082944 0.824325 +v -0.957527 -0.099867 0.817896 +v -0.923785 -0.110289 0.810920 +v -0.917793 0.105605 0.805026 +v -0.949557 0.118435 0.804940 +v -0.981430 0.144211 0.804957 +v -1.006395 0.178959 0.805648 +v -1.037029 0.171071 0.805989 +v -1.053515 0.139410 0.806248 +v -1.063667 0.105055 0.806407 +v -1.067095 0.069327 0.806460 +v -1.063667 0.033599 0.806407 +v -1.053515 -0.000755 0.806248 +v -1.037029 -0.032417 0.805989 +v -1.014843 -0.060169 0.805642 +v -0.987808 -0.082944 0.805218 +v -0.956966 -0.099867 0.804735 +v -0.923499 -0.110289 0.804211 +v -0.916416 0.106636 0.798779 +v -0.946809 0.121198 0.792549 +v -0.978086 0.148035 0.786387 +v -1.002990 0.184085 0.782334 +v -1.030107 0.171071 0.777305 +v -1.045824 0.139410 0.774375 +v -1.055502 0.105055 0.772571 +v -1.058770 0.069327 0.771962 +v -1.055502 0.033599 0.772571 +v -1.045824 -0.000755 0.774375 +v -1.030107 -0.032417 0.777305 +v -1.008956 -0.060169 0.781247 +v -0.983184 -0.082944 0.786052 +v -0.953780 -0.099867 0.791533 +v -0.921875 -0.110289 0.797480 +v -0.913859 0.108151 0.792925 +v -0.941519 0.124970 0.780992 +v -0.969813 0.155093 0.769376 +v -0.998435 0.198761 0.757718 +v -1.017752 0.171071 0.749633 +v -1.032095 0.139410 0.743628 +v -1.040928 0.105055 0.739930 +v -1.043910 0.069327 0.738681 +v -1.040928 0.033599 0.739930 +v -1.032095 -0.000755 0.743628 +v -1.017752 -0.032417 0.749633 +v -0.998449 -0.060169 0.757715 +v -0.974928 -0.082944 0.767562 +v -0.948093 -0.099867 0.778797 +v -0.918976 -0.110289 0.790988 +v -0.910332 0.109658 0.787636 +v -0.934346 0.128011 0.770420 +v -0.958936 0.157463 0.753273 +v -0.983723 0.198822 0.735948 +v -1.000436 0.171071 0.724038 +v -1.012855 0.139410 0.715188 +v -1.020503 0.105055 0.709738 +v -1.023085 0.069327 0.707898 +v -1.020503 0.033599 0.709738 +v -1.012855 -0.000755 0.715188 +v -1.000436 -0.032417 0.724038 +v -0.983723 -0.060169 0.735948 +v -0.963358 -0.082944 0.750460 +v -0.940124 -0.099867 0.767017 +v -0.914913 -0.110289 0.784982 +v -0.906016 0.111060 0.783036 +v -0.925554 0.130997 0.761135 +v -0.945557 0.162077 0.739272 +v -0.965346 0.198823 0.716783 +v -0.978827 0.171071 0.701502 +v -0.988844 0.139410 0.690148 +v -0.995013 0.105055 0.683156 +v -0.997096 0.069327 0.680795 +v -0.995013 0.033599 0.683156 +v -0.988844 -0.000755 0.690148 +v -0.978827 -0.032417 0.701502 +v -0.965346 -0.060169 0.716783 +v -0.948919 -0.082944 0.735402 +v -0.930178 -0.099867 0.756645 +v -0.909843 -0.110289 0.779695 +v -0.901069 0.112214 0.779233 +v -0.915486 0.133416 0.753375 +v -0.930270 0.166676 0.727294 +v -0.944022 0.198821 0.700958 +v -0.953753 0.171071 0.682893 +v -0.960984 0.139410 0.669471 +v -0.965437 0.105055 0.661205 +v -0.966940 0.069327 0.658414 +v -0.965437 0.033599 0.661205 +v -0.960984 -0.000755 0.669471 +v -0.953753 -0.032417 0.682893 +v -0.944023 -0.060169 0.700957 +v -0.932166 -0.082944 0.722968 +v -0.918638 -0.099867 0.748080 +v -0.903960 -0.110289 0.775328 +v -0.895626 0.111755 0.776282 +v -0.904334 0.134112 0.747446 +v -0.913069 0.167604 0.718179 +v -0.920573 0.198823 0.689078 +v -0.926180 0.171071 0.668925 +v -0.930346 0.139410 0.653950 +v -0.932912 0.105055 0.644729 +v -0.933778 0.069327 0.641615 +v -0.932912 0.033599 0.644729 +v -0.930346 -0.000755 0.653950 +v -0.926180 -0.032417 0.668925 +v -0.920573 -0.060169 0.689078 +v -0.913742 -0.082944 0.713635 +v -0.905947 -0.099867 0.741651 +v -0.897490 -0.110289 0.772051 +v -0.889762 0.111002 0.774361 +v -0.892562 0.134385 0.743651 +v -0.895152 0.169335 0.712297 +v -0.895899 0.198823 0.681603 +v -0.897166 0.171071 0.660135 +v -0.898108 0.139410 0.644183 +v -0.898687 0.105055 0.634360 +v -0.898883 0.069327 0.631043 +v -0.898687 0.033599 0.634360 +v -0.898108 -0.000755 0.644183 +v -0.897166 -0.032417 0.660135 +v -0.895899 -0.060169 0.681603 +v -0.894355 -0.082944 0.707762 +v -0.892594 -0.099867 0.737606 +v -0.890683 -0.110289 0.769989 +v -0.883738 0.110630 0.773750 +v -0.880559 0.133393 0.742262 +v -0.876971 0.168158 0.709891 +v -0.870948 0.198823 0.678819 +v -0.867827 0.171071 0.656861 +v -0.865507 0.139410 0.640545 +v -0.864079 0.105055 0.630498 +v -0.863597 0.069327 0.627105 +v -0.864079 0.033599 0.630498 +v -0.865507 -0.000755 0.640545 +v -0.867827 -0.032417 0.656861 +v -0.870948 -0.060169 0.678819 +v -0.874751 -0.082944 0.705574 +v -0.879090 -0.099867 0.736099 +v -0.883799 -0.110289 0.769220 +v -0.877838 0.109884 0.774405 +v -0.868491 0.130362 0.743495 +v -0.858373 0.162037 0.711872 +v -0.846679 0.198823 0.680832 +v -0.839289 0.171071 0.659229 +v -0.833798 0.139410 0.643176 +v -0.830417 0.105055 0.633291 +v -0.829275 0.069327 0.629953 +v -0.830417 0.033599 0.633291 +v -0.833798 -0.000755 0.643176 +v -0.839289 -0.032417 0.659229 +v -0.846679 -0.060169 0.680832 +v -0.855683 -0.082944 0.707156 +v -0.865956 -0.099867 0.737189 +v -0.877103 -0.110289 0.769776 +v -0.872176 0.110631 0.776393 +v -0.856963 0.127180 0.747197 +v -0.841001 0.157407 0.717612 +v -0.824024 0.198823 0.687566 +v -0.812650 0.171071 0.667147 +v -0.804199 0.139410 0.651974 +v -0.798994 0.105055 0.642631 +v -0.797237 0.069327 0.639476 +v -0.798994 0.033599 0.642631 +v -0.804199 -0.000755 0.651974 +v -0.812650 -0.032417 0.667147 +v -0.824024 -0.060169 0.687566 +v -0.837883 -0.082944 0.712447 +v -0.853695 -0.099867 0.740833 +v -0.870852 -0.110289 0.771634 +v -0.866903 0.109523 0.779436 +v -0.846467 0.125727 0.753212 +v -0.825399 0.156023 0.726481 +v -0.803855 0.198823 0.698761 +v -0.788934 0.171071 0.680311 +v -0.777846 0.139410 0.666602 +v -0.771019 0.105055 0.658159 +v -0.768713 0.069327 0.655308 +v -0.771019 0.033599 0.658159 +v -0.777846 -0.000755 0.666602 +v -0.788934 -0.032417 0.680311 +v -0.803855 -0.060169 0.698761 +v -0.822037 -0.082944 0.721243 +v -0.842780 -0.099867 0.746892 +v -0.865288 -0.110289 0.774723 +v -0.862351 0.109562 0.783572 +v -0.837570 0.126715 0.761314 +v -0.812291 0.157574 0.738378 +v -0.786946 0.198823 0.713988 +v -0.769051 0.171071 0.698216 +v -0.755754 0.139410 0.686496 +v -0.747565 0.105055 0.679279 +v -0.744800 0.069327 0.676842 +v -0.747565 0.033599 0.679279 +v -0.755754 -0.000755 0.686496 +v -0.769051 -0.032417 0.698216 +v -0.786946 -0.060169 0.713988 +v -0.808751 -0.082944 0.733206 +v -0.833629 -0.099867 0.755132 +v -0.860622 -0.110289 0.778924 +v -0.858846 0.110952 0.788547 +v -0.830706 0.128755 0.770964 +v -0.802114 0.161643 0.752724 +v -0.773947 0.198823 0.732661 +v -0.753766 0.171071 0.720173 +v -0.738770 0.139410 0.710894 +v -0.729536 0.105055 0.705180 +v -0.726417 0.069327 0.703250 +v -0.729536 0.033599 0.705180 +v -0.738770 -0.000755 0.710894 +v -0.753766 -0.032417 0.720173 +v -0.773947 -0.060169 0.732661 +v -0.798538 -0.082944 0.747878 +v -0.826594 -0.099867 0.765238 +v -0.857036 -0.110289 0.784075 +v -0.856630 0.113125 0.793972 +v -0.826435 0.132465 0.781603 +v -0.795729 0.167607 0.768372 +v -0.765358 0.198823 0.754063 +v -0.743666 0.171071 0.745339 +v -0.727548 0.139410 0.738857 +v -0.717622 0.105055 0.734865 +v -0.714271 0.069327 0.733517 +v -0.717622 0.033599 0.734865 +v -0.727548 -0.000755 0.738857 +v -0.743666 -0.032417 0.745339 +v -0.765358 -0.060169 0.754063 +v -0.791790 -0.082944 0.764693 +v -0.821946 -0.099867 0.776821 +v -0.854666 -0.110289 0.789980 +v -0.855735 0.115404 0.799635 +v -0.824640 0.134309 0.793029 +v -0.793462 0.163081 0.785518 +v -0.761509 0.198823 0.777371 +v -0.739140 0.171071 0.772746 +v -0.722518 0.139410 0.769310 +v -0.712283 0.105055 0.767194 +v -0.708827 0.069327 0.766479 +v -0.712283 0.033599 0.767194 +v -0.722519 -0.000755 0.769310 +v -0.739140 -0.032417 0.772746 +v -0.761509 -0.060169 0.777371 +v -0.788766 -0.082944 0.783006 +v -0.819862 -0.099867 0.789435 +v -0.853604 -0.110289 0.796411 +v -0.855912 0.117033 0.805669 +v -0.825242 0.135866 0.805083 +v -0.794364 0.162174 0.803689 +v -0.762547 0.198823 0.801689 +v -0.740361 0.171071 0.801342 +v -0.723875 0.139410 0.801083 +v -0.713723 0.105055 0.800924 +v -0.710295 0.069327 0.800871 +v -0.713723 0.033599 0.800924 +v -0.723875 -0.000755 0.801083 +v -0.740361 -0.032417 0.801342 +v -0.762547 -0.060169 0.801689 +v -0.789581 -0.082944 0.802113 +v -0.820424 -0.099867 0.802596 +v -0.853891 -0.110289 0.803120 +v -0.857125 0.119010 0.811770 +v -0.828152 0.136665 0.817148 +v -0.798761 0.164559 0.821820 +v -0.768434 0.198823 0.826084 +v -0.747282 0.171071 0.830026 +v -0.731566 0.139410 0.832956 +v -0.721888 0.105055 0.834760 +v -0.718620 0.069327 0.835370 +v -0.721888 0.033599 0.834760 +v -0.731566 -0.000755 0.832956 +v -0.747282 -0.032417 0.830026 +v -0.768434 -0.060169 0.826084 +v -0.794206 -0.082944 0.821279 +v -0.823610 -0.099867 0.815798 +v -0.855515 -0.110289 0.809851 +v -0.859463 0.120953 0.817597 +v -0.833166 0.138262 0.828689 +v -0.806381 0.168068 0.839193 +v -0.778941 0.198823 0.849616 +v -0.759638 0.171071 0.857698 +v -0.745295 0.139410 0.863703 +v -0.736462 0.105055 0.867401 +v -0.733480 0.069327 0.868650 +v -0.736462 0.033599 0.867401 +v -0.745295 -0.000755 0.863703 +v -0.759638 -0.032417 0.857698 +v -0.778941 -0.060169 0.849616 +v -0.802462 -0.082944 0.839769 +v -0.829297 -0.099867 0.828534 +v -0.858414 -0.110289 0.816343 +v -0.888695 -0.113807 0.803666 +v -0.862920 0.121973 0.822890 +v -0.840167 0.140091 0.839301 +v -0.817067 0.172159 0.855194 +v -0.793667 0.198823 0.871383 +v -0.776954 0.171071 0.883293 +v -0.764535 0.139410 0.892143 +v -0.756887 0.105055 0.897593 +v -0.754305 0.069327 0.899433 +v -0.756887 0.033599 0.897593 +v -0.764535 -0.000755 0.892143 +v -0.776954 -0.032417 0.883293 +v -0.793667 -0.060169 0.871383 +v -0.814032 -0.082944 0.856871 +v -0.837266 -0.099867 0.840314 +v -0.862477 -0.110289 0.822349 +v -0.867203 0.121924 0.827362 +v -0.848925 0.142079 0.848684 +v -0.830572 0.178690 0.869438 +v -0.812044 0.198823 0.890548 +v -0.798563 0.171071 0.905829 +v -0.788546 0.139410 0.917183 +v -0.782377 0.105055 0.924175 +v -0.780294 0.069327 0.926536 +v -0.782377 0.033599 0.924175 +v -0.788546 -0.000755 0.917183 +v -0.798563 -0.032417 0.905829 +v -0.812044 -0.060169 0.890548 +v -0.828471 -0.082944 0.871929 +v -0.847212 -0.099867 0.850686 +v -0.867547 -0.110289 0.827636 +v -0.872288 0.119615 0.830918 +v -0.859094 0.143088 0.856348 +v -0.846492 0.188867 0.881489 +v -0.833367 0.198823 0.906374 +v -0.823636 0.171071 0.924438 +v -0.816406 0.139410 0.937860 +v -0.811953 0.105055 0.946126 +v -0.810450 0.069327 0.948917 +v -0.811953 0.033599 0.946126 +v -0.816406 -0.000755 0.937860 +v -0.823636 -0.032417 0.924438 +v -0.833367 -0.060169 0.906374 +v -0.845224 -0.082944 0.884363 +v -0.858752 -0.099867 0.859251 +v -0.873430 -0.110289 0.832003 +v -0.878094 0.116394 0.833596 +v -0.870401 0.136881 0.862016 +v -0.863899 0.172816 0.890506 +v -0.856820 0.198797 0.918239 +v -0.851210 0.171071 0.938406 +v -0.847044 0.139410 0.953381 +v -0.844478 0.105055 0.962602 +v -0.843612 0.069327 0.965716 +v -0.844478 0.033599 0.962602 +v -0.847044 -0.000755 0.953381 +v -0.851210 -0.032417 0.938406 +v -0.856816 -0.060169 0.918253 +v -0.863648 -0.082944 0.893696 +v -0.871442 -0.099867 0.865680 +v -0.879900 -0.110289 0.835280 +v -0.884354 0.113251 0.835312 +v -0.882579 0.129995 0.865697 +v -0.881852 0.160637 0.896308 +v -0.881493 0.198775 0.925701 +v -0.880224 0.171071 0.947196 +v -0.879282 0.139410 0.963148 +v -0.878702 0.105055 0.972971 +v -0.878507 0.069327 0.976288 +v -0.878702 0.033599 0.972971 +v -0.879282 -0.000755 0.963148 +v -0.880224 -0.032417 0.947196 +v -0.881491 -0.060169 0.925728 +v -0.883035 -0.082944 0.899569 +v -0.884796 -0.099867 0.869725 +v -0.886707 -0.110289 0.837342 +v -0.890784 0.110833 0.835950 +v -0.895449 0.124746 0.867121 +v -0.900725 0.157100 0.897831 +v -0.906441 0.198811 0.928505 +v -0.909563 0.171071 0.950470 +v -0.911882 0.139410 0.966786 +v -0.913311 0.105055 0.976833 +v -0.913793 0.069327 0.980225 +v -0.913311 0.033599 0.976833 +v -0.911882 -0.000755 0.966786 +v -0.909563 -0.032417 0.950470 +v -0.906442 -0.060169 0.928512 +v -0.902639 -0.082944 0.901757 +v -0.898300 -0.099867 0.871232 +v -0.893591 -0.110289 0.838111 +v -0.897038 0.109615 0.835419 +v -0.907826 0.126885 0.865629 +v -0.919032 0.156820 0.895940 +v -0.930711 0.198823 0.926499 +v -0.938101 0.171071 0.948102 +v -0.943592 0.139410 0.964155 +v -0.946973 0.105055 0.974040 +v -0.948115 0.069327 0.977378 +v -0.946973 0.033599 0.974040 +v -0.943592 -0.000755 0.964155 +v -0.938101 -0.032417 0.948102 +v -0.930711 -0.060169 0.926499 +v -0.921707 -0.082944 0.900175 +v -0.911434 -0.099867 0.870142 +v -0.900287 -0.110289 0.837555 +v -0.902747 0.108911 0.833785 +v -0.919343 0.126336 0.862550 +v -0.936096 0.156384 0.890935 +v -0.953366 0.198823 0.919765 +v -0.964740 0.171071 0.940184 +v -0.973191 0.139410 0.955357 +v -0.978396 0.105055 0.964700 +v -0.980153 0.069327 0.967855 +v -0.978396 0.033599 0.964700 +v -0.973191 -0.000755 0.955357 +v -0.964740 -0.032417 0.940184 +v -0.953366 -0.060169 0.919765 +v -0.939506 -0.082944 0.894884 +v -0.923694 -0.099867 0.866498 +v -0.906538 -0.110289 0.835697 +v -0.886821 0.108050 0.805276 +v -0.907688 0.108589 0.831044 +v -0.929275 0.124972 0.857060 +v -0.951206 0.155948 0.882674 +v -0.973533 0.198816 0.908568 +v -0.988456 0.171071 0.927020 +v -0.999544 0.139410 0.940729 +v -1.006371 0.105055 0.949172 +v -1.008677 0.069327 0.952022 +v -1.006371 0.033599 0.949172 +v -0.999544 -0.000755 0.940729 +v -0.988456 -0.032417 0.927020 +v -0.973535 -0.060169 0.908570 +v -0.955353 -0.082944 0.886088 +v -0.934610 -0.099867 0.860439 +v -0.912102 -0.110289 0.832609 +v -0.911797 0.107654 0.827343 +v -0.937569 0.123775 0.849490 +v -0.963876 0.154073 0.871440 +v -0.985613 0.187155 0.889769 +v -1.008339 0.171071 0.909115 +v -1.021636 0.139410 0.920835 +v -1.029824 0.105055 0.928052 +v -1.032589 0.069327 0.930489 +v -1.029825 0.033599 0.928052 +v -1.021636 -0.000755 0.920835 +v -1.008339 -0.032417 0.909115 +v -0.990444 -0.060169 0.893343 +v -0.968638 -0.082944 0.874125 +v -0.943761 -0.099867 0.852199 +v -0.916767 -0.110289 0.828407 +vn -0.943907 0.197516 0.264595 +vn 0.474410 0.846034 -0.243110 +vn 0.189673 0.975890 -0.107700 +vn -0.724845 -0.567095 0.391125 +vn -0.202490 -0.979186 0.011109 +vn -0.998108 0.000000 0.061373 +vn -0.972839 0.187139 -0.135990 +vn -0.860256 -0.178137 -0.477676 +vn 0.428510 0.772362 0.468856 +vn 0.369884 0.764306 0.528184 +vn -0.874294 0.000000 -0.485366 +vn -0.328166 -0.906491 -0.265633 +vn -0.030274 0.999146 -0.027039 +vn -0.493789 -0.664998 -0.560259 +vn 0.312662 0.748894 0.584246 +vn 0.166234 0.917997 0.359996 +vn -0.081942 -0.975890 -0.202246 +vn -0.009033 -0.818598 -0.574236 +vn -0.064699 0.946013 0.317515 +vn 0.026704 0.998230 -0.052797 +vn 0.272134 -0.710532 -0.648854 +vn -0.317606 0.829768 0.458876 +vn 0.316660 -0.837947 -0.444441 +vn 0.478469 0.567003 -0.670431 +vn 0.532487 -0.833369 -0.148076 +vn 0.972869 0.187139 0.135990 +vn 0.553331 -0.811121 0.189276 +vn 0.387494 -0.912198 0.133030 +vn 0.860256 0.178137 0.477676 +vn 0.171636 -0.975249 0.139225 +vn -0.344157 0.863186 -0.369366 +vn -0.512497 0.624989 -0.588794 +vn 0.081942 -0.975890 0.202216 +vn 0.009033 -0.818598 0.574236 +vn 0.044038 -0.976867 0.209235 +vn -0.154302 -0.549699 0.820948 +vn 0.154057 0.811884 -0.563097 +vn -0.054750 0.636555 -0.769250 +vn 0.002075 0.999268 0.037935 +vn -0.071047 -0.920469 0.384289 +vn -0.010163 0.999207 0.038087 +vn -0.087680 0.942198 -0.323344 +vn 0.161962 0.802271 -0.574541 +vn -0.272164 -0.710532 0.648854 +vn -0.213446 -0.833277 0.509964 +vn -0.520859 -0.719382 0.459517 +vn 0.336100 0.820551 -0.462233 +usemtl Body +s 1 +f 5791//3529 5790//3530 5805//3531 +f 5786//3532 5785//3533 5800//3534 +f 5797//3535 5796//3536 5812//3537 +f 5792//3538 5791//3529 5806//4010 +f 5787//3540 5786//3532 5801//4011 +f 5798//3542 5797//3535 5813//3543 +f 5793//3544 5792//3538 5808//3545 +f 5788//4012 5787//3540 5802//3547 +f 5799//3548 5798//3542 5814//3549 +f 5794//3550 5793//3544 5809//3551 +f 5789//3552 5788//4012 5803//3553 +f 5795//4013 5794//3550 5810//3555 +f 5790//3530 5789//3552 5804//3556 +f 5796//3536 5795//4013 5811//3557 +f 5811//3557 5810//3555 5826//3558 +f 5806//4010 5805//3531 5820//3559 +f 5801//4011 5800//3534 5815//3560 +f 5812//3537 5811//3557 5827//3561 +f 5807//3562 5806//4010 5821//3563 +f 5802//3547 5801//4011 5816//3564 +f 5813//3543 5812//3537 5828//3565 +f 5808//3545 5807//3562 5823//3566 +f 5803//3553 5802//3547 5817//3567 +f 5814//3549 5813//3543 5829//4014 +f 5809//3551 5808//3545 5824//3569 +f 5804//3556 5803//3553 5818//3570 +f 5810//3555 5809//3551 5825//3571 +f 5805//3531 5804//3556 5819//3572 +f 5825//3571 5824//3569 5840//3573 +f 5820//3559 5819//3572 5834//3574 +f 5826//3558 5825//3571 5841//3575 +f 5821//3563 5820//3559 5835//3576 +f 5816//3564 5815//3560 5830//3577 +f 5827//3561 5826//3558 5842//3578 +f 5822//4015 5821//3563 5836//4016 +f 5817//3567 5816//3564 5831//3581 +f 5828//3565 5827//3561 5843//3582 +f 5823//3566 5822//4015 5838//3583 +f 5818//3570 5817//3567 5832//3584 +f 5829//4014 5828//3565 5844//3585 +f 5824//3569 5823//3566 5839//3586 +f 5819//3572 5818//3570 5833//3587 +f 5844//3585 5843//3582 5859//3588 +f 5839//3586 5838//3583 5854//3589 +f 5834//3574 5833//3587 5848//3590 +f 5840//3573 5839//3586 5855//3591 +f 5835//3576 5834//3574 5849//3592 +f 5841//3575 5840//3573 5856//3593 +f 5836//4016 5835//3576 5850//3594 +f 5831//3581 5830//3577 5845//3595 +f 5842//3578 5841//3575 5857//3596 +f 5837//3597 5836//4016 5851//3598 +f 5832//3584 5831//3581 5847//3599 +f 5843//3582 5842//3578 5858//3600 +f 5838//3583 5837//3597 5853//3601 +f 5833//3587 5832//3584 5848//3590 +f 5847//3599 5846//3602 5862//3603 +f 5858//3600 5857//3596 5873//3604 +f 5853//3601 5852//3605 5868//4017 +f 5848//3590 5847//3599 5863//3607 +f 5859//3588 5858//3600 5874//3608 +f 5854//3589 5853//3601 5869//3609 +f 5849//3592 5848//3590 5863//3607 +f 5855//3591 5854//3589 5870//3610 +f 5850//3594 5849//3592 5864//3611 +f 5856//3593 5855//3591 5871//3612 +f 5851//3598 5850//3594 5865//3613 +f 5846//3602 5845//3595 5861//4018 +f 5857//3596 5856//3593 5872//3615 +f 5852//3605 5851//3598 5866//3616 +f 5866//3616 5865//3613 5880//3617 +f 5861//4018 5860//3618 5876//4019 +f 5872//3615 5871//3612 5887//3620 +f 5867//4020 5866//3616 5881//3622 +f 5862//3603 5861//4018 5877//3623 +f 5873//3604 5872//3615 5888//4021 +f 5868//4017 5867//4020 5883//3625 +f 5863//3607 5862//3603 5877//3623 +f 5874//3608 5873//3604 5889//3626 +f 5869//3609 5868//4017 5884//3627 +f 5864//3611 5863//3607 5878//4022 +f 5870//3610 5869//3609 5885//3629 +f 5865//3613 5864//3611 5879//3630 +f 5871//3612 5870//3610 5886//3631 +f 5885//3629 5884//3627 5900//3632 +f 5880//3617 5879//3630 5894//3633 +f 5886//3631 5885//3629 5901//4023 +f 5881//3622 5880//3617 5895//3635 +f 5876//4019 5875//3636 5891//4024 +f 5887//3620 5886//3631 5902//3638 +f 5882//3639 5881//3622 5896//3640 +f 5877//3623 5876//4019 5892//3641 +f 5888//4021 5887//3620 5903//3642 +f 5883//3625 5882//3639 5898//3643 +f 5878//4022 5877//3623 5893//3644 +f 5889//3626 5888//4021 5904//3645 +f 5884//3627 5883//3625 5899//3646 +f 5879//3630 5878//4022 5893//3644 +f 5904//3645 5903//3642 5918//3647 +f 5899//3646 5898//3643 5913//3648 +f 5894//3633 5893//3644 5909//3649 +f 5900//3632 5899//3646 5914//3650 +f 5895//3635 5894//3633 5910//3651 +f 5901//4023 5900//3632 5915//3652 +f 5896//3640 5895//3635 5911//3653 +f 5891//4024 5890//3654 5906//3655 +f 5902//3638 5901//4023 5916//3656 +f 5897//3657 5896//3640 5912//3658 +f 5892//3641 5891//4024 5907//3659 +f 5903//3642 5902//3638 5917//3660 +f 5898//3643 5897//3657 5912//3658 +f 5893//3644 5892//3641 5908//3661 +f 5907//3659 5906//3655 5922//3662 +f 5918//3647 5917//3660 5932//3663 +f 5913//3648 5912//3658 5927//3664 +f 5908//3661 5907//3659 5923//3665 +f 5919//3666 5918//3647 5933//3667 +f 5914//3650 5913//3648 5928//3668 +f 5909//3649 5908//3661 5924//3669 +f 5915//3652 5914//3650 5929//3670 +f 5910//3651 5909//3649 5925//3671 +f 5916//3656 5915//3652 5930//3672 +f 5911//3653 5910//3651 5926//3673 +f 5906//3655 5905//4025 5921//3675 +f 5917//3660 5916//3656 5931//3676 +f 5912//3658 5911//3653 5927//3664 +f 5926//3673 5925//3671 5941//3677 +f 5921//3675 5920//3678 5936//3679 +f 5932//3663 5931//3676 5946//3680 +f 5927//3664 5926//3673 5942//3681 +f 5922//3662 5921//3675 5937//3682 +f 5933//3667 5932//3663 5947//3683 +f 5928//3668 5927//3664 5942//3681 +f 5923//3665 5922//3662 5938//3684 +f 5934//4026 5933//3667 5948//3686 +f 5929//3670 5928//3668 5943//3687 +f 5924//3669 5923//3665 5939//3688 +f 5930//3672 5929//3670 5944//3689 +f 5925//3671 5924//3669 5940//3690 +f 5931//3676 5930//3672 5945//3691 +f 5945//3691 5944//3689 5959//3692 +f 5940//3690 5939//3688 5955//3693 +f 5946//3680 5945//3691 5960//3694 +f 5941//3677 5940//3690 5956//3695 +f 5936//3679 5935//3696 5951//3697 +f 5947//3683 5946//3680 5961//3698 +f 5942//3681 5941//3677 5957//3699 +f 5937//3682 5936//3679 5952//3700 +f 5948//3686 5947//3683 5962//4027 +f 5943//3687 5942//3681 5957//3699 +f 5938//3684 5937//3682 5953//3702 +f 5949//3703 5948//3686 5963//3704 +f 5944//3689 5943//3687 5958//3705 +f 5939//3688 5938//3684 5954//3706 +f 5964//3707 5963//3704 5978//3708 +f 5959//3692 5958//3705 5973//3709 +f 5954//3706 5953//3702 5969//3710 +f 5960//3694 5959//3692 5974//3711 +f 5955//3693 5954//3706 5970//3712 +f 5961//3698 5960//3694 5975//3713 +f 5956//3695 5955//3693 5971//3714 +f 5951//3697 5950//3715 5965//4028 +f 5962//4027 5961//3698 5976//3717 +f 5957//3699 5956//3695 5972//3718 +f 5952//3700 5951//3697 5966//3719 +f 5963//3704 5962//4027 5977//3720 +f 5958//3705 5957//3699 5972//3718 +f 5953//3702 5952//3700 5968//3721 +f 5978//3708 5977//3720 5992//3722 +f 5973//3709 5972//3718 5987//3723 +f 5968//3721 5967//3724 5983//4029 +f 5979//3726 5978//3708 5993//3727 +f 5974//3711 5973//3709 5988//3728 +f 5969//3710 5968//3721 5984//3729 +f 5975//3713 5974//3711 5989//3730 +f 5970//3712 5969//3710 5985//3731 +f 5976//3717 5975//3713 5990//3732 +f 5971//3714 5970//3712 5986//3733 +f 5966//3719 5965//4028 5980//3734 +f 5977//3720 5976//3717 5991//4030 +f 5972//3718 5971//3714 5987//3723 +f 5967//3724 5966//3719 5981//3736 +f 5981//3736 5980//3734 5995//3737 +f 5992//3722 5991//4030 6006//3738 +f 5987//3723 5986//3733 6002//3739 +f 5982//3740 5981//3736 5996//4031 +f 5993//3727 5992//3722 6007//4032 +f 5988//3728 5987//3723 6002//3739 +f 5983//4029 5982//3740 5998//3743 +f 5994//3744 5993//3727 6008//3745 +f 5989//3730 5988//3728 6003//3746 +f 5984//3729 5983//4029 5999//4033 +f 5990//3732 5989//3730 6004//3748 +f 5985//3731 5984//3729 6000//3749 +f 5991//4030 5990//3732 6005//3750 +f 5986//3733 5985//3731 6001//3751 +f 6000//3749 5999//4033 6015//3752 +f 6006//3738 6005//3750 6020//3753 +f 6001//3751 6000//3749 6016//3754 +f 5996//4031 5995//3737 6011//3755 +f 6007//4032 6006//3738 6021//3756 +f 6002//3739 6001//3751 6017//3757 +f 5997//3758 5996//4031 6012//3759 +f 6008//3745 6007//4032 6022//3760 +f 6003//3746 6002//3739 6017//3757 +f 5998//3743 5997//3758 6013//3761 +f 6009//3762 6008//3745 6023//3763 +f 6004//3748 6003//3746 6018//3764 +f 5999//4033 5998//3743 6014//3765 +f 6005//3750 6004//3748 6019//3766 +f 6019//3766 6018//3764 6034//3767 +f 6014//3765 6013//3761 6028//3768 +f 6020//3753 6019//3766 6035//3769 +f 6015//3752 6014//3765 6029//3770 +f 6021//3756 6020//3753 6036//3771 +f 6016//3754 6015//3752 6030//3772 +f 6011//3755 6010//3773 6026//3774 +f 6022//3760 6021//3756 6037//3775 +f 6017//3757 6016//3754 6031//3776 +f 6012//3759 6011//3755 6027//3777 +f 6023//3763 6022//3760 6038//3778 +f 6018//3764 6017//3757 6033//3779 +f 6013//3761 6012//3759 6028//3768 +f 6024//3780 6023//3763 6039//3781 +f 6038//3778 6037//3775 6053//3782 +f 6033//3779 6032//3783 6048//3784 +f 6028//3768 6027//3777 6043//3785 +f 6039//3781 6038//3778 6054//3786 +f 6034//3767 6033//3779 6049//3787 +f 6029//3770 6028//3768 6043//3785 +f 6035//3769 6034//3767 6050//3788 +f 6030//3772 6029//3770 6044//3789 +f 6036//3771 6035//3769 6051//3790 +f 6031//3776 6030//3772 6045//3791 +f 6026//3774 6025//3792 6041//3793 +f 6037//3775 6036//3771 6052//4034 +f 6032//3783 6031//3776 6046//3795 +f 6027//3777 6026//3774 6042//3796 +f 6041//3793 6040//3797 6055//3798 +f 6052//4034 6051//3790 6067//3799 +f 6047//3800 6046//3795 6061//3801 +f 6042//3796 6041//3793 6056//3802 +f 6053//3782 6052//4034 6068//3803 +f 6048//3784 6047//3800 6063//3804 +f 6043//3785 6042//3796 6057//3805 +f 6054//3786 6053//3782 6069//3806 +f 6049//3787 6048//3784 6064//3807 +f 6044//3789 6043//3785 6058//3808 +f 6050//3788 6049//3787 6065//3809 +f 6045//3791 6044//3789 6059//3810 +f 6051//3790 6050//3788 6066//3811 +f 6046//3795 6045//3791 6060//3812 +f 6060//3812 6059//3810 6074//3813 +f 6066//3811 6065//3809 6081//3814 +f 6061//3801 6060//3812 6075//3815 +f 6056//3802 6055//3798 6070//3816 +f 6067//3799 6066//3811 6082//3817 +f 6062//3818 6061//3801 6076//4035 +f 6057//3805 6056//3802 6071//3820 +f 6068//3803 6067//3799 6083//3821 +f 6063//3804 6062//3818 6078//3822 +f 6058//3808 6057//3805 6072//3823 +f 6069//3806 6068//3803 6084//3824 +f 6064//3807 6063//3804 6079//3825 +f 6059//3810 6058//3808 6073//3826 +f 6065//3809 6064//3807 6080//3827 +f 6079//3825 6078//3822 6094//3828 +f 6074//3813 6073//3826 6088//3829 +f 6080//3827 6079//3825 6095//3830 +f 6075//3815 6074//3813 6089//3831 +f 6081//3814 6080//3827 6096//3832 +f 6076//4035 6075//3815 6090//3833 +f 6071//3820 6070//3816 6085//3834 +f 6082//3817 6081//3814 6097//4036 +f 6077//3836 6076//4035 6091//3837 +f 6072//3823 6071//3820 6086//3838 +f 6083//3821 6082//3817 6098//4037 +f 6078//3822 6077//3836 6093//3840 +f 6073//3826 6072//3823 6087//3841 +f 6084//3824 6083//3821 6099//3842 +f 6098//4037 6097//4036 6113//3843 +f 6093//3840 6092//3844 6108//3845 +f 6088//3829 6087//3841 6102//3846 +f 6099//3842 6098//4037 6114//3847 +f 6094//3828 6093//3840 6109//3848 +f 6089//3831 6088//3829 6103//3849 +f 6095//3830 6094//3828 6110//3850 +f 6090//3833 6089//3831 6104//3851 +f 6096//3832 6095//3830 6111//3852 +f 6091//3837 6090//3833 6105//3853 +f 6086//3838 6085//3834 6101//3854 +f 6097//4036 6096//3832 6112//3855 +f 6092//3844 6091//3837 6106//4038 +f 6087//3841 6086//3838 6102//3846 +f 6112//3855 6111//3852 6128//3857 +f 6107//3858 6106//4038 6122//3859 +f 6102//3846 6101//3854 6118//3860 +f 6113//3843 6112//3855 6129//3861 +f 6108//3845 6107//3858 6124//3862 +f 6103//3849 6102//3846 6118//3860 +f 6114//3847 6113//3843 6130//4039 +f 6109//3848 6108//3845 6125//3864 +f 6104//3851 6103//3849 6119//3865 +f 6110//3850 6109//3848 6126//3866 +f 6105//3853 6104//3851 6120//3867 +f 6111//3852 6110//3850 6127//3868 +f 6106//4038 6105//3853 6121//3869 +f 6101//3854 6100//3870 6117//3871 +f 6127//3868 6126//3866 6142//3872 +f 6122//3859 6121//3869 6136//3873 +f 6117//3871 6116//4040 6132//3875 +f 6128//3857 6127//3868 6143//3876 +f 6123//3877 6122//3859 6137//3878 +f 6118//3860 6117//3871 6133//3879 +f 6129//3861 6128//3857 6144//3880 +f 6124//3862 6123//3877 6139//3881 +f 6119//3865 6118//3860 6134//3882 +f 6130//4039 6129//3861 6145//3883 +f 6125//3864 6124//3862 6140//3884 +f 6120//3867 6119//3865 6134//3882 +f 6126//3866 6125//3864 6141//3885 +f 6121//3869 6120//3867 6135//3886 +f 6135//3886 6134//3882 6150//3887 +f 6141//3885 6140//3884 6155//3888 +f 6136//3873 6135//3886 6151//3889 +f 6142//3872 6141//3885 6156//3890 +f 6137//3878 6136//3873 6152//3891 +f 6132//3875 6131//3892 6146//3893 +f 6143//3876 6142//3872 6157//3894 +f 6138//3895 6137//3878 6153//3896 +f 6133//3879 6132//3875 6148//3897 +f 6144//3880 6143//3876 6158//3898 +f 6139//3881 6138//3895 6153//3896 +f 6134//3882 6133//3879 6149//3899 +f 6145//3883 6144//3880 6159//3900 +f 6140//3884 6139//3881 6154//3901 +f 6154//3901 6153//3896 6168//3902 +f 6149//3899 6148//3897 6163//3903 +f 6160//3904 6159//3900 6174//3905 +f 6155//3888 6154//3901 6169//3906 +f 6150//3887 6149//3899 6165//3907 +f 6156//3890 6155//3888 6170//3908 +f 6151//3889 6150//3887 6166//3909 +f 6157//3894 6156//3890 6171//3910 +f 6152//3891 6151//3889 6167//3911 +f 6147//4041 6146//3893 6161//3913 +f 6158//3898 6157//3894 6172//3914 +f 6153//3896 6152//3891 6168//3902 +f 6148//3897 6147//4041 6162//3915 +f 6159//3900 6158//3898 6173//3916 +f 6173//3916 6172//3914 6187//3917 +f 6168//3902 6167//3911 6183//3918 +f 6163//3903 6162//3915 6177//3919 +f 6174//3905 6173//3916 6188//3920 +f 6169//3906 6168//3902 6183//3918 +f 6164//3921 6163//3903 6178//3922 +f 6175//4042 6174//3905 6189//3924 +f 6170//3908 6169//3906 6184//3925 +f 6165//3907 6164//3921 6180//3926 +f 6171//3910 6170//3908 6185//3927 +f 6166//3909 6165//3907 6181//3928 +f 6172//3914 6171//3910 6186//3929 +f 6167//3911 6166//3909 6182//3930 +f 6162//3915 6161//3913 6176//3931 +f 6187//3917 6186//3929 6201//3932 +f 6182//3930 6181//3928 6197//3933 +f 6177//3919 6176//3931 6191//3934 +f 6188//3920 6187//3917 6202//3935 +f 6183//3918 6182//3930 6198//3936 +f 6178//3922 6177//3919 6192//3937 +f 6189//3924 6188//3920 6203//4043 +f 6184//3925 6183//3918 6198//3936 +f 6179//3939 6178//3922 6194//3940 +f 6190//4044 6189//3924 6204//3942 +f 6185//3927 6184//3925 6199//3943 +f 6180//3926 6179//3939 6195//3944 +f 6186//3929 6185//3927 6200//3945 +f 6181//3928 6180//3926 6196//3946 +f 6195//3944 6194//3940 6210//3947 +f 6201//3932 6200//3945 6215//3948 +f 6196//3946 6195//3944 6211//3949 +f 6202//3935 6201//3932 6216//4045 +f 6197//3933 6196//3946 6212//3951 +f 6192//3937 6191//3934 6207//4046 +f 6203//4043 6202//3935 6217//3953 +f 6198//3936 6197//3933 6213//3954 +f 6193//4047 6192//3937 6208//3956 +f 6204//3942 6203//4043 6218//3957 +f 6199//3943 6198//3936 6213//3954 +f 6194//3940 6193//4047 6209//4048 +f 6205//3959 6204//3942 6219//4049 +f 6200//3945 6199//3943 6214//3961 +f 6214//3961 6213//3954 6228//3962 +f 6209//4048 6208//3956 6224//4050 +f 6220//3964 6219//4049 6234//3965 +f 6215//3948 6214//3961 6229//3966 +f 6210//3947 6209//4048 6225//3967 +f 6216//4045 6215//3948 6230//3968 +f 6211//3949 6210//3947 6226//3969 +f 6217//3953 6216//4045 6231//3970 +f 6212//3951 6211//3949 6227//3971 +f 6207//4046 6206//4051 6222//4052 +f 6218//3957 6217//3953 6232//4053 +f 6213//3954 6212//3951 6228//3962 +f 6208//3956 6207//4046 6223//3975 +f 6219//4049 6218//3957 6233//4054 +f 6233//4054 6232//4053 6248//3977 +f 6228//3962 6227//3971 6244//3978 +f 6223//3975 6222//4052 6239//3979 +f 6234//3965 6233//4054 6249//3980 +f 6229//3966 6228//3962 6244//3978 +f 6224//4050 6223//3975 6240//3981 +f 6235//3982 6234//3965 6250//3983 +f 6230//3968 6229//3966 6245//3984 +f 6225//3967 6224//4050 6241//3985 +f 6231//3970 6230//3968 6246//3986 +f 6226//3969 6225//3967 6242//3987 +f 6232//4053 6231//3970 6247//3988 +f 6227//3971 6226//3969 6243//3989 +f 6222//4052 6221//3990 6238//3991 +f 6248//3977 6247//3988 6262//3992 +f 6243//3989 6242//3987 6258//3993 +f 6238//3991 6237//3994 6252//3995 +f 6249//3980 6248//3977 6263//4055 +f 6244//3978 6243//3989 6259//3997 +f 6239//3979 6238//3991 6253//4056 +f 6250//3983 6249//3980 6264//3999 +f 6245//3984 6244//3978 6259//3997 +f 6240//3981 6239//3979 6254//4000 +f 6251//4001 6250//3983 6265//4002 +f 6246//3986 6245//3984 6260//4003 +f 6241//3985 6240//3981 6256//4004 +f 6247//3988 6246//3986 6261//4005 +f 6242//3987 6241//3985 6257//4006 +f 6115//364 5799//3548 5814//3549 +f 5785//3533 6236//4007 5800//3534 +f 6115//364 5814//3549 5829//4014 +f 5800//3534 6236//4007 5815//3560 +f 6115//364 5829//4014 5844//3585 +f 5815//3560 6236//4007 5830//3577 +f 6115//364 5844//3585 5859//3588 +f 5830//3577 6236//4007 5845//3595 +f 6115//364 5859//3588 5874//3608 +f 5845//3595 6236//4007 5860//3618 +f 6115//364 5874//3608 5889//3626 +f 5860//3618 6236//4007 5875//3636 +f 5875//3636 6236//4007 5890//3654 +f 6115//364 5889//3626 5904//3645 +f 6115//364 5904//3645 5919//3666 +f 5890//3654 6236//4007 5905//4025 +f 6115//364 5919//3666 5934//4026 +f 5905//4025 6236//4007 5920//3678 +f 6115//364 5934//4026 5949//3703 +f 5920//3678 6236//4007 5935//3696 +f 5935//3696 6236//4007 5950//3715 +f 6115//364 5949//3703 5964//3707 +f 6115//364 5964//3707 5979//3726 +f 5950//3715 6236//4007 5965//4028 +f 6115//364 5979//3726 5994//3744 +f 5965//4028 6236//4007 5980//3734 +f 6115//364 5994//3744 6009//3762 +f 5980//3734 6236//4007 5995//3737 +f 5995//3737 6236//4007 6010//3773 +f 6115//364 6009//3762 6024//3780 +f 6115//364 6024//3780 6039//3781 +f 6010//3773 6236//4007 6025//3792 +f 6115//364 6039//3781 6054//3786 +f 6025//3792 6236//4007 6040//3797 +f 6115//364 6054//3786 6069//3806 +f 6040//3797 6236//4007 6055//3798 +f 6055//3798 6236//4007 6070//3816 +f 6115//364 6069//3806 6084//3824 +f 6115//364 6084//3824 6099//3842 +f 6070//3816 6236//4007 6085//3834 +f 6115//364 6099//3842 6114//3847 +f 6085//3834 6236//4007 6100//3870 +f 6115//364 6114//3847 6130//4039 +f 6100//3870 6236//4007 6116//4040 +f 6116//4040 6236//4007 6131//3892 +f 6115//364 6130//4039 6145//3883 +f 6115//364 6145//3883 6160//3904 +f 6131//3892 6236//4007 6146//3893 +f 6115//364 6160//3904 6175//4042 +f 6146//3893 6236//4007 6161//3913 +f 6115//364 6175//4042 6190//4044 +f 6161//3913 6236//4007 6176//3931 +f 6176//3931 6236//4007 6191//3934 +f 6115//364 6190//4044 6205//3959 +f 6115//364 6205//3959 6220//3964 +f 6191//3934 6236//4007 6206//4051 +f 6115//364 6220//3964 6235//3982 +f 6206//4051 6236//4007 6221//3990 +f 6115//364 6235//3982 6251//4001 +f 6221//3990 6236//4007 6237//3994 +f 6115//364 6251//4001 6266//4008 +f 6237//3994 6236//4007 6252//3995 +f 6115//364 6266//4008 5799//3548 +f 6262//3992 6261//4005 5795//4013 +f 6257//4006 6256//4004 5789//3552 +f 6252//3995 6236//4007 5785//3533 +f 6263//4055 6262//3992 5796//3536 +f 6258//3993 6257//4006 5790//3530 +f 6253//4056 6252//3995 5785//3533 +f 6264//3999 6263//4055 5797//3535 +f 6259//3997 6258//3993 5791//3529 +f 6254//4000 6253//4056 5786//3532 +f 6265//4002 6264//3999 5798//3542 +f 6260//4003 6259//3997 5793//3544 +f 6255//4009 6254//4000 5787//3540 +f 6266//4008 6265//4002 5799//3548 +f 6261//4005 6260//4003 5794//3550 +f 6256//4004 6255//4009 5788//4012 +f 5806//4010 5791//3529 5805//3531 +f 5801//4011 5786//3532 5800//3534 +f 5796//3536 5811//3557 5812//3537 +f 5807//3562 5792//3538 5806//4010 +f 5802//3547 5787//3540 5801//4011 +f 5797//3535 5812//3537 5813//3543 +f 5792//3538 5807//3562 5808//3545 +f 5803//3553 5788//4012 5802//3547 +f 5798//3542 5813//3543 5814//3549 +f 5793//3544 5808//3545 5809//3551 +f 5804//3556 5789//3552 5803//3553 +f 5794//3550 5809//3551 5810//3555 +f 5805//3531 5790//3530 5804//3556 +f 5795//4013 5810//3555 5811//3557 +f 5810//3555 5825//3571 5826//3558 +f 5821//3563 5806//4010 5820//3559 +f 5816//3564 5801//4011 5815//3560 +f 5811//3557 5826//3558 5827//3561 +f 5822//4015 5807//3562 5821//3563 +f 5817//3567 5802//3547 5816//3564 +f 5812//3537 5827//3561 5828//3565 +f 5807//3562 5822//4015 5823//3566 +f 5818//3570 5803//3553 5817//3567 +f 5813//3543 5828//3565 5829//4014 +f 5808//3545 5823//3566 5824//3569 +f 5819//3572 5804//3556 5818//3570 +f 5809//3551 5824//3569 5825//3571 +f 5820//3559 5805//3531 5819//3572 +f 5824//3569 5839//3586 5840//3573 +f 5835//3576 5820//3559 5834//3574 +f 5825//3571 5840//3573 5841//3575 +f 5836//4016 5821//3563 5835//3576 +f 5831//3581 5816//3564 5830//3577 +f 5826//3558 5841//3575 5842//3578 +f 5837//3597 5822//4015 5836//4016 +f 5832//3584 5817//3567 5831//3581 +f 5827//3561 5842//3578 5843//3582 +f 5822//4015 5837//3597 5838//3583 +f 5833//3587 5818//3570 5832//3584 +f 5828//3565 5843//3582 5844//3585 +f 5823//3566 5838//3583 5839//3586 +f 5834//3574 5819//3572 5833//3587 +f 5843//3582 5858//3600 5859//3588 +f 5838//3583 5853//3601 5854//3589 +f 5849//3592 5834//3574 5848//3590 +f 5839//3586 5854//3589 5855//3591 +f 5850//3594 5835//3576 5849//3592 +f 5840//3573 5855//3591 5856//3593 +f 5851//3598 5836//4016 5850//3594 +f 5846//3602 5831//3581 5845//3595 +f 5841//3575 5856//3593 5857//3596 +f 5852//3605 5837//3597 5851//3598 +f 5831//3581 5846//3602 5847//3599 +f 5842//3578 5857//3596 5858//3600 +f 5837//3597 5852//3605 5853//3601 +f 5832//3584 5847//3599 5848//3590 +f 5846//3602 5861//4018 5862//3603 +f 5857//3596 5872//3615 5873//3604 +f 5852//3605 5867//4020 5868//4017 +f 5847//3599 5862//3603 5863//3607 +f 5858//3600 5873//3604 5874//3608 +f 5853//3601 5868//4017 5869//3609 +f 5864//3611 5849//3592 5863//3607 +f 5854//3589 5869//3609 5870//3610 +f 5865//3613 5850//3594 5864//3611 +f 5855//3591 5870//3610 5871//3612 +f 5866//3616 5851//3598 5865//3613 +f 5845//3595 5860//3618 5861//4018 +f 5856//3593 5871//3612 5872//3615 +f 5867//4020 5852//3605 5866//3616 +f 5881//3622 5866//3616 5880//3617 +f 5860//3618 5875//3636 5876//4019 +f 5871//3612 5886//3631 5887//3620 +f 5882//3639 5867//4020 5881//3622 +f 5861//4018 5876//4019 5877//3623 +f 5872//3615 5887//3620 5888//4021 +f 5867//4020 5882//3639 5883//3625 +f 5878//4022 5863//3607 5877//3623 +f 5873//3604 5888//4021 5889//3626 +f 5868//4017 5883//3625 5884//3627 +f 5879//3630 5864//3611 5878//4022 +f 5869//3609 5884//3627 5885//3629 +f 5880//3617 5865//3613 5879//3630 +f 5870//3610 5885//3629 5886//3631 +f 5884//3627 5899//3646 5900//3632 +f 5895//3635 5880//3617 5894//3633 +f 5885//3629 5900//3632 5901//4023 +f 5896//3640 5881//3622 5895//3635 +f 5875//3636 5890//3654 5891//4024 +f 5886//3631 5901//4023 5902//3638 +f 5897//3657 5882//3639 5896//3640 +f 5876//4019 5891//4024 5892//3641 +f 5887//3620 5902//3638 5903//3642 +f 5882//3639 5897//3657 5898//3643 +f 5877//3623 5892//3641 5893//3644 +f 5888//4021 5903//3642 5904//3645 +f 5883//3625 5898//3643 5899//3646 +f 5894//3633 5879//3630 5893//3644 +f 5919//3666 5904//3645 5918//3647 +f 5914//3650 5899//3646 5913//3648 +f 5893//3644 5908//3661 5909//3649 +f 5915//3652 5900//3632 5914//3650 +f 5894//3633 5909//3649 5910//3651 +f 5916//3656 5901//4023 5915//3652 +f 5895//3635 5910//3651 5911//3653 +f 5890//3654 5905//4025 5906//3655 +f 5917//3660 5902//3638 5916//3656 +f 5896//3640 5911//3653 5912//3658 +f 5891//4024 5906//3655 5907//3659 +f 5918//3647 5903//3642 5917//3660 +f 5913//3648 5898//3643 5912//3658 +f 5892//3641 5907//3659 5908//3661 +f 5906//3655 5921//3675 5922//3662 +f 5933//3667 5918//3647 5932//3663 +f 5928//3668 5913//3648 5927//3664 +f 5907//3659 5922//3662 5923//3665 +f 5934//4026 5919//3666 5933//3667 +f 5929//3670 5914//3650 5928//3668 +f 5908//3661 5923//3665 5924//3669 +f 5930//3672 5915//3652 5929//3670 +f 5909//3649 5924//3669 5925//3671 +f 5931//3676 5916//3656 5930//3672 +f 5910//3651 5925//3671 5926//3673 +f 5905//4025 5920//3678 5921//3675 +f 5932//3663 5917//3660 5931//3676 +f 5911//3653 5926//3673 5927//3664 +f 5925//3671 5940//3690 5941//3677 +f 5920//3678 5935//3696 5936//3679 +f 5947//3683 5932//3663 5946//3680 +f 5926//3673 5941//3677 5942//3681 +f 5921//3675 5936//3679 5937//3682 +f 5948//3686 5933//3667 5947//3683 +f 5943//3687 5928//3668 5942//3681 +f 5922//3662 5937//3682 5938//3684 +f 5949//3703 5934//4026 5948//3686 +f 5944//3689 5929//3670 5943//3687 +f 5923//3665 5938//3684 5939//3688 +f 5945//3691 5930//3672 5944//3689 +f 5924//3669 5939//3688 5940//3690 +f 5946//3680 5931//3676 5945//3691 +f 5960//3694 5945//3691 5959//3692 +f 5939//3688 5954//3706 5955//3693 +f 5961//3698 5946//3680 5960//3694 +f 5940//3690 5955//3693 5956//3695 +f 5935//3696 5950//3715 5951//3697 +f 5962//4027 5947//3683 5961//3698 +f 5941//3677 5956//3695 5957//3699 +f 5936//3679 5951//3697 5952//3700 +f 5963//3704 5948//3686 5962//4027 +f 5958//3705 5943//3687 5957//3699 +f 5937//3682 5952//3700 5953//3702 +f 5964//3707 5949//3703 5963//3704 +f 5959//3692 5944//3689 5958//3705 +f 5938//3684 5953//3702 5954//3706 +f 5979//3726 5964//3707 5978//3708 +f 5974//3711 5959//3692 5973//3709 +f 5953//3702 5968//3721 5969//3710 +f 5975//3713 5960//3694 5974//3711 +f 5954//3706 5969//3710 5970//3712 +f 5976//3717 5961//3698 5975//3713 +f 5955//3693 5970//3712 5971//3714 +f 5966//3719 5951//3697 5965//4028 +f 5977//3720 5962//4027 5976//3717 +f 5956//3695 5971//3714 5972//3718 +f 5967//3724 5952//3700 5966//3719 +f 5978//3708 5963//3704 5977//3720 +f 5973//3709 5958//3705 5972//3718 +f 5952//3700 5967//3724 5968//3721 +f 5993//3727 5978//3708 5992//3722 +f 5988//3728 5973//3709 5987//3723 +f 5967//3724 5982//3740 5983//4029 +f 5994//3744 5979//3726 5993//3727 +f 5989//3730 5974//3711 5988//3728 +f 5968//3721 5983//4029 5984//3729 +f 5990//3732 5975//3713 5989//3730 +f 5969//3710 5984//3729 5985//3731 +f 5991//4030 5976//3717 5990//3732 +f 5970//3712 5985//3731 5986//3733 +f 5981//3736 5966//3719 5980//3734 +f 5992//3722 5977//3720 5991//4030 +f 5971//3714 5986//3733 5987//3723 +f 5982//3740 5967//3724 5981//3736 +f 5996//4031 5981//3736 5995//3737 +f 6007//4032 5992//3722 6006//3738 +f 5986//3733 6001//3751 6002//3739 +f 5997//3758 5982//3740 5996//4031 +f 6008//3745 5993//3727 6007//4032 +f 6003//3746 5988//3728 6002//3739 +f 5982//3740 5997//3758 5998//3743 +f 6009//3762 5994//3744 6008//3745 +f 6004//3748 5989//3730 6003//3746 +f 5983//4029 5998//3743 5999//4033 +f 6005//3750 5990//3732 6004//3748 +f 5984//3729 5999//4033 6000//3749 +f 6006//3738 5991//4030 6005//3750 +f 5985//3731 6000//3749 6001//3751 +f 5999//4033 6014//3765 6015//3752 +f 6021//3756 6006//3738 6020//3753 +f 6000//3749 6015//3752 6016//3754 +f 5995//3737 6010//3773 6011//3755 +f 6022//3760 6007//4032 6021//3756 +f 6001//3751 6016//3754 6017//3757 +f 5996//4031 6011//3755 6012//3759 +f 6023//3763 6008//3745 6022//3760 +f 6018//3764 6003//3746 6017//3757 +f 5997//3758 6012//3759 6013//3761 +f 6024//3780 6009//3762 6023//3763 +f 6019//3766 6004//3748 6018//3764 +f 5998//3743 6013//3761 6014//3765 +f 6020//3753 6005//3750 6019//3766 +f 6018//3764 6033//3779 6034//3767 +f 6029//3770 6014//3765 6028//3768 +f 6019//3766 6034//3767 6035//3769 +f 6030//3772 6015//3752 6029//3770 +f 6020//3753 6035//3769 6036//3771 +f 6031//3776 6016//3754 6030//3772 +f 6010//3773 6025//3792 6026//3774 +f 6021//3756 6036//3771 6037//3775 +f 6032//3783 6017//3757 6031//3776 +f 6011//3755 6026//3774 6027//3777 +f 6022//3760 6037//3775 6038//3778 +f 6017//3757 6032//3783 6033//3779 +f 6012//3759 6027//3777 6028//3768 +f 6023//3763 6038//3778 6039//3781 +f 6037//3775 6052//4034 6053//3782 +f 6032//3783 6047//3800 6048//3784 +f 6027//3777 6042//3796 6043//3785 +f 6038//3778 6053//3782 6054//3786 +f 6033//3779 6048//3784 6049//3787 +f 6044//3789 6029//3770 6043//3785 +f 6034//3767 6049//3787 6050//3788 +f 6045//3791 6030//3772 6044//3789 +f 6035//3769 6050//3788 6051//3790 +f 6046//3795 6031//3776 6045//3791 +f 6025//3792 6040//3797 6041//3793 +f 6036//3771 6051//3790 6052//4034 +f 6047//3800 6032//3783 6046//3795 +f 6026//3774 6041//3793 6042//3796 +f 6056//3802 6041//3793 6055//3798 +f 6051//3790 6066//3811 6067//3799 +f 6062//3818 6047//3800 6061//3801 +f 6057//3805 6042//3796 6056//3802 +f 6052//4034 6067//3799 6068//3803 +f 6047//3800 6062//3818 6063//3804 +f 6058//3808 6043//3785 6057//3805 +f 6053//3782 6068//3803 6069//3806 +f 6048//3784 6063//3804 6064//3807 +f 6059//3810 6044//3789 6058//3808 +f 6049//3787 6064//3807 6065//3809 +f 6060//3812 6045//3791 6059//3810 +f 6050//3788 6065//3809 6066//3811 +f 6061//3801 6046//3795 6060//3812 +f 6075//3815 6060//3812 6074//3813 +f 6065//3809 6080//3827 6081//3814 +f 6076//4035 6061//3801 6075//3815 +f 6071//3820 6056//3802 6070//3816 +f 6066//3811 6081//3814 6082//3817 +f 6077//3836 6062//3818 6076//4035 +f 6072//3823 6057//3805 6071//3820 +f 6067//3799 6082//3817 6083//3821 +f 6062//3818 6077//3836 6078//3822 +f 6073//3826 6058//3808 6072//3823 +f 6068//3803 6083//3821 6084//3824 +f 6063//3804 6078//3822 6079//3825 +f 6074//3813 6059//3810 6073//3826 +f 6064//3807 6079//3825 6080//3827 +f 6078//3822 6093//3840 6094//3828 +f 6089//3831 6074//3813 6088//3829 +f 6079//3825 6094//3828 6095//3830 +f 6090//3833 6075//3815 6089//3831 +f 6080//3827 6095//3830 6096//3832 +f 6091//3837 6076//4035 6090//3833 +f 6086//3838 6071//3820 6085//3834 +f 6081//3814 6096//3832 6097//4036 +f 6092//3844 6077//3836 6091//3837 +f 6087//3841 6072//3823 6086//3838 +f 6082//3817 6097//4036 6098//4037 +f 6077//3836 6092//3844 6093//3840 +f 6088//3829 6073//3826 6087//3841 +f 6083//3821 6098//4037 6099//3842 +f 6097//4036 6112//3855 6113//3843 +f 6092//3844 6107//3858 6108//3845 +f 6103//3849 6088//3829 6102//3846 +f 6098//4037 6113//3843 6114//3847 +f 6093//3840 6108//3845 6109//3848 +f 6104//3851 6089//3831 6103//3849 +f 6094//3828 6109//3848 6110//3850 +f 6105//3853 6090//3833 6104//3851 +f 6095//3830 6110//3850 6111//3852 +f 6106//4038 6091//3837 6105//3853 +f 6085//3834 6100//3870 6101//3854 +f 6096//3832 6111//3852 6112//3855 +f 6107//3858 6092//3844 6106//4038 +f 6086//3838 6101//3854 6102//3846 +f 6111//3852 6127//3868 6128//3857 +f 6123//3877 6107//3858 6122//3859 +f 6101//3854 6117//3871 6118//3860 +f 6112//3855 6128//3857 6129//3861 +f 6107//3858 6123//3877 6124//3862 +f 6119//3865 6103//3849 6118//3860 +f 6113//3843 6129//3861 6130//4039 +f 6108//3845 6124//3862 6125//3864 +f 6120//3867 6104//3851 6119//3865 +f 6109//3848 6125//3864 6126//3866 +f 6121//3869 6105//3853 6120//3867 +f 6110//3850 6126//3866 6127//3868 +f 6122//3859 6106//4038 6121//3869 +f 6100//3870 6116//4040 6117//3871 +f 6126//3866 6141//3885 6142//3872 +f 6137//3878 6122//3859 6136//3873 +f 6116//4040 6131//3892 6132//3875 +f 6127//3868 6142//3872 6143//3876 +f 6138//3895 6123//3877 6137//3878 +f 6117//3871 6132//3875 6133//3879 +f 6128//3857 6143//3876 6144//3880 +f 6123//3877 6138//3895 6139//3881 +f 6118//3860 6133//3879 6134//3882 +f 6129//3861 6144//3880 6145//3883 +f 6124//3862 6139//3881 6140//3884 +f 6135//3886 6120//3867 6134//3882 +f 6125//3864 6140//3884 6141//3885 +f 6136//3873 6121//3869 6135//3886 +f 6134//3882 6149//3899 6150//3887 +f 6156//3890 6141//3885 6155//3888 +f 6135//3886 6150//3887 6151//3889 +f 6157//3894 6142//3872 6156//3890 +f 6136//3873 6151//3889 6152//3891 +f 6147//4041 6132//3875 6146//3893 +f 6158//3898 6143//3876 6157//3894 +f 6137//3878 6152//3891 6153//3896 +f 6132//3875 6147//4041 6148//3897 +f 6159//3900 6144//3880 6158//3898 +f 6154//3901 6139//3881 6153//3896 +f 6133//3879 6148//3897 6149//3899 +f 6160//3904 6145//3883 6159//3900 +f 6155//3888 6140//3884 6154//3901 +f 6169//3906 6154//3901 6168//3902 +f 6164//3921 6149//3899 6163//3903 +f 6175//4042 6160//3904 6174//3905 +f 6170//3908 6155//3888 6169//3906 +f 6149//3899 6164//3921 6165//3907 +f 6171//3910 6156//3890 6170//3908 +f 6150//3887 6165//3907 6166//3909 +f 6172//3914 6157//3894 6171//3910 +f 6151//3889 6166//3909 6167//3911 +f 6162//3915 6147//4041 6161//3913 +f 6173//3916 6158//3898 6172//3914 +f 6152//3891 6167//3911 6168//3902 +f 6163//3903 6148//3897 6162//3915 +f 6174//3905 6159//3900 6173//3916 +f 6188//3920 6173//3916 6187//3917 +f 6167//3911 6182//3930 6183//3918 +f 6178//3922 6163//3903 6177//3919 +f 6189//3924 6174//3905 6188//3920 +f 6184//3925 6169//3906 6183//3918 +f 6179//3939 6164//3921 6178//3922 +f 6190//4044 6175//4042 6189//3924 +f 6185//3927 6170//3908 6184//3925 +f 6164//3921 6179//3939 6180//3926 +f 6186//3929 6171//3910 6185//3927 +f 6165//3907 6180//3926 6181//3928 +f 6187//3917 6172//3914 6186//3929 +f 6166//3909 6181//3928 6182//3930 +f 6177//3919 6162//3915 6176//3931 +f 6202//3935 6187//3917 6201//3932 +f 6181//3928 6196//3946 6197//3933 +f 6192//3937 6177//3919 6191//3934 +f 6203//4043 6188//3920 6202//3935 +f 6182//3930 6197//3933 6198//3936 +f 6193//4047 6178//3922 6192//3937 +f 6204//3942 6189//3924 6203//4043 +f 6199//3943 6184//3925 6198//3936 +f 6178//3922 6193//4047 6194//3940 +f 6205//3959 6190//4044 6204//3942 +f 6200//3945 6185//3927 6199//3943 +f 6179//3939 6194//3940 6195//3944 +f 6201//3932 6186//3929 6200//3945 +f 6180//3926 6195//3944 6196//3946 +f 6194//3940 6209//4048 6210//3947 +f 6216//4045 6201//3932 6215//3948 +f 6195//3944 6210//3947 6211//3949 +f 6217//3953 6202//3935 6216//4045 +f 6196//3946 6211//3949 6212//3951 +f 6191//3934 6206//4051 6207//4046 +f 6218//3957 6203//4043 6217//3953 +f 6197//3933 6212//3951 6213//3954 +f 6192//3937 6207//4046 6208//3956 +f 6219//4049 6204//3942 6218//3957 +f 6214//3961 6199//3943 6213//3954 +f 6193//4047 6208//3956 6209//4048 +f 6220//3964 6205//3959 6219//4049 +f 6215//3948 6200//3945 6214//3961 +f 6229//3966 6214//3961 6228//3962 +f 6208//3956 6223//3975 6224//4050 +f 6235//3982 6220//3964 6234//3965 +f 6230//3968 6215//3948 6229//3966 +f 6209//4048 6224//4050 6225//3967 +f 6231//3970 6216//4045 6230//3968 +f 6210//3947 6225//3967 6226//3969 +f 6232//4053 6217//3953 6231//3970 +f 6211//3949 6226//3969 6227//3971 +f 6206//4051 6221//3990 6222//4052 +f 6233//4054 6218//3957 6232//4053 +f 6212//3951 6227//3971 6228//3962 +f 6207//4046 6222//4052 6223//3975 +f 6234//3965 6219//4049 6233//4054 +f 6249//3980 6233//4054 6248//3977 +f 6227//3971 6243//3989 6244//3978 +f 6222//4052 6238//3991 6239//3979 +f 6250//3983 6234//3965 6249//3980 +f 6245//3984 6229//3966 6244//3978 +f 6223//3975 6239//3979 6240//3981 +f 6251//4001 6235//3982 6250//3983 +f 6246//3986 6230//3968 6245//3984 +f 6224//4050 6240//3981 6241//3985 +f 6247//3988 6231//3970 6246//3986 +f 6225//3967 6241//3985 6242//3987 +f 6248//3977 6232//4053 6247//3988 +f 6226//3969 6242//3987 6243//3989 +f 6221//3990 6237//3994 6238//3991 +f 6263//4055 6248//3977 6262//3992 +f 6242//3987 6257//4006 6258//3993 +f 6253//4056 6238//3991 6252//3995 +f 6264//3999 6249//3980 6263//4055 +f 6243//3989 6258//3993 6259//3997 +f 6254//4000 6239//3979 6253//4056 +f 6265//4002 6250//3983 6264//3999 +f 6260//4003 6245//3984 6259//3997 +f 6255//4009 6240//3981 6254//4000 +f 6266//4008 6251//4001 6265//4002 +f 6261//4005 6246//3986 6260//4003 +f 6240//3981 6255//4009 6256//4004 +f 6262//3992 6247//3988 6261//4005 +f 6241//3985 6256//4004 6257//4006 +f 6261//4005 5794//3550 5795//4013 +f 5790//3530 6257//4006 5789//3552 +f 6262//3992 5795//4013 5796//3536 +f 5791//3529 6258//3993 5790//3530 +f 5786//3532 6253//4056 5785//3533 +f 6263//4055 5796//3536 5797//3535 +f 5792//3538 6259//3997 5791//3529 +f 5787//3540 6254//4000 5786//3532 +f 6264//3999 5797//3535 5798//3542 +f 6259//3997 5792//3538 5793//3544 +f 5788//4012 6255//4009 5787//3540 +f 6265//4002 5798//3542 5799//3548 +f 6260//4003 5793//3544 5794//3550 +f 5789//3552 6256//4004 5788//4012 +o Nose_Sphere +v -0.159802 1.092958 -0.013143 +v -0.180371 1.079367 -0.014504 +v -0.198152 1.059956 -0.015819 +v -0.212461 1.035470 -0.017036 +v -0.224784 1.022868 -0.011991 +v -0.235916 0.992648 -0.011991 +v -0.242772 0.959858 -0.011991 +v -0.245086 0.925758 -0.011991 +v -0.242772 0.891657 -0.011991 +v -0.235916 0.858867 -0.011991 +v -0.224784 0.828648 -0.011991 +v -0.209802 0.802160 -0.011991 +v -0.191547 0.780422 -0.011991 +v -0.170720 0.764269 -0.011991 +v -0.148121 0.754323 -0.011991 +v -0.158929 1.093175 -0.020995 +v -0.178659 1.079792 -0.029908 +v -0.195666 1.060573 -0.038182 +v -0.209297 1.036256 -0.045498 +v -0.222859 1.022868 -0.045623 +v -0.233778 0.992648 -0.049360 +v -0.240501 0.959858 -0.051662 +v -0.242772 0.925758 -0.052439 +v -0.240501 0.891657 -0.051662 +v -0.233778 0.858867 -0.049360 +v -0.222859 0.828648 -0.045623 +v -0.208166 0.802160 -0.040592 +v -0.190261 0.780422 -0.034463 +v -0.169834 0.764269 -0.027470 +v -0.147670 0.754323 -0.019882 +v -0.157201 1.093534 -0.028495 +v -0.175268 1.080498 -0.044620 +v -0.190744 1.061598 -0.059539 +v -0.203033 1.037560 -0.072681 +v -0.217159 1.022868 -0.077962 +v -0.227444 0.992648 -0.085294 +v -0.233778 0.959858 -0.089809 +v -0.235916 0.925758 -0.091334 +v -0.233778 0.891657 -0.089809 +v -0.227444 0.858867 -0.085294 +v -0.217159 0.828648 -0.077962 +v -0.203318 0.802160 -0.068095 +v -0.186453 0.780422 -0.056071 +v -0.167211 0.764269 -0.042354 +v -0.146332 0.754323 -0.027470 +v -0.154683 1.094023 -0.035354 +v -0.170331 1.081457 -0.058074 +v -0.183576 1.062990 -0.079072 +v -0.193910 1.039332 -0.097541 +v -0.207903 1.022868 -0.107766 +v -0.217159 0.992648 -0.118410 +v -0.222859 0.959858 -0.124965 +v -0.224784 0.925758 -0.127179 +v -0.222859 0.891657 -0.124965 +v -0.217159 0.858867 -0.118410 +v -0.207903 0.828648 -0.107766 +v -0.195446 0.802160 -0.093441 +v -0.180268 0.780422 -0.075986 +v -0.162951 0.764269 -0.056071 +v -0.144160 0.754323 -0.034463 +v -0.151474 1.094623 -0.041308 +v -0.164035 1.082633 -0.069753 +v -0.174436 1.064697 -0.096028 +v -0.182277 1.041504 -0.119122 +v -0.195446 1.022868 -0.133889 +v -0.203318 0.992648 -0.147437 +v -0.208166 0.959858 -0.155780 +v -0.209802 0.925758 -0.158597 +v -0.208166 0.891657 -0.155780 +v -0.203318 0.858867 -0.147437 +v -0.195446 0.828648 -0.133889 +v -0.184853 0.802160 -0.115657 +v -0.171944 0.780422 -0.093441 +v -0.157217 0.764269 -0.068095 +v -0.141238 0.754323 -0.040592 +v -0.147696 1.095309 -0.046129 +v -0.156623 1.083979 -0.079210 +v -0.163676 1.066652 -0.109756 +v -0.168582 1.043993 -0.136595 +v -0.180268 1.022868 -0.155328 +v -0.186453 0.992648 -0.171259 +v -0.190261 0.959858 -0.181069 +v -0.191547 0.925758 -0.184381 +v -0.190261 0.891657 -0.181069 +v -0.186453 0.858867 -0.171259 +v -0.180268 0.828648 -0.155328 +v -0.171944 0.802160 -0.133889 +v -0.161802 0.780422 -0.107766 +v -0.150231 0.764269 -0.077962 +v -0.137676 0.754323 -0.045623 +v -0.143493 1.096057 -0.049631 +v -0.148381 1.085446 -0.086079 +v -0.151709 1.068781 -0.119729 +v -0.153352 1.046703 -0.149288 +v -0.162951 1.022868 -0.171259 +v -0.167211 0.992648 -0.188960 +v -0.169834 0.959858 -0.199860 +v -0.170720 0.925758 -0.203541 +v -0.169834 0.891657 -0.199860 +v -0.167211 0.858867 -0.188960 +v -0.162951 0.828648 -0.171259 +v -0.157217 0.802160 -0.147437 +v -0.150231 0.780422 -0.118410 +v -0.142261 0.764269 -0.085294 +v -0.133613 0.754323 -0.049360 +v -0.139029 1.096837 -0.051680 +v -0.139624 1.086976 -0.090098 +v -0.138996 1.071002 -0.125564 +v -0.137171 1.049529 -0.156714 +v -0.144160 1.022868 -0.181069 +v -0.146332 0.992648 -0.199860 +v -0.147670 0.959858 -0.211432 +v -0.148121 0.925758 -0.215339 +v -0.147670 0.891657 -0.211432 +v -0.146332 0.858867 -0.199860 +v -0.144160 0.828648 -0.181069 +v -0.141238 0.802160 -0.155780 +v -0.137676 0.780422 -0.124965 +v -0.133613 0.764269 -0.089809 +v -0.129204 0.754323 -0.051662 +v -0.134474 1.097619 -0.052197 +v -0.130689 1.088510 -0.091112 +v -0.126025 1.073229 -0.127035 +v -0.120661 1.052364 -0.158587 +v -0.124619 1.022868 -0.184381 +v -0.124619 0.992648 -0.203541 +v -0.124619 0.959858 -0.215339 +v -0.124619 0.925758 -0.219323 +v -0.124619 0.891657 -0.215339 +v -0.124619 0.858867 -0.203541 +v -0.124619 0.828648 -0.184381 +v -0.124619 0.802160 -0.158597 +v -0.124619 0.780422 -0.127178 +v -0.124619 0.764269 -0.091334 +v -0.124619 0.754323 -0.052439 +v -0.130004 1.098373 -0.051162 +v -0.121920 1.089989 -0.089081 +v -0.113294 1.075377 -0.124088 +v -0.104457 1.055098 -0.154836 +v -0.105078 1.022868 -0.181069 +v -0.102906 0.992648 -0.199860 +v -0.101569 0.959858 -0.211432 +v -0.101117 0.925758 -0.215339 +v -0.101569 0.891657 -0.211432 +v -0.102906 0.858867 -0.199860 +v -0.105078 0.828648 -0.181069 +v -0.108001 0.802160 -0.155780 +v -0.111562 0.780422 -0.124965 +v -0.115625 0.764269 -0.089809 +v -0.120034 0.754323 -0.051662 +v -0.125789 1.099071 -0.048614 +v -0.113653 1.091357 -0.084085 +v -0.101292 1.077363 -0.116834 +v -0.089182 1.057626 -0.145603 +v -0.086288 1.022868 -0.171259 +v -0.082027 0.992648 -0.188960 +v -0.079404 0.959858 -0.199860 +v -0.078518 0.925758 -0.203541 +v -0.079404 0.891657 -0.199860 +v -0.082027 0.858867 -0.188960 +v -0.086288 0.828648 -0.171259 +v -0.092021 0.802160 -0.147437 +v -0.099007 0.780422 -0.118410 +v -0.106977 0.764269 -0.085294 +v -0.115625 0.754323 -0.049360 +v -0.121993 1.099684 -0.044653 +v -0.106206 1.092562 -0.076314 +v -0.090481 1.079112 -0.105553 +v -0.075423 1.059851 -0.131245 +v -0.068970 1.022868 -0.155328 +v -0.062786 0.992648 -0.171259 +v -0.058977 0.959858 -0.181069 +v -0.057691 0.925758 -0.184381 +v -0.058977 0.891657 -0.181069 +v -0.062786 0.858867 -0.171259 +v -0.068970 0.828648 -0.155328 +v -0.077294 0.802160 -0.133889 +v -0.087436 0.780422 -0.107766 +v -0.099007 0.764269 -0.077962 +v -0.111562 0.754323 -0.045623 +v -0.118761 1.100191 -0.039430 +v -0.099866 1.093556 -0.066068 +v -0.081277 1.080555 -0.090678 +v -0.063708 1.061688 -0.112313 +v -0.053792 1.022868 -0.133889 +v -0.045920 0.992648 -0.147437 +v -0.041073 0.959858 -0.155780 +v -0.039436 0.925758 -0.158597 +v -0.041073 0.891657 -0.155780 +v -0.045920 0.858867 -0.147437 +v -0.053792 0.828648 -0.133889 +v -0.064385 0.802160 -0.115657 +v -0.077294 0.780422 -0.093441 +v -0.092021 0.764269 -0.068095 +v -0.108001 0.754323 -0.040592 +v -0.116217 1.100571 -0.033145 +v -0.094876 1.094301 -0.053741 +v -0.074032 1.081637 -0.072781 +v -0.054487 1.063065 -0.089535 +v -0.041335 1.022868 -0.107766 +v -0.032079 0.992648 -0.118410 +v -0.026379 0.959858 -0.124965 +v -0.024454 0.925758 -0.127178 +v -0.026379 0.891657 -0.124965 +v -0.032079 0.858867 -0.118410 +v -0.041335 0.828648 -0.107766 +v -0.053792 0.802160 -0.093441 +v -0.068970 0.780422 -0.075986 +v -0.086288 0.764269 -0.056071 +v -0.105078 0.754323 -0.034463 +v -0.114459 1.100810 -0.026041 +v -0.091427 1.094770 -0.039805 +v -0.069026 1.082317 -0.052550 +v -0.048115 1.063931 -0.063785 +v -0.032079 1.022868 -0.077962 +v -0.021794 0.992648 -0.085294 +v -0.015460 0.959858 -0.089809 +v -0.013322 0.925758 -0.091333 +v -0.015460 0.891657 -0.089809 +v -0.021794 0.858867 -0.085294 +v -0.032079 0.828648 -0.077962 +v -0.045920 0.802160 -0.068095 +v -0.062786 0.780422 -0.056071 +v -0.082027 0.764269 -0.042354 +v -0.102906 0.754323 -0.027470 +v -0.113554 1.100899 -0.018390 +v -0.089653 1.094943 -0.024797 +v -0.066450 1.082569 -0.030761 +v -0.044837 1.064251 -0.036054 +v -0.026379 1.022868 -0.045623 +v -0.015460 0.992648 -0.049360 +v -0.008737 0.959858 -0.051662 +v -0.006467 0.925758 -0.052439 +v -0.008737 0.891657 -0.051662 +v -0.015460 0.858867 -0.049360 +v -0.026379 0.828648 -0.045623 +v -0.041073 0.802160 -0.040592 +v -0.058977 0.780422 -0.034463 +v -0.079404 0.764269 -0.027470 +v -0.101569 0.754323 -0.019882 +v -0.113538 1.100833 -0.010486 +v -0.089622 1.094815 -0.009293 +v -0.066405 1.082383 -0.008253 +v -0.044779 1.064014 -0.007406 +v -0.024454 1.022868 -0.011991 +v -0.013322 0.992648 -0.011991 +v -0.006467 0.959858 -0.011991 +v -0.004152 0.925758 -0.011991 +v -0.006467 0.891657 -0.011991 +v -0.013322 0.858867 -0.011991 +v -0.024454 0.828648 -0.011991 +v -0.039436 0.802160 -0.011991 +v -0.057691 0.780422 -0.011991 +v -0.078518 0.764269 -0.011991 +v -0.101117 0.754323 -0.011991 +v -0.114411 1.100616 -0.002633 +v -0.091334 1.094390 0.006110 +v -0.068890 1.081765 0.014109 +v -0.047943 1.063228 0.021056 +v -0.026379 1.022868 0.021641 +v -0.015460 0.992648 0.025379 +v -0.008737 0.959858 0.027680 +v -0.006467 0.925758 0.028458 +v -0.008737 0.891657 0.027680 +v -0.015460 0.858867 0.025379 +v -0.026379 0.828648 0.021641 +v -0.041073 0.802160 0.016610 +v -0.058977 0.780422 0.010481 +v -0.079404 0.764269 0.003488 +v -0.101569 0.754323 -0.004100 +v -0.116139 1.100257 0.004867 +v -0.094724 1.093684 0.020822 +v -0.073812 1.080741 0.035467 +v -0.054207 1.061924 0.048239 +v -0.032079 1.022868 0.053980 +v -0.021794 0.992648 0.061312 +v -0.015460 0.959858 0.065827 +v -0.013322 0.925758 0.067352 +v -0.015460 0.891657 0.065827 +v -0.021794 0.858867 0.061312 +v -0.032079 0.828648 0.053980 +v -0.045920 0.802160 0.044113 +v -0.062786 0.780422 0.032089 +v -0.082027 0.764269 0.018372 +v -0.102906 0.754323 0.003488 +v -0.118657 1.099768 0.011726 +v -0.099662 1.092725 0.034276 +v -0.080980 1.079349 0.054999 +v -0.063330 1.060152 0.073099 +v -0.041335 1.022868 0.083784 +v -0.032079 0.992648 0.094428 +v -0.026379 0.959858 0.100983 +v -0.024454 0.925758 0.103197 +v -0.026379 0.891657 0.100983 +v -0.032079 0.858867 0.094428 +v -0.041335 0.828648 0.083784 +v -0.053792 0.802160 0.069459 +v -0.068970 0.780422 0.052004 +v -0.086288 0.764269 0.032089 +v -0.105078 0.754323 0.010481 +v -0.121866 1.099168 0.017680 +v -0.105957 1.091549 0.045956 +v -0.090120 1.077642 0.071955 +v -0.074963 1.057980 0.094680 +v -0.053792 1.022868 0.109907 +v -0.045920 0.992648 0.123455 +v -0.041073 0.959858 0.131798 +v -0.039436 0.925758 0.134615 +v -0.041073 0.891657 0.131798 +v -0.045920 0.858867 0.123455 +v -0.053792 0.828648 0.109907 +v -0.064385 0.802160 0.091675 +v -0.077294 0.780422 0.069459 +v -0.092021 0.764269 0.044113 +v -0.108001 0.754323 0.016610 +v -0.125645 1.098482 0.022501 +v -0.113369 1.090202 0.055412 +v -0.100880 1.075686 0.085684 +v -0.088658 1.055492 0.112153 +v -0.068970 1.022868 0.131346 +v -0.062786 0.992648 0.147277 +v -0.058977 0.959858 0.157087 +v -0.057691 0.925758 0.160399 +v -0.058977 0.891657 0.157087 +v -0.062786 0.858867 0.147277 +v -0.068970 0.828648 0.131346 +v -0.077294 0.802160 0.109907 +v -0.087436 0.780422 0.083784 +v -0.099007 0.764269 0.053980 +v -0.111562 0.754323 0.021641 +v -0.124619 0.750964 -0.011991 +v -0.129847 1.097734 0.026003 +v -0.121612 1.088736 0.062281 +v -0.112847 1.073557 0.095657 +v -0.103888 1.052782 0.124846 +v -0.086288 1.022868 0.147277 +v -0.082028 0.992648 0.164978 +v -0.079404 0.959858 0.175878 +v -0.078518 0.925758 0.179559 +v -0.079404 0.891657 0.175878 +v -0.082027 0.858867 0.164978 +v -0.086288 0.828648 0.147277 +v -0.092021 0.802160 0.123455 +v -0.099007 0.780422 0.094428 +v -0.106977 0.764269 0.061312 +v -0.115625 0.754323 0.025379 +v -0.134311 1.096954 0.028051 +v -0.130369 1.087206 0.066300 +v -0.125560 1.071337 0.101491 +v -0.120069 1.049955 0.132272 +v -0.105078 1.022868 0.157087 +v -0.102906 0.992648 0.175878 +v -0.101569 0.959858 0.187450 +v -0.101117 0.925758 0.191357 +v -0.101569 0.891657 0.187450 +v -0.102906 0.858867 0.175878 +v -0.105078 0.828648 0.157087 +v -0.108001 0.802160 0.131798 +v -0.111562 0.780422 0.100983 +v -0.115625 0.764269 0.065827 +v -0.120034 0.754323 0.027680 +v -0.138866 1.096172 0.028568 +v -0.139303 1.085672 0.067314 +v -0.138531 1.069110 0.102963 +v -0.136579 1.047121 0.134145 +v -0.124619 1.022868 0.160399 +v -0.124619 0.992648 0.179559 +v -0.124619 0.959858 0.191357 +v -0.124619 0.925758 0.195341 +v -0.124619 0.891657 0.191357 +v -0.124619 0.858867 0.179559 +v -0.124619 0.828648 0.160399 +v -0.124619 0.802160 0.134615 +v -0.124619 0.780422 0.103197 +v -0.124619 0.764269 0.067352 +v -0.124619 0.754323 0.028458 +v -0.143336 1.095418 0.027533 +v -0.148073 1.084193 0.065284 +v -0.151262 1.066962 0.100015 +v -0.152783 1.044387 0.130393 +v -0.144160 1.022868 0.157087 +v -0.146332 0.992648 0.175878 +v -0.147670 0.959858 0.187450 +v -0.148121 0.925758 0.191357 +v -0.147670 0.891657 0.187450 +v -0.146332 0.858867 0.175878 +v -0.144160 0.828648 0.157087 +v -0.141238 0.802160 0.131798 +v -0.137676 0.780422 0.100983 +v -0.133613 0.764269 0.065827 +v -0.129204 0.754323 0.027680 +v -0.147551 1.094720 0.024986 +v -0.156340 1.082824 0.060287 +v -0.163264 1.064975 0.092762 +v -0.168058 1.041859 0.121161 +v -0.162951 1.022868 0.147277 +v -0.167211 0.992648 0.164978 +v -0.169834 0.959858 0.175878 +v -0.170720 0.925758 0.179559 +v -0.169834 0.891657 0.175878 +v -0.167211 0.858867 0.164978 +v -0.162951 0.828648 0.147277 +v -0.157217 0.802160 0.123455 +v -0.150231 0.780422 0.094428 +v -0.142261 0.764269 0.061312 +v -0.133613 0.754323 0.025379 +v -0.151347 1.094107 0.021025 +v -0.163786 1.081620 0.052517 +v -0.174075 1.063227 0.081481 +v -0.181817 1.039634 0.106803 +v -0.180268 1.022868 0.131346 +v -0.186453 0.992648 0.147277 +v -0.190261 0.959858 0.157087 +v -0.191547 0.925758 0.160399 +v -0.190261 0.891657 0.157087 +v -0.186453 0.858867 0.147277 +v -0.180268 0.828648 0.131346 +v -0.171944 0.802160 0.109907 +v -0.161802 0.780422 0.083784 +v -0.150231 0.764269 0.053980 +v -0.137676 0.754323 0.021641 +v -0.154579 1.093600 0.015801 +v -0.170126 1.080626 0.042271 +v -0.183279 1.061784 0.066606 +v -0.193532 1.037797 0.087871 +v -0.195446 1.022868 0.109907 +v -0.203318 0.992648 0.123455 +v -0.208166 0.959858 0.131798 +v -0.209802 0.925758 0.134615 +v -0.208166 0.891657 0.131798 +v -0.203318 0.858867 0.123455 +v -0.195446 0.828648 0.109907 +v -0.184853 0.802160 0.091675 +v -0.171944 0.780422 0.069459 +v -0.157217 0.764269 0.044113 +v -0.141238 0.754323 0.016610 +v -0.157123 1.093220 0.009517 +v -0.175117 1.079881 0.029943 +v -0.190524 1.060701 0.048709 +v -0.202753 1.036419 0.065092 +v -0.207903 1.022868 0.083784 +v -0.217159 0.992648 0.094428 +v -0.222859 0.959858 0.100983 +v -0.224784 0.925758 0.103196 +v -0.222859 0.891657 0.100983 +v -0.217159 0.858867 0.094428 +v -0.207903 0.828648 0.083784 +v -0.195446 0.802160 0.069459 +v -0.180268 0.780422 0.052004 +v -0.162951 0.764269 0.032089 +v -0.144160 0.754323 0.010481 +v -0.137235 1.100206 -0.011786 +v -0.158881 1.092981 0.002412 +v -0.178565 1.079412 0.016007 +v -0.195530 1.060021 0.028477 +v -0.209125 1.035554 0.039343 +v -0.217159 1.022868 0.053980 +v -0.227444 0.992648 0.061312 +v -0.233778 0.959858 0.065827 +v -0.235916 0.925758 0.067351 +v -0.233778 0.891657 0.065827 +v -0.227444 0.858867 0.061312 +v -0.217159 0.828648 0.053980 +v -0.203318 0.802160 0.044113 +v -0.186453 0.780422 0.032089 +v -0.167211 0.764269 0.018372 +v -0.146332 0.754323 0.003488 +v -0.159786 1.092892 -0.005239 +v -0.180339 1.079239 0.000999 +v -0.198106 1.059770 0.006689 +v -0.212403 1.035233 0.011611 +v -0.222859 1.022868 0.021641 +v -0.233778 0.992648 0.025378 +v -0.240501 0.959858 0.027680 +v -0.242772 0.925758 0.028457 +v -0.240501 0.891657 0.027680 +v -0.233778 0.858867 0.025379 +v -0.222859 0.828648 0.021641 +v -0.208166 0.802160 0.016610 +v -0.190261 0.780422 0.010481 +v -0.169834 0.764269 0.003488 +v -0.147670 0.754323 -0.004100 +vn -0.514939 -0.857204 0.000000 +vn -0.695212 -0.718772 0.000000 +vn -0.686117 -0.723106 -0.079501 +vn -0.990661 -0.136143 0.000000 +vn -0.993225 0.000000 -0.116092 +vn -0.797174 0.602863 -0.031526 +vn -0.805200 0.592029 -0.033174 +vn -0.779168 0.617084 -0.109775 +vn -0.279244 -0.960204 0.000000 +vn -0.507035 -0.859920 -0.058229 +vn -0.961364 -0.275185 0.000000 +vn -0.983734 -0.137883 -0.114963 +vn -0.846065 0.533036 0.001099 +vn -0.907865 -0.419233 0.000000 +vn -0.953948 -0.278481 -0.111423 +vn -0.961364 0.275185 0.000000 +vn -0.953948 0.278481 -0.111423 +vn -0.822626 -0.568529 0.000000 +vn -0.899686 -0.423688 -0.104953 +vn -0.990661 0.136143 0.000000 +vn -0.983734 0.137883 -0.114963 +vn -0.813746 -0.573443 -0.094699 +vn -0.651082 0.758660 -0.021790 +vn -0.792688 0.599231 -0.112003 +vn -0.658254 -0.735832 -0.158757 +vn -0.971587 0.000000 -0.236671 +vn -0.752586 0.629994 -0.191534 +vn -0.274667 -0.961028 -0.030824 +vn -0.483169 -0.867855 -0.115482 +vn -0.961577 -0.143223 -0.234169 +vn -0.836879 0.538957 -0.095462 +vn -0.930296 -0.288522 -0.226386 +vn -0.930296 0.288522 -0.226386 +vn -0.873928 -0.437117 -0.212348 +vn -0.961577 0.143223 -0.234169 +vn -0.786065 -0.588031 -0.190497 +vn -0.640584 0.763726 -0.079470 +vn -0.763115 0.617847 -0.189459 +vn -0.736595 -0.611957 -0.287912 +vn -0.930540 0.000000 -0.366100 +vn -0.615345 0.776543 -0.135228 +vn -0.714682 0.647328 -0.264809 +vn -0.609943 -0.756096 -0.237159 +vn -0.714133 0.643666 -0.275063 +vn -0.260842 -0.963439 -0.061007 +vn -0.442885 -0.880154 -0.170660 +vn -0.919706 -0.152440 -0.361736 +vn -0.814631 0.545915 -0.195654 +vn -0.775445 0.555406 -0.300272 +vn -0.886135 -0.305734 -0.348186 +vn -0.886135 0.305734 -0.348186 +vn -0.826746 -0.459700 -0.324198 +vn -0.919706 0.152440 -0.361736 +vn -0.813318 0.330302 -0.478927 +vn -0.751091 -0.491134 -0.441115 +vn -0.849422 0.165838 -0.500931 +vn -0.660237 -0.644124 -0.386212 +vn -0.861263 0.000000 -0.508133 +vn -0.574755 0.796442 -0.187933 +vn -0.644642 0.686453 -0.336406 +vn -0.538469 -0.782250 -0.313150 +vn -0.657186 0.660909 -0.362316 +vn -0.237770 -0.967132 -0.089785 +vn -0.385571 -0.895505 -0.222205 +vn -0.849422 -0.165838 -0.500931 +vn -0.712607 0.567461 -0.412488 +vn -0.813318 -0.330302 -0.478927 +vn -0.736229 -0.183203 -0.651448 +vn -0.614612 0.582446 -0.531907 +vn -0.698904 -0.361461 -0.617084 +vn -0.698904 0.361461 -0.617084 +vn -0.636860 -0.529527 -0.560289 +vn -0.736198 0.183203 -0.651448 +vn -0.550523 -0.681631 -0.481918 +vn -0.748650 0.000000 -0.662923 +vn -0.518143 0.822077 -0.236000 +vn -0.549821 0.732719 -0.400983 +vn -0.441054 -0.811365 -0.383557 +vn -0.572985 0.682669 -0.453413 +vn -0.205603 -0.971679 -0.116184 +vn -0.310953 -0.911832 -0.267953 +vn -0.316080 -0.838862 -0.443129 +vn -0.572100 0.000000 -0.820154 +vn -0.451399 0.706778 -0.544633 +vn -0.164708 -0.976440 -0.139256 +vn -0.219672 -0.926633 -0.305032 +vn -0.560656 -0.202704 -0.802850 +vn -0.467483 0.598224 -0.650777 +vn -0.526963 -0.395459 -0.752251 +vn -0.526963 0.395459 -0.752251 +vn -0.473006 -0.569720 -0.672018 +vn -0.560656 0.202704 -0.802820 +vn -0.401654 -0.718986 -0.567186 +vn -0.444960 0.851497 -0.277322 +vn -0.428205 0.781823 -0.453139 +vn -0.213813 -0.747581 -0.628773 +vn -0.316630 0.000000 -0.948515 +vn -0.355571 0.882046 -0.309061 +vn -0.281625 0.827570 -0.485580 +vn -0.165960 -0.859004 -0.484298 +vn -0.288858 0.732231 -0.616718 +vn -0.115726 -0.980651 -0.157720 +vn -0.114139 -0.937071 -0.329844 +vn -0.309336 -0.219367 -0.925291 +vn -0.266823 0.602985 -0.751793 +vn -0.288247 -0.423780 -0.858638 +vn -0.288247 0.423780 -0.858638 +vn -0.255470 -0.601917 -0.756554 +vn -0.309336 0.219367 -0.925291 +vn 0.000000 -0.614490 -0.788903 +vn 0.000000 0.226112 -0.974090 +vn 0.000000 -0.758446 -0.651692 +vn -0.252144 0.910459 -0.327799 +vn -0.118686 0.863002 -0.491012 +vn 0.000000 -0.866451 -0.499191 +vn -0.069491 0.744591 -0.663869 +vn -0.059969 -0.983581 -0.170080 +vn 0.000000 -0.940886 -0.338694 +vn 0.000000 -0.226112 -0.974090 +vn 0.000000 -0.435102 -0.900357 +vn 0.000000 0.435102 -0.900357 +vn -0.006378 0.592059 -0.805841 +vn 0.165624 0.732536 -0.660237 +vn 0.255470 -0.601917 -0.756554 +vn 0.260140 0.562822 -0.784539 +vn 0.213813 -0.747581 -0.628773 +vn 0.288247 0.423780 -0.858638 +vn 0.165960 -0.859004 -0.484268 +vn 0.309336 0.219367 -0.925291 +vn -0.139927 0.933470 -0.330149 +vn -0.027406 0.948698 -0.314890 +vn 0.114139 -0.937071 -0.329844 +vn 0.309336 -0.219367 -0.925291 +vn 0.045106 0.883175 -0.466811 +vn 0.000000 -0.984649 -0.174505 +vn 0.059969 -0.983581 -0.170080 +vn 0.288247 -0.423780 -0.858638 +vn 0.316630 0.000000 -0.948515 +vn 0.560656 -0.202704 -0.802820 +vn 0.194006 0.887753 -0.417402 +vn 0.115726 -0.980651 -0.157720 +vn 0.526963 -0.395489 -0.752251 +vn 0.381359 0.704642 -0.598346 +vn 0.473006 -0.569720 -0.672018 +vn 0.490677 0.517380 -0.701071 +vn 0.401654 -0.718986 -0.567186 +vn 0.526963 0.395459 -0.752251 +vn 0.316080 -0.838862 -0.443129 +vn 0.560656 0.202704 -0.802820 +vn 0.076815 0.955657 -0.284249 +vn 0.219672 -0.926633 -0.305032 +vn 0.441054 -0.811365 -0.383557 +vn 0.572100 0.000000 -0.820154 +vn 0.736229 0.183203 -0.651448 +vn 0.167150 0.955687 -0.242195 +vn 0.310953 -0.911832 -0.267953 +vn 0.736229 -0.183203 -0.651448 +vn 0.318369 0.880520 -0.351115 +vn 0.164708 -0.976440 -0.139225 +vn 0.698904 -0.361461 -0.617084 +vn 0.548967 0.670980 -0.498367 +vn 0.636860 -0.529527 -0.560289 +vn 0.662526 0.470107 -0.583117 +vn 0.550523 -0.681631 -0.481918 +vn 0.698904 0.361461 -0.617084 +vn 0.660237 -0.644124 -0.386212 +vn 0.813318 0.330302 -0.478927 +vn 0.538469 -0.782250 -0.313150 +vn 0.748650 0.000000 -0.662923 +vn 0.849422 0.165838 -0.500931 +vn 0.240852 0.951262 -0.192419 +vn 0.385571 -0.895505 -0.222205 +vn 0.849422 -0.165838 -0.500931 +vn 0.415357 0.866909 -0.275552 +vn 0.205603 -0.971679 -0.116184 +vn 0.813318 -0.330302 -0.478927 +vn 0.665120 0.640492 -0.383831 +vn 0.751091 -0.491134 -0.441115 +vn 0.778466 0.431745 -0.455550 +vn 0.739006 0.617817 -0.268532 +vn 0.826746 -0.459700 -0.324198 +vn 0.851558 0.406201 -0.331370 +vn 0.736595 -0.611957 -0.287912 +vn 0.886135 0.305734 -0.348186 +vn 0.609943 -0.756096 -0.237159 +vn 0.861263 0.000000 -0.508133 +vn 0.919706 0.152440 -0.361736 +vn 0.297037 0.944823 -0.137852 +vn 0.442885 -0.880154 -0.170660 +vn 0.919706 -0.152440 -0.361736 +vn 0.485946 0.851711 -0.195868 +vn 0.237770 -0.967132 -0.089785 +vn 0.886135 -0.305734 -0.348186 +vn 0.930540 0.000000 -0.366100 +vn 0.961577 -0.143223 -0.234169 +vn 0.532701 0.838435 -0.115024 +vn 0.260842 -0.963439 -0.061007 +vn 0.930296 -0.288522 -0.226386 +vn 0.780816 0.604541 -0.157598 +vn 0.873928 -0.437117 -0.212348 +vn 0.894131 0.393170 -0.214240 +vn 0.786065 -0.588031 -0.190497 +vn 0.930296 0.288522 -0.226386 +vn 0.658254 -0.735832 -0.158757 +vn 0.961577 0.143223 -0.234169 +vn 0.335795 0.938475 -0.080599 +vn 0.483169 -0.867855 -0.115482 +vn 0.686117 -0.723106 -0.079501 +vn 0.971587 0.000000 -0.236671 +vn 0.983734 0.137883 -0.114963 +vn 0.357494 0.933622 -0.022156 +vn 0.507035 -0.859920 -0.058229 +vn 0.983734 -0.137883 -0.114963 +vn 0.557939 0.829157 -0.034425 +vn 0.274667 -0.961028 -0.030824 +vn 0.953948 -0.278481 -0.111423 +vn 0.797754 0.600757 -0.051546 +vn 0.899686 -0.423688 -0.104953 +vn 0.914457 0.391186 -0.103427 +vn 0.813746 -0.573443 -0.094699 +vn 0.953948 0.278481 -0.111423 +vn 0.822626 -0.568529 0.000000 +vn 0.961364 0.275185 0.000000 +vn 0.695212 -0.718772 0.000000 +vn 0.993225 0.000000 -0.116092 +vn 0.990661 0.136143 0.000000 +vn 0.362560 0.931211 0.036378 +vn 0.514939 -0.857204 0.000000 +vn 0.990661 -0.136143 0.000000 +vn 0.563280 0.824976 0.045381 +vn 0.279244 -0.960204 0.000000 +vn 0.961364 -0.275185 0.000000 +vn 0.793847 0.605945 0.050661 +vn 0.907865 -0.419233 0.000000 +vn 0.916959 0.398907 0.003296 +vn 0.953948 -0.278481 0.111423 +vn 0.953948 0.278481 0.111423 +vn 0.899686 -0.423688 0.104953 +vn 0.983734 0.137883 0.114963 +vn 0.813746 -0.573443 0.094699 +vn 0.993225 0.000000 0.116092 +vn 0.549303 0.826289 0.124302 +vn 0.686117 -0.723106 0.079501 +vn 0.770409 0.619465 0.150639 +vn 0.507035 -0.859920 0.058229 +vn 0.983734 -0.137883 0.114963 +vn 0.723502 0.646840 0.240974 +vn 0.274667 -0.961028 0.030824 +vn 0.483169 -0.867855 0.115482 +vn 0.961577 -0.143223 0.234169 +vn 0.903134 0.415326 0.108646 +vn 0.930296 -0.288522 0.226386 +vn 0.930296 0.288522 0.226386 +vn 0.873928 -0.437117 0.212348 +vn 0.961577 0.143223 0.234169 +vn 0.786065 -0.588031 0.190497 +vn 0.971587 0.000000 0.236671 +vn 0.351177 0.931547 0.094089 +vn 0.515458 0.832759 0.201941 +vn 0.658254 -0.735832 0.158757 +vn 0.930540 0.000000 0.366100 +vn 0.323252 0.934324 0.149998 +vn 0.460219 0.843257 0.277657 +vn 0.609943 -0.756096 0.237159 +vn 0.647175 0.680319 0.343974 +vn 0.260842 -0.963439 0.061007 +vn 0.442885 -0.880154 0.170660 +vn 0.919706 -0.152440 0.361736 +vn 0.876583 0.433119 0.209693 +vn 0.826838 0.458083 0.326304 +vn 0.886135 -0.305734 0.348186 +vn 0.886135 0.305734 0.348186 +vn 0.826746 -0.459700 0.324198 +vn 0.919706 0.152440 0.361736 +vn 0.736564 -0.611957 0.287912 +vn 0.751091 -0.491134 0.441115 +vn 0.849422 0.165838 0.500931 +vn 0.660237 -0.644124 0.386212 +vn 0.861263 0.000000 0.508133 +vn 0.278512 0.938719 0.202887 +vn 0.381359 0.855708 0.349712 +vn 0.538469 -0.782250 0.313150 +vn 0.549120 0.711600 0.438215 +vn 0.237770 -0.967132 0.089785 +vn 0.385571 -0.895505 0.222205 +vn 0.849422 -0.165838 0.500931 +vn 0.748222 0.495621 0.440962 +vn 0.813318 -0.330302 0.478927 +vn 0.813318 0.330302 0.478927 +vn 0.698904 -0.361461 0.617084 +vn 0.698904 0.361461 0.617084 +vn 0.636860 -0.529527 0.560289 +vn 0.736229 0.183203 0.651448 +vn 0.550523 -0.681631 0.481918 +vn 0.748650 0.000000 0.662923 +vn 0.216742 0.943327 0.251228 +vn 0.276742 0.866787 0.414777 +vn 0.441054 -0.811365 0.383557 +vn 0.417280 0.741905 0.524796 +vn 0.205603 -0.971679 0.116184 +vn 0.310953 -0.911832 0.267953 +vn 0.736229 -0.183203 0.651448 +vn 0.632618 0.537614 0.557390 +vn 0.245094 0.754112 0.609241 +vn 0.164708 -0.976440 0.139225 +vn 0.219672 -0.926633 0.305032 +vn 0.560656 -0.202704 0.802820 +vn 0.458968 0.587359 0.666555 +vn 0.526963 -0.395459 0.752251 +vn 0.526963 0.395459 0.752251 +vn 0.473006 -0.569720 0.672018 +vn 0.560656 0.202704 0.802850 +vn 0.401654 -0.718986 0.567186 +vn 0.572100 0.000000 0.820154 +vn 0.138066 0.946104 0.292856 +vn 0.145878 0.871914 0.467391 +vn 0.316080 -0.838862 0.443129 +vn 0.316630 0.000000 0.948515 +vn 0.043703 0.944731 0.324839 +vn -0.007447 0.865871 0.500168 +vn 0.165960 -0.859004 0.484298 +vn 0.058351 0.751823 0.656728 +vn 0.115726 -0.980651 0.157720 +vn 0.114139 -0.937071 0.329844 +vn 0.309336 -0.219367 0.925291 +vn 0.288247 -0.423780 0.858638 +vn 0.288247 0.423780 0.858638 +vn 0.255470 -0.601917 0.756554 +vn 0.309336 0.219367 0.925291 +vn 0.213813 -0.747581 0.628773 +vn 0.000000 -0.614490 0.788903 +vn 0.000000 0.226112 0.974090 +vn 0.000000 -0.758446 0.651692 +vn -0.063234 0.936918 0.343730 +vn -0.172887 0.845149 0.505753 +vn 0.000000 -0.866451 0.499191 +vn -0.161382 0.734306 0.659291 +vn 0.059969 -0.983581 0.170080 +vn 0.000000 -0.940886 0.338694 +vn 0.000000 -0.226112 0.974090 +vn 0.249763 0.628559 0.736534 +vn 0.000000 -0.435102 0.900357 +vn 0.000000 0.435102 0.900357 +vn -0.255470 -0.601917 0.756554 +vn 0.002136 0.641591 0.767022 +vn -0.245430 0.631153 0.735771 +vn -0.213813 -0.747581 0.628773 +vn -0.288247 0.423780 0.858638 +vn -0.165960 -0.859004 0.484268 +vn -0.309336 0.219367 0.925291 +vn -0.176702 0.921354 0.346141 +vn -0.287942 0.898648 0.330821 +vn -0.114139 -0.937071 0.329844 +vn -0.309336 -0.219367 0.925291 +vn -0.334208 0.810236 0.481399 +vn 0.000000 -0.984649 0.174505 +vn -0.059969 -0.983581 0.170080 +vn -0.288247 -0.423780 0.858638 +vn -0.368816 0.696921 0.615009 +vn -0.115726 -0.980651 0.157720 +vn -0.526963 -0.395459 0.752251 +vn -0.539537 0.650319 0.534715 +vn -0.473006 -0.569720 0.672018 +vn -0.456343 0.603473 0.653859 +vn -0.401654 -0.718986 0.567186 +vn -0.526963 0.395459 0.752251 +vn -0.316080 -0.838862 0.443129 +vn -0.316630 0.000000 0.948515 +vn -0.560656 0.202704 0.802820 +vn -0.388684 0.871120 0.299997 +vn -0.219672 -0.926633 0.305032 +vn -0.560656 -0.202704 0.802820 +vn -0.476333 0.765984 0.431654 +vn -0.474075 0.841914 0.257698 +vn -0.310953 -0.911832 0.267953 +vn -0.572100 0.000000 0.820154 +vn -0.736229 -0.183203 0.651448 +vn -0.591449 0.719016 0.364910 +vn -0.164708 -0.976440 0.139225 +vn -0.698904 -0.361461 0.617084 +vn -0.664083 0.607868 0.435255 +vn -0.636860 -0.529527 0.560289 +vn -0.614277 0.571032 0.544542 +vn -0.550523 -0.681631 0.481918 +vn -0.698904 0.361461 0.617084 +vn -0.441054 -0.811365 0.383557 +vn -0.736229 0.183203 0.651448 +vn -0.813318 0.330302 0.478927 +vn -0.538469 -0.782250 0.313150 +vn -0.748650 0.000000 0.662923 +vn -0.849422 0.165838 0.500931 +vn -0.542253 0.814112 0.207648 +vn -0.385571 -0.895505 0.222205 +vn -0.849422 -0.165838 0.500931 +vn -0.678640 0.675253 0.288827 +vn -0.205603 -0.971679 0.116184 +vn -0.813318 -0.330302 0.478927 +vn -0.744896 0.579577 0.330424 +vn -0.751091 -0.491134 0.441115 +vn -0.721854 0.544542 0.427045 +vn -0.660237 -0.644124 0.386212 +vn -0.826746 -0.459700 0.324198 +vn -0.789148 0.529160 0.311686 +vn -0.736595 -0.611957 0.287912 +vn -0.886135 0.305734 0.348186 +vn -0.609943 -0.756096 0.237159 +vn -0.861263 0.000000 0.508133 +vn -0.919706 0.152440 0.361736 +vn -0.593280 0.790338 0.152837 +vn -0.442885 -0.880154 0.170660 +vn -0.919706 -0.152440 0.361736 +vn -0.740440 0.638844 0.208716 +vn -0.237770 -0.967132 0.089785 +vn -0.886135 -0.305734 0.348186 +vn -0.789636 0.569292 0.228828 +vn -0.260842 -0.963439 0.061007 +vn -0.930296 -0.288522 0.226386 +vn -0.807459 0.574297 0.134648 +vn -0.873928 -0.437117 0.212348 +vn -0.826899 0.524644 0.202399 +vn -0.786065 -0.588031 0.190497 +vn -0.930296 0.288522 0.226386 +vn -0.658254 -0.735832 0.158757 +vn -0.930540 0.000000 0.366100 +vn -0.961577 0.143223 0.234169 +vn -0.627888 0.772423 0.095370 +vn -0.483169 -0.867855 0.115482 +vn -0.961577 -0.143223 0.234169 +vn -0.780328 0.612171 0.127537 +vn -0.646931 0.761650 0.036775 +vn -0.507035 -0.859920 0.058199 +vn -0.971587 0.000000 0.236671 +vn -0.983734 -0.137883 0.114963 +vn -0.801294 0.596393 0.046724 +vn -0.274667 -0.961028 0.030824 +vn -0.953948 -0.278481 0.111423 +vn -0.807581 0.587695 0.048647 +vn -0.899686 -0.423688 0.104953 +vn -0.843806 0.527329 0.099399 +vn -0.813746 -0.573443 0.094699 +vn -0.953948 0.278481 0.111423 +vn -0.686117 -0.723106 0.079501 +vn -0.983734 0.137883 0.114963 +vn -0.993225 0.000000 0.116092 +vn -0.436445 0.899686 -0.007599 +vn -0.430372 0.901822 -0.038118 +vn -0.415540 0.907041 -0.067476 +vn -0.391919 0.915067 -0.094852 +vn -0.359569 0.925413 -0.119358 +vn -0.318857 0.937376 -0.140019 +vn -0.270363 0.950072 -0.155644 +vn -0.215308 0.962523 -0.164800 +vn -0.156194 0.973693 -0.165838 +vn -0.097232 0.982604 -0.158025 +vn -0.042512 0.988861 -0.142582 +vn 0.005341 0.992584 -0.121403 +vn 0.045167 0.994324 -0.096133 +vn 0.076144 0.994751 -0.067965 +vn 0.097903 0.994446 -0.037965 +vn 0.110294 0.993866 -0.007080 +vn 0.113285 0.993255 0.023957 +vn 0.106937 0.992767 0.054476 +vn 0.091281 0.992279 0.083865 +vn 0.066408 0.991546 0.111301 +vn 0.032533 0.990173 0.135899 +vn -0.009735 0.987579 0.156621 +vn -0.059664 0.983215 0.172338 +vn -0.115696 0.976531 0.181555 +vn -0.175146 0.967437 0.182592 +vn -0.233772 0.956450 0.174749 +vn -0.287484 0.944426 0.159246 +vn -0.333995 0.932401 0.138005 +vn -0.372204 0.921262 0.112644 +vn -0.401654 0.911863 0.084414 +vn -0.422163 0.904843 0.054384 +vn -0.433729 0.900723 0.023408 +vn -0.168279 0.985687 0.008484 +usemtl SkinColor +s 1 +f 6280//4057 6279//4058 6294//4059 +f 6275//4060 6274//2918 6289//4061 +f 6270//4062 6269//4063 6285//4064 +f 6281//4065 6280//4057 6295//4066 +f 6276//4067 6275//4060 6290//4068 +f 6271//4069 6270//4062 6285//4064 +f 6277//4070 6276//4067 6291//4071 +f 6272//4072 6271//4069 6287//4073 +f 6278//4074 6277//4070 6292//4075 +f 6273//4076 6272//4072 6288//4077 +f 6279//4058 6278//4074 6293//4078 +f 6274//2918 6273//4076 6289//4061 +f 6269//4063 6268//4079 6284//4080 +f 6295//4066 6294//4059 6309//4081 +f 6290//4068 6289//4061 6304//4082 +f 6285//4064 6284//4080 6300//4083 +f 6296//4084 6295//4066 6310//4085 +f 6291//4071 6290//4068 6305//4086 +f 6286//4087 6285//4064 6300//4083 +f 6292//4075 6291//4071 6306//4088 +f 6287//4073 6286//4087 6302//4089 +f 6293//4078 6292//4075 6307//4090 +f 6288//4077 6287//4073 6303//4091 +f 6294//4059 6293//4078 6308//4092 +f 6289//4061 6288//4077 6304//4082 +f 6284//4080 6283//4093 6299//4094 +f 6309//4081 6308//4092 6323//4095 +f 6304//4082 6303//4091 6319//4096 +f 6299//4094 6298//4097 6314//4098 +f 6310//4085 6309//4081 6324//4099 +f 6305//4086 6304//4082 6319//4096 +f 6300//4083 6299//4094 6315//4100 +f 6311//4101 6310//4085 6325//4102 +f 6306//4088 6305//4086 6320//4103 +f 6301//4104 6300//4083 6316//4105 +f 6307//4090 6306//4088 6321//4106 +f 6302//4089 6301//4104 6317//4107 +f 6308//4092 6307//4090 6322//4108 +f 6303//4091 6302//4089 6318//4109 +f 6317//4107 6316//4105 6332//4110 +f 6323//4095 6322//4108 6337//4111 +f 6318//4109 6317//4107 6333//4112 +f 6324//4099 6323//4095 6338//4113 +f 6319//4096 6318//4109 6334//4114 +f 6314//4098 6313//4115 6329//4116 +f 6325//4102 6324//4099 6339//4117 +f 6320//4103 6319//4096 6334//4114 +f 6315//4100 6314//4098 6330//4118 +f 6326//4119 6325//4102 6340//4120 +f 6321//4106 6320//4103 6335//4121 +f 6316//4105 6315//4100 6331//4122 +f 6322//4108 6321//4106 6336//4123 +f 6336//4123 6335//4121 6350//4124 +f 6331//4122 6330//4118 6346//4125 +f 6337//4111 6336//4123 6351//4126 +f 6332//4110 6331//4122 6347//4127 +f 6338//4113 6337//4111 6352//4128 +f 6333//4112 6332//4110 6348//4129 +f 6339//4117 6338//4113 6353//4130 +f 6334//4114 6333//4112 6349//4131 +f 6329//4116 6328//4132 6344//4133 +f 6340//4120 6339//4117 6354//4134 +f 6335//4121 6334//4114 6349//4131 +f 6330//4118 6329//4116 6345//4135 +f 6341//4136 6340//4120 6355//4137 +f 6355//4137 6354//4134 6369//4138 +f 6350//4124 6349//4131 6364//4139 +f 6345//4135 6344//4133 6360//4140 +f 6356//4141 6355//4137 6370//4142 +f 6351//4126 6350//4124 6365//4143 +f 6346//4125 6345//4135 6361//4144 +f 6352//4128 6351//4126 6366//4145 +f 6347//4127 6346//4125 6362//4146 +f 6353//4130 6352//4128 6367//4147 +f 6348//4129 6347//4127 6363//4148 +f 6354//4134 6353//4130 6368//4149 +f 6349//4131 6348//4129 6364//4139 +f 6344//4133 6343//4150 6359//4151 +f 6369//4138 6368//4149 6383//4152 +f 6364//4139 6363//4148 6379//4153 +f 6359//4151 6358//4154 6374//4155 +f 6370//4142 6369//4138 6384//4156 +f 6365//4143 6364//4139 6379//4153 +f 6360//4140 6359//4151 6375//4157 +f 6371//4158 6370//4142 6385//4159 +f 6366//4145 6365//4143 6380//4160 +f 6361//4144 6360//4140 6376//4161 +f 6367//4147 6366//4145 6381//4162 +f 6362//4146 6361//4144 6377//4163 +f 6368//4149 6367//4147 6382//4164 +f 6363//4148 6362//4146 6378//4165 +f 6383//4152 6382//4164 6397//4166 +f 6378//4165 6377//4163 6393//4167 +f 6384//4156 6383//4152 6398//4168 +f 6379//4153 6378//4165 6394//3044 +f 6374//4155 6373//4169 6389//4170 +f 6385//4159 6384//4156 6399//4171 +f 6380//4160 6379//4153 6394//3044 +f 6375//4157 6374//4155 6390//4172 +f 6386//4173 6385//4159 6400//4174 +f 6381//4162 6380//4160 6395//4175 +f 6376//4161 6375//4157 6390//4172 +f 6382//4164 6381//4162 6396//4176 +f 6377//4163 6376//4161 6392//4177 +f 6391//4178 6390//4172 6405//4179 +f 6397//4166 6396//4176 6412//4180 +f 6392//4177 6391//4178 6406//4181 +f 6398//4168 6397//4166 6413//4182 +f 6393//4167 6392//4177 6407//4183 +f 6399//4171 6398//4168 6414//4184 +f 6394//3044 6393//4167 6408//4185 +f 6389//4170 6388//4186 6403//4187 +f 6400//4174 6399//4171 6415//4188 +f 6395//4175 6394//3044 6410//4189 +f 6390//4172 6389//4170 6404//4190 +f 6401//4191 6400//4174 6416//4192 +f 6396//4176 6395//4175 6411//4193 +f 6410//4189 6409//4194 6425//4195 +f 6405//4179 6404//4190 6419//4196 +f 6416//4192 6415//4188 6431//4197 +f 6411//4193 6410//4189 6426//4198 +f 6406//4181 6405//4179 6420//4199 +f 6412//4180 6411//4193 6427//4200 +f 6407//4183 6406//4181 6421//4201 +f 6413//4182 6412//4180 6428//4202 +f 6408//4185 6407//4183 6422//4203 +f 6414//4184 6413//4182 6429//4204 +f 6409//4194 6408//4185 6423//4205 +f 6404//4190 6403//4187 6418//4206 +f 6415//4188 6414//4184 6430//4207 +f 6429//4204 6428//4202 6444//4208 +f 6424//4209 6423//4205 6438//4210 +f 6419//4196 6418//4206 6433//4211 +f 6430//4207 6429//4204 6445//4212 +f 6425//4195 6424//4209 6440//4213 +f 6420//4199 6419//4196 6434//4214 +f 6431//4197 6430//4207 6446//4215 +f 6426//4198 6425//4195 6441//4216 +f 6421//4201 6420//4199 6435//4217 +f 6427//4200 6426//4198 6442//4218 +f 6422//4203 6421//4201 6436//4219 +f 6428//4202 6427//4200 6443//4220 +f 6423//4205 6422//4203 6437//4221 +f 6443//4220 6442//4218 6458//4222 +f 6438//4210 6437//4221 6452//4223 +f 6444//4208 6443//4220 6459//4224 +f 6439//4225 6438//4210 6453//4226 +f 6434//4214 6433//4211 6448//4227 +f 6445//4212 6444//4208 6460//4228 +f 6440//4213 6439//4225 6455//4229 +f 6435//4217 6434//4214 6449//4230 +f 6446//4215 6445//4212 6461//4231 +f 6441//4216 6440//4213 6456//4232 +f 6436//4219 6435//4217 6450//4233 +f 6442//4218 6441//4216 6457//4234 +f 6437//4221 6436//4219 6451//4235 +f 6451//4235 6450//4233 6465//4236 +f 6457//4234 6456//4232 6472//4237 +f 6452//4223 6451//4235 6466//4238 +f 6458//4222 6457//4234 6473//4239 +f 6453//4226 6452//4223 6467//4240 +f 6459//4224 6458//4222 6474//4241 +f 6454//4242 6453//4226 6468//4243 +f 6449//4230 6448//4227 6463//4244 +f 6460//4228 6459//4224 6475//4245 +f 6455//4229 6454//4242 6470//4246 +f 6450//4233 6449//4230 6464//4247 +f 6461//4231 6460//4228 6476//4248 +f 6456//4232 6455//4229 6471//4249 +f 6470//4246 6469//4250 6485//4251 +f 6465//4236 6464//4247 6479//4252 +f 6476//4248 6475//4245 6491//4253 +f 6471//4249 6470//4246 6486//4254 +f 6466//4238 6465//4236 6480//4255 +f 6472//4237 6471//4249 6487//4256 +f 6467//4240 6466//4238 6481//4257 +f 6473//4239 6472//4237 6488//4258 +f 6468//4243 6467//4240 6482//4259 +f 6474//4241 6473//4239 6489//4260 +f 6469//4250 6468//4243 6483//4261 +f 6464//4247 6463//4244 6478//4262 +f 6475//4245 6474//4241 6490//4263 +f 6489//4260 6488//4258 6504//4264 +f 6484//4265 6483//4261 6498//4266 +f 6479//4252 6478//4262 6493//4267 +f 6490//4263 6489//4260 6505//4268 +f 6485//4251 6484//4265 6500//4269 +f 6480//4255 6479//4252 6494//4270 +f 6491//4253 6490//4263 6506//4271 +f 6486//4254 6485//4251 6501//4272 +f 6481//4257 6480//4255 6495//4273 +f 6487//4256 6486//4254 6502//4274 +f 6482//4259 6481//4257 6496//4275 +f 6488//4258 6487//4256 6503//4276 +f 6483//4261 6482//4259 6497//4277 +f 6503//4276 6502//4274 6518//4278 +f 6498//4266 6497//4277 6512//4279 +f 6504//4264 6503//4276 6519//4280 +f 6499//4281 6498//4266 6513//4282 +f 6494//4270 6493//4267 6508//4283 +f 6505//4268 6504//4264 6520//4284 +f 6500//4269 6499//4281 6515//4285 +f 6495//4273 6494//4270 6509//4286 +f 6506//4271 6505//4268 6521//4287 +f 6501//4272 6500//4269 6516//4288 +f 6496//4275 6495//4273 6510//4289 +f 6502//4274 6501//4272 6517//4290 +f 6497//4277 6496//4275 6511//4291 +f 6517//4290 6516//4288 6531//4292 +f 6512//4279 6511//4291 6527//4293 +f 6518//4278 6517//4290 6532//4294 +f 6513//4282 6512//4279 6528//4295 +f 6519//4280 6518//4278 6533//4296 +f 6514//261 6513//4282 6529//4297 +f 6509//4286 6508//4283 6524//4298 +f 6520//4284 6519//4280 6534//4299 +f 6515//4285 6514//261 6529//4297 +f 6510//4289 6509//4286 6525//4300 +f 6521//4287 6520//4284 6535//4301 +f 6516//4288 6515//4285 6530//4302 +f 6511//4291 6510//4289 6525//4300 +f 6525//4300 6524//4298 6540//4303 +f 6536//4304 6535//4301 6550//4305 +f 6531//4292 6530//4302 6545//4306 +f 6526//4307 6525//4300 6540//4303 +f 6532//4294 6531//4292 6546//4308 +f 6527//4293 6526//4307 6542//4309 +f 6533//4296 6532//4294 6547//4310 +f 6528//4295 6527//4293 6543//4311 +f 6534//4299 6533//4296 6548//4312 +f 6529//4297 6528//4295 6544//4313 +f 6524//4298 6523//4314 6539//4315 +f 6535//4301 6534//4299 6549//4316 +f 6530//4302 6529//4297 6544//4313 +f 6544//4313 6543//4311 6559//4317 +f 6539//4315 6538//4318 6554//4319 +f 6550//4305 6549//4316 6564//4320 +f 6545//4306 6544//4313 6559//4317 +f 6540//4303 6539//4315 6555//4321 +f 6551//4322 6550//4305 6565//4323 +f 6546//4308 6545//4306 6560//4324 +f 6541//4325 6540//4303 6556//4326 +f 6547//4310 6546//4308 6561//4327 +f 6542//4309 6541//4325 6557//4328 +f 6548//4312 6547//4310 6562//4329 +f 6543//4311 6542//4309 6558//4330 +f 6549//4316 6548//4312 6563//4331 +f 6563//4331 6562//4329 6577//4332 +f 6558//4330 6557//4328 6573//4333 +f 6564//4320 6563//4331 6578//4334 +f 6559//4317 6558//4330 6574//4335 +f 6554//4319 6553//4336 6569//4337 +f 6565//4323 6564//4320 6579//4338 +f 6560//4324 6559//4317 6574//4335 +f 6555//4321 6554//4319 6570//4339 +f 6566//4340 6565//4323 6580//4341 +f 6561//4327 6560//4324 6575//4342 +f 6556//4326 6555//4321 6571//4343 +f 6562//4329 6561//4327 6576//4344 +f 6557//4328 6556//4326 6572//4345 +f 6577//4332 6576//4344 6591//4346 +f 6572//4345 6571//4343 6587//4347 +f 6578//4334 6577//4332 6592//4348 +f 6573//4333 6572//4345 6588//4349 +f 6579//4338 6578//4334 6593//4350 +f 6574//4335 6573//4333 6589//4351 +f 6569//4337 6568//4352 6584//4353 +f 6580//4341 6579//4338 6594//4354 +f 6575//4342 6574//4335 6589//4351 +f 6570//4339 6569//4337 6585//4355 +f 6581//4356 6580//4341 6595//4357 +f 6576//4344 6575//4342 6590//4358 +f 6571//4343 6570//4339 6586//4359 +f 6585//4355 6584//4353 6601//4360 +f 6596//4361 6595//4357 6611//4362 +f 6591//4346 6590//4358 6606//4363 +f 6586//4359 6585//4355 6602//4364 +f 6592//4348 6591//4346 6607//4365 +f 6587//4347 6586//4359 6603//4366 +f 6593//4350 6592//4348 6608//4367 +f 6588//4349 6587//4347 6604//4368 +f 6594//4354 6593//4350 6609//4369 +f 6589//4351 6588//4349 6605//4370 +f 6584//4353 6583//4371 6600//4372 +f 6595//4357 6594//4354 6610//4373 +f 6590//4358 6589//4351 6605//4370 +f 6605//4370 6604//4368 6620//4374 +f 6600//4372 6599//4375 6615//4376 +f 6611//4362 6610//4373 6625//4377 +f 6606//4363 6605//4370 6620//4374 +f 6601//4360 6600//4372 6616//4378 +f 6612//4379 6611//4362 6626//4380 +f 6607//4365 6606//4363 6621//4381 +f 6602//4364 6601//4360 6616//4378 +f 6608//4367 6607//4365 6622//4382 +f 6603//4366 6602//4364 6618//4383 +f 6609//4369 6608//4367 6623//4384 +f 6604//4368 6603//4366 6619//4385 +f 6610//4373 6609//4369 6624//4386 +f 6624//4386 6623//4384 6638//4387 +f 6619//4385 6618//4383 6634//4388 +f 6625//4377 6624//4386 6639//4389 +f 6620//4374 6619//4385 6635//3282 +f 6615//4376 6614//4390 6630//4391 +f 6626//4380 6625//4377 6640//4392 +f 6621//4381 6620//4374 6635//3282 +f 6616//4378 6615//4376 6631//4393 +f 6627//4394 6626//4380 6641//4395 +f 6622//4382 6621//4381 6636//4396 +f 6617//4397 6616//4378 6631//4393 +f 6623//4384 6622//4382 6637//4398 +f 6618//4383 6617//4397 6633//4399 +f 6638//4387 6637//4398 6653//4400 +f 6633//4399 6632//4401 6647//4402 +f 6639//4389 6638//4387 6654//4403 +f 6634//4388 6633//4399 6648//4404 +f 6640//4392 6639//4389 6655//4405 +f 6635//3282 6634//4388 6649//4406 +f 6630//4391 6629//4407 6644//4408 +f 6641//4395 6640//4392 6656//4409 +f 6636//4396 6635//3282 6651//4410 +f 6631//4393 6630//4391 6645//4411 +f 6642//4412 6641//4395 6657//4413 +f 6637//4398 6636//4396 6652//4414 +f 6632//4401 6631//4393 6646//4415 +f 6657//4413 6656//4409 6672//4416 +f 6652//4414 6651//4410 6667//4417 +f 6647//4402 6646//4415 6661//4418 +f 6653//4400 6652//4414 6668//4419 +f 6648//4404 6647//4402 6662//4420 +f 6654//4403 6653//4400 6669//4421 +f 6649//4406 6648//4404 6663//4422 +f 6655//4405 6654//4403 6670//4423 +f 6650//4424 6649//4406 6664//4425 +f 6645//4411 6644//4408 6659//4426 +f 6656//4409 6655//4405 6671//4427 +f 6651//4410 6650//4424 6666//4428 +f 6646//4415 6645//4411 6660//4429 +f 6660//4429 6659//4426 6674//4430 +f 6671//4427 6670//4423 6686//4431 +f 6666//4428 6665//4432 6681//4433 +f 6661//4418 6660//4429 6675//4434 +f 6672//4416 6671//4427 6687//4435 +f 6667//4417 6666//4428 6682//4436 +f 6662//4420 6661//4418 6676//4437 +f 6668//4419 6667//4417 6683//4438 +f 6663//4422 6662//4420 6677//4439 +f 6669//4421 6668//4419 6684//4440 +f 6664//4425 6663//4422 6678//4441 +f 6670//4423 6669//4421 6685//4442 +f 6665//4432 6664//4425 6679//4443 +f 6679//4443 6678//4441 6693//4444 +f 6685//4442 6684//4440 6700//4445 +f 6680//4446 6679//4443 6694//4447 +f 6675//4434 6674//4430 6689//4448 +f 6686//4431 6685//4442 6701//4449 +f 6681//4433 6680//4446 6696//4450 +f 6676//4437 6675//4434 6690//4451 +f 6687//4435 6686//4431 6702//4452 +f 6682//4436 6681//4433 6697//4453 +f 6677//4439 6676//4437 6691//4454 +f 6683//4438 6682//4436 6698//4455 +f 6678//4441 6677//4439 6692//4456 +f 6684//4440 6683//4438 6699//4457 +f 6698//4455 6697//4453 6713//4458 +f 6693//4444 6692//4456 6707//4459 +f 6699//4457 6698//4455 6714//4460 +f 6694//4447 6693//4444 6708//4461 +f 6700//4445 6699//4457 6715//4462 +f 6695//4463 6694//4447 6709//4464 +f 6690//4451 6689//4448 6704//4465 +f 6701//4449 6700//4445 6716//4466 +f 6696//4450 6695//4463 6711//4467 +f 6691//4454 6690//4451 6705//4468 +f 6702//4452 6701//4449 6717//4469 +f 6697//4453 6696//4450 6712//4470 +f 6692//4456 6691//4454 6706//4471 +f 6717//4469 6716//4466 6733//4472 +f 6712//4470 6711//4467 6728//4473 +f 6707//4459 6706//4471 6722//4474 +f 6713//4458 6712//4470 6729//4475 +f 6708//4461 6707//4459 6723//4476 +f 6714//4460 6713//4458 6730//4477 +f 6709//4464 6708//4461 6724//4478 +f 6715//4462 6714//4460 6731//4479 +f 6710//4480 6709//4464 6725//4481 +f 6705//4468 6704//4465 6720//4482 +f 6716//4466 6715//4462 6732//4483 +f 6711//4467 6710//4480 6727//4484 +f 6706//4471 6705//4468 6721//4485 +f 6721//4485 6720//4482 6735//4486 +f 6732//4483 6731//4479 6747//4487 +f 6727//4484 6726//4488 6742//4489 +f 6722//4474 6721//4485 6736//4490 +f 6733//4472 6732//4483 6748//4491 +f 6728//4473 6727//4484 6743//4492 +f 6723//4476 6722//4474 6737//4493 +f 6729//4475 6728//4473 6744//4494 +f 6724//4478 6723//4476 6738//4495 +f 6730//4477 6729//4475 6745//4496 +f 6725//4481 6724//4478 6739//4497 +f 6731//4479 6730//4477 6746//4498 +f 6726//4488 6725//4481 6740//4499 +f 6597//364 6281//4065 6296//4084 +f 6597//364 6296//4084 6311//4101 +f 6597//364 6311//4101 6326//4119 +f 6597//364 6326//4119 6341//4136 +f 6597//364 6341//4136 6356//4141 +f 6597//364 6356//4141 6371//4158 +f 6597//364 6371//4158 6386//4173 +f 6597//364 6386//4173 6401//4191 +f 6597//364 6401//4191 6416//4192 +f 6597//364 6416//4192 6431//4197 +f 6597//364 6431//4197 6446//4215 +f 6597//364 6446//4215 6461//4231 +f 6597//364 6461//4231 6476//4248 +f 6597//364 6476//4248 6491//4253 +f 6597//364 6491//4253 6506//4271 +f 6597//364 6506//4271 6521//4287 +f 6597//364 6521//4287 6536//4304 +f 6597//364 6536//4304 6551//4322 +f 6597//364 6551//4322 6566//4340 +f 6597//364 6566//4340 6581//4356 +f 6597//364 6581//4356 6596//4361 +f 6597//364 6596//4361 6612//4379 +f 6597//364 6612//4379 6627//4394 +f 6597//364 6627//4394 6642//4412 +f 6597//364 6642//4412 6657//4413 +f 6597//364 6657//4413 6672//4416 +f 6597//364 6672//4416 6687//4435 +f 6597//364 6687//4435 6702//4452 +f 6597//364 6702//4452 6717//4469 +f 6597//364 6717//4469 6733//4472 +f 6597//364 6733//4472 6748//4491 +f 6740//4499 6739//4497 6272//4072 +f 6746//4498 6745//4496 6279//4058 +f 6741//4500 6740//4499 6273//4076 +f 6736//4490 6735//4486 6268//4079 +f 6747//4487 6746//4498 6280//4057 +f 6742//4489 6741//4500 6275//4060 +f 6737//4493 6736//4490 6269//4063 +f 6748//4491 6747//4487 6281//4065 +f 6743//4492 6742//4489 6276//4067 +f 6738//4495 6737//4493 6270//4062 +f 6597//364 6748//4491 6281//4065 +f 6744//4494 6743//4492 6277//4070 +f 6739//4497 6738//4495 6271//4069 +f 6745//4496 6744//4494 6278//4074 +f 6295//4066 6280//4057 6294//4059 +f 6290//4068 6275//4060 6289//4061 +f 6269//4063 6284//4080 6285//4064 +f 6296//4084 6281//4065 6295//4066 +f 6291//4071 6276//4067 6290//4068 +f 6286//4087 6271//4069 6285//4064 +f 6292//4075 6277//4070 6291//4071 +f 6271//4069 6286//4087 6287//4073 +f 6293//4078 6278//4074 6292//4075 +f 6272//4072 6287//4073 6288//4077 +f 6294//4059 6279//4058 6293//4078 +f 6273//4076 6288//4077 6289//4061 +f 6268//4079 6283//4093 6284//4080 +f 6310//4085 6295//4066 6309//4081 +f 6305//4086 6290//4068 6304//4082 +f 6284//4080 6299//4094 6300//4083 +f 6311//4101 6296//4084 6310//4085 +f 6306//4088 6291//4071 6305//4086 +f 6301//4104 6286//4087 6300//4083 +f 6307//4090 6292//4075 6306//4088 +f 6286//4087 6301//4104 6302//4089 +f 6308//4092 6293//4078 6307//4090 +f 6287//4073 6302//4089 6303//4091 +f 6309//4081 6294//4059 6308//4092 +f 6288//4077 6303//4091 6304//4082 +f 6283//4093 6298//4097 6299//4094 +f 6324//4099 6309//4081 6323//4095 +f 6303//4091 6318//4109 6319//4096 +f 6298//4097 6313//4115 6314//4098 +f 6325//4102 6310//4085 6324//4099 +f 6320//4103 6305//4086 6319//4096 +f 6299//4094 6314//4098 6315//4100 +f 6326//4119 6311//4101 6325//4102 +f 6321//4106 6306//4088 6320//4103 +f 6300//4083 6315//4100 6316//4105 +f 6322//4108 6307//4090 6321//4106 +f 6301//4104 6316//4105 6317//4107 +f 6323//4095 6308//4092 6322//4108 +f 6302//4089 6317//4107 6318//4109 +f 6316//4105 6331//4122 6332//4110 +f 6338//4113 6323//4095 6337//4111 +f 6317//4107 6332//4110 6333//4112 +f 6339//4117 6324//4099 6338//4113 +f 6318//4109 6333//4112 6334//4114 +f 6313//4115 6328//4132 6329//4116 +f 6340//4120 6325//4102 6339//4117 +f 6335//4121 6320//4103 6334//4114 +f 6314//4098 6329//4116 6330//4118 +f 6341//4136 6326//4119 6340//4120 +f 6336//4123 6321//4106 6335//4121 +f 6315//4100 6330//4118 6331//4122 +f 6337//4111 6322//4108 6336//4123 +f 6351//4126 6336//4123 6350//4124 +f 6330//4118 6345//4135 6346//4125 +f 6352//4128 6337//4111 6351//4126 +f 6331//4122 6346//4125 6347//4127 +f 6353//4130 6338//4113 6352//4128 +f 6332//4110 6347//4127 6348//4129 +f 6354//4134 6339//4117 6353//4130 +f 6333//4112 6348//4129 6349//4131 +f 6328//4132 6343//4150 6344//4133 +f 6355//4137 6340//4120 6354//4134 +f 6350//4124 6335//4121 6349//4131 +f 6329//4116 6344//4133 6345//4135 +f 6356//4141 6341//4136 6355//4137 +f 6370//4142 6355//4137 6369//4138 +f 6365//4143 6350//4124 6364//4139 +f 6344//4133 6359//4151 6360//4140 +f 6371//4158 6356//4141 6370//4142 +f 6366//4145 6351//4126 6365//4143 +f 6345//4135 6360//4140 6361//4144 +f 6367//4147 6352//4128 6366//4145 +f 6346//4125 6361//4144 6362//4146 +f 6368//4149 6353//4130 6367//4147 +f 6347//4127 6362//4146 6363//4148 +f 6369//4138 6354//4134 6368//4149 +f 6348//4129 6363//4148 6364//4139 +f 6343//4150 6358//4154 6359//4151 +f 6384//4156 6369//4138 6383//4152 +f 6363//4148 6378//4165 6379//4153 +f 6358//4154 6373//4169 6374//4155 +f 6385//4159 6370//4142 6384//4156 +f 6380//4160 6365//4143 6379//4153 +f 6359//4151 6374//4155 6375//4157 +f 6386//4173 6371//4158 6385//4159 +f 6381//4162 6366//4145 6380//4160 +f 6360//4140 6375//4157 6376//4161 +f 6382//4164 6367//4147 6381//4162 +f 6361//4144 6376//4161 6377//4163 +f 6383//4152 6368//4149 6382//4164 +f 6362//4146 6377//4163 6378//4165 +f 6398//4168 6383//4152 6397//4166 +f 6377//4163 6392//4177 6393//4167 +f 6399//4171 6384//4156 6398//4168 +f 6378//4165 6393//4167 6394//3044 +f 6373//4169 6388//4186 6389//4170 +f 6400//4174 6385//4159 6399//4171 +f 6395//4175 6380//4160 6394//3044 +f 6374//4155 6389//4170 6390//4172 +f 6401//4191 6386//4173 6400//4174 +f 6396//4176 6381//4162 6395//4175 +f 6391//4178 6376//4161 6390//4172 +f 6397//4166 6382//4164 6396//4176 +f 6376//4161 6391//4178 6392//4177 +f 6406//4181 6391//4178 6405//4179 +f 6396//4176 6411//4193 6412//4180 +f 6407//4183 6392//4177 6406//4181 +f 6397//4166 6412//4180 6413//4182 +f 6408//4185 6393//4167 6407//4183 +f 6398//4168 6413//4182 6414//4184 +f 6409//4194 6394//3044 6408//4185 +f 6404//4190 6389//4170 6403//4187 +f 6399//4171 6414//4184 6415//4188 +f 6394//3044 6409//4194 6410//4189 +f 6405//4179 6390//4172 6404//4190 +f 6400//4174 6415//4188 6416//4192 +f 6395//4175 6410//4189 6411//4193 +f 6409//4194 6424//4209 6425//4195 +f 6420//4199 6405//4179 6419//4196 +f 6415//4188 6430//4207 6431//4197 +f 6410//4189 6425//4195 6426//4198 +f 6421//4201 6406//4181 6420//4199 +f 6411//4193 6426//4198 6427//4200 +f 6422//4203 6407//4183 6421//4201 +f 6412//4180 6427//4200 6428//4202 +f 6423//4205 6408//4185 6422//4203 +f 6413//4182 6428//4202 6429//4204 +f 6424//4209 6409//4194 6423//4205 +f 6419//4196 6404//4190 6418//4206 +f 6414//4184 6429//4204 6430//4207 +f 6428//4202 6443//4220 6444//4208 +f 6439//4225 6424//4209 6438//4210 +f 6434//4214 6419//4196 6433//4211 +f 6429//4204 6444//4208 6445//4212 +f 6424//4209 6439//4225 6440//4213 +f 6435//4217 6420//4199 6434//4214 +f 6430//4207 6445//4212 6446//4215 +f 6425//4195 6440//4213 6441//4216 +f 6436//4219 6421//4201 6435//4217 +f 6426//4198 6441//4216 6442//4218 +f 6437//4221 6422//4203 6436//4219 +f 6427//4200 6442//4218 6443//4220 +f 6438//4210 6423//4205 6437//4221 +f 6442//4218 6457//4234 6458//4222 +f 6453//4226 6438//4210 6452//4223 +f 6443//4220 6458//4222 6459//4224 +f 6454//4242 6439//4225 6453//4226 +f 6449//4230 6434//4214 6448//4227 +f 6444//4208 6459//4224 6460//4228 +f 6439//4225 6454//4242 6455//4229 +f 6450//4233 6435//4217 6449//4230 +f 6445//4212 6460//4228 6461//4231 +f 6440//4213 6455//4229 6456//4232 +f 6451//4235 6436//4219 6450//4233 +f 6441//4216 6456//4232 6457//4234 +f 6452//4223 6437//4221 6451//4235 +f 6466//4238 6451//4235 6465//4236 +f 6456//4232 6471//4249 6472//4237 +f 6467//4240 6452//4223 6466//4238 +f 6457//4234 6472//4237 6473//4239 +f 6468//4243 6453//4226 6467//4240 +f 6458//4222 6473//4239 6474//4241 +f 6469//4250 6454//4242 6468//4243 +f 6464//4247 6449//4230 6463//4244 +f 6459//4224 6474//4241 6475//4245 +f 6454//4242 6469//4250 6470//4246 +f 6465//4236 6450//4233 6464//4247 +f 6460//4228 6475//4245 6476//4248 +f 6455//4229 6470//4246 6471//4249 +f 6469//4250 6484//4265 6485//4251 +f 6480//4255 6465//4236 6479//4252 +f 6475//4245 6490//4263 6491//4253 +f 6470//4246 6485//4251 6486//4254 +f 6481//4257 6466//4238 6480//4255 +f 6471//4249 6486//4254 6487//4256 +f 6482//4259 6467//4240 6481//4257 +f 6472//4237 6487//4256 6488//4258 +f 6483//4261 6468//4243 6482//4259 +f 6473//4239 6488//4258 6489//4260 +f 6484//4265 6469//4250 6483//4261 +f 6479//4252 6464//4247 6478//4262 +f 6474//4241 6489//4260 6490//4263 +f 6488//4258 6503//4276 6504//4264 +f 6499//4281 6484//4265 6498//4266 +f 6494//4270 6479//4252 6493//4267 +f 6489//4260 6504//4264 6505//4268 +f 6484//4265 6499//4281 6500//4269 +f 6495//4273 6480//4255 6494//4270 +f 6490//4263 6505//4268 6506//4271 +f 6485//4251 6500//4269 6501//4272 +f 6496//4275 6481//4257 6495//4273 +f 6486//4254 6501//4272 6502//4274 +f 6497//4277 6482//4259 6496//4275 +f 6487//4256 6502//4274 6503//4276 +f 6498//4266 6483//4261 6497//4277 +f 6502//4274 6517//4290 6518//4278 +f 6513//4282 6498//4266 6512//4279 +f 6503//4276 6518//4278 6519//4280 +f 6514//261 6499//4281 6513//4282 +f 6509//4286 6494//4270 6508//4283 +f 6504//4264 6519//4280 6520//4284 +f 6499//4281 6514//261 6515//4285 +f 6510//4289 6495//4273 6509//4286 +f 6505//4268 6520//4284 6521//4287 +f 6500//4269 6515//4285 6516//4288 +f 6511//4291 6496//4275 6510//4289 +f 6501//4272 6516//4288 6517//4290 +f 6512//4279 6497//4277 6511//4291 +f 6532//4294 6517//4290 6531//4292 +f 6511//4291 6526//4307 6527//4293 +f 6533//4296 6518//4278 6532//4294 +f 6512//4279 6527//4293 6528//4295 +f 6534//4299 6519//4280 6533//4296 +f 6513//4282 6528//4295 6529//4297 +f 6508//4283 6523//4314 6524//4298 +f 6535//4301 6520//4284 6534//4299 +f 6530//4302 6515//4285 6529//4297 +f 6509//4286 6524//4298 6525//4300 +f 6536//4304 6521//4287 6535//4301 +f 6531//4292 6516//4288 6530//4302 +f 6526//4307 6511//4291 6525//4300 +f 6524//4298 6539//4315 6540//4303 +f 6551//4322 6536//4304 6550//4305 +f 6546//4308 6531//4292 6545//4306 +f 6541//4325 6526//4307 6540//4303 +f 6547//4310 6532//4294 6546//4308 +f 6526//4307 6541//4325 6542//4309 +f 6548//4312 6533//4296 6547//4310 +f 6527//4293 6542//4309 6543//4311 +f 6549//4316 6534//4299 6548//4312 +f 6528//4295 6543//4311 6544//4313 +f 6523//4314 6538//4318 6539//4315 +f 6550//4305 6535//4301 6549//4316 +f 6545//4306 6530//4302 6544//4313 +f 6543//4311 6558//4330 6559//4317 +f 6538//4318 6553//4336 6554//4319 +f 6565//4323 6550//4305 6564//4320 +f 6560//4324 6545//4306 6559//4317 +f 6539//4315 6554//4319 6555//4321 +f 6566//4340 6551//4322 6565//4323 +f 6561//4327 6546//4308 6560//4324 +f 6540//4303 6555//4321 6556//4326 +f 6562//4329 6547//4310 6561//4327 +f 6541//4325 6556//4326 6557//4328 +f 6563//4331 6548//4312 6562//4329 +f 6542//4309 6557//4328 6558//4330 +f 6564//4320 6549//4316 6563//4331 +f 6578//4334 6563//4331 6577//4332 +f 6557//4328 6572//4345 6573//4333 +f 6579//4338 6564//4320 6578//4334 +f 6558//4330 6573//4333 6574//4335 +f 6553//4336 6568//4352 6569//4337 +f 6580//4341 6565//4323 6579//4338 +f 6575//4342 6560//4324 6574//4335 +f 6554//4319 6569//4337 6570//4339 +f 6581//4356 6566//4340 6580//4341 +f 6576//4344 6561//4327 6575//4342 +f 6555//4321 6570//4339 6571//4343 +f 6577//4332 6562//4329 6576//4344 +f 6556//4326 6571//4343 6572//4345 +f 6592//4348 6577//4332 6591//4346 +f 6571//4343 6586//4359 6587//4347 +f 6593//4350 6578//4334 6592//4348 +f 6572//4345 6587//4347 6588//4349 +f 6594//4354 6579//4338 6593//4350 +f 6573//4333 6588//4349 6589//4351 +f 6568//4352 6583//4371 6584//4353 +f 6595//4357 6580//4341 6594//4354 +f 6590//4358 6575//4342 6589//4351 +f 6569//4337 6584//4353 6585//4355 +f 6596//4361 6581//4356 6595//4357 +f 6591//4346 6576//4344 6590//4358 +f 6570//4339 6585//4355 6586//4359 +f 6584//4353 6600//4372 6601//4360 +f 6612//4379 6596//4361 6611//4362 +f 6607//4365 6591//4346 6606//4363 +f 6585//4355 6601//4360 6602//4364 +f 6608//4367 6592//4348 6607//4365 +f 6586//4359 6602//4364 6603//4366 +f 6609//4369 6593//4350 6608//4367 +f 6587//4347 6603//4366 6604//4368 +f 6610//4373 6594//4354 6609//4369 +f 6588//4349 6604//4368 6605//4370 +f 6583//4371 6599//4375 6600//4372 +f 6611//4362 6595//4357 6610//4373 +f 6606//4363 6590//4358 6605//4370 +f 6604//4368 6619//4385 6620//4374 +f 6599//4375 6614//4390 6615//4376 +f 6626//4380 6611//4362 6625//4377 +f 6621//4381 6606//4363 6620//4374 +f 6600//4372 6615//4376 6616//4378 +f 6627//4394 6612//4379 6626//4380 +f 6622//4382 6607//4365 6621//4381 +f 6617//4397 6602//4364 6616//4378 +f 6623//4384 6608//4367 6622//4382 +f 6602//4364 6617//4397 6618//4383 +f 6624//4386 6609//4369 6623//4384 +f 6603//4366 6618//4383 6619//4385 +f 6625//4377 6610//4373 6624//4386 +f 6639//4389 6624//4386 6638//4387 +f 6618//4383 6633//4399 6634//4388 +f 6640//4392 6625//4377 6639//4389 +f 6619//4385 6634//4388 6635//3282 +f 6614//4390 6629//4407 6630//4391 +f 6641//4395 6626//4380 6640//4392 +f 6636//4396 6621//4381 6635//3282 +f 6615//4376 6630//4391 6631//4393 +f 6642//4412 6627//4394 6641//4395 +f 6637//4398 6622//4382 6636//4396 +f 6632//4401 6617//4397 6631//4393 +f 6638//4387 6623//4384 6637//4398 +f 6617//4397 6632//4401 6633//4399 +f 6637//4398 6652//4414 6653//4400 +f 6648//4404 6633//4399 6647//4402 +f 6638//4387 6653//4400 6654//4403 +f 6649//4406 6634//4388 6648//4404 +f 6639//4389 6654//4403 6655//4405 +f 6650//4424 6635//3282 6649//4406 +f 6645//4411 6630//4391 6644//4408 +f 6640//4392 6655//4405 6656//4409 +f 6635//3282 6650//4424 6651//4410 +f 6646//4415 6631//4393 6645//4411 +f 6641//4395 6656//4409 6657//4413 +f 6636//4396 6651//4410 6652//4414 +f 6647//4402 6632//4401 6646//4415 +f 6656//4409 6671//4427 6672//4416 +f 6651//4410 6666//4428 6667//4417 +f 6662//4420 6647//4402 6661//4418 +f 6652//4414 6667//4417 6668//4419 +f 6663//4422 6648//4404 6662//4420 +f 6653//4400 6668//4419 6669//4421 +f 6664//4425 6649//4406 6663//4422 +f 6654//4403 6669//4421 6670//4423 +f 6665//4432 6650//4424 6664//4425 +f 6660//4429 6645//4411 6659//4426 +f 6655//4405 6670//4423 6671//4427 +f 6650//4424 6665//4432 6666//4428 +f 6661//4418 6646//4415 6660//4429 +f 6675//4434 6660//4429 6674//4430 +f 6670//4423 6685//4442 6686//4431 +f 6665//4432 6680//4446 6681//4433 +f 6676//4437 6661//4418 6675//4434 +f 6671//4427 6686//4431 6687//4435 +f 6666//4428 6681//4433 6682//4436 +f 6677//4439 6662//4420 6676//4437 +f 6667//4417 6682//4436 6683//4438 +f 6678//4441 6663//4422 6677//4439 +f 6668//4419 6683//4438 6684//4440 +f 6679//4443 6664//4425 6678//4441 +f 6669//4421 6684//4440 6685//4442 +f 6680//4446 6665//4432 6679//4443 +f 6694//4447 6679//4443 6693//4444 +f 6684//4440 6699//4457 6700//4445 +f 6695//4463 6680//4446 6694//4447 +f 6690//4451 6675//4434 6689//4448 +f 6685//4442 6700//4445 6701//4449 +f 6680//4446 6695//4463 6696//4450 +f 6691//4454 6676//4437 6690//4451 +f 6686//4431 6701//4449 6702//4452 +f 6681//4433 6696//4450 6697//4453 +f 6692//4456 6677//4439 6691//4454 +f 6682//4436 6697//4453 6698//4455 +f 6693//4444 6678//4441 6692//4456 +f 6683//4438 6698//4455 6699//4457 +f 6697//4453 6712//4470 6713//4458 +f 6708//4461 6693//4444 6707//4459 +f 6698//4455 6713//4458 6714//4460 +f 6709//4464 6694//4447 6708//4461 +f 6699//4457 6714//4460 6715//4462 +f 6710//4480 6695//4463 6709//4464 +f 6705//4468 6690//4451 6704//4465 +f 6700//4445 6715//4462 6716//4466 +f 6695//4463 6710//4480 6711//4467 +f 6706//4471 6691//4454 6705//4468 +f 6701//4449 6716//4466 6717//4469 +f 6696//4450 6711//4467 6712//4470 +f 6707//4459 6692//4456 6706//4471 +f 6716//4466 6732//4483 6733//4472 +f 6711//4467 6727//4484 6728//4473 +f 6723//4476 6707//4459 6722//4474 +f 6712//4470 6728//4473 6729//4475 +f 6724//4478 6708//4461 6723//4476 +f 6713//4458 6729//4475 6730//4477 +f 6725//4481 6709//4464 6724//4478 +f 6714//4460 6730//4477 6731//4479 +f 6726//4488 6710//4480 6725//4481 +f 6721//4485 6705//4468 6720//4482 +f 6715//4462 6731//4479 6732//4483 +f 6710//4480 6726//4488 6727//4484 +f 6722//4474 6706//4471 6721//4485 +f 6736//4490 6721//4485 6735//4486 +f 6731//4479 6746//4498 6747//4487 +f 6726//4488 6741//4500 6742//4489 +f 6737//4493 6722//4474 6736//4490 +f 6732//4483 6747//4487 6748//4491 +f 6727//4484 6742//4489 6743//4492 +f 6738//4495 6723//4476 6737//4493 +f 6728//4473 6743//4492 6744//4494 +f 6739//4497 6724//4478 6738//4495 +f 6729//4475 6744//4494 6745//4496 +f 6740//4499 6725//4481 6739//4497 +f 6730//4477 6745//4496 6746//4498 +f 6741//4500 6726//4488 6740//4499 +f 6273//4076 6740//4499 6272//4072 +f 6745//4496 6278//4074 6279//4058 +f 6274//2918 6741//4500 6273//4076 +f 6269//4063 6736//4490 6268//4079 +f 6746//4498 6279//4058 6280//4057 +f 6741//4500 6274//2918 6275//4060 +f 6270//4062 6737//4493 6269//4063 +f 6747//4487 6280//4057 6281//4065 +f 6742//4489 6275//4060 6276//4067 +f 6271//4069 6738//4495 6270//4062 +f 6743//4492 6276//4067 6277//4070 +f 6272//4072 6739//4497 6271//4069 +f 6744//4494 6277//4070 6278//4074 +usemtl NoseTop +f 6268//4079 6267//4501 6283//4093 +f 6283//4093 6282//4502 6298//4097 +f 6298//4097 6297//4503 6313//4115 +f 6313//4115 6312//4504 6328//4132 +f 6328//4132 6327//4505 6343//4150 +f 6343//4150 6342//4506 6358//4154 +f 6358//4154 6357//4507 6373//4169 +f 6373//4169 6372//4508 6388//4186 +f 6388//4186 6387//4509 6402//4510 +f 6403//4187 6402//4510 6417//4511 +f 6418//4206 6417//4511 6432//4512 +f 6433//4211 6432//4512 6447//4513 +f 6448//4227 6447//4513 6462//4514 +f 6463//4244 6462//4514 6477//4515 +f 6478//4262 6477//4515 6492//4516 +f 6493//4267 6492//4516 6507//4517 +f 6508//4283 6507//4517 6523//4314 +f 6523//4314 6522//4518 6538//4318 +f 6538//4318 6537//4519 6553//4336 +f 6553//4336 6552//4520 6568//4352 +f 6568//4352 6567//4521 6583//4371 +f 6583//4371 6582//4522 6599//4375 +f 6599//4375 6598//4523 6614//4390 +f 6614//4390 6613//4524 6629//4407 +f 6629//4407 6628//4525 6643//4526 +f 6644//4408 6643//4526 6658//4527 +f 6659//4426 6658//4527 6673//4528 +f 6674//4430 6673//4528 6688//4529 +f 6689//4448 6688//4529 6703//4530 +f 6704//4465 6703//4530 6719//4531 +f 6720//4482 6719//4531 6734//4532 +f 6267//4501 6718//4533 6282//4502 +f 6282//4502 6718//4533 6297//4503 +f 6297//4503 6718//4533 6312//4504 +f 6312//4504 6718//4533 6327//4505 +f 6327//4505 6718//4533 6342//4506 +f 6342//4506 6718//4533 6357//4507 +f 6357//4507 6718//4533 6372//4508 +f 6372//4508 6718//4533 6387//4509 +f 6387//4509 6718//4533 6402//4510 +f 6402//4510 6718//4533 6417//4511 +f 6417//4511 6718//4533 6432//4512 +f 6432//4512 6718//4533 6447//4513 +f 6447//4513 6718//4533 6462//4514 +f 6462//4514 6718//4533 6477//4515 +f 6477//4515 6718//4533 6492//4516 +f 6492//4516 6718//4533 6507//4517 +f 6507//4517 6718//4533 6522//4518 +f 6522//4518 6718//4533 6537//4519 +f 6537//4519 6718//4533 6552//4520 +f 6552//4520 6718//4533 6567//4521 +f 6567//4521 6718//4533 6582//4522 +f 6582//4522 6718//4533 6598//4523 +f 6598//4523 6718//4533 6613//4524 +f 6613//4524 6718//4533 6628//4525 +f 6628//4525 6718//4533 6643//4526 +f 6643//4526 6718//4533 6658//4527 +f 6658//4527 6718//4533 6673//4528 +f 6673//4528 6718//4533 6688//4529 +f 6688//4529 6718//4533 6703//4530 +f 6703//4530 6718//4533 6719//4531 +f 6719//4531 6718//4533 6734//4532 +f 6735//4486 6734//4532 6267//4501 +f 6734//4532 6718//4533 6267//4501 +f 6267//4501 6282//4502 6283//4093 +f 6282//4502 6297//4503 6298//4097 +f 6297//4503 6312//4504 6313//4115 +f 6312//4504 6327//4505 6328//4132 +f 6327//4505 6342//4506 6343//4150 +f 6342//4506 6357//4507 6358//4154 +f 6357//4507 6372//4508 6373//4169 +f 6372//4508 6387//4509 6388//4186 +f 6403//4187 6388//4186 6402//4510 +f 6418//4206 6403//4187 6417//4511 +f 6433//4211 6418//4206 6432//4512 +f 6448//4227 6433//4211 6447//4513 +f 6463//4244 6448//4227 6462//4514 +f 6478//4262 6463//4244 6477//4515 +f 6493//4267 6478//4262 6492//4516 +f 6508//4283 6493//4267 6507//4517 +f 6507//4517 6522//4518 6523//4314 +f 6522//4518 6537//4519 6538//4318 +f 6537//4519 6552//4520 6553//4336 +f 6552//4520 6567//4521 6568//4352 +f 6567//4521 6582//4522 6583//4371 +f 6582//4522 6598//4523 6599//4375 +f 6598//4523 6613//4524 6614//4390 +f 6613//4524 6628//4525 6629//4407 +f 6644//4408 6629//4407 6643//4526 +f 6659//4426 6644//4408 6658//4527 +f 6674//4430 6659//4426 6673//4528 +f 6689//4448 6674//4430 6688//4529 +f 6704//4465 6689//4448 6703//4530 +f 6720//4482 6704//4465 6719//4531 +f 6735//4486 6720//4482 6734//4532 +f 6268//4079 6735//4486 6267//4501 +o Eye_R_Sphere.006 +v -0.524476 0.974916 -0.429854 +v -0.531200 0.971113 -0.437667 +v -0.521508 0.974612 -0.432816 +v -0.529686 0.970959 -0.439177 +v -0.519084 0.973822 -0.436159 +v -0.528450 0.970556 -0.440881 +v -0.517299 0.972578 -0.439756 +v -0.527540 0.969921 -0.442715 +v -0.516221 0.970925 -0.443469 +v -0.526991 0.969079 -0.444608 +v -0.515891 0.968928 -0.447154 +v -0.526823 0.968061 -0.446487 +v -0.516322 0.966664 -0.450671 +v -0.527043 0.966907 -0.448279 +v -0.517498 0.964220 -0.453883 +v -0.527642 0.965661 -0.449917 +v -0.519374 0.961690 -0.456668 +v -0.528598 0.964371 -0.451337 +v -0.521876 0.959170 -0.458918 +v -0.529874 0.963086 -0.452484 +v -0.524910 0.956758 -0.460548 +v -0.531421 0.961856 -0.453314 +v -0.528358 0.954546 -0.461493 +v -0.533179 0.960729 -0.453797 +v -0.532089 0.952620 -0.461719 +v -0.535080 0.959747 -0.453912 +v -0.535957 0.951053 -0.461216 +v -0.537053 0.958948 -0.453655 +v -0.539816 0.949906 -0.460004 +v -0.539020 0.958363 -0.453038 +v -0.543517 0.949222 -0.458129 +v -0.540906 0.958015 -0.452082 +v -0.546917 0.949029 -0.455664 +v -0.542640 0.957916 -0.450825 +v -0.549886 0.949332 -0.452703 +v -0.544153 0.958071 -0.449315 +v -0.552309 0.950122 -0.449359 +v -0.545389 0.958474 -0.447611 +v -0.554094 0.951367 -0.445762 +v -0.546299 0.959108 -0.445777 +v -0.555173 0.953019 -0.442049 +v -0.546848 0.959951 -0.443884 +v -0.555502 0.955016 -0.438364 +v -0.547016 0.960968 -0.442005 +v -0.537332 0.965373 -0.444748 +v -0.555071 0.957280 -0.434848 +v -0.546796 0.962123 -0.440213 +v -0.553895 0.959724 -0.431635 +v -0.546197 0.963369 -0.438575 +v -0.552019 0.962255 -0.428850 +v -0.545241 0.964659 -0.437155 +v -0.549517 0.964774 -0.426600 +v -0.543965 0.965943 -0.436008 +v -0.546483 0.967187 -0.424971 +v -0.542418 0.967173 -0.435178 +v -0.543035 0.969398 -0.424025 +v -0.540661 0.968301 -0.434695 +v -0.539305 0.971325 -0.423799 +v -0.538759 0.969283 -0.434580 +v -0.535436 0.972891 -0.424302 +v -0.536787 0.970081 -0.434837 +v -0.531577 0.974039 -0.425514 +v -0.534819 0.970666 -0.435455 +v -0.527876 0.974722 -0.427389 +v -0.532933 0.971015 -0.436410 +v -0.527903 0.973309 -0.433843 +v -0.525649 0.973078 -0.436092 +v -0.522998 0.974809 -0.431345 +v -0.530446 0.971047 -0.438426 +v -0.523808 0.972479 -0.438630 +v -0.520299 0.974262 -0.434501 +v -0.529071 0.970768 -0.440034 +v -0.522453 0.971533 -0.441362 +v -0.527998 0.970250 -0.441803 +v -0.518193 0.973244 -0.437974 +v -0.521634 0.970279 -0.444180 +v -0.516760 0.971794 -0.441632 +v -0.527268 0.969511 -0.443667 +v -0.521384 0.968763 -0.446979 +v -0.516056 0.969968 -0.445334 +v -0.526909 0.968580 -0.445553 +v -0.521712 0.967044 -0.449649 +v -0.516107 0.967836 -0.448938 +v -0.526935 0.967494 -0.447389 +v -0.522605 0.965188 -0.452088 +v -0.527345 0.966294 -0.449105 +v -0.516911 0.965480 -0.452305 +v -0.524029 0.963266 -0.454202 +v -0.518438 0.962990 -0.455306 +v -0.528123 0.965025 -0.450634 +v -0.525929 0.961353 -0.455911 +v -0.520629 0.960463 -0.457826 +v -0.529239 0.963738 -0.451918 +v -0.528232 0.959522 -0.457148 +v -0.523399 0.957995 -0.459767 +v -0.530651 0.962480 -0.452907 +v -0.530850 0.957842 -0.457866 +v -0.532303 0.961302 -0.453563 +v -0.526643 0.955681 -0.461056 +v -0.533683 0.956380 -0.458038 +v -0.530235 0.953610 -0.461642 +v -0.534133 0.960247 -0.453862 +v -0.536620 0.955190 -0.457656 +v -0.534038 0.951862 -0.461504 +v -0.536071 0.959356 -0.453791 +v -0.539550 0.954319 -0.456735 +v -0.537905 0.950504 -0.460645 +v -0.538041 0.958664 -0.453354 +v -0.542360 0.953800 -0.455312 +v -0.541688 0.949588 -0.459101 +v -0.539968 0.958197 -0.452567 +v -0.544942 0.953653 -0.453440 +v -0.545241 0.949149 -0.456929 +v -0.541779 0.957974 -0.451461 +v -0.547196 0.953884 -0.451191 +v -0.548429 0.949204 -0.454213 +v -0.543402 0.958002 -0.450077 +v -0.549036 0.954483 -0.448653 +v -0.551127 0.949751 -0.451058 +v -0.544777 0.958281 -0.448469 +v -0.550391 0.955428 -0.445921 +v -0.553233 0.950769 -0.447585 +v -0.545850 0.958799 -0.446700 +v -0.551210 0.956683 -0.443102 +v -0.554666 0.952219 -0.443927 +v -0.546580 0.959538 -0.444836 +v -0.551460 0.958199 -0.440304 +v -0.542328 0.963416 -0.443519 +v -0.555370 0.954045 -0.440225 +v -0.546939 0.960468 -0.442950 +v -0.551133 0.959918 -0.437634 +v -0.555319 0.956177 -0.436621 +v -0.546913 0.961555 -0.441114 +v -0.550240 0.961774 -0.435195 +v -0.554515 0.958533 -0.433253 +v -0.546503 0.962755 -0.439398 +v -0.548816 0.963695 -0.433081 +v -0.545726 0.964023 -0.437869 +v -0.552988 0.961023 -0.430252 +v -0.546916 0.965609 -0.431372 +v -0.550797 0.963550 -0.427733 +v -0.544609 0.965311 -0.436586 +v -0.544612 0.967440 -0.430135 +v -0.548027 0.966018 -0.425791 +v -0.543198 0.966568 -0.435597 +v -0.541994 0.969119 -0.429417 +v -0.544783 0.968332 -0.424502 +v -0.541545 0.967747 -0.434940 +v -0.539162 0.970582 -0.429245 +v -0.539715 0.968802 -0.434641 +v -0.541191 0.970403 -0.423916 +v -0.536224 0.971772 -0.429627 +v -0.537388 0.972151 -0.424055 +v -0.537778 0.969693 -0.434712 +v -0.533294 0.972643 -0.430547 +v -0.533521 0.973509 -0.424913 +v -0.535807 0.970385 -0.435149 +v -0.530484 0.973162 -0.431971 +v -0.529738 0.974425 -0.426458 +v -0.533880 0.970852 -0.435936 +v -0.534371 0.968519 -0.441337 +v -0.533610 0.968441 -0.442096 +v -0.532988 0.968239 -0.442954 +v -0.532531 0.967919 -0.443876 +v -0.532254 0.967496 -0.444829 +v -0.532170 0.966984 -0.445774 +v -0.532280 0.966403 -0.446676 +v -0.532582 0.965776 -0.447499 +v -0.533063 0.965127 -0.448214 +v -0.533705 0.964481 -0.448791 +v -0.534483 0.963862 -0.449209 +v -0.535367 0.963295 -0.449451 +v -0.536324 0.962801 -0.449509 +v -0.537316 0.962399 -0.449380 +v -0.538306 0.962105 -0.449069 +v -0.539255 0.961930 -0.448588 +v -0.540127 0.961880 -0.447956 +v -0.540888 0.961958 -0.447197 +v -0.541509 0.962160 -0.446339 +v -0.541967 0.962480 -0.445417 +v -0.542244 0.962904 -0.444464 +v -0.542218 0.963996 -0.442618 +v -0.541916 0.964623 -0.441794 +v -0.541435 0.965272 -0.441079 +v -0.540793 0.965918 -0.440502 +v -0.540015 0.966537 -0.440085 +v -0.539131 0.967104 -0.439842 +v -0.538174 0.967598 -0.439784 +v -0.537182 0.968000 -0.439913 +v -0.536192 0.968294 -0.440224 +v -0.535243 0.968470 -0.440705 +v -0.532070 0.971075 -0.437043 +v -0.526185 0.974864 -0.428630 +v -0.526781 0.973219 -0.434975 +v -0.524733 0.972804 -0.437370 +v -0.523134 0.972031 -0.440006 +v -0.522047 0.970930 -0.442783 +v -0.521512 0.969544 -0.445593 +v -0.521551 0.967926 -0.448328 +v -0.522161 0.966138 -0.450884 +v -0.523320 0.964248 -0.453162 +v -0.524983 0.962330 -0.455074 +v -0.527086 0.960457 -0.456548 +v -0.529548 0.958700 -0.457526 +v -0.532274 0.957129 -0.457971 +v -0.535161 0.955802 -0.457866 +v -0.538096 0.954771 -0.457214 +v -0.540967 0.954075 -0.456042 +v -0.543664 0.953742 -0.454393 +v -0.546083 0.953784 -0.452332 +v -0.548132 0.954199 -0.449937 +v -0.549730 0.954972 -0.447301 +v -0.550818 0.956073 -0.444524 +v -0.551353 0.957459 -0.441714 +v -0.551314 0.959077 -0.438979 +v -0.550703 0.960865 -0.436423 +v -0.549544 0.962755 -0.434145 +v -0.547881 0.964673 -0.432233 +v -0.545779 0.966546 -0.430759 +v -0.543317 0.968303 -0.429781 +v -0.540590 0.969874 -0.429336 +v -0.537704 0.971201 -0.429441 +v -0.534768 0.972232 -0.430093 +v -0.531897 0.972928 -0.431265 +v -0.529200 0.973261 -0.432914 +v -0.278633 0.972176 -0.169592 +v -0.294496 0.987579 -0.191783 +v -0.315813 0.996242 -0.220002 +v -0.345297 1.010831 -0.259381 +v -0.379326 1.021626 -0.304026 +v -0.414714 1.021300 -0.348918 +v -0.450102 1.009866 -0.392330 +v -0.238105 0.964990 -0.207660 +v -0.256320 0.980810 -0.227642 +v -0.281455 0.990149 -0.252275 +v -0.316078 1.005650 -0.286827 +v -0.356369 1.017555 -0.325590 +v -0.398901 1.018496 -0.363771 +v -0.442040 1.008437 -0.399903 +v -0.205451 0.952861 -0.251590 +v -0.225560 0.969385 -0.269024 +v -0.253772 0.979867 -0.289517 +v -0.292535 0.996905 -0.318499 +v -0.337872 1.010685 -0.350475 +v -0.386160 1.013764 -0.380912 +v -0.435545 1.006024 -0.408641 +v -0.181925 0.936256 -0.299696 +v -0.203399 0.953743 -0.314338 +v -0.233828 0.965789 -0.330299 +v -0.275574 0.984934 -0.353181 +v -0.324545 1.001278 -0.377724 +v -0.376981 1.007284 -0.399682 +v -0.430865 1.002721 -0.418210 +v -0.168432 0.915812 -0.350127 +v -0.190689 0.934485 -0.361843 +v -0.222389 0.948458 -0.373053 +v -0.265846 0.970195 -0.389540 +v -0.316902 0.989698 -0.406291 +v -0.371716 0.999308 -0.419359 +v -0.428182 0.998655 -0.428241 +v -0.165490 0.892316 -0.400946 +v -0.187918 0.912352 -0.409714 +v -0.219895 0.928539 -0.416135 +v -0.263725 0.953255 -0.426178 +v -0.315236 0.976388 -0.435078 +v -0.370568 0.990140 -0.439188 +v -0.427596 0.993981 -0.438350 +v -0.173213 0.866670 -0.450200 +v -0.195192 0.888194 -0.456110 +v -0.226441 0.906797 -0.457890 +v -0.269293 0.934765 -0.461688 +v -0.319610 0.961861 -0.462978 +v -0.373581 0.980133 -0.458405 +v -0.429132 0.988880 -0.448147 +v -0.191302 0.839860 -0.495996 +v -0.212232 0.862940 -0.499249 +v -0.241777 0.884069 -0.496714 +v -0.282335 0.915436 -0.494706 +v -0.329857 0.946674 -0.488919 +v -0.380639 0.969673 -0.476274 +v -0.432731 0.983547 -0.457256 +v -0.219064 0.812916 -0.536574 +v -0.238383 0.837559 -0.537473 +v -0.265313 0.861227 -0.531115 +v -0.302350 0.896011 -0.523961 +v -0.345583 0.931412 -0.511905 +v -0.391472 0.959160 -0.492107 +v -0.438253 0.978187 -0.465328 +v -0.255432 0.786873 -0.570376 +v -0.272641 0.813028 -0.569313 +v -0.296143 0.839149 -0.559771 +v -0.328569 0.877235 -0.548330 +v -0.366183 0.916660 -0.531052 +v -0.405661 0.948999 -0.505296 +v -0.445487 0.973007 -0.472051 +v -0.299007 0.762734 -0.596101 +v -0.313688 0.790289 -0.593546 +v -0.333085 0.818684 -0.581579 +v -0.359985 0.859831 -0.566877 +v -0.390867 0.902986 -0.545624 +v -0.422664 0.939580 -0.515333 +v -0.454154 0.968206 -0.477168 +v -0.348115 0.741424 -0.612761 +v -0.359947 0.770215 -0.609240 +v -0.374717 0.800619 -0.595703 +v -0.395391 0.844468 -0.578889 +v -0.418684 0.890915 -0.555062 +v -0.441825 0.931265 -0.521834 +v -0.463923 0.963967 -0.480482 +v -0.400870 0.723763 -0.619717 +v -0.409640 0.753579 -0.615791 +v -0.419440 0.785647 -0.601600 +v -0.433424 0.831735 -0.583903 +v -0.448567 0.880911 -0.559002 +v -0.462409 0.924374 -0.524548 +v -0.474416 0.960454 -0.481866 +v -0.455243 0.710430 -0.616700 +v -0.460859 0.741020 -0.612950 +v -0.465535 0.774344 -0.599042 +v -0.472625 0.822123 -0.581728 +v -0.479367 0.873359 -0.557293 +v -0.483624 0.919172 -0.523371 +v -0.485232 0.957802 -0.481266 +v -0.509145 0.701937 -0.603827 +v -0.511634 0.733020 -0.600823 +v -0.511231 0.767144 -0.588129 +v -0.511487 0.816000 -0.572447 +v -0.509901 0.868548 -0.550001 +v -0.504656 0.915858 -0.518348 +v -0.495954 0.956113 -0.478705 +v -0.560505 0.698611 -0.581592 +v -0.560014 0.729886 -0.579879 +v -0.554772 0.764324 -0.569279 +v -0.548515 0.813601 -0.556417 +v -0.538994 0.866663 -0.537406 +v -0.524695 0.914560 -0.509672 +v -0.506170 0.955451 -0.474282 +v -0.607349 0.700579 -0.550850 +v -0.604140 0.731740 -0.550920 +v -0.594485 0.765992 -0.543217 +v -0.582288 0.815020 -0.534253 +v -0.565529 0.867778 -0.519992 +v -0.542973 0.915328 -0.497677 +v -0.515488 0.955842 -0.468167 +v -0.647877 0.707765 -0.512782 +v -0.642316 0.738510 -0.515061 +v -0.628843 0.772084 -0.510945 +v -0.611507 0.820201 -0.506808 +v -0.588486 0.871849 -0.498428 +v -0.558786 0.918132 -0.482824 +v -0.523804 0.953636 -0.459109 +v -0.680531 0.719894 -0.468852 +v -0.673076 0.749935 -0.473679 +v -0.656525 0.782367 -0.473702 +v -0.635049 0.828946 -0.475135 +v -0.606983 0.878720 -0.473543 +v -0.571527 0.922864 -0.465683 +v -0.531714 0.953934 -0.450611 +v -0.704057 0.736500 -0.420746 +v -0.695237 0.765577 -0.428365 +v -0.676470 0.796444 -0.432921 +v -0.652010 0.840918 -0.440454 +v -0.620309 0.888126 -0.446294 +v -0.580706 0.929344 -0.446913 +v -0.536923 0.956848 -0.440806 +v -0.717550 0.756943 -0.370315 +v -0.707947 0.784834 -0.380860 +v -0.687909 0.813776 -0.390167 +v -0.661738 0.855657 -0.404095 +v -0.627952 0.899706 -0.417727 +v -0.585971 0.937320 -0.427236 +v -0.539247 0.961473 -0.430560 +v -0.720492 0.780440 -0.319496 +v -0.710718 0.806967 -0.332990 +v -0.690402 0.833695 -0.347085 +v -0.663859 0.872597 -0.367456 +v -0.629619 0.913016 -0.388940 +v -0.587119 0.946488 -0.407407 +v -0.538122 0.967966 -0.420997 +v -0.484129 0.987764 -0.432596 +v -0.712770 0.806086 -0.270242 +v -0.703444 0.831125 -0.286594 +v -0.683856 0.855436 -0.305330 +v -0.658292 0.891086 -0.331946 +v -0.625244 0.927543 -0.361040 +v -0.584106 0.956495 -0.388189 +v -0.536457 0.976829 -0.412351 +v -0.694680 0.832896 -0.224446 +v -0.686404 0.856380 -0.243454 +v -0.668520 0.878165 -0.266505 +v -0.645250 0.910415 -0.298929 +v -0.614998 0.942730 -0.335099 +v -0.577048 0.966955 -0.370321 +v -0.532859 0.982162 -0.403242 +v -0.666918 0.859839 -0.183868 +v -0.660252 0.881760 -0.205230 +v -0.644985 0.901007 -0.232105 +v -0.625235 0.929841 -0.269673 +v -0.599272 0.957992 -0.312113 +v -0.566216 0.977468 -0.354488 +v -0.527337 0.987521 -0.395170 +v -0.630551 0.885882 -0.150066 +v -0.625995 0.906292 -0.173390 +v -0.614154 0.923084 -0.203449 +v -0.599015 0.948616 -0.245304 +v -0.578671 0.972744 -0.292966 +v -0.552026 0.987630 -0.341299 +v -0.520103 0.992701 -0.388447 +v -0.586976 0.910022 -0.124341 +v -0.584948 0.929031 -0.149158 +v -0.577213 0.943549 -0.181641 +v -0.567599 0.966020 -0.226757 +v -0.553988 0.986418 -0.278394 +v -0.535023 0.997048 -0.331262 +v -0.511435 0.997503 -0.383330 +v -0.537867 0.931331 -0.107681 +v -0.538689 0.949104 -0.133464 +v -0.535581 0.961614 -0.167517 +v -0.532194 0.981383 -0.214746 +v -0.526170 0.998489 -0.268956 +v -0.515862 1.005363 -0.324761 +v -0.501667 1.001742 -0.380015 +v -0.485113 0.948992 -0.100725 +v -0.488996 0.965740 -0.126912 +v -0.490858 0.976587 -0.161620 +v -0.494160 0.994116 -0.209731 +v -0.496287 1.008493 -0.265017 +v -0.495279 1.012254 -0.322047 +v -0.491173 1.005255 -0.378632 +v -0.430740 0.962325 -0.103742 +v -0.437777 0.978299 -0.129754 +v -0.444762 0.987890 -0.164178 +v -0.454959 1.003729 -0.211906 +v -0.465487 1.016046 -0.266725 +v -0.474063 1.017456 -0.323224 +v -0.480358 1.007907 -0.379232 +v -0.376837 0.970818 -0.116615 +v -0.387002 0.986300 -0.141880 +v -0.399066 0.995090 -0.175091 +v -0.416098 1.009852 -0.221187 +v -0.434954 1.020856 -0.274017 +v -0.453032 1.020770 -0.328247 +v -0.469636 1.009596 -0.381793 +v -0.325477 0.974144 -0.138850 +v -0.338622 0.989433 -0.162825 +v -0.355525 0.997910 -0.193941 +v -0.379070 1.012250 -0.237218 +v -0.405861 1.022741 -0.286613 +v -0.432992 1.022068 -0.336923 +v -0.459420 1.010258 -0.386215 +v -0.415446 0.857282 -0.444361 +v -0.417073 0.866694 -0.445501 +v -0.432496 1.017174 -0.370947 +v -0.420489 1.015045 -0.382225 +v -0.406800 1.020138 -0.356382 +v -0.446078 1.009213 -0.396135 +v -0.410815 1.011451 -0.395240 +v -0.392511 1.016366 -0.372392 +v -0.438798 1.007291 -0.404292 +v -0.403845 1.006532 -0.409491 +v -0.433209 1.004433 -0.413448 +v -0.381542 1.010756 -0.390363 +v -0.399848 1.000475 -0.424432 +v -0.374314 1.003522 -0.409602 +v -0.429526 1.000747 -0.423250 +v -0.398976 0.993514 -0.439488 +v -0.371104 0.994942 -0.429372 +v -0.427891 0.996376 -0.433322 +v -0.401264 0.985916 -0.454079 +v -0.372038 0.985347 -0.448912 +v -0.428367 0.991487 -0.443278 +v -0.406623 0.977974 -0.467647 +v -0.430935 0.986269 -0.452733 +v -0.377078 0.975105 -0.467471 +v -0.414848 0.969991 -0.479669 +v -0.386031 0.964609 -0.484336 +v -0.435496 0.980922 -0.461325 +v -0.425622 0.962276 -0.489683 +v -0.398552 0.954263 -0.498859 +v -0.441876 0.975651 -0.468725 +v -0.438531 0.955124 -0.497304 +v -0.414161 0.944465 -0.510482 +v -0.449828 0.970659 -0.474646 +v -0.453080 0.948811 -0.502240 +v -0.459048 0.966137 -0.478863 +v -0.432258 0.935591 -0.518758 +v -0.468709 0.943579 -0.504300 +v -0.452147 0.927981 -0.523369 +v -0.469181 0.962261 -0.481212 +v -0.484818 0.939629 -0.503407 +v -0.473065 0.921930 -0.524138 +v -0.479838 0.959177 -0.481604 +v -0.500787 0.937113 -0.499593 +v -0.494206 0.917668 -0.521035 +v -0.490609 0.957006 -0.480023 +v -0.516003 0.936127 -0.493006 +v -0.514759 0.915360 -0.514180 +v -0.501081 0.955831 -0.476531 +v -0.529881 0.936710 -0.483898 +v -0.533934 0.915095 -0.503836 +v -0.510850 0.955695 -0.471260 +v -0.540733 0.936655 -0.470678 +v -0.550994 0.916883 -0.490401 +v -0.517062 0.957178 -0.461155 +v -0.550829 0.939020 -0.457830 +v -0.565283 0.920654 -0.474390 +v -0.526043 0.955162 -0.453987 +v -0.557939 0.943609 -0.443723 +v -0.576252 0.926265 -0.456420 +v -0.532387 0.956737 -0.445250 +v -0.561669 0.949869 -0.428975 +v -0.583480 0.933499 -0.437180 +v -0.536014 0.960367 -0.435597 +v -0.561843 0.957783 -0.414486 +v -0.520832 0.975010 -0.425454 +v -0.586689 0.942078 -0.417410 +v -0.536532 0.965659 -0.426069 +v -0.561113 0.967968 -0.400765 +v -0.585756 0.951673 -0.397871 +v -0.533283 0.973412 -0.417979 +v -0.555753 0.975910 -0.387198 +v -0.580716 0.961916 -0.379312 +v -0.534685 0.979550 -0.407818 +v -0.547529 0.983893 -0.375176 +v -0.530123 0.984897 -0.399225 +v -0.571763 0.972411 -0.362447 +v -0.536754 0.991608 -0.365162 +v -0.559242 0.982757 -0.347924 +v -0.523744 0.990168 -0.391826 +v -0.523845 0.998760 -0.357541 +v -0.543633 0.992555 -0.336301 +v -0.515791 0.995160 -0.385904 +v -0.509296 1.005073 -0.352605 +v -0.525536 1.001430 -0.328025 +v -0.506571 0.999681 -0.381688 +v -0.493667 1.010305 -0.350544 +v -0.496438 1.003558 -0.379339 +v -0.505646 1.009039 -0.323414 +v -0.477559 1.014255 -0.351438 +v -0.484729 1.015090 -0.322645 +v -0.485781 1.006641 -0.378947 +v -0.461589 1.016771 -0.355252 +v -0.463588 1.019352 -0.325747 +v -0.475010 1.008812 -0.380527 +v -0.446374 1.017757 -0.361839 +v -0.443035 1.021660 -0.332602 +v -0.464539 1.009988 -0.384020 +v -0.467412 1.000360 -0.413046 +v -0.463357 0.999641 -0.416855 +v -0.460089 0.998427 -0.421251 +v -0.457735 0.996765 -0.426065 +v -0.456385 0.994720 -0.431111 +v -0.456091 0.992368 -0.436197 +v -0.456863 0.989802 -0.441125 +v -0.458674 0.987119 -0.445708 +v -0.461452 0.984423 -0.449768 +v -0.465091 0.981817 -0.453151 +v -0.469451 0.979402 -0.455725 +v -0.474365 0.977269 -0.457392 +v -0.479644 0.975502 -0.458088 +v -0.485085 0.974168 -0.457786 +v -0.490479 0.973318 -0.456498 +v -0.495618 0.972985 -0.454273 +v -0.500306 0.973182 -0.451197 +v -0.511379 0.965548 -0.450617 +v -0.517597 0.964818 -0.445377 +v -0.521351 0.966678 -0.438652 +v -0.522773 0.969998 -0.431599 +v -0.510855 0.983740 -0.423117 +v -0.509045 0.986422 -0.418535 +v -0.506266 0.989119 -0.414474 +v -0.502627 0.991724 -0.411092 +v -0.498267 0.994140 -0.408518 +v -0.493353 0.996272 -0.406851 +v -0.488074 0.998040 -0.406155 +v -0.482633 0.999374 -0.406457 +v -0.477239 1.000224 -0.407745 +v -0.472100 1.000557 -0.409970 +v -0.454769 1.010123 -0.389290 +v -0.423860 1.021925 -0.342946 +v -0.426497 1.016246 -0.376617 +v -0.415652 1.013384 -0.388769 +v -0.407326 1.009125 -0.402409 +v -0.401839 1.003634 -0.417013 +v -0.399404 0.997122 -0.432018 +v -0.400112 0.989839 -0.446849 +v -0.403937 0.982065 -0.460936 +v -0.410733 0.974099 -0.473737 +v -0.420237 0.966246 -0.484760 +v -0.432085 0.958809 -0.493582 +v -0.445820 0.952073 -0.499864 +v -0.460917 0.946298 -0.503364 +v -0.476793 0.941704 -0.503947 +v -0.492840 0.938470 -0.501592 +v -0.508440 0.936718 -0.496389 +v -0.522994 0.936517 -0.488538 +v -0.534619 0.936980 -0.476557 +v -0.545722 0.937873 -0.464221 +v -0.554352 0.941408 -0.450806 +v -0.559776 0.946836 -0.436369 +v -0.561683 0.953847 -0.421735 +v -0.560447 0.962830 -0.407806 +v -0.558503 0.972054 -0.394021 +v -0.551708 0.980021 -0.381220 +v -0.542203 0.987873 -0.370197 +v -0.530356 0.995311 -0.361375 +v -0.516620 1.002046 -0.355094 +v -0.501524 1.007822 -0.351594 +v -0.485647 1.012415 -0.351010 +v -0.469600 1.015650 -0.353365 +v -0.454000 1.017401 -0.358568 +v -0.439446 1.017603 -0.366419 +vn 0.210974 0.967528 0.139164 +vn 0.223701 0.962066 0.156041 +vn 0.306406 0.950591 0.049532 +vn 0.124363 0.991882 0.025971 +vn 0.203894 0.977783 -0.048402 +vn 0.022462 0.994324 -0.103732 +vn 0.291482 0.924070 0.247169 +vn 0.361278 0.866878 0.343425 +vn 0.400739 0.904691 0.144536 +vn 0.321390 0.944731 0.064272 +vn 0.400098 0.915494 -0.041566 +vn 0.383282 0.922025 -0.053865 +vn 0.081088 0.983428 -0.162053 +vn 0.267800 0.954039 -0.134404 +vn 0.481491 0.845576 0.230537 +vn 0.488784 0.871975 0.026124 +vn 0.552202 0.827204 -0.103549 +vn 0.438704 0.882931 -0.167150 +vn 0.313883 0.921506 -0.228614 +vn 0.128025 0.965697 -0.225837 +vn 0.578326 0.809595 0.100253 +vn 0.648091 0.760338 -0.042390 +vn 0.688131 0.699728 -0.191961 +vn 0.456801 0.875484 -0.157537 +vn 0.489334 0.826197 -0.279092 +vn 0.470473 0.834803 -0.285897 +vn 0.161718 0.941496 -0.295572 +vn 0.340281 0.881497 -0.327342 +vn 0.180883 0.911802 -0.368603 +vn 0.346233 0.835414 -0.426771 +vn 0.588580 0.772088 -0.239509 +vn 0.696829 0.630024 -0.342662 +vn 0.496445 0.769555 -0.401593 +vn 0.477401 0.779473 -0.405560 +vn 0.459212 0.719077 -0.521531 +vn 0.330699 0.785363 -0.523240 +vn 0.175787 0.840907 -0.511795 +vn 0.596515 0.708762 -0.376537 +vn 0.575701 0.639607 -0.509323 +vn 0.477828 0.707724 -0.520341 +vn 0.526933 0.567339 -0.632801 +vn 0.416608 0.655934 -0.629383 +vn 0.295480 0.732780 -0.612934 +vn 0.673940 0.553972 -0.488754 +vn 0.620289 0.474471 -0.624561 +vn 0.452101 0.494675 -0.742180 +vn 0.434217 0.643117 -0.630726 +vn 0.367290 0.578173 -0.728538 +vn 0.351238 0.592517 -0.724937 +vn 0.146641 0.801691 -0.579424 +vn 0.241310 0.679922 -0.692404 +vn 0.169958 0.629078 -0.758507 +vn 0.056154 0.726920 -0.684378 +vn 0.537950 0.394574 -0.744896 +vn 0.430097 0.317331 -0.845149 +vn 0.279611 0.515397 -0.810022 +vn 0.265603 0.531175 -0.804529 +vn 0.174596 0.457198 -0.872036 +vn 0.084658 0.581805 -0.808893 +vn -0.006653 0.691916 -0.721915 +vn 0.354045 0.424482 -0.833338 +vn 0.300882 0.245735 -0.921445 +vn 0.236549 0.359386 -0.902676 +vn 0.104160 0.301950 -0.947600 +vn 0.162999 0.474349 -0.865078 +vn 0.047365 0.424177 -0.904324 +vn -0.011475 0.540086 -0.841517 +vn -0.077548 0.660939 -0.746391 +vn 0.155217 0.182531 -0.970855 +vn -0.038057 0.254341 -0.966338 +vn 0.056215 0.405835 -0.912198 +vn -0.070925 0.363262 -0.928953 +vn -0.076815 0.382580 -0.920713 +vn -0.114841 0.505661 -0.855037 +vn -0.155278 0.633076 -0.758324 +vn -0.221229 0.479171 -0.849361 +vn -0.001190 0.130161 -0.991485 +vn -0.162450 0.090609 -0.982513 +vn -0.202002 0.331126 -0.921690 +vn -0.204871 0.351177 -0.913602 +vn -0.326762 0.462752 -0.824030 +vn -0.310526 0.603320 -0.734519 +vn -0.184637 0.218390 -0.958220 +vn -0.329966 0.195471 -0.923521 +vn -0.331919 0.310648 -0.890652 +vn -0.331767 0.331187 -0.883297 +vn -0.455733 0.302622 -0.837062 +vn -0.452712 0.323344 -0.830927 +vn -0.427290 0.456435 -0.780389 +vn -0.387432 0.596515 -0.702872 +vn -0.322306 0.065432 -0.944365 +vn -0.468429 0.186529 -0.863552 +vn -0.474624 0.055574 -0.878414 +vn -0.594714 0.191809 -0.780694 +vn -0.568651 0.307352 -0.762963 +vn -0.563005 0.327982 -0.758538 +vn -0.519089 0.460097 -0.720267 +vn -0.457930 0.613758 -0.643086 +vn -0.598437 0.474166 -0.645741 +vn -0.613544 0.061403 -0.787225 +vn -0.733757 0.082705 -0.674337 +vn -0.704001 0.211188 -0.678060 +vn -0.658437 0.344920 -0.668905 +vn -0.662465 0.497726 -0.559771 +vn -0.491714 0.649556 -0.579852 +vn -0.792016 0.243904 -0.559618 +vn -0.666341 0.324686 -0.671194 +vn -0.745079 0.353923 -0.565294 +vn -0.735343 0.373455 -0.565447 +vn -0.855464 0.288675 -0.429914 +vn -0.801782 0.393963 -0.449324 +vn -0.708274 0.530595 -0.465590 +vn -0.547624 0.694357 -0.466811 +vn -0.830592 0.118686 -0.544053 +vn -0.900357 0.167943 -0.401379 +vn -0.891842 0.343791 -0.293954 +vn -0.790735 0.412580 -0.452193 +vn -0.822504 0.460707 -0.333445 +vn -0.734977 0.570269 -0.366771 +vn -0.740440 0.616596 -0.267403 +vn -0.581835 0.737846 -0.342082 +vn -0.940367 0.228553 -0.251839 +vn -0.899777 0.407117 -0.156926 +vn -0.834315 0.443251 -0.327769 +vn -0.841395 0.499863 -0.205267 +vn -0.829432 0.516037 -0.213782 +vn -0.725455 0.666677 -0.170843 +vn -0.949095 0.298257 -0.101108 +vn -0.926206 0.374310 0.044923 +vn -0.878933 0.476272 -0.024140 +vn -0.822779 0.561693 -0.086550 +vn -0.811243 0.576434 -0.097812 +vn -0.779168 0.626331 0.023835 +vn -0.690023 0.719169 -0.081179 +vn -0.597766 0.756615 -0.264870 +vn -0.872555 0.453810 0.180761 +vn -0.830164 0.548540 0.099307 +vn -0.790216 0.533708 0.301096 +vn -0.755333 0.621204 0.208686 +vn -0.768670 0.639546 0.010010 +vn -0.712241 0.691275 0.121647 +vn -0.635823 0.771813 -0.001617 +vn -0.580157 0.793603 -0.183233 +vn -0.564531 0.822871 0.064364 +vn -0.489669 0.868374 -0.078310 +vn -0.682363 0.610950 0.401349 +vn -0.624592 0.754051 0.203131 +vn -0.703299 0.702994 0.105564 +vn -0.617664 0.764306 0.185156 +vn -0.479110 0.870235 0.114536 +vn -0.425916 0.903958 -0.037935 +vn -0.657277 0.691397 0.299814 +vn -0.553117 0.682546 0.477615 +vn -0.519547 0.812250 0.265114 +vn -0.515030 0.821162 0.245735 +vn -0.401166 0.863613 0.305277 +vn -0.382977 0.911893 0.147374 +vn -0.539781 0.756493 0.369182 +vn -0.407483 0.745750 0.527055 +vn -0.407392 0.813929 0.414106 +vn -0.251045 0.798120 0.547655 +vn -0.273995 0.906186 0.322062 +vn -0.399426 0.871334 0.284951 +vn -0.275185 0.912931 0.301340 +vn -0.352153 0.935789 -0.015412 +vn -0.279733 0.946440 0.161199 +vn -0.173315 0.972564 0.155065 +vn -0.201025 0.979522 -0.009857 +vn -0.265175 0.861568 0.432844 +vn -0.089785 0.837672 0.538713 +vn -0.142918 0.938322 0.314798 +vn -0.147160 0.944304 0.294229 +vn -0.067812 0.989227 0.129643 +vn -0.120304 0.992370 -0.026673 +vn -0.118564 0.897488 0.424726 +vn 0.070040 0.862850 0.500534 +vn -0.013001 0.958800 0.283761 +vn -0.020234 0.964324 0.263924 +vn 0.110782 0.966796 0.230171 +vn 0.032899 0.995697 0.086520 +vn 0.026734 0.920408 0.389996 +vn 0.222358 0.872707 0.434584 +vn 0.165197 0.929380 0.330058 +vn 0.100681 0.972137 0.211554 +vn 0.048250 0.989959 -0.132664 +vn 0.101382 0.976196 -0.191687 +vn 0.142277 0.955596 -0.258034 +vn 0.169347 0.928953 -0.329112 +vn 0.181585 0.897305 -0.402234 +vn 0.182653 0.879025 -0.440382 +vn 0.177984 0.860134 -0.477950 +vn 0.160222 0.824030 -0.543352 +vn 0.127415 0.785211 -0.605914 +vn 0.105502 0.764672 -0.635701 +vn 0.078921 0.745140 -0.662191 +vn 0.020936 0.708975 -0.704917 +vn -0.046175 0.676229 -0.735221 +vn -0.119877 0.648213 -0.751946 +vn -0.193609 0.626881 -0.754662 +vn -0.234596 0.617054 -0.751091 +vn -0.275491 0.610370 -0.742637 +vn -0.351451 0.602008 -0.716941 +vn -0.419050 0.601062 -0.680502 +vn -0.463057 0.637104 -0.616138 +vn -0.495712 0.667684 -0.555345 +vn -0.517838 0.675344 -0.525040 +vn -0.528306 0.690207 -0.494400 +vn -0.549638 0.711570 -0.437605 +vn -0.562700 0.720267 -0.405621 +vn -0.564898 0.736930 -0.371197 +vn -0.582324 0.754143 -0.303507 +vn -0.594317 0.773431 -0.220344 +vn -0.561510 0.812250 -0.157781 +vn -0.539445 0.832240 -0.127750 +vn -0.513016 0.852321 -0.101535 +vn -0.455031 0.888516 -0.058809 +vn -0.391247 0.919797 -0.029633 +vn -0.317789 0.948057 -0.012238 +vn -0.277627 0.960631 -0.007996 +vn -0.236763 0.971496 -0.009247 +vn -0.158574 0.987091 -0.021088 +vn -0.086123 0.995239 -0.045228 +vn -0.047731 0.996857 -0.062899 +vn -0.011841 0.996277 -0.085299 +vn -0.194830 0.936521 -0.291391 +vn -0.156560 0.954192 -0.254860 +vn -0.133274 0.951018 -0.278878 +vn -0.158269 0.929136 -0.334117 +vn -0.113315 0.945433 -0.305368 +vn -0.094485 0.938383 -0.332347 +vn -0.129734 0.915311 -0.381207 +vn -0.079562 0.929136 -0.361034 +vn -0.065950 0.918455 -0.389904 +vn -0.110324 0.895688 -0.430738 +vn -0.056612 0.905881 -0.419691 +vn -0.048708 0.892026 -0.449293 +vn -0.100772 0.870937 -0.480880 +vn -0.045320 0.876614 -0.478988 +vn -0.043428 0.860103 -0.508225 +vn -0.101474 0.842067 -0.529679 +vn -0.046144 0.842463 -0.536729 +vn -0.050325 0.823908 -0.564470 +vn -0.112369 0.810175 -0.575304 +vn -0.059023 0.804712 -0.590686 +vn -0.069155 0.784814 -0.615833 +vn -0.133061 0.776452 -0.615925 +vn -0.083499 0.764824 -0.638783 +vn -0.099124 0.744346 -0.660390 +vn -0.162725 0.742210 -0.650075 +vn -0.118595 0.724326 -0.679159 +vn -0.139164 0.704031 -0.696371 +vn -0.200262 0.708792 -0.676382 +vn -0.162969 0.684774 -0.710257 +vn -0.187689 0.665456 -0.722434 +vn -0.244209 0.677450 -0.693838 +vn -0.214972 0.647725 -0.730888 +vn -0.242836 0.630085 -0.737541 +vn -0.292825 0.649373 -0.701773 +vn -0.272530 0.614551 -0.740287 +vn -0.302469 0.599292 -0.741172 +vn -0.344371 0.625690 -0.699911 +vn -0.333445 0.586535 -0.738060 +vn -0.364360 0.574236 -0.733116 +vn -0.396741 0.607318 -0.688253 +vn -0.395428 0.564776 -0.724326 +vn -0.426069 0.555864 -0.713736 +vn -0.447981 0.594897 -0.667348 +vn -0.456008 0.550066 -0.699576 +vn -0.485275 0.544939 -0.683737 +vn -0.496109 0.588946 -0.637928 +vn -0.512986 0.543046 -0.664754 +vn -0.539628 0.541856 -0.644307 +vn -0.539293 0.589709 -0.601123 +vn -0.564043 0.543931 -0.621235 +vn -0.587146 0.546709 -0.596942 +vn -0.575823 0.597125 -0.558397 +vn -0.607288 0.552690 -0.570696 +vn -0.625904 0.559313 -0.543474 +vn -0.604358 0.610920 -0.511338 +vn -0.641011 0.568987 -0.515061 +vn -0.654439 0.579241 -0.485977 +vn -0.623768 0.630543 -0.461806 +vn -0.663991 0.592242 -0.456435 +vn -0.671682 0.605670 -0.426557 +vn -0.633320 0.655263 -0.411664 +vn -0.675283 0.621509 -0.397107 +vn -0.676962 0.637593 -0.367595 +vn -0.632618 0.684164 -0.362835 +vn -0.674459 0.655660 -0.339366 +vn -0.670064 0.673788 -0.311411 +vn -0.621723 0.716086 -0.317240 +vn -0.661580 0.693411 -0.285409 +vn -0.651234 0.712912 -0.259987 +vn -0.601062 0.749779 -0.276620 +vn -0.637104 0.733299 -0.237312 +vn -0.621265 0.753349 -0.215491 +vn -0.571368 0.784020 -0.242439 +vn -0.602008 0.773797 -0.196966 +vn -0.581225 0.793664 -0.179510 +vn -0.533860 0.817469 -0.216132 +vn -0.557604 0.813349 -0.165868 +vn -0.532701 0.832240 -0.153417 +vn -0.489914 0.848781 -0.198706 +vn -0.505631 0.850429 -0.145177 +vn -0.477523 0.867641 -0.138279 +vn -0.441237 0.876858 -0.190741 +vn -0.448073 0.883602 -0.135807 +vn -0.417890 0.898434 -0.134709 +vn -0.389752 0.900510 -0.192633 +vn -0.387127 0.911618 -0.138035 +vn -0.356029 0.923490 -0.142735 +vn -0.337352 0.918943 -0.204260 +vn -0.325175 0.933378 -0.151769 +vn -0.294290 0.941832 -0.162114 +vn -0.286111 0.931333 -0.225196 +vn -0.264534 0.948057 -0.176519 +vn -0.235115 0.952757 -0.192083 +vn -0.383465 0.797235 -0.466201 +vn -0.328898 0.853908 -0.403272 +vn -0.314951 0.852504 -0.417158 +vn -0.303568 0.848781 -0.432844 +vn -0.295206 0.842921 -0.449751 +vn -0.290139 0.835170 -0.467208 +vn -0.288583 0.825800 -0.484451 +vn -0.290628 0.815210 -0.500931 +vn -0.296152 0.803735 -0.515976 +vn -0.304941 0.791864 -0.529069 +vn -0.316660 0.780023 -0.539659 +vn -0.330912 0.768731 -0.547258 +vn -0.347118 0.758324 -0.551744 +vn -0.364574 0.749290 -0.552812 +vn -0.382702 0.741966 -0.550432 +vn -0.400830 0.736564 -0.544755 +vn -0.418165 0.733360 -0.535966 +vn -0.434126 0.732444 -0.524400 +vn -0.448073 0.733909 -0.510453 +vn -0.459426 0.737571 -0.494827 +vn -0.467818 0.743431 -0.477950 +vn -0.472884 0.751183 -0.460524 +vn -0.474410 0.760521 -0.443251 +vn -0.472396 0.771172 -0.426710 +vn -0.466872 0.782617 -0.411664 +vn -0.458083 0.794488 -0.398602 +vn -0.446364 0.806299 -0.388043 +vn -0.432112 0.817621 -0.380413 +vn -0.415937 0.828028 -0.375958 +vn -0.398450 0.837062 -0.374889 +vn -0.380291 0.844386 -0.377270 +vn -0.362163 0.849788 -0.382946 +vn -0.344859 0.852962 -0.391766 +vn -0.238014 0.937284 -0.254616 +vn -0.207617 0.955077 -0.211310 +vn -0.180731 0.955870 -0.231513 +vn -0.259590 0.899075 -0.352489 +vn -0.172674 0.934965 -0.309793 +vn -0.271981 0.901151 -0.337535 +vn -0.213233 0.939116 -0.269326 +vn -0.234840 0.894070 -0.381420 +vn -0.139531 0.924161 -0.355510 +vn -0.244514 0.898312 -0.364971 +vn -0.215583 0.884732 -0.413160 +vn -0.115146 0.907163 -0.404675 +vn -0.222114 0.891018 -0.395856 +vn -0.202429 0.871456 -0.446669 +vn -0.100406 0.884548 -0.455458 +vn -0.205603 0.879513 -0.429121 +vn -0.196020 0.854762 -0.480544 +vn -0.095889 0.857295 -0.505783 +vn -0.195624 0.864193 -0.463515 +vn -0.196448 0.835170 -0.513627 +vn -0.101779 0.826319 -0.553880 +vn -0.192572 0.845759 -0.497574 +vn -0.203833 0.813623 -0.544450 +vn -0.117862 0.792932 -0.597736 +vn -0.196570 0.824793 -0.530137 +vn -0.217811 0.790857 -0.571886 +vn -0.143498 0.758354 -0.635823 +vn -0.207465 0.802149 -0.559862 +vn -0.237861 0.767693 -0.595019 +vn -0.177709 0.723899 -0.666585 +vn -0.224799 0.778771 -0.585620 +vn -0.263253 0.745048 -0.612812 +vn -0.219184 0.690939 -0.688864 +vn -0.247963 0.755455 -0.606433 +vn -0.292947 0.723869 -0.624622 +vn -0.266274 0.660665 -0.701834 +vn -0.276040 0.733116 -0.621540 +vn -0.325877 0.704947 -0.629933 +vn -0.317301 0.634358 -0.704886 +vn -0.307932 0.712668 -0.630268 +vn -0.360698 0.688894 -0.628712 +vn -0.370159 0.612934 -0.698019 +vn -0.342448 0.694845 -0.632344 +vn -0.396130 0.676443 -0.620838 +vn -0.422926 0.597278 -0.681448 +vn -0.378246 0.680319 -0.627735 +vn -0.430769 0.668050 -0.606708 +vn -0.473525 0.587909 -0.655812 +vn -0.413953 0.669698 -0.616504 +vn -0.463332 0.664052 -0.586779 +vn -0.519974 0.585284 -0.622120 +vn -0.448195 0.663411 -0.599139 +vn -0.492508 0.664541 -0.561937 +vn -0.560564 0.589435 -0.581622 +vn -0.479659 0.661580 -0.576342 +vn -0.517228 0.669576 -0.533006 +vn -0.593677 0.600238 -0.535905 +vn -0.507096 0.664418 -0.548936 +vn -0.536515 0.678854 -0.501236 +vn -0.618061 0.617237 -0.486770 +vn -0.529557 0.671712 -0.518021 +vn -0.549669 0.692190 -0.467635 +vn -0.632832 0.639821 -0.436018 +vn -0.546068 0.683218 -0.484725 +vn -0.556078 0.708884 -0.433821 +vn -0.637318 0.667135 -0.385632 +vn -0.556047 0.698538 -0.450331 +vn -0.555620 0.728416 -0.400800 +vn -0.631428 0.698050 -0.337565 +vn -0.559099 0.717002 -0.416272 +vn -0.548265 0.749992 -0.369945 +vn -0.615345 0.731468 -0.293710 +vn -0.555101 0.737938 -0.383709 +vn -0.534288 0.772820 -0.342418 +vn -0.589709 0.766076 -0.255593 +vn -0.544206 0.760552 -0.354015 +vn -0.514206 0.795953 -0.319376 +vn -0.555528 0.800501 -0.224830 +vn -0.526841 0.783990 -0.328227 +vn -0.488815 0.818567 -0.301614 +vn -0.514054 0.833461 -0.202612 +vn -0.503708 0.807276 -0.307443 +vn -0.459120 0.839747 -0.289773 +vn -0.466933 0.863704 -0.189642 +vn -0.475631 0.829615 -0.292337 +vn -0.426221 0.858730 -0.284402 +vn -0.415937 0.890011 -0.186560 +vn -0.443709 0.850093 -0.283578 +vn -0.391369 0.874722 -0.285714 +vn -0.363018 0.911466 -0.193426 +vn -0.409223 0.867916 -0.281503 +vn -0.355998 0.887173 -0.293558 +vn -0.310312 0.927122 -0.209998 +vn -0.373424 0.882382 -0.286172 +vn -0.321329 0.895566 -0.307657 +vn -0.259713 0.936460 -0.235664 +vn -0.337718 0.893002 -0.297372 +vn -0.303446 0.899350 -0.314707 +vn -0.288736 0.899594 -0.327616 +vn -0.040223 0.973144 -0.226539 +vn -0.003021 0.963347 -0.268227 +vn 0.025513 0.948729 -0.315012 +vn 0.044313 0.929899 -0.365093 +vn 0.052675 0.907559 -0.416547 +vn 0.050233 0.882595 -0.467422 +vn 0.037141 0.855922 -0.515732 +vn 0.013825 0.828578 -0.559648 +vn -0.018738 0.801660 -0.597461 +vn -0.059389 0.776147 -0.627705 +vn -0.106479 0.753044 -0.649251 +vn -0.158269 0.733238 -0.661245 +vn -0.212714 0.717490 -0.663259 +vn -0.267769 0.706381 -0.655171 +vn -0.321268 0.700400 -0.637349 +vn -0.371197 0.699698 -0.610401 +vn -0.511979 0.737114 -0.441054 +vn -0.426923 0.764824 -0.482437 +vn -0.423017 0.776543 -0.466933 +vn -0.432417 0.785943 -0.441908 +vn -0.447127 0.785028 -0.428663 +vn -0.495315 0.720420 -0.485397 +vn -0.492965 0.821589 -0.286233 +vn -0.469680 0.848903 -0.242317 +vn -0.437086 0.875851 -0.204505 +vn -0.396435 0.901334 -0.174261 +vn -0.349315 0.924467 -0.152715 +vn -0.297555 0.944243 -0.140721 +vn -0.243080 0.960021 -0.138707 +vn -0.188055 0.971099 -0.146794 +vn -0.134556 0.977111 -0.164617 +vn -0.268075 0.864223 -0.425642 +vn -0.179052 0.919553 -0.349712 +vn -0.164800 0.917020 -0.363109 +vn -0.153325 0.912778 -0.378552 +vn -0.145054 0.906919 -0.395489 +vn -0.140294 0.899747 -0.413221 +vn -0.139256 0.891476 -0.431104 +vn -0.141972 0.882443 -0.448439 +vn -0.148350 0.873012 -0.464553 +vn -0.158116 0.863521 -0.478805 +vn -0.170904 0.854366 -0.490707 +vn -0.186224 0.845882 -0.499771 +vn -0.203497 0.838374 -0.505631 +vn -0.222053 0.832179 -0.508072 +vn -0.241188 0.827479 -0.507004 +vn -0.260170 0.824488 -0.502487 +vn -0.278237 0.823328 -0.494644 +vn -0.435316 0.832057 -0.343669 +vn -0.492935 0.797113 -0.348735 +vn -0.424390 0.795648 -0.432173 +vn -0.409894 0.792291 -0.451888 +vn -0.408918 0.780175 -0.473373 +vn -0.413160 0.717277 -0.561052 +vn -0.357555 0.754265 -0.550645 +vn -0.325449 0.870571 -0.369030 +vn -0.315683 0.880032 -0.354747 +vn -0.302866 0.889187 -0.342845 +vn -0.287545 0.897702 -0.333811 +vn -0.270272 0.905179 -0.327921 +vn -0.251717 0.911405 -0.325480 +vn -0.232582 0.916105 -0.326548 +vn -0.213599 0.919095 -0.331065 +vn -0.195532 0.920255 -0.338908 +vn -0.084628 0.977813 -0.191565 +vn -0.106571 0.950163 -0.292856 +vn -0.017609 0.969573 -0.244118 +vn -0.119327 0.953032 -0.278298 +vn -0.059175 0.976928 -0.205115 +vn -0.081423 0.943541 -0.321024 +vn 0.015809 0.957121 -0.289163 +vn -0.091189 0.948057 -0.304727 +vn -0.062105 0.933683 -0.352641 +vn 0.039918 0.940123 -0.338450 +vn -0.068545 0.939634 -0.335215 +vn -0.049379 0.920927 -0.386547 +vn 0.053774 0.919156 -0.390149 +vn -0.052217 0.928098 -0.368572 +vn -0.043733 0.905820 -0.421339 +vn 0.056764 0.895077 -0.442244 +vn -0.042848 0.913938 -0.403577 +vn -0.045381 0.888943 -0.455733 +vn 0.048860 0.868801 -0.492721 +vn -0.040803 0.897610 -0.438826 +vn -0.054262 0.870907 -0.488418 +vn 0.030305 0.841304 -0.539659 +vn -0.046175 0.879818 -0.473006 +vn -0.070009 0.852443 -0.518082 +vn 0.001862 0.813685 -0.581256 +vn -0.058718 0.861232 -0.504776 +vn -0.092074 0.834223 -0.543657 +vn -0.035371 0.786981 -0.615925 +vn -0.077975 0.842524 -0.532945 +vn -0.119541 0.816950 -0.564135 +vn -0.080050 0.762261 -0.642293 +vn -0.103214 0.824458 -0.556383 +vn -0.151402 0.801355 -0.578692 +vn -0.130375 0.740410 -0.659352 +vn -0.133457 0.807703 -0.574236 +vn -0.186407 0.787957 -0.586810 +vn -0.184454 0.722312 -0.666494 +vn -0.167547 0.792932 -0.585803 +vn -0.223212 0.777306 -0.588153 +vn -0.240181 0.708640 -0.663381 +vn -0.204138 0.780663 -0.590625 +vn -0.260445 0.769799 -0.582690 +vn -0.295450 0.699942 -0.650197 +vn -0.241859 0.771416 -0.588519 +vn -0.296609 0.765740 -0.570635 +vn -0.348094 0.696524 -0.627400 +vn -0.279275 0.765526 -0.579608 +vn -0.330393 0.765282 -0.552416 +vn -0.494949 0.705496 -0.507218 +vn -0.314890 0.763207 -0.564165 +vn -0.552904 0.768364 -0.322275 +vn -0.457961 0.759026 -0.462691 +vn -0.489914 0.762749 -0.422071 +vn -0.447127 0.776940 -0.443159 +vn -0.423292 0.771905 -0.474288 +vn -0.491501 0.773614 -0.399884 +vn -0.428724 0.778161 -0.458907 +vn -0.427625 0.781396 -0.454451 +vn -0.433607 0.777703 -0.455092 +vn -0.431806 0.781243 -0.450697 +vn -0.437971 0.786584 -0.435255 +vn -0.428968 0.780541 -0.454634 +vn -0.437239 0.766991 -0.469558 +vn -0.461043 0.762108 -0.454512 +vn -0.433454 0.777581 -0.455458 +vn -0.450789 0.666128 -0.594134 +vn -0.527757 0.738304 -0.419874 +vn -0.447188 0.729270 -0.517838 +vn -0.412732 0.847682 -0.333201 +vn -0.485611 0.834162 -0.261330 +vn -0.461348 0.734153 -0.498123 +vn -0.396985 0.866176 -0.303507 +vn -0.457167 0.861782 -0.219733 +vn -0.408002 0.856380 -0.316355 +vn -0.374920 0.884365 -0.277963 +vn -0.419874 0.888485 -0.185095 +vn -0.388745 0.875088 -0.288217 +vn -0.347453 0.901639 -0.257485 +vn -0.375225 0.913236 -0.158727 +vn -0.363506 0.893155 -0.264748 +vn -0.315592 0.917234 -0.242927 +vn -0.324870 0.935057 -0.141636 +vn -0.333262 0.909909 -0.246895 +vn -0.280587 0.930631 -0.234809 +vn -0.270821 0.953154 -0.134526 +vn -0.299203 0.924680 -0.235359 +vn -0.243751 0.941282 -0.233467 +vn -0.215064 0.966826 -0.137608 +vn -0.262581 0.936949 -0.230506 +vn -0.206549 0.948790 -0.238929 +vn -0.159825 0.975524 -0.150792 +vn -0.224860 0.946196 -0.232612 +vn -0.170354 0.952849 -0.250984 +vn -0.107181 0.978942 -0.173589 +vn -0.187445 0.952086 -0.241554 +vn -0.151830 0.954405 -0.256966 +vn -0.136601 0.953337 -0.269204 +usemtl Eye-White +s 1 +f 6977//4534 6976//4535 6984//4536 +f 6978//4537 6977//4534 6985//4538 +f 6979//4539 6978//4537 6985//4538 +f 6975//4540 6974//4541 6982//4542 +f 6976//4535 6975//4540 6983//4543 +f 6984//4536 6983//4543 6990//4544 +f 6985//4538 6984//4536 6991//4545 +f 6986//4546 6985//4538 6992//4547 +f 6982//4542 6981//4548 6989//4549 +f 6983//4543 6982//4542 6989//4549 +f 6990//4544 6989//4549 6996//4550 +f 6991//4545 6990//4544 6998//4551 +f 6992//4547 6991//4545 6999//4552 +f 6993//4553 6992//4547 6999//4552 +f 6989//4549 6988//4554 6996//4550 +f 6996//4550 6995//4555 7002//4556 +f 6997//4557 6996//4550 7004//4558 +f 6998//4551 6997//4557 7005//4559 +f 6999//4552 6998//4551 7005//4559 +f 7000//4560 6999//4552 7006//4561 +f 7007//4562 7006//4561 7013//4563 +f 7003//4564 7002//4556 7009//4565 +f 7004//4558 7003//4564 7011//4566 +f 7005//4559 7004//4558 7011//4566 +f 7006//4561 7005//4559 7013//4563 +f 7012//4567 7011//4566 7019//4568 +f 7013//4563 7012//4567 7020//4569 +f 7013//4563 7020//4569 7021//4570 +f 7010//4571 7009//4565 7017//4572 +f 7011//4566 7010//4571 7018//4573 +f 7018//4573 7017//4572 7024//4574 +f 7019//4568 7018//4573 7026//4575 +f 7020//4569 7019//4568 7026//4575 +f 7021//4570 7020//4569 7027//4576 +f 7017//4572 7016//4577 7024//4574 +f 7024//4574 7023//4578 7031//4579 +f 7025//4580 7024//4574 7032//4581 +f 7026//4575 7025//4580 7033//4582 +f 7027//4576 7026//4575 7033//4582 +f 7028//4583 7027//4576 7034//4584 +f 7034//4584 7041//4585 7042//4586 +f 7031//4579 7030//4587 7037//4588 +f 7032//4581 7031//4579 7039//4589 +f 7033//4582 7032//4581 7039//4589 +f 7034//4584 7033//4582 7041//4585 +f 7040//4590 7039//4589 7046//4591 +f 7041//4585 7040//4590 7048//4592 +f 7041//4585 7048//4592 7049//4593 +f 7038//4594 7037//4588 7044//4595 +f 7039//4589 7038//4594 7046//4591 +f 7046//4591 7045//4596 7052//4597 +f 7047//4598 7046//4591 7054//4599 +f 7048//4592 7047//4598 7054//4599 +f 7048//4592 7055//4600 7056//4601 +f 7045//4596 7044//4595 7051//4602 +f 7052//4597 7051//4602 7059//4603 +f 7053//4604 7052//4597 7060//4605 +f 7054//4599 7053//4604 7061//4606 +f 7055//4600 7054//4599 7061//4606 +f 7055//4600 7062//4607 7063//4608 +f 7063//4608 7062//4607 7069//4609 +f 7059//4603 7058//4610 7065//4611 +f 7060//4605 7059//4603 7067//4612 +f 7061//4606 7060//4605 7068//4613 +f 7062//4607 7061//4606 7069//4609 +f 7069//4609 7068//4613 7076//4614 +f 7069//4609 7076//4614 7077//4615 +f 7066//4616 7065//4611 7073//4617 +f 7067//4612 7066//4616 7074//4618 +f 7068//4613 7067//4612 7075//4619 +f 7074//4618 7073//4617 7081//4620 +f 7075//4619 7074//4618 7081//4620 +f 7076//4614 7075//4619 7082//4621 +f 7076//4614 7083//4622 7084//4623 +f 7073//4617 7072//4624 7080//4625 +f 7080//4625 7079//4626 7087//4627 +f 7081//4620 7080//4625 7088//4628 +f 7082//4621 7081//4620 7089//4629 +f 7083//4622 7082//4621 7090//4630 +f 7084//4623 7083//4622 7090//4630 +f 7091//4631 7090//4630 7097//4632 +f 7087//4627 7086//4633 7093//4634 +f 7088//4628 7087//4627 7094//4635 +f 7089//4629 7088//4628 7096//4636 +f 7090//4630 7089//4629 7097//4632 +f 7097//4632 7096//4636 7104//4637 +f 7098//4638 7097//4632 7104//4637 +f 7094//4635 7093//4634 7101//4639 +f 7095//4640 7094//4635 7102//4641 +f 7096//4636 7095//4640 7103//4642 +f 7102//4641 7101//4639 7108//4643 +f 7103//4642 7102//4641 7109//4644 +f 7104//4637 7103//4642 7111//4645 +f 7104//4637 7111//4645 7112//4646 +f 7101//4639 7100//4647 7108//4643 +f 7108//4643 7107//4648 7115//4649 +f 7109//4644 7108//4643 7115//4649 +f 7110//4650 7109//4644 7117//4651 +f 7111//4645 7110//4650 7118//4652 +f 7112//4646 7111//4645 7118//4652 +f 7118//4652 7125//4653 7126//4654 +f 7115//4649 7114//4655 7122//4656 +f 7116//4657 7115//4649 7123//4658 +f 7117//4651 7116//4657 7124//4659 +f 7118//4652 7117//4651 7124//4659 +f 7125//4653 7124//4659 7133//4660 +f 7126//4654 7125//4653 7133//4660 +f 7122//4656 7121//4661 7129//4662 +f 7123//4658 7122//4656 7130//4663 +f 7124//4659 7123//4658 7131//4664 +f 7132//4665 7131//4664 7138//4666 +f 7133//4660 7132//4665 7140//4667 +f 7134//4668 7133//4660 7140//4667 +f 7130//4663 7129//4662 7136//4669 +f 7131//4664 7130//4663 7138//4666 +f 7137//4670 7136//4669 7143//4671 +f 7138//4666 7137//4670 7144//4672 +f 7139//4673 7138//4666 7145//4674 +f 7140//4667 7139//4673 7147//4675 +f 7141//4676 7140//4667 7147//4675 +f 7147//4675 7154//4677 7155//4678 +f 7144//4672 7143//4671 7150//4679 +f 7145//4674 7144//4672 7152//4680 +f 7146//4681 7145//4674 7153//4682 +f 7147//4675 7146//4681 7154//4677 +f 7154//4677 7153//4682 7161//4683 +f 7154//4677 7161//4683 7162//4684 +f 7151//4685 7150//4679 7157//4686 +f 7152//4680 7151//4685 7159//4687 +f 7153//4682 7152//4680 7160//4688 +f 7160//4688 7159//4687 7166//4689 +f 7161//4683 7160//4688 7168//4690 +f 7162//4684 7161//4683 7168//4690 +f 7158//4691 7157//4686 7164//4692 +f 7159//4687 7158//4691 7165//4693 +f 7165//4693 7164//4692 7171//4694 +f 7166//4689 7165//4693 7173//4695 +f 7167//4696 7166//4689 7173//4695 +f 7168//4690 7167//4696 7174//4697 +f 7169//4698 7168//4690 7175//4699 +f 7175//4699 7182//4700 7183//4701 +f 7172//4702 7171//4694 7178//4703 +f 7173//4695 7172//4702 7180//4704 +f 7174//4697 7173//4695 7181//4705 +f 7175//4699 7174//4697 7181//4705 +f 7182//4700 7181//4705 7189//4706 +f 7182//4700 7189//4706 7190//4707 +f 7179//4708 7178//4703 7185//4709 +f 7180//4704 7179//4708 7187//4710 +f 7181//4705 7180//4704 7188//4711 +f 7188//4711 7187//4710 7194//4712 +f 7189//4706 7188//4711 7196//4713 +f 7190//4707 7189//4706 7196//4713 +f 7186//4714 7185//4709 7192//4715 +f 7187//4710 7186//4714 7193//4716 +f 7194//4712 7193//4716 6975//4540 +f 7195//4717 7194//4712 6976//4535 +f 7196//4713 7195//4717 6977//4534 +f 7196//4713 6978//4537 6979//4539 +f 7193//4716 7192//4715 6974//4541 +f 6976//4535 6983//4543 6984//4536 +f 6977//4534 6984//4536 6985//4538 +f 7203//4718 6979//4539 6985//4538 +f 6986//4546 7203//4718 6985//4538 +f 6974//4541 6981//4548 6982//4542 +f 6975//4540 6982//4542 6983//4543 +f 6991//4545 6984//4536 6990//4544 +f 6992//4547 6985//4538 6991//4545 +f 7206//4719 6986//4546 6992//4547 +f 6993//4553 7206//4719 6992//4547 +f 6981//4548 6988//4554 6989//4549 +f 6990//4544 6983//4543 6989//4549 +f 6997//4557 6990//4544 6996//4550 +f 6990//4544 6997//4557 6998//4551 +f 6991//4545 6998//4551 6999//4552 +f 7210//4720 6993//4553 6999//4552 +f 7000//4560 7210//4720 6999//4552 +f 6988//4554 6995//4555 6996//4550 +f 7003//4564 6996//4550 7002//4556 +f 6996//4550 7003//4564 7004//4558 +f 6997//4557 7004//4558 7005//4559 +f 7006//4561 6999//4552 7005//4559 +f 7212//4721 7000//4560 7006//4561 +f 7007//4562 7212//4721 7006//4561 +f 7215//4722 7007//4562 7013//4563 +f 7014//4723 7215//4722 7013//4563 +f 7010//4571 7003//4564 7009//4565 +f 7003//4564 7010//4571 7011//4566 +f 7012//4567 7005//4559 7011//4566 +f 7005//4559 7012//4567 7013//4563 +f 7011//4566 7018//4573 7019//4568 +f 7012//4567 7019//4568 7020//4569 +f 7014//4723 7013//4563 7218//4724 +f 7013//4563 7021//4570 7218//4724 +f 7009//4565 7016//4577 7017//4572 +f 7010//4571 7017//4572 7018//4573 +f 7025//4580 7018//4573 7024//4574 +f 7018//4573 7025//4580 7026//4575 +f 7027//4576 7020//4569 7026//4575 +f 7222//4725 7021//4570 7027//4576 +f 7028//4583 7222//4725 7027//4576 +f 7016//4577 7023//4578 7024//4574 +f 7023//4578 7030//4587 7031//4579 +f 7024//4574 7031//4579 7032//4581 +f 7025//4580 7032//4581 7033//4582 +f 7034//4584 7027//4576 7033//4582 +f 7224//4726 7028//4583 7034//4584 +f 7035//4727 7224//4726 7034//4584 +f 7035//4727 7034//4584 7227//4728 +f 7034//4584 7042//4586 7227//4728 +f 7038//4594 7031//4579 7037//4588 +f 7031//4579 7038//4594 7039//4589 +f 7040//4590 7033//4582 7039//4589 +f 7033//4582 7040//4590 7041//4585 +f 7047//4598 7040//4590 7046//4591 +f 7040//4590 7047//4598 7048//4592 +f 7042//4586 7041//4585 7230//4729 +f 7041//4585 7049//4593 7230//4729 +f 7045//4596 7038//4594 7044//4595 +f 7038//4594 7045//4596 7046//4591 +f 7053//4604 7046//4591 7052//4597 +f 7046//4591 7053//4604 7054//4599 +f 7055//4600 7048//4592 7054//4599 +f 7049//4593 7048//4592 7234//4730 +f 7048//4592 7056//4601 7234//4730 +f 7052//4597 7045//4596 7051//4602 +f 7051//4602 7058//4610 7059//4603 +f 7052//4597 7059//4603 7060//4605 +f 7053//4604 7060//4605 7061//4606 +f 7062//4607 7055//4600 7061//4606 +f 7056//4601 7055//4600 7236//4731 +f 7055//4600 7063//4608 7236//4731 +f 7239//4732 7063//4608 7069//4609 +f 7070//4733 7239//4732 7069//4609 +f 7066//4616 7059//4603 7065//4611 +f 7059//4603 7066//4616 7067//4612 +f 7060//4605 7067//4612 7068//4613 +f 7061//4606 7068//4613 7069//4609 +f 7068//4613 7075//4619 7076//4614 +f 7070//4733 7069//4609 7242//4734 +f 7069//4609 7077//4615 7242//4734 +f 7065//4611 7072//4624 7073//4617 +f 7066//4616 7073//4617 7074//4618 +f 7067//4612 7074//4618 7075//4619 +f 7073//4617 7080//4625 7081//4620 +f 7082//4621 7075//4619 7081//4620 +f 7083//4622 7076//4614 7082//4621 +f 7077//4615 7076//4614 7245//4735 +f 7076//4614 7084//4623 7245//4735 +f 7072//4624 7079//4626 7080//4625 +f 7079//4626 7086//4633 7087//4627 +f 7080//4625 7087//4627 7088//4628 +f 7081//4620 7088//4628 7089//4629 +f 7082//4621 7089//4629 7090//4630 +f 7248//4736 7084//4623 7090//4630 +f 7091//4631 7248//4736 7090//4630 +f 7251//4737 7091//4631 7097//4632 +f 7098//4638 7251//4737 7097//4632 +f 7094//4635 7087//4627 7093//4634 +f 7095//4640 7088//4628 7094//4635 +f 7088//4628 7095//4640 7096//4636 +f 7089//4629 7096//4636 7097//4632 +f 7096//4636 7103//4642 7104//4637 +f 7254//4738 7098//4638 7104//4637 +f 7105//4739 7254//4738 7104//4637 +f 7093//4634 7100//4647 7101//4639 +f 7094//4635 7101//4639 7102//4641 +f 7095//4640 7102//4641 7103//4642 +f 7109//4644 7102//4641 7108//4643 +f 7110//4650 7103//4642 7109//4644 +f 7103//4642 7110//4650 7111//4645 +f 7105//4739 7104//4637 7257//4740 +f 7104//4637 7112//4646 7257//4740 +f 7100//4647 7107//4648 7108//4643 +f 7107//4648 7114//4655 7115//4649 +f 7116//4657 7109//4644 7115//4649 +f 7109//4644 7116//4657 7117//4651 +f 7110//4650 7117//4651 7118//4652 +f 7260//4741 7112//4646 7118//4652 +f 7119//4742 7260//4741 7118//4652 +f 7119//4742 7118//4652 7264//4743 +f 7118//4652 7126//4654 7264//4743 +f 7114//4655 7121//4661 7122//4656 +f 7115//4649 7122//4656 7123//4658 +f 7116//4657 7123//4658 7124//4659 +f 7125//4653 7118//4652 7124//4659 +f 7124//4659 7132//4665 7133//4660 +f 7267//4744 7126//4654 7133//4660 +f 7134//4668 7267//4744 7133//4660 +f 7130//4663 7122//4656 7129//4662 +f 7131//4664 7123//4658 7130//4663 +f 7132//4665 7124//4659 7131//4664 +f 7139//4673 7132//4665 7138//4666 +f 7132//4665 7139//4673 7140//4667 +f 7270//4745 7134//4668 7140//4667 +f 7141//4676 7270//4745 7140//4667 +f 7137//4670 7130//4663 7136//4669 +f 7130//4663 7137//4670 7138//4666 +f 7144//4672 7137//4670 7143//4671 +f 7145//4674 7138//4666 7144//4672 +f 7146//4681 7139//4673 7145//4674 +f 7139//4673 7146//4681 7147//4675 +f 7274//4746 7141//4676 7147//4675 +f 7148//4747 7274//4746 7147//4675 +f 7148//4747 7147//4675 7276//4748 +f 7147//4675 7155//4678 7276//4748 +f 7151//4685 7144//4672 7150//4679 +f 7144//4672 7151//4685 7152//4680 +f 7145//4674 7152//4680 7153//4682 +f 7146//4681 7153//4682 7154//4677 +f 7153//4682 7160//4688 7161//4683 +f 7155//4678 7154//4677 7279//4749 +f 7154//4677 7162//4684 7279//4749 +f 7158//4691 7151//4685 7157//4686 +f 7151//4685 7158//4691 7159//4687 +f 7152//4680 7159//4687 7160//4688 +f 7167//4696 7160//4688 7166//4689 +f 7160//4688 7167//4696 7168//4690 +f 7282//4750 7162//4684 7168//4690 +f 7169//4698 7282//4750 7168//4690 +f 7165//4693 7158//4691 7164//4692 +f 7166//4689 7159//4687 7165//4693 +f 7172//4702 7165//4693 7171//4694 +f 7165//4693 7172//4702 7173//4695 +f 7174//4697 7167//4696 7173//4695 +f 7175//4699 7168//4690 7174//4697 +f 7286//4751 7169//4698 7175//4699 +f 7176//4752 7286//4751 7175//4699 +f 7176//4752 7175//4699 7288//4753 +f 7175//4699 7183//4701 7288//4753 +f 7179//4708 7172//4702 7178//4703 +f 7172//4702 7179//4708 7180//4704 +f 7173//4695 7180//4704 7181//4705 +f 7182//4700 7175//4699 7181//4705 +f 7181//4705 7188//4711 7189//4706 +f 7183//4701 7182//4700 7291//4754 +f 7182//4700 7190//4707 7291//4754 +f 7186//4714 7179//4708 7185//4709 +f 7179//4708 7186//4714 7187//4710 +f 7180//4704 7187//4710 7188//4711 +f 7195//4717 7188//4711 7194//4712 +f 7188//4711 7195//4717 7196//4713 +f 7294//4755 7190//4707 7196//4713 +f 7197//4756 7294//4755 7196//4713 +f 7193//4716 7186//4714 7192//4715 +f 7194//4712 7187//4710 7193//4716 +f 6976//4535 7194//4712 6975//4540 +f 6977//4534 7195//4717 6976//4535 +f 6978//4537 7196//4713 6977//4534 +f 7197//4756 7196//4713 7328//4757 +f 7196//4713 6979//4539 7328//4757 +f 6975//4540 7193//4716 6974//4541 +usemtl Material +f 6942//4758 6816//4759 6751//4760 +f 6943//4761 6819//4762 6753//4763 +f 6944//4764 6823//4765 6755//4766 +f 6945//4767 6825//4768 6757//4769 +f 6946//4770 6828//4771 6759//4772 +f 6947//4773 6831//4774 6761//4775 +f 6948//4776 6835//4777 6763//4778 +f 6949//4779 6837//4780 6765//4781 +f 6950//4782 6840//4783 6767//4784 +f 6951//4785 6843//4786 6769//4787 +f 6952//4788 6847//4789 6771//4790 +f 6953//4791 6849//4792 6773//4793 +f 6954//4794 6852//4795 6775//4796 +f 6955//4797 6855//4798 6777//4799 +f 6956//4800 6858//4801 6779//4802 +f 6957//4803 6861//4804 6781//4805 +f 6958//4806 6864//4807 6783//4808 +f 6959//4809 6867//4810 6785//4811 +f 6960//4812 6870//4813 6787//4814 +f 6961//4815 6873//4816 6789//4817 +f 6962//4818 6877//4819 6791//4820 +f 6963//4821 6880//4822 6794//4823 +f 6964//4824 6883//4825 6796//4826 +f 6965//4827 6887//4828 6798//4829 +f 6966//4830 6889//4831 6800//4832 +f 6967//4833 6892//4834 6802//4835 +f 6968//4836 6895//4837 6804//4838 +f 6969//4839 6899//4840 6806//4841 +f 6970//4842 6901//4843 6808//4844 +f 6971//4845 6904//4846 6810//4847 +f 6972//4848 6907//4849 6812//4850 +f 6793//4851 6909//4852 6910//4853 +f 6793//4851 6910//4853 6911//4854 +f 6793//4851 6911//4854 6912//4855 +f 6793//4851 6912//4855 6913//4856 +f 6793//4851 6913//4856 6914//4857 +f 6793//4851 6914//4857 6915//4858 +f 6793//4851 6915//4858 6916//4859 +f 6793//4851 6916//4859 6917//4860 +f 6793//4851 6917//4860 6918//4861 +f 6793//4851 6918//4861 6919//4862 +f 6793//4851 6919//4862 6920//4863 +f 6793//4851 6920//4863 6921//4864 +f 6793//4851 6921//4864 6922//4865 +f 6793//4851 6922//4865 6923//4866 +f 6793//4851 6923//4866 6924//4867 +f 6793//4851 6924//4867 6925//4868 +f 6793//4851 6925//4868 6926//4869 +f 6793//4851 6926//4869 6927//4870 +f 6793//4851 6927//4870 6928//4871 +f 6793//4851 6928//4871 6929//4872 +f 6793//4851 6929//4872 6876//4873 +f 6793//4851 6876//4873 6930//4874 +f 6793//4851 6930//4874 6931//4875 +f 6793//4851 6931//4875 6932//4876 +f 6793//4851 6932//4876 6933//4877 +f 6793//4851 6933//4877 6934//4878 +f 6793//4851 6934//4878 6935//4879 +f 6793//4851 6935//4879 6936//4880 +f 6793//4851 6936//4880 6937//4881 +f 6793//4851 6937//4881 6938//4882 +f 6793//4851 6938//4882 6939//4883 +f 6793//4851 6939//4883 6909//4852 +f 6973//4884 6941//4885 6749//4886 +f 6817//4887 6942//4758 6815//4888 +f 6750//4889 6814//4890 6817//4887 +f 6814//4890 6749//4886 6942//4758 +f 6820//4891 6943//4761 6818//4892 +f 6752//4893 6815//4888 6820//4891 +f 6815//4888 6751//4760 6943//4761 +f 6822//4894 6944//4764 6821//4895 +f 6754//4896 6818//4892 6822//4894 +f 6818//4892 6753//4763 6944//4764 +f 6826//4897 6945//4767 6824//4898 +f 6756//4899 6821//4895 6826//4897 +f 6821//4895 6755//4766 6945//4767 +f 6829//4900 6946//4770 6827//4901 +f 6758//4902 6824//4898 6829//4900 +f 6824//4898 6757//4769 6946//4770 +f 6832//4903 6947//4773 6830//4904 +f 6760//4905 6827//4901 6832//4903 +f 6827//4901 6759//4772 6947//4773 +f 6834//4906 6948//4776 6833//4907 +f 6762//4908 6830//4904 6834//4906 +f 6830//4904 6761//4775 6948//4776 +f 6838//4909 6949//4779 6836//4910 +f 6764//4911 6833//4907 6838//4909 +f 6833//4907 6763//4778 6949//4779 +f 6841//4912 6950//4782 6839//4913 +f 6766//4914 6836//4910 6841//4912 +f 6836//4910 6765//4781 6950//4782 +f 6844//4915 6951//4785 6842//4916 +f 6768//4917 6839//4913 6844//4915 +f 6839//4913 6767//4784 6951//4785 +f 6846//4918 6952//4788 6845//4919 +f 6770//4920 6842//4916 6846//4918 +f 6842//4916 6769//4787 6952//4788 +f 6850//4921 6953//4791 6848//4922 +f 6772//4923 6845//4919 6850//4921 +f 6845//4919 6771//4790 6953//4791 +f 6853//4924 6954//4794 6851//4925 +f 6774//4926 6848//4922 6853//4924 +f 6848//4922 6773//4793 6954//4794 +f 6856//4927 6955//4797 6854//4928 +f 6776//4929 6851//4925 6856//4927 +f 6851//4925 6775//4796 6955//4797 +f 6859//4930 6956//4800 6857//4931 +f 6778//4932 6854//4928 6859//4930 +f 6854//4928 6777//4799 6956//4800 +f 6862//4933 6957//4803 6860//4934 +f 6780//4935 6857//4931 6862//4933 +f 6857//4931 6779//4802 6957//4803 +f 6865//4936 6958//4806 6863//4937 +f 6782//4938 6860//4934 6865//4936 +f 6860//4934 6781//4805 6958//4806 +f 6868//4939 6959//4809 6866//4940 +f 6784//4941 6863//4937 6868//4939 +f 6863//4937 6783//4808 6959//4809 +f 6871//4942 6960//4812 6869//4943 +f 6786//4944 6866//4940 6871//4942 +f 6866//4940 6785//4811 6960//4812 +f 6874//4945 6961//4815 6872//4946 +f 6788//4947 6869//4943 6874//4945 +f 6869//4943 6787//4814 6961//4815 +f 6878//4948 6962//4818 6875//4949 +f 6790//4950 6872//4946 6878//4948 +f 6872//4946 6789//4817 6962//4818 +f 6881//4951 6963//4821 6879//4952 +f 6792//4953 6875//4949 6881//4951 +f 6875//4949 6791//4820 6963//4821 +f 6884//4954 6964//4824 6882//4955 +f 6795//4956 6879//4952 6884//4954 +f 6879//4952 6794//4823 6964//4824 +f 6886//4957 6965//4827 6885//4958 +f 6797//4959 6882//4955 6886//4957 +f 6882//4955 6796//4826 6965//4827 +f 6890//4960 6966//4830 6888//4961 +f 6799//4962 6885//4958 6890//4960 +f 6885//4958 6798//4829 6966//4830 +f 6893//4963 6967//4833 6891//4964 +f 6801//4965 6888//4961 6893//4963 +f 6888//4961 6800//4832 6967//4833 +f 6896//4966 6968//4836 6894//4967 +f 6803//4968 6891//4964 6896//4966 +f 6891//4964 6802//4835 6968//4836 +f 6898//4969 6969//4839 6897//4970 +f 6805//4971 6894//4967 6898//4969 +f 6894//4967 6804//4838 6969//4839 +f 6902//4972 6970//4842 6900//4973 +f 6807//4974 6897//4970 6902//4972 +f 6897//4970 6806//4841 6970//4842 +f 6905//4975 6971//4845 6903//4976 +f 6809//4977 6900//4973 6905//4975 +f 6900//4973 6808//4844 6971//4845 +f 6908//4978 6972//4848 6906//4979 +f 6811//4980 6903//4976 6908//4978 +f 6903//4976 6810//4847 6972//4848 +f 6910//4853 6817//4887 6752//4893 +f 6910//4853 6909//4852 6817//4887 +f 6909//4852 6750//4889 6817//4887 +f 6911//4854 6820//4891 6754//4896 +f 6911//4854 6910//4853 6820//4891 +f 6910//4853 6752//4893 6820//4891 +f 6912//4855 6822//4894 6756//4899 +f 6912//4855 6911//4854 6822//4894 +f 6911//4854 6754//4896 6822//4894 +f 6913//4856 6826//4897 6758//4902 +f 6913//4856 6912//4855 6826//4897 +f 6912//4855 6756//4899 6826//4897 +f 6914//4857 6829//4900 6760//4905 +f 6914//4857 6913//4856 6829//4900 +f 6913//4856 6758//4902 6829//4900 +f 6915//4858 6832//4903 6762//4908 +f 6915//4858 6914//4857 6832//4903 +f 6914//4857 6760//4905 6832//4903 +f 6916//4859 6834//4906 6764//4911 +f 6916//4859 6915//4858 6834//4906 +f 6915//4858 6762//4908 6834//4906 +f 6917//4860 6838//4909 6766//4914 +f 6917//4860 6916//4859 6838//4909 +f 6916//4859 6764//4911 6838//4909 +f 6918//4861 6841//4912 6768//4917 +f 6918//4861 6917//4860 6841//4912 +f 6917//4860 6766//4914 6841//4912 +f 6919//4862 6844//4915 6770//4920 +f 6919//4862 6918//4861 6844//4915 +f 6918//4861 6768//4917 6844//4915 +f 6920//4863 6846//4918 6772//4923 +f 6920//4863 6919//4862 6846//4918 +f 6919//4862 6770//4920 6846//4918 +f 6921//4864 6850//4921 6774//4926 +f 6921//4864 6920//4863 6850//4921 +f 6920//4863 6772//4923 6850//4921 +f 6922//4865 6853//4924 6776//4929 +f 6922//4865 6921//4864 6853//4924 +f 6921//4864 6774//4926 6853//4924 +f 6923//4866 6856//4927 6778//4932 +f 6923//4866 6922//4865 6856//4927 +f 6922//4865 6776//4929 6856//4927 +f 6924//4867 6859//4930 6780//4935 +f 6924//4867 6923//4866 6859//4930 +f 6923//4866 6778//4932 6859//4930 +f 6925//4868 6862//4933 6782//4938 +f 6925//4868 6924//4867 6862//4933 +f 6924//4867 6780//4935 6862//4933 +f 6926//4869 6865//4936 6784//4941 +f 6926//4869 6925//4868 6865//4936 +f 6925//4868 6782//4938 6865//4936 +f 6927//4870 6868//4939 6786//4944 +f 6927//4870 6926//4869 6868//4939 +f 6926//4869 6784//4941 6868//4939 +f 6928//4871 6871//4942 6788//4947 +f 6928//4871 6927//4870 6871//4942 +f 6927//4870 6786//4944 6871//4942 +f 6929//4872 6874//4945 6790//4950 +f 6929//4872 6928//4871 6874//4945 +f 6928//4871 6788//4947 6874//4945 +f 6876//4873 6878//4948 6792//4953 +f 6876//4873 6929//4872 6878//4948 +f 6929//4872 6790//4950 6878//4948 +f 6930//4874 6881//4951 6795//4956 +f 6930//4874 6876//4873 6881//4951 +f 6876//4873 6792//4953 6881//4951 +f 6931//4875 6884//4954 6797//4959 +f 6931//4875 6930//4874 6884//4954 +f 6930//4874 6795//4956 6884//4954 +f 6932//4876 6886//4957 6799//4962 +f 6932//4876 6931//4875 6886//4957 +f 6931//4875 6797//4959 6886//4957 +f 6933//4877 6890//4960 6801//4965 +f 6933//4877 6932//4876 6890//4960 +f 6932//4876 6799//4962 6890//4960 +f 6934//4878 6893//4963 6803//4968 +f 6934//4878 6933//4877 6893//4963 +f 6933//4877 6801//4965 6893//4963 +f 6935//4879 6896//4966 6805//4971 +f 6935//4879 6934//4878 6896//4966 +f 6934//4878 6803//4968 6896//4966 +f 6936//4880 6898//4969 6807//4974 +f 6936//4880 6935//4879 6898//4969 +f 6935//4879 6805//4971 6898//4969 +f 6937//4881 6902//4972 6809//4977 +f 6937//4881 6936//4880 6902//4972 +f 6936//4880 6807//4974 6902//4972 +f 6938//4882 6905//4975 6811//4980 +f 6938//4882 6937//4881 6905//4975 +f 6937//4881 6809//4977 6905//4975 +f 6939//4883 6908//4978 6813//4981 +f 6939//4883 6938//4882 6908//4978 +f 6938//4882 6811//4980 6908//4978 +f 6909//4852 6940//4982 6750//4889 +f 6909//4852 6939//4883 6940//4982 +f 6939//4883 6813//4981 6940//4982 +f 6940//4982 6973//4884 6814//4890 +f 6813//4981 6906//4979 6940//4982 +f 6906//4979 6812//4850 6973//4884 +f 6815//4888 6942//4758 6751//4760 +f 6818//4892 6943//4761 6753//4763 +f 6821//4895 6944//4764 6755//4766 +f 6824//4898 6945//4767 6757//4769 +f 6827//4901 6946//4770 6759//4772 +f 6830//4904 6947//4773 6761//4775 +f 6833//4907 6948//4776 6763//4778 +f 6836//4910 6949//4779 6765//4781 +f 6839//4913 6950//4782 6767//4784 +f 6842//4916 6951//4785 6769//4787 +f 6845//4919 6952//4788 6771//4790 +f 6848//4922 6953//4791 6773//4793 +f 6851//4925 6954//4794 6775//4796 +f 6854//4928 6955//4797 6777//4799 +f 6857//4931 6956//4800 6779//4802 +f 6860//4934 6957//4803 6781//4805 +f 6863//4937 6958//4806 6783//4808 +f 6866//4940 6959//4809 6785//4811 +f 6869//4943 6960//4812 6787//4814 +f 6872//4946 6961//4815 6789//4817 +f 6875//4949 6962//4818 6791//4820 +f 6879//4952 6963//4821 6794//4823 +f 6882//4955 6964//4824 6796//4826 +f 6885//4958 6965//4827 6798//4829 +f 6888//4961 6966//4830 6800//4832 +f 6891//4964 6967//4833 6802//4835 +f 6894//4967 6968//4836 6804//4838 +f 6897//4970 6969//4839 6806//4841 +f 6900//4973 6970//4842 6808//4844 +f 6903//4976 6971//4845 6810//4847 +f 6906//4979 6972//4848 6812//4850 +f 6814//4890 6973//4884 6749//4886 +f 6752//4893 6817//4887 6815//4888 +f 6814//4890 6942//4758 6817//4887 +f 6749//4886 6816//4759 6942//4758 +f 6754//4896 6820//4891 6818//4892 +f 6815//4888 6943//4761 6820//4891 +f 6751//4760 6819//4762 6943//4761 +f 6756//4899 6822//4894 6821//4895 +f 6818//4892 6944//4764 6822//4894 +f 6753//4763 6823//4765 6944//4764 +f 6758//4902 6826//4897 6824//4898 +f 6821//4895 6945//4767 6826//4897 +f 6755//4766 6825//4768 6945//4767 +f 6760//4905 6829//4900 6827//4901 +f 6824//4898 6946//4770 6829//4900 +f 6757//4769 6828//4771 6946//4770 +f 6762//4908 6832//4903 6830//4904 +f 6827//4901 6947//4773 6832//4903 +f 6759//4772 6831//4774 6947//4773 +f 6764//4911 6834//4906 6833//4907 +f 6830//4904 6948//4776 6834//4906 +f 6761//4775 6835//4777 6948//4776 +f 6766//4914 6838//4909 6836//4910 +f 6833//4907 6949//4779 6838//4909 +f 6763//4778 6837//4780 6949//4779 +f 6768//4917 6841//4912 6839//4913 +f 6836//4910 6950//4782 6841//4912 +f 6765//4781 6840//4783 6950//4782 +f 6770//4920 6844//4915 6842//4916 +f 6839//4913 6951//4785 6844//4915 +f 6767//4784 6843//4786 6951//4785 +f 6772//4923 6846//4918 6845//4919 +f 6842//4916 6952//4788 6846//4918 +f 6769//4787 6847//4789 6952//4788 +f 6774//4926 6850//4921 6848//4922 +f 6845//4919 6953//4791 6850//4921 +f 6771//4790 6849//4792 6953//4791 +f 6776//4929 6853//4924 6851//4925 +f 6848//4922 6954//4794 6853//4924 +f 6773//4793 6852//4795 6954//4794 +f 6778//4932 6856//4927 6854//4928 +f 6851//4925 6955//4797 6856//4927 +f 6775//4796 6855//4798 6955//4797 +f 6780//4935 6859//4930 6857//4931 +f 6854//4928 6956//4800 6859//4930 +f 6777//4799 6858//4801 6956//4800 +f 6782//4938 6862//4933 6860//4934 +f 6857//4931 6957//4803 6862//4933 +f 6779//4802 6861//4804 6957//4803 +f 6784//4941 6865//4936 6863//4937 +f 6860//4934 6958//4806 6865//4936 +f 6781//4805 6864//4807 6958//4806 +f 6786//4944 6868//4939 6866//4940 +f 6863//4937 6959//4809 6868//4939 +f 6783//4808 6867//4810 6959//4809 +f 6788//4947 6871//4942 6869//4943 +f 6866//4940 6960//4812 6871//4942 +f 6785//4811 6870//4813 6960//4812 +f 6790//4950 6874//4945 6872//4946 +f 6869//4943 6961//4815 6874//4945 +f 6787//4814 6873//4816 6961//4815 +f 6792//4953 6878//4948 6875//4949 +f 6872//4946 6962//4818 6878//4948 +f 6789//4817 6877//4819 6962//4818 +f 6795//4956 6881//4951 6879//4952 +f 6875//4949 6963//4821 6881//4951 +f 6791//4820 6880//4822 6963//4821 +f 6797//4959 6884//4954 6882//4955 +f 6879//4952 6964//4824 6884//4954 +f 6794//4823 6883//4825 6964//4824 +f 6799//4962 6886//4957 6885//4958 +f 6882//4955 6965//4827 6886//4957 +f 6796//4826 6887//4828 6965//4827 +f 6801//4965 6890//4960 6888//4961 +f 6885//4958 6966//4830 6890//4960 +f 6798//4829 6889//4831 6966//4830 +f 6803//4968 6893//4963 6891//4964 +f 6888//4961 6967//4833 6893//4963 +f 6800//4832 6892//4834 6967//4833 +f 6805//4971 6896//4966 6894//4967 +f 6891//4964 6968//4836 6896//4966 +f 6802//4835 6895//4837 6968//4836 +f 6807//4974 6898//4969 6897//4970 +f 6894//4967 6969//4839 6898//4969 +f 6804//4838 6899//4840 6969//4839 +f 6809//4977 6902//4972 6900//4973 +f 6897//4970 6970//4842 6902//4972 +f 6806//4841 6901//4843 6970//4842 +f 6811//4980 6905//4975 6903//4976 +f 6900//4973 6971//4845 6905//4975 +f 6808//4844 6904//4846 6971//4845 +f 6813//4981 6908//4978 6906//4979 +f 6903//4976 6972//4848 6908//4978 +f 6810//4847 6907//4849 6972//4848 +f 6750//4889 6940//4982 6814//4890 +f 6906//4979 6973//4884 6940//4982 +f 6812//4850 6941//4885 6973//4884 +usemtl Material.001 +f 7329//4983 7203//4718 6986//4546 +f 7330//4984 7206//4719 6993//4553 +f 7331//4985 7210//4720 7000//4560 +f 7332//4986 7212//4721 7007//4562 +f 7333//4987 7215//4722 7014//4723 +f 7334//4988 7218//4724 7021//4570 +f 7335//4989 7222//4725 7028//4583 +f 7336//4990 7224//4726 7035//4727 +f 7337//4991 7227//4728 7042//4586 +f 7338//4992 7230//4729 7049//4593 +f 7339//4993 7234//4730 7056//4601 +f 7340//4994 7236//4731 7063//4608 +f 7341//4995 7239//4732 7070//4733 +f 7342//4996 7242//4734 7077//4615 +f 7343//4997 7245//4735 7084//4623 +f 7344//4998 7248//4736 7091//4631 +f 7345//4999 7251//4737 7098//4638 +f 7346//5000 7254//4738 7105//4739 +f 7347//5001 7257//4740 7112//4646 +f 7348//5002 7260//4741 7119//4742 +f 7349//5003 7264//4743 7126//4654 +f 7350//5004 7267//4744 7134//4668 +f 7351//5005 7270//4745 7141//4676 +f 7352//5006 7274//4746 7148//4747 +f 7353//5007 7276//4748 7155//4678 +f 7354//5008 7279//4749 7162//4684 +f 7355//5009 7282//4750 7169//4698 +f 7356//5010 7286//4751 7176//4752 +f 7357//5011 7288//4753 7183//4701 +f 7358//5012 7291//4754 7190//4707 +f 7359//5013 7294//4755 7197//4756 +f 7128//5014 7296//5015 7297//5016 +f 7128//5014 7297//5016 7298//5017 +f 7128//5014 7298//5017 7299//5018 +f 7128//5014 7299//5018 7300//5019 +f 7128//5014 7300//5019 7301//5020 +f 7128//5014 7301//5020 7302//5021 +f 7128//5014 7302//5021 7303//5022 +f 7128//5014 7303//5022 7304//5023 +f 7128//5014 7304//5023 7305//5024 +f 7128//5014 7305//5024 7306//5025 +f 7128//5014 7306//5025 7307//5026 +f 7128//5014 7307//5026 7308//5027 +f 7128//5014 7308//5027 7309//5028 +f 7128//5014 7309//5028 7310//5029 +f 7128//5014 7310//5029 7311//5030 +f 7128//5014 7311//5030 7312//5031 +f 7128//5014 7312//5031 7313//5032 +f 7128//5014 7313//5032 7314//5033 +f 7128//5014 7314//5033 7315//5034 +f 7128//5014 7315//5034 7316//5035 +f 7128//5014 7316//5035 7263//5036 +f 7128//5014 7263//5036 7317//5037 +f 7128//5014 7317//5037 7318//5038 +f 7128//5014 7318//5038 7319//5039 +f 7128//5014 7319//5039 7320//5040 +f 7128//5014 7320//5040 7321//5041 +f 7128//5014 7321//5041 7322//5042 +f 7128//5014 7322//5042 7323//5043 +f 7128//5014 7323//5043 7324//5044 +f 7128//5014 7324//5044 7325//5045 +f 7128//5014 7325//5045 7326//5046 +f 7128//5014 7326//5046 7296//5015 +f 7360//5047 7328//4757 6979//4539 +f 7204//5048 7329//4983 7202//5049 +f 6980//5050 7201//5051 7204//5048 +f 7201//5051 6979//4539 7329//4983 +f 7207//5052 7330//4984 7205//5053 +f 6987//5054 7202//5049 7207//5052 +f 7202//5049 6986//4546 7330//4984 +f 7209//5055 7331//4985 7208//5056 +f 6994//5057 7205//5053 7209//5055 +f 7205//5053 6993//4553 7331//4985 +f 7213//5058 7332//4986 7211//5059 +f 7001//5060 7208//5056 7213//5058 +f 7208//5056 7000//4560 7332//4986 +f 7216//5061 7333//4987 7214//5062 +f 7008//5063 7211//5059 7216//5061 +f 7211//5059 7007//4562 7333//4987 +f 7219//5064 7334//4988 7217//5065 +f 7015//5066 7214//5062 7219//5064 +f 7214//5062 7014//4723 7334//4988 +f 7221//5067 7335//4989 7220//5068 +f 7022//5069 7217//5065 7221//5067 +f 7217//5065 7021//4570 7335//4989 +f 7225//5070 7336//4990 7223//5071 +f 7029//5072 7220//5068 7225//5070 +f 7220//5068 7028//4583 7336//4990 +f 7228//5073 7337//4991 7226//5074 +f 7036//5075 7223//5071 7228//5073 +f 7223//5071 7035//4727 7337//4991 +f 7231//5076 7338//4992 7229//5077 +f 7043//5078 7226//5074 7231//5076 +f 7226//5074 7042//4586 7338//4992 +f 7233//5079 7339//4993 7232//5080 +f 7050//5081 7229//5077 7233//5079 +f 7229//5077 7049//4593 7339//4993 +f 7237//5082 7340//4994 7235//5083 +f 7057//5084 7232//5080 7237//5082 +f 7232//5080 7056//4601 7340//4994 +f 7240//5085 7341//4995 7238//5086 +f 7064//5087 7235//5083 7240//5085 +f 7235//5083 7063//4608 7341//4995 +f 7243//5088 7342//4996 7241//5089 +f 7071//5090 7238//5086 7243//5088 +f 7238//5086 7070//4733 7342//4996 +f 7246//5091 7343//4997 7244//5092 +f 7078//5093 7241//5089 7246//5091 +f 7241//5089 7077//4615 7343//4997 +f 7249//5094 7344//4998 7247//5095 +f 7085//5096 7244//5092 7249//5094 +f 7244//5092 7084//4623 7344//4998 +f 7252//5097 7345//4999 7250//5098 +f 7092//5099 7247//5095 7252//5097 +f 7247//5095 7091//4631 7345//4999 +f 7255//5100 7346//5000 7253//5101 +f 7099//5102 7250//5098 7255//5100 +f 7250//5098 7098//4638 7346//5000 +f 7258//5103 7347//5001 7256//5104 +f 7106//5105 7253//5101 7258//5103 +f 7253//5101 7105//4739 7347//5001 +f 7261//5106 7348//5002 7259//5107 +f 7113//5108 7256//5104 7261//5106 +f 7256//5104 7112//4646 7348//5002 +f 7265//5109 7349//5003 7262//5110 +f 7120//5111 7259//5107 7265//5109 +f 7259//5107 7119//4742 7349//5003 +f 7268//5112 7350//5004 7266//5113 +f 7127//5114 7262//5110 7268//5112 +f 7262//5110 7126//4654 7350//5004 +f 7271//5115 7351//5005 7269//5116 +f 7135//5117 7266//5113 7271//5115 +f 7266//5113 7134//4668 7351//5005 +f 7273//5118 7352//5006 7272//5119 +f 7142//5120 7269//5116 7273//5118 +f 7269//5116 7141//4676 7352//5006 +f 7277//5121 7353//5007 7275//5122 +f 7149//5123 7272//5119 7277//5121 +f 7272//5119 7148//4747 7353//5007 +f 7280//5124 7354//5008 7278//5125 +f 7156//5126 7275//5122 7280//5124 +f 7275//5122 7155//4678 7354//5008 +f 7283//5127 7355//5009 7281//5128 +f 7163//5129 7278//5125 7283//5127 +f 7278//5125 7162//4684 7355//5009 +f 7285//5130 7356//5010 7284//5131 +f 7170//5132 7281//5128 7285//5130 +f 7281//5128 7169//4698 7356//5010 +f 7289//5133 7357//5011 7287//5134 +f 7177//5135 7284//5131 7289//5133 +f 7284//5131 7176//4752 7357//5011 +f 7292//5136 7358//5012 7290//5137 +f 7184//5138 7287//5134 7292//5136 +f 7287//5134 7183//4701 7358//5012 +f 7295//5139 7359//5013 7293//5140 +f 7191//5141 7290//5137 7295//5139 +f 7290//5137 7190//4707 7359//5013 +f 7297//5016 7204//5048 6987//5054 +f 7297//5016 7296//5015 7204//5048 +f 7296//5015 6980//5050 7204//5048 +f 7298//5017 7207//5052 6994//5057 +f 7298//5017 7297//5016 7207//5052 +f 7297//5016 6987//5054 7207//5052 +f 7299//5018 7209//5055 7001//5060 +f 7299//5018 7298//5017 7209//5055 +f 7298//5017 6994//5057 7209//5055 +f 7300//5019 7213//5058 7008//5063 +f 7300//5019 7299//5018 7213//5058 +f 7299//5018 7001//5060 7213//5058 +f 7301//5020 7216//5061 7015//5066 +f 7301//5020 7300//5019 7216//5061 +f 7300//5019 7008//5063 7216//5061 +f 7302//5021 7219//5064 7022//5069 +f 7302//5021 7301//5020 7219//5064 +f 7301//5020 7015//5066 7219//5064 +f 7303//5022 7221//5067 7029//5072 +f 7303//5022 7302//5021 7221//5067 +f 7302//5021 7022//5069 7221//5067 +f 7304//5023 7225//5070 7036//5075 +f 7304//5023 7303//5022 7225//5070 +f 7303//5022 7029//5072 7225//5070 +f 7305//5024 7228//5073 7043//5078 +f 7305//5024 7304//5023 7228//5073 +f 7304//5023 7036//5075 7228//5073 +f 7306//5025 7231//5076 7050//5081 +f 7306//5025 7305//5024 7231//5076 +f 7305//5024 7043//5078 7231//5076 +f 7307//5026 7233//5079 7057//5084 +f 7307//5026 7306//5025 7233//5079 +f 7306//5025 7050//5081 7233//5079 +f 7308//5027 7237//5082 7064//5087 +f 7308//5027 7307//5026 7237//5082 +f 7307//5026 7057//5084 7237//5082 +f 7309//5028 7240//5085 7071//5090 +f 7309//5028 7308//5027 7240//5085 +f 7308//5027 7064//5087 7240//5085 +f 7310//5029 7243//5088 7078//5093 +f 7310//5029 7309//5028 7243//5088 +f 7309//5028 7071//5090 7243//5088 +f 7311//5030 7246//5091 7085//5096 +f 7311//5030 7310//5029 7246//5091 +f 7310//5029 7078//5093 7246//5091 +f 7312//5031 7249//5094 7092//5099 +f 7312//5031 7311//5030 7249//5094 +f 7311//5030 7085//5096 7249//5094 +f 7313//5032 7252//5097 7099//5102 +f 7313//5032 7312//5031 7252//5097 +f 7312//5031 7092//5099 7252//5097 +f 7314//5033 7255//5100 7106//5105 +f 7314//5033 7313//5032 7255//5100 +f 7313//5032 7099//5102 7255//5100 +f 7315//5034 7258//5103 7113//5108 +f 7315//5034 7314//5033 7258//5103 +f 7314//5033 7106//5105 7258//5103 +f 7316//5035 7261//5106 7120//5111 +f 7316//5035 7315//5034 7261//5106 +f 7315//5034 7113//5108 7261//5106 +f 7263//5036 7265//5109 7127//5114 +f 7263//5036 7316//5035 7265//5109 +f 7316//5035 7120//5111 7265//5109 +f 7317//5037 7268//5112 7135//5117 +f 7317//5037 7263//5036 7268//5112 +f 7263//5036 7127//5114 7268//5112 +f 7318//5038 7271//5115 7142//5120 +f 7318//5038 7317//5037 7271//5115 +f 7317//5037 7135//5117 7271//5115 +f 7319//5039 7273//5118 7149//5123 +f 7319//5039 7318//5038 7273//5118 +f 7318//5038 7142//5120 7273//5118 +f 7320//5040 7277//5121 7156//5126 +f 7320//5040 7319//5039 7277//5121 +f 7319//5039 7149//5123 7277//5121 +f 7321//5041 7280//5124 7163//5129 +f 7321//5041 7320//5040 7280//5124 +f 7320//5040 7156//5126 7280//5124 +f 7322//5042 7283//5127 7170//5132 +f 7322//5042 7321//5041 7283//5127 +f 7321//5041 7163//5129 7283//5127 +f 7323//5043 7285//5130 7177//5135 +f 7323//5043 7322//5042 7285//5130 +f 7322//5042 7170//5132 7285//5130 +f 7324//5044 7289//5133 7184//5138 +f 7324//5044 7323//5043 7289//5133 +f 7323//5043 7177//5135 7289//5133 +f 7325//5045 7292//5136 7191//5141 +f 7325//5045 7324//5044 7292//5136 +f 7324//5044 7184//5138 7292//5136 +f 7326//5046 7295//5139 7198//5142 +f 7326//5046 7325//5045 7295//5139 +f 7325//5045 7191//5141 7295//5139 +f 7296//5015 7327//5143 6980//5050 +f 7296//5015 7326//5046 7327//5143 +f 7326//5046 7198//5142 7327//5143 +f 7327//5143 7360//5047 7201//5051 +f 7198//5142 7293//5140 7327//5143 +f 7293//5140 7197//4756 7360//5047 +f 7202//5049 7329//4983 6986//4546 +f 7205//5053 7330//4984 6993//4553 +f 7208//5056 7331//4985 7000//4560 +f 7211//5059 7332//4986 7007//4562 +f 7214//5062 7333//4987 7014//4723 +f 7217//5065 7334//4988 7021//4570 +f 7220//5068 7335//4989 7028//4583 +f 7223//5071 7336//4990 7035//4727 +f 7226//5074 7337//4991 7042//4586 +f 7229//5077 7338//4992 7049//4593 +f 7232//5080 7339//4993 7056//4601 +f 7235//5083 7340//4994 7063//4608 +f 7238//5086 7341//4995 7070//4733 +f 7241//5089 7342//4996 7077//4615 +f 7244//5092 7343//4997 7084//4623 +f 7247//5095 7344//4998 7091//4631 +f 7250//5098 7345//4999 7098//4638 +f 7253//5101 7346//5000 7105//4739 +f 7256//5104 7347//5001 7112//4646 +f 7259//5107 7348//5002 7119//4742 +f 7262//5110 7349//5003 7126//4654 +f 7266//5113 7350//5004 7134//4668 +f 7269//5116 7351//5005 7141//4676 +f 7272//5119 7352//5006 7148//4747 +f 7275//5122 7353//5007 7155//4678 +f 7278//5125 7354//5008 7162//4684 +f 7281//5128 7355//5009 7169//4698 +f 7284//5131 7356//5010 7176//4752 +f 7287//5134 7357//5011 7183//4701 +f 7290//5137 7358//5012 7190//4707 +f 7293//5140 7359//5013 7197//4756 +f 7201//5051 7360//5047 6979//4539 +f 6987//5054 7204//5048 7202//5049 +f 7201//5051 7329//4983 7204//5048 +f 6979//4539 7203//4718 7329//4983 +f 6994//5057 7207//5052 7205//5053 +f 7202//5049 7330//4984 7207//5052 +f 6986//4546 7206//4719 7330//4984 +f 7001//5060 7209//5055 7208//5056 +f 7205//5053 7331//4985 7209//5055 +f 6993//4553 7210//4720 7331//4985 +f 7008//5063 7213//5058 7211//5059 +f 7208//5056 7332//4986 7213//5058 +f 7000//4560 7212//4721 7332//4986 +f 7015//5066 7216//5061 7214//5062 +f 7211//5059 7333//4987 7216//5061 +f 7007//4562 7215//4722 7333//4987 +f 7022//5069 7219//5064 7217//5065 +f 7214//5062 7334//4988 7219//5064 +f 7014//4723 7218//4724 7334//4988 +f 7029//5072 7221//5067 7220//5068 +f 7217//5065 7335//4989 7221//5067 +f 7021//4570 7222//4725 7335//4989 +f 7036//5075 7225//5070 7223//5071 +f 7220//5068 7336//4990 7225//5070 +f 7028//4583 7224//4726 7336//4990 +f 7043//5078 7228//5073 7226//5074 +f 7223//5071 7337//4991 7228//5073 +f 7035//4727 7227//4728 7337//4991 +f 7050//5081 7231//5076 7229//5077 +f 7226//5074 7338//4992 7231//5076 +f 7042//4586 7230//4729 7338//4992 +f 7057//5084 7233//5079 7232//5080 +f 7229//5077 7339//4993 7233//5079 +f 7049//4593 7234//4730 7339//4993 +f 7064//5087 7237//5082 7235//5083 +f 7232//5080 7340//4994 7237//5082 +f 7056//4601 7236//4731 7340//4994 +f 7071//5090 7240//5085 7238//5086 +f 7235//5083 7341//4995 7240//5085 +f 7063//4608 7239//4732 7341//4995 +f 7078//5093 7243//5088 7241//5089 +f 7238//5086 7342//4996 7243//5088 +f 7070//4733 7242//4734 7342//4996 +f 7085//5096 7246//5091 7244//5092 +f 7241//5089 7343//4997 7246//5091 +f 7077//4615 7245//4735 7343//4997 +f 7092//5099 7249//5094 7247//5095 +f 7244//5092 7344//4998 7249//5094 +f 7084//4623 7248//4736 7344//4998 +f 7099//5102 7252//5097 7250//5098 +f 7247//5095 7345//4999 7252//5097 +f 7091//4631 7251//4737 7345//4999 +f 7106//5105 7255//5100 7253//5101 +f 7250//5098 7346//5000 7255//5100 +f 7098//4638 7254//4738 7346//5000 +f 7113//5108 7258//5103 7256//5104 +f 7253//5101 7347//5001 7258//5103 +f 7105//4739 7257//4740 7347//5001 +f 7120//5111 7261//5106 7259//5107 +f 7256//5104 7348//5002 7261//5106 +f 7112//4646 7260//4741 7348//5002 +f 7127//5114 7265//5109 7262//5110 +f 7259//5107 7349//5003 7265//5109 +f 7119//4742 7264//4743 7349//5003 +f 7135//5117 7268//5112 7266//5113 +f 7262//5110 7350//5004 7268//5112 +f 7126//4654 7267//4744 7350//5004 +f 7142//5120 7271//5115 7269//5116 +f 7266//5113 7351//5005 7271//5115 +f 7134//4668 7270//4745 7351//5005 +f 7149//5123 7273//5118 7272//5119 +f 7269//5116 7352//5006 7273//5118 +f 7141//4676 7274//4746 7352//5006 +f 7156//5126 7277//5121 7275//5122 +f 7272//5119 7353//5007 7277//5121 +f 7148//4747 7276//4748 7353//5007 +f 7163//5129 7280//5124 7278//5125 +f 7275//5122 7354//5008 7280//5124 +f 7155//4678 7279//4749 7354//5008 +f 7170//5132 7283//5127 7281//5128 +f 7278//5125 7355//5009 7283//5127 +f 7162//4684 7282//4750 7355//5009 +f 7177//5135 7285//5130 7284//5131 +f 7281//5128 7356//5010 7285//5130 +f 7169//4698 7286//4751 7356//5010 +f 7184//5138 7289//5133 7287//5134 +f 7284//5131 7357//5011 7289//5133 +f 7176//4752 7288//4753 7357//5011 +f 7191//5141 7292//5136 7290//5137 +f 7287//5134 7358//5012 7292//5136 +f 7183//4701 7291//4754 7358//5012 +f 7198//5142 7295//5139 7293//5140 +f 7290//5137 7359//5013 7295//5139 +f 7190//4707 7294//4755 7359//5013 +f 6980//5050 7327//5143 7201//5051 +f 7293//5140 7360//5047 7327//5143 +f 7197//4756 7328//4757 7360//5047 +l 7199 7200 +o Eye_L_Sphere.004 +v -0.483685 1.010693 0.349484 +v -0.489504 1.014649 0.341047 +v -0.480361 1.012142 0.347357 +v -0.487809 1.015388 0.339963 +v -0.477556 1.013611 0.344591 +v -0.486379 1.016137 0.338553 +v -0.475379 1.015045 0.341293 +v -0.485269 1.016868 0.336871 +v -0.473913 1.016386 0.337588 +v -0.484522 1.017552 0.334982 +v -0.473215 1.017585 0.333619 +v -0.484166 1.018163 0.332959 +v -0.473311 1.018595 0.329539 +v -0.484215 1.018678 0.330879 +v -0.474199 1.019378 0.325504 +v -0.484668 1.019077 0.328822 +v -0.475842 1.019902 0.321670 +v -0.485506 1.019344 0.326867 +v -0.478180 1.020149 0.318184 +v -0.486697 1.019470 0.325090 +v -0.481121 1.020108 0.315180 +v -0.488197 1.019449 0.323559 +v -0.484553 1.019781 0.312773 +v -0.489946 1.019282 0.322332 +v -0.488343 1.019181 0.311056 +v -0.491879 1.018976 0.321457 +v -0.492347 1.018330 0.310095 +v -0.493920 1.018543 0.320967 +v -0.496410 1.017262 0.309927 +v -0.495991 1.017998 0.320881 +v -0.500376 1.016018 0.310558 +v -0.498013 1.017364 0.321202 +v -0.504093 1.014645 0.311964 +v -0.499908 1.016664 0.321919 +v -0.507417 1.013196 0.314090 +v -0.501602 1.015925 0.323003 +v -0.510222 1.011726 0.316856 +v -0.503032 1.015176 0.324413 +v -0.512399 1.010293 0.320155 +v -0.504142 1.014446 0.326095 +v -0.513865 1.008951 0.323860 +v -0.504889 1.013762 0.327984 +v -0.514563 1.007752 0.327829 +v -0.505245 1.013150 0.330007 +v -0.494982 1.016666 0.331739 +v -0.514467 1.006742 0.331909 +v -0.505196 1.012635 0.332087 +v -0.513579 1.005960 0.335944 +v -0.504744 1.012237 0.334144 +v -0.511935 1.005435 0.339778 +v -0.503906 1.011969 0.336098 +v -0.509598 1.005189 0.343264 +v -0.502714 1.011844 0.337876 +v -0.506657 1.005230 0.346268 +v -0.501215 1.011864 0.339407 +v -0.503225 1.005557 0.348674 +v -0.499465 1.012031 0.340634 +v -0.499435 1.006157 0.350391 +v -0.497533 1.012337 0.341509 +v -0.495431 1.007007 0.351352 +v -0.495492 1.012771 0.341999 +v -0.491368 1.008075 0.351521 +v -0.493421 1.013315 0.342085 +v -0.487402 1.009320 0.350890 +v -0.491399 1.013949 0.341763 +v -0.486626 1.012941 0.345419 +v -0.484102 1.014042 0.343804 +v -0.482024 1.011457 0.348446 +v -0.488658 1.015030 0.340510 +v -0.481972 1.015157 0.341704 +v -0.478957 1.012917 0.345998 +v -0.487096 1.015774 0.339262 +v -0.480319 1.016246 0.339199 +v -0.485825 1.016514 0.337716 +v -0.476464 1.014370 0.342963 +v -0.479206 1.017264 0.336386 +v -0.474641 1.015758 0.339458 +v -0.484897 1.017222 0.335930 +v -0.478676 1.018175 0.333372 +v -0.473558 1.017030 0.335617 +v -0.484345 1.017869 0.333974 +v -0.478749 1.018942 0.330274 +v -0.473257 1.018135 0.331590 +v -0.484192 1.018432 0.331922 +v -0.479423 1.019536 0.327211 +v -0.484442 1.018889 0.329853 +v -0.473749 1.019032 0.327529 +v -0.480671 1.019934 0.324300 +v -0.475016 1.019686 0.323591 +v -0.485088 1.019223 0.327847 +v -0.482446 1.020121 0.321653 +v -0.477008 1.020072 0.319928 +v -0.486103 1.019419 0.325980 +v -0.484679 1.020090 0.319372 +v -0.479649 1.020175 0.316681 +v -0.487448 1.019472 0.324326 +v -0.487285 1.019842 0.317545 +v -0.489073 1.019378 0.322946 +v -0.482838 1.019991 0.313973 +v -0.490163 1.019386 0.316241 +v -0.486453 1.019527 0.311909 +v -0.490915 1.019141 0.321895 +v -0.493203 1.018740 0.315511 +v -0.490353 1.018801 0.310569 +v -0.492902 1.018772 0.321212 +v -0.496288 1.017930 0.315383 +v -0.494390 1.017841 0.310004 +v -0.494958 1.018283 0.320924 +v -0.499299 1.016985 0.315862 +v -0.498408 1.016684 0.310235 +v -0.497005 1.017693 0.321042 +v -0.502121 1.015942 0.316930 +v -0.502252 1.015374 0.311255 +v -0.498964 1.017026 0.321561 +v -0.504646 1.014842 0.318545 +v -0.505776 1.013961 0.313022 +v -0.500759 1.016306 0.322462 +v -0.506775 1.013726 0.320645 +v -0.508843 1.012501 0.315471 +v -0.502322 1.015562 0.323709 +v -0.508428 1.012638 0.323150 +v -0.511336 1.011048 0.318506 +v -0.503592 1.014822 0.325256 +v -0.509541 1.011619 0.325963 +v -0.513159 1.009660 0.322011 +v -0.504521 1.014114 0.327041 +v -0.510071 1.010709 0.328976 +v -0.500228 1.015201 0.330945 +v -0.514242 1.008388 0.325851 +v -0.505073 1.013467 0.328998 +v -0.509998 1.009942 0.332074 +v -0.514543 1.007283 0.329879 +v -0.505226 1.012903 0.331050 +v -0.509324 1.009348 0.335138 +v -0.514051 1.006386 0.333939 +v -0.504975 1.012447 0.333119 +v -0.508076 1.008950 0.338049 +v -0.504330 1.012113 0.335125 +v -0.512784 1.005732 0.337877 +v -0.506301 1.008762 0.340696 +v -0.510792 1.005346 0.341540 +v -0.503315 1.011917 0.336991 +v -0.504068 1.008794 0.342976 +v -0.508151 1.005243 0.344788 +v -0.501969 1.011864 0.338646 +v -0.501463 1.009042 0.344804 +v -0.504961 1.005427 0.347495 +v -0.500344 1.011958 0.340025 +v -0.498584 1.009497 0.346108 +v -0.498503 1.012195 0.341077 +v -0.501347 1.005891 0.349559 +v -0.495544 1.010143 0.346837 +v -0.497447 1.006617 0.350899 +v -0.496516 1.012564 0.341759 +v -0.492460 1.010954 0.346965 +v -0.493410 1.007577 0.351464 +v -0.494459 1.013053 0.342047 +v -0.489448 1.011899 0.346486 +v -0.489392 1.008734 0.351233 +v -0.492412 1.013643 0.341929 +v -0.492309 1.015955 0.336499 +v -0.491456 1.016326 0.335953 +v -0.490737 1.016703 0.335244 +v -0.490179 1.017071 0.334398 +v -0.489803 1.017415 0.333448 +v -0.489624 1.017722 0.332430 +v -0.489648 1.017981 0.331383 +v -0.489876 1.018182 0.330349 +v -0.490298 1.018317 0.329365 +v -0.490897 1.018380 0.328471 +v -0.491651 1.018369 0.327701 +v -0.492531 1.018286 0.327084 +v -0.493504 1.018131 0.326643 +v -0.494530 1.017913 0.326397 +v -0.495572 1.017640 0.326354 +v -0.496589 1.017320 0.326516 +v -0.497543 1.016968 0.326876 +v -0.498395 1.016597 0.327421 +v -0.499115 1.016220 0.328131 +v -0.499673 1.015852 0.328977 +v -0.500049 1.015508 0.329927 +v -0.500203 1.014942 0.331991 +v -0.499976 1.014741 0.333026 +v -0.499554 1.014606 0.334009 +v -0.498955 1.014543 0.334903 +v -0.498200 1.014554 0.335674 +v -0.497320 1.014638 0.336291 +v -0.496348 1.014791 0.336731 +v -0.495321 1.015010 0.336978 +v -0.494279 1.015283 0.337021 +v -0.493262 1.015603 0.336859 +v -0.490453 1.014310 0.341410 +v -0.485548 1.010044 0.350214 +v -0.485366 1.013515 0.344624 +v -0.483038 1.014624 0.342766 +v -0.481146 1.015726 0.340462 +v -0.479762 1.016780 0.337802 +v -0.478940 1.017745 0.334887 +v -0.478712 1.018584 0.331830 +v -0.479085 1.019265 0.328748 +v -0.480047 1.019762 0.325759 +v -0.481559 1.020054 0.322979 +v -0.483564 1.020133 0.320514 +v -0.485984 1.019993 0.318458 +v -0.488728 1.019641 0.316892 +v -0.491688 1.019090 0.315875 +v -0.494752 1.018361 0.315446 +v -0.497802 1.017483 0.315621 +v -0.500720 1.016489 0.316395 +v -0.503394 1.015417 0.317737 +v -0.505723 1.014308 0.319595 +v -0.507615 1.013206 0.321899 +v -0.508998 1.012151 0.324559 +v -0.509820 1.011186 0.327474 +v -0.510049 1.010347 0.330531 +v -0.509675 1.009667 0.333613 +v -0.508714 1.009170 0.336602 +v -0.507202 1.008878 0.339382 +v -0.505197 1.008799 0.341847 +v -0.502776 1.008939 0.343903 +v -0.500033 1.009291 0.345469 +v -0.497072 1.009842 0.346486 +v -0.494008 1.010571 0.346915 +v -0.490959 1.011449 0.346739 +v -0.488041 1.012443 0.345966 +v -0.277543 0.786707 0.537948 +v -0.288994 0.815456 0.533079 +v -0.305471 0.844683 0.518935 +v -0.328026 0.887146 0.501019 +v -0.354605 0.931433 0.476525 +v -0.383290 0.968461 0.443756 +v -0.412980 0.996808 0.403974 +v -0.232706 0.802725 0.508343 +v -0.246759 0.830544 0.505192 +v -0.267461 0.858262 0.493837 +v -0.295701 0.898694 0.479675 +v -0.329207 0.940506 0.459755 +v -0.365796 0.974710 0.432205 +v -0.404061 0.999994 0.398085 +v -0.195180 0.820703 0.470769 +v -0.211410 0.847479 0.469798 +v -0.235647 0.873503 0.461983 +v -0.268646 0.911656 0.452586 +v -0.307950 0.950690 0.438470 +v -0.351154 0.981725 0.417544 +v -0.396597 1.003570 0.390611 +v -0.166405 0.839951 0.426668 +v -0.184304 0.865610 0.428256 +v -0.211253 0.889820 0.424597 +v -0.247900 0.925533 0.420791 +v -0.291650 0.961593 0.413490 +v -0.339926 0.989235 0.400337 +v -0.390873 1.007398 0.381839 +v -0.147488 0.859728 0.377737 +v -0.166485 0.884240 0.382163 +v -0.195216 0.906587 0.383114 +v -0.234262 0.939792 0.385513 +v -0.280935 0.972796 0.385772 +v -0.332545 0.996952 0.381245 +v -0.387111 1.011332 0.372106 +v -0.139156 0.879276 0.325854 +v -0.158636 0.902654 0.333291 +v -0.188153 0.923159 0.339131 +v -0.228255 0.953885 0.348108 +v -0.276215 0.983869 0.356383 +v -0.329294 1.004579 0.361001 +v -0.385453 1.015221 0.361786 +v -0.141728 0.897842 0.273015 +v -0.161060 0.920143 0.283518 +v -0.190334 0.938898 0.294336 +v -0.230110 0.967270 0.310013 +v -0.277672 0.994386 0.326452 +v -0.330298 1.011823 0.340385 +v -0.385965 1.018914 0.351275 +v -0.155107 0.914714 0.221250 +v -0.173662 0.936036 0.234756 +v -0.201675 0.953201 0.250451 +v -0.239755 0.979434 0.272692 +v -0.285250 1.003943 0.297129 +v -0.335518 1.018407 0.320187 +v -0.388626 1.022270 0.340979 +v -0.178777 0.929242 0.172547 +v -0.195959 0.949721 0.188879 +v -0.221742 0.965518 0.209163 +v -0.256821 0.989908 0.237580 +v -0.298659 1.012172 0.269541 +v -0.344754 1.024075 0.301184 +v -0.393334 1.025160 0.331291 +v -0.211830 0.940869 0.128779 +v -0.227094 0.960673 0.147651 +v -0.249763 0.975375 0.172058 +v -0.280650 0.998291 0.206025 +v -0.317382 1.018759 0.244749 +v -0.357650 1.028612 0.284106 +v -0.399909 1.027472 0.322585 +v -0.252995 0.949148 0.091628 +v -0.265871 0.968472 0.112655 +v -0.284661 0.982393 0.140563 +v -0.310328 1.004259 0.179240 +v -0.340700 1.023448 0.223704 +v -0.373712 1.031842 0.269611 +v -0.408097 1.029119 0.315195 +v -0.300690 0.953760 0.062521 +v -0.310798 0.972816 0.085236 +v -0.325095 0.986303 0.115887 +v -0.344715 1.007585 0.158255 +v -0.367717 1.026061 0.207217 +v -0.392322 1.033641 0.258254 +v -0.417584 1.030036 0.309405 +v -0.353083 0.954529 0.042576 +v -0.360151 0.973540 0.066449 +v -0.369511 0.986955 0.098979 +v -0.382487 1.008139 0.143876 +v -0.397395 1.026496 0.195919 +v -0.412764 1.033941 0.250472 +v -0.428006 1.030189 0.305438 +v -0.408159 0.951424 0.032561 +v -0.412031 0.970616 0.057016 +v -0.416202 0.984323 0.090489 +v -0.422195 1.005901 0.136656 +v -0.428593 1.024737 0.190246 +v -0.434254 1.032730 0.246564 +v -0.438961 1.029572 0.303446 +v -0.463802 0.944565 0.032861 +v -0.464446 0.964155 0.057297 +v -0.463374 0.978508 0.090743 +v -0.462312 1.000956 0.136871 +v -0.460112 1.020852 0.190415 +v -0.455965 1.030054 0.246681 +v -0.450029 1.028207 0.303506 +v -0.517874 0.934216 0.043462 +v -0.515381 0.954407 0.067284 +v -0.509215 0.969735 0.099731 +v -0.501296 0.993495 0.144515 +v -0.490742 1.014990 0.196421 +v -0.477063 1.026016 0.250818 +v -0.460785 1.026149 0.305614 +v -0.568297 0.920775 0.063960 +v -0.562879 0.941745 0.086592 +v -0.551961 0.958340 0.117107 +v -0.537649 0.983804 0.159293 +v -0.519304 1.007376 0.208032 +v -0.496737 1.020771 0.258815 +v -0.470815 1.023475 0.309692 +v -0.613134 0.904757 0.093564 +v -0.605114 0.926657 0.114479 +v -0.589972 0.944761 0.142205 +v -0.569974 0.972256 0.180636 +v -0.544702 0.998303 0.224802 +v -0.514231 1.014522 0.270366 +v -0.480455 1.016774 0.313963 +v -0.650660 0.886779 0.131139 +v -0.640463 0.909722 0.149873 +v -0.621785 0.929520 0.174059 +v -0.597029 0.959294 0.207726 +v -0.565959 0.988119 0.246086 +v -0.528874 1.007507 0.285027 +v -0.489434 1.012130 0.319679 +v -0.679435 0.867532 0.175239 +v -0.667568 0.891591 0.191415 +v -0.646179 0.913202 0.211446 +v -0.617775 0.945418 0.239521 +v -0.582259 0.977216 0.271067 +v -0.540101 0.999997 0.302234 +v -0.495741 1.007945 0.328309 +v -0.698352 0.847754 0.224171 +v -0.685388 0.872961 0.237508 +v -0.662217 0.896436 0.252928 +v -0.631413 0.931159 0.274799 +v -0.592974 0.966013 0.298784 +v -0.547482 0.992280 0.321327 +v -0.499139 1.004188 0.338610 +v -0.706684 0.828206 0.276053 +v -0.693237 0.854547 0.286380 +v -0.669280 0.879864 0.296912 +v -0.637420 0.917066 0.312204 +v -0.597694 0.954940 0.328173 +v -0.550733 0.984653 0.341570 +v -0.498901 1.001679 0.349947 +v -0.442533 1.015384 0.358706 +v -0.704112 0.809640 0.328892 +v -0.690813 0.837058 0.336153 +v -0.667099 0.864124 0.341706 +v -0.635565 0.903680 0.350298 +v -0.596237 0.944423 0.358104 +v -0.549729 0.977409 0.362187 +v -0.497830 1.001369 0.362390 +v -0.690733 0.792768 0.380658 +v -0.678211 0.821166 0.384915 +v -0.655757 0.849821 0.385591 +v -0.625920 0.891516 0.387619 +v -0.588658 0.934866 0.387427 +v -0.544509 0.970826 0.382385 +v -0.495169 0.998013 0.372687 +v -0.667063 0.778240 0.429360 +v -0.655914 0.807480 0.430792 +v -0.635691 0.837505 0.426879 +v -0.608854 0.881042 0.422732 +v -0.575250 0.926637 0.415015 +v -0.535273 0.965157 0.401388 +v -0.490460 0.995123 0.382374 +v -0.634010 0.766613 0.473128 +v -0.624779 0.796528 0.472020 +v -0.607670 0.827648 0.463984 +v -0.585025 0.872659 0.454287 +v -0.556527 0.920050 0.439807 +v -0.522377 0.960620 0.418465 +v -0.483886 0.992811 0.391080 +v -0.592845 0.758335 0.510280 +v -0.586002 0.788730 0.507016 +v -0.572772 0.820629 0.495479 +v -0.555346 0.866691 0.481071 +v -0.533209 0.915361 0.460852 +v -0.506315 0.957390 0.432961 +v -0.475698 0.991164 0.398470 +v -0.545150 0.753722 0.539387 +v -0.541074 0.784385 0.534435 +v -0.532338 0.816719 0.520155 +v -0.520960 0.863366 0.502056 +v -0.506192 0.912748 0.477340 +v -0.487705 0.955591 0.444318 +v -0.466210 0.990246 0.404260 +v -0.492758 0.752954 0.559331 +v -0.491722 0.783661 0.553222 +v -0.487922 0.816068 0.537063 +v -0.483188 0.862811 0.516435 +v -0.476514 0.912313 0.488637 +v -0.467263 0.955291 0.452100 +v -0.455789 0.990094 0.408227 +v -0.437681 0.756058 0.569346 +v -0.439842 0.786585 0.562656 +v -0.441231 0.818700 0.545553 +v -0.443480 0.865050 0.523656 +v -0.445316 0.914072 0.494310 +v -0.445773 0.956502 0.456007 +v -0.444834 0.990711 0.410219 +v -0.382038 0.762917 0.569047 +v -0.387427 0.793046 0.562374 +v -0.394059 0.824514 0.545299 +v -0.403363 0.869995 0.523440 +v -0.413797 0.917957 0.494141 +v -0.424062 0.959178 0.455890 +v -0.433766 0.992075 0.410160 +v -0.327966 0.773266 0.558445 +v -0.336492 0.802794 0.552387 +v -0.348218 0.833287 0.536312 +v -0.364379 0.877456 0.515796 +v -0.383167 0.923819 0.488135 +v -0.402964 0.963216 0.451754 +v -0.423010 0.994134 0.408051 +v -0.377985 0.891508 0.314816 +v -0.379611 0.900920 0.313675 +v -0.398062 0.983969 0.424789 +v -0.384779 0.988715 0.416018 +v -0.374513 0.971776 0.438129 +v -0.408520 0.998457 0.401060 +v -0.373661 0.994041 0.404886 +v -0.358431 0.978413 0.425012 +v -0.400327 1.001839 0.394377 +v -0.365136 0.999743 0.391821 +v -0.393731 1.005542 0.386253 +v -0.345486 0.985682 0.409064 +v -0.359532 1.005602 0.377325 +v -0.336174 0.993302 0.390899 +v -0.388987 1.009424 0.376998 +v -0.357064 1.011394 0.361954 +v -0.330853 1.000980 0.371215 +v -0.386276 1.013336 0.366969 +v -0.357826 1.016894 0.346300 +v -0.329728 1.008422 0.350767 +v -0.385703 1.017128 0.356551 +v -0.361789 1.021892 0.330964 +v -0.387290 1.020653 0.346145 +v -0.332843 1.015342 0.330343 +v -0.368802 1.026197 0.316536 +v -0.340077 1.021473 0.310726 +v -0.390976 1.023776 0.336151 +v -0.378594 1.029641 0.303569 +v -0.351153 1.026580 0.292671 +v -0.396619 1.026378 0.326952 +v -0.390790 1.032094 0.292562 +v -0.365644 1.030466 0.276871 +v -0.404002 1.028359 0.318902 +v -0.404920 1.033460 0.283939 +v -0.412841 1.029641 0.312311 +v -0.382994 1.032983 0.263933 +v -0.420441 1.033688 0.278030 +v -0.402537 1.034034 0.254356 +v -0.422798 1.030176 0.307432 +v -0.436758 1.032768 0.275063 +v -0.423521 1.033578 0.248506 +v -0.433489 1.029944 0.304451 +v -0.453243 1.030736 0.275152 +v -0.445139 1.031632 0.246609 +v -0.444503 1.028953 0.303485 +v -0.469262 1.027670 0.278293 +v -0.466562 1.028273 0.248738 +v -0.455417 1.027241 0.304569 +v -0.484201 1.023688 0.284366 +v -0.486965 1.023627 0.254810 +v -0.465812 1.024874 0.307663 +v -0.496772 1.015887 0.292947 +v -0.505565 1.017875 0.264592 +v -0.473255 1.019645 0.315419 +v -0.508371 1.009900 0.303056 +v -0.521647 1.011238 0.277709 +v -0.483273 1.014518 0.318496 +v -0.517039 1.004095 0.315776 +v -0.534592 1.003969 0.293657 +v -0.490648 1.010345 0.325370 +v -0.522337 0.998472 0.330299 +v -0.543904 0.996349 0.311822 +v -0.495320 1.006522 0.334484 +v -0.523969 0.993633 0.345999 +v -0.480696 1.007079 0.352749 +v -0.549225 0.988671 0.331506 +v -0.496785 1.003461 0.344855 +v -0.524437 0.990763 0.362854 +v -0.550349 0.981229 0.351954 +v -0.494152 1.002545 0.356183 +v -0.520474 0.985765 0.378190 +v -0.547235 0.974309 0.372378 +v -0.496519 0.999748 0.367562 +v -0.513461 0.981461 0.392619 +v -0.492833 0.996624 0.377556 +v -0.540001 0.968178 0.391995 +v -0.503669 0.978016 0.405586 +v -0.528925 0.963071 0.410051 +v -0.487190 0.994022 0.386755 +v -0.491473 0.975564 0.416592 +v -0.514434 0.959185 0.425850 +v -0.479807 0.992042 0.394805 +v -0.477343 0.974197 0.425215 +v -0.497084 0.956668 0.438788 +v -0.470968 0.990760 0.401396 +v -0.461821 0.973969 0.431124 +v -0.461011 0.990224 0.406276 +v -0.477541 0.955617 0.448365 +v -0.445505 0.974889 0.434091 +v -0.456557 0.956073 0.454215 +v -0.450320 0.990457 0.409256 +v -0.429020 0.976921 0.434002 +v -0.434939 0.958019 0.456112 +v -0.439306 0.991448 0.410223 +v -0.413000 0.979987 0.430861 +v -0.413516 0.961378 0.453983 +v -0.428392 0.993160 0.409138 +v -0.427857 1.007615 0.382042 +v -0.423371 1.009218 0.379079 +v -0.419616 1.011017 0.375319 +v -0.416736 1.012943 0.370907 +v -0.414843 1.014922 0.366010 +v -0.414010 1.016878 0.360818 +v -0.414267 1.018736 0.355531 +v -0.415606 1.020425 0.350351 +v -0.417974 1.021878 0.345478 +v -0.421282 1.023042 0.341098 +v -0.425401 1.023870 0.337380 +v -0.430174 1.024332 0.334468 +v -0.435416 1.024409 0.332472 +v -0.440928 1.024098 0.331470 +v -0.446496 1.023412 0.331500 +v -0.451907 1.022376 0.332561 +v -0.456952 1.021031 0.334612 +v -0.468517 1.017045 0.328992 +v -0.475444 1.013756 0.331794 +v -0.479959 1.010818 0.337605 +v -0.482112 1.008299 0.344802 +v -0.470543 1.009910 0.361122 +v -0.469204 1.008222 0.366302 +v -0.466835 1.006768 0.371176 +v -0.463528 1.005605 0.375556 +v -0.459409 1.004776 0.379273 +v -0.454636 1.004315 0.382186 +v -0.449393 1.004238 0.384182 +v -0.443882 1.004549 0.385184 +v -0.438314 1.005235 0.385154 +v -0.432903 1.006270 0.384093 +v -0.417997 0.995526 0.406044 +v -0.393113 0.966024 0.447911 +v -0.391411 0.986459 0.420481 +v -0.379205 0.991497 0.410525 +v -0.369379 0.997014 0.398420 +v -0.362311 1.002798 0.384633 +v -0.358272 1.008626 0.369692 +v -0.357419 1.014275 0.354172 +v -0.359783 1.019527 0.338669 +v -0.365274 1.024180 0.323780 +v -0.373680 1.028056 0.310075 +v -0.384679 1.031006 0.298083 +v -0.397849 1.032917 0.288263 +v -0.412682 1.033714 0.280994 +v -0.428609 1.033368 0.276554 +v -0.445018 1.031892 0.275114 +v -0.461278 1.029341 0.276729 +v -0.476764 1.025816 0.281338 +v -0.489888 1.019368 0.289406 +v -0.502516 1.012886 0.298052 +v -0.512663 1.007077 0.309465 +v -0.519650 1.001359 0.323095 +v -0.523079 0.996059 0.338165 +v -0.523164 0.992139 0.354316 +v -0.522510 0.988382 0.370575 +v -0.517020 0.983729 0.385465 +v -0.508613 0.979852 0.399169 +v -0.497614 0.976902 0.411161 +v -0.484445 0.974992 0.420981 +v -0.469612 0.974194 0.428251 +v -0.453684 0.974541 0.432691 +v -0.437276 0.976017 0.434130 +v -0.421016 0.978567 0.432515 +v -0.405529 0.982093 0.427906 +vn 0.258370 0.533799 0.805139 +vn 0.268197 0.516129 0.813410 +vn 0.363964 0.571520 0.735435 +vn 0.190466 0.644063 0.740837 +vn 0.278390 0.675283 0.682974 +vn 0.108158 0.753349 0.648640 +vn 0.319651 0.415021 0.851802 +vn 0.370983 0.296793 0.879910 +vn 0.503952 0.344279 0.792108 +vn 0.376263 0.554735 0.742058 +vn 0.466720 0.598071 0.651479 +vn 0.452315 0.613849 0.646962 +vn 0.173437 0.778497 0.603168 +vn 0.351848 0.710471 0.609394 +vn 0.440535 0.458205 0.771966 +vn 0.541704 0.506668 0.670675 +vn 0.619282 0.558550 0.551775 +vn 0.536088 0.644490 0.545152 +vn 0.408338 0.748039 0.523118 +vn 0.227454 0.804559 0.548540 +vn 0.615253 0.397595 0.680685 +vn 0.700583 0.454695 0.549883 +vn 0.670278 0.611896 0.419843 +vn 0.581683 0.692160 0.427229 +vn 0.520066 0.659169 0.543107 +vn 0.564623 0.705741 0.427900 +vn 0.445021 0.786981 0.427259 +vn 0.297281 0.859554 0.415632 +vn 0.461715 0.825037 0.325663 +vn 0.756706 0.513352 0.404767 +vn 0.781396 0.571306 0.250893 +vn 0.601764 0.739280 0.302164 +vn 0.584246 0.751762 0.305734 +vn 0.595569 0.784020 0.174780 +vn 0.456282 0.861599 0.222297 +vn 0.305673 0.914975 0.263344 +vn 0.692740 0.664602 0.279977 +vn 0.685812 0.714652 0.137516 +vn 0.649739 0.760125 -0.002014 +vn 0.578173 0.795495 0.181310 +vn 0.546678 0.835200 0.059420 +vn 0.430280 0.894559 0.120853 +vn 0.773766 0.626392 0.094211 +vn 0.734092 0.676412 -0.059297 +vn 0.585925 0.799310 -0.133335 +vn 0.563311 0.824702 0.049989 +vn 0.490951 0.869411 -0.055239 +vn 0.283547 0.940519 0.187078 +vn 0.383923 0.923002 0.025483 +vn 0.248909 0.961455 0.116733 +vn 0.319376 0.945677 -0.060305 +vn 0.663900 0.719504 -0.203742 +vn 0.565874 0.753990 -0.333537 +vn 0.506272 0.859706 -0.067385 +vn 0.426588 0.887753 -0.172887 +vn 0.413099 0.896786 -0.158300 +vn 0.327372 0.907712 -0.262429 +vn 0.238655 0.961943 -0.132847 +vn 0.144200 0.989532 0.002564 +vn 0.496811 0.830653 -0.251320 +vn 0.443800 0.778527 -0.443709 +vn 0.385815 0.852962 -0.351482 +vn 0.257241 0.865413 -0.429975 +vn 0.316172 0.916288 -0.245766 +vn 0.203864 0.927152 -0.314310 +vn 0.145268 0.970977 -0.189856 +vn 0.075381 0.996338 -0.039857 +vn 0.302347 0.792199 -0.530045 +vn 0.115970 0.867458 -0.483718 +vn 0.212378 0.918821 -0.332591 +vn 0.086093 0.920682 -0.380688 +vn 0.080508 0.928953 -0.361278 +vn 0.042604 0.972533 -0.228706 +vn -0.001648 0.997406 -0.071718 +vn -0.065127 0.966369 -0.248756 +vn 0.146977 0.794488 -0.589190 +vn -0.016327 0.785272 -0.618885 +vn -0.046632 0.913175 -0.404828 +vn -0.049165 0.921659 -0.384838 +vn -0.174047 0.953001 -0.247932 +vn -0.160466 0.983459 -0.083865 +vn -0.032472 0.859096 -0.510727 +vn -0.182501 0.840602 -0.509934 +vn -0.180761 0.896664 -0.404096 +vn -0.180181 0.905484 -0.384136 +vn -0.328288 0.812708 -0.481338 +vn -0.311106 0.871700 -0.378521 +vn -0.279916 0.932798 -0.226966 +vn -0.241310 0.967864 -0.070437 +vn -0.181371 0.764946 -0.618000 +vn -0.341716 0.734245 -0.586566 +vn -0.464217 0.776482 -0.426069 +vn -0.432661 0.839320 -0.329142 +vn -0.307505 0.881130 -0.359172 +vn -0.426221 0.849483 -0.310923 +vn -0.378704 0.906400 -0.187017 +vn -0.318094 0.947844 -0.019959 +vn -0.466567 0.874966 -0.129276 +vn -0.491256 0.694388 -0.525773 +vn -0.585101 0.733299 -0.346263 +vn -0.540727 0.800684 -0.257759 +vn -0.531785 0.811762 -0.241218 +vn -0.539811 0.839930 -0.055361 +vn -0.392438 0.914274 0.100253 +vn -0.624226 0.646870 -0.437971 +vn -0.735527 0.593554 -0.326548 +vn -0.631184 0.757347 -0.167180 +vn -0.620167 0.769433 -0.152715 +vn -0.686270 0.684805 -0.244972 +vn -0.700552 0.710959 -0.060884 +vn -0.596423 0.802057 0.030671 +vn -0.763848 0.632923 -0.126072 +vn -0.820856 0.536485 -0.195746 +vn -0.814844 0.579608 0.005829 +vn -0.687918 0.724113 -0.048891 +vn -0.732475 0.677541 0.066286 +vn -0.633168 0.763543 0.126682 +vn -0.450942 0.866421 0.214362 +vn -0.649648 0.725150 0.228217 +vn -0.876980 0.477828 -0.050630 +vn -0.837306 0.526902 0.145695 +vn -0.746147 0.663289 0.057039 +vn -0.766259 0.616169 0.182104 +vn -0.752068 0.631519 0.188452 +vn -0.644765 0.688650 0.331614 +vn -0.471847 0.838008 0.274026 +vn -0.901669 0.419843 0.103214 +vn -0.894040 0.364788 0.259926 +vn -0.830378 0.476852 0.288156 +vn -0.760033 0.571398 0.309488 +vn -0.746025 0.587786 0.312876 +vn -0.714530 0.548051 0.434767 +vn -0.618244 0.655934 0.432997 +vn -0.492691 0.762169 0.419904 +vn -0.854366 0.314768 0.413434 +vn -0.727805 0.530747 0.434248 +vn -0.794305 0.431349 0.427717 +vn -0.784173 0.271676 0.557878 +vn -0.670736 0.495712 0.551653 +vn -0.572192 0.627155 0.528398 +vn -0.507370 0.604572 0.614002 +vn -0.410199 0.725974 0.551958 +vn -0.730491 0.392193 0.559038 +vn -0.686148 0.237190 0.687674 +vn -0.591052 0.467696 0.657155 +vn -0.658773 0.513840 0.549455 +vn -0.580950 0.486465 0.652516 +vn -0.426649 0.588549 0.686697 +vn -0.350322 0.712088 0.608386 +vn -0.641377 0.360851 0.677023 +vn -0.564074 0.212653 0.797845 +vn -0.491836 0.447737 0.746727 +vn -0.484024 0.466994 0.739982 +vn -0.376873 0.436628 0.816889 +vn -0.333323 0.579333 0.743797 +vn -0.530412 0.338511 0.777184 +vn -0.422620 0.198950 0.884182 +vn -0.401807 0.326090 0.855678 +vn -0.267220 0.196692 0.943327 +vn -0.250557 0.434767 0.864956 +vn -0.371715 0.456130 0.808527 +vn -0.248360 0.454329 0.855495 +vn -0.278390 0.706839 0.650258 +vn -0.230811 0.577624 0.782952 +vn -0.122990 0.583911 0.802423 +vn -0.126743 0.710135 0.692526 +vn -0.260567 0.324015 0.909452 +vn -0.103885 0.205878 0.973022 +vn -0.117801 0.442244 0.889096 +vn -0.118656 0.461623 0.879086 +vn -0.014039 0.597522 0.801721 +vn -0.043764 0.718741 0.693838 +vn -0.112064 0.332377 0.936430 +vn 0.061098 0.226234 0.972137 +vn 0.016297 0.458785 0.888363 +vn 0.012329 0.477767 0.878384 +vn 0.146641 0.483718 0.862819 +vn 0.091922 0.617420 0.781213 +vn 0.037904 0.350871 0.935636 +vn 0.221442 0.256935 0.940703 +vn 0.183691 0.378765 0.907041 +vn 0.139653 0.502152 0.853420 +vn 0.137364 0.767022 0.626698 +vn 0.197119 0.791528 0.578448 +vn 0.245308 0.818384 0.519669 +vn 0.265969 0.832698 0.485641 +vn 0.281381 0.847896 0.449293 +vn 0.300119 0.874966 0.379925 +vn 0.305216 0.889309 0.340465 +vn 0.304483 0.903775 0.300699 +vn 0.293497 0.928159 0.228706 +vn 0.267098 0.950926 0.156041 +vn 0.226447 0.969909 0.089084 +vn 0.200537 0.978027 0.056612 +vn 0.170293 0.984985 0.027863 +vn 0.105899 0.994171 -0.019684 +vn 0.033448 0.997925 -0.054811 +vn -0.040498 0.996307 -0.075411 +vn -0.082186 0.993225 -0.081912 +vn -0.124241 0.988769 -0.082766 +vn -0.203436 0.976226 -0.074557 +vn -0.275338 0.959868 -0.053133 +vn -0.325236 0.945494 0.015259 +vn -0.354930 0.933622 0.048494 +vn -0.366375 0.926969 0.080355 +vn -0.400922 0.906583 0.131565 +vn -0.422010 0.892666 0.158086 +vn -0.431684 0.881405 0.191595 +vn -0.452345 0.856624 0.248085 +vn -0.478347 0.821619 0.309976 +vn -0.497269 0.799921 0.335856 +vn -0.499557 0.776391 0.384198 +vn -0.474075 0.754753 0.453352 +vn -0.455031 0.743797 0.489517 +vn -0.431166 0.734977 0.523301 +vn -0.377270 0.720725 0.581530 +vn -0.316111 0.711844 0.627125 +vn -0.243995 0.707816 0.662862 +vn -0.204016 0.707389 0.676717 +vn -0.162694 0.709586 0.685537 +vn -0.082705 0.716910 0.692190 +vn -0.007202 0.728751 0.684683 +vn 0.033296 0.736656 0.675436 +vn 0.071810 0.746757 0.661184 +vn -0.084292 0.879818 0.467727 +vn -0.050356 0.860195 0.507401 +vn -0.024201 0.871609 0.489578 +vn -0.042756 0.899625 0.434553 +vn -0.001221 0.883602 0.468154 +vn 0.020631 0.895108 0.445326 +vn -0.008972 0.919279 0.393414 +vn 0.038697 0.906919 0.419507 +vn 0.055422 0.918058 0.392499 +vn 0.015687 0.938078 0.345988 +vn 0.067934 0.929136 0.363384 +vn 0.078890 0.939482 0.333323 +vn 0.030366 0.955321 0.293924 +vn 0.085299 0.949522 0.301767 +vn 0.090060 0.958678 0.269845 +vn 0.034425 0.970306 0.239357 +vn 0.090091 0.967223 0.237342 +vn 0.088504 0.974822 0.204566 +vn 0.027741 0.982452 0.184332 +vn 0.082217 0.981597 0.172246 +vn 0.074313 0.987335 0.140019 +vn 0.010620 0.991302 0.131046 +vn 0.061922 0.992065 0.109134 +vn 0.048036 0.995727 0.078738 +vn -0.016358 0.996521 0.081454 +vn 0.029969 0.998260 0.050417 +vn 0.010620 0.999664 0.022919 +vn -0.052126 0.997925 0.037416 +vn -0.012268 0.999908 -0.001556 +vn -0.036378 0.999023 -0.025056 +vn -0.095340 0.995422 0.000732 +vn -0.063387 0.996948 -0.045015 +vn -0.091250 0.993774 -0.063540 +vn -0.144261 0.989135 -0.027161 +vn -0.121311 0.989532 -0.078066 +vn -0.151860 0.984191 -0.091006 +vn -0.197119 0.979308 -0.045320 +vn -0.183813 0.977905 -0.099521 +vn -0.215918 0.970580 -0.106388 +vn -0.251778 0.966308 -0.052980 +vn -0.248482 0.962523 -0.108554 +vn -0.280892 0.953520 -0.109043 +vn -0.306192 0.950652 -0.049837 +vn -0.312845 0.943968 -0.104862 +vn -0.344340 0.933592 -0.098972 +vn -0.358318 0.932890 -0.036042 +vn -0.374493 0.922971 -0.088504 +vn -0.403760 0.911649 -0.076510 +vn -0.406018 0.913755 -0.012085 +vn -0.430921 0.900357 -0.060244 +vn -0.456923 0.888455 -0.042482 +vn -0.447584 0.893979 0.021058 +vn -0.480056 0.876949 -0.020936 +vn -0.501816 0.864956 0.001770 +vn -0.481338 0.874294 0.062136 +vn -0.520035 0.853664 0.027650 +vn -0.536607 0.842036 0.054445 +vn -0.506027 0.855495 0.109653 +vn -0.549242 0.831416 0.083834 +vn -0.560045 0.820582 0.113834 +vn -0.520707 0.838282 0.161657 +vn -0.566576 0.811029 0.145390 +vn -0.571215 0.801416 0.177252 +vn -0.524796 0.823298 0.216163 +vn -0.571398 0.793359 0.209906 +vn -0.569689 0.785241 0.242470 +vn -0.518113 0.811151 0.271218 +vn -0.563524 0.778954 0.274972 +vn -0.555498 0.772729 0.306986 +vn -0.500961 0.802301 0.324534 +vn -0.543229 0.768517 0.337992 +vn -0.529191 0.764336 0.368328 +vn -0.473952 0.797082 0.374157 +vn -0.511307 0.762322 0.396741 +vn -0.491836 0.760399 0.424116 +vn -0.438185 0.795679 0.418165 +vn -0.468978 0.760643 0.448775 +vn -0.444777 0.761040 0.472152 +vn -0.394971 0.798181 0.454848 +vn -0.417859 0.763573 0.492203 +vn -0.389874 0.766289 0.510636 +vn -0.346049 0.804437 0.482803 +vn -0.359966 0.771050 0.525224 +vn -0.329264 0.775903 0.538072 +vn -0.293191 0.814295 0.500931 +vn -0.297464 0.782678 0.546709 +vn -0.265236 0.789483 0.553453 +vn -0.238533 0.827296 0.508591 +vn -0.232795 0.798059 0.555742 +vn -0.200262 0.806574 0.556139 +vn -0.184088 0.842982 0.505448 +vn -0.168432 0.816614 0.552049 +vn -0.136814 0.826472 0.546037 +vn -0.256111 0.936888 0.237953 +vn -0.206946 0.922849 0.324747 +vn -0.191351 0.929655 0.314798 +vn -0.178198 0.936552 0.301798 +vn -0.167974 0.943266 0.286355 +vn -0.161107 0.949553 0.268960 +vn -0.157811 0.955199 0.250313 +vn -0.158269 0.959899 0.231269 +vn -0.162420 0.963591 0.212348 +vn -0.170141 0.966063 0.194281 +vn -0.181127 0.967223 0.177892 +vn -0.194891 0.967009 0.163884 +vn -0.211066 0.965484 0.152562 +vn -0.228828 0.962676 0.144444 +vn -0.247566 0.958678 0.139958 +vn -0.266640 0.953673 0.139195 +vn -0.285195 0.947844 0.142186 +vn -0.302683 0.941374 0.148747 +vn -0.318308 0.934599 0.158696 +vn -0.331431 0.927732 0.171606 +vn -0.341655 0.920988 0.187170 +vn -0.348521 0.914670 0.204596 +vn -0.351817 0.909055 0.223151 +vn -0.351360 0.904324 0.242347 +vn -0.347209 0.900632 0.261238 +vn -0.339488 0.898190 0.279153 +vn -0.328501 0.897031 0.295572 +vn -0.314707 0.897214 0.309702 +vn -0.298593 0.898740 0.320994 +vn -0.280801 0.901578 0.329020 +vn -0.262032 0.905545 0.333537 +vn -0.242988 0.910581 0.334330 +vn -0.224372 0.916410 0.331370 +vn -0.132023 0.860714 0.491623 +vn -0.106815 0.837581 0.535722 +vn -0.077395 0.848445 0.523576 +vn -0.142369 0.907315 0.395581 +vn -0.059938 0.888516 0.454878 +vn -0.156590 0.899960 0.406842 +vn -0.105380 0.868709 0.483932 +vn -0.114292 0.920682 0.373180 +vn -0.021607 0.908597 0.417035 +vn -0.125858 0.913388 0.387097 +vn -0.091464 0.933988 0.345378 +vn 0.008118 0.928159 0.371990 +vn -0.099918 0.926969 0.361553 +vn -0.074740 0.946715 0.313211 +vn 0.028138 0.946501 0.321360 +vn -0.079745 0.940245 0.330973 +vn -0.064852 0.958342 0.278146 +vn 0.037690 0.962920 0.267037 +vn -0.066195 0.952635 0.296731 +vn -0.062075 0.968444 0.241249 +vn 0.036378 0.976714 0.211280 +vn -0.059725 0.963713 0.260048 +vn -0.066591 0.976684 0.203986 +vn 0.024232 0.987396 0.156194 +vn -0.060640 0.973083 0.222297 +vn -0.078188 0.982696 0.167882 +vn 0.001801 0.994598 0.103732 +vn -0.068819 0.980316 0.184881 +vn -0.096438 0.986206 0.134434 +vn -0.030122 0.997955 0.056124 +vn -0.084017 0.985168 0.149480 +vn -0.120640 0.987152 0.104678 +vn -0.070345 0.997406 0.015046 +vn -0.105655 0.987457 0.117222 +vn -0.149846 0.985473 0.079806 +vn -0.117252 0.992920 -0.017823 +vn -0.132908 0.987060 0.089389 +vn -0.182928 0.981231 0.060945 +vn -0.169042 0.984741 -0.041261 +vn -0.164647 0.984039 0.067110 +vn -0.218696 0.974548 0.048677 +vn -0.223823 0.973083 -0.054445 +vn -0.199683 0.978484 0.051271 +vn -0.255654 0.965758 0.043489 +vn -0.279305 0.958495 -0.056734 +vn -0.236763 0.970611 0.042390 +vn -0.292459 0.955168 0.045595 +vn -0.333506 0.941496 -0.048097 +vn -0.274300 0.960753 0.040803 +vn -0.327647 0.943175 0.054903 +vn -0.384350 0.922727 -0.028871 +vn -0.311075 0.949217 0.046632 +vn -0.359966 0.930235 0.071169 +vn -0.429792 0.902921 0.000153 +vn -0.345408 0.936521 0.059633 +vn -0.388012 0.916868 0.093539 +vn -0.468123 0.882839 0.037996 +vn -0.376202 0.923124 0.079348 +vn -0.410871 0.903562 0.121433 +vn -0.497879 0.863247 0.083041 +vn -0.402112 0.909543 0.104892 +vn -0.427564 0.890866 0.153386 +vn -0.517899 0.844905 0.133702 +vn -0.422285 0.896268 0.135441 +vn -0.437483 0.879177 0.188665 +vn -0.527451 0.828516 0.187933 +vn -0.435835 0.883847 0.169683 +vn -0.440230 0.869076 0.225562 +vn -0.526139 0.814722 0.243690 +vn -0.442305 0.872738 0.206580 +vn -0.435743 0.860866 0.262642 +vn -0.513993 0.804010 0.298898 +vn -0.441420 0.863430 0.244118 +vn -0.424116 0.854854 0.298837 +vn -0.491531 0.796838 0.351238 +vn -0.433210 0.856166 0.281533 +vn -0.405896 0.851314 0.332408 +vn -0.459578 0.793481 0.398938 +vn -0.418012 0.851314 0.316996 +vn -0.381695 0.850398 0.362072 +vn -0.419385 0.794031 0.439985 +vn -0.396374 0.849025 0.349284 +vn -0.352489 0.852077 0.386853 +vn -0.372448 0.798517 0.472884 +vn -0.369182 0.849422 0.377026 +vn -0.319346 0.856319 0.405805 +vn -0.320688 0.806696 0.496353 +vn -0.337382 0.852443 0.399335 +vn -0.283670 0.862972 0.418073 +vn -0.265908 0.818323 0.509476 +vn -0.302316 0.857997 0.415235 +vn -0.246681 0.871761 0.423231 +vn -0.210395 0.832911 0.511795 +vn -0.265297 0.865841 0.424116 +vn -0.209876 0.882351 0.421155 +vn -0.156194 0.849940 0.503159 +vn -0.227729 0.875729 0.425672 +vn -0.190985 0.887234 0.419843 +vn -0.174657 0.894375 0.411786 +vn 0.061892 0.835566 0.545854 +vn 0.103763 0.852840 0.511704 +vn 0.137455 0.871761 0.470199 +vn 0.161718 0.891598 0.422895 +vn 0.175573 0.911588 0.371654 +vn 0.178472 0.930967 0.318430 +vn 0.170385 0.948973 0.265267 +vn 0.151555 0.964934 0.214179 +vn 0.122715 0.978240 0.167180 +vn 0.084994 0.988372 0.126041 +vn 0.039827 0.994903 0.092349 +vn -0.011017 0.997650 0.067446 +vn -0.065645 0.996460 0.052187 +vn -0.121921 0.991394 0.047273 +vn -0.177709 0.982635 0.052797 +vn -0.230811 0.970550 0.068606 +vn -0.390851 0.897061 0.206030 +vn -0.299081 0.932707 0.201392 +vn -0.296548 0.929136 0.220740 +vn -0.308664 0.919218 0.244331 +vn -0.325114 0.911405 0.252174 +vn -0.369396 0.914640 0.164190 +vn -0.387707 0.842158 0.374676 +vn -0.368877 0.826197 0.425764 +vn -0.340068 0.812922 0.472762 +vn -0.302316 0.802789 0.513871 +vn -0.257149 0.796228 0.547563 +vn -0.206275 0.793512 0.572497 +vn -0.151646 0.794702 0.587725 +vn -0.095370 0.799768 0.592669 +vn -0.039613 0.808496 0.587115 +vn -0.143040 0.936674 0.319590 +vn -0.061800 0.907254 0.415937 +vn -0.046022 0.912900 0.405530 +vn -0.032807 0.919218 0.392315 +vn -0.022675 0.925993 0.376782 +vn -0.016022 0.932951 0.359569 +vn -0.013092 0.939817 0.341350 +vn -0.014008 0.946379 0.322733 +vn -0.018708 0.952300 0.304544 +vn -0.027039 0.957396 0.287393 +vn -0.038667 0.961486 0.272011 +vn -0.053163 0.964415 0.258919 +vn -0.069918 0.966033 0.248695 +vn -0.088351 0.966308 0.241676 +vn -0.107730 0.965209 0.238136 +vn -0.127323 0.962798 0.238258 +vn -0.146336 0.959166 0.241981 +vn -0.321970 0.881527 0.345286 +vn -0.380688 0.869778 0.313913 +vn -0.301431 0.917783 0.258431 +vn -0.284585 0.927305 0.243080 +vn -0.281472 0.934080 0.219550 +vn -0.277902 0.953856 0.113437 +vn -0.221809 0.963469 0.149876 +vn -0.207160 0.909391 0.360607 +vn -0.198828 0.904294 0.377728 +vn -0.187201 0.900204 0.393139 +vn -0.172704 0.897275 0.406201 +vn -0.155950 0.895657 0.416456 +vn -0.137516 0.895383 0.423475 +vn -0.118137 0.896481 0.426984 +vn -0.098544 0.898892 0.426893 +vn -0.079531 0.902524 0.423139 +vn 0.013459 0.820582 0.571306 +vn 0.003998 0.876949 0.480544 +vn 0.086428 0.842189 0.532151 +vn -0.010376 0.870479 0.492050 +vn 0.040468 0.825770 0.562487 +vn 0.032319 0.888638 0.457442 +vn 0.124882 0.860622 0.493637 +vn 0.020692 0.881588 0.471511 +vn 0.055086 0.901425 0.429395 +vn 0.154393 0.880367 0.448439 +vn 0.046724 0.894070 0.445448 +vn 0.071505 0.914823 0.397382 +vn 0.173772 0.900632 0.398267 +vn 0.066713 0.907407 0.414838 +vn 0.080874 0.928343 0.362774 +vn 0.182318 0.920652 0.345103 +vn 0.079836 0.921140 0.380871 +vn 0.082827 0.941435 0.326762 +vn 0.179662 0.939695 0.290933 +vn 0.085604 0.934690 0.344920 +vn 0.077364 0.953642 0.290780 +vn 0.165960 0.956999 0.237861 +vn 0.083834 0.947600 0.308237 +vn 0.064638 0.964415 0.256294 +vn 0.141697 0.971892 0.187964 +vn 0.074526 0.959288 0.272286 +vn 0.045106 0.973418 0.224494 +vn 0.107822 0.983795 0.143101 +vn 0.058107 0.969359 0.238533 +vn 0.019623 0.980255 0.196661 +vn 0.065615 0.992279 0.105014 +vn 0.035188 0.977447 0.208136 +vn -0.010895 0.984680 0.173894 +vn 0.016724 0.997009 0.075167 +vn 0.006623 0.983184 0.182379 +vn -0.045289 0.986541 0.157018 +vn -0.036927 0.997803 0.054720 +vn -0.026460 0.986389 0.162175 +vn -0.082247 0.985717 0.146733 +vn -0.093387 0.994629 0.044465 +vn -0.062777 0.986938 0.148350 +vn -0.120304 0.982299 0.143406 +vn -0.150426 0.987579 0.044771 +vn -0.101016 0.984771 0.141392 +vn -0.157994 0.976409 0.147160 +vn -0.205847 0.976989 0.055635 +vn -0.139622 0.980010 0.141606 +vn -0.193915 0.968230 0.157842 +vn -0.367077 0.919828 0.138340 +vn -0.177129 0.972839 0.148961 +vn -0.445692 0.840266 0.308634 +vn -0.332926 0.919370 0.209418 +vn -0.369915 0.897885 0.238655 +vn -0.323679 0.916166 0.236274 +vn -0.296152 0.931211 0.212287 +vn -0.373791 0.889798 0.261757 +vn -0.303201 0.925413 0.227180 +vn -0.302530 0.924284 0.232643 +vn -0.308603 0.923124 0.229255 +vn -0.307169 0.922178 0.234931 +vn -0.315043 0.915769 0.249153 +vn -0.303903 0.924039 0.231819 +vn -0.310923 0.926603 0.211371 +vn -0.336894 0.916135 0.217170 +vn -0.308420 0.923276 0.228919 +vn -0.314097 0.947935 0.051973 +vn -0.409345 0.885220 0.220801 +vn -0.316691 0.936521 0.150365 +vn -0.300027 0.881405 0.364788 +vn -0.383038 0.831996 0.401288 +vn -0.333079 0.928007 0.166845 +vn -0.287301 0.870602 0.399335 +vn -0.358776 0.817103 0.451186 +vn -0.297067 0.874691 0.382916 +vn -0.267800 0.861629 0.431104 +vn -0.324900 0.805170 0.496048 +vn -0.280648 0.864589 0.416700 +vn -0.242286 0.854762 0.458937 +vn -0.282693 0.796686 0.534135 +vn -0.257729 0.856533 0.447096 +vn -0.211737 0.850337 0.481704 +vn -0.233802 0.791955 0.563982 +vn -0.229163 0.850795 0.472854 +vn -0.177343 0.848506 0.498581 +vn -0.180120 0.791192 0.584429 +vn -0.196051 0.847591 0.493057 +vn -0.140385 0.849300 0.508866 +vn -0.123661 0.794366 0.594684 +vn -0.159703 0.847072 0.506882 +vn -0.102329 0.852718 0.512192 +vn -0.066622 0.801386 0.594378 +vn -0.121494 0.849208 0.513840 +vn -0.064638 0.858638 0.508469 +vn -0.011200 0.812006 0.583514 +vn -0.082888 0.853969 0.513627 +vn -0.045381 0.861141 0.506272 +vn -0.028718 0.866817 0.497757 +usemtl Eye-White +s 1 +f 7589//5144 7588//5145 7596//5146 +f 7590//5147 7589//5144 7597//5148 +f 7591//5149 7590//5147 7597//5148 +f 7587//5150 7586//5151 7593//5152 +f 7588//5145 7587//5150 7595//5153 +f 7596//5146 7595//5153 7602//5154 +f 7597//5148 7596//5146 7603//5155 +f 7598//5156 7597//5148 7604//5157 +f 7594//5158 7593//5152 7601//5159 +f 7595//5153 7594//5158 7602//5154 +f 7602//5154 7601//5159 7608//5160 +f 7603//5155 7602//5154 7609//5161 +f 7604//5157 7603//5155 7611//5162 +f 7605//5163 7604//5157 7611//5162 +f 7601//5159 7600//5164 7608//5160 +f 7608//5160 7607//5165 7615//5166 +f 7609//5161 7608//5160 7616//5167 +f 7610//5168 7609//5161 7617//5169 +f 7611//5162 7610//5168 7618//5170 +f 7611//5162 7618//5170 7619//5171 +f 7619//5171 7618//5170 7625//5172 +f 7615//5166 7614//5173 7621//5174 +f 7616//5167 7615//5166 7623//5175 +f 7617//5169 7616//5167 7623//5175 +f 7618//5170 7617//5169 7625//5172 +f 7624//5176 7623//5175 7630//5177 +f 7625//5172 7624//5176 7632//5178 +f 7625//5172 7632//5178 7633//5179 +f 7622//5180 7621//5174 7629//5181 +f 7623//5175 7622//5180 7630//5177 +f 7630//5177 7629//5181 7636//5182 +f 7631//5183 7630//5177 7638//5184 +f 7632//5178 7631//5183 7638//5184 +f 7633//5179 7632//5178 7639//5185 +f 7629//5181 7628//5186 7636//5182 +f 7636//5182 7635//5187 7643//5188 +f 7637//5189 7636//5182 7643//5188 +f 7638//5184 7637//5189 7645//5190 +f 7639//5185 7638//5184 7645//5190 +f 7640//5191 7639//5185 7646//5192 +f 7647//5193 7646//5192 7653//5194 +f 7643//5188 7642//5195 7649//5196 +f 7644//5197 7643//5188 7651//5198 +f 7645//5190 7644//5197 7652//5199 +f 7646//5192 7645//5190 7653//5194 +f 7652//5199 7651//5198 7658//5200 +f 7653//5194 7652//5199 7660//5201 +f 7653//5194 7660//5201 7661//5202 +f 7650//5203 7649//5196 7656//5204 +f 7651//5198 7650//5203 7658//5200 +f 7658//5200 7657//5205 7664//5206 +f 7659//5207 7658//5200 7666//5208 +f 7660//5201 7659//5207 7667//5209 +f 7660//5201 7667//5209 7668//5210 +f 7657//5205 7656//5204 7663//5211 +f 7664//5206 7663//5211 7671//5212 +f 7665//5213 7664//5206 7672//5214 +f 7666//5208 7665//5213 7673//5215 +f 7667//5209 7666//5208 7673//5215 +f 7667//5209 7674//5216 7675//5217 +f 7675//5217 7674//5216 7681//5218 +f 7671//5212 7670//5219 7677//5220 +f 7672//5214 7671//5212 7679//5221 +f 7673//5215 7672//5214 7680//5222 +f 7674//5216 7673//5215 7681//5218 +f 7681//5218 7680//5222 7688//5223 +f 7681//5218 7688//5223 7689//5224 +f 7678//5225 7677//5220 7685//5226 +f 7679//5221 7678//5225 7686//5227 +f 7680//5222 7679//5221 7687//5228 +f 7686//5227 7685//5226 7692//5229 +f 7687//5228 7686//5227 7693//5230 +f 7688//5223 7687//5228 7695//5231 +f 7688//5223 7695//5231 7696//5232 +f 7685//5226 7684//5233 7691//5234 +f 7692//5229 7691//5234 7699//5235 +f 7693//5230 7692//5229 7700//5236 +f 7694//5237 7693//5230 7701//5238 +f 7695//5231 7694//5237 7702//5239 +f 7696//5232 7695//5231 7702//5239 +f 7703//5240 7702//5239 7709//5241 +f 7699//5235 7698//5242 7706//5243 +f 7700//5236 7699//5235 7707//5244 +f 7701//5238 7700//5236 7707//5244 +f 7702//5239 7701//5238 7709//5241 +f 7709//5241 7708//5245 7716//5246 +f 7709//5241 7716//5246 7717//5247 +f 7706//5243 7705//5248 7712//5249 +f 7707//5244 7706//5243 7714//5250 +f 7708//5245 7707//5244 7715//5251 +f 7714//5250 7713//5252 7721//5253 +f 7715//5251 7714//5250 7721//5253 +f 7716//5246 7715//5251 7723//5254 +f 7717//5247 7716//5246 7723//5254 +f 7713//5252 7712//5249 7720//5255 +f 7720//5255 7719//5256 7727//5257 +f 7721//5253 7720//5255 7727//5257 +f 7722//5258 7721//5253 7729//5259 +f 7723//5254 7722//5258 7730//5260 +f 7723//5254 7730//5260 7731//5261 +f 7731//5261 7730//5260 7737//5262 +f 7727//5257 7726//5263 7734//5264 +f 7728//5265 7727//5257 7735//5266 +f 7729//5259 7728//5265 7736//5267 +f 7730//5260 7729//5259 7736//5267 +f 7737//5262 7736//5267 7745//5268 +f 7738//5269 7737//5262 7745//5268 +f 7734//5264 7733//5270 7741//5271 +f 7735//5266 7734//5264 7742//5272 +f 7736//5267 7735//5266 7743//5273 +f 7744//5274 7743//5273 7751//5275 +f 7745//5268 7744//5274 7752//5276 +f 7745//5268 7752//5276 7753//5277 +f 7742//5272 7741//5271 7748//5278 +f 7743//5273 7742//5272 7750//5279 +f 7749//5280 7748//5278 7755//5281 +f 7750//5279 7749//5280 7757//5282 +f 7751//5275 7750//5279 7757//5282 +f 7752//5276 7751//5275 7759//5283 +f 7753//5277 7752//5276 7759//5283 +f 7759//5283 7766//5284 7767//5285 +f 7756//5286 7755//5281 7762//5287 +f 7757//5282 7756//5286 7764//5288 +f 7758//5289 7757//5282 7765//5290 +f 7759//5283 7758//5289 7766//5284 +f 7766//5284 7765//5290 7773//5291 +f 7766//5284 7773//5291 7774//5292 +f 7763//5293 7762//5287 7769//5294 +f 7764//5288 7763//5293 7771//5295 +f 7765//5290 7764//5288 7772//5296 +f 7772//5296 7771//5295 7778//5297 +f 7773//5291 7772//5296 7780//5298 +f 7774//5292 7773//5291 7780//5298 +f 7770//5299 7769//5294 7776//5300 +f 7771//5295 7770//5299 7777//5301 +f 7777//5301 7776//5300 7783//5302 +f 7778//5297 7777//5301 7785//5303 +f 7779//5304 7778//5297 7785//5303 +f 7780//5298 7779//5304 7786//5305 +f 7781//5306 7780//5298 7787//5307 +f 7787//5307 7794//5308 7795//5309 +f 7784//5310 7783//5302 7790//5311 +f 7785//5303 7784//5310 7792//5312 +f 7786//5305 7785//5303 7793//5313 +f 7787//5307 7786//5305 7793//5313 +f 7794//5308 7793//5313 7801//5314 +f 7794//5308 7801//5314 7802//5315 +f 7791//5316 7790//5311 7797//5317 +f 7792//5312 7791//5316 7799//5318 +f 7793//5313 7792//5312 7800//5319 +f 7800//5319 7799//5318 7806//5320 +f 7801//5314 7800//5319 7808//5321 +f 7802//5315 7801//5314 7808//5321 +f 7798//5322 7797//5317 7804//5323 +f 7799//5318 7798//5322 7806//5320 +f 7806//5320 7805//5324 7587//5150 +f 7807//5325 7806//5320 7588//5145 +f 7808//5321 7807//5325 7589//5144 +f 7808//5321 7590//5147 7591//5149 +f 7805//5324 7804//5323 7586//5151 +f 7588//5145 7595//5153 7596//5146 +f 7589//5144 7596//5146 7597//5148 +f 7815//5326 7591//5149 7597//5148 +f 7598//5156 7815//5326 7597//5148 +f 7594//5158 7587//5150 7593//5152 +f 7587//5150 7594//5158 7595//5153 +f 7603//5155 7596//5146 7602//5154 +f 7604//5157 7597//5148 7603//5155 +f 7818//5327 7598//5156 7604//5157 +f 7605//5163 7818//5327 7604//5157 +f 7593//5152 7600//5164 7601//5159 +f 7594//5158 7601//5159 7602//5154 +f 7609//5161 7602//5154 7608//5160 +f 7610//5168 7603//5155 7609//5161 +f 7603//5155 7610//5168 7611//5162 +f 7822//5328 7605//5163 7611//5162 +f 7612//5329 7822//5328 7611//5162 +f 7600//5164 7607//5165 7608//5160 +f 7607//5165 7614//5173 7615//5166 +f 7608//5160 7615//5166 7616//5167 +f 7609//5161 7616//5167 7617//5169 +f 7610//5168 7617//5169 7618//5170 +f 7612//5329 7611//5162 7824//5330 +f 7611//5162 7619//5171 7824//5330 +f 7827//5331 7619//5171 7625//5172 +f 7626//5332 7827//5331 7625//5172 +f 7622//5180 7615//5166 7621//5174 +f 7615//5166 7622//5180 7623//5175 +f 7624//5176 7617//5169 7623//5175 +f 7617//5169 7624//5176 7625//5172 +f 7631//5183 7624//5176 7630//5177 +f 7624//5176 7631//5183 7632//5178 +f 7626//5332 7625//5172 7830//5333 +f 7625//5172 7633//5179 7830//5333 +f 7621//5174 7628//5186 7629//5181 +f 7622//5180 7629//5181 7630//5177 +f 7637//5189 7630//5177 7636//5182 +f 7630//5177 7637//5189 7638//5184 +f 7639//5185 7632//5178 7638//5184 +f 7834//5334 7633//5179 7639//5185 +f 7640//5191 7834//5334 7639//5185 +f 7628//5186 7635//5187 7636//5182 +f 7635//5187 7642//5195 7643//5188 +f 7644//5197 7637//5189 7643//5188 +f 7637//5189 7644//5197 7645//5190 +f 7646//5192 7639//5185 7645//5190 +f 7836//5335 7640//5191 7646//5192 +f 7647//5193 7836//5335 7646//5192 +f 7839//5336 7647//5193 7653//5194 +f 7654//5337 7839//5336 7653//5194 +f 7650//5203 7643//5188 7649//5196 +f 7643//5188 7650//5203 7651//5198 +f 7644//5197 7651//5198 7652//5199 +f 7645//5190 7652//5199 7653//5194 +f 7659//5207 7652//5199 7658//5200 +f 7652//5199 7659//5207 7660//5201 +f 7654//5337 7653//5194 7842//5338 +f 7653//5194 7661//5202 7842//5338 +f 7657//5205 7650//5203 7656//5204 +f 7650//5203 7657//5205 7658//5200 +f 7665//5213 7658//5200 7664//5206 +f 7658//5200 7665//5213 7666//5208 +f 7659//5207 7666//5208 7667//5209 +f 7661//5202 7660//5201 7846//5339 +f 7660//5201 7668//5210 7846//5339 +f 7664//5206 7657//5205 7663//5211 +f 7663//5211 7670//5219 7671//5212 +f 7664//5206 7671//5212 7672//5214 +f 7665//5213 7672//5214 7673//5215 +f 7674//5216 7667//5209 7673//5215 +f 7668//5210 7667//5209 7848//5340 +f 7667//5209 7675//5217 7848//5340 +f 7851//5341 7675//5217 7681//5218 +f 7682//5342 7851//5341 7681//5218 +f 7678//5225 7671//5212 7677//5220 +f 7671//5212 7678//5225 7679//5221 +f 7672//5214 7679//5221 7680//5222 +f 7673//5215 7680//5222 7681//5218 +f 7680//5222 7687//5228 7688//5223 +f 7682//5342 7681//5218 7854//5343 +f 7681//5218 7689//5224 7854//5343 +f 7677//5220 7684//5233 7685//5226 +f 7678//5225 7685//5226 7686//5227 +f 7679//5221 7686//5227 7687//5228 +f 7693//5230 7686//5227 7692//5229 +f 7694//5237 7687//5228 7693//5230 +f 7687//5228 7694//5237 7695//5231 +f 7689//5224 7688//5223 7857//5344 +f 7688//5223 7696//5232 7857//5344 +f 7692//5229 7685//5226 7691//5234 +f 7691//5234 7698//5242 7699//5235 +f 7692//5229 7699//5235 7700//5236 +f 7693//5230 7700//5236 7701//5238 +f 7694//5237 7701//5238 7702//5239 +f 7860//5345 7696//5232 7702//5239 +f 7703//5240 7860//5345 7702//5239 +f 7863//5346 7703//5240 7709//5241 +f 7710//5347 7863//5346 7709//5241 +f 7698//5242 7705//5248 7706//5243 +f 7699//5235 7706//5243 7707//5244 +f 7708//5245 7701//5238 7707//5244 +f 7701//5238 7708//5245 7709//5241 +f 7708//5245 7715//5251 7716//5246 +f 7710//5347 7709//5241 7866//5348 +f 7709//5241 7717//5247 7866//5348 +f 7713//5252 7706//5243 7712//5249 +f 7706//5243 7713//5252 7714//5250 +f 7707//5244 7714//5250 7715//5251 +f 7713//5252 7720//5255 7721//5253 +f 7722//5258 7715//5251 7721//5253 +f 7715//5251 7722//5258 7723//5254 +f 7869//5349 7717//5247 7723//5254 +f 7724//5350 7869//5349 7723//5254 +f 7712//5249 7719//5256 7720//5255 +f 7719//5256 7726//5263 7727//5257 +f 7728//5265 7721//5253 7727//5257 +f 7721//5253 7728//5265 7729//5259 +f 7722//5258 7729//5259 7730//5260 +f 7724//5350 7723//5254 7872//5351 +f 7723//5254 7731//5261 7872//5351 +f 7876//5352 7731//5261 7737//5262 +f 7738//5269 7876//5352 7737//5262 +f 7726//5263 7733//5270 7734//5264 +f 7727//5257 7734//5264 7735//5266 +f 7728//5265 7735//5266 7736//5267 +f 7737//5262 7730//5260 7736//5267 +f 7736//5267 7744//5274 7745//5268 +f 7879//5353 7738//5269 7745//5268 +f 7746//5354 7879//5353 7745//5268 +f 7742//5272 7734//5264 7741//5271 +f 7743//5273 7735//5266 7742//5272 +f 7744//5274 7736//5267 7743//5273 +f 7743//5273 7750//5279 7751//5275 +f 7744//5274 7751//5275 7752//5276 +f 7746//5354 7745//5268 7882//5355 +f 7745//5268 7753//5277 7882//5355 +f 7749//5280 7742//5272 7748//5278 +f 7742//5272 7749//5280 7750//5279 +f 7756//5286 7749//5280 7755//5281 +f 7749//5280 7756//5286 7757//5282 +f 7758//5289 7751//5275 7757//5282 +f 7751//5275 7758//5289 7759//5283 +f 7886//5356 7753//5277 7759//5283 +f 7760//5357 7886//5356 7759//5283 +f 7760//5357 7759//5283 7888//5358 +f 7759//5283 7767//5285 7888//5358 +f 7763//5293 7756//5286 7762//5287 +f 7756//5286 7763//5293 7764//5288 +f 7757//5282 7764//5288 7765//5290 +f 7758//5289 7765//5290 7766//5284 +f 7765//5290 7772//5296 7773//5291 +f 7767//5285 7766//5284 7891//5359 +f 7766//5284 7774//5292 7891//5359 +f 7770//5299 7763//5293 7769//5294 +f 7763//5293 7770//5299 7771//5295 +f 7764//5288 7771//5295 7772//5296 +f 7779//5304 7772//5296 7778//5297 +f 7772//5296 7779//5304 7780//5298 +f 7894//5360 7774//5292 7780//5298 +f 7781//5306 7894//5360 7780//5298 +f 7777//5301 7770//5299 7776//5300 +f 7778//5297 7771//5295 7777//5301 +f 7784//5310 7777//5301 7783//5302 +f 7777//5301 7784//5310 7785//5303 +f 7786//5305 7779//5304 7785//5303 +f 7787//5307 7780//5298 7786//5305 +f 7898//5361 7781//5306 7787//5307 +f 7788//5362 7898//5361 7787//5307 +f 7788//5362 7787//5307 7900//5363 +f 7787//5307 7795//5309 7900//5363 +f 7791//5316 7784//5310 7790//5311 +f 7784//5310 7791//5316 7792//5312 +f 7785//5303 7792//5312 7793//5313 +f 7794//5308 7787//5307 7793//5313 +f 7793//5313 7800//5319 7801//5314 +f 7795//5309 7794//5308 7903//5364 +f 7794//5308 7802//5315 7903//5364 +f 7798//5322 7791//5316 7797//5317 +f 7791//5316 7798//5322 7799//5318 +f 7792//5312 7799//5318 7800//5319 +f 7807//5325 7800//5319 7806//5320 +f 7800//5319 7807//5325 7808//5321 +f 7906//5365 7802//5315 7808//5321 +f 7809//5366 7906//5365 7808//5321 +f 7805//5324 7798//5322 7804//5323 +f 7798//5322 7805//5324 7806//5320 +f 7588//5145 7806//5320 7587//5150 +f 7589//5144 7807//5325 7588//5145 +f 7590//5147 7808//5321 7589//5144 +f 7809//5366 7808//5321 7940//5367 +f 7808//5321 7591//5149 7940//5367 +f 7587//5150 7805//5324 7586//5151 +usemtl Material +f 7554//5368 7428//5369 7363//5370 +f 7555//5371 7431//5372 7365//5373 +f 7556//5374 7435//5375 7367//5376 +f 7557//5377 7437//5378 7369//5379 +f 7558//5380 7440//5381 7371//5382 +f 7559//5383 7443//5384 7373//5385 +f 7560//5386 7447//5387 7375//5388 +f 7561//5389 7449//5390 7377//5391 +f 7562//5392 7452//5393 7379//5394 +f 7563//5395 7455//5396 7381//5397 +f 7564//5398 7459//5399 7383//5400 +f 7565//5401 7461//5402 7385//5403 +f 7566//5404 7464//5405 7387//5406 +f 7567//5407 7467//5408 7389//5409 +f 7568//5410 7470//5411 7391//5412 +f 7569//5413 7473//5414 7393//5415 +f 7570//5416 7476//5417 7395//5418 +f 7571//5419 7479//5420 7397//5421 +f 7572//5422 7482//5423 7399//5424 +f 7573//5425 7485//5426 7401//5427 +f 7574//5428 7489//5429 7403//5430 +f 7575//5431 7492//5432 7406//5433 +f 7576//5434 7495//5435 7408//5436 +f 7577//5437 7499//5438 7410//5439 +f 7578//5440 7501//5441 7412//5442 +f 7579//5443 7504//5444 7414//5445 +f 7580//5446 7507//5447 7416//5448 +f 7581//5449 7511//5450 7418//5451 +f 7582//5452 7513//5453 7420//5454 +f 7583//5455 7516//5456 7422//5457 +f 7584//5458 7519//5459 7424//5460 +f 7405//5461 7521//5462 7522//5463 +f 7405//5461 7522//5463 7523//5464 +f 7405//5461 7523//5464 7524//5465 +f 7405//5461 7524//5465 7525//5466 +f 7405//5461 7525//5466 7526//5467 +f 7405//5461 7526//5467 7527//5468 +f 7405//5461 7527//5468 7528//5469 +f 7405//5461 7528//5469 7529//5470 +f 7405//5461 7529//5470 7530//5471 +f 7405//5461 7530//5471 7531//5472 +f 7405//5461 7531//5472 7532//5473 +f 7405//5461 7532//5473 7533//5474 +f 7405//5461 7533//5474 7534//5475 +f 7405//5461 7534//5475 7535//5476 +f 7405//5461 7535//5476 7536//5477 +f 7405//5461 7536//5477 7537//5478 +f 7405//5461 7537//5478 7538//5479 +f 7405//5461 7538//5479 7539//5480 +f 7405//5461 7539//5480 7540//5481 +f 7405//5461 7540//5481 7541//5482 +f 7405//5461 7541//5482 7488//5483 +f 7405//5461 7488//5483 7542//5484 +f 7405//5461 7542//5484 7543//5485 +f 7405//5461 7543//5485 7544//5486 +f 7405//5461 7544//5486 7545//5487 +f 7405//5461 7545//5487 7546//5488 +f 7405//5461 7546//5488 7547//5489 +f 7405//5461 7547//5489 7548//5490 +f 7405//5461 7548//5490 7549//5491 +f 7405//5461 7549//5491 7550//5492 +f 7405//5461 7550//5492 7551//5493 +f 7405//5461 7551//5493 7521//5462 +f 7585//5494 7553//5495 7361//5496 +f 7429//5497 7554//5368 7427//5498 +f 7362//5499 7426//5500 7429//5497 +f 7426//5500 7361//5496 7554//5368 +f 7432//5501 7555//5371 7430//5502 +f 7364//5503 7427//5498 7432//5501 +f 7427//5498 7363//5370 7555//5371 +f 7434//5504 7556//5374 7433//5505 +f 7366//5506 7430//5502 7434//5504 +f 7430//5502 7365//5373 7556//5374 +f 7438//5507 7557//5377 7436//5508 +f 7368//5509 7433//5505 7438//5507 +f 7433//5505 7367//5376 7557//5377 +f 7441//5510 7558//5380 7439//5511 +f 7370//5512 7436//5508 7441//5510 +f 7436//5508 7369//5379 7558//5380 +f 7444//5513 7559//5383 7442//5514 +f 7372//5515 7439//5511 7444//5513 +f 7439//5511 7371//5382 7559//5383 +f 7446//5516 7560//5386 7445//5517 +f 7374//5518 7442//5514 7446//5516 +f 7442//5514 7373//5385 7560//5386 +f 7450//5519 7561//5389 7448//5520 +f 7376//5521 7445//5517 7450//5519 +f 7445//5517 7375//5388 7561//5389 +f 7453//5522 7562//5392 7451//5523 +f 7378//5524 7448//5520 7453//5522 +f 7448//5520 7377//5391 7562//5392 +f 7456//5525 7563//5395 7454//5526 +f 7380//5527 7451//5523 7456//5525 +f 7451//5523 7379//5394 7563//5395 +f 7458//5528 7564//5398 7457//5529 +f 7382//5530 7454//5526 7458//5528 +f 7454//5526 7381//5397 7564//5398 +f 7462//5531 7565//5401 7460//5532 +f 7384//5533 7457//5529 7462//5531 +f 7457//5529 7383//5400 7565//5401 +f 7465//5534 7566//5404 7463//5535 +f 7386//5536 7460//5532 7465//5534 +f 7460//5532 7385//5403 7566//5404 +f 7468//5537 7567//5407 7466//5538 +f 7388//5539 7463//5535 7468//5537 +f 7463//5535 7387//5406 7567//5407 +f 7471//5540 7568//5410 7469//5541 +f 7390//5542 7466//5538 7471//5540 +f 7466//5538 7389//5409 7568//5410 +f 7474//5543 7569//5413 7472//5544 +f 7392//5545 7469//5541 7474//5543 +f 7469//5541 7391//5412 7569//5413 +f 7477//5546 7570//5416 7475//5547 +f 7394//5548 7472//5544 7477//5546 +f 7472//5544 7393//5415 7570//5416 +f 7480//5549 7571//5419 7478//5550 +f 7396//5551 7475//5547 7480//5549 +f 7475//5547 7395//5418 7571//5419 +f 7483//5552 7572//5422 7481//5553 +f 7398//5554 7478//5550 7483//5552 +f 7478//5550 7397//5421 7572//5422 +f 7486//5555 7573//5425 7484//5556 +f 7400//5557 7481//5553 7486//5555 +f 7481//5553 7399//5424 7573//5425 +f 7490//5558 7574//5428 7487//5559 +f 7402//5560 7484//5556 7490//5558 +f 7484//5556 7401//5427 7574//5428 +f 7493//5561 7575//5431 7491//5562 +f 7404//5563 7487//5559 7493//5561 +f 7487//5559 7403//5430 7575//5431 +f 7496//5564 7576//5434 7494//5565 +f 7407//5566 7491//5562 7496//5564 +f 7491//5562 7406//5433 7576//5434 +f 7498//5567 7577//5437 7497//5568 +f 7409//5569 7494//5565 7498//5567 +f 7494//5565 7408//5436 7577//5437 +f 7502//5570 7578//5440 7500//5571 +f 7411//5572 7497//5568 7502//5570 +f 7497//5568 7410//5439 7578//5440 +f 7505//5573 7579//5443 7503//5574 +f 7413//5575 7500//5571 7505//5573 +f 7500//5571 7412//5442 7579//5443 +f 7508//5576 7580//5446 7506//5577 +f 7415//5578 7503//5574 7508//5576 +f 7503//5574 7414//5445 7580//5446 +f 7510//5579 7581//5449 7509//5580 +f 7417//5581 7506//5577 7510//5579 +f 7506//5577 7416//5448 7581//5449 +f 7514//5582 7582//5452 7512//5583 +f 7419//5584 7509//5580 7514//5582 +f 7509//5580 7418//5451 7582//5452 +f 7517//5585 7583//5455 7515//5586 +f 7421//5587 7512//5583 7517//5585 +f 7512//5583 7420//5454 7583//5455 +f 7520//5588 7584//5458 7518//5589 +f 7423//5590 7515//5586 7520//5588 +f 7515//5586 7422//5457 7584//5458 +f 7522//5463 7429//5497 7364//5503 +f 7522//5463 7521//5462 7429//5497 +f 7521//5462 7362//5499 7429//5497 +f 7523//5464 7432//5501 7366//5506 +f 7523//5464 7522//5463 7432//5501 +f 7522//5463 7364//5503 7432//5501 +f 7524//5465 7434//5504 7368//5509 +f 7524//5465 7523//5464 7434//5504 +f 7523//5464 7366//5506 7434//5504 +f 7525//5466 7438//5507 7370//5512 +f 7525//5466 7524//5465 7438//5507 +f 7524//5465 7368//5509 7438//5507 +f 7526//5467 7441//5510 7372//5515 +f 7526//5467 7525//5466 7441//5510 +f 7525//5466 7370//5512 7441//5510 +f 7527//5468 7444//5513 7374//5518 +f 7527//5468 7526//5467 7444//5513 +f 7526//5467 7372//5515 7444//5513 +f 7528//5469 7446//5516 7376//5521 +f 7528//5469 7527//5468 7446//5516 +f 7527//5468 7374//5518 7446//5516 +f 7529//5470 7450//5519 7378//5524 +f 7529//5470 7528//5469 7450//5519 +f 7528//5469 7376//5521 7450//5519 +f 7530//5471 7453//5522 7380//5527 +f 7530//5471 7529//5470 7453//5522 +f 7529//5470 7378//5524 7453//5522 +f 7531//5472 7456//5525 7382//5530 +f 7531//5472 7530//5471 7456//5525 +f 7530//5471 7380//5527 7456//5525 +f 7532//5473 7458//5528 7384//5533 +f 7532//5473 7531//5472 7458//5528 +f 7531//5472 7382//5530 7458//5528 +f 7533//5474 7462//5531 7386//5536 +f 7533//5474 7532//5473 7462//5531 +f 7532//5473 7384//5533 7462//5531 +f 7534//5475 7465//5534 7388//5539 +f 7534//5475 7533//5474 7465//5534 +f 7533//5474 7386//5536 7465//5534 +f 7535//5476 7468//5537 7390//5542 +f 7535//5476 7534//5475 7468//5537 +f 7534//5475 7388//5539 7468//5537 +f 7536//5477 7471//5540 7392//5545 +f 7536//5477 7535//5476 7471//5540 +f 7535//5476 7390//5542 7471//5540 +f 7537//5478 7474//5543 7394//5548 +f 7537//5478 7536//5477 7474//5543 +f 7536//5477 7392//5545 7474//5543 +f 7538//5479 7477//5546 7396//5551 +f 7538//5479 7537//5478 7477//5546 +f 7537//5478 7394//5548 7477//5546 +f 7539//5480 7480//5549 7398//5554 +f 7539//5480 7538//5479 7480//5549 +f 7538//5479 7396//5551 7480//5549 +f 7540//5481 7483//5552 7400//5557 +f 7540//5481 7539//5480 7483//5552 +f 7539//5480 7398//5554 7483//5552 +f 7541//5482 7486//5555 7402//5560 +f 7541//5482 7540//5481 7486//5555 +f 7540//5481 7400//5557 7486//5555 +f 7488//5483 7490//5558 7404//5563 +f 7488//5483 7541//5482 7490//5558 +f 7541//5482 7402//5560 7490//5558 +f 7542//5484 7493//5561 7407//5566 +f 7542//5484 7488//5483 7493//5561 +f 7488//5483 7404//5563 7493//5561 +f 7543//5485 7496//5564 7409//5569 +f 7543//5485 7542//5484 7496//5564 +f 7542//5484 7407//5566 7496//5564 +f 7544//5486 7498//5567 7411//5572 +f 7544//5486 7543//5485 7498//5567 +f 7543//5485 7409//5569 7498//5567 +f 7545//5487 7502//5570 7413//5575 +f 7545//5487 7544//5486 7502//5570 +f 7544//5486 7411//5572 7502//5570 +f 7546//5488 7505//5573 7415//5578 +f 7546//5488 7545//5487 7505//5573 +f 7545//5487 7413//5575 7505//5573 +f 7547//5489 7508//5576 7417//5581 +f 7547//5489 7546//5488 7508//5576 +f 7546//5488 7415//5578 7508//5576 +f 7548//5490 7510//5579 7419//5584 +f 7548//5490 7547//5489 7510//5579 +f 7547//5489 7417//5581 7510//5579 +f 7549//5491 7514//5582 7421//5587 +f 7549//5491 7548//5490 7514//5582 +f 7548//5490 7419//5584 7514//5582 +f 7550//5492 7517//5585 7423//5590 +f 7550//5492 7549//5491 7517//5585 +f 7549//5491 7421//5587 7517//5585 +f 7551//5493 7520//5588 7425//5591 +f 7551//5493 7550//5492 7520//5588 +f 7550//5492 7423//5590 7520//5588 +f 7521//5462 7552//5592 7362//5499 +f 7521//5462 7551//5493 7552//5592 +f 7551//5493 7425//5591 7552//5592 +f 7552//5592 7585//5494 7426//5500 +f 7425//5591 7518//5589 7552//5592 +f 7518//5589 7424//5460 7585//5494 +f 7427//5498 7554//5368 7363//5370 +f 7430//5502 7555//5371 7365//5373 +f 7433//5505 7556//5374 7367//5376 +f 7436//5508 7557//5377 7369//5379 +f 7439//5511 7558//5380 7371//5382 +f 7442//5514 7559//5383 7373//5385 +f 7445//5517 7560//5386 7375//5388 +f 7448//5520 7561//5389 7377//5391 +f 7451//5523 7562//5392 7379//5394 +f 7454//5526 7563//5395 7381//5397 +f 7457//5529 7564//5398 7383//5400 +f 7460//5532 7565//5401 7385//5403 +f 7463//5535 7566//5404 7387//5406 +f 7466//5538 7567//5407 7389//5409 +f 7469//5541 7568//5410 7391//5412 +f 7472//5544 7569//5413 7393//5415 +f 7475//5547 7570//5416 7395//5418 +f 7478//5550 7571//5419 7397//5421 +f 7481//5553 7572//5422 7399//5424 +f 7484//5556 7573//5425 7401//5427 +f 7487//5559 7574//5428 7403//5430 +f 7491//5562 7575//5431 7406//5433 +f 7494//5565 7576//5434 7408//5436 +f 7497//5568 7577//5437 7410//5439 +f 7500//5571 7578//5440 7412//5442 +f 7503//5574 7579//5443 7414//5445 +f 7506//5577 7580//5446 7416//5448 +f 7509//5580 7581//5449 7418//5451 +f 7512//5583 7582//5452 7420//5454 +f 7515//5586 7583//5455 7422//5457 +f 7518//5589 7584//5458 7424//5460 +f 7426//5500 7585//5494 7361//5496 +f 7364//5503 7429//5497 7427//5498 +f 7426//5500 7554//5368 7429//5497 +f 7361//5496 7428//5369 7554//5368 +f 7366//5506 7432//5501 7430//5502 +f 7427//5498 7555//5371 7432//5501 +f 7363//5370 7431//5372 7555//5371 +f 7368//5509 7434//5504 7433//5505 +f 7430//5502 7556//5374 7434//5504 +f 7365//5373 7435//5375 7556//5374 +f 7370//5512 7438//5507 7436//5508 +f 7433//5505 7557//5377 7438//5507 +f 7367//5376 7437//5378 7557//5377 +f 7372//5515 7441//5510 7439//5511 +f 7436//5508 7558//5380 7441//5510 +f 7369//5379 7440//5381 7558//5380 +f 7374//5518 7444//5513 7442//5514 +f 7439//5511 7559//5383 7444//5513 +f 7371//5382 7443//5384 7559//5383 +f 7376//5521 7446//5516 7445//5517 +f 7442//5514 7560//5386 7446//5516 +f 7373//5385 7447//5387 7560//5386 +f 7378//5524 7450//5519 7448//5520 +f 7445//5517 7561//5389 7450//5519 +f 7375//5388 7449//5390 7561//5389 +f 7380//5527 7453//5522 7451//5523 +f 7448//5520 7562//5392 7453//5522 +f 7377//5391 7452//5393 7562//5392 +f 7382//5530 7456//5525 7454//5526 +f 7451//5523 7563//5395 7456//5525 +f 7379//5394 7455//5396 7563//5395 +f 7384//5533 7458//5528 7457//5529 +f 7454//5526 7564//5398 7458//5528 +f 7381//5397 7459//5399 7564//5398 +f 7386//5536 7462//5531 7460//5532 +f 7457//5529 7565//5401 7462//5531 +f 7383//5400 7461//5402 7565//5401 +f 7388//5539 7465//5534 7463//5535 +f 7460//5532 7566//5404 7465//5534 +f 7385//5403 7464//5405 7566//5404 +f 7390//5542 7468//5537 7466//5538 +f 7463//5535 7567//5407 7468//5537 +f 7387//5406 7467//5408 7567//5407 +f 7392//5545 7471//5540 7469//5541 +f 7466//5538 7568//5410 7471//5540 +f 7389//5409 7470//5411 7568//5410 +f 7394//5548 7474//5543 7472//5544 +f 7469//5541 7569//5413 7474//5543 +f 7391//5412 7473//5414 7569//5413 +f 7396//5551 7477//5546 7475//5547 +f 7472//5544 7570//5416 7477//5546 +f 7393//5415 7476//5417 7570//5416 +f 7398//5554 7480//5549 7478//5550 +f 7475//5547 7571//5419 7480//5549 +f 7395//5418 7479//5420 7571//5419 +f 7400//5557 7483//5552 7481//5553 +f 7478//5550 7572//5422 7483//5552 +f 7397//5421 7482//5423 7572//5422 +f 7402//5560 7486//5555 7484//5556 +f 7481//5553 7573//5425 7486//5555 +f 7399//5424 7485//5426 7573//5425 +f 7404//5563 7490//5558 7487//5559 +f 7484//5556 7574//5428 7490//5558 +f 7401//5427 7489//5429 7574//5428 +f 7407//5566 7493//5561 7491//5562 +f 7487//5559 7575//5431 7493//5561 +f 7403//5430 7492//5432 7575//5431 +f 7409//5569 7496//5564 7494//5565 +f 7491//5562 7576//5434 7496//5564 +f 7406//5433 7495//5435 7576//5434 +f 7411//5572 7498//5567 7497//5568 +f 7494//5565 7577//5437 7498//5567 +f 7408//5436 7499//5438 7577//5437 +f 7413//5575 7502//5570 7500//5571 +f 7497//5568 7578//5440 7502//5570 +f 7410//5439 7501//5441 7578//5440 +f 7415//5578 7505//5573 7503//5574 +f 7500//5571 7579//5443 7505//5573 +f 7412//5442 7504//5444 7579//5443 +f 7417//5581 7508//5576 7506//5577 +f 7503//5574 7580//5446 7508//5576 +f 7414//5445 7507//5447 7580//5446 +f 7419//5584 7510//5579 7509//5580 +f 7506//5577 7581//5449 7510//5579 +f 7416//5448 7511//5450 7581//5449 +f 7421//5587 7514//5582 7512//5583 +f 7509//5580 7582//5452 7514//5582 +f 7418//5451 7513//5453 7582//5452 +f 7423//5590 7517//5585 7515//5586 +f 7512//5583 7583//5455 7517//5585 +f 7420//5454 7516//5456 7583//5455 +f 7425//5591 7520//5588 7518//5589 +f 7515//5586 7584//5458 7520//5588 +f 7422//5457 7519//5459 7584//5458 +f 7362//5499 7552//5592 7426//5500 +f 7518//5589 7585//5494 7552//5592 +f 7424//5460 7553//5495 7585//5494 +usemtl Material.001 +f 7941//5593 7815//5326 7598//5156 +f 7942//5594 7818//5327 7605//5163 +f 7943//5595 7822//5328 7612//5329 +f 7944//5596 7824//5330 7619//5171 +f 7945//5597 7827//5331 7626//5332 +f 7946//5598 7830//5333 7633//5179 +f 7947//5599 7834//5334 7640//5191 +f 7948//5600 7836//5335 7647//5193 +f 7949//5601 7839//5336 7654//5337 +f 7950//5602 7842//5338 7661//5202 +f 7951//5603 7846//5339 7668//5210 +f 7952//5604 7848//5340 7675//5217 +f 7953//5605 7851//5341 7682//5342 +f 7954//5606 7854//5343 7689//5224 +f 7955//5607 7857//5344 7696//5232 +f 7956//5608 7860//5345 7703//5240 +f 7957//5609 7863//5346 7710//5347 +f 7958//5610 7866//5348 7717//5247 +f 7959//5611 7869//5349 7724//5350 +f 7960//5612 7872//5351 7731//5261 +f 7961//5613 7876//5352 7738//5269 +f 7962//5614 7879//5353 7746//5354 +f 7963//5615 7882//5355 7753//5277 +f 7964//5616 7886//5356 7760//5357 +f 7965//5617 7888//5358 7767//5285 +f 7966//5618 7891//5359 7774//5292 +f 7967//5619 7894//5360 7781//5306 +f 7968//5620 7898//5361 7788//5362 +f 7969//5621 7900//5363 7795//5309 +f 7970//5622 7903//5364 7802//5315 +f 7971//5623 7906//5365 7809//5366 +f 7740//5624 7908//5625 7909//5626 +f 7740//5624 7909//5626 7910//5627 +f 7740//5624 7910//5627 7911//5628 +f 7740//5624 7911//5628 7912//5629 +f 7740//5624 7912//5629 7913//5630 +f 7740//5624 7913//5630 7914//5631 +f 7740//5624 7914//5631 7915//5632 +f 7740//5624 7915//5632 7916//5633 +f 7740//5624 7916//5633 7917//5634 +f 7740//5624 7917//5634 7918//5635 +f 7740//5624 7918//5635 7919//5636 +f 7740//5624 7919//5636 7920//5637 +f 7740//5624 7920//5637 7921//5638 +f 7740//5624 7921//5638 7922//5639 +f 7740//5624 7922//5639 7923//5640 +f 7740//5624 7923//5640 7924//5641 +f 7740//5624 7924//5641 7925//5642 +f 7740//5624 7925//5642 7926//5643 +f 7740//5624 7926//5643 7927//5644 +f 7740//5624 7927//5644 7928//5645 +f 7740//5624 7928//5645 7875//5646 +f 7740//5624 7875//5646 7929//5647 +f 7740//5624 7929//5647 7930//5648 +f 7740//5624 7930//5648 7931//5649 +f 7740//5624 7931//5649 7932//5650 +f 7740//5624 7932//5650 7933//5651 +f 7740//5624 7933//5651 7934//5652 +f 7740//5624 7934//5652 7935//5653 +f 7740//5624 7935//5653 7936//5654 +f 7740//5624 7936//5654 7937//5655 +f 7740//5624 7937//5655 7938//5656 +f 7740//5624 7938//5656 7908//5625 +f 7972//5657 7940//5367 7591//5149 +f 7816//5658 7941//5593 7814//5659 +f 7592//5660 7813//5661 7816//5658 +f 7813//5661 7591//5149 7941//5593 +f 7819//5662 7942//5594 7817//5663 +f 7599//5664 7814//5659 7819//5662 +f 7814//5659 7598//5156 7942//5594 +f 7821//5665 7943//5595 7820//5666 +f 7606//5667 7817//5663 7821//5665 +f 7817//5663 7605//5163 7943//5595 +f 7825//5668 7944//5596 7823//5669 +f 7613//5670 7820//5666 7825//5668 +f 7820//5666 7612//5329 7944//5596 +f 7828//5671 7945//5597 7826//5672 +f 7620//5673 7823//5669 7828//5671 +f 7823//5669 7619//5171 7945//5597 +f 7831//5674 7946//5598 7829//5675 +f 7627//5676 7826//5672 7831//5674 +f 7826//5672 7626//5332 7946//5598 +f 7833//5677 7947//5599 7832//5678 +f 7634//5679 7829//5675 7833//5677 +f 7829//5675 7633//5179 7947//5599 +f 7837//5680 7948//5600 7835//5681 +f 7641//5682 7832//5678 7837//5680 +f 7832//5678 7640//5191 7948//5600 +f 7840//5683 7949//5601 7838//5684 +f 7648//5685 7835//5681 7840//5683 +f 7835//5681 7647//5193 7949//5601 +f 7843//5686 7950//5602 7841//5687 +f 7655//5688 7838//5684 7843//5686 +f 7838//5684 7654//5337 7950//5602 +f 7845//5689 7951//5603 7844//5690 +f 7662//5691 7841//5687 7845//5689 +f 7841//5687 7661//5202 7951//5603 +f 7849//5692 7952//5604 7847//5693 +f 7669//5694 7844//5690 7849//5692 +f 7844//5690 7668//5210 7952//5604 +f 7852//5695 7953//5605 7850//5696 +f 7676//5697 7847//5693 7852//5695 +f 7847//5693 7675//5217 7953//5605 +f 7855//5698 7954//5606 7853//5699 +f 7683//5700 7850//5696 7855//5698 +f 7850//5696 7682//5342 7954//5606 +f 7858//5701 7955//5607 7856//5702 +f 7690//5703 7853//5699 7858//5701 +f 7853//5699 7689//5224 7955//5607 +f 7861//5704 7956//5608 7859//5705 +f 7697//5706 7856//5702 7861//5704 +f 7856//5702 7696//5232 7956//5608 +f 7864//5707 7957//5609 7862//5708 +f 7704//5709 7859//5705 7864//5707 +f 7859//5705 7703//5240 7957//5609 +f 7867//5710 7958//5610 7865//5711 +f 7711//5712 7862//5708 7867//5710 +f 7862//5708 7710//5347 7958//5610 +f 7870//5713 7959//5611 7868//5714 +f 7718//5715 7865//5711 7870//5713 +f 7865//5711 7717//5247 7959//5611 +f 7873//5716 7960//5612 7871//5717 +f 7725//5718 7868//5714 7873//5716 +f 7868//5714 7724//5350 7960//5612 +f 7877//5719 7961//5613 7874//5720 +f 7732//5721 7871//5717 7877//5719 +f 7871//5717 7731//5261 7961//5613 +f 7880//5722 7962//5614 7878//5723 +f 7739//5724 7874//5720 7880//5722 +f 7874//5720 7738//5269 7962//5614 +f 7883//5725 7963//5615 7881//5726 +f 7747//5727 7878//5723 7883//5725 +f 7878//5723 7746//5354 7963//5615 +f 7885//5728 7964//5616 7884//5729 +f 7754//5730 7881//5726 7885//5728 +f 7881//5726 7753//5277 7964//5616 +f 7889//5731 7965//5617 7887//5732 +f 7761//5733 7884//5729 7889//5731 +f 7884//5729 7760//5357 7965//5617 +f 7892//5734 7966//5618 7890//5735 +f 7768//5736 7887//5732 7892//5734 +f 7887//5732 7767//5285 7966//5618 +f 7895//5737 7967//5619 7893//5738 +f 7775//5739 7890//5735 7895//5737 +f 7890//5735 7774//5292 7967//5619 +f 7897//5740 7968//5620 7896//5741 +f 7782//5742 7893//5738 7897//5740 +f 7893//5738 7781//5306 7968//5620 +f 7901//5743 7969//5621 7899//5744 +f 7789//5745 7896//5741 7901//5743 +f 7896//5741 7788//5362 7969//5621 +f 7904//5746 7970//5622 7902//5747 +f 7796//5748 7899//5744 7904//5746 +f 7899//5744 7795//5309 7970//5622 +f 7907//5749 7971//5623 7905//5750 +f 7803//5751 7902//5747 7907//5749 +f 7902//5747 7802//5315 7971//5623 +f 7909//5626 7816//5658 7599//5664 +f 7909//5626 7908//5625 7816//5658 +f 7908//5625 7592//5660 7816//5658 +f 7910//5627 7819//5662 7606//5667 +f 7910//5627 7909//5626 7819//5662 +f 7909//5626 7599//5664 7819//5662 +f 7911//5628 7821//5665 7613//5670 +f 7911//5628 7910//5627 7821//5665 +f 7910//5627 7606//5667 7821//5665 +f 7912//5629 7825//5668 7620//5673 +f 7912//5629 7911//5628 7825//5668 +f 7911//5628 7613//5670 7825//5668 +f 7913//5630 7828//5671 7627//5676 +f 7913//5630 7912//5629 7828//5671 +f 7912//5629 7620//5673 7828//5671 +f 7914//5631 7831//5674 7634//5679 +f 7914//5631 7913//5630 7831//5674 +f 7913//5630 7627//5676 7831//5674 +f 7915//5632 7833//5677 7641//5682 +f 7915//5632 7914//5631 7833//5677 +f 7914//5631 7634//5679 7833//5677 +f 7916//5633 7837//5680 7648//5685 +f 7916//5633 7915//5632 7837//5680 +f 7915//5632 7641//5682 7837//5680 +f 7917//5634 7840//5683 7655//5688 +f 7917//5634 7916//5633 7840//5683 +f 7916//5633 7648//5685 7840//5683 +f 7918//5635 7843//5686 7662//5691 +f 7918//5635 7917//5634 7843//5686 +f 7917//5634 7655//5688 7843//5686 +f 7919//5636 7845//5689 7669//5694 +f 7919//5636 7918//5635 7845//5689 +f 7918//5635 7662//5691 7845//5689 +f 7920//5637 7849//5692 7676//5697 +f 7920//5637 7919//5636 7849//5692 +f 7919//5636 7669//5694 7849//5692 +f 7921//5638 7852//5695 7683//5700 +f 7921//5638 7920//5637 7852//5695 +f 7920//5637 7676//5697 7852//5695 +f 7922//5639 7855//5698 7690//5703 +f 7922//5639 7921//5638 7855//5698 +f 7921//5638 7683//5700 7855//5698 +f 7923//5640 7858//5701 7697//5706 +f 7923//5640 7922//5639 7858//5701 +f 7922//5639 7690//5703 7858//5701 +f 7924//5641 7861//5704 7704//5709 +f 7924//5641 7923//5640 7861//5704 +f 7923//5640 7697//5706 7861//5704 +f 7925//5642 7864//5707 7711//5712 +f 7925//5642 7924//5641 7864//5707 +f 7924//5641 7704//5709 7864//5707 +f 7926//5643 7867//5710 7718//5715 +f 7926//5643 7925//5642 7867//5710 +f 7925//5642 7711//5712 7867//5710 +f 7927//5644 7870//5713 7725//5718 +f 7927//5644 7926//5643 7870//5713 +f 7926//5643 7718//5715 7870//5713 +f 7928//5645 7873//5716 7732//5721 +f 7928//5645 7927//5644 7873//5716 +f 7927//5644 7725//5718 7873//5716 +f 7875//5646 7877//5719 7739//5724 +f 7875//5646 7928//5645 7877//5719 +f 7928//5645 7732//5721 7877//5719 +f 7929//5647 7880//5722 7747//5727 +f 7929//5647 7875//5646 7880//5722 +f 7875//5646 7739//5724 7880//5722 +f 7930//5648 7883//5725 7754//5730 +f 7930//5648 7929//5647 7883//5725 +f 7929//5647 7747//5727 7883//5725 +f 7931//5649 7885//5728 7761//5733 +f 7931//5649 7930//5648 7885//5728 +f 7930//5648 7754//5730 7885//5728 +f 7932//5650 7889//5731 7768//5736 +f 7932//5650 7931//5649 7889//5731 +f 7931//5649 7761//5733 7889//5731 +f 7933//5651 7892//5734 7775//5739 +f 7933//5651 7932//5650 7892//5734 +f 7932//5650 7768//5736 7892//5734 +f 7934//5652 7895//5737 7782//5742 +f 7934//5652 7933//5651 7895//5737 +f 7933//5651 7775//5739 7895//5737 +f 7935//5653 7897//5740 7789//5745 +f 7935//5653 7934//5652 7897//5740 +f 7934//5652 7782//5742 7897//5740 +f 7936//5654 7901//5743 7796//5748 +f 7936//5654 7935//5653 7901//5743 +f 7935//5653 7789//5745 7901//5743 +f 7937//5655 7904//5746 7803//5751 +f 7937//5655 7936//5654 7904//5746 +f 7936//5654 7796//5748 7904//5746 +f 7938//5656 7907//5749 7810//5752 +f 7938//5656 7937//5655 7907//5749 +f 7937//5655 7803//5751 7907//5749 +f 7908//5625 7939//5753 7592//5660 +f 7908//5625 7938//5656 7939//5753 +f 7938//5656 7810//5752 7939//5753 +f 7939//5753 7972//5657 7813//5661 +f 7810//5752 7905//5750 7939//5753 +f 7905//5750 7809//5366 7972//5657 +f 7814//5659 7941//5593 7598//5156 +f 7817//5663 7942//5594 7605//5163 +f 7820//5666 7943//5595 7612//5329 +f 7823//5669 7944//5596 7619//5171 +f 7826//5672 7945//5597 7626//5332 +f 7829//5675 7946//5598 7633//5179 +f 7832//5678 7947//5599 7640//5191 +f 7835//5681 7948//5600 7647//5193 +f 7838//5684 7949//5601 7654//5337 +f 7841//5687 7950//5602 7661//5202 +f 7844//5690 7951//5603 7668//5210 +f 7847//5693 7952//5604 7675//5217 +f 7850//5696 7953//5605 7682//5342 +f 7853//5699 7954//5606 7689//5224 +f 7856//5702 7955//5607 7696//5232 +f 7859//5705 7956//5608 7703//5240 +f 7862//5708 7957//5609 7710//5347 +f 7865//5711 7958//5610 7717//5247 +f 7868//5714 7959//5611 7724//5350 +f 7871//5717 7960//5612 7731//5261 +f 7874//5720 7961//5613 7738//5269 +f 7878//5723 7962//5614 7746//5354 +f 7881//5726 7963//5615 7753//5277 +f 7884//5729 7964//5616 7760//5357 +f 7887//5732 7965//5617 7767//5285 +f 7890//5735 7966//5618 7774//5292 +f 7893//5738 7967//5619 7781//5306 +f 7896//5741 7968//5620 7788//5362 +f 7899//5744 7969//5621 7795//5309 +f 7902//5747 7970//5622 7802//5315 +f 7905//5750 7971//5623 7809//5366 +f 7813//5661 7972//5657 7591//5149 +f 7599//5664 7816//5658 7814//5659 +f 7813//5661 7941//5593 7816//5658 +f 7591//5149 7815//5326 7941//5593 +f 7606//5667 7819//5662 7817//5663 +f 7814//5659 7942//5594 7819//5662 +f 7598//5156 7818//5327 7942//5594 +f 7613//5670 7821//5665 7820//5666 +f 7817//5663 7943//5595 7821//5665 +f 7605//5163 7822//5328 7943//5595 +f 7620//5673 7825//5668 7823//5669 +f 7820//5666 7944//5596 7825//5668 +f 7612//5329 7824//5330 7944//5596 +f 7627//5676 7828//5671 7826//5672 +f 7823//5669 7945//5597 7828//5671 +f 7619//5171 7827//5331 7945//5597 +f 7634//5679 7831//5674 7829//5675 +f 7826//5672 7946//5598 7831//5674 +f 7626//5332 7830//5333 7946//5598 +f 7641//5682 7833//5677 7832//5678 +f 7829//5675 7947//5599 7833//5677 +f 7633//5179 7834//5334 7947//5599 +f 7648//5685 7837//5680 7835//5681 +f 7832//5678 7948//5600 7837//5680 +f 7640//5191 7836//5335 7948//5600 +f 7655//5688 7840//5683 7838//5684 +f 7835//5681 7949//5601 7840//5683 +f 7647//5193 7839//5336 7949//5601 +f 7662//5691 7843//5686 7841//5687 +f 7838//5684 7950//5602 7843//5686 +f 7654//5337 7842//5338 7950//5602 +f 7669//5694 7845//5689 7844//5690 +f 7841//5687 7951//5603 7845//5689 +f 7661//5202 7846//5339 7951//5603 +f 7676//5697 7849//5692 7847//5693 +f 7844//5690 7952//5604 7849//5692 +f 7668//5210 7848//5340 7952//5604 +f 7683//5700 7852//5695 7850//5696 +f 7847//5693 7953//5605 7852//5695 +f 7675//5217 7851//5341 7953//5605 +f 7690//5703 7855//5698 7853//5699 +f 7850//5696 7954//5606 7855//5698 +f 7682//5342 7854//5343 7954//5606 +f 7697//5706 7858//5701 7856//5702 +f 7853//5699 7955//5607 7858//5701 +f 7689//5224 7857//5344 7955//5607 +f 7704//5709 7861//5704 7859//5705 +f 7856//5702 7956//5608 7861//5704 +f 7696//5232 7860//5345 7956//5608 +f 7711//5712 7864//5707 7862//5708 +f 7859//5705 7957//5609 7864//5707 +f 7703//5240 7863//5346 7957//5609 +f 7718//5715 7867//5710 7865//5711 +f 7862//5708 7958//5610 7867//5710 +f 7710//5347 7866//5348 7958//5610 +f 7725//5718 7870//5713 7868//5714 +f 7865//5711 7959//5611 7870//5713 +f 7717//5247 7869//5349 7959//5611 +f 7732//5721 7873//5716 7871//5717 +f 7868//5714 7960//5612 7873//5716 +f 7724//5350 7872//5351 7960//5612 +f 7739//5724 7877//5719 7874//5720 +f 7871//5717 7961//5613 7877//5719 +f 7731//5261 7876//5352 7961//5613 +f 7747//5727 7880//5722 7878//5723 +f 7874//5720 7962//5614 7880//5722 +f 7738//5269 7879//5353 7962//5614 +f 7754//5730 7883//5725 7881//5726 +f 7878//5723 7963//5615 7883//5725 +f 7746//5354 7882//5355 7963//5615 +f 7761//5733 7885//5728 7884//5729 +f 7881//5726 7964//5616 7885//5728 +f 7753//5277 7886//5356 7964//5616 +f 7768//5736 7889//5731 7887//5732 +f 7884//5729 7965//5617 7889//5731 +f 7760//5357 7888//5358 7965//5617 +f 7775//5739 7892//5734 7890//5735 +f 7887//5732 7966//5618 7892//5734 +f 7767//5285 7891//5359 7966//5618 +f 7782//5742 7895//5737 7893//5738 +f 7890//5735 7967//5619 7895//5737 +f 7774//5292 7894//5360 7967//5619 +f 7789//5745 7897//5740 7896//5741 +f 7893//5738 7968//5620 7897//5740 +f 7781//5306 7898//5361 7968//5620 +f 7796//5748 7901//5743 7899//5744 +f 7896//5741 7969//5621 7901//5743 +f 7788//5362 7900//5363 7969//5621 +f 7803//5751 7904//5746 7902//5747 +f 7899//5744 7970//5622 7904//5746 +f 7795//5309 7903//5364 7970//5622 +f 7810//5752 7907//5749 7905//5750 +f 7902//5747 7971//5623 7907//5749 +f 7802//5315 7906//5365 7971//5623 +f 7592//5660 7939//5753 7813//5661 +f 7905//5750 7972//5657 7939//5753 +f 7809//5366 7940//5367 7972//5657 +l 7811 7812 +o Body_Sphere.002 +v 1.170026 0.251981 0.110623 +v 1.168350 0.409033 0.206367 +v 1.143010 0.551349 0.294090 +v 1.114024 0.673459 0.370420 +v 0.955484 0.770670 0.432424 +v 0.777509 0.839246 0.477720 +v 0.586939 0.876553 0.504566 +v -0.480150 0.831895 0.501455 +v -0.673737 0.803618 0.489056 +v -0.768059 0.743547 0.457369 +v -0.935192 0.653991 0.407613 +v -1.079141 0.538391 0.341698 +v -1.194375 0.401190 0.262159 +v -1.276466 0.247660 0.172051 +v -1.322257 0.083702 0.074839 +v 1.169478 0.268339 0.076058 +v 1.167277 0.441121 0.138565 +v 1.141450 0.597933 0.195657 +v 1.112040 0.732748 0.245138 +v 0.953150 0.840387 0.285108 +v 0.774916 0.916712 0.314031 +v 0.584186 0.958790 0.330795 +v -0.482956 0.915743 0.324280 +v -0.676490 0.885855 0.315285 +v -0.770652 0.821013 0.293681 +v -0.937526 0.723708 0.260297 +v -1.081126 0.597681 0.216416 +v -1.195935 0.447774 0.163726 +v -1.277540 0.279748 0.104249 +v -1.322805 0.100060 0.040274 +v 1.169391 0.277653 0.038965 +v 1.167106 0.459392 0.065805 +v 1.141203 0.624459 0.090026 +v 1.111725 0.766510 0.110696 +v 0.952780 0.880086 0.127021 +v 0.774505 0.960823 0.138373 +v 0.583750 1.005618 0.144318 +v -0.483401 0.963489 0.134150 +v -0.676926 0.932684 0.128808 +v -0.771063 0.865124 0.118023 +v -0.937896 0.763407 0.102209 +v -1.081441 0.631442 0.081974 +v -1.196182 0.474300 0.058095 +v -1.277710 0.298019 0.031490 +v -1.322891 0.109375 0.003181 +v 1.169769 0.279567 0.000770 +v 1.167847 0.463146 -0.009116 +v 1.142278 0.629908 -0.018743 +v 1.113093 0.773445 -0.027741 +v 0.954389 0.888242 -0.035764 +v 0.776292 0.969885 -0.042503 +v 0.585647 1.015238 -0.047700 +v -0.481466 0.973298 -0.061629 +v -0.675029 0.942304 -0.063209 +v -0.769276 0.874186 -0.062853 +v -0.936287 0.771563 -0.060576 +v -1.080073 0.638378 -0.056463 +v -1.195107 0.479749 -0.050675 +v -1.276970 0.301773 -0.043432 +v -1.322514 0.111288 -0.035014 +v 1.170596 0.274006 -0.037058 +v 1.169469 0.452237 -0.083320 +v 1.144634 0.614071 -0.126471 +v 1.116091 0.753289 -0.164852 +v 0.957914 0.864540 -0.196989 +v 0.780209 0.943549 -0.221647 +v 0.589806 0.987280 -0.237878 +v -0.477227 0.944792 -0.255534 +v -0.670871 0.914345 -0.253388 +v -0.765359 0.847849 -0.241998 +v -0.932762 0.747861 -0.221801 +v -1.077075 0.618221 -0.193574 +v -1.192752 0.463912 -0.158402 +v -1.275347 0.290864 -0.117636 +v -1.321687 0.105727 -0.072843 +v 1.171840 0.261183 -0.073068 +v 1.171911 0.427085 -0.153955 +v 1.148179 0.577556 -0.229017 +v 1.120603 0.706814 -0.295368 +v 0.963220 0.809891 -0.350460 +v 0.786105 0.882827 -0.392175 +v 0.594635 0.922509 -0.418819 +v -0.470858 0.879065 -0.440112 +v -0.664612 0.849883 -0.434419 +v -0.759463 0.787128 -0.412525 +v -0.927456 0.693212 -0.375272 +v -1.072562 0.571746 -0.324090 +v -1.189206 0.427397 -0.260948 +v -1.272905 0.265712 -0.188271 +v -1.320442 0.092905 -0.108852 +v 1.173456 0.241593 -0.105874 +v 1.175079 0.388657 -0.218306 +v 1.152778 0.521767 -0.322441 +v 1.126457 0.635808 -0.414274 +v 0.970103 0.726397 -0.490279 +v 0.793753 0.790052 -0.547533 +v 0.603244 0.824142 -0.583748 +v -0.141841 0.757556 -0.567727 +v -0.636989 0.753823 -0.599597 +v -0.753183 0.694974 -0.568368 +v -0.920573 0.609718 -0.515090 +v -1.066709 0.500740 -0.442996 +v -1.184607 0.371608 -0.354372 +v -1.269737 0.227284 -0.252622 +v -1.318827 0.073314 -0.141658 +v 1.175379 0.215987 -0.134216 +v 1.178851 0.338429 -0.273901 +v 1.158254 0.448847 -0.403152 +v 1.133427 0.542998 -0.517000 +v 0.978299 0.617264 -0.611071 +v 0.802860 0.668791 -0.681750 +v 0.613862 0.695602 -0.726323 +v -0.045623 0.621289 -0.682280 +v -0.501306 0.649655 -0.755550 +v -0.756130 0.580078 -0.708091 +v -0.912376 0.500585 -0.635882 +v -1.059739 0.407930 -0.545722 +v -1.179131 0.298688 -0.435083 +v -1.265965 0.177056 -0.308217 +v -1.316904 0.047708 -0.170000 +v 1.177536 0.185349 -0.157005 +v 1.183083 0.278331 -0.318603 +v 1.164397 0.361599 -0.468048 +v 1.141245 0.431952 -0.599598 +v 0.987493 0.486688 -0.708196 +v 0.813075 0.523703 -0.789670 +v 0.607618 0.536290 -0.831925 +v -0.016459 0.475452 -0.784209 +v -0.469195 0.511069 -0.903810 +v -0.816490 0.428845 -0.810804 +v -0.903183 0.370009 -0.733008 +v -1.051920 0.296884 -0.628320 +v -1.172988 0.211440 -0.499979 +v -1.261733 0.116958 -0.352918 +v -1.314747 0.017071 -0.192789 +v 1.179844 0.150858 -0.173364 +v 1.187611 0.210673 -0.350694 +v 1.170971 0.263375 -0.514637 +v 1.149612 0.306938 -0.658894 +v 0.997330 0.339686 -0.777921 +v 0.824003 0.360358 -0.867132 +v 0.466183 0.334358 -0.812978 +v -0.044104 0.313668 -0.867533 +v -0.488226 0.303455 -0.941785 +v -0.810803 0.264560 -0.887196 +v -0.893342 0.223005 -0.802724 +v -1.043554 0.171870 -0.687616 +v -1.166414 0.113216 -0.546568 +v -1.257206 0.049300 -0.385009 +v -1.312438 -0.017421 -0.209148 +v 1.182215 0.113837 -0.182667 +v 1.192261 0.138056 -0.368940 +v 1.177722 0.157951 -0.541127 +v 1.158205 0.172758 -0.692609 +v 1.007435 0.181908 -0.817567 +v 0.835030 0.184958 -0.910662 +v 0.450410 0.158526 -0.840500 +v -0.042604 0.136737 -0.867782 +v -0.553344 0.109950 -0.964634 +v -0.798504 0.088943 -0.927640 +v -0.883079 0.065187 -0.842022 +v -1.034961 0.037690 -0.721332 +v -1.159663 0.007792 -0.573058 +v -1.252555 -0.023317 -0.403256 +v -1.310068 -0.054441 -0.218451 +v 1.184557 0.075711 -0.184554 +v 1.196855 0.063269 -0.372642 +v 1.184392 0.049377 -0.546500 +v 1.166694 0.034570 -0.699448 +v 1.017383 0.019417 -0.825538 +v 0.844563 0.004561 -0.917578 +v 0.503968 -0.006608 -0.888890 +v 0.006670 -0.025496 -0.854412 +v -0.456641 -0.067888 -0.958529 +v -0.764428 -0.089275 -0.929270 +v -0.876402 -0.097433 -0.850188 +v -1.026453 -0.100495 -0.728142 +v -1.152993 -0.100782 -0.578431 +v -1.247961 -0.098104 -0.406957 +v -1.307725 -0.092567 -0.220337 +v 1.186780 0.037945 -0.178953 +v 1.201217 -0.010813 -0.361656 +v 1.190724 -0.058173 -0.530551 +v 1.174753 -0.102316 -0.679148 +v 1.026743 -0.141479 -0.801446 +v 0.851393 -0.172787 -0.887069 +v 0.532145 -0.182662 -0.887325 +v 0.058786 -0.176775 -0.830105 +v -0.369879 -0.239324 -0.908436 +v -0.680602 -0.263016 -0.898859 +v -0.871201 -0.260408 -0.830650 +v -1.021784 -0.238164 -0.710148 +v -1.146661 -0.208332 -0.562482 +v -1.243599 -0.172186 -0.395971 +v -1.305502 -0.130334 -0.214737 +v 1.188800 0.001989 -0.166080 +v 1.205178 -0.081343 -0.336404 +v 1.196475 -0.160567 -0.493891 +v 1.182072 -0.232639 -0.632490 +v 1.035221 -0.294568 -0.746381 +v 0.855982 -0.339241 -0.821388 +v 0.528492 -0.341555 -0.811172 +v 0.089816 -0.316378 -0.749180 +v -0.314099 -0.376406 -0.804710 +v -0.604131 -0.418183 -0.821949 +v -0.856762 -0.435491 -0.805552 +v -1.032427 -0.376249 -0.677646 +v -1.141438 -0.310852 -0.526033 +v -1.239638 -0.242716 -0.370719 +v -1.303483 -0.166290 -0.201864 +v 1.190538 -0.030775 -0.146429 +v 1.208587 -0.145612 -0.297857 +v 1.201423 -0.253870 -0.437930 +v 1.188371 -0.351391 -0.561265 +v 1.042584 -0.434072 -0.662626 +v 0.861424 -0.489870 -0.726461 +v 0.535224 -0.479332 -0.706059 +v 0.118240 -0.447841 -0.657629 +v -0.289889 -0.479721 -0.673794 +v -0.556585 -0.531586 -0.697052 +v -0.820025 -0.569757 -0.705469 +v -1.034142 -0.506114 -0.612872 +v -1.137452 -0.404445 -0.470328 +v -1.236230 -0.306984 -0.332173 +v -1.301745 -0.199053 -0.182213 +v 1.191927 -0.059087 -0.120755 +v 1.211312 -0.201148 -0.247497 +v 1.205380 -0.334496 -0.364818 +v 1.193406 -0.454009 -0.468211 +v 1.048613 -0.554800 -0.553429 +v 0.868724 -0.621876 -0.607199 +v 0.551781 -0.603082 -0.586171 +v 0.141882 -0.558404 -0.542041 +v -0.255361 -0.573527 -0.545677 +v -0.520518 -0.617642 -0.560960 +v -0.788935 -0.695637 -0.589723 +v -1.026482 -0.615123 -0.511853 +v -1.135105 -0.485933 -0.397545 +v -1.233504 -0.362521 -0.281813 +v -1.300355 -0.227366 -0.156539 +v 1.192914 -0.081860 -0.090046 +v 1.213249 -0.245818 -0.187258 +v 1.208191 -0.399347 -0.277365 +v 1.196985 -0.536548 -0.356905 +v 1.052972 -0.652048 -0.422758 +v 0.878573 -0.732351 -0.466904 +v 0.574862 -0.710197 -0.450470 +v 0.152302 -0.657719 -0.418195 +v -0.201642 -0.646087 -0.408551 +v -0.490517 -0.692532 -0.424318 +v -0.766150 -0.781431 -0.450915 +v -1.021193 -0.703857 -0.399212 +v -1.133385 -0.550988 -0.309953 +v -1.231568 -0.407191 -0.221574 +v -1.299368 -0.250138 -0.125830 +v 1.193462 -0.098218 -0.055481 +v 1.214323 -0.277905 -0.119456 +v 1.209751 -0.445931 -0.178932 +v 1.198969 -0.595838 -0.231623 +v 1.055364 -0.721857 -0.275500 +v 0.885055 -0.813473 -0.306814 +v 0.601112 -0.795985 -0.298868 +v 0.178243 -0.727458 -0.275527 +v -0.159195 -0.695518 -0.266070 +v -0.467766 -0.742134 -0.280394 +v -0.758102 -0.833252 -0.299626 +v -1.005275 -0.748882 -0.265650 +v -1.129849 -0.596890 -0.211123 +v -1.230493 -0.439278 -0.153772 +v -1.298820 -0.266496 -0.091265 +v 1.193549 -0.107533 -0.018388 +v 1.214493 -0.296177 -0.046697 +v 1.209998 -0.472457 -0.073302 +v 1.199284 -0.629600 -0.097181 +v 1.055739 -0.761566 -0.117416 +v 0.887365 -0.860117 -0.132756 +v 0.628538 -0.857493 -0.133145 +v 0.199313 -0.773585 -0.123536 +v -0.132514 -0.725518 -0.121035 +v -0.446784 -0.766974 -0.132601 +v -0.771414 -0.827424 -0.136850 +v -0.991911 -0.762915 -0.125202 +v -1.127415 -0.622549 -0.105222 +v -1.230323 -0.457550 -0.081012 +v -1.298734 -0.275811 -0.054172 +v 1.193171 -0.109446 0.019807 +v 1.213752 -0.299931 0.028225 +v 1.208923 -0.477907 0.035468 +v 1.197916 -0.636535 0.041256 +v 1.054131 -0.769721 0.045368 +v 0.886460 -0.870880 0.047565 +v 0.652570 -0.888116 0.044837 +v 0.216101 -0.789321 0.036283 +v -0.115915 -0.731150 0.027219 +v -0.429533 -0.764740 0.017879 +v -0.764277 -0.813153 0.014237 +v -0.991789 -0.766912 0.012182 +v -1.128355 -0.627948 0.003532 +v -1.231064 -0.461303 -0.006091 +v -1.299111 -0.277724 -0.015977 +v 1.192344 -0.103885 0.057636 +v 1.212130 -0.289022 0.102429 +v 1.206568 -0.462069 0.143195 +v 1.194918 -0.616378 0.178367 +v 1.050605 -0.746018 0.206594 +v 0.883054 -0.845665 0.226701 +v 0.663915 -0.876175 0.228465 +v 0.222684 -0.773574 0.198548 +v -0.112693 -0.712770 0.176470 +v -0.428049 -0.742911 0.168776 +v -0.757560 -0.792337 0.166993 +v -0.992496 -0.744249 0.148011 +v -1.130772 -0.612180 0.111253 +v -1.232686 -0.450395 0.068113 +v -1.299939 -0.272163 0.021851 +v 1.191099 -0.091063 0.093645 +v 1.209688 -0.263870 0.173064 +v 1.203023 -0.425554 0.245741 +v 1.190406 -0.569904 0.308883 +v 1.045299 -0.691370 0.360065 +v 0.877299 -0.785269 0.397311 +v 0.664523 -0.821507 0.406446 +v 0.217102 -0.727817 0.356521 +v -0.125261 -0.672088 0.322781 +v -0.447424 -0.713146 0.319925 +v -0.762455 -0.793627 0.325218 +v -1.001917 -0.706727 0.279637 +v -1.134504 -0.575787 0.213837 +v -1.235128 -0.425243 0.138748 +v -1.301183 -0.259341 0.057861 +v -1.329990 -0.084384 -0.025743 +v 1.189484 -0.071472 0.126451 +v 1.206520 -0.225441 0.237415 +v 1.198423 -0.369765 0.339164 +v 1.184552 -0.498897 0.427789 +v 1.038416 -0.607875 0.499883 +v 0.869659 -0.692513 0.552677 +v 0.660566 -0.730856 0.570304 +v 0.200657 -0.653684 0.504463 +v -0.149387 -0.609356 0.461289 +v -0.478713 -0.683345 0.478874 +v -0.789194 -0.747580 0.484899 +v -1.021586 -0.647070 0.405307 +v -1.139924 -0.520356 0.307494 +v -1.238296 -0.386814 0.203099 +v -1.302798 -0.239750 0.090667 +v 1.187561 -0.045866 0.154793 +v 1.202748 -0.175213 0.293010 +v 1.192947 -0.296845 0.419875 +v 1.177582 -0.406088 0.530515 +v 1.030220 -0.498743 0.620675 +v 0.860551 -0.571249 0.686893 +v 0.654934 -0.609524 0.714114 +v 0.176148 -0.551206 0.636425 +v -0.186749 -0.524303 0.590501 +v -0.515034 -0.613565 0.632753 +v -0.816389 -0.635426 0.617641 +v -1.033123 -0.550978 0.512622 +v -1.145560 -0.447451 0.388352 +v -1.242068 -0.336586 0.258694 +v -1.304721 -0.214144 0.119009 +v 1.185404 -0.015229 0.177582 +v 1.198516 -0.115116 0.337711 +v 1.186804 -0.209597 0.484772 +v 1.169764 -0.295042 0.613112 +v 1.021026 -0.368167 0.717800 +v 0.850337 -0.426162 0.794814 +v 0.648436 -0.461197 0.831559 +v 0.180867 -0.415546 0.736738 +v -0.236050 -0.423315 0.712625 +v -0.556370 -0.507463 0.775262 +v -0.851295 -0.506838 0.734483 +v -1.034265 -0.434724 0.591930 +v -1.150877 -0.359852 0.452968 +v -1.246300 -0.276489 0.303395 +v -1.306879 -0.183507 0.141797 +v 1.183095 0.019263 0.193941 +v 1.193989 -0.047458 0.369802 +v 1.180231 -0.111374 0.531361 +v 1.161397 -0.170027 0.672408 +v 1.011189 -0.221165 0.787525 +v 0.839405 -0.262822 0.872287 +v 0.644075 -0.291929 0.918848 +v 0.161990 -0.265251 0.802916 +v -0.307243 -0.298719 0.815489 +v -0.615181 -0.356512 0.876354 +v -0.878254 -0.344664 0.794119 +v -1.034928 -0.305863 0.645856 +v -1.157154 -0.261533 0.499429 +v -1.250827 -0.208831 0.335486 +v -1.309187 -0.149015 0.158157 +v 1.180725 0.056283 0.203243 +v 1.189338 0.025159 0.388049 +v 1.173479 -0.005949 0.557850 +v 1.152804 -0.035848 0.706124 +v 1.001085 -0.063387 0.827170 +v 0.828178 -0.087507 0.916338 +v 0.638413 -0.107237 0.969312 +v 0.130850 -0.107358 0.850958 +v -0.362991 -0.141709 0.872963 +v -0.672017 -0.177250 0.891682 +v -0.885841 -0.178825 0.799926 +v -1.040438 -0.170928 0.677456 +v -1.163906 -0.156109 0.525919 +v -1.255478 -0.136214 0.353733 +v -1.311558 -0.111995 0.167459 +v 1.178383 0.094409 0.205130 +v 1.184744 0.099946 0.391750 +v 1.166809 0.102624 0.563224 +v 1.144315 0.102340 0.712963 +v 0.991102 0.099105 0.835212 +v 0.817086 0.093044 0.925274 +v 0.628946 0.084388 0.979685 +v 0.100723 0.057570 0.856166 +v -0.401542 0.027638 0.895254 +v -0.728480 -0.002655 0.904905 +v -0.899573 -0.017574 0.810400 +v -1.048850 -0.032728 0.684241 +v -1.170576 -0.047535 0.531293 +v -1.260072 -0.061427 0.357434 +v -1.313900 -0.073869 0.169346 +v 1.176159 0.132176 0.199530 +v 1.180382 0.174028 0.380764 +v 1.160477 0.210174 0.547274 +v 1.136256 0.239226 0.692663 +v 0.981626 0.260066 0.811342 +v 0.806557 0.271894 0.898750 +v 0.617674 0.274235 0.951460 +v 0.063238 0.223971 0.839858 +v -0.455144 0.206294 0.901867 +v -0.740857 0.176476 0.879052 +v -0.909050 0.143387 0.786530 +v -1.056909 0.104158 0.663941 +v -1.176908 0.060015 0.515343 +v -1.264434 0.012655 0.346448 +v -1.316123 -0.036103 0.163745 +v 1.174140 0.168132 0.186656 +v 1.176421 0.244558 0.355512 +v 1.154727 0.312568 0.510615 +v 1.128937 0.369549 0.646004 +v 0.973019 0.413309 0.756477 +v 0.796993 0.442169 0.837788 +v 0.604243 0.454236 0.885228 +v 0.004683 0.393361 0.808195 +v -0.513573 0.399796 0.897164 +v -0.763628 0.349293 0.823998 +v -0.917657 0.296630 0.731665 +v -1.064229 0.234481 0.617282 +v -1.182659 0.162409 0.478684 +v -1.268395 0.083185 0.321196 +v -1.318143 -0.000147 0.150872 +v 1.200648 0.086226 0.010537 +v 1.172402 0.200896 0.167005 +v 1.173012 0.308826 0.316966 +v 1.149778 0.405871 0.454654 +v 1.122639 0.488301 0.574779 +v 0.965613 0.552947 0.672725 +v 0.788764 0.597326 0.744728 +v 0.588576 0.617843 0.785979 +v -0.127622 0.553786 0.736012 +v -0.626691 0.567583 0.801105 +v -0.794315 0.515991 0.743870 +v -0.925065 0.436268 0.647914 +v -1.070527 0.353233 0.546057 +v -1.187607 0.255712 0.422723 +v -1.271803 0.147454 0.282650 +v -1.319880 0.032617 0.131221 +v 1.171013 0.229208 0.141332 +v 1.170287 0.364363 0.266605 +v 1.145822 0.486498 0.381542 +v 1.117603 0.590918 0.481726 +v 0.959692 0.673613 0.563306 +v 0.782185 0.731402 0.623148 +v 0.589864 0.761636 0.658639 +v -0.473998 0.715069 0.658733 +v -0.664633 0.689706 0.643674 +v -0.766485 0.635908 0.602887 +v -0.930984 0.556934 0.538494 +v -1.075563 0.455851 0.453004 +v -1.191563 0.336338 0.349611 +v -1.274529 0.202990 0.232290 +v -1.321270 0.060929 0.105548 +vn -0.374462 0.791803 0.482437 +vn -0.096896 0.852321 0.513932 +vn -0.379284 0.870022 0.314890 +vn 0.830714 0.485824 0.271767 +vn 0.984283 0.160680 0.073092 +vn 0.983917 0.170660 0.052400 +vn -0.989471 0.112491 0.090701 +vn -0.942656 0.275948 0.187597 +vn -0.990051 0.129337 0.055086 +vn -0.555315 0.709464 0.433882 +vn 0.502792 0.746544 0.435713 +vn 0.829218 0.528428 0.181982 +vn -0.600574 0.679464 0.421430 +vn -0.602893 0.749321 0.273782 +vn 0.324931 0.814142 0.481185 +vn 0.322947 0.891842 0.316660 +vn -0.744346 0.564867 0.356120 +vn -0.746330 0.624409 0.230293 +vn 0.098239 0.853572 0.511582 +vn 0.095035 0.937407 0.335002 +vn 0.996216 0.082614 0.026032 +vn 0.996704 0.077548 0.023041 +vn 0.996643 0.079165 0.019532 +vn -0.859859 0.428663 0.277200 +vn -0.861446 0.475600 0.178014 +vn -0.099521 0.936430 0.336344 +vn 0.996155 0.084780 0.021546 +vn -0.943754 0.308451 0.118870 +vn -0.943937 0.326975 0.045106 +vn -0.379833 0.915098 0.135075 +vn 0.983856 0.176305 0.030091 +vn -0.990143 0.138951 0.016877 +vn -0.557329 0.779962 0.284555 +vn 0.500443 0.816401 0.288064 +vn 0.500076 0.856197 0.129612 +vn -0.603290 0.789117 0.115360 +vn 0.322520 0.936003 0.140812 +vn -0.746666 0.658315 0.095279 +vn 0.094607 0.984558 0.147191 +vn 0.996643 0.080111 0.015778 +vn -0.861690 0.502304 0.071566 +vn -0.099948 0.984161 0.146397 +vn 0.996124 0.086001 0.016663 +vn -0.860622 0.507797 -0.037996 +vn 0.096438 0.994263 -0.046205 +vn 0.984100 0.177313 0.007111 +vn -0.377453 0.924650 -0.050020 +vn 0.828974 0.552660 0.085604 +vn 0.830012 0.557543 -0.013642 +vn -0.943175 0.330790 -0.030793 +vn -0.557848 0.821162 0.120212 +vn -0.555620 0.829951 -0.048952 +vn -0.601672 0.797296 -0.047761 +vn 0.324320 0.945067 -0.040193 +vn -0.745293 0.665273 -0.043703 +vn 0.996185 0.086245 0.011658 +vn -0.742271 0.645039 -0.181402 +vn 0.100925 0.965789 -0.238838 +vn 0.996673 0.080325 0.011902 +vn 0.996307 0.085452 0.006714 +vn -0.858241 0.491836 -0.146519 +vn -0.098086 0.993957 -0.049196 +vn 0.984649 0.173711 -0.015534 +vn -0.941527 0.319742 -0.106021 +vn -0.372204 0.898251 -0.233528 +vn 0.832270 0.542924 -0.111881 +vn -0.989746 0.140904 -0.022431 +vn -0.988891 0.135197 -0.061403 +vn -0.550768 0.805994 -0.216742 +vn 0.501694 0.864376 -0.033509 +vn 0.505234 0.840602 -0.195105 +vn -0.598132 0.773522 -0.209357 +vn 0.327860 0.918729 -0.219977 +vn 0.510544 0.785852 -0.348918 +vn -0.592822 0.718772 -0.363170 +vn 0.332560 0.858425 -0.390484 +vn -0.737754 0.598376 -0.312479 +vn 0.105289 0.901059 -0.420698 +vn 0.996765 0.079806 0.008057 +vn 0.996460 0.083712 0.002045 +vn -0.093966 0.965453 -0.242958 +vn -0.099857 0.799524 -0.592242 +vn 0.985473 0.165624 -0.036927 +vn -0.854671 0.455061 -0.249855 +vn -0.340678 0.828852 -0.443709 +vn 0.835658 0.509384 -0.205298 +vn -0.987610 0.121982 -0.098483 +vn -0.536943 0.751122 -0.384014 +vn -0.038148 0.650563 -0.758476 +vn 0.840052 0.458266 -0.290262 +vn -0.939055 0.294229 -0.177618 +vn -0.985961 0.101779 -0.132298 +vn -0.264687 0.744194 -0.613239 +vn -0.588122 0.634327 -0.501694 +vn 0.517441 0.702170 -0.489059 +vn -0.731864 0.527055 -0.431898 +vn 0.340617 0.765465 -0.545885 +vn 0.996887 0.078555 0.004395 +vn 0.996673 0.081088 -0.002136 +vn -0.850032 0.398846 -0.343974 +vn 0.096255 0.797418 -0.595691 +vn 0.986541 0.153478 -0.056215 +vn -0.935850 0.255287 -0.242836 +vn -0.844508 0.325388 -0.425306 +vn 0.084933 0.645466 -0.759026 +vn 0.987793 0.137791 -0.072573 +vn -0.932035 0.204382 -0.299173 +vn -0.009064 0.612293 -0.790551 +vn 0.845302 0.391552 -0.363475 +vn -0.983978 0.075411 -0.161473 +vn -0.481857 0.692221 -0.537187 +vn -0.053896 0.769066 -0.636860 +vn 0.525651 0.592792 -0.610126 +vn -0.602557 0.519761 -0.605579 +vn 0.342418 0.638813 -0.688925 +vn 0.997040 0.076601 0.001007 +vn 0.996948 0.077700 -0.005737 +vn -0.724845 0.433851 -0.535081 +vn -0.677541 0.374004 -0.633259 +vn 0.103519 0.231452 -0.967315 +vn 0.997223 0.074038 -0.001923 +vn 0.997223 0.073672 -0.008576 +vn -0.838313 0.237465 -0.490707 +vn 0.989166 0.119327 -0.085421 +vn -0.927732 0.143468 -0.344493 +vn 0.019135 0.513871 -0.857631 +vn 0.851131 0.311930 -0.422163 +vn -0.981750 0.043855 -0.184973 +vn -0.442152 0.644002 -0.624256 +vn -0.569414 0.479659 -0.667562 +vn 0.534867 0.461898 -0.707450 +vn 0.266182 0.458602 -0.847804 +vn 0.544725 0.314585 -0.777337 +vn -0.695486 0.202673 -0.689322 +vn -0.717002 0.322336 -0.618030 +vn -0.708579 0.196783 -0.677602 +vn 0.011689 0.027253 -0.999542 +vn 0.997467 0.070956 -0.004334 +vn 0.997528 0.069185 -0.010559 +vn -0.831690 0.138493 -0.537645 +vn 0.099307 0.208991 -0.972839 +vn 0.990600 0.098788 -0.094302 +vn -0.923154 0.074892 -0.377026 +vn 0.002625 0.489303 -0.872066 +vn 0.020844 0.160680 -0.986755 +vn 0.857387 0.222449 -0.464064 +vn -0.979369 0.008332 -0.201819 +vn -0.506485 0.240120 -0.828120 +vn -0.025788 0.037629 -0.998932 +vn 0.863765 0.126591 -0.487655 +vn -0.976928 -0.029786 -0.211402 +vn -0.440474 0.059725 -0.895749 +vn 0.552660 0.154241 -0.818995 +vn -0.679556 0.067385 -0.730491 +vn 0.148991 0.335887 -0.930021 +vn -0.699423 0.061739 -0.712027 +vn -0.039399 0.206763 -0.977569 +vn 0.997681 0.067415 -0.006134 +vn 0.997833 0.064425 -0.011628 +vn 0.116916 0.000183 -0.993133 +vn 0.992096 0.077090 -0.098941 +vn -0.918424 0.001282 -0.395520 +vn -0.824885 0.032289 -0.564318 +vn -0.818140 -0.077120 -0.569781 +vn -0.047792 0.098483 -0.993988 +vn 0.993530 0.055025 -0.099277 +vn 0.067293 -0.084353 -0.994140 +vn 0.870022 0.028016 -0.492203 +vn -0.974517 -0.069063 -0.213324 +vn 0.064119 -0.114505 -0.991333 +vn -0.580645 -0.108310 -0.806909 +vn 0.149022 0.146641 -0.977874 +vn 0.184820 -0.040223 -0.981933 +vn -0.696280 -0.062716 -0.714988 +vn 0.997925 0.063601 -0.007202 +vn 0.998138 0.059572 -0.011719 +vn -0.697043 -0.116947 -0.707389 +vn 0.220588 -0.247017 -0.943541 +vn 0.998169 0.059633 -0.007477 +vn 0.998413 0.054811 -0.010895 +vn -0.828303 -0.157170 -0.537767 +vn -0.042360 -0.236274 -0.970733 +vn 0.994873 0.033479 -0.095340 +vn -0.913785 -0.074496 -0.399274 +vn -0.909360 -0.149571 -0.388134 +vn 0.041353 -0.322794 -0.945555 +vn 0.875729 -0.069643 -0.477706 +vn -0.972228 -0.107944 -0.207556 +vn -0.332499 -0.191137 -0.923521 +vn 0.103122 -0.396741 -0.912107 +vn 0.555406 -0.011780 -0.831446 +vn -0.162389 -0.368084 -0.915464 +vn -0.452315 -0.181341 -0.873196 +vn 0.038057 -0.573077 -0.818598 +vn 0.552324 -0.178899 -0.814173 +vn 0.210028 -0.430799 -0.877621 +vn -0.327464 -0.422651 -0.845027 +vn -0.081271 -0.515397 -0.853053 +vn 0.998413 0.055666 -0.006989 +vn 0.998688 0.050325 -0.009186 +vn -0.702872 -0.252235 -0.665059 +vn 0.996063 0.013184 -0.087405 +vn -0.905789 -0.220252 -0.361888 +vn 0.029267 -0.537767 -0.842555 +vn 0.880825 -0.162633 -0.444594 +vn -0.970153 -0.144993 -0.194311 +vn 0.134312 -0.645802 -0.751579 +vn 0.885372 -0.246895 -0.393811 +vn -0.968352 -0.178747 -0.174047 +vn 0.128208 -0.765648 -0.630299 +vn 0.549120 -0.333811 -0.766167 +vn 0.143864 -0.751610 -0.643696 +vn 0.549181 -0.482040 -0.682638 +vn -0.175512 -0.654378 -0.735496 +vn 0.187567 -0.594287 -0.782037 +vn 0.998627 0.051851 -0.005707 +vn 0.998901 0.046297 -0.006623 +vn -0.853938 -0.245888 -0.458571 +vn -0.670614 -0.441908 -0.595782 +vn -0.107700 -0.650716 -0.751610 +vn 0.997101 -0.005097 -0.075808 +vn -0.904141 -0.281625 -0.321207 +vn -0.011414 -0.662282 -0.749138 +vn -0.117283 -0.747246 -0.654073 +vn 0.997894 -0.020783 -0.060976 +vn -0.859615 -0.325175 -0.394055 +vn -0.854366 -0.394971 -0.337687 +vn -0.050935 -0.760033 -0.647847 +vn 0.889370 -0.319346 -0.327067 +vn -0.966918 -0.207923 -0.147618 +vn 0.099796 -0.824946 -0.556291 +vn 0.553301 -0.604297 -0.573229 +vn 0.204932 -0.808802 -0.551195 +vn -0.073000 -0.776666 -0.625629 +vn 0.180944 -0.718009 -0.672048 +vn 0.998810 0.048341 -0.003693 +vn 0.999054 0.042817 -0.003388 +vn -0.646107 -0.587115 -0.487625 +vn -0.019105 -0.898770 -0.437941 +vn 0.197272 -0.824274 -0.530686 +vn 0.998962 0.045289 -0.001007 +vn 0.999176 0.040010 0.000458 +vn -0.607379 -0.713370 -0.349498 +vn -0.115207 -0.834712 -0.538438 +vn 0.998474 -0.033357 -0.043519 +vn -0.903104 -0.336406 -0.266762 +vn -0.901120 -0.381298 -0.206275 +vn -0.082034 -0.850948 -0.518754 +vn 0.892331 -0.377514 -0.247353 +vn -0.965911 -0.231361 -0.115970 +vn 0.053468 -0.905911 -0.420026 +vn 0.568773 -0.696371 -0.437635 +vn 0.236244 -0.869198 -0.434339 +vn 0.231239 -0.933744 -0.273141 +vn 0.586627 -0.758263 -0.284341 +vn -0.017426 -0.984619 -0.173711 +vn 0.217109 -0.908811 -0.356212 +vn 0.999054 0.042848 0.002197 +vn 0.999237 0.038026 0.004761 +vn -0.853908 -0.457167 -0.248512 +vn -0.832453 -0.533799 -0.148473 +vn -0.106052 -0.912839 -0.394238 +vn 0.998810 -0.042390 -0.024049 +vn -0.128910 -0.931150 -0.341014 +vn 0.893887 -0.419416 -0.158147 +vn -0.897885 -0.417493 -0.139500 +vn 0.019929 -0.961455 -0.274148 +vn 0.894131 -0.443342 -0.062655 +vn -0.965331 -0.248207 -0.080386 +vn -0.965239 -0.257820 -0.042177 +vn -0.009186 -0.992706 -0.120182 +vn 0.596912 -0.793634 -0.117466 +vn 0.174871 -0.981048 -0.083041 +vn 0.245796 -0.955657 -0.162114 +vn -0.563860 -0.815821 -0.128208 +vn -0.516037 -0.856197 -0.024018 +vn 0.999115 0.041078 0.005860 +vn 0.999268 0.036866 0.009339 +vn -0.798791 -0.597980 -0.065584 +vn -0.085543 -0.968596 -0.233375 +vn 0.998840 -0.047578 -0.003204 +vn -0.165990 -0.971129 -0.171270 +vn -0.057222 -0.997742 -0.034883 +vn 0.999207 0.036622 0.014100 +vn -0.895840 -0.438978 -0.068789 +vn -0.785607 -0.618397 0.019715 +vn -0.195471 -0.980560 0.015503 +vn 0.998627 -0.048769 0.018189 +vn -0.965636 -0.259774 -0.002808 +vn -0.036744 -0.998199 0.047029 +vn 0.893124 -0.448347 0.035615 +vn -0.053377 -0.997528 0.045076 +vn 0.127384 -0.989074 0.074068 +vn 0.286538 -0.957549 0.030885 +vn -0.481368 -0.873867 0.067965 +vn 0.999146 0.040071 0.009827 +vn 0.999084 0.039888 0.013886 +vn -0.027955 -0.992798 0.116337 +vn -0.023347 -0.997650 0.063936 +vn 0.320963 -0.920042 0.224586 +vn 0.998993 0.040498 0.017914 +vn -0.787011 -0.604694 0.122166 +vn -0.038575 -0.981384 0.187994 +vn 0.999115 0.037263 0.018799 +vn -0.896512 -0.442946 0.006958 +vn -0.206641 -0.960448 0.186590 +vn 0.998138 -0.045900 0.039491 +vn -0.966491 -0.254067 0.036134 +vn -0.046693 -0.980499 0.190863 +vn 0.598987 -0.799341 0.046968 +vn 0.890927 -0.434187 0.133030 +vn 0.132786 -0.978179 0.159764 +vn -0.057192 -0.981994 0.179876 +vn 0.597552 -0.774041 0.209204 +vn 0.339274 -0.848323 0.406446 +vn -0.491562 -0.858241 0.147496 +vn 0.998871 0.041932 0.021729 +vn -0.565081 -0.786493 0.249062 +vn -0.021790 -0.920469 0.390179 +vn 0.998962 0.038789 0.023316 +vn -0.898312 -0.431593 0.082034 +vn -0.799982 -0.556658 0.223914 +vn -0.020203 -0.945341 0.325388 +vn 0.997436 -0.039033 0.059908 +vn -0.967772 -0.240852 0.073214 +vn 0.169836 -0.959868 0.223090 +vn 0.592792 -0.718802 0.363170 +vn -0.900967 -0.405744 0.153661 +vn -0.969451 -0.220679 0.106998 +vn 0.170904 -0.916013 0.362896 +vn 0.887600 -0.401379 0.225837 +vn 0.883297 -0.351177 0.310526 +vn -0.143468 -0.883145 0.446577 +vn 0.348155 -0.746879 0.566485 +vn -0.635243 -0.684622 0.357341 +vn 0.998688 0.044069 0.025178 +vn -0.824061 -0.487320 0.288766 +vn -0.203467 -0.917539 0.341594 +vn -0.189062 -0.843776 0.502243 +vn 0.998749 0.041169 0.027436 +vn -0.904904 -0.366100 0.217048 +vn 0.028748 -0.876370 0.480758 +vn 0.996460 -0.028382 0.078738 +vn 0.998505 0.044282 0.031068 +vn -0.838893 -0.393567 0.375927 +vn 0.070132 -0.790216 0.608753 +vn 0.995331 -0.014252 0.095279 +vn -0.971435 -0.194281 0.136204 +vn 0.132603 -0.823817 0.551073 +vn 0.585925 -0.635090 0.503311 +vn 0.577715 -0.525712 0.624378 +vn -0.249458 -0.730308 0.635884 +vn -0.677450 -0.511155 0.528886 +vn -0.000641 -0.823328 0.567522 +vn 0.354869 -0.618183 0.701315 +vn 0.998505 0.046815 0.028108 +vn -0.153081 -0.708701 0.688681 +vn 0.015046 -0.693136 0.720603 +vn 0.359874 -0.466201 0.808130 +vn 0.998260 0.050081 0.030427 +vn -0.712210 -0.368603 0.597339 +vn 0.015076 -0.534349 0.845119 +vn 0.998260 0.048097 0.034028 +vn -0.908902 -0.314097 0.274178 +vn -0.837275 -0.318339 0.444472 +vn 0.112522 -0.657094 0.745354 +vn 0.878140 -0.285440 0.383862 +vn 0.994049 0.002838 0.108890 +vn -0.973632 -0.162725 0.159673 +vn 0.079043 -0.651418 0.754570 +vn 0.872341 -0.206641 0.443007 +vn -0.379650 -0.543687 0.748466 +vn -0.475265 -0.251350 0.843135 +vn 0.568499 -0.394848 0.721702 +vn 0.558641 -0.247505 0.791589 +vn -0.732963 -0.233222 0.638997 +vn 0.366466 -0.297952 0.881405 +vn 0.998016 0.053743 0.032044 +vn -0.831690 -0.223701 0.508103 +vn -0.116092 -0.513871 0.849940 +vn -0.092380 -0.363811 0.926847 +vn 0.997955 0.052400 0.036225 +vn -0.912351 -0.254799 0.320383 +vn 0.122623 -0.418348 0.899960 +vn 0.992615 0.022370 0.118992 +vn -0.976012 -0.127201 0.176519 +vn -0.035859 -0.338450 0.940275 +vn -0.916684 -0.186743 0.353252 +vn -0.978454 -0.089053 0.186102 +vn -0.152043 -0.137059 0.978820 +vn 0.866146 -0.117771 0.485672 +vn 0.548509 -0.089358 0.831324 +vn -0.499710 -0.087191 0.861782 +vn -0.712699 -0.118076 0.691427 +vn 0.022614 -0.362712 0.931608 +vn 0.369549 -0.117771 0.921690 +vn 0.997772 0.057619 0.032899 +vn -0.083590 -0.177953 0.980468 +vn 0.997650 0.057070 0.037538 +vn -0.921384 -0.113132 0.371746 +vn 0.063601 -0.211982 0.975188 +vn 0.991150 0.043672 0.125126 +vn 0.997345 0.061953 0.037935 +vn -0.829279 -0.132756 0.542802 +vn -0.926054 -0.037324 0.375500 +vn 0.037690 -0.054811 0.997772 +vn 0.859767 -0.022187 0.510178 +vn 0.989685 0.065889 0.127018 +vn -0.980865 -0.049776 0.188055 +vn -0.245125 -0.018342 0.969298 +vn 0.538499 0.073458 0.839381 +vn -0.552080 -0.018647 0.833552 +vn 0.364238 0.066408 0.928922 +vn -0.711478 -0.011475 0.702597 +vn 0.031343 -0.158574 0.986847 +vn 0.997528 0.061586 0.033021 +vn -0.071932 0.012207 0.997314 +vn 0.029176 0.043703 0.998596 +vn 0.039552 0.239692 0.970031 +vn 0.997314 0.065462 0.032350 +vn -0.835902 -0.023438 0.548357 +vn -0.842280 0.084902 0.532273 +vn -0.048036 0.122135 0.991333 +vn 0.997040 0.066836 0.037324 +vn -0.930479 0.037751 0.364360 +vn -0.014863 0.022034 0.999634 +vn 0.853420 0.076388 0.515549 +vn 0.988281 0.088198 0.124454 +vn -0.983154 -0.010895 0.182287 +vn -0.287851 0.176611 0.941221 +vn 0.847407 0.174261 0.501480 +vn -0.576708 0.166082 0.799860 +vn 0.352794 0.248085 0.902188 +vn -0.722007 0.128758 0.679739 +vn -0.605853 0.304514 0.734947 +vn 0.529008 0.234779 0.815485 +vn 0.337230 0.419202 0.842891 +vn -0.729362 0.259651 0.632893 +vn 0.055849 0.427595 0.902219 +vn 0.997101 0.069124 0.030946 +vn -0.848079 0.188055 0.495346 +vn -0.022523 0.291757 0.956206 +vn 0.996765 0.071535 0.035768 +vn -0.934477 0.109226 0.338755 +vn -0.066775 0.265389 0.961821 +vn 0.986969 0.109684 0.117496 +vn -0.985260 0.026124 0.169042 +vn -0.423841 0.260079 0.867550 +vn 0.520371 0.388379 0.760491 +vn -0.987030 0.059877 0.148778 +vn -0.553056 0.497757 0.668050 +vn 0.841914 0.267617 0.468520 +vn 0.512955 0.528306 0.676534 +vn -0.643544 0.442030 0.624805 +vn 0.324656 0.574297 0.751488 +vn -0.735710 0.378918 0.561357 +vn 0.074831 0.583087 0.808924 +vn 0.996948 0.072420 0.028871 +vn -0.853053 0.282083 0.438978 +vn -0.013337 0.395398 0.918393 +vn 0.996551 0.075838 0.033326 +vn -0.937956 0.174383 0.299692 +vn -0.186468 0.593951 0.782556 +vn 0.985839 0.129490 0.106296 +vn -0.940703 0.230659 0.248634 +vn -0.325968 0.706595 0.628040 +vn 0.837184 0.352794 0.417859 +vn 0.984924 0.146733 0.091311 +vn -0.543962 0.651540 0.528703 +vn 0.507004 0.649251 0.566881 +vn 0.325358 0.705710 0.629353 +vn -0.599200 0.581439 0.550340 +vn 0.996796 0.075259 0.026185 +vn -0.857051 0.363323 0.365307 +vn -0.103153 0.562700 0.820154 +vn 0.996368 0.079592 0.030030 +vn -0.998047 -0.060671 -0.012879 +vn 0.998047 0.060671 0.012879 +vn -0.988464 0.089053 0.122349 +vn -0.740745 0.481979 0.467910 +vn 0.102420 0.732994 0.672445 +vn 0.833399 0.426496 0.351421 +usemtl Body +s 1 +f 7981//5754 7980//5755 7996//5756 +f 7976//5757 7975//5758 7990//5759 +f 7987//5760 7986//5761 8002//5762 +f 7982//5763 7981//5754 7996//5756 +f 7977//5764 7976//5757 7991//5765 +f 7983//5766 7982//5763 7998//5767 +f 7978//5768 7977//5764 7993//5769 +f 7984//5770 7983//5766 7999//5771 +f 7979//5772 7978//5768 7994//5773 +f 7974//5774 7973//5775 7988//5776 +f 7985//5777 7984//5770 8000//5778 +f 7980//5755 7979//5772 7995//5779 +f 7975//5758 7974//5774 7989//5780 +f 7986//5761 7985//5777 8000//5778 +f 8001//5781 8000//5778 8016//5782 +f 7996//5756 7995//5779 8011//5783 +f 7991//5765 7990//5759 8005//5784 +f 8002//5762 8001//5781 8017//5785 +f 7997//5786 7996//5756 8011//5783 +f 7992//5787 7991//5765 8007//5788 +f 7998//5767 7997//5786 8013//5789 +f 7993//5769 7992//5787 8008//5790 +f 7999//5771 7998//5767 8014//5791 +f 7994//5773 7993//5769 8009//5792 +f 7989//5780 7988//5776 8003//5793 +f 8000//5778 7999//5771 8015//5794 +f 7995//5779 7994//5773 8010//5795 +f 7990//5759 7989//5780 8004//5796 +f 8015//5794 8014//5791 8030//5797 +f 8010//5795 8009//5792 8024//5798 +f 8005//5784 8004//5796 8020//5799 +f 8016//5782 8015//5794 8030//5797 +f 8011//5783 8010//5795 8026//5800 +f 8006//5801 8005//5784 8021//5802 +f 8017//5785 8016//5782 8031//5803 +f 8012//5804 8011//5783 8027//5805 +f 8007//5788 8006//5801 8021//5802 +f 8013//5789 8012//5804 8028//5806 +f 8008//5790 8007//5788 8023//5807 +f 8014//5791 8013//5789 8029//5808 +f 8009//5792 8008//5790 8024//5798 +f 8004//5796 8003//5793 8019//5809 +f 8029//5808 8028//5806 8044//5810 +f 8024//5798 8023//5807 8039//5811 +f 8019//5809 8018//5812 8034//5813 +f 8030//5797 8029//5808 8045//5814 +f 8025//5815 8024//5798 8039//5811 +f 8020//5799 8019//5809 8035//5816 +f 8031//5803 8030//5797 8046//5817 +f 8026//5800 8025//5815 8041//5818 +f 8021//5802 8020//5799 8036//5819 +f 8032//5820 8031//5803 8047//5821 +f 8027//5805 8026//5800 8042//5822 +f 8022//5823 8021//5802 8037//5824 +f 8028//5806 8027//5805 8043//5825 +f 8023//5807 8022//5823 8038//5826 +f 8037//5824 8036//5819 8052//5827 +f 8043//5825 8042//5822 8058//5828 +f 8038//5826 8037//5824 8053//5829 +f 8044//5810 8043//5825 8059//5830 +f 8039//5811 8038//5826 8054//5831 +f 8034//5813 8033//5832 8049//5833 +f 8045//5814 8044//5810 8059//5830 +f 8040//5834 8039//5811 8055//5835 +f 8035//5816 8034//5813 8050//5836 +f 8046//5817 8045//5814 8060//5837 +f 8041//5818 8040//5834 8056//5838 +f 8036//5819 8035//5816 8051//5839 +f 8047//5821 8046//5817 8062//5840 +f 8042//5822 8041//5818 8057//5841 +f 8056//5838 8055//5835 8070//5842 +f 8051//5839 8050//5836 8066//5843 +f 8062//5840 8061//5844 8077//5845 +f 8057//5841 8056//5838 8071//5846 +f 8052//5827 8051//5839 8066//5843 +f 8058//5828 8057//5841 8073//5847 +f 8053//5829 8052//5827 8067//5848 +f 8059//5830 8058//5828 8074//5849 +f 8054//5831 8053//5829 8068//5850 +f 8049//5833 8048//5851 8064//5852 +f 8060//5837 8059//5830 8075//5853 +f 8055//5835 8054//5831 8069//5854 +f 8050//5836 8049//5833 8065//5855 +f 8061//5844 8060//5837 8076//5856 +f 8075//5853 8074//5849 8090//5857 +f 8070//5842 8069//5854 8084//5858 +f 8065//5855 8064//5852 8080//5859 +f 8076//5856 8075//5853 8091//5860 +f 8071//5846 8070//5842 8085//5861 +f 8066//5843 8065//5855 8081//5862 +f 8077//5845 8076//5856 8092//5863 +f 8072//5864 8071//5846 8086//5865 +f 8067//5848 8066//5843 8082//5866 +f 8073//5847 8072//5864 8088//5867 +f 8068//5850 8067//5848 8083//5868 +f 8074//5849 8073//5847 8088//5867 +f 8069//5854 8068//5850 8083//5868 +f 8064//5852 8063//5869 8079//5870 +f 8089//5871 8088//5867 8103//5872 +f 8084//5858 8083//5868 8099//5873 +f 8079//5870 8078//5874 8094//5875 +f 8090//5857 8089//5871 8105//5876 +f 8085//5861 8084//5858 8099//5873 +f 8080//5859 8079//5870 8095//5877 +f 8091//5860 8090//5857 8106//5878 +f 8086//5865 8085//5861 8100//5879 +f 8081//5862 8080//5859 8096//5880 +f 8092//5863 8091//5860 8107//5881 +f 8087//5882 8086//5865 8102//5883 +f 8082//5866 8081//5862 8097//5884 +f 8088//5867 8087//5882 8103//5872 +f 8083//5868 8082//5866 8098//5885 +f 8097//5884 8096//5880 8112//5886 +f 8103//5872 8102//5883 8118//5887 +f 8098//5885 8097//5884 8112//5886 +f 8104//5888 8103//5872 8119//5889 +f 8099//5873 8098//5885 8114//5890 +f 8094//5875 8093//5891 8109//5892 +f 8105//5876 8104//5888 8120//5893 +f 8100//5879 8099//5873 8115//5894 +f 8095//5877 8094//5875 8110//5895 +f 8106//5878 8105//5876 8121//5896 +f 8101//5897 8100//5879 8116//5898 +f 8096//5880 8095//5877 8111//5899 +f 8107//5881 8106//5878 8122//5900 +f 8102//5883 8101//5897 8117//5901 +f 8116//5898 8115//5894 8131//5902 +f 8111//5899 8110//5895 8126//5903 +f 8122//5900 8121//5896 8137//5904 +f 8117//5901 8116//5898 8132//5905 +f 8112//5886 8111//5899 8127//5906 +f 8118//5887 8117//5901 8133//5907 +f 8113//5908 8112//5886 8127//5906 +f 8119//5889 8118//5887 8134//5909 +f 8114//5890 8113//5908 8129//5910 +f 8109//5892 8108//5911 8124//5912 +f 8120//5893 8119//5889 8134//5909 +f 8115//5894 8114//5890 8130//5913 +f 8110//5895 8109//5892 8125//5914 +f 8121//5896 8120//5893 8136//5915 +f 8135//5916 8134//5909 8150//5917 +f 8130//5913 8129//5910 8144//5918 +f 8125//5914 8124//5912 8140//5919 +f 8136//5915 8135//5916 8150//5917 +f 8131//5902 8130//5913 8145//5920 +f 8126//5903 8125//5914 8141//5921 +f 8137//5904 8136//5915 8152//5922 +f 8132//5905 8131//5902 8146//5923 +f 8127//5906 8126//5903 8141//5921 +f 8133//5907 8132//5905 8148//5924 +f 8128//5925 8127//5906 8143//5926 +f 8134//5909 8133//5907 8149//5927 +f 8129//5910 8128//5925 8143//5926 +f 8124//5912 8123//5928 8139//5929 +f 8149//5927 8148//5924 8164//5930 +f 8144//5918 8143//5926 8158//5931 +f 8139//5929 8138//5932 8154//5933 +f 8150//5917 8149//5927 8165//5934 +f 8145//5920 8144//5918 8159//5935 +f 8140//5919 8139//5929 8155//5936 +f 8151//5937 8150//5917 8166//5938 +f 8146//5923 8145//5920 8160//5939 +f 8141//5921 8140//5919 8156//5940 +f 8152//5922 8151//5937 8167//5941 +f 8147//5942 8146//5923 8161//5943 +f 8142//5944 8141//5921 8156//5940 +f 8148//5924 8147//5942 8162//5945 +f 8143//5926 8142//5944 8158//5931 +f 8163//5946 8162//5945 8177//5947 +f 8158//5931 8157//5948 8173//5949 +f 8164//5930 8163//5946 8178//5950 +f 8159//5935 8158//5931 8174//5951 +f 8154//5933 8153//5952 8169//5953 +f 8165//5934 8164//5930 8179//5954 +f 8160//5939 8159//5935 8174//5951 +f 8155//5936 8154//5933 8170//5955 +f 8166//5938 8165//5934 8181//5956 +f 8161//5943 8160//5939 8175//5957 +f 8156//5940 8155//5936 8171//5958 +f 8167//5941 8166//5938 8182//5959 +f 8162//5945 8161//5943 8176//5960 +f 8157//5948 8156//5940 8171//5958 +f 8171//5958 8170//5955 8186//5961 +f 8182//5959 8181//5956 8197//5962 +f 8177//5947 8176//5960 8191//5963 +f 8172//5964 8171//5958 8186//5961 +f 8178//5950 8177//5947 8192//5965 +f 8173//5949 8172//5964 8187//5966 +f 8179//5954 8178//5950 8193//5967 +f 8174//5951 8173//5949 8188//5968 +f 8169//5953 8168//5969 8184//5970 +f 8180//5971 8179//5954 8194//5972 +f 8175//5957 8174//5951 8189//5973 +f 8170//5955 8169//5953 8185//5974 +f 8181//5956 8180//5971 8196//5975 +f 8176//5960 8175//5957 8190//5976 +f 8190//5976 8189//5973 8204//5977 +f 8185//5974 8184//5970 8200//5978 +f 8196//5975 8195//5979 8210//5980 +f 8191//5963 8190//5976 8205//5981 +f 8186//5961 8185//5974 8201//5982 +f 8197//5962 8196//5975 8212//5983 +f 8192//5965 8191//5963 8206//5984 +f 8187//5966 8186//5961 8202//5985 +f 8193//5967 8192//5965 8207//5986 +f 8188//5968 8187//5966 8202//5985 +f 8194//5972 8193//5967 8208//5987 +f 8189//5973 8188//5968 8203//5988 +f 8184//5970 8183//5989 8199//5990 +f 8195//5979 8194//5972 8209//5991 +f 8209//5991 8208//5987 8223//5992 +f 8204//5977 8203//5988 8218//5993 +f 8199//5990 8198//5994 8214//5995 +f 8210//5980 8209//5991 8224//5996 +f 8205//5981 8204//5977 8219//5997 +f 8200//5978 8199//5990 8215//5998 +f 8211//5999 8210//5980 8226//6000 +f 8206//5984 8205//5981 8220//6001 +f 8201//5982 8200//5978 8216//6002 +f 8212//5983 8211//5999 8227//6003 +f 8207//5986 8206//5984 8221//6004 +f 8202//5985 8201//5982 8217//6005 +f 8208//5987 8207//5986 8222//6006 +f 8203//5988 8202//5985 8217//6005 +f 8223//5992 8222//6006 8237//6007 +f 8218//5993 8217//6005 8232//6008 +f 8224//5996 8223//5992 8238//6009 +f 8219//5997 8218//5993 8233//6010 +f 8214//5995 8213//6011 8229//6012 +f 8225//6013 8224//5996 8240//6014 +f 8220//6001 8219//5997 8234//6015 +f 8215//5998 8214//5995 8230//6016 +f 8226//6000 8225//6013 8240//6014 +f 8221//6004 8220//6001 8235//6017 +f 8216//6002 8215//5998 8231//6018 +f 8227//6003 8226//6000 8241//6019 +f 8222//6006 8221//6004 8236//6020 +f 8217//6005 8216//6002 8232//6008 +f 8231//6018 8230//6016 8246//6021 +f 8242//6022 8241//6019 8257//6023 +f 8237//6007 8236//6020 8251//6024 +f 8232//6008 8231//6018 8247//6025 +f 8238//6009 8237//6007 8252//6026 +f 8233//6010 8232//6008 8248//6027 +f 8239//6028 8238//6009 8254//6029 +f 8234//6015 8233//6010 8248//6027 +f 8229//6012 8228//6030 8244//6031 +f 8240//6014 8239//6028 8255//6032 +f 8235//6017 8234//6015 8249//6033 +f 8230//6016 8229//6012 8245//6034 +f 8241//6019 8240//6014 8255//6032 +f 8236//6020 8235//6017 8250//6035 +f 8250//6035 8249//6033 8264//6036 +f 8245//6034 8244//6031 8259//6037 +f 8256//6038 8255//6032 8270//6039 +f 8251//6024 8250//6035 8265//6040 +f 8246//6021 8245//6034 8260//6041 +f 8257//6023 8256//6038 8272//6042 +f 8252//6026 8251//6024 8266//6043 +f 8247//6025 8246//6021 8261//6044 +f 8253//6045 8252//6026 8267//6046 +f 8248//6027 8247//6025 8263//6047 +f 8254//6029 8253//6045 8269//6048 +f 8249//6033 8248//6027 8263//6047 +f 8244//6031 8243//6049 8258//6050 +f 8255//6032 8254//6029 8270//6039 +f 8269//6048 8268//6051 8283//6052 +f 8264//6036 8263//6047 8278//6053 +f 8259//6037 8258//6050 8273//6054 +f 8270//6039 8269//6048 8285//6055 +f 8265//6040 8264//6036 8279//6056 +f 8260//6041 8259//6037 8274//6057 +f 8271//6058 8270//6039 8285//6055 +f 8266//6043 8265//6040 8280//6059 +f 8261//6044 8260//6041 8275//6060 +f 8272//6042 8271//6058 8287//6061 +f 8267//6046 8266//6043 8281//6062 +f 8262//6063 8261//6044 8276//6064 +f 8268//6051 8267//6046 8282//6065 +f 8263//6047 8262//6063 8278//6053 +f 8283//6052 8282//6065 8298//6066 +f 8278//6053 8277//6067 8293//6068 +f 8284//6069 8283//6052 8298//6066 +f 8279//6056 8278//6053 8293//6068 +f 8274//6057 8273//6054 8288//6070 +f 8285//6055 8284//6069 8299//6071 +f 8280//6059 8279//6056 8294//6072 +f 8275//6060 8274//6057 8289//6073 +f 8286//6074 8285//6055 8300//6075 +f 8281//6062 8280//6059 8296//6076 +f 8276//6064 8275//6060 8290//6077 +f 8287//6061 8286//6074 8302//6078 +f 8282//6065 8281//6062 8297//6079 +f 8277//6067 8276//6064 8292//6080 +f 8302//6078 8301//6081 8318//6082 +f 8297//6079 8296//6076 8313//6083 +f 8292//6080 8291//6084 8307//6085 +f 8298//6066 8297//6079 8314//6086 +f 8293//6068 8292//6080 8309//6087 +f 8299//6071 8298//6066 8315//6088 +f 8294//6072 8293//6068 8309//6087 +f 8289//6073 8288//6070 8304//6089 +f 8300//6075 8299//6071 8316//6090 +f 8295//6091 8294//6072 8311//6092 +f 8290//6077 8289//6073 8305//6093 +f 8301//6081 8300//6075 8317//6094 +f 8296//6076 8295//6091 8312//6095 +f 8291//6084 8290//6077 8306//6096 +f 8306//6096 8305//6093 8320//6097 +f 8317//6094 8316//6090 8331//6098 +f 8312//6095 8311//6092 8327//6099 +f 8307//6085 8306//6096 8321//6100 +f 8318//6082 8317//6094 8333//6101 +f 8313//6083 8312//6095 8328//6102 +f 8308//6103 8307//6085 8323//6104 +f 8314//6086 8313//6083 8329//6105 +f 8309//6087 8308//6103 8323//6104 +f 8315//6088 8314//6086 8330//6106 +f 8310//6107 8309//6087 8324//6108 +f 8305//6093 8304//6089 8319//6109 +f 8316//6090 8315//6088 8331//6098 +f 8311//6092 8310//6107 8326//6110 +f 8325//6111 8324//6108 8339//6112 +f 8320//6097 8319//6109 8334//6113 +f 8331//6098 8330//6106 8345//6114 +f 8326//6110 8325//6111 8340//6115 +f 8321//6100 8320//6097 8335//6116 +f 8332//6117 8331//6098 8346//6118 +f 8327//6099 8326//6110 8342//6119 +f 8322//6120 8321//6100 8336//6121 +f 8333//6101 8332//6117 8348//6122 +f 8328//6102 8327//6099 8343//6123 +f 8323//6104 8322//6120 8337//6124 +f 8329//6105 8328//6102 8344//6125 +f 8324//6108 8323//6104 8339//6112 +f 8330//6106 8329//6105 8345//6114 +f 8344//6125 8343//6123 8359//6126 +f 8339//6112 8338//6127 8353//6128 +f 8345//6114 8344//6125 8360//6129 +f 8340//6115 8339//6112 8354//6130 +f 8335//6116 8334//6113 8349//6131 +f 8346//6118 8345//6114 8361//6132 +f 8341//6133 8340//6115 8356//6134 +f 8336//6121 8335//6116 8350//6135 +f 8347//6136 8346//6118 8361//6132 +f 8342//6119 8341//6133 8357//6137 +f 8337//6124 8336//6121 8351//6138 +f 8348//6122 8347//6136 8363//6139 +f 8343//6123 8342//6119 8358//6140 +f 8338//6127 8337//6124 8353//6128 +f 8363//6139 8362//6141 8378//6142 +f 8358//6140 8357//6137 8373//6143 +f 8353//6128 8352//6144 8368//6145 +f 8359//6126 8358//6140 8374//6146 +f 8354//6130 8353//6128 8368//6145 +f 8360//6129 8359//6126 8375//6147 +f 8355//6148 8354//6130 8369//6149 +f 8350//6135 8349//6131 8364//6150 +f 8361//6132 8360//6129 8375//6147 +f 8356//6134 8355//6148 8371//6151 +f 8351//6138 8350//6135 8365//6152 +f 8362//6141 8361//6132 8377//6153 +f 8357//6137 8356//6134 8372//6154 +f 8352//6144 8351//6138 8366//6155 +f 8366//6155 8365//6152 8380//6156 +f 8377//6153 8376//6157 8392//6158 +f 8372//6154 8371//6151 8387//6159 +f 8367//6160 8366//6155 8381//6161 +f 8378//6142 8377//6153 8393//6162 +f 8373//6143 8372//6154 8388//6163 +f 8368//6145 8367//6160 8383//6164 +f 8374//6146 8373//6143 8389//6165 +f 8369//6149 8368//6145 8384//6166 +f 8375//6147 8374//6146 8390//6167 +f 8370//6168 8369//6149 8384//6166 +f 8365//6152 8364//6150 8379//6169 +f 8376//6157 8375//6147 8390//6167 +f 8371//6151 8370//6168 8386//6170 +f 8385//6171 8384//6166 8400//6172 +f 8380//6156 8379//6169 8394//6173 +f 8391//6174 8390//6167 8406//6175 +f 8386//6170 8385//6171 8401//6176 +f 8381//6161 8380//6156 8395//6177 +f 8392//6158 8391//6174 8407//6178 +f 8387//6159 8386//6170 8402//6179 +f 8382//6180 8381//6161 8396//6181 +f 8393//6162 8392//6158 8408//6182 +f 8388//6163 8387//6159 8403//6183 +f 8383//6164 8382//6180 8397//6184 +f 8389//6165 8388//6163 8404//6185 +f 8384//6166 8383//6164 8399//6186 +f 8390//6167 8389//6165 8405//6187 +f 8404//6185 8403//6183 8419//6188 +f 8399//6186 8398//6189 8414//6190 +f 8405//6187 8404//6185 8420//6191 +f 8400//6172 8399//6186 8415//6192 +f 8395//6177 8394//6173 8409//6193 +f 8406//6175 8405//6187 8421//6194 +f 8401//6176 8400//6172 8416//6195 +f 8396//6181 8395//6177 8410//6196 +f 8407//6178 8406//6175 8422//6197 +f 8402//6179 8401//6176 8417//6198 +f 8397//6184 8396//6181 8411//6199 +f 8408//6182 8407//6178 8423//6200 +f 8403//6183 8402//6179 8418//6201 +f 8398//6189 8397//6184 8413//6202 +f 8423//6200 8422//6197 8439//6203 +f 8418//6201 8417//6198 8434//6204 +f 8413//6202 8412//6205 8429//6206 +f 8419//6188 8418//6201 8435//6207 +f 8414//6190 8413//6202 8430//6208 +f 8420//6191 8419//6188 8436//6209 +f 8415//6192 8414//6190 8431//6210 +f 8410//6196 8409//6193 8425//6211 +f 8421//6194 8420//6191 8437//6212 +f 8416//6195 8415//6192 8432//6213 +f 8411//6199 8410//6196 8426//6214 +f 8422//6197 8421//6194 8438//6215 +f 8417//6198 8416//6195 8433//6216 +f 8412//6205 8411//6199 8427//6217 +f 8438//6215 8437//6212 8453//6218 +f 8433//6216 8432//6213 8448//6219 +f 8428//6220 8427//6217 8442//6221 +f 8439//6203 8438//6215 8453//6218 +f 8434//6204 8433//6216 8449//6222 +f 8429//6206 8428//6220 8444//6223 +f 8435//6207 8434//6204 8449//6222 +f 8430//6208 8429//6206 8445//6224 +f 8436//6209 8435//6207 8450//6225 +f 8431//6210 8430//6208 8445//6224 +f 8426//6214 8425//6211 8440//6226 +f 8437//6212 8436//6209 8452//6227 +f 8432//6213 8431//6210 8447//6228 +f 8427//6217 8426//6214 8441//6229 +f 8303//6230 7987//5760 8002//5762 +f 7973//5775 8424//6231 7988//5776 +f 8303//6230 8002//5762 8017//5785 +f 7988//5776 8424//6231 8003//5793 +f 8303//6230 8017//5785 8032//5820 +f 8003//5793 8424//6231 8018//5812 +f 8018//5812 8424//6231 8033//5832 +f 8303//6230 8032//5820 8047//5821 +f 8303//6230 8047//5821 8062//5840 +f 8033//5832 8424//6231 8048//5851 +f 8303//6230 8062//5840 8077//5845 +f 8048//5851 8424//6231 8063//5869 +f 8303//6230 8077//5845 8092//5863 +f 8063//5869 8424//6231 8078//5874 +f 8078//5874 8424//6231 8093//5891 +f 8303//6230 8092//5863 8107//5881 +f 8303//6230 8107//5881 8122//5900 +f 8093//5891 8424//6231 8108//5911 +f 8303//6230 8122//5900 8137//5904 +f 8108//5911 8424//6231 8123//5928 +f 8303//6230 8137//5904 8152//5922 +f 8123//5928 8424//6231 8138//5932 +f 8303//6230 8152//5922 8167//5941 +f 8138//5932 8424//6231 8153//5952 +f 8303//6230 8167//5941 8182//5959 +f 8153//5952 8424//6231 8168//5969 +f 8303//6230 8182//5959 8197//5962 +f 8168//5969 8424//6231 8183//5989 +f 8303//6230 8197//5962 8212//5983 +f 8183//5989 8424//6231 8198//5994 +f 8303//6230 8212//5983 8227//6003 +f 8198//5994 8424//6231 8213//6011 +f 8303//6230 8227//6003 8242//6022 +f 8213//6011 8424//6231 8228//6030 +f 8303//6230 8242//6022 8257//6023 +f 8228//6030 8424//6231 8243//6049 +f 8303//6230 8257//6023 8272//6042 +f 8243//6049 8424//6231 8258//6050 +f 8303//6230 8272//6042 8287//6061 +f 8258//6050 8424//6231 8273//6054 +f 8303//6230 8287//6061 8302//6078 +f 8273//6054 8424//6231 8288//6070 +f 8303//6230 8302//6078 8318//6082 +f 8288//6070 8424//6231 8304//6089 +f 8303//6230 8318//6082 8333//6101 +f 8304//6089 8424//6231 8319//6109 +f 8303//6230 8333//6101 8348//6122 +f 8319//6109 8424//6231 8334//6113 +f 8334//6113 8424//6231 8349//6131 +f 8303//6230 8348//6122 8363//6139 +f 8303//6230 8363//6139 8378//6142 +f 8349//6131 8424//6231 8364//6150 +f 8303//6230 8378//6142 8393//6162 +f 8364//6150 8424//6231 8379//6169 +f 8303//6230 8393//6162 8408//6182 +f 8379//6169 8424//6231 8394//6173 +f 8394//6173 8424//6231 8409//6193 +f 8303//6230 8408//6182 8423//6200 +f 8303//6230 8423//6200 8439//6203 +f 8409//6193 8424//6231 8425//6211 +f 8303//6230 8439//6203 8454//6232 +f 8425//6211 8424//6231 8440//6226 +f 8441//6229 8440//6226 7973//5775 +f 8452//6227 8451//6233 7984//5770 +f 8447//6228 8446//6234 7979//5772 +f 8442//6221 8441//6229 7974//5774 +f 8453//6218 8452//6227 7985//5777 +f 8448//6219 8447//6228 7981//5754 +f 8443//6235 8442//6221 7975//5758 +f 8454//6232 8453//6218 7986//5761 +f 8449//6222 8448//6219 7981//5754 +f 8444//6223 8443//6235 7977//5764 +f 8303//6230 8454//6232 7987//5760 +f 8450//6225 8449//6222 7982//5763 +f 8445//6224 8444//6223 7978//5768 +f 8440//6226 8424//6231 7973//5775 +f 8451//6233 8450//6225 7983//5766 +f 8446//6234 8445//6224 7978//5768 +f 7980//5755 7995//5779 7996//5756 +f 7991//5765 7976//5757 7990//5759 +f 7986//5761 8001//5781 8002//5762 +f 7997//5786 7982//5763 7996//5756 +f 7992//5787 7977//5764 7991//5765 +f 7982//5763 7997//5786 7998//5767 +f 7977//5764 7992//5787 7993//5769 +f 7983//5766 7998//5767 7999//5771 +f 7978//5768 7993//5769 7994//5773 +f 7989//5780 7974//5774 7988//5776 +f 7984//5770 7999//5771 8000//5778 +f 7979//5772 7994//5773 7995//5779 +f 7990//5759 7975//5758 7989//5780 +f 8001//5781 7986//5761 8000//5778 +f 8000//5778 8015//5794 8016//5782 +f 7995//5779 8010//5795 8011//5783 +f 8006//5801 7991//5765 8005//5784 +f 8001//5781 8016//5782 8017//5785 +f 8012//5804 7997//5786 8011//5783 +f 7991//5765 8006//5801 8007//5788 +f 7997//5786 8012//5804 8013//5789 +f 7992//5787 8007//5788 8008//5790 +f 7998//5767 8013//5789 8014//5791 +f 7993//5769 8008//5790 8009//5792 +f 8004//5796 7989//5780 8003//5793 +f 7999//5771 8014//5791 8015//5794 +f 7994//5773 8009//5792 8010//5795 +f 8005//5784 7990//5759 8004//5796 +f 8014//5791 8029//5808 8030//5797 +f 8025//5815 8010//5795 8024//5798 +f 8004//5796 8019//5809 8020//5799 +f 8031//5803 8016//5782 8030//5797 +f 8010//5795 8025//5815 8026//5800 +f 8005//5784 8020//5799 8021//5802 +f 8032//5820 8017//5785 8031//5803 +f 8011//5783 8026//5800 8027//5805 +f 8022//5823 8007//5788 8021//5802 +f 8012//5804 8027//5805 8028//5806 +f 8007//5788 8022//5823 8023//5807 +f 8013//5789 8028//5806 8029//5808 +f 8008//5790 8023//5807 8024//5798 +f 8003//5793 8018//5812 8019//5809 +f 8028//5806 8043//5825 8044//5810 +f 8023//5807 8038//5826 8039//5811 +f 8018//5812 8033//5832 8034//5813 +f 8029//5808 8044//5810 8045//5814 +f 8040//5834 8025//5815 8039//5811 +f 8019//5809 8034//5813 8035//5816 +f 8030//5797 8045//5814 8046//5817 +f 8025//5815 8040//5834 8041//5818 +f 8020//5799 8035//5816 8036//5819 +f 8031//5803 8046//5817 8047//5821 +f 8026//5800 8041//5818 8042//5822 +f 8021//5802 8036//5819 8037//5824 +f 8027//5805 8042//5822 8043//5825 +f 8022//5823 8037//5824 8038//5826 +f 8036//5819 8051//5839 8052//5827 +f 8042//5822 8057//5841 8058//5828 +f 8037//5824 8052//5827 8053//5829 +f 8043//5825 8058//5828 8059//5830 +f 8038//5826 8053//5829 8054//5831 +f 8033//5832 8048//5851 8049//5833 +f 8060//5837 8045//5814 8059//5830 +f 8039//5811 8054//5831 8055//5835 +f 8034//5813 8049//5833 8050//5836 +f 8061//5844 8046//5817 8060//5837 +f 8040//5834 8055//5835 8056//5838 +f 8035//5816 8050//5836 8051//5839 +f 8046//5817 8061//5844 8062//5840 +f 8041//5818 8056//5838 8057//5841 +f 8071//5846 8056//5838 8070//5842 +f 8050//5836 8065//5855 8066//5843 +f 8061//5844 8076//5856 8077//5845 +f 8072//5864 8057//5841 8071//5846 +f 8067//5848 8052//5827 8066//5843 +f 8057//5841 8072//5864 8073//5847 +f 8068//5850 8053//5829 8067//5848 +f 8058//5828 8073//5847 8074//5849 +f 8069//5854 8054//5831 8068//5850 +f 8048//5851 8063//5869 8064//5852 +f 8059//5830 8074//5849 8075//5853 +f 8070//5842 8055//5835 8069//5854 +f 8049//5833 8064//5852 8065//5855 +f 8060//5837 8075//5853 8076//5856 +f 8074//5849 8089//5871 8090//5857 +f 8085//5861 8070//5842 8084//5858 +f 8064//5852 8079//5870 8080//5859 +f 8075//5853 8090//5857 8091//5860 +f 8086//5865 8071//5846 8085//5861 +f 8065//5855 8080//5859 8081//5862 +f 8076//5856 8091//5860 8092//5863 +f 8087//5882 8072//5864 8086//5865 +f 8066//5843 8081//5862 8082//5866 +f 8072//5864 8087//5882 8088//5867 +f 8067//5848 8082//5866 8083//5868 +f 8089//5871 8074//5849 8088//5867 +f 8084//5858 8069//5854 8083//5868 +f 8063//5869 8078//5874 8079//5870 +f 8104//5888 8089//5871 8103//5872 +f 8083//5868 8098//5885 8099//5873 +f 8078//5874 8093//5891 8094//5875 +f 8089//5871 8104//5888 8105//5876 +f 8100//5879 8085//5861 8099//5873 +f 8079//5870 8094//5875 8095//5877 +f 8090//5857 8105//5876 8106//5878 +f 8101//5897 8086//5865 8100//5879 +f 8080//5859 8095//5877 8096//5880 +f 8091//5860 8106//5878 8107//5881 +f 8086//5865 8101//5897 8102//5883 +f 8081//5862 8096//5880 8097//5884 +f 8087//5882 8102//5883 8103//5872 +f 8082//5866 8097//5884 8098//5885 +f 8096//5880 8111//5899 8112//5886 +f 8102//5883 8117//5901 8118//5887 +f 8113//5908 8098//5885 8112//5886 +f 8103//5872 8118//5887 8119//5889 +f 8098//5885 8113//5908 8114//5890 +f 8093//5891 8108//5911 8109//5892 +f 8104//5888 8119//5889 8120//5893 +f 8099//5873 8114//5890 8115//5894 +f 8094//5875 8109//5892 8110//5895 +f 8105//5876 8120//5893 8121//5896 +f 8100//5879 8115//5894 8116//5898 +f 8095//5877 8110//5895 8111//5899 +f 8106//5878 8121//5896 8122//5900 +f 8101//5897 8116//5898 8117//5901 +f 8115//5894 8130//5913 8131//5902 +f 8110//5895 8125//5914 8126//5903 +f 8121//5896 8136//5915 8137//5904 +f 8116//5898 8131//5902 8132//5905 +f 8111//5899 8126//5903 8127//5906 +f 8117//5901 8132//5905 8133//5907 +f 8128//5925 8113//5908 8127//5906 +f 8118//5887 8133//5907 8134//5909 +f 8113//5908 8128//5925 8129//5910 +f 8108//5911 8123//5928 8124//5912 +f 8135//5916 8120//5893 8134//5909 +f 8114//5890 8129//5910 8130//5913 +f 8109//5892 8124//5912 8125//5914 +f 8120//5893 8135//5916 8136//5915 +f 8134//5909 8149//5927 8150//5917 +f 8145//5920 8130//5913 8144//5918 +f 8124//5912 8139//5929 8140//5919 +f 8151//5937 8136//5915 8150//5917 +f 8146//5923 8131//5902 8145//5920 +f 8125//5914 8140//5919 8141//5921 +f 8136//5915 8151//5937 8152//5922 +f 8147//5942 8132//5905 8146//5923 +f 8142//5944 8127//5906 8141//5921 +f 8132//5905 8147//5942 8148//5924 +f 8127//5906 8142//5944 8143//5926 +f 8133//5907 8148//5924 8149//5927 +f 8144//5918 8129//5910 8143//5926 +f 8123//5928 8138//5932 8139//5929 +f 8148//5924 8163//5946 8164//5930 +f 8159//5935 8144//5918 8158//5931 +f 8138//5932 8153//5952 8154//5933 +f 8149//5927 8164//5930 8165//5934 +f 8160//5939 8145//5920 8159//5935 +f 8139//5929 8154//5933 8155//5936 +f 8150//5917 8165//5934 8166//5938 +f 8161//5943 8146//5923 8160//5939 +f 8140//5919 8155//5936 8156//5940 +f 8151//5937 8166//5938 8167//5941 +f 8162//5945 8147//5942 8161//5943 +f 8157//5948 8142//5944 8156//5940 +f 8163//5946 8148//5924 8162//5945 +f 8142//5944 8157//5948 8158//5931 +f 8178//5950 8163//5946 8177//5947 +f 8157//5948 8172//5964 8173//5949 +f 8179//5954 8164//5930 8178//5950 +f 8158//5931 8173//5949 8174//5951 +f 8153//5952 8168//5969 8169//5953 +f 8180//5971 8165//5934 8179//5954 +f 8175//5957 8160//5939 8174//5951 +f 8154//5933 8169//5953 8170//5955 +f 8165//5934 8180//5971 8181//5956 +f 8176//5960 8161//5943 8175//5957 +f 8155//5936 8170//5955 8171//5958 +f 8166//5938 8181//5956 8182//5959 +f 8177//5947 8162//5945 8176//5960 +f 8172//5964 8157//5948 8171//5958 +f 8170//5955 8185//5974 8186//5961 +f 8181//5956 8196//5975 8197//5962 +f 8192//5965 8177//5947 8191//5963 +f 8187//5966 8172//5964 8186//5961 +f 8193//5967 8178//5950 8192//5965 +f 8188//5968 8173//5949 8187//5966 +f 8194//5972 8179//5954 8193//5967 +f 8189//5973 8174//5951 8188//5968 +f 8168//5969 8183//5989 8184//5970 +f 8195//5979 8180//5971 8194//5972 +f 8190//5976 8175//5957 8189//5973 +f 8169//5953 8184//5970 8185//5974 +f 8180//5971 8195//5979 8196//5975 +f 8191//5963 8176//5960 8190//5976 +f 8205//5981 8190//5976 8204//5977 +f 8184//5970 8199//5990 8200//5978 +f 8211//5999 8196//5975 8210//5980 +f 8206//5984 8191//5963 8205//5981 +f 8185//5974 8200//5978 8201//5982 +f 8196//5975 8211//5999 8212//5983 +f 8207//5986 8192//5965 8206//5984 +f 8186//5961 8201//5982 8202//5985 +f 8208//5987 8193//5967 8207//5986 +f 8203//5988 8188//5968 8202//5985 +f 8209//5991 8194//5972 8208//5987 +f 8204//5977 8189//5973 8203//5988 +f 8183//5989 8198//5994 8199//5990 +f 8210//5980 8195//5979 8209//5991 +f 8224//5996 8209//5991 8223//5992 +f 8219//5997 8204//5977 8218//5993 +f 8198//5994 8213//6011 8214//5995 +f 8225//6013 8210//5980 8224//5996 +f 8220//6001 8205//5981 8219//5997 +f 8199//5990 8214//5995 8215//5998 +f 8210//5980 8225//6013 8226//6000 +f 8221//6004 8206//5984 8220//6001 +f 8200//5978 8215//5998 8216//6002 +f 8211//5999 8226//6000 8227//6003 +f 8222//6006 8207//5986 8221//6004 +f 8201//5982 8216//6002 8217//6005 +f 8223//5992 8208//5987 8222//6006 +f 8218//5993 8203//5988 8217//6005 +f 8238//6009 8223//5992 8237//6007 +f 8233//6010 8218//5993 8232//6008 +f 8239//6028 8224//5996 8238//6009 +f 8234//6015 8219//5997 8233//6010 +f 8213//6011 8228//6030 8229//6012 +f 8224//5996 8239//6028 8240//6014 +f 8235//6017 8220//6001 8234//6015 +f 8214//5995 8229//6012 8230//6016 +f 8241//6019 8226//6000 8240//6014 +f 8236//6020 8221//6004 8235//6017 +f 8215//5998 8230//6016 8231//6018 +f 8242//6022 8227//6003 8241//6019 +f 8237//6007 8222//6006 8236//6020 +f 8216//6002 8231//6018 8232//6008 +f 8230//6016 8245//6034 8246//6021 +f 8241//6019 8256//6038 8257//6023 +f 8252//6026 8237//6007 8251//6024 +f 8231//6018 8246//6021 8247//6025 +f 8253//6045 8238//6009 8252//6026 +f 8232//6008 8247//6025 8248//6027 +f 8238//6009 8253//6045 8254//6029 +f 8249//6033 8234//6015 8248//6027 +f 8228//6030 8243//6049 8244//6031 +f 8239//6028 8254//6029 8255//6032 +f 8250//6035 8235//6017 8249//6033 +f 8229//6012 8244//6031 8245//6034 +f 8256//6038 8241//6019 8255//6032 +f 8251//6024 8236//6020 8250//6035 +f 8265//6040 8250//6035 8264//6036 +f 8260//6041 8245//6034 8259//6037 +f 8271//6058 8256//6038 8270//6039 +f 8266//6043 8251//6024 8265//6040 +f 8261//6044 8246//6021 8260//6041 +f 8256//6038 8271//6058 8272//6042 +f 8267//6046 8252//6026 8266//6043 +f 8262//6063 8247//6025 8261//6044 +f 8268//6051 8253//6045 8267//6046 +f 8247//6025 8262//6063 8263//6047 +f 8253//6045 8268//6051 8269//6048 +f 8264//6036 8249//6033 8263//6047 +f 8259//6037 8244//6031 8258//6050 +f 8254//6029 8269//6048 8270//6039 +f 8284//6069 8269//6048 8283//6052 +f 8279//6056 8264//6036 8278//6053 +f 8274//6057 8259//6037 8273//6054 +f 8269//6048 8284//6069 8285//6055 +f 8280//6059 8265//6040 8279//6056 +f 8275//6060 8260//6041 8274//6057 +f 8286//6074 8271//6058 8285//6055 +f 8281//6062 8266//6043 8280//6059 +f 8276//6064 8261//6044 8275//6060 +f 8271//6058 8286//6074 8287//6061 +f 8282//6065 8267//6046 8281//6062 +f 8277//6067 8262//6063 8276//6064 +f 8283//6052 8268//6051 8282//6065 +f 8262//6063 8277//6067 8278//6053 +f 8282//6065 8297//6079 8298//6066 +f 8277//6067 8292//6080 8293//6068 +f 8299//6071 8284//6069 8298//6066 +f 8294//6072 8279//6056 8293//6068 +f 8289//6073 8274//6057 8288//6070 +f 8300//6075 8285//6055 8299//6071 +f 8295//6091 8280//6059 8294//6072 +f 8290//6077 8275//6060 8289//6073 +f 8301//6081 8286//6074 8300//6075 +f 8280//6059 8295//6091 8296//6076 +f 8291//6084 8276//6064 8290//6077 +f 8286//6074 8301//6081 8302//6078 +f 8281//6062 8296//6076 8297//6079 +f 8276//6064 8291//6084 8292//6080 +f 8301//6081 8317//6094 8318//6082 +f 8296//6076 8312//6095 8313//6083 +f 8308//6103 8292//6080 8307//6085 +f 8297//6079 8313//6083 8314//6086 +f 8292//6080 8308//6103 8309//6087 +f 8298//6066 8314//6086 8315//6088 +f 8310//6107 8294//6072 8309//6087 +f 8305//6093 8289//6073 8304//6089 +f 8299//6071 8315//6088 8316//6090 +f 8294//6072 8310//6107 8311//6092 +f 8306//6096 8290//6077 8305//6093 +f 8300//6075 8316//6090 8317//6094 +f 8295//6091 8311//6092 8312//6095 +f 8307//6085 8291//6084 8306//6096 +f 8321//6100 8306//6096 8320//6097 +f 8332//6117 8317//6094 8331//6098 +f 8311//6092 8326//6110 8327//6099 +f 8322//6120 8307//6085 8321//6100 +f 8317//6094 8332//6117 8333//6101 +f 8312//6095 8327//6099 8328//6102 +f 8307//6085 8322//6120 8323//6104 +f 8313//6083 8328//6102 8329//6105 +f 8324//6108 8309//6087 8323//6104 +f 8314//6086 8329//6105 8330//6106 +f 8325//6111 8310//6107 8324//6108 +f 8320//6097 8305//6093 8319//6109 +f 8315//6088 8330//6106 8331//6098 +f 8310//6107 8325//6111 8326//6110 +f 8340//6115 8325//6111 8339//6112 +f 8335//6116 8320//6097 8334//6113 +f 8346//6118 8331//6098 8345//6114 +f 8341//6133 8326//6110 8340//6115 +f 8336//6121 8321//6100 8335//6116 +f 8347//6136 8332//6117 8346//6118 +f 8326//6110 8341//6133 8342//6119 +f 8337//6124 8322//6120 8336//6121 +f 8332//6117 8347//6136 8348//6122 +f 8327//6099 8342//6119 8343//6123 +f 8338//6127 8323//6104 8337//6124 +f 8328//6102 8343//6123 8344//6125 +f 8323//6104 8338//6127 8339//6112 +f 8329//6105 8344//6125 8345//6114 +f 8343//6123 8358//6140 8359//6126 +f 8354//6130 8339//6112 8353//6128 +f 8344//6125 8359//6126 8360//6129 +f 8355//6148 8340//6115 8354//6130 +f 8350//6135 8335//6116 8349//6131 +f 8345//6114 8360//6129 8361//6132 +f 8340//6115 8355//6148 8356//6134 +f 8351//6138 8336//6121 8350//6135 +f 8362//6141 8347//6136 8361//6132 +f 8341//6133 8356//6134 8357//6137 +f 8352//6144 8337//6124 8351//6138 +f 8347//6136 8362//6141 8363//6139 +f 8342//6119 8357//6137 8358//6140 +f 8337//6124 8352//6144 8353//6128 +f 8362//6141 8377//6153 8378//6142 +f 8357//6137 8372//6154 8373//6143 +f 8352//6144 8367//6160 8368//6145 +f 8358//6140 8373//6143 8374//6146 +f 8369//6149 8354//6130 8368//6145 +f 8359//6126 8374//6146 8375//6147 +f 8370//6168 8355//6148 8369//6149 +f 8365//6152 8350//6135 8364//6150 +f 8376//6157 8361//6132 8375//6147 +f 8355//6148 8370//6168 8371//6151 +f 8366//6155 8351//6138 8365//6152 +f 8361//6132 8376//6157 8377//6153 +f 8356//6134 8371//6151 8372//6154 +f 8367//6160 8352//6144 8366//6155 +f 8381//6161 8366//6155 8380//6156 +f 8376//6157 8391//6174 8392//6158 +f 8371//6151 8386//6170 8387//6159 +f 8382//6180 8367//6160 8381//6161 +f 8377//6153 8392//6158 8393//6162 +f 8372//6154 8387//6159 8388//6163 +f 8367//6160 8382//6180 8383//6164 +f 8373//6143 8388//6163 8389//6165 +f 8368//6145 8383//6164 8384//6166 +f 8374//6146 8389//6165 8390//6167 +f 8385//6171 8370//6168 8384//6166 +f 8380//6156 8365//6152 8379//6169 +f 8391//6174 8376//6157 8390//6167 +f 8370//6168 8385//6171 8386//6170 +f 8384//6166 8399//6186 8400//6172 +f 8395//6177 8380//6156 8394//6173 +f 8390//6167 8405//6187 8406//6175 +f 8385//6171 8400//6172 8401//6176 +f 8396//6181 8381//6161 8395//6177 +f 8391//6174 8406//6175 8407//6178 +f 8386//6170 8401//6176 8402//6179 +f 8397//6184 8382//6180 8396//6181 +f 8392//6158 8407//6178 8408//6182 +f 8387//6159 8402//6179 8403//6183 +f 8398//6189 8383//6164 8397//6184 +f 8388//6163 8403//6183 8404//6185 +f 8383//6164 8398//6189 8399//6186 +f 8389//6165 8404//6185 8405//6187 +f 8403//6183 8418//6201 8419//6188 +f 8398//6189 8413//6202 8414//6190 +f 8404//6185 8419//6188 8420//6191 +f 8399//6186 8414//6190 8415//6192 +f 8410//6196 8395//6177 8409//6193 +f 8405//6187 8420//6191 8421//6194 +f 8400//6172 8415//6192 8416//6195 +f 8411//6199 8396//6181 8410//6196 +f 8406//6175 8421//6194 8422//6197 +f 8401//6176 8416//6195 8417//6198 +f 8412//6205 8397//6184 8411//6199 +f 8407//6178 8422//6197 8423//6200 +f 8402//6179 8417//6198 8418//6201 +f 8397//6184 8412//6205 8413//6202 +f 8422//6197 8438//6215 8439//6203 +f 8417//6198 8433//6216 8434//6204 +f 8412//6205 8428//6220 8429//6206 +f 8418//6201 8434//6204 8435//6207 +f 8413//6202 8429//6206 8430//6208 +f 8419//6188 8435//6207 8436//6209 +f 8414//6190 8430//6208 8431//6210 +f 8426//6214 8410//6196 8425//6211 +f 8420//6191 8436//6209 8437//6212 +f 8415//6192 8431//6210 8432//6213 +f 8427//6217 8411//6199 8426//6214 +f 8421//6194 8437//6212 8438//6215 +f 8416//6195 8432//6213 8433//6216 +f 8428//6220 8412//6205 8427//6217 +f 8437//6212 8452//6227 8453//6218 +f 8432//6213 8447//6228 8448//6219 +f 8443//6235 8428//6220 8442//6221 +f 8454//6232 8439//6203 8453//6218 +f 8433//6216 8448//6219 8449//6222 +f 8428//6220 8443//6235 8444//6223 +f 8450//6225 8435//6207 8449//6222 +f 8429//6206 8444//6223 8445//6224 +f 8451//6233 8436//6209 8450//6225 +f 8446//6234 8431//6210 8445//6224 +f 8441//6229 8426//6214 8440//6226 +f 8436//6209 8451//6233 8452//6227 +f 8431//6210 8446//6234 8447//6228 +f 8442//6221 8427//6217 8441//6229 +f 7974//5774 8441//6229 7973//5775 +f 7985//5777 8452//6227 7984//5770 +f 7980//5755 8447//6228 7979//5772 +f 7975//5758 8442//6221 7974//5774 +f 7986//5761 8453//6218 7985//5777 +f 8447//6228 7980//5755 7981//5754 +f 7976//5757 8443//6235 7975//5758 +f 7987//5760 8454//6232 7986//5761 +f 7982//5763 8449//6222 7981//5754 +f 8443//6235 7976//5757 7977//5764 +f 7983//5766 8450//6225 7982//5763 +f 8444//6223 7977//5764 7978//5768 +f 7984//5770 8451//6233 7983//5766 +f 7979//5772 8446//6234 7978//5768 diff --git a/examples/gopher/wavefront.go b/examples/gopher/wavefront.go new file mode 100644 index 00000000..964f8b83 --- /dev/null +++ b/examples/gopher/wavefront.go @@ -0,0 +1,280 @@ +package main + +import ( + "bufio" + "fmt" + "os" + "path/filepath" + "strconv" + "strings" +) + +type Object struct { + Name string + Groups []*Group +} + +type Group struct { + Vertexes []float32 + Normals []float32 + Material *Material +} + +type Material struct { + Name string + Ambient []float32 + Diffuse []float32 + Specular []float32 + Shininess float32 +} + +func Read(filename string) (map[string]*Object, error) { + file, err := os.Open(filename) + if err != nil { + return nil, err + } + defer file.Close() + + var materials map[string]*Material + var objects = make(map[string]*Object) + var object *Object + var group *Group + var vertex []float32 + var normal []float32 + + lno := 0 + line := "" + scanner := bufio.NewScanner(file) + + fail := func(msg string) error { + return fmt.Errorf(msg+" at %s:%d: %s", filename, lno, line) + } + + for scanner.Scan() { + lno++ + line = scanner.Text() + if strings.HasPrefix(line, "#") { + continue + } + + fields := strings.Fields(line) + if len(fields) == 0 { + continue + } + + if fields[0] == "mtllib" { + if len(fields) != 2 { + return nil, fail("unsupported materials library line") + } + materials, err = readMaterials(filepath.Join(filepath.Dir(filename), fields[1])) + if err != nil { + return nil, err + } + continue + } + + if fields[0] == "o" { + if len(fields) != 2 { + return nil, fail("unsupported object line") + } + object = &Object{Name: fields[1]} + objects[object.Name] = object + group = nil + continue + } + + if object == nil { + return nil, fail("found data before object") + } + + if fields[0] == "usemtl" { + group = &Group{} + object.Groups = append(object.Groups, group) + } + + switch fields[0] { + case "usemtl": + if len(fields) != 2 { + return nil, fail("unsupported material usage line") + } + group.Material = materials[fields[1]] + if group.Material == nil { + return nil, fmt.Errorf("material %q not defined", fields[1]) + } + case "v": + if len(fields) != 4 { + return nil, fail("unsupported vertex line") + } + for i := 0; i < 3; i++ { + f, err := strconv.ParseFloat(fields[i+1], 32) + if err != nil { + return nil, fail("cannot parse float") + } + vertex = append(vertex, float32(f)) + } + case "vn": + if len(fields) != 4 { + return nil, fail("unsupported vertex normal line") + } + for i := 0; i < 3; i++ { + f, err := strconv.ParseFloat(fields[i+1], 32) + if err != nil { + return nil, fail("cannot parse float") + } + normal = append(normal, float32(f)) + } + case "f": + if len(fields) != 4 { + return nil, fail("unsupported face line") + } + for i := 0; i < 3; i++ { + face := strings.Split(fields[i+1], "/") + if len(face) != 3 { + return nil, fail("unsupported face shape (not a triangle)") + } + vi, err := strconv.Atoi(face[0]) + if err != nil { + return nil, fail("unsupported face vertex index") + } + ni, err := strconv.Atoi(face[2]) + if err != nil { + return nil, fail("unsupported face normal index") + } + vi = (vi - 1) * 3 + ni = (ni - 1) * 3 + group.Vertexes = append(group.Vertexes, vertex[vi], vertex[vi+1], vertex[vi+2]) + group.Normals = append(group.Normals, normal[ni], normal[ni+1], normal[ni+2]) + } + } + } + if err := scanner.Err(); err != nil { + return nil, err + } + return objects, nil +} + +func readMaterials(filename string) (map[string]*Material, error) { + file, err := os.Open(filename) + if err != nil { + return nil, fmt.Errorf("cannot read referenced material library: %v", err) + } + defer file.Close() + + var materials = make(map[string]*Material) + var material *Material + + lno := 0 + line := "" + scanner := bufio.NewScanner(file) + + fail := func(msg string) error { + return fmt.Errorf(msg+" at %s:%d: %s", filename, lno, line) + } + + for scanner.Scan() { + lno++ + line = scanner.Text() + if strings.HasPrefix(line, "#") { + continue + } + + fields := strings.Fields(line) + if len(fields) == 0 { + continue + } + + if fields[0] == "newmtl" { + if len(fields) != 2 { + return nil, fail("unsupported material definition") + } + material = &Material{Name: fields[1]} + material.Ambient = []float32{0.2, 0.2, 0.2, 1.0} + material.Diffuse = []float32{0.8, 0.8, 0.8, 1.0} + material.Specular = []float32{0.0, 0.0, 0.0, 1.0} + materials[material.Name] = material + continue + } + + if material == nil { + return nil, fail("found data before material") + } + + switch fields[0] { + case "Ka": + if len(fields) != 4 { + return nil, fail("unsupported ambient color line") + } + for i := 0; i < 3; i++ { + f, err := strconv.ParseFloat(fields[i+1], 32) + if err != nil { + return nil, fail("cannot parse float") + } + material.Ambient[i] = float32(f) + } + case "Kd": + if len(fields) != 4 { + return nil, fail("unsupported diffuse color line") + } + for i := 0; i < 3; i++ { + f, err := strconv.ParseFloat(fields[i+1], 32) + if err != nil { + return nil, fail("cannot parse float") + } + material.Diffuse[i] = float32(f) + } + case "Ks": + if len(fields) != 4 { + return nil, fail("unsupported specular color line") + } + for i := 0; i < 3; i++ { + f, err := strconv.ParseFloat(fields[i+1], 32) + if err != nil { + return nil, fail("cannot parse float") + } + material.Specular[i] = float32(f) + } + case "Ns": + if len(fields) != 2 { + return nil, fail("unsupported shininess line") + } + f, err := strconv.ParseFloat(fields[1], 32) + if err != nil { + return nil, fail("cannot parse float") + } + material.Shininess = float32(f / 1000 * 128) + case "d": + if len(fields) != 2 { + return nil, fail("unsupported transparency line") + } + f, err := strconv.ParseFloat(fields[1], 32) + if err != nil { + return nil, fail("cannot parse float") + } + material.Ambient[3] = float32(f) + material.Diffuse[3] = float32(f) + material.Specular[3] = float32(f) + } + } + if err := scanner.Err(); err != nil { + return nil, err + } + + // Exporting from blender seems to show everything too dark in + // practice, so hack colors to look closer to what we see there. + // TODO This needs more real world checking. + for _, material := range materials { + if material.Ambient[0] == 0 && material.Ambient[1] == 0 && material.Ambient[2] == 0 && material.Ambient[3] == 1 { + material.Ambient[0] = material.Diffuse[0] * 0.7 + material.Ambient[1] = material.Diffuse[1] * 0.7 + material.Ambient[2] = material.Diffuse[2] * 0.7 + } + for i := 0; i < 3; i++ { + material.Diffuse[i] *= 1.3 + if material.Diffuse[i] > 1 { + material.Diffuse[i] = 1 + } + } + } + + return materials, nil +} diff --git a/examples/govalue/README.md b/examples/govalue/README.md new file mode 100644 index 00000000..6edf83f4 --- /dev/null +++ b/examples/govalue/README.md @@ -0,0 +1,38 @@ +# Reproducer for go1.6 port problem + +SjB's go 1.6 port worked very well for me for pretty much all of my programs, but +I did discover one corner case that causes problems. The TL;DR is that passing a +go type to qml and back to go does not work. + +## What I expect: + +Basically the old behaviour. After cloning this repo, try this: + +``` +GODEBUG=cgocheck=0 go run main.go +``` + +You should see it print, "Successfully called UseGoType()" and display a white rectangle. + +## It doesn't quite work so well with the fix + +If we use the 1.6 port (I have copied commit 0309d2df1d6572e107b2bd0712da5b517c4a49be here +for your convenience) then it doesn't work quite like it used to: + +``` +mv vendor_cjb vendor +go run main.go +``` + +You should see something like: + +``` +panic: cannot find fold go reference + +goroutine 1 [running, locked to thread]: +panic(0x5716e0, 0xc820090070) + /usr/local/go/src/runtime/panic.go:464 +0x3e6 +.../vendor/gopkg.in/qml%2ev1.getFoldFromGoRef(0x7ffc3a3bc044, 0x8aec00) +.../vendor/gopkg.in/qml.v1/bridge.go:230 +0x9e +... cut ... +``` diff --git a/examples/govalue/main.go b/examples/govalue/main.go new file mode 100644 index 00000000..1315dc73 --- /dev/null +++ b/examples/govalue/main.go @@ -0,0 +1,38 @@ +package main + +import ( + "fmt" + + "gopkg.in/qml.v1" +) + +func main() { + err := qml.Run(run) + if err != nil { + panic(err) + } +} + +type GoStruct struct { +} + +func (gs *GoStruct) ReturnGoType() *GoStruct { + return gs +} +func (gs *GoStruct) UseGoType(v *GoStruct) { + fmt.Println("Successfully called UseGoType()") +} + +func run() error { + engine := qml.NewEngine() + context := engine.Context() + context.SetVar("gostruct", &GoStruct{}) + component, err := engine.LoadFile("main.qml") + if err != nil { + return err + } + win := component.CreateWindow(nil) + win.Show() + win.Wait() + return nil +} diff --git a/examples/govalue/main.qml b/examples/govalue/main.qml new file mode 100644 index 00000000..e2a26cb9 --- /dev/null +++ b/examples/govalue/main.qml @@ -0,0 +1,9 @@ +import QtQuick 2.0 +Rectangle { + width:600 + height:600 + Component.onCompleted: { + var gt = gostruct.returnGoType() + gt.useGoType(gt) + } +} diff --git a/examples/imgprovider/imgprovider.go b/examples/imgprovider/imgprovider.go new file mode 100644 index 00000000..533a23b8 --- /dev/null +++ b/examples/imgprovider/imgprovider.go @@ -0,0 +1,43 @@ +package main + +import ( + "fmt" + "gopkg.in/qml.v1" + "image" + "image/png" + "os" +) + +func main() { + if err := qml.Run(run); err != nil { + fmt.Fprintf(os.Stderr, "error: %v\n", err) + os.Exit(1) + } +} + +func run() error { + engine := qml.NewEngine() + engine.AddImageProvider("pwd", func(id string, width, height int) image.Image { + f, err := os.Open(id) + if err != nil { + panic(err) + } + defer f.Close() + image, err := png.Decode(f) + if err != nil { + panic(err) + } + return image + }) + + component, err := engine.LoadFile("imgprovider.qml") + if err != nil { + return err + } + + win := component.CreateWindow(nil) + win.Show() + win.Wait() + + return nil +} diff --git a/examples/imgprovider/imgprovider.qml b/examples/imgprovider/imgprovider.qml new file mode 100644 index 00000000..0c5c747f --- /dev/null +++ b/examples/imgprovider/imgprovider.qml @@ -0,0 +1,5 @@ +import QtQuick 2.0 + +Image { + source: "image://pwd/ubuntu-gopher.png" +} diff --git a/examples/imgprovider/ubuntu-gopher.png b/examples/imgprovider/ubuntu-gopher.png new file mode 100644 index 00000000..3f51d379 Binary files /dev/null and b/examples/imgprovider/ubuntu-gopher.png differ diff --git a/examples/modelview/delegate/delegate.go b/examples/modelview/delegate/delegate.go new file mode 100644 index 00000000..440fd229 --- /dev/null +++ b/examples/modelview/delegate/delegate.go @@ -0,0 +1,53 @@ +package main + +import ( + "fmt" + "gopkg.in/qml.v1" + "image/color" + "math/rand" + "os" + "time" +) + +func main() { + if err := qml.Run(run); err != nil { + fmt.Fprintf(os.Stderr, "error: %v\n", err) + os.Exit(1) + } +} + +func run() error { + engine := qml.NewEngine() + colors := &Colors{} + engine.Context().SetVar("colors", colors) + component, err := engine.LoadFile("delegate.qml") + if err != nil { + return err + } + window := component.CreateWindow(nil) + window.Show() + go func() { + n := func() uint8 { return uint8(rand.Intn(256)) } + for i := 0; i < 100; i++ { + colors.Add(color.RGBA{n(), n(), n(), 0xff}) + time.Sleep(1 * time.Second) + } + }() + window.Wait() + return nil +} + +type Colors struct { + list []color.RGBA + Len int +} + +func (colors *Colors) Add(c color.RGBA) { + colors.list = append(colors.list, c) + colors.Len = len(colors.list) + qml.Changed(colors, &colors.Len) +} + +func (colors *Colors) Color(index int) color.RGBA { + return colors.list[index] +} diff --git a/examples/modelview/delegate/delegate.qml b/examples/modelview/delegate/delegate.qml new file mode 100644 index 00000000..4b37d31f --- /dev/null +++ b/examples/modelview/delegate/delegate.qml @@ -0,0 +1,17 @@ +import QtQuick 2.0 + +Item { + width: 320; height: 200 + + ListView { + width: 120; + model: colors.len + delegate: Text { + text: "I am color number: " + index + color: colors.color(index) + } + anchors.top: parent.top + anchors.bottom: parent.bottom + anchors.horizontalCenter: parent.horizontalCenter + } +} diff --git a/examples/mousearea/mousearea b/examples/mousearea/mousearea new file mode 100755 index 00000000..9a339388 Binary files /dev/null and b/examples/mousearea/mousearea differ diff --git a/examples/mousearea/mousearea.go b/examples/mousearea/mousearea.go new file mode 100644 index 00000000..a07282e5 --- /dev/null +++ b/examples/mousearea/mousearea.go @@ -0,0 +1,52 @@ +package main + +import ( + "fmt" + "os" + + "github.com/SjB/qml" +) + +const test_qml = ` +import QtQuick 2.2 +import QtQuick.Controls 1.1 + +ApplicationWindow { + width: 640 + height: 280 + + MouseArea { + objectName: "mouseArea" + hoverEnabled: true + + anchors.fill: parent + } +} +` + +func main() { + if err := qml.Run(run); err != nil { + fmt.Fprintf(os.Stderr, "error: %v\n", err) + os.Exit(1) + } +} + +func run() error { + engine := qml.NewEngine() + component, err := engine.LoadString("test.qml", test_qml) + if err != nil { + return err + } + + win := component.CreateWindow(nil) + + mouseArea := win.Root().ObjectByName("mouseArea") + mouseArea.On("positionChanged", func(mouseEvent qml.Object) { + fmt.Printf("X %d Y %d\n", mouseEvent.Int("x"), mouseEvent.Int("y")) + }) + + win.Show() + win.Wait() + + return nil +} diff --git a/examples/painting-es2/painting.go b/examples/painting-es2/painting.go new file mode 100644 index 00000000..71f2d89a --- /dev/null +++ b/examples/painting-es2/painting.go @@ -0,0 +1,115 @@ +package main + +import ( + "fmt" + "os" + + "gopkg.in/qml.v1" + "gopkg.in/qml.v1/gl/es2" +) + +func main() { + if err := qml.Run(run); err != nil { + fmt.Fprintf(os.Stderr, "error: %v\n", err) + os.Exit(1) + } +} + +func run() error { + qml.RegisterTypes("GoExtensions", 1, 0, []qml.TypeSpec{{ + Init: func(r *GoRect, obj qml.Object) { r.Object = obj }, + }}) + + engine := qml.NewEngine() + component, err := engine.LoadFile("painting.qml") + if err != nil { + return err + } + + win := component.CreateWindow(nil) + win.Show() + win.Wait() + return nil +} + +type GoRect struct { + qml.Object +} + +var vertexShader = ` +#version 120 + +attribute vec2 position; + +void main() +{ + gl_Position = vec4(position.x, position.y, 0.0, 1.0); +} +` + +var fragmentShader = ` +#version 120 + +void main() +{ + gl_FragColor = vec4(1.0, 1.0, 1.0, 0.8); +} +` + +func (r *GoRect) Paint(p *qml.Painter) { + gl := GL.API(p) + + vertices := []float32{ + -1, -1, + +1, -1, + +1, +1, + -1, +1, + } + + indices := []uint8{ + 0, 1, 2, // first triangle + 2, 3, 0, // second triangle + } + + buf := gl.GenBuffers(2) + gl.BindBuffer(GL.ARRAY_BUFFER, buf[0]) + gl.BufferData(GL.ARRAY_BUFFER, 0, vertices, GL.STATIC_DRAW) + gl.BindBuffer(GL.ELEMENT_ARRAY_BUFFER, buf[1]) + gl.BufferData(GL.ELEMENT_ARRAY_BUFFER, 0, indices, GL.STATIC_DRAW) + + vshader := gl.CreateShader(GL.VERTEX_SHADER); + gl.ShaderSource(vshader, vertexShader) + gl.CompileShader(vshader) + + var status [1]int32 + gl.GetShaderiv(vshader, GL.COMPILE_STATUS, status[:]) + if status[0] == 0 { + log := gl.GetShaderInfoLog(vshader) + panic("vertex shader compilation failed: " + string(log)) + } + + fshader := gl.CreateShader(GL.FRAGMENT_SHADER) + gl.ShaderSource(fshader, fragmentShader) + gl.CompileShader(fshader) + + gl.GetShaderiv(fshader, GL.COMPILE_STATUS, status[:]) + if status[0] == 0 { + log := gl.GetShaderInfoLog(fshader) + panic("fragment shader compilation failed: " + string(log)) + } + + program := gl.CreateProgram() + gl.AttachShader(program, vshader) + gl.AttachShader(program, fshader) + gl.LinkProgram(program) + gl.UseProgram(program) + + position := gl.GetAttribLocation(program, "position") + gl.VertexAttribPointer(position, 2, GL.FLOAT, false, 0, 0) + gl.EnableVertexAttribArray(position) + + gl.Enable(GL.BLEND) + gl.BlendFunc(GL.SRC_ALPHA, GL.ONE_MINUS_SRC_ALPHA) + + gl.DrawElements(GL.TRIANGLES, 6, GL.UNSIGNED_BYTE, nil) +} diff --git a/examples/painting-es2/painting.qml b/examples/painting-es2/painting.qml new file mode 100644 index 00000000..8c59fc35 --- /dev/null +++ b/examples/painting-es2/painting.qml @@ -0,0 +1,66 @@ +import QtQuick 2.0 +import GoExtensions 1.0 + +Rectangle { + id: root + + width: 640 + height: 280 + color: "black" + + Rectangle { + x: 20; y: 20; width: 100; height: 100 + color: "red" + + SequentialAnimation on x { + loops: Animation.Infinite + NumberAnimation { from: 20; to: 120; duration: 4000; easing.type: Easing.InOutQuad } + NumberAnimation { from: 120; to: 20; duration: 4000; easing.type: Easing.InOutQuad } + } + } + + Rectangle { + x: 40; y: 40; width: 100; height: 100 + color: "yellow" + opacity: 0.7 + + SequentialAnimation on x { + loops: Animation.Infinite + NumberAnimation { from: 40; to: 220; duration: 4000; easing.type: Easing.InOutQuad } + NumberAnimation { from: 220; to: 40; duration: 4000; easing.type: Easing.InOutQuad } + } + } + + GoRect { + x: 60; y: 60; width: 100; height: 100 + + SequentialAnimation on x { + loops: Animation.Infinite + NumberAnimation { from: 60; to: 320; duration: 4000; easing.type: Easing.InOutQuad } + NumberAnimation { from: 320; to: 60; duration: 4000; easing.type: Easing.InOutQuad } + } + } + + Rectangle { + x: 80; y: 80; width: 100; height: 100 + color: "yellow" + opacity: 0.7 + + SequentialAnimation on x { + loops: Animation.Infinite + NumberAnimation { from: 80; to: 420; duration: 4000; easing.type: Easing.InOutQuad } + NumberAnimation { from: 420; to: 80; duration: 4000; easing.type: Easing.InOutQuad } + } + } + + Rectangle { + x: 100; y: 100; width: 100; height: 100 + color: "red" + + SequentialAnimation on x { + loops: Animation.Infinite + NumberAnimation { from: 100; to: 520; duration: 4000; easing.type: Easing.InOutQuad } + NumberAnimation { from: 520; to: 100; duration: 4000; easing.type: Easing.InOutQuad } + } + } +} diff --git a/examples/painting/painting b/examples/painting/painting new file mode 100755 index 00000000..6f2eb6e8 Binary files /dev/null and b/examples/painting/painting differ diff --git a/examples/painting/painting.go b/examples/painting/painting.go new file mode 100644 index 00000000..889c1c43 --- /dev/null +++ b/examples/painting/painting.go @@ -0,0 +1,64 @@ +package main + +import ( + "fmt" + "os" + + "github.com/SjB/qml" + "github.com/SjB/qml/gl/2.0" +) + +func main() { + if err := qml.Run(run); err != nil { + fmt.Fprintf(os.Stderr, "error: %v\n", err) + os.Exit(1) + } +} + +type GoRect struct { + qml.Object +} + +func (r *GoRect) Paint(p *qml.Painter) { + gl := GL.API(p) + + width := float32(r.Int("width")) + height := float32(r.Int("height")) + + gl.Enable(GL.BLEND) + gl.BlendFunc(GL.SRC_ALPHA, GL.ONE_MINUS_SRC_ALPHA) + gl.Color4f(1.0, 1.0, 1.0, 0.8) + gl.Begin(GL.QUADS) + gl.Vertex2f(0, 0) + gl.Vertex2f(width, 0) + gl.Vertex2f(width, height) + gl.Vertex2f(0, height) + gl.End() + + gl.LineWidth(2.5) + gl.Color4f(0.0, 0.0, 0.0, 1.0) + gl.Begin(GL.LINES) + gl.Vertex2f(0, 0) + gl.Vertex2f(width, height) + gl.Vertex2f(width, 0) + gl.Vertex2f(0, height) + gl.End() +} + +func run() error { + qml.RegisterTypes("GoExtensions", 1, 0, []qml.TypeSpec{{ + Init: func(r *GoRect, obj qml.Object) { r.Object = obj }, + }}) + + engine := qml.NewEngine() + component, err := engine.LoadFile("painting.qml") + if err != nil { + return err + } + + win := component.CreateWindow(nil) + win.Show() + win.Wait() + + return nil +} diff --git a/examples/painting/painting.qml b/examples/painting/painting.qml new file mode 100644 index 00000000..8c59fc35 --- /dev/null +++ b/examples/painting/painting.qml @@ -0,0 +1,66 @@ +import QtQuick 2.0 +import GoExtensions 1.0 + +Rectangle { + id: root + + width: 640 + height: 280 + color: "black" + + Rectangle { + x: 20; y: 20; width: 100; height: 100 + color: "red" + + SequentialAnimation on x { + loops: Animation.Infinite + NumberAnimation { from: 20; to: 120; duration: 4000; easing.type: Easing.InOutQuad } + NumberAnimation { from: 120; to: 20; duration: 4000; easing.type: Easing.InOutQuad } + } + } + + Rectangle { + x: 40; y: 40; width: 100; height: 100 + color: "yellow" + opacity: 0.7 + + SequentialAnimation on x { + loops: Animation.Infinite + NumberAnimation { from: 40; to: 220; duration: 4000; easing.type: Easing.InOutQuad } + NumberAnimation { from: 220; to: 40; duration: 4000; easing.type: Easing.InOutQuad } + } + } + + GoRect { + x: 60; y: 60; width: 100; height: 100 + + SequentialAnimation on x { + loops: Animation.Infinite + NumberAnimation { from: 60; to: 320; duration: 4000; easing.type: Easing.InOutQuad } + NumberAnimation { from: 320; to: 60; duration: 4000; easing.type: Easing.InOutQuad } + } + } + + Rectangle { + x: 80; y: 80; width: 100; height: 100 + color: "yellow" + opacity: 0.7 + + SequentialAnimation on x { + loops: Animation.Infinite + NumberAnimation { from: 80; to: 420; duration: 4000; easing.type: Easing.InOutQuad } + NumberAnimation { from: 420; to: 80; duration: 4000; easing.type: Easing.InOutQuad } + } + } + + Rectangle { + x: 100; y: 100; width: 100; height: 100 + color: "red" + + SequentialAnimation on x { + loops: Animation.Infinite + NumberAnimation { from: 100; to: 520; duration: 4000; easing.type: Easing.InOutQuad } + NumberAnimation { from: 520; to: 100; duration: 4000; easing.type: Easing.InOutQuad } + } + } +} diff --git a/examples/particle/main.go b/examples/particle/main.go new file mode 100644 index 00000000..2a7ab865 --- /dev/null +++ b/examples/particle/main.go @@ -0,0 +1,84 @@ +package main + +import ( + "fmt" + "math/rand" + "os" + "time" + + "gopkg.in/qml.v1" +) + +func main() { + if err := qml.Run(run); err != nil { + fmt.Fprintf(os.Stderr, "error: %v\n", err) + os.Exit(1) + } +} + +func run() error { + engine := qml.NewEngine() + component, err := engine.LoadFile("particle.qml") + if err != nil { + return err + } + + ctrl := Control{Message: "Hello from Go!"} + + context := engine.Context() + context.SetVar("ctrl", &ctrl) + + window := component.CreateWindow(nil) + + ctrl.Root = window.Root() + + rand.Seed(time.Now().Unix()) + + window.Show() + window.Wait() + + return nil +} + +type Control struct { + Root qml.Object + Message string +} + +func (ctrl *Control) TextReleased(text qml.Object) { + x := text.Int("x") + y := text.Int("y") + width := text.Int("width") + height := text.Int("height") + + ctrl.Emit(x+15, y+height/2) + ctrl.Emit(x+width/2, 1.0*y+height/2) + ctrl.Emit(x+width-15, 1.0*y+height/2) + + go func() { + time.Sleep(500 * time.Millisecond) + messages := []string{"Hello", "Hello", "Hacks"} + ctrl.Message = messages[rand.Intn(len(messages))] + " from Go!" + qml.Changed(ctrl, &ctrl.Message) + }() +} + +func (ctrl *Control) Emit(x, y int) { + component := ctrl.Root.Object("emitterComponent") + for i := 0; i < 8; i++ { + emitter := component.Create(nil) + emitter.Set("x", x) + emitter.Set("y", y) + emitter.Set("targetX", rand.Intn(240)-120+x) + emitter.Set("targetY", rand.Intn(240)-120+y) + emitter.Set("life", rand.Intn(2400)+200) + emitter.Set("emitRate", rand.Intn(32)+32) + emitter.ObjectByName("xAnim").Call("start") + emitter.ObjectByName("yAnim").Call("start") + emitter.Set("enabled", true) + } +} + +func (ctrl *Control) Done(emitter qml.Object) { + emitter.Destroy() +} diff --git a/examples/particle/particle.png b/examples/particle/particle.png new file mode 100644 index 00000000..5c83896d Binary files /dev/null and b/examples/particle/particle.png differ diff --git a/examples/particle/particle.qml b/examples/particle/particle.qml new file mode 100644 index 00000000..1fd1f1c8 --- /dev/null +++ b/examples/particle/particle.qml @@ -0,0 +1,89 @@ +import QtQuick 2.0 +import QtQuick.Particles 2.0 +import QtGraphicalEffects 1.0; + +Rectangle { + id: root + + width: 640 + height: 480 + + gradient: Gradient { + GradientStop { position: 0.0; color: "#3a2c32"; } + GradientStop { position: 0.8; color: "#875864"; } + GradientStop { position: 1.0; color: "#9b616c"; } + } + + Text { + text: ctrl.message + + Component.onCompleted: { + x = parent.width/2 - width/2 + y = parent.height/2 - height/2 + } + + color: "white" + font.bold: true + font.pointSize: 20 + + MouseArea { + id: mouseArea + anchors.fill: parent + drag.target: parent + onReleased: ctrl.textReleased(parent) + } + } + + ParticleSystem { id: sys } + + ImageParticle { + system: sys + source: "particle.png" + color: "white" + colorVariation: 1.0 + alpha: 0.1 + } + + property var emitterComponent: Component { + id: emitterComponent + Emitter { + id: container + system: sys + Emitter { + system: sys + emitRate: 128 + lifeSpan: 600 + size: 16 + endSize: 8 + velocity: AngleDirection { angleVariation:360; magnitude: 60 } + } + + property int life: 2600 + property real targetX: 0 + property real targetY: 0 + emitRate: 128 + lifeSpan: 600 + size: 24 + endSize: 8 + NumberAnimation on x { + objectName: "xAnim" + id: xAnim; + to: targetX + duration: life + running: false + } + NumberAnimation on y { + objectName: "yAnim" + id: yAnim; + to: targetY + duration: life + running: false + } + Timer { + interval: life + running: true + onTriggered: ctrl.done(container) + } + } + } +} diff --git a/examples/qmlscene/Cell.qml b/examples/qmlscene/Cell.qml new file mode 100644 index 00000000..998a4924 --- /dev/null +++ b/examples/qmlscene/Cell.qml @@ -0,0 +1,20 @@ +import QtQuick 2.0 + +Item { + id: container + property alias cellColor: rectangle.color + signal clicked(color cellColor) + + width: 40; height: 25 + + Rectangle { + id: rectangle + border.color: "white" + anchors.fill: parent + } + + MouseArea { + anchors.fill: parent + onClicked: container.clicked(container.cellColor) + } +} diff --git a/examples/qmlscene/qmlscene.go b/examples/qmlscene/qmlscene.go new file mode 100644 index 00000000..cf485f01 --- /dev/null +++ b/examples/qmlscene/qmlscene.go @@ -0,0 +1,33 @@ +package main + +import ( + "fmt" + "github.com/SjB/qml" + "os" +) + +func main() { + if len(os.Args) != 2 { + fmt.Fprintf(os.Stderr, "usage: %s \n", os.Args[0]) + os.Exit(1) + } + if err := qml.Run(run); err != nil { + fmt.Fprintf(os.Stderr, "error: %v\n", err) + os.Exit(1) + } +} + +func run() error { + engine := qml.NewEngine() + + engine.On("quit", func() { os.Exit(0) }) + + component, err := engine.LoadFile(os.Args[1]) + if err != nil { + return err + } + window := component.CreateWindow(nil) + window.Show() + window.Wait() + return nil +} diff --git a/examples/qmlscene/tutorial1.qml b/examples/qmlscene/tutorial1.qml new file mode 100644 index 00000000..e42216e6 --- /dev/null +++ b/examples/qmlscene/tutorial1.qml @@ -0,0 +1,17 @@ +// See http://qt-project.org/doc/qt-5.1/qtquick/qml-tutorial1.html + +import QtQuick 2.0 + +Rectangle { + id: page + width: 320; height: 480 + color: "lightgray" + + Text { + id: helloText + text: "Hello world!" + y: 30 + anchors.horizontalCenter: page.horizontalCenter + font.pointSize: 24; font.bold: true + } +} diff --git a/examples/qmlscene/tutorial2.qml b/examples/qmlscene/tutorial2.qml new file mode 100644 index 00000000..aa64bc1a --- /dev/null +++ b/examples/qmlscene/tutorial2.qml @@ -0,0 +1,30 @@ +// See http://qt-project.org/doc/qt-5.1/qtquick/qml-tutorial2.html + +import QtQuick 2.0 + +Rectangle { + id: page + width: 320; height: 480 + color: "lightgray" + + Text { + id: helloText + text: "Hello world!" + y: 30 + anchors.horizontalCenter: page.horizontalCenter + font.pointSize: 24; font.bold: true + } + + Grid { + id: colorPicker + x: 4; anchors.bottom: page.bottom; anchors.bottomMargin: 4 + rows: 2; columns: 3; spacing: 3 + + Cell { cellColor: "red"; onClicked: helloText.color = cellColor } + Cell { cellColor: "green"; onClicked: helloText.color = cellColor } + Cell { cellColor: "blue"; onClicked: helloText.color = cellColor } + Cell { cellColor: "yellow"; onClicked: helloText.color = cellColor } + Cell { cellColor: "steelblue"; onClicked: helloText.color = cellColor } + Cell { cellColor: "black"; onClicked: helloText.color = cellColor } + } +} diff --git a/examples/qmlscene/tutorial3.qml b/examples/qmlscene/tutorial3.qml new file mode 100644 index 00000000..e5eabab1 --- /dev/null +++ b/examples/qmlscene/tutorial3.qml @@ -0,0 +1,45 @@ +// See http://qt-project.org/doc/qt-5.1/qtquick/qml-tutorial3.html + +import QtQuick 2.0 + +Rectangle { + id: page + width: 320; height: 480 + color: "lightgray" + + Text { + id: helloText + text: "Hello world!" + y: 30 + anchors.horizontalCenter: page.horizontalCenter + font.pointSize: 24; font.bold: true + + MouseArea { id: mouseArea; anchors.fill: parent } + + states: State { + name: "down"; when: mouseArea.pressed == true + PropertyChanges { target: helloText; y: 160; rotation: 180; color: "red" } + } + + transitions: Transition { + from: ""; to: "down"; reversible: true + ParallelAnimation { + NumberAnimation { properties: "y,rotation"; duration: 500; easing.type: Easing.InOutQuad } + ColorAnimation { duration: 500 } + } + } + } + + Grid { + id: colorPicker + x: 4; anchors.bottom: page.bottom; anchors.bottomMargin: 4 + rows: 2; columns: 3; spacing: 3 + + Cell { cellColor: "red"; onClicked: helloText.color = cellColor } + Cell { cellColor: "green"; onClicked: helloText.color = cellColor } + Cell { cellColor: "blue"; onClicked: helloText.color = cellColor } + Cell { cellColor: "yellow"; onClicked: helloText.color = cellColor } + Cell { cellColor: "steelblue"; onClicked: helloText.color = cellColor } + Cell { cellColor: "black"; onClicked: helloText.color = cellColor } + } +} diff --git a/examples/qrcpacking/assets/particle.png b/examples/qrcpacking/assets/particle.png new file mode 100644 index 00000000..5c83896d Binary files /dev/null and b/examples/qrcpacking/assets/particle.png differ diff --git a/examples/qrcpacking/assets/particle.qml b/examples/qrcpacking/assets/particle.qml new file mode 100644 index 00000000..2708a3df --- /dev/null +++ b/examples/qrcpacking/assets/particle.qml @@ -0,0 +1,89 @@ +import QtQuick 2.0 +import QtQuick.Particles 2.0 +import QtGraphicalEffects 1.0; + +Rectangle { + id: root + + width: 640 + height: 480 + + gradient: Gradient { + GradientStop { position: 0.0; color: "#3a2c32"; } + GradientStop { position: 0.8; color: "#875864"; } + GradientStop { position: 1.0; color: "#9b616c"; } + } + + Text { + text: ctrl.message + + Component.onCompleted: { + x = parent.width/2 - width/2 + y = parent.height/2 - height/2 + } + + color: "white" + font.bold: true + font.pointSize: 20 + + MouseArea { + id: mouseArea + anchors.fill: parent + drag.target: parent + onReleased: ctrl.textReleased(parent) + } + } + + ParticleSystem { id: sys } + + ImageParticle { + system: sys + source: "qrc:///assets/particle.png" + color: "white" + colorVariation: 1.0 + alpha: 0.1 + } + + property var emitterComponent: Component { + id: emitterComponent + Emitter { + id: container + system: sys + Emitter { + system: sys + emitRate: 128 + lifeSpan: 600 + size: 16 + endSize: 8 + velocity: AngleDirection { angleVariation:360; magnitude: 60 } + } + + property int life: 2600 + property real targetX: 0 + property real targetY: 0 + emitRate: 128 + lifeSpan: 600 + size: 24 + endSize: 8 + NumberAnimation on x { + objectName: "xAnim" + id: xAnim; + to: targetX + duration: life + running: false + } + NumberAnimation on y { + objectName: "yAnim" + id: yAnim; + to: targetY + duration: life + running: false + } + Timer { + interval: life + running: true + onTriggered: ctrl.done(container) + } + } + } +} diff --git a/examples/qrcpacking/main.go b/examples/qrcpacking/main.go new file mode 100644 index 00000000..a151cdb4 --- /dev/null +++ b/examples/qrcpacking/main.go @@ -0,0 +1,86 @@ +package main + +//go:generate genqrc assets + +import ( + "fmt" + "math/rand" + "os" + "time" + + "gopkg.in/qml.v1" +) + +func main() { + if err := qml.Run(run); err != nil { + fmt.Fprintf(os.Stderr, "error: %v\n", err) + os.Exit(1) + } +} + +func run() error { + engine := qml.NewEngine() + component, err := engine.LoadFile("qrc:///assets/particle.qml") + if err != nil { + return err + } + + ctrl := Control{Message: "Hello from Go!"} + + context := engine.Context() + context.SetVar("ctrl", &ctrl) + + window := component.CreateWindow(nil) + + ctrl.Root = window.Root() + + rand.Seed(time.Now().Unix()) + + window.Show() + window.Wait() + + return nil +} + +type Control struct { + Root qml.Object + Message string +} + +func (ctrl *Control) TextReleased(text qml.Object) { + x := text.Int("x") + y := text.Int("y") + width := text.Int("width") + height := text.Int("height") + + ctrl.Emit(x+15, y+height/2) + ctrl.Emit(x+width/2, 1.0*y+height/2) + ctrl.Emit(x+width-15, 1.0*y+height/2) + + go func() { + time.Sleep(500 * time.Millisecond) + messages := []string{"Hello", "Hello", "Hacks"} + ctrl.Message = messages[rand.Intn(len(messages))] + " from Go!" + qml.Changed(ctrl, &ctrl.Message) + }() +} + +func (ctrl *Control) Emit(x, y int) { + component := ctrl.Root.Object("emitterComponent") + for i := 0; i < 8; i++ { + emitter := component.Create(nil) + emitter.Set("x", x) + emitter.Set("y", y) + emitter.Set("targetX", rand.Intn(240)-120+x) + emitter.Set("targetY", rand.Intn(240)-120+y) + emitter.Set("life", rand.Intn(2400)+200) + emitter.Set("emitRate", rand.Intn(32)+32) + emitter.ObjectByName("xAnim").Call("start") + emitter.ObjectByName("yAnim").Call("start") + emitter.Set("enabled", true) + } +} + +func (ctrl *Control) Done(emitter qml.Object) { + emitter.Destroy() +} diff --git a/examples/qrcpacking/qrc.go b/examples/qrcpacking/qrc.go new file mode 100644 index 00000000..7002e67f --- /dev/null +++ b/examples/qrcpacking/qrc.go @@ -0,0 +1,58 @@ +package main + +// This file is automatically generated by gopkg.in/qml.v1/cmd/genqrc + +import ( + "io/ioutil" + "os" + "path/filepath" + + "gopkg.in/qml.v1" +) + +func init() { + var r *qml.Resources + var err error + if os.Getenv("QRC_REPACK") == "1" { + err = qrcRepackResources() + if err != nil { + panic("cannot repack qrc resources: " + err.Error()) + } + r, err = qml.ParseResources(qrcResourcesRepacked) + } else { + r, err = qml.ParseResourcesString(qrcResourcesData) + } + if err != nil { + panic("cannot parse bundled resources data: " + err.Error()) + } + qml.LoadResources(r) +} + +func qrcRepackResources() error { + subdirs := []string{"assets"} + var rp qml.ResourcesPacker + for _, subdir := range subdirs { + err := filepath.Walk(subdir, func(path string, info os.FileInfo, err error) error { + if err != nil { + return err + } + if info.IsDir() { + return nil + } + data, err := ioutil.ReadFile(path) + if err != nil { + return err + } + rp.Add(filepath.ToSlash(path), data) + return nil + }) + if err != nil { + return err + } + } + qrcResourcesRepacked = rp.Pack().Bytes() + return nil +} + +var qrcResourcesRepacked []byte +var qrcResourcesData = "qres\x00\x00\x00\x01\x00\x00\t\xeb\x00\x00\x00\x14\x00\x00\t\x9d\x00\x00\x03]\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \b\x06\x00\x00\x00szz\xf4\x00\x00\x00\x19tEXtSoftware\x00Adobe ImageReadyq\xc9e<\x00\x00\x02\xffIDATxڔWM\x8f\xd40\fM\xd2t\x96\x0f\xed\xc2a\xf7\x00\a~\x01\xff\xff\x9fp\xe2\xc0\x05\x84\x84\x90X\x81\xc4\x0e\xdb6&\xae\x9c\xea\xcd\xc3閑\xacd\xda\xd4~v\x9e\x1d'\x87\xff\xf8\x89H\xaaC\x93hc\xd1W&:/1F9\xaa3\x9b\xe2\xbd5jh\xb0\xb5\x99\x9e\a3\x1c`^\xd5\xc9\\\xc7Ť\xaf8\xc6\v\x85=\x80W\xe6i\x00\xcf\x11\x84\x10\x90bϳ\x01\x98\xecY?\x02\x1d\xaf\xd5\xf0\b\x86Q\xdc\x1d\x82mXl\u07b6IA\xccG\x01\xe8G\xcf-\xec\tF\xde{6\x8e\\H\x06\"BĢ\x01\xd9\x05\x80\xc6\a\x02\xd18\x90H1\x86\xbe\x98\xa7\xed}!\x1e\bG\x82\x01\\\x81\xe1\f\xe3\b`\"\xf1\x80\xa3о\xe9\x85]\x10T&0#x<\xd8\xff\x11\xfe\xefeJp\xb6*:\xc63\x80\xdd\x00\xe8\xc2g\x90r͋\x93͙\xf9\t\x14F`y\x04\x0ed\xda\x1a\x01\xe7t\xfe\x88\x002(F\xef\xd9\xf3\x04{ޛ\x17\x00\x96\x81\x98\x02\xeb\xb6\"\xd6\x00\x8c\xf00\x01\xe1\xd8x\xa4T\x8c\x94~b\xdf,\xf0\xae9Q(3V\x00\xc9\xca+\xa7\xda@F\xd8x\xdaIS/:\x19\xb6\xb7\x8dj;採\xc1\xa9zhDS\xf5]\x95[c\xfb\xf7*\x9f\xab\xfc&\x1e\b\x01\xc7\xf3#\x06\nst\x1630\x95\x17U\xdeWym$Ue/\xab\xdcT\xf9P\xe5\x81·\xd4ѹ\xea\xcdNU\x8b\x0e\xeb\x11\xd8[3vm`\x16{\xae9\xff\xa6\xca'\xe2Fp\xf4\xfdC\xac^q\t\x8e\xa2W\x90\xa27\x96\xbe\xad~\\;\aT\xcf\xf8\xb6\x05\xd21\xea\xe5}\x006k\x1e\xff4\xcf'\xc8\xf7@\xa1\x96\x8e\xde\xf5}&/e'\x02M~X\xe8U\xf9\x1f3\xfa`r\x0f \x84\xb6\x82\x8fmi\x00\x8as\xa8`\xe1\xc0:\xaf\n\xbf\x1a\xe9f\x8b`\xb1h\xfc\xaa\xf2\xadcP\xbc\xc6E%\xc3\xc1\x80\v\x17\xe2\a\x82SO?V\xb93>Lf\\S\xf1\xdc1Th\xdc\xdegz\x89G*o\x0f\x16\x97\xb3\xe5\xfd\x17\xa7\x17\x10ꀚ\xbeB\xe7\xc2:\xa6ڗa\aS\x80d3\x9d\xe5\x05\xfa<\x9e\xb3\x0e!\xe33\x91t\xb1\x9ep;\v&\xaa\u05ed\x8dJ\xce\xe9\x17\bX\x8fh\xec\xc8\xe2Da\v\xb3\x17\x81؎L\xa74\xcbN\xca\x16\xe0\xd1#y/d\xebb\x9f\xcfV\xe3g'\rG:\xb2{-\x99P\x9d\xc0\bx\x1c\xb8\xe8\x88\xdaG'\xe8\xeb8\x9c\x83S\xd7y\r\x87\x9d\xe5\xa2/\xe4\x9ep2ţ-j\x8a\x13\x8c^\xe9\xe6L\xf0ȊϺMik\x95\xb0\x9bI\x0e\x00>\xf3\x99|\x9c\x15L\xc2\xdd{A\xe3\xc3\t.&\xec}\x82m\x92N\xd1\x11 \x12\xfd\xd0\xcd(\x00\x89F\xeaf\xc2\x13\xf7C&\x9bx\x17\x92#\x00\x02\x84n\xa0K\x898\x1c\xe8\x95\xde\xf2\xe4\xedXo\xa9G\x80h\x0fG\xc5)\x92\x81\x15@շ\x1c\xbd\x9e\xff\x15`\x00\xdfɄ\xff\xd7\x15\xb9\x95\x00\x00\x00\x00IEND\xaeB`\x82\x00\x00\x06$import QtQuick 2.0\nimport QtQuick.Particles 2.0\nimport QtGraphicalEffects 1.0;\n\nRectangle {\n\tid: root\n\n\twidth: 640\n\theight: 480\n\n\tgradient: Gradient {\n\t\tGradientStop { position: 0.0; color: \"#3a2c32\"; }\n\t\tGradientStop { position: 0.8; color: \"#875864\"; }\n\t\tGradientStop { position: 1.0; color: \"#9b616c\"; }\n\t}\n\n\tText {\n\t\ttext: ctrl.message\n\n\t\tComponent.onCompleted: {\n\t\t\tx = parent.width/2 - width/2\n\t\t\ty = parent.height/2 - height/2\n\t\t}\n\n\t\tcolor: \"white\"\n\t\tfont.bold: true\n\t\tfont.pointSize: 20\n\n\t\tMouseArea {\n\t\t id: mouseArea\n\t\t anchors.fill: parent\n\t\t drag.target: parent\n onReleased: ctrl.textReleased(parent)\n\t\t}\n\t}\n\n\tParticleSystem { id: sys }\n\n\tImageParticle {\n\t\tsystem: sys\n\t\tsource: \"qrc:///assets/particle.png\"\n\t\tcolor: \"white\"\n\t\tcolorVariation: 1.0\n\t\talpha: 0.1\n\t}\n\n\tproperty var emitterComponent: Component {\n\t\tid: emitterComponent\n\t\tEmitter {\n\t\t\tid: container\n\t\t\tsystem: sys\n\t\t\tEmitter {\n\t\t\t\tsystem: sys\n\t\t\t\temitRate: 128\n\t\t\t\tlifeSpan: 600\n\t\t\t\tsize: 16\n\t\t\t\tendSize: 8\n\t\t\t\tvelocity: AngleDirection { angleVariation:360; magnitude: 60 }\n\t\t\t}\n\n\t\t\tproperty int life: 2600\n\t\t\tproperty real targetX: 0\n\t\t\tproperty real targetY: 0\n\t\t\temitRate: 128\n\t\t\tlifeSpan: 600\n\t\t\tsize: 24\n\t\t\tendSize: 8\n\t\t\tNumberAnimation on x {\n\t\t\t\tobjectName: \"xAnim\"\n\t\t\t\tid: xAnim;\n\t\t\t\tto: targetX\n\t\t\t\tduration: life\n\t\t\t\trunning: false\n\t\t\t}\n\t\t\tNumberAnimation on y {\n\t\t\t\tobjectName: \"yAnim\"\n\t\t\t\tid: yAnim;\n\t\t\t\tto: targetY\n\t\t\t\tduration: life\n\t\t\t\trunning: false\n\t\t\t}\n\t\t\tTimer {\n\t\t\t\tinterval: life\n\t\t\t\trunning: true\n\t\t\t\tonTriggered: ctrl.done(container)\n\t\t\t}\n\t\t}\n\t}\n}\n\x00\x06\x06\x8a\x9c\xb3\x00a\x00s\x00s\x00e\x00t\x00s\x00\f\b\xf9b\xa7\x00p\x00a\x00r\x00t\x00i\x00c\x00l\x00e\x00.\x00p\x00n\x00g\x00\f\b\xf9e\xdc\x00p\x00a\x00r\x00t\x00i\x00c\x00l\x00e\x00.\x00q\x00m\x00l\x00\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x02\x00\x00\x00\x02\x00\x00\x00\x02\x00\x00\x00\x12\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x000\x00\x00\x00\x00\x00\x01\x00\x00\x03a" diff --git a/examples/reparent/base.qml b/examples/reparent/base.qml new file mode 100644 index 00000000..a77243e3 --- /dev/null +++ b/examples/reparent/base.qml @@ -0,0 +1,7 @@ +import QtQuick 2.0 + +Rectangle { + width: 640 + height: 480 + color: "black" +} diff --git a/examples/reparent/rect.qml b/examples/reparent/rect.qml new file mode 100644 index 00000000..21eda2fe --- /dev/null +++ b/examples/reparent/rect.qml @@ -0,0 +1,8 @@ +import QtQuick 2.0 + +Rectangle { + anchors.centerIn: parent + width: 50 + height: 50 + color: "red" +} diff --git a/examples/reparent/reparent.go b/examples/reparent/reparent.go new file mode 100644 index 00000000..c1399f88 --- /dev/null +++ b/examples/reparent/reparent.go @@ -0,0 +1,37 @@ +package main + +import ( + "fmt" + "gopkg.in/qml.v1" + "os" +) + +func main() { + if err := qml.Run(run); err != nil { + fmt.Fprintf(os.Stderr, "error: %v\n", err) + os.Exit(1) + } +} + +func run() error { + engine := qml.NewEngine() + + base, err := engine.LoadFile("base.qml") + if err != nil { + return err + } + rect, err := engine.LoadFile("rect.qml") + if err != nil { + return err + } + + win := base.CreateWindow(nil) + obj := rect.Create(nil) + + obj.Set("parent", win.Root()) + + win.Show() + win.Wait() + + return nil +} diff --git a/examples/snapweb/snapweb.go b/examples/snapweb/snapweb.go new file mode 100644 index 00000000..53d1d621 --- /dev/null +++ b/examples/snapweb/snapweb.go @@ -0,0 +1,70 @@ +package main + +import ( + "fmt" + "gopkg.in/qml.v1" + "image/png" + "os" +) + +const webview = ` +import QtQuick 2.0 +import QtWebKit 3.0 + +WebView { + width: 1024 + height: 768 +} +` + +func main() { + if len(os.Args) != 3 { + fmt.Fprintf(os.Stderr, "usage: %s \n", os.Args[0]) + os.Exit(1) + } + if err := qml.Run(run); err != nil { + fmt.Fprintf(os.Stderr, "error: %v\n", err) + os.Exit(1) + } +} + +func run() error { + engine := qml.NewEngine() + component, err := engine.LoadString("webview.qml", webview) + if err != nil { + return err + } + ctrl := &Control{ + done: make(chan error), + win: component.CreateWindow(nil), + } + engine.Context().SetVar("ctrl", ctrl) + root := ctrl.win.Root() + root.On("loadingChanged", ctrl.Snapshot) + root.Set("url", os.Args[1]) + ctrl.win.Show() + return <-ctrl.done +} + +type Control struct { + win *qml.Window + done chan error +} + +func (ctrl *Control) Snapshot(request qml.Object) { + if request.Int("status") != 2 { + return + } + f, err := os.Create(os.Args[2]) + if err != nil { + ctrl.done <- err + return + } + defer f.Close() + img := ctrl.win.Snapshot() + err = png.Encode(f, img) + if err != nil { + os.Remove(os.Args[2]) + } + ctrl.done <- err +} diff --git a/gl/1.0/funcs.cpp b/gl/1.0/funcs.cpp new file mode 100644 index 00000000..d7d9cf65 --- /dev/null +++ b/gl/1.0/funcs.cpp @@ -0,0 +1,1848 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#include +#include + +#include "funcs.h" + +void *gl1_0_funcs() { + QOpenGLFunctions_1_0* funcs = QOpenGLContext::currentContext()->versionFunctions(); + if (!funcs) { + return 0; + } + funcs->initializeOpenGLFunctions(); + return funcs; +} + + +void gl1_0_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewport(x, y, width, height); +} + +void gl1_0_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRange(nearVal, farVal); +} + +GLboolean gl1_0_glIsEnabled(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabled(cap); +} + +void gl1_0_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameteriv(target, level, pname, params); +} + +void gl1_0_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameterfv(target, level, pname, params); +} + +void gl1_0_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameteriv(target, pname, params); +} + +void gl1_0_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterfv(target, pname, params); +} + +void gl1_0_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexImage(target, level, format, gltype, pixels); +} + +void gl1_0_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegerv(pname, params); +} + +void gl1_0_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFloatv(pname, params); +} + +GLenum gl1_0_glGetError(void *_glfuncs) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetError(); +} + +void gl1_0_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetDoublev(pname, params); +} + +void gl1_0_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleanv(pname, params); +} + +void gl1_0_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadPixels(x, y, width, height, format, gltype, pixels); +} + +void gl1_0_glReadBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadBuffer(mode); +} + +void gl1_0_glPixelStorei(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStorei(pname, param); +} + +void gl1_0_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStoref(pname, param); +} + +void gl1_0_glDepthFunc(void *_glfuncs, GLenum glfunc) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthFunc(glfunc); +} + +void gl1_0_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOp(fail, zfail, zpass); +} + +void gl1_0_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFunc(glfunc, ref, mask); +} + +void gl1_0_glLogicOp(void *_glfuncs, GLenum opcode) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLogicOp(opcode); +} + +void gl1_0_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFunc(sfactor, dfactor); +} + +void gl1_0_glFlush(void *_glfuncs) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlush(); +} + +void gl1_0_glFinish(void *_glfuncs) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFinish(); +} + +void gl1_0_glEnable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnable(cap); +} + +void gl1_0_glDisable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisable(cap); +} + +void gl1_0_glDepthMask(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthMask(flag); +} + +void gl1_0_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMask(red, green, blue, alpha); +} + +void gl1_0_glStencilMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMask(mask); +} + +void gl1_0_glClearDepth(void *_glfuncs, GLdouble depth) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearDepth(depth); +} + +void gl1_0_glClearStencil(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearStencil(s); +} + +void gl1_0_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearColor(red, green, blue, alpha); +} + +void gl1_0_glClear(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClear(mask); +} + +void gl1_0_glDrawBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffer(mode); +} + +void gl1_0_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage2D(target, level, internalFormat, width, height, border, format, gltype, pixels); +} + +void gl1_0_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage1D(target, level, internalFormat, width, border, format, gltype, pixels); +} + +void gl1_0_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteriv(target, pname, params); +} + +void gl1_0_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteri(target, pname, param); +} + +void gl1_0_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterfv(target, pname, params); +} + +void gl1_0_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterf(target, pname, param); +} + +void gl1_0_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissor(x, y, width, height); +} + +void gl1_0_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonMode(face, mode); +} + +void gl1_0_glPointSize(void *_glfuncs, GLfloat size) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointSize(size); +} + +void gl1_0_glLineWidth(void *_glfuncs, GLfloat width) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineWidth(width); +} + +void gl1_0_glHint(void *_glfuncs, GLenum target, GLenum mode) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glHint(target, mode); +} + +void gl1_0_glFrontFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrontFace(mode); +} + +void gl1_0_glCullFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCullFace(mode); +} + +void gl1_0_glTranslatef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTranslatef(x, y, z); +} + +void gl1_0_glTranslated(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTranslated(x, y, z); +} + +void gl1_0_glScalef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScalef(x, y, z); +} + +void gl1_0_glScaled(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScaled(x, y, z); +} + +void gl1_0_glRotatef(void *_glfuncs, GLfloat angle, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRotatef(angle, x, y, z); +} + +void gl1_0_glRotated(void *_glfuncs, GLdouble angle, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRotated(angle, x, y, z); +} + +void gl1_0_glPushMatrix(void *_glfuncs) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushMatrix(); +} + +void gl1_0_glPopMatrix(void *_glfuncs) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopMatrix(); +} + +void gl1_0_glOrtho(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glOrtho(left, right, bottom, top, zNear, zFar); +} + +void gl1_0_glMultMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultMatrixd(m); +} + +void gl1_0_glMultMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultMatrixf(m); +} + +void gl1_0_glMatrixMode(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMatrixMode(mode); +} + +void gl1_0_glLoadMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadMatrixd(m); +} + +void gl1_0_glLoadMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadMatrixf(m); +} + +void gl1_0_glLoadIdentity(void *_glfuncs) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadIdentity(); +} + +void gl1_0_glFrustum(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrustum(left, right, bottom, top, zNear, zFar); +} + +GLboolean gl1_0_glIsList(void *_glfuncs, GLuint list) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsList(list); +} + +void gl1_0_glGetTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGeniv(coord, pname, params); +} + +void gl1_0_glGetTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGenfv(coord, pname, params); +} + +void gl1_0_glGetTexGendv(void *_glfuncs, GLenum coord, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGendv(coord, pname, params); +} + +void gl1_0_glGetTexEnviv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexEnviv(target, pname, params); +} + +void gl1_0_glGetTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexEnvfv(target, pname, params); +} + +void gl1_0_glGetPolygonStipple(void *_glfuncs, GLubyte* mask) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPolygonStipple(mask); +} + +void gl1_0_glGetPixelMapusv(void *_glfuncs, GLenum glmap, GLushort* values) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapusv(glmap, values); +} + +void gl1_0_glGetPixelMapuiv(void *_glfuncs, GLenum glmap, GLuint* values) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapuiv(glmap, values); +} + +void gl1_0_glGetPixelMapfv(void *_glfuncs, GLenum glmap, GLfloat* values) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapfv(glmap, values); +} + +void gl1_0_glGetMaterialiv(void *_glfuncs, GLenum face, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMaterialiv(face, pname, params); +} + +void gl1_0_glGetMaterialfv(void *_glfuncs, GLenum face, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMaterialfv(face, pname, params); +} + +void gl1_0_glGetMapiv(void *_glfuncs, GLenum target, GLenum query, GLint* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapiv(target, query, v); +} + +void gl1_0_glGetMapfv(void *_glfuncs, GLenum target, GLenum query, GLfloat* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapfv(target, query, v); +} + +void gl1_0_glGetMapdv(void *_glfuncs, GLenum target, GLenum query, GLdouble* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapdv(target, query, v); +} + +void gl1_0_glGetLightiv(void *_glfuncs, GLenum light, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetLightiv(light, pname, params); +} + +void gl1_0_glGetLightfv(void *_glfuncs, GLenum light, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetLightfv(light, pname, params); +} + +void gl1_0_glGetClipPlane(void *_glfuncs, GLenum plane, GLdouble* equation) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetClipPlane(plane, equation); +} + +void gl1_0_glDrawPixels(void *_glfuncs, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawPixels(width, height, format, gltype, pixels); +} + +void gl1_0_glCopyPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum gltype) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyPixels(x, y, width, height, gltype); +} + +void gl1_0_glPixelMapusv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLushort* values) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapusv(glmap, mapsize, values); +} + +void gl1_0_glPixelMapuiv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLuint* values) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapuiv(glmap, mapsize, values); +} + +void gl1_0_glPixelMapfv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLfloat* values) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapfv(glmap, mapsize, values); +} + +void gl1_0_glPixelTransferi(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelTransferi(pname, param); +} + +void gl1_0_glPixelTransferf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelTransferf(pname, param); +} + +void gl1_0_glPixelZoom(void *_glfuncs, GLfloat xfactor, GLfloat yfactor) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelZoom(xfactor, yfactor); +} + +void gl1_0_glAlphaFunc(void *_glfuncs, GLenum glfunc, GLfloat ref) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAlphaFunc(glfunc, ref); +} + +void gl1_0_glEvalPoint2(void *_glfuncs, GLint i, GLint j) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalPoint2(i, j); +} + +void gl1_0_glEvalMesh2(void *_glfuncs, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalMesh2(mode, i1, i2, j1, j2); +} + +void gl1_0_glEvalPoint1(void *_glfuncs, GLint i) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalPoint1(i); +} + +void gl1_0_glEvalMesh1(void *_glfuncs, GLenum mode, GLint i1, GLint i2) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalMesh1(mode, i1, i2); +} + +void gl1_0_glEvalCoord2fv(void *_glfuncs, const GLfloat* u) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2fv(u); +} + +void gl1_0_glEvalCoord2f(void *_glfuncs, GLfloat u, GLfloat v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2f(u, v); +} + +void gl1_0_glEvalCoord2dv(void *_glfuncs, const GLdouble* u) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2dv(u); +} + +void gl1_0_glEvalCoord2d(void *_glfuncs, GLdouble u, GLdouble v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2d(u, v); +} + +void gl1_0_glEvalCoord1fv(void *_glfuncs, const GLfloat* u) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1fv(u); +} + +void gl1_0_glEvalCoord1f(void *_glfuncs, GLfloat u) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1f(u); +} + +void gl1_0_glEvalCoord1dv(void *_glfuncs, const GLdouble* u) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1dv(u); +} + +void gl1_0_glEvalCoord1d(void *_glfuncs, GLdouble u) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1d(u); +} + +void gl1_0_glMapGrid2f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid2f(un, u1, u2, vn, v1, v2); +} + +void gl1_0_glMapGrid2d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid2d(un, u1, u2, vn, v1, v2); +} + +void gl1_0_glMapGrid1f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid1f(un, u1, u2); +} + +void gl1_0_glMapGrid1d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid1d(un, u1, u2); +} + +void gl1_0_glMap2f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); +} + +void gl1_0_glMap2d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); +} + +void gl1_0_glMap1f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap1f(target, u1, u2, stride, order, points); +} + +void gl1_0_glMap1d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap1d(target, u1, u2, stride, order, points); +} + +void gl1_0_glPushAttrib(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushAttrib(mask); +} + +void gl1_0_glPopAttrib(void *_glfuncs) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopAttrib(); +} + +void gl1_0_glAccum(void *_glfuncs, GLenum op, GLfloat value) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAccum(op, value); +} + +void gl1_0_glIndexMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexMask(mask); +} + +void gl1_0_glClearIndex(void *_glfuncs, GLfloat c) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearIndex(c); +} + +void gl1_0_glClearAccum(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearAccum(red, green, blue, alpha); +} + +void gl1_0_glPushName(void *_glfuncs, GLuint name) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushName(name); +} + +void gl1_0_glPopName(void *_glfuncs) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopName(); +} + +void gl1_0_glPassThrough(void *_glfuncs, GLfloat token) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPassThrough(token); +} + +void gl1_0_glLoadName(void *_glfuncs, GLuint name) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadName(name); +} + +void gl1_0_glInitNames(void *_glfuncs) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInitNames(); +} + +GLint gl1_0_glRenderMode(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glRenderMode(mode); +} + +void gl1_0_glSelectBuffer(void *_glfuncs, GLsizei size, GLuint* buffer) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSelectBuffer(size, buffer); +} + +void gl1_0_glFeedbackBuffer(void *_glfuncs, GLsizei size, GLenum gltype, GLfloat* buffer) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFeedbackBuffer(size, gltype, buffer); +} + +void gl1_0_glTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGeniv(coord, pname, params); +} + +void gl1_0_glTexGeni(void *_glfuncs, GLenum coord, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGeni(coord, pname, param); +} + +void gl1_0_glTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGenfv(coord, pname, params); +} + +void gl1_0_glTexGenf(void *_glfuncs, GLenum coord, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGenf(coord, pname, param); +} + +void gl1_0_glTexGendv(void *_glfuncs, GLenum coord, GLenum pname, const GLdouble* params) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGendv(coord, pname, params); +} + +void gl1_0_glTexGend(void *_glfuncs, GLenum coord, GLenum pname, GLdouble param) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGend(coord, pname, param); +} + +void gl1_0_glTexEnviv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnviv(target, pname, params); +} + +void gl1_0_glTexEnvi(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvi(target, pname, param); +} + +void gl1_0_glTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvfv(target, pname, params); +} + +void gl1_0_glTexEnvf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvf(target, pname, param); +} + +void gl1_0_glShadeModel(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShadeModel(mode); +} + +void gl1_0_glPolygonStipple(void *_glfuncs, const GLubyte* mask) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonStipple(mask); +} + +void gl1_0_glMaterialiv(void *_glfuncs, GLenum face, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialiv(face, pname, params); +} + +void gl1_0_glMateriali(void *_glfuncs, GLenum face, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMateriali(face, pname, param); +} + +void gl1_0_glMaterialfv(void *_glfuncs, GLenum face, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialfv(face, pname, params); +} + +void gl1_0_glMaterialf(void *_glfuncs, GLenum face, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialf(face, pname, param); +} + +void gl1_0_glLineStipple(void *_glfuncs, GLint factor, GLushort pattern) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineStipple(factor, pattern); +} + +void gl1_0_glLightModeliv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModeliv(pname, params); +} + +void gl1_0_glLightModeli(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModeli(pname, param); +} + +void gl1_0_glLightModelfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModelfv(pname, params); +} + +void gl1_0_glLightModelf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModelf(pname, param); +} + +void gl1_0_glLightiv(void *_glfuncs, GLenum light, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightiv(light, pname, params); +} + +void gl1_0_glLighti(void *_glfuncs, GLenum light, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLighti(light, pname, param); +} + +void gl1_0_glLightfv(void *_glfuncs, GLenum light, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightfv(light, pname, params); +} + +void gl1_0_glLightf(void *_glfuncs, GLenum light, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightf(light, pname, param); +} + +void gl1_0_glFogiv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogiv(pname, params); +} + +void gl1_0_glFogi(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogi(pname, param); +} + +void gl1_0_glFogfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogfv(pname, params); +} + +void gl1_0_glFogf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogf(pname, param); +} + +void gl1_0_glColorMaterial(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMaterial(face, mode); +} + +void gl1_0_glClipPlane(void *_glfuncs, GLenum plane, const GLdouble* equation) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClipPlane(plane, equation); +} + +void gl1_0_glVertex4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4sv(v); +} + +void gl1_0_glVertex4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4s(x, y, z, w); +} + +void gl1_0_glVertex4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4iv(v); +} + +void gl1_0_glVertex4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4i(x, y, z, w); +} + +void gl1_0_glVertex4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4fv(v); +} + +void gl1_0_glVertex4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4f(x, y, z, w); +} + +void gl1_0_glVertex4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4dv(v); +} + +void gl1_0_glVertex4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4d(x, y, z, w); +} + +void gl1_0_glVertex3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3sv(v); +} + +void gl1_0_glVertex3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3s(x, y, z); +} + +void gl1_0_glVertex3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3iv(v); +} + +void gl1_0_glVertex3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3i(x, y, z); +} + +void gl1_0_glVertex3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3fv(v); +} + +void gl1_0_glVertex3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3f(x, y, z); +} + +void gl1_0_glVertex3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3dv(v); +} + +void gl1_0_glVertex3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3d(x, y, z); +} + +void gl1_0_glVertex2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2sv(v); +} + +void gl1_0_glVertex2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2s(x, y); +} + +void gl1_0_glVertex2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2iv(v); +} + +void gl1_0_glVertex2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2i(x, y); +} + +void gl1_0_glVertex2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2fv(v); +} + +void gl1_0_glVertex2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2f(x, y); +} + +void gl1_0_glVertex2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2dv(v); +} + +void gl1_0_glVertex2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2d(x, y); +} + +void gl1_0_glTexCoord4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4sv(v); +} + +void gl1_0_glTexCoord4s(void *_glfuncs, GLshort s, GLshort t, GLshort r, GLshort q) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4s(s, t, r, q); +} + +void gl1_0_glTexCoord4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4iv(v); +} + +void gl1_0_glTexCoord4i(void *_glfuncs, GLint s, GLint t, GLint r, GLint q) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4i(s, t, r, q); +} + +void gl1_0_glTexCoord4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4fv(v); +} + +void gl1_0_glTexCoord4f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4f(s, t, r, q); +} + +void gl1_0_glTexCoord4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4dv(v); +} + +void gl1_0_glTexCoord4d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r, GLdouble q) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4d(s, t, r, q); +} + +void gl1_0_glTexCoord3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3sv(v); +} + +void gl1_0_glTexCoord3s(void *_glfuncs, GLshort s, GLshort t, GLshort r) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3s(s, t, r); +} + +void gl1_0_glTexCoord3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3iv(v); +} + +void gl1_0_glTexCoord3i(void *_glfuncs, GLint s, GLint t, GLint r) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3i(s, t, r); +} + +void gl1_0_glTexCoord3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3fv(v); +} + +void gl1_0_glTexCoord3f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3f(s, t, r); +} + +void gl1_0_glTexCoord3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3dv(v); +} + +void gl1_0_glTexCoord3d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3d(s, t, r); +} + +void gl1_0_glTexCoord2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2sv(v); +} + +void gl1_0_glTexCoord2s(void *_glfuncs, GLshort s, GLshort t) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2s(s, t); +} + +void gl1_0_glTexCoord2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2iv(v); +} + +void gl1_0_glTexCoord2i(void *_glfuncs, GLint s, GLint t) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2i(s, t); +} + +void gl1_0_glTexCoord2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2fv(v); +} + +void gl1_0_glTexCoord2f(void *_glfuncs, GLfloat s, GLfloat t) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2f(s, t); +} + +void gl1_0_glTexCoord2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2dv(v); +} + +void gl1_0_glTexCoord2d(void *_glfuncs, GLdouble s, GLdouble t) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2d(s, t); +} + +void gl1_0_glTexCoord1sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1sv(v); +} + +void gl1_0_glTexCoord1s(void *_glfuncs, GLshort s) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1s(s); +} + +void gl1_0_glTexCoord1iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1iv(v); +} + +void gl1_0_glTexCoord1i(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1i(s); +} + +void gl1_0_glTexCoord1fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1fv(v); +} + +void gl1_0_glTexCoord1f(void *_glfuncs, GLfloat s) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1f(s); +} + +void gl1_0_glTexCoord1dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1dv(v); +} + +void gl1_0_glTexCoord1d(void *_glfuncs, GLdouble s) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1d(s); +} + +void gl1_0_glRectsv(void *_glfuncs, const GLshort* v1, const GLshort* v2) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectsv(v1, v2); +} + +void gl1_0_glRects(void *_glfuncs, GLshort x1, GLshort y1, GLshort x2, GLshort y2) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRects(x1, y1, x2, y2); +} + +void gl1_0_glRectiv(void *_glfuncs, const GLint* v1, const GLint* v2) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectiv(v1, v2); +} + +void gl1_0_glRecti(void *_glfuncs, GLint x1, GLint y1, GLint x2, GLint y2) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRecti(x1, y1, x2, y2); +} + +void gl1_0_glRectfv(void *_glfuncs, const GLfloat* v1, const GLfloat* v2) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectfv(v1, v2); +} + +void gl1_0_glRectf(void *_glfuncs, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectf(x1, y1, x2, y2); +} + +void gl1_0_glRectdv(void *_glfuncs, const GLdouble* v1, const GLdouble* v2) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectdv(v1, v2); +} + +void gl1_0_glRectd(void *_glfuncs, GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectd(x1, y1, x2, y2); +} + +void gl1_0_glRasterPos4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4sv(v); +} + +void gl1_0_glRasterPos4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4s(x, y, z, w); +} + +void gl1_0_glRasterPos4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4iv(v); +} + +void gl1_0_glRasterPos4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4i(x, y, z, w); +} + +void gl1_0_glRasterPos4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4fv(v); +} + +void gl1_0_glRasterPos4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4f(x, y, z, w); +} + +void gl1_0_glRasterPos4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4dv(v); +} + +void gl1_0_glRasterPos4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4d(x, y, z, w); +} + +void gl1_0_glRasterPos3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3sv(v); +} + +void gl1_0_glRasterPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3s(x, y, z); +} + +void gl1_0_glRasterPos3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3iv(v); +} + +void gl1_0_glRasterPos3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3i(x, y, z); +} + +void gl1_0_glRasterPos3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3fv(v); +} + +void gl1_0_glRasterPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3f(x, y, z); +} + +void gl1_0_glRasterPos3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3dv(v); +} + +void gl1_0_glRasterPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3d(x, y, z); +} + +void gl1_0_glRasterPos2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2sv(v); +} + +void gl1_0_glRasterPos2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2s(x, y); +} + +void gl1_0_glRasterPos2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2iv(v); +} + +void gl1_0_glRasterPos2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2i(x, y); +} + +void gl1_0_glRasterPos2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2fv(v); +} + +void gl1_0_glRasterPos2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2f(x, y); +} + +void gl1_0_glRasterPos2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2dv(v); +} + +void gl1_0_glRasterPos2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2d(x, y); +} + +void gl1_0_glNormal3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3sv(v); +} + +void gl1_0_glNormal3s(void *_glfuncs, GLshort nx, GLshort ny, GLshort nz) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3s(nx, ny, nz); +} + +void gl1_0_glNormal3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3iv(v); +} + +void gl1_0_glNormal3i(void *_glfuncs, GLint nx, GLint ny, GLint nz) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3i(nx, ny, nz); +} + +void gl1_0_glNormal3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3fv(v); +} + +void gl1_0_glNormal3f(void *_glfuncs, GLfloat nx, GLfloat ny, GLfloat nz) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3f(nx, ny, nz); +} + +void gl1_0_glNormal3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3dv(v); +} + +void gl1_0_glNormal3d(void *_glfuncs, GLdouble nx, GLdouble ny, GLdouble nz) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3d(nx, ny, nz); +} + +void gl1_0_glNormal3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3bv(v); +} + +void gl1_0_glNormal3b(void *_glfuncs, GLbyte nx, GLbyte ny, GLbyte nz) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3b(nx, ny, nz); +} + +void gl1_0_glIndexsv(void *_glfuncs, const GLshort* c) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexsv(c); +} + +void gl1_0_glIndexs(void *_glfuncs, GLshort c) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexs(c); +} + +void gl1_0_glIndexiv(void *_glfuncs, const GLint* c) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexiv(c); +} + +void gl1_0_glIndexi(void *_glfuncs, GLint c) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexi(c); +} + +void gl1_0_glIndexfv(void *_glfuncs, const GLfloat* c) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexfv(c); +} + +void gl1_0_glIndexf(void *_glfuncs, GLfloat c) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexf(c); +} + +void gl1_0_glIndexdv(void *_glfuncs, const GLdouble* c) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexdv(c); +} + +void gl1_0_glIndexd(void *_glfuncs, GLdouble c) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexd(c); +} + +void gl1_0_glEnd(void *_glfuncs) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnd(); +} + +void gl1_0_glEdgeFlagv(void *_glfuncs, const GLboolean* flag) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlagv(flag); +} + +void gl1_0_glEdgeFlag(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlag(flag); +} + +void gl1_0_glColor4usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4usv(v); +} + +void gl1_0_glColor4us(void *_glfuncs, GLushort red, GLushort green, GLushort blue, GLushort alpha) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4us(red, green, blue, alpha); +} + +void gl1_0_glColor4uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4uiv(v); +} + +void gl1_0_glColor4ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue, GLuint alpha) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ui(red, green, blue, alpha); +} + +void gl1_0_glColor4ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ubv(v); +} + +void gl1_0_glColor4ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ub(red, green, blue, alpha); +} + +void gl1_0_glColor4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4sv(v); +} + +void gl1_0_glColor4s(void *_glfuncs, GLshort red, GLshort green, GLshort blue, GLshort alpha) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4s(red, green, blue, alpha); +} + +void gl1_0_glColor4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4iv(v); +} + +void gl1_0_glColor4i(void *_glfuncs, GLint red, GLint green, GLint blue, GLint alpha) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4i(red, green, blue, alpha); +} + +void gl1_0_glColor4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4fv(v); +} + +void gl1_0_glColor4f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4f(red, green, blue, alpha); +} + +void gl1_0_glColor4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4dv(v); +} + +void gl1_0_glColor4d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4d(red, green, blue, alpha); +} + +void gl1_0_glColor4bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4bv(v); +} + +void gl1_0_glColor4b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4b(red, green, blue, alpha); +} + +void gl1_0_glColor3usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3usv(v); +} + +void gl1_0_glColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3us(red, green, blue); +} + +void gl1_0_glColor3uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3uiv(v); +} + +void gl1_0_glColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ui(red, green, blue); +} + +void gl1_0_glColor3ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ubv(v); +} + +void gl1_0_glColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ub(red, green, blue); +} + +void gl1_0_glColor3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3sv(v); +} + +void gl1_0_glColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3s(red, green, blue); +} + +void gl1_0_glColor3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3iv(v); +} + +void gl1_0_glColor3i(void *_glfuncs, GLint red, GLint green, GLint blue) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3i(red, green, blue); +} + +void gl1_0_glColor3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3fv(v); +} + +void gl1_0_glColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3f(red, green, blue); +} + +void gl1_0_glColor3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3dv(v); +} + +void gl1_0_glColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3d(red, green, blue); +} + +void gl1_0_glColor3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3bv(v); +} + +void gl1_0_glColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3b(red, green, blue); +} + +void gl1_0_glBitmap(void *_glfuncs, GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBitmap(width, height, xorig, yorig, xmove, ymove, bitmap); +} + +void gl1_0_glBegin(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBegin(mode); +} + +void gl1_0_glListBase(void *_glfuncs, GLuint base) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glListBase(base); +} + +GLuint gl1_0_glGenLists(void *_glfuncs, GLsizei range_) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGenLists(range_); +} + +void gl1_0_glDeleteLists(void *_glfuncs, GLuint list, GLsizei range_) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteLists(list, range_); +} + +void gl1_0_glCallLists(void *_glfuncs, GLsizei n, GLenum gltype, const GLvoid* lists) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCallLists(n, gltype, lists); +} + +void gl1_0_glCallList(void *_glfuncs, GLuint list) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCallList(list); +} + +void gl1_0_glEndList(void *_glfuncs) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndList(); +} + +void gl1_0_glNewList(void *_glfuncs, GLuint list, GLenum mode) +{ + QOpenGLFunctions_1_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNewList(list, mode); +} + diff --git a/gl/1.0/funcs.h b/gl/1.0/funcs.h new file mode 100644 index 00000000..c016eec7 --- /dev/null +++ b/gl/1.0/funcs.h @@ -0,0 +1,347 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#ifndef __cplusplus +#include +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef char GLchar; +typedef signed char GLbyte; /* 1-byte signed */ +typedef short GLshort; /* 2-byte signed */ +typedef int GLint; /* 4-byte signed */ +typedef unsigned char GLubyte; /* 1-byte unsigned */ +typedef unsigned short GLushort; /* 2-byte unsigned */ +typedef unsigned int GLuint; /* 4-byte unsigned */ +typedef int GLsizei; /* 4-byte signed */ +typedef float GLfloat; /* single precision float */ +typedef float GLclampf; /* single precision float in [0,1] */ +typedef double GLdouble; /* double precision float */ +typedef double GLclampd; /* double precision float in [0,1] */ +typedef int64_t GLint64; +typedef uint64_t GLuint64; +typedef ptrdiff_t GLintptr; +typedef ptrdiff_t GLsizeiptr; +typedef ptrdiff_t GLintptrARB; +typedef ptrdiff_t GLsizeiptrARB; +typedef struct __GLsync *GLsync; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +void *gl1_0_funcs(); + +void gl1_0_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl1_0_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal); +GLboolean gl1_0_glIsEnabled(void *_glfuncs, GLenum cap); +void gl1_0_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params); +void gl1_0_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params); +void gl1_0_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl1_0_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl1_0_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels); +void gl1_0_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params); +void gl1_0_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params); +GLenum gl1_0_glGetError(void *_glfuncs); +void gl1_0_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params); +void gl1_0_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params); +void gl1_0_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels); +void gl1_0_glReadBuffer(void *_glfuncs, GLenum mode); +void gl1_0_glPixelStorei(void *_glfuncs, GLenum pname, GLint param); +void gl1_0_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param); +void gl1_0_glDepthFunc(void *_glfuncs, GLenum glfunc); +void gl1_0_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass); +void gl1_0_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask); +void gl1_0_glLogicOp(void *_glfuncs, GLenum opcode); +void gl1_0_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor); +void gl1_0_glFlush(void *_glfuncs); +void gl1_0_glFinish(void *_glfuncs); +void gl1_0_glEnable(void *_glfuncs, GLenum cap); +void gl1_0_glDisable(void *_glfuncs, GLenum cap); +void gl1_0_glDepthMask(void *_glfuncs, GLboolean flag); +void gl1_0_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +void gl1_0_glStencilMask(void *_glfuncs, GLuint mask); +void gl1_0_glClearDepth(void *_glfuncs, GLdouble depth); +void gl1_0_glClearStencil(void *_glfuncs, GLint s); +void gl1_0_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl1_0_glClear(void *_glfuncs, GLbitfield mask); +void gl1_0_glDrawBuffer(void *_glfuncs, GLenum mode); +void gl1_0_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_0_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_0_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl1_0_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl1_0_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl1_0_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl1_0_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl1_0_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode); +void gl1_0_glPointSize(void *_glfuncs, GLfloat size); +void gl1_0_glLineWidth(void *_glfuncs, GLfloat width); +void gl1_0_glHint(void *_glfuncs, GLenum target, GLenum mode); +void gl1_0_glFrontFace(void *_glfuncs, GLenum mode); +void gl1_0_glCullFace(void *_glfuncs, GLenum mode); +void gl1_0_glTranslatef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl1_0_glTranslated(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl1_0_glScalef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl1_0_glScaled(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl1_0_glRotatef(void *_glfuncs, GLfloat angle, GLfloat x, GLfloat y, GLfloat z); +void gl1_0_glRotated(void *_glfuncs, GLdouble angle, GLdouble x, GLdouble y, GLdouble z); +void gl1_0_glPushMatrix(void *_glfuncs); +void gl1_0_glPopMatrix(void *_glfuncs); +void gl1_0_glOrtho(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +void gl1_0_glMultMatrixd(void *_glfuncs, const GLdouble* m); +void gl1_0_glMultMatrixf(void *_glfuncs, const GLfloat* m); +void gl1_0_glMatrixMode(void *_glfuncs, GLenum mode); +void gl1_0_glLoadMatrixd(void *_glfuncs, const GLdouble* m); +void gl1_0_glLoadMatrixf(void *_glfuncs, const GLfloat* m); +void gl1_0_glLoadIdentity(void *_glfuncs); +void gl1_0_glFrustum(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +GLboolean gl1_0_glIsList(void *_glfuncs, GLuint list); +void gl1_0_glGetTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, GLint* params); +void gl1_0_glGetTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, GLfloat* params); +void gl1_0_glGetTexGendv(void *_glfuncs, GLenum coord, GLenum pname, GLdouble* params); +void gl1_0_glGetTexEnviv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl1_0_glGetTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl1_0_glGetPolygonStipple(void *_glfuncs, GLubyte* mask); +void gl1_0_glGetPixelMapusv(void *_glfuncs, GLenum glmap, GLushort* values); +void gl1_0_glGetPixelMapuiv(void *_glfuncs, GLenum glmap, GLuint* values); +void gl1_0_glGetPixelMapfv(void *_glfuncs, GLenum glmap, GLfloat* values); +void gl1_0_glGetMaterialiv(void *_glfuncs, GLenum face, GLenum pname, GLint* params); +void gl1_0_glGetMaterialfv(void *_glfuncs, GLenum face, GLenum pname, GLfloat* params); +void gl1_0_glGetMapiv(void *_glfuncs, GLenum target, GLenum query, GLint* v); +void gl1_0_glGetMapfv(void *_glfuncs, GLenum target, GLenum query, GLfloat* v); +void gl1_0_glGetMapdv(void *_glfuncs, GLenum target, GLenum query, GLdouble* v); +void gl1_0_glGetLightiv(void *_glfuncs, GLenum light, GLenum pname, GLint* params); +void gl1_0_glGetLightfv(void *_glfuncs, GLenum light, GLenum pname, GLfloat* params); +void gl1_0_glGetClipPlane(void *_glfuncs, GLenum plane, GLdouble* equation); +void gl1_0_glDrawPixels(void *_glfuncs, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_0_glCopyPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum gltype); +void gl1_0_glPixelMapusv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLushort* values); +void gl1_0_glPixelMapuiv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLuint* values); +void gl1_0_glPixelMapfv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLfloat* values); +void gl1_0_glPixelTransferi(void *_glfuncs, GLenum pname, GLint param); +void gl1_0_glPixelTransferf(void *_glfuncs, GLenum pname, GLfloat param); +void gl1_0_glPixelZoom(void *_glfuncs, GLfloat xfactor, GLfloat yfactor); +void gl1_0_glAlphaFunc(void *_glfuncs, GLenum glfunc, GLfloat ref); +void gl1_0_glEvalPoint2(void *_glfuncs, GLint i, GLint j); +void gl1_0_glEvalMesh2(void *_glfuncs, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); +void gl1_0_glEvalPoint1(void *_glfuncs, GLint i); +void gl1_0_glEvalMesh1(void *_glfuncs, GLenum mode, GLint i1, GLint i2); +void gl1_0_glEvalCoord2fv(void *_glfuncs, const GLfloat* u); +void gl1_0_glEvalCoord2f(void *_glfuncs, GLfloat u, GLfloat v); +void gl1_0_glEvalCoord2dv(void *_glfuncs, const GLdouble* u); +void gl1_0_glEvalCoord2d(void *_glfuncs, GLdouble u, GLdouble v); +void gl1_0_glEvalCoord1fv(void *_glfuncs, const GLfloat* u); +void gl1_0_glEvalCoord1f(void *_glfuncs, GLfloat u); +void gl1_0_glEvalCoord1dv(void *_glfuncs, const GLdouble* u); +void gl1_0_glEvalCoord1d(void *_glfuncs, GLdouble u); +void gl1_0_glMapGrid2f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); +void gl1_0_glMapGrid2d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); +void gl1_0_glMapGrid1f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2); +void gl1_0_glMapGrid1d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2); +void gl1_0_glMap2f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points); +void gl1_0_glMap2d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points); +void gl1_0_glMap1f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points); +void gl1_0_glMap1d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points); +void gl1_0_glPushAttrib(void *_glfuncs, GLbitfield mask); +void gl1_0_glPopAttrib(void *_glfuncs); +void gl1_0_glAccum(void *_glfuncs, GLenum op, GLfloat value); +void gl1_0_glIndexMask(void *_glfuncs, GLuint mask); +void gl1_0_glClearIndex(void *_glfuncs, GLfloat c); +void gl1_0_glClearAccum(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl1_0_glPushName(void *_glfuncs, GLuint name); +void gl1_0_glPopName(void *_glfuncs); +void gl1_0_glPassThrough(void *_glfuncs, GLfloat token); +void gl1_0_glLoadName(void *_glfuncs, GLuint name); +void gl1_0_glInitNames(void *_glfuncs); +GLint gl1_0_glRenderMode(void *_glfuncs, GLenum mode); +void gl1_0_glSelectBuffer(void *_glfuncs, GLsizei size, GLuint* buffer); +void gl1_0_glFeedbackBuffer(void *_glfuncs, GLsizei size, GLenum gltype, GLfloat* buffer); +void gl1_0_glTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, const GLint* params); +void gl1_0_glTexGeni(void *_glfuncs, GLenum coord, GLenum pname, GLint param); +void gl1_0_glTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, const GLfloat* params); +void gl1_0_glTexGenf(void *_glfuncs, GLenum coord, GLenum pname, GLfloat param); +void gl1_0_glTexGendv(void *_glfuncs, GLenum coord, GLenum pname, const GLdouble* params); +void gl1_0_glTexGend(void *_glfuncs, GLenum coord, GLenum pname, GLdouble param); +void gl1_0_glTexEnviv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl1_0_glTexEnvi(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl1_0_glTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl1_0_glTexEnvf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl1_0_glShadeModel(void *_glfuncs, GLenum mode); +void gl1_0_glPolygonStipple(void *_glfuncs, const GLubyte* mask); +void gl1_0_glMaterialiv(void *_glfuncs, GLenum face, GLenum pname, const GLint* params); +void gl1_0_glMateriali(void *_glfuncs, GLenum face, GLenum pname, GLint param); +void gl1_0_glMaterialfv(void *_glfuncs, GLenum face, GLenum pname, const GLfloat* params); +void gl1_0_glMaterialf(void *_glfuncs, GLenum face, GLenum pname, GLfloat param); +void gl1_0_glLineStipple(void *_glfuncs, GLint factor, GLushort pattern); +void gl1_0_glLightModeliv(void *_glfuncs, GLenum pname, const GLint* params); +void gl1_0_glLightModeli(void *_glfuncs, GLenum pname, GLint param); +void gl1_0_glLightModelfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl1_0_glLightModelf(void *_glfuncs, GLenum pname, GLfloat param); +void gl1_0_glLightiv(void *_glfuncs, GLenum light, GLenum pname, const GLint* params); +void gl1_0_glLighti(void *_glfuncs, GLenum light, GLenum pname, GLint param); +void gl1_0_glLightfv(void *_glfuncs, GLenum light, GLenum pname, const GLfloat* params); +void gl1_0_glLightf(void *_glfuncs, GLenum light, GLenum pname, GLfloat param); +void gl1_0_glFogiv(void *_glfuncs, GLenum pname, const GLint* params); +void gl1_0_glFogi(void *_glfuncs, GLenum pname, GLint param); +void gl1_0_glFogfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl1_0_glFogf(void *_glfuncs, GLenum pname, GLfloat param); +void gl1_0_glColorMaterial(void *_glfuncs, GLenum face, GLenum mode); +void gl1_0_glClipPlane(void *_glfuncs, GLenum plane, const GLdouble* equation); +void gl1_0_glVertex4sv(void *_glfuncs, const GLshort* v); +void gl1_0_glVertex4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w); +void gl1_0_glVertex4iv(void *_glfuncs, const GLint* v); +void gl1_0_glVertex4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w); +void gl1_0_glVertex4fv(void *_glfuncs, const GLfloat* v); +void gl1_0_glVertex4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl1_0_glVertex4dv(void *_glfuncs, const GLdouble* v); +void gl1_0_glVertex4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl1_0_glVertex3sv(void *_glfuncs, const GLshort* v); +void gl1_0_glVertex3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl1_0_glVertex3iv(void *_glfuncs, const GLint* v); +void gl1_0_glVertex3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl1_0_glVertex3fv(void *_glfuncs, const GLfloat* v); +void gl1_0_glVertex3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl1_0_glVertex3dv(void *_glfuncs, const GLdouble* v); +void gl1_0_glVertex3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl1_0_glVertex2sv(void *_glfuncs, const GLshort* v); +void gl1_0_glVertex2s(void *_glfuncs, GLshort x, GLshort y); +void gl1_0_glVertex2iv(void *_glfuncs, const GLint* v); +void gl1_0_glVertex2i(void *_glfuncs, GLint x, GLint y); +void gl1_0_glVertex2fv(void *_glfuncs, const GLfloat* v); +void gl1_0_glVertex2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl1_0_glVertex2dv(void *_glfuncs, const GLdouble* v); +void gl1_0_glVertex2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl1_0_glTexCoord4sv(void *_glfuncs, const GLshort* v); +void gl1_0_glTexCoord4s(void *_glfuncs, GLshort s, GLshort t, GLshort r, GLshort q); +void gl1_0_glTexCoord4iv(void *_glfuncs, const GLint* v); +void gl1_0_glTexCoord4i(void *_glfuncs, GLint s, GLint t, GLint r, GLint q); +void gl1_0_glTexCoord4fv(void *_glfuncs, const GLfloat* v); +void gl1_0_glTexCoord4f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +void gl1_0_glTexCoord4dv(void *_glfuncs, const GLdouble* v); +void gl1_0_glTexCoord4d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +void gl1_0_glTexCoord3sv(void *_glfuncs, const GLshort* v); +void gl1_0_glTexCoord3s(void *_glfuncs, GLshort s, GLshort t, GLshort r); +void gl1_0_glTexCoord3iv(void *_glfuncs, const GLint* v); +void gl1_0_glTexCoord3i(void *_glfuncs, GLint s, GLint t, GLint r); +void gl1_0_glTexCoord3fv(void *_glfuncs, const GLfloat* v); +void gl1_0_glTexCoord3f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r); +void gl1_0_glTexCoord3dv(void *_glfuncs, const GLdouble* v); +void gl1_0_glTexCoord3d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r); +void gl1_0_glTexCoord2sv(void *_glfuncs, const GLshort* v); +void gl1_0_glTexCoord2s(void *_glfuncs, GLshort s, GLshort t); +void gl1_0_glTexCoord2iv(void *_glfuncs, const GLint* v); +void gl1_0_glTexCoord2i(void *_glfuncs, GLint s, GLint t); +void gl1_0_glTexCoord2fv(void *_glfuncs, const GLfloat* v); +void gl1_0_glTexCoord2f(void *_glfuncs, GLfloat s, GLfloat t); +void gl1_0_glTexCoord2dv(void *_glfuncs, const GLdouble* v); +void gl1_0_glTexCoord2d(void *_glfuncs, GLdouble s, GLdouble t); +void gl1_0_glTexCoord1sv(void *_glfuncs, const GLshort* v); +void gl1_0_glTexCoord1s(void *_glfuncs, GLshort s); +void gl1_0_glTexCoord1iv(void *_glfuncs, const GLint* v); +void gl1_0_glTexCoord1i(void *_glfuncs, GLint s); +void gl1_0_glTexCoord1fv(void *_glfuncs, const GLfloat* v); +void gl1_0_glTexCoord1f(void *_glfuncs, GLfloat s); +void gl1_0_glTexCoord1dv(void *_glfuncs, const GLdouble* v); +void gl1_0_glTexCoord1d(void *_glfuncs, GLdouble s); +void gl1_0_glRectsv(void *_glfuncs, const GLshort* v1, const GLshort* v2); +void gl1_0_glRects(void *_glfuncs, GLshort x1, GLshort y1, GLshort x2, GLshort y2); +void gl1_0_glRectiv(void *_glfuncs, const GLint* v1, const GLint* v2); +void gl1_0_glRecti(void *_glfuncs, GLint x1, GLint y1, GLint x2, GLint y2); +void gl1_0_glRectfv(void *_glfuncs, const GLfloat* v1, const GLfloat* v2); +void gl1_0_glRectf(void *_glfuncs, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); +void gl1_0_glRectdv(void *_glfuncs, const GLdouble* v1, const GLdouble* v2); +void gl1_0_glRectd(void *_glfuncs, GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); +void gl1_0_glRasterPos4sv(void *_glfuncs, const GLshort* v); +void gl1_0_glRasterPos4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w); +void gl1_0_glRasterPos4iv(void *_glfuncs, const GLint* v); +void gl1_0_glRasterPos4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w); +void gl1_0_glRasterPos4fv(void *_glfuncs, const GLfloat* v); +void gl1_0_glRasterPos4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl1_0_glRasterPos4dv(void *_glfuncs, const GLdouble* v); +void gl1_0_glRasterPos4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl1_0_glRasterPos3sv(void *_glfuncs, const GLshort* v); +void gl1_0_glRasterPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl1_0_glRasterPos3iv(void *_glfuncs, const GLint* v); +void gl1_0_glRasterPos3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl1_0_glRasterPos3fv(void *_glfuncs, const GLfloat* v); +void gl1_0_glRasterPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl1_0_glRasterPos3dv(void *_glfuncs, const GLdouble* v); +void gl1_0_glRasterPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl1_0_glRasterPos2sv(void *_glfuncs, const GLshort* v); +void gl1_0_glRasterPos2s(void *_glfuncs, GLshort x, GLshort y); +void gl1_0_glRasterPos2iv(void *_glfuncs, const GLint* v); +void gl1_0_glRasterPos2i(void *_glfuncs, GLint x, GLint y); +void gl1_0_glRasterPos2fv(void *_glfuncs, const GLfloat* v); +void gl1_0_glRasterPos2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl1_0_glRasterPos2dv(void *_glfuncs, const GLdouble* v); +void gl1_0_glRasterPos2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl1_0_glNormal3sv(void *_glfuncs, const GLshort* v); +void gl1_0_glNormal3s(void *_glfuncs, GLshort nx, GLshort ny, GLshort nz); +void gl1_0_glNormal3iv(void *_glfuncs, const GLint* v); +void gl1_0_glNormal3i(void *_glfuncs, GLint nx, GLint ny, GLint nz); +void gl1_0_glNormal3fv(void *_glfuncs, const GLfloat* v); +void gl1_0_glNormal3f(void *_glfuncs, GLfloat nx, GLfloat ny, GLfloat nz); +void gl1_0_glNormal3dv(void *_glfuncs, const GLdouble* v); +void gl1_0_glNormal3d(void *_glfuncs, GLdouble nx, GLdouble ny, GLdouble nz); +void gl1_0_glNormal3bv(void *_glfuncs, const GLbyte* v); +void gl1_0_glNormal3b(void *_glfuncs, GLbyte nx, GLbyte ny, GLbyte nz); +void gl1_0_glIndexsv(void *_glfuncs, const GLshort* c); +void gl1_0_glIndexs(void *_glfuncs, GLshort c); +void gl1_0_glIndexiv(void *_glfuncs, const GLint* c); +void gl1_0_glIndexi(void *_glfuncs, GLint c); +void gl1_0_glIndexfv(void *_glfuncs, const GLfloat* c); +void gl1_0_glIndexf(void *_glfuncs, GLfloat c); +void gl1_0_glIndexdv(void *_glfuncs, const GLdouble* c); +void gl1_0_glIndexd(void *_glfuncs, GLdouble c); +void gl1_0_glEnd(void *_glfuncs); +void gl1_0_glEdgeFlagv(void *_glfuncs, const GLboolean* flag); +void gl1_0_glEdgeFlag(void *_glfuncs, GLboolean flag); +void gl1_0_glColor4usv(void *_glfuncs, const GLushort* v); +void gl1_0_glColor4us(void *_glfuncs, GLushort red, GLushort green, GLushort blue, GLushort alpha); +void gl1_0_glColor4uiv(void *_glfuncs, const GLuint* v); +void gl1_0_glColor4ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue, GLuint alpha); +void gl1_0_glColor4ubv(void *_glfuncs, const GLubyte* v); +void gl1_0_glColor4ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); +void gl1_0_glColor4sv(void *_glfuncs, const GLshort* v); +void gl1_0_glColor4s(void *_glfuncs, GLshort red, GLshort green, GLshort blue, GLshort alpha); +void gl1_0_glColor4iv(void *_glfuncs, const GLint* v); +void gl1_0_glColor4i(void *_glfuncs, GLint red, GLint green, GLint blue, GLint alpha); +void gl1_0_glColor4fv(void *_glfuncs, const GLfloat* v); +void gl1_0_glColor4f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl1_0_glColor4dv(void *_glfuncs, const GLdouble* v); +void gl1_0_glColor4d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); +void gl1_0_glColor4bv(void *_glfuncs, const GLbyte* v); +void gl1_0_glColor4b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); +void gl1_0_glColor3usv(void *_glfuncs, const GLushort* v); +void gl1_0_glColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue); +void gl1_0_glColor3uiv(void *_glfuncs, const GLuint* v); +void gl1_0_glColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue); +void gl1_0_glColor3ubv(void *_glfuncs, const GLubyte* v); +void gl1_0_glColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue); +void gl1_0_glColor3sv(void *_glfuncs, const GLshort* v); +void gl1_0_glColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue); +void gl1_0_glColor3iv(void *_glfuncs, const GLint* v); +void gl1_0_glColor3i(void *_glfuncs, GLint red, GLint green, GLint blue); +void gl1_0_glColor3fv(void *_glfuncs, const GLfloat* v); +void gl1_0_glColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue); +void gl1_0_glColor3dv(void *_glfuncs, const GLdouble* v); +void gl1_0_glColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue); +void gl1_0_glColor3bv(void *_glfuncs, const GLbyte* v); +void gl1_0_glColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue); +void gl1_0_glBitmap(void *_glfuncs, GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap); +void gl1_0_glBegin(void *_glfuncs, GLenum mode); +void gl1_0_glListBase(void *_glfuncs, GLuint base); +GLuint gl1_0_glGenLists(void *_glfuncs, GLsizei range_); +void gl1_0_glDeleteLists(void *_glfuncs, GLuint list, GLsizei range_); +void gl1_0_glCallLists(void *_glfuncs, GLsizei n, GLenum gltype, const GLvoid* lists); +void gl1_0_glCallList(void *_glfuncs, GLuint list); +void gl1_0_glEndList(void *_glfuncs); +void gl1_0_glNewList(void *_glfuncs, GLuint list, GLenum mode); + + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/gl/1.0/gl.go b/gl/1.0/gl.go new file mode 100644 index 00000000..ce6c47ce --- /dev/null +++ b/gl/1.0/gl.go @@ -0,0 +1,2528 @@ +// ** file automatically generated by glgen -- do not edit manually ** + +package GL + +// #cgo CXXFLAGS: -std=c++0x -pedantic-errors -Wall -fno-strict-aliasing +// #cgo LDFLAGS: -lstdc++ +// #cgo pkg-config: Qt5Core Qt5OpenGL +// +// #include "funcs.h" +// +// void free(void*); +// +import "C" + +import ( + "fmt" + "reflect" + "unsafe" + + "gopkg.in/qml.v1/gl/glbase" +) + +// API returns a value that offers methods matching the OpenGL version 1.0 API. +// +// The returned API must not be used after the provided OpenGL context becomes invalid. +func API(context glbase.Contexter) *GL { + gl := &GL{} + gl.funcs = C.gl1_0_funcs() + if gl.funcs == nil { + panic(fmt.Errorf("OpenGL version 1.0 is not available")) + } + return gl +} + +// GL implements the OpenGL version 1.0 API. Values of this +// type must be created via the API function, and it must not be used after +// the associated OpenGL context becomes invalid. +type GL struct { + funcs unsafe.Pointer +} + +const ( + FALSE = 0 + TRUE = 1 + NONE = 0 + + BYTE = 0x1400 + UNSIGNED_BYTE = 0x1401 + SHORT = 0x1402 + UNSIGNED_SHORT = 0x1403 + INT = 0x1404 + UNSIGNED_INT = 0x1405 + FLOAT = 0x1406 + N2_BYTES = 0x1407 + N3_BYTES = 0x1408 + N4_BYTES = 0x1409 + DOUBLE = 0x140A + + ACCUM = 0x0100 + LOAD = 0x0101 + RETURN = 0x0102 + MULT = 0x0103 + ADD = 0x0104 + + ACCUM_BUFFER_BIT = 0x00000200 + ALL_ATTRIB_BITS = 0xFFFFFFFF + COLOR_BUFFER_BIT = 0x00004000 + CURRENT_BIT = 0x00000001 + DEPTH_BUFFER_BIT = 0x00000100 + ENABLE_BIT = 0x00002000 + EVAL_BIT = 0x00010000 + FOG_BIT = 0x00000080 + HINT_BIT = 0x00008000 + LIGHTING_BIT = 0x00000040 + LINE_BIT = 0x00000004 + LIST_BIT = 0x00020000 + PIXEL_MODE_BIT = 0x00000020 + POINT_BIT = 0x00000002 + POLYGON_BIT = 0x00000008 + POLYGON_STIPPLE_BIT = 0x00000010 + SCISSOR_BIT = 0x00080000 + STENCIL_BUFFER_BIT = 0x00000400 + TEXTURE_BIT = 0x00040000 + TRANSFORM_BIT = 0x00001000 + VIEWPORT_BIT = 0x00000800 + + ALWAYS = 0x0207 + EQUAL = 0x0202 + GEQUAL = 0x0206 + GREATER = 0x0204 + LEQUAL = 0x0203 + LESS = 0x0201 + NEVER = 0x0200 + NOTEQUAL = 0x0205 + + LOGIC_OP = 0x0BF1 + + DST_ALPHA = 0x0304 + ONE = 1 + ONE_MINUS_DST_ALPHA = 0x0305 + ONE_MINUS_SRC_ALPHA = 0x0303 + ONE_MINUS_SRC_COLOR = 0x0301 + SRC_ALPHA = 0x0302 + SRC_COLOR = 0x0300 + ZERO = 0 + + DST_COLOR = 0x0306 + ONE_MINUS_DST_COLOR = 0x0307 + SRC_ALPHA_SATURATE = 0x0308 + + CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF + CLIENT_PIXEL_STORE_BIT = 0x00000001 + CLIENT_VERTEX_ARRAY_BIT = 0x00000002 + + CLIP_PLANE0 = 0x3000 + CLIP_PLANE1 = 0x3001 + CLIP_PLANE2 = 0x3002 + CLIP_PLANE3 = 0x3003 + CLIP_PLANE4 = 0x3004 + CLIP_PLANE5 = 0x3005 + + BACK = 0x0405 + FRONT = 0x0404 + FRONT_AND_BACK = 0x0408 + + AMBIENT = 0x1200 + AMBIENT_AND_DIFFUSE = 0x1602 + DIFFUSE = 0x1201 + EMISSION = 0x1600 + SPECULAR = 0x1202 + + AUX0 = 0x0409 + AUX1 = 0x040A + AUX2 = 0x040B + AUX3 = 0x040C + BACK_LEFT = 0x0402 + BACK_RIGHT = 0x0403 + FRONT_LEFT = 0x0400 + FRONT_RIGHT = 0x0401 + LEFT = 0x0406 + RIGHT = 0x0407 + + ALPHA_TEST = 0x0BC0 + AUTO_NORMAL = 0x0D80 + BLEND = 0x0BE2 + COLOR_ARRAY = 0x8076 + COLOR_LOGIC_OP = 0x0BF2 + COLOR_MATERIAL = 0x0B57 + CULL_FACE = 0x0B44 + DEPTH_TEST = 0x0B71 + DITHER = 0x0BD0 + EDGE_FLAG_ARRAY = 0x8079 + FOG = 0x0B60 + INDEX_ARRAY = 0x8077 + INDEX_LOGIC_OP = 0x0BF1 + LIGHT0 = 0x4000 + LIGHT1 = 0x4001 + LIGHT2 = 0x4002 + LIGHT3 = 0x4003 + LIGHT4 = 0x4004 + LIGHT5 = 0x4005 + LIGHT6 = 0x4006 + LIGHT7 = 0x4007 + LIGHTING = 0x0B50 + LINE_SMOOTH = 0x0B20 + LINE_STIPPLE = 0x0B24 + MAP1_COLOR_4 = 0x0D90 + MAP1_INDEX = 0x0D91 + MAP1_NORMAL = 0x0D92 + MAP1_TEXTURE_COORD_1 = 0x0D93 + MAP1_TEXTURE_COORD_2 = 0x0D94 + MAP1_TEXTURE_COORD_3 = 0x0D95 + MAP1_TEXTURE_COORD_4 = 0x0D96 + MAP1_VERTEX_3 = 0x0D97 + MAP1_VERTEX_4 = 0x0D98 + MAP2_COLOR_4 = 0x0DB0 + MAP2_INDEX = 0x0DB1 + MAP2_NORMAL = 0x0DB2 + MAP2_TEXTURE_COORD_1 = 0x0DB3 + MAP2_TEXTURE_COORD_2 = 0x0DB4 + MAP2_TEXTURE_COORD_3 = 0x0DB5 + MAP2_TEXTURE_COORD_4 = 0x0DB6 + MAP2_VERTEX_3 = 0x0DB7 + MAP2_VERTEX_4 = 0x0DB8 + NORMALIZE = 0x0BA1 + NORMAL_ARRAY = 0x8075 + POINT_SMOOTH = 0x0B10 + POLYGON_OFFSET_FILL = 0x8037 + POLYGON_OFFSET_LINE = 0x2A02 + POLYGON_OFFSET_POINT = 0x2A01 + POLYGON_SMOOTH = 0x0B41 + POLYGON_STIPPLE = 0x0B42 + SCISSOR_TEST = 0x0C11 + STENCIL_TEST = 0x0B90 + TEXTURE_1D = 0x0DE0 + TEXTURE_2D = 0x0DE1 + TEXTURE_COORD_ARRAY = 0x8078 + TEXTURE_GEN_Q = 0x0C63 + TEXTURE_GEN_R = 0x0C62 + TEXTURE_GEN_S = 0x0C60 + TEXTURE_GEN_T = 0x0C61 + VERTEX_ARRAY = 0x8074 + + INVALID_ENUM = 0x0500 + INVALID_OPERATION = 0x0502 + INVALID_VALUE = 0x0501 + NO_ERROR = 0 + OUT_OF_MEMORY = 0x0505 + STACK_OVERFLOW = 0x0503 + STACK_UNDERFLOW = 0x0504 + + N2D = 0x0600 + N3D = 0x0601 + N3D_COLOR = 0x0602 + N3D_COLOR_TEXTURE = 0x0603 + N4D_COLOR_TEXTURE = 0x0604 + + BITMAP_TOKEN = 0x0704 + COPY_PIXEL_TOKEN = 0x0706 + DRAW_PIXEL_TOKEN = 0x0705 + LINE_RESET_TOKEN = 0x0707 + LINE_TOKEN = 0x0702 + PASS_THROUGH_TOKEN = 0x0700 + POINT_TOKEN = 0x0701 + POLYGON_TOKEN = 0x0703 + + EXP = 0x0800 + EXP2 = 0x0801 + LINEAR = 0x2601 + + FOG_COLOR = 0x0B66 + FOG_DENSITY = 0x0B62 + FOG_END = 0x0B64 + FOG_INDEX = 0x0B61 + FOG_MODE = 0x0B65 + FOG_START = 0x0B63 + + CCW = 0x0901 + CW = 0x0900 + + COEFF = 0x0A00 + DOMAIN = 0x0A02 + ORDER = 0x0A01 + + PIXEL_MAP_A_TO_A = 0x0C79 + PIXEL_MAP_B_TO_B = 0x0C78 + PIXEL_MAP_G_TO_G = 0x0C77 + PIXEL_MAP_I_TO_A = 0x0C75 + PIXEL_MAP_I_TO_B = 0x0C74 + PIXEL_MAP_I_TO_G = 0x0C73 + PIXEL_MAP_I_TO_I = 0x0C70 + PIXEL_MAP_I_TO_R = 0x0C72 + PIXEL_MAP_R_TO_R = 0x0C76 + PIXEL_MAP_S_TO_S = 0x0C71 + + ACCUM_ALPHA_BITS = 0x0D5B + ACCUM_BLUE_BITS = 0x0D5A + ACCUM_CLEAR_VALUE = 0x0B80 + ACCUM_GREEN_BITS = 0x0D59 + ACCUM_RED_BITS = 0x0D58 + ALPHA_BIAS = 0x0D1D + ALPHA_BITS = 0x0D55 + ALPHA_SCALE = 0x0D1C + ALPHA_TEST_FUNC = 0x0BC1 + ALPHA_TEST_REF = 0x0BC2 + ATTRIB_STACK_DEPTH = 0x0BB0 + AUX_BUFFERS = 0x0C00 + BLEND_DST = 0x0BE0 + BLEND_SRC = 0x0BE1 + BLUE_BIAS = 0x0D1B + BLUE_BITS = 0x0D54 + BLUE_SCALE = 0x0D1A + CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1 + COLOR_ARRAY_SIZE = 0x8081 + COLOR_ARRAY_STRIDE = 0x8083 + COLOR_ARRAY_TYPE = 0x8082 + COLOR_CLEAR_VALUE = 0x0C22 + COLOR_MATERIAL_FACE = 0x0B55 + COLOR_MATERIAL_PARAMETER = 0x0B56 + COLOR_WRITEMASK = 0x0C23 + CULL_FACE_MODE = 0x0B45 + CURRENT_COLOR = 0x0B00 + CURRENT_INDEX = 0x0B01 + CURRENT_NORMAL = 0x0B02 + CURRENT_RASTER_COLOR = 0x0B04 + CURRENT_RASTER_DISTANCE = 0x0B09 + CURRENT_RASTER_INDEX = 0x0B05 + CURRENT_RASTER_POSITION = 0x0B07 + CURRENT_RASTER_POSITION_VALID = 0x0B08 + CURRENT_RASTER_TEXTURE_COORDS = 0x0B06 + CURRENT_TEXTURE_COORDS = 0x0B03 + DEPTH_BIAS = 0x0D1F + DEPTH_BITS = 0x0D56 + DEPTH_CLEAR_VALUE = 0x0B73 + DEPTH_FUNC = 0x0B74 + DEPTH_RANGE = 0x0B70 + DEPTH_SCALE = 0x0D1E + DEPTH_WRITEMASK = 0x0B72 + DOUBLEBUFFER = 0x0C32 + DRAW_BUFFER = 0x0C01 + EDGE_FLAG = 0x0B43 + EDGE_FLAG_ARRAY_STRIDE = 0x808C + FEEDBACK_BUFFER_SIZE = 0x0DF1 + FEEDBACK_BUFFER_TYPE = 0x0DF2 + FOG_HINT = 0x0C54 + FRONT_FACE = 0x0B46 + GREEN_BIAS = 0x0D19 + GREEN_BITS = 0x0D53 + GREEN_SCALE = 0x0D18 + INDEX_ARRAY_STRIDE = 0x8086 + INDEX_ARRAY_TYPE = 0x8085 + INDEX_BITS = 0x0D51 + INDEX_CLEAR_VALUE = 0x0C20 + INDEX_MODE = 0x0C30 + INDEX_OFFSET = 0x0D13 + INDEX_SHIFT = 0x0D12 + INDEX_WRITEMASK = 0x0C21 + LIGHT_MODEL_AMBIENT = 0x0B53 + LIGHT_MODEL_LOCAL_VIEWER = 0x0B51 + LIGHT_MODEL_TWO_SIDE = 0x0B52 + LINE_SMOOTH_HINT = 0x0C52 + LINE_STIPPLE_PATTERN = 0x0B25 + LINE_STIPPLE_REPEAT = 0x0B26 + LINE_WIDTH = 0x0B21 + LINE_WIDTH_GRANULARITY = 0x0B23 + LINE_WIDTH_RANGE = 0x0B22 + LIST_BASE = 0x0B32 + LIST_INDEX = 0x0B33 + LIST_MODE = 0x0B30 + LOGIC_OP_MODE = 0x0BF0 + MAP1_GRID_DOMAIN = 0x0DD0 + MAP1_GRID_SEGMENTS = 0x0DD1 + MAP2_GRID_DOMAIN = 0x0DD2 + MAP2_GRID_SEGMENTS = 0x0DD3 + MAP_COLOR = 0x0D10 + MAP_STENCIL = 0x0D11 + MATRIX_MODE = 0x0BA0 + MAX_ATTRIB_STACK_DEPTH = 0x0D35 + MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B + MAX_CLIP_PLANES = 0x0D32 + MAX_EVAL_ORDER = 0x0D30 + MAX_LIGHTS = 0x0D31 + MAX_LIST_NESTING = 0x0B31 + MAX_MODELVIEW_STACK_DEPTH = 0x0D36 + MAX_NAME_STACK_DEPTH = 0x0D37 + MAX_PIXEL_MAP_TABLE = 0x0D34 + MAX_PROJECTION_STACK_DEPTH = 0x0D38 + MAX_TEXTURE_SIZE = 0x0D33 + MAX_TEXTURE_STACK_DEPTH = 0x0D39 + MAX_VIEWPORT_DIMS = 0x0D3A + MODELVIEW_MATRIX = 0x0BA6 + MODELVIEW_STACK_DEPTH = 0x0BA3 + NAME_STACK_DEPTH = 0x0D70 + NORMAL_ARRAY_STRIDE = 0x807F + NORMAL_ARRAY_TYPE = 0x807E + PACK_ALIGNMENT = 0x0D05 + PACK_LSB_FIRST = 0x0D01 + PACK_ROW_LENGTH = 0x0D02 + PACK_SKIP_PIXELS = 0x0D04 + PACK_SKIP_ROWS = 0x0D03 + PACK_SWAP_BYTES = 0x0D00 + PERSPECTIVE_CORRECTION_HINT = 0x0C50 + PIXEL_MAP_A_TO_A_SIZE = 0x0CB9 + PIXEL_MAP_B_TO_B_SIZE = 0x0CB8 + PIXEL_MAP_G_TO_G_SIZE = 0x0CB7 + PIXEL_MAP_I_TO_A_SIZE = 0x0CB5 + PIXEL_MAP_I_TO_B_SIZE = 0x0CB4 + PIXEL_MAP_I_TO_G_SIZE = 0x0CB3 + PIXEL_MAP_I_TO_I_SIZE = 0x0CB0 + PIXEL_MAP_I_TO_R_SIZE = 0x0CB2 + PIXEL_MAP_R_TO_R_SIZE = 0x0CB6 + PIXEL_MAP_S_TO_S_SIZE = 0x0CB1 + POINT_SIZE = 0x0B11 + POINT_SIZE_GRANULARITY = 0x0B13 + POINT_SIZE_RANGE = 0x0B12 + POINT_SMOOTH_HINT = 0x0C51 + POLYGON_MODE = 0x0B40 + POLYGON_OFFSET_FACTOR = 0x8038 + POLYGON_OFFSET_UNITS = 0x2A00 + POLYGON_SMOOTH_HINT = 0x0C53 + PROJECTION_MATRIX = 0x0BA7 + PROJECTION_STACK_DEPTH = 0x0BA4 + READ_BUFFER = 0x0C02 + RED_BIAS = 0x0D15 + RED_BITS = 0x0D52 + RED_SCALE = 0x0D14 + RENDER_MODE = 0x0C40 + RGBA_MODE = 0x0C31 + SCISSOR_BOX = 0x0C10 + SELECTION_BUFFER_SIZE = 0x0DF4 + SHADE_MODEL = 0x0B54 + STENCIL_BITS = 0x0D57 + STENCIL_CLEAR_VALUE = 0x0B91 + STENCIL_FAIL = 0x0B94 + STENCIL_FUNC = 0x0B92 + STENCIL_PASS_DEPTH_FAIL = 0x0B95 + STENCIL_PASS_DEPTH_PASS = 0x0B96 + STENCIL_REF = 0x0B97 + STENCIL_VALUE_MASK = 0x0B93 + STENCIL_WRITEMASK = 0x0B98 + STEREO = 0x0C33 + SUBPIXEL_BITS = 0x0D50 + TEXTURE_BINDING_1D = 0x8068 + TEXTURE_BINDING_2D = 0x8069 + TEXTURE_COORD_ARRAY_SIZE = 0x8088 + TEXTURE_COORD_ARRAY_STRIDE = 0x808A + TEXTURE_COORD_ARRAY_TYPE = 0x8089 + TEXTURE_MATRIX = 0x0BA8 + TEXTURE_STACK_DEPTH = 0x0BA5 + UNPACK_ALIGNMENT = 0x0CF5 + UNPACK_LSB_FIRST = 0x0CF1 + UNPACK_ROW_LENGTH = 0x0CF2 + UNPACK_SKIP_PIXELS = 0x0CF4 + UNPACK_SKIP_ROWS = 0x0CF3 + UNPACK_SWAP_BYTES = 0x0CF0 + VERTEX_ARRAY_SIZE = 0x807A + VERTEX_ARRAY_STRIDE = 0x807C + VERTEX_ARRAY_TYPE = 0x807B + VIEWPORT = 0x0BA2 + ZOOM_X = 0x0D16 + ZOOM_Y = 0x0D17 + + COLOR_ARRAY_POINTER = 0x8090 + EDGE_FLAG_ARRAY_POINTER = 0x8093 + FEEDBACK_BUFFER_POINTER = 0x0DF0 + INDEX_ARRAY_POINTER = 0x8091 + NORMAL_ARRAY_POINTER = 0x808F + SELECTION_BUFFER_POINTER = 0x0DF3 + TEXTURE_COORD_ARRAY_POINTER = 0x8092 + VERTEX_ARRAY_POINTER = 0x808E + + TEXTURE_ALPHA_SIZE = 0x805F + TEXTURE_BLUE_SIZE = 0x805E + TEXTURE_BORDER = 0x1005 + TEXTURE_BORDER_COLOR = 0x1004 + TEXTURE_COMPONENTS = 0x1003 + TEXTURE_GREEN_SIZE = 0x805D + TEXTURE_HEIGHT = 0x1001 + TEXTURE_INTENSITY_SIZE = 0x8061 + TEXTURE_INTERNAL_FORMAT = 0x1003 + TEXTURE_LUMINANCE_SIZE = 0x8060 + TEXTURE_MAG_FILTER = 0x2800 + TEXTURE_MIN_FILTER = 0x2801 + TEXTURE_PRIORITY = 0x8066 + TEXTURE_RED_SIZE = 0x805C + TEXTURE_RESIDENT = 0x8067 + TEXTURE_WIDTH = 0x1000 + TEXTURE_WRAP_S = 0x2802 + TEXTURE_WRAP_T = 0x2803 + + DONT_CARE = 0x1100 + FASTEST = 0x1101 + NICEST = 0x1102 + + C3F_V3F = 0x2A24 + C4F_N3F_V3F = 0x2A26 + C4UB_V2F = 0x2A22 + C4UB_V3F = 0x2A23 + N3F_V3F = 0x2A25 + T2F_C3F_V3F = 0x2A2A + T2F_C4F_N3F_V3F = 0x2A2C + T2F_C4UB_V3F = 0x2A29 + T2F_N3F_V3F = 0x2A2B + T2F_V3F = 0x2A27 + T4F_C4F_N3F_V4F = 0x2A2D + T4F_V4F = 0x2A28 + V2F = 0x2A20 + V3F = 0x2A21 + + MODULATE = 0x2100 + REPLACE = 0x1E01 + + CONSTANT_ATTENUATION = 0x1207 + LINEAR_ATTENUATION = 0x1208 + POSITION = 0x1203 + QUADRATIC_ATTENUATION = 0x1209 + SPOT_CUTOFF = 0x1206 + SPOT_DIRECTION = 0x1204 + SPOT_EXPONENT = 0x1205 + + COMPILE = 0x1300 + COMPILE_AND_EXECUTE = 0x1301 + + AND = 0x1501 + AND_INVERTED = 0x1504 + AND_REVERSE = 0x1502 + CLEAR = 0x1500 + COPY = 0x1503 + COPY_INVERTED = 0x150C + EQUIV = 0x1509 + INVERT = 0x150A + NAND = 0x150E + NOOP = 0x1505 + NOR = 0x1508 + OR = 0x1507 + OR_INVERTED = 0x150D + OR_REVERSE = 0x150B + SET = 0x150F + XOR = 0x1506 + + COLOR_INDEXES = 0x1603 + SHININESS = 0x1601 + + MODELVIEW = 0x1700 + PROJECTION = 0x1701 + TEXTURE = 0x1702 + + LINE = 0x1B01 + POINT = 0x1B00 + + FILL = 0x1B02 + + COLOR = 0x1800 + DEPTH = 0x1801 + STENCIL = 0x1802 + + ALPHA = 0x1906 + BLUE = 0x1905 + COLOR_INDEX = 0x1900 + DEPTH_COMPONENT = 0x1902 + GREEN = 0x1904 + LUMINANCE = 0x1909 + LUMINANCE_ALPHA = 0x190A + RED = 0x1903 + RGB = 0x1907 + RGBA = 0x1908 + STENCIL_INDEX = 0x1901 + + ALPHA12 = 0x803D + ALPHA16 = 0x803E + ALPHA4 = 0x803B + ALPHA8 = 0x803C + INTENSITY = 0x8049 + INTENSITY12 = 0x804C + INTENSITY16 = 0x804D + INTENSITY4 = 0x804A + INTENSITY8 = 0x804B + LUMINANCE12 = 0x8041 + LUMINANCE12_ALPHA12 = 0x8047 + LUMINANCE12_ALPHA4 = 0x8046 + LUMINANCE16 = 0x8042 + LUMINANCE16_ALPHA16 = 0x8048 + LUMINANCE4 = 0x803F + LUMINANCE4_ALPHA4 = 0x8043 + LUMINANCE6_ALPHA2 = 0x8044 + LUMINANCE8 = 0x8040 + LUMINANCE8_ALPHA8 = 0x8045 + R3_G3_B2 = 0x2A10 + RGB10 = 0x8052 + RGB10_A2 = 0x8059 + RGB12 = 0x8053 + RGB16 = 0x8054 + RGB4 = 0x804F + RGB5 = 0x8050 + RGB5_A1 = 0x8057 + RGB8 = 0x8051 + RGBA12 = 0x805A + RGBA16 = 0x805B + RGBA2 = 0x8055 + RGBA4 = 0x8056 + RGBA8 = 0x8058 + + BITMAP = 0x1A00 + + LINES = 0x0001 + LINE_LOOP = 0x0002 + LINE_STRIP = 0x0003 + POINTS = 0x0000 + POLYGON = 0x0009 + QUADS = 0x0007 + QUAD_STRIP = 0x0008 + TRIANGLES = 0x0004 + TRIANGLE_FAN = 0x0006 + TRIANGLE_STRIP = 0x0005 + + FEEDBACK = 0x1C01 + RENDER = 0x1C00 + SELECT = 0x1C02 + + FLAT = 0x1D00 + SMOOTH = 0x1D01 + + DECR = 0x1E03 + INCR = 0x1E02 + KEEP = 0x1E00 + + EXTENSIONS = 0x1F03 + RENDERER = 0x1F01 + VENDOR = 0x1F00 + VERSION = 0x1F02 + + S = 0x2000 + T = 0x2001 + R = 0x2002 + Q = 0x2003 + + DECAL = 0x2101 + + TEXTURE_ENV_COLOR = 0x2201 + TEXTURE_ENV_MODE = 0x2200 + + TEXTURE_ENV = 0x2300 + + EYE_LINEAR = 0x2400 + OBJECT_LINEAR = 0x2401 + SPHERE_MAP = 0x2402 + + EYE_PLANE = 0x2502 + OBJECT_PLANE = 0x2501 + TEXTURE_GEN_MODE = 0x2500 + + NEAREST = 0x2600 + + LINEAR_MIPMAP_LINEAR = 0x2703 + LINEAR_MIPMAP_NEAREST = 0x2701 + NEAREST_MIPMAP_LINEAR = 0x2702 + NEAREST_MIPMAP_NEAREST = 0x2700 + + PROXY_TEXTURE_1D = 0x8063 + PROXY_TEXTURE_2D = 0x8064 + + CLAMP = 0x2900 + REPEAT = 0x2901 +) + +// https://www.opengl.org/sdk/docs/man2/xhtml/glViewport.xml +func (gl *GL) Viewport(x, y, width, height int) { + C.gl1_0_glViewport(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// DepthRange specifies the mapping of depth values from normalized device +// coordinates to window coordinates. +// +// Parameter nearVal specifies the mapping of the near clipping plane to window +// coordinates (defaults to 0), while farVal specifies the mapping of the far +// clipping plane to window coordinates (defaults to 1). +// +// After clipping and division by w, depth coordinates range from -1 to 1, +// corresponding to the near and far clipping planes. DepthRange specifies a +// linear mapping of the normalized depth coordinates in this range to window +// depth coordinates. Regardless of the actual depth buffer implementation, +// window coordinate depth values are treated as though they range from 0 through 1 +// (like color components). Thus, the values accepted by DepthRange are both +// clamped to this range before they are accepted. +// +// The default setting of (0, 1) maps the near plane to 0 and the far plane to 1. +// With this mapping, the depth buffer range is fully utilized. +// +// It is not necessary that nearVal be less than farVal. Reverse mappings such as +// nearVal 1, and farVal 0 are acceptable. +// +// GL.INVALID_OPERATION is generated if DepthRange is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) DepthRange(nearVal, farVal float64) { + C.gl1_0_glDepthRange(gl.funcs, C.GLdouble(nearVal), C.GLdouble(farVal)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsEnabled.xml +func (gl *GL) IsEnabled(cap glbase.Enum) bool { + glresult := C.gl1_0_glIsEnabled(gl.funcs, C.GLenum(cap)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexLevelParameteriv.xml +func (gl *GL) GetTexLevelParameteriv(target glbase.Enum, level int, pname glbase.Enum, params []int32) { + C.gl1_0_glGetTexLevelParameteriv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexLevelParameterfv.xml +func (gl *GL) GetTexLevelParameterfv(target glbase.Enum, level int, pname glbase.Enum, params []float32) { + C.gl1_0_glGetTexLevelParameterfv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexParameteriv.xml +func (gl *GL) GetTexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_0_glGetTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexParameterfv.xml +func (gl *GL) GetTexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_0_glGetTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexImage.xml +func (gl *GL) GetTexImage(target glbase.Enum, level int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_0_glGetTexImage(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetIntegerv.xml +func (gl *GL) GetIntegerv(pname glbase.Enum, params []int32) { + C.gl1_0_glGetIntegerv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetFloatv.xml +func (gl *GL) GetFloatv(pname glbase.Enum, params []float32) { + C.gl1_0_glGetFloatv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetError.xml +func (gl *GL) GetError() glbase.Enum { + glresult := C.gl1_0_glGetError(gl.funcs) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetDoublev.xml +func (gl *GL) GetDoublev(pname glbase.Enum, params []float64) { + C.gl1_0_glGetDoublev(gl.funcs, C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetBooleanv.xml +func (gl *GL) GetBooleanv(pname glbase.Enum, params []bool) { + C.gl1_0_glGetBooleanv(gl.funcs, C.GLenum(pname), (*C.GLboolean)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glReadPixels.xml +func (gl *GL) ReadPixels(x, y, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_0_glReadPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glReadBuffer.xml +func (gl *GL) ReadBuffer(mode glbase.Enum) { + C.gl1_0_glReadBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelStorei.xml +func (gl *GL) PixelStorei(pname glbase.Enum, param int32) { + C.gl1_0_glPixelStorei(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelStoref.xml +func (gl *GL) PixelStoref(pname glbase.Enum, param float32) { + C.gl1_0_glPixelStoref(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDepthFunc.xml +func (gl *GL) DepthFunc(glfunc glbase.Enum) { + C.gl1_0_glDepthFunc(gl.funcs, C.GLenum(glfunc)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilOp.xml +func (gl *GL) StencilOp(fail, zfail, zpass glbase.Enum) { + C.gl1_0_glStencilOp(gl.funcs, C.GLenum(fail), C.GLenum(zfail), C.GLenum(zpass)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilFunc.xml +func (gl *GL) StencilFunc(glfunc glbase.Enum, ref int32, mask uint32) { + C.gl1_0_glStencilFunc(gl.funcs, C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLogicOp.xml +func (gl *GL) LogicOp(opcode glbase.Enum) { + C.gl1_0_glLogicOp(gl.funcs, C.GLenum(opcode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBlendFunc.xml +func (gl *GL) BlendFunc(sfactor, dfactor glbase.Enum) { + C.gl1_0_glBlendFunc(gl.funcs, C.GLenum(sfactor), C.GLenum(dfactor)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFlush.xml +func (gl *GL) Flush() { + C.gl1_0_glFlush(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFinish.xml +func (gl *GL) Finish() { + C.gl1_0_glFinish(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEnable.xml +func (gl *GL) Enable(cap glbase.Enum) { + C.gl1_0_glEnable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDisable.xml +func (gl *GL) Disable(cap glbase.Enum) { + C.gl1_0_glDisable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDepthMask.xml +func (gl *GL) DepthMask(flag bool) { + C.gl1_0_glDepthMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorMask.xml +func (gl *GL) ColorMask(red, green, blue, alpha bool) { + C.gl1_0_glColorMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&red)), *(*C.GLboolean)(unsafe.Pointer(&green)), *(*C.GLboolean)(unsafe.Pointer(&blue)), *(*C.GLboolean)(unsafe.Pointer(&alpha))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilMask.xml +func (gl *GL) StencilMask(mask uint32) { + C.gl1_0_glStencilMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearDepth.xml +func (gl *GL) ClearDepth(depth float64) { + C.gl1_0_glClearDepth(gl.funcs, C.GLdouble(depth)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearStencil.xml +func (gl *GL) ClearStencil(s int32) { + C.gl1_0_glClearStencil(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearColor.xml +func (gl *GL) ClearColor(red, green, blue, alpha float32) { + C.gl1_0_glClearColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClear.xml +func (gl *GL) Clear(mask glbase.Bitfield) { + C.gl1_0_glClear(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawBuffer.xml +func (gl *GL) DrawBuffer(mode glbase.Enum) { + C.gl1_0_glDrawBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexImage2D.xml +func (gl *GL) TexImage2D(target glbase.Enum, level int, internalFormat int32, width, height, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_0_glTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexImage1D.xml +func (gl *GL) TexImage1D(target glbase.Enum, level int, internalFormat int32, width, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_0_glTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameteriv.xml +func (gl *GL) TexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_0_glTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameteri.xml +func (gl *GL) TexParameteri(target, pname glbase.Enum, param int32) { + C.gl1_0_glTexParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameterfv.xml +func (gl *GL) TexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_0_glTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameterf.xml +func (gl *GL) TexParameterf(target, pname glbase.Enum, param float32) { + C.gl1_0_glTexParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glScissor.xml +func (gl *GL) Scissor(x, y, width, height int) { + C.gl1_0_glScissor(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPolygonMode.xml +func (gl *GL) PolygonMode(face, mode glbase.Enum) { + C.gl1_0_glPolygonMode(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPointSize.xml +func (gl *GL) PointSize(size float32) { + C.gl1_0_glPointSize(gl.funcs, C.GLfloat(size)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLineWidth.xml +func (gl *GL) LineWidth(width float32) { + C.gl1_0_glLineWidth(gl.funcs, C.GLfloat(width)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glHint.xml +func (gl *GL) Hint(target, mode glbase.Enum) { + C.gl1_0_glHint(gl.funcs, C.GLenum(target), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFrontFace.xml +func (gl *GL) FrontFace(mode glbase.Enum) { + C.gl1_0_glFrontFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCullFace.xml +func (gl *GL) CullFace(mode glbase.Enum) { + C.gl1_0_glCullFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTranslatef.xml +func (gl *GL) Translatef(x, y, z float32) { + C.gl1_0_glTranslatef(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTranslated.xml +func (gl *GL) Translated(x, y, z float64) { + C.gl1_0_glTranslated(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glScalef.xml +func (gl *GL) Scalef(x, y, z float32) { + C.gl1_0_glScalef(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glScaled.xml +func (gl *GL) Scaled(x, y, z float64) { + C.gl1_0_glScaled(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRotatef.xml +func (gl *GL) Rotatef(angle, x, y, z float32) { + C.gl1_0_glRotatef(gl.funcs, C.GLfloat(angle), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRotated.xml +func (gl *GL) Rotated(angle, x, y, z float64) { + C.gl1_0_glRotated(gl.funcs, C.GLdouble(angle), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPushMatrix.xml +func (gl *GL) PushMatrix() { + C.gl1_0_glPushMatrix(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPopMatrix.xml +func (gl *GL) PopMatrix() { + C.gl1_0_glPopMatrix(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glOrtho.xml +func (gl *GL) Ortho(left, right, bottom, top, zNear, zFar float64) { + C.gl1_0_glOrtho(gl.funcs, C.GLdouble(left), C.GLdouble(right), C.GLdouble(bottom), C.GLdouble(top), C.GLdouble(zNear), C.GLdouble(zFar)) +} + +// MultMatrixd multiplies the current matrix with the provided matrix. +// +// The m parameter must hold 16 consecutive elements of a 4x4 column-major matrix. +// +// The current matrix is determined by the current matrix mode (see +// MatrixMode). It is either the projection matrix, modelview matrix, or the +// texture matrix. +// +// For example, if the current matrix is C and the coordinates to be transformed +// are v = (v[0], v[1], v[2], v[3]), then the current transformation is C × v, or +// +// c[0] c[4] c[8] c[12] v[0] +// c[1] c[5] c[9] c[13] v[1] +// c[2] c[6] c[10] c[14] X v[2] +// c[3] c[7] c[11] c[15] v[3] +// +// Calling MultMatrix with an argument of m = m[0], m[1], ..., m[15] +// replaces the current transformation with (C X M) x v, or +// +// c[0] c[4] c[8] c[12] m[0] m[4] m[8] m[12] v[0] +// c[1] c[5] c[9] c[13] m[1] m[5] m[9] m[13] v[1] +// c[2] c[6] c[10] c[14] X m[2] m[6] m[10] m[14] X v[2] +// c[3] c[7] c[11] c[15] m[3] m[7] m[11] m[15] v[3] +// +// Where 'X' denotes matrix multiplication, and v is represented as a 4x1 matrix. +// +// While the elements of the matrix may be specified with single or double +// precision, the GL may store or operate on these values in less-than-single +// precision. +// +// In many computer languages, 4×4 arrays are represented in row-major +// order. The transformations just described represent these matrices in +// column-major order. The order of the multiplication is important. For +// example, if the current transformation is a rotation, and MultMatrix is +// called with a translation matrix, the translation is done directly on the +// coordinates to be transformed, while the rotation is done on the results +// of that translation. +// +// GL.INVALID_OPERATION is generated if MultMatrix is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) MultMatrixd(m []float64) { + if len(m) != 16 { + panic("parameter m must have length 16 for the 4x4 matrix") + } + C.gl1_0_glMultMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// MultMatrixf multiplies the current matrix with the provided matrix. +// +// The m parameter must hold 16 consecutive elements of a 4x4 column-major matrix. +// +// The current matrix is determined by the current matrix mode (see +// MatrixMode). It is either the projection matrix, modelview matrix, or the +// texture matrix. +// +// For example, if the current matrix is C and the coordinates to be transformed +// are v = (v[0], v[1], v[2], v[3]), then the current transformation is C × v, or +// +// c[0] c[4] c[8] c[12] v[0] +// c[1] c[5] c[9] c[13] v[1] +// c[2] c[6] c[10] c[14] X v[2] +// c[3] c[7] c[11] c[15] v[3] +// +// Calling MultMatrix with an argument of m = m[0], m[1], ..., m[15] +// replaces the current transformation with (C X M) x v, or +// +// c[0] c[4] c[8] c[12] m[0] m[4] m[8] m[12] v[0] +// c[1] c[5] c[9] c[13] m[1] m[5] m[9] m[13] v[1] +// c[2] c[6] c[10] c[14] X m[2] m[6] m[10] m[14] X v[2] +// c[3] c[7] c[11] c[15] m[3] m[7] m[11] m[15] v[3] +// +// Where 'X' denotes matrix multiplication, and v is represented as a 4x1 matrix. +// +// While the elements of the matrix may be specified with single or double +// precision, the GL may store or operate on these values in less-than-single +// precision. +// +// In many computer languages, 4×4 arrays are represented in row-major +// order. The transformations just described represent these matrices in +// column-major order. The order of the multiplication is important. For +// example, if the current transformation is a rotation, and MultMatrix is +// called with a translation matrix, the translation is done directly on the +// coordinates to be transformed, while the rotation is done on the results +// of that translation. +// +// GL.INVALID_OPERATION is generated if MultMatrix is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) MultMatrixf(m []float32) { + if len(m) != 16 { + panic("parameter m must have length 16 for the 4x4 matrix") + } + C.gl1_0_glMultMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMatrixMode.xml +func (gl *GL) MatrixMode(mode glbase.Enum) { + C.gl1_0_glMatrixMode(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadMatrixd.xml +func (gl *GL) LoadMatrixd(m []float64) { + C.gl1_0_glLoadMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadMatrixf.xml +func (gl *GL) LoadMatrixf(m []float32) { + C.gl1_0_glLoadMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadIdentity.xml +func (gl *GL) LoadIdentity() { + C.gl1_0_glLoadIdentity(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFrustum.xml +func (gl *GL) Frustum(left, right, bottom, top, zNear, zFar float64) { + C.gl1_0_glFrustum(gl.funcs, C.GLdouble(left), C.GLdouble(right), C.GLdouble(bottom), C.GLdouble(top), C.GLdouble(zNear), C.GLdouble(zFar)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsList.xml +func (gl *GL) IsList(list uint32) bool { + glresult := C.gl1_0_glIsList(gl.funcs, C.GLuint(list)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexGeniv.xml +func (gl *GL) GetTexGeniv(coord, pname glbase.Enum, params []int32) { + C.gl1_0_glGetTexGeniv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexGenfv.xml +func (gl *GL) GetTexGenfv(coord, pname glbase.Enum, params []float32) { + C.gl1_0_glGetTexGenfv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexGendv.xml +func (gl *GL) GetTexGendv(coord, pname glbase.Enum, params []float64) { + C.gl1_0_glGetTexGendv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexEnviv.xml +func (gl *GL) GetTexEnviv(target, pname glbase.Enum, params []int32) { + C.gl1_0_glGetTexEnviv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexEnvfv.xml +func (gl *GL) GetTexEnvfv(target, pname glbase.Enum, params []float32) { + C.gl1_0_glGetTexEnvfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetPolygonStipple.xml +func (gl *GL) GetPolygonStipple(mask []uint8) { + C.gl1_0_glGetPolygonStipple(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&mask[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetPixelMapusv.xml +func (gl *GL) GetPixelMapusv(glmap glbase.Enum, values []uint16) { + C.gl1_0_glGetPixelMapusv(gl.funcs, C.GLenum(glmap), (*C.GLushort)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetPixelMapuiv.xml +func (gl *GL) GetPixelMapuiv(glmap glbase.Enum, values []uint32) { + C.gl1_0_glGetPixelMapuiv(gl.funcs, C.GLenum(glmap), (*C.GLuint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetPixelMapfv.xml +func (gl *GL) GetPixelMapfv(glmap glbase.Enum, values []float32) { + C.gl1_0_glGetPixelMapfv(gl.funcs, C.GLenum(glmap), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMaterialiv.xml +func (gl *GL) GetMaterialiv(face, pname glbase.Enum, params []int32) { + C.gl1_0_glGetMaterialiv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMaterialfv.xml +func (gl *GL) GetMaterialfv(face, pname glbase.Enum, params []float32) { + C.gl1_0_glGetMaterialfv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMapiv.xml +func (gl *GL) GetMapiv(target, query glbase.Enum, v []int32) { + C.gl1_0_glGetMapiv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMapfv.xml +func (gl *GL) GetMapfv(target, query glbase.Enum, v []float32) { + C.gl1_0_glGetMapfv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMapdv.xml +func (gl *GL) GetMapdv(target, query glbase.Enum, v []float64) { + C.gl1_0_glGetMapdv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetLightiv.xml +func (gl *GL) GetLightiv(light, pname glbase.Enum, params []int32) { + C.gl1_0_glGetLightiv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetLightfv.xml +func (gl *GL) GetLightfv(light, pname glbase.Enum, params []float32) { + C.gl1_0_glGetLightfv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetClipPlane.xml +func (gl *GL) GetClipPlane(plane glbase.Enum, equation []float64) { + C.gl1_0_glGetClipPlane(gl.funcs, C.GLenum(plane), (*C.GLdouble)(unsafe.Pointer(&equation[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawPixels.xml +func (gl *GL) DrawPixels(width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_0_glDrawPixels(gl.funcs, C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyPixels.xml +func (gl *GL) CopyPixels(x, y, width, height int, gltype glbase.Enum) { + C.gl1_0_glCopyPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(gltype)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelMapusv.xml +func (gl *GL) PixelMapusv(glmap glbase.Enum, mapsize int32, values []uint16) { + C.gl1_0_glPixelMapusv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLushort)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelMapuiv.xml +func (gl *GL) PixelMapuiv(glmap glbase.Enum, mapsize int32, values []uint32) { + C.gl1_0_glPixelMapuiv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLuint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelMapfv.xml +func (gl *GL) PixelMapfv(glmap glbase.Enum, mapsize int32, values []float32) { + C.gl1_0_glPixelMapfv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelTransferi.xml +func (gl *GL) PixelTransferi(pname glbase.Enum, param int32) { + C.gl1_0_glPixelTransferi(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelTransferf.xml +func (gl *GL) PixelTransferf(pname glbase.Enum, param float32) { + C.gl1_0_glPixelTransferf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelZoom.xml +func (gl *GL) PixelZoom(xfactor, yfactor float32) { + C.gl1_0_glPixelZoom(gl.funcs, C.GLfloat(xfactor), C.GLfloat(yfactor)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glAlphaFunc.xml +func (gl *GL) AlphaFunc(glfunc glbase.Enum, ref float32) { + C.gl1_0_glAlphaFunc(gl.funcs, C.GLenum(glfunc), C.GLfloat(ref)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalPoint2.xml +func (gl *GL) EvalPoint2(i, j int32) { + C.gl1_0_glEvalPoint2(gl.funcs, C.GLint(i), C.GLint(j)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalMesh2.xml +func (gl *GL) EvalMesh2(mode glbase.Enum, i1, i2, j1, j2 int32) { + C.gl1_0_glEvalMesh2(gl.funcs, C.GLenum(mode), C.GLint(i1), C.GLint(i2), C.GLint(j1), C.GLint(j2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalPoint1.xml +func (gl *GL) EvalPoint1(i int32) { + C.gl1_0_glEvalPoint1(gl.funcs, C.GLint(i)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalMesh1.xml +func (gl *GL) EvalMesh1(mode glbase.Enum, i1, i2 int32) { + C.gl1_0_glEvalMesh1(gl.funcs, C.GLenum(mode), C.GLint(i1), C.GLint(i2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord2fv.xml +func (gl *GL) EvalCoord2fv(u []float32) { + if len(u) != 2 { + panic("parameter u has incorrect length") + } + C.gl1_0_glEvalCoord2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord2f.xml +func (gl *GL) EvalCoord2f(u, v float32) { + C.gl1_0_glEvalCoord2f(gl.funcs, C.GLfloat(u), C.GLfloat(v)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord2dv.xml +func (gl *GL) EvalCoord2dv(u []float64) { + if len(u) != 2 { + panic("parameter u has incorrect length") + } + C.gl1_0_glEvalCoord2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord2d.xml +func (gl *GL) EvalCoord2d(u, v float64) { + C.gl1_0_glEvalCoord2d(gl.funcs, C.GLdouble(u), C.GLdouble(v)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord1fv.xml +func (gl *GL) EvalCoord1fv(u []float32) { + C.gl1_0_glEvalCoord1fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord1f.xml +func (gl *GL) EvalCoord1f(u float32) { + C.gl1_0_glEvalCoord1f(gl.funcs, C.GLfloat(u)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord1dv.xml +func (gl *GL) EvalCoord1dv(u []float64) { + C.gl1_0_glEvalCoord1dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord1d.xml +func (gl *GL) EvalCoord1d(u float64) { + C.gl1_0_glEvalCoord1d(gl.funcs, C.GLdouble(u)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMapGrid2f.xml +func (gl *GL) MapGrid2f(un int32, u1, u2 float32, vn int32, v1, v2 float32) { + C.gl1_0_glMapGrid2f(gl.funcs, C.GLint(un), C.GLfloat(u1), C.GLfloat(u2), C.GLint(vn), C.GLfloat(v1), C.GLfloat(v2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMapGrid2d.xml +func (gl *GL) MapGrid2d(un int32, u1, u2 float64, vn int32, v1, v2 float64) { + C.gl1_0_glMapGrid2d(gl.funcs, C.GLint(un), C.GLdouble(u1), C.GLdouble(u2), C.GLint(vn), C.GLdouble(v1), C.GLdouble(v2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMapGrid1f.xml +func (gl *GL) MapGrid1f(un int32, u1, u2 float32) { + C.gl1_0_glMapGrid1f(gl.funcs, C.GLint(un), C.GLfloat(u1), C.GLfloat(u2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMapGrid1d.xml +func (gl *GL) MapGrid1d(un int32, u1, u2 float64) { + C.gl1_0_glMapGrid1d(gl.funcs, C.GLint(un), C.GLdouble(u1), C.GLdouble(u2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMap2f.xml +func (gl *GL) Map2f(target glbase.Enum, u1, u2 float32, ustride, uorder int32, v1, v2 float32, vstride, vorder int32, points []float32) { + C.gl1_0_glMap2f(gl.funcs, C.GLenum(target), C.GLfloat(u1), C.GLfloat(u2), C.GLint(ustride), C.GLint(uorder), C.GLfloat(v1), C.GLfloat(v2), C.GLint(vstride), C.GLint(vorder), (*C.GLfloat)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMap2d.xml +func (gl *GL) Map2d(target glbase.Enum, u1, u2 float64, ustride, uorder int32, v1, v2 float64, vstride, vorder int32, points []float64) { + C.gl1_0_glMap2d(gl.funcs, C.GLenum(target), C.GLdouble(u1), C.GLdouble(u2), C.GLint(ustride), C.GLint(uorder), C.GLdouble(v1), C.GLdouble(v2), C.GLint(vstride), C.GLint(vorder), (*C.GLdouble)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMap1f.xml +func (gl *GL) Map1f(target glbase.Enum, u1, u2 float32, stride, order int, points []float32) { + C.gl1_0_glMap1f(gl.funcs, C.GLenum(target), C.GLfloat(u1), C.GLfloat(u2), C.GLint(stride), C.GLint(order), (*C.GLfloat)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMap1d.xml +func (gl *GL) Map1d(target glbase.Enum, u1, u2 float64, stride, order int, points []float64) { + C.gl1_0_glMap1d(gl.funcs, C.GLenum(target), C.GLdouble(u1), C.GLdouble(u2), C.GLint(stride), C.GLint(order), (*C.GLdouble)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPushAttrib.xml +func (gl *GL) PushAttrib(mask glbase.Bitfield) { + C.gl1_0_glPushAttrib(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPopAttrib.xml +func (gl *GL) PopAttrib() { + C.gl1_0_glPopAttrib(gl.funcs) +} + +// Accum executes an operation on the accumulation buffer. +// +// Parameter op defines the accumulation buffer operation (GL.ACCUM, GL.LOAD, +// GL.ADD, GL.MULT, or GL.RETURN) and specifies how the value parameter is +// used. +// +// The accumulation buffer is an extended-range color buffer. Images are not +// rendered into it. Rather, images rendered into one of the color buffers +// are added to the contents of the accumulation buffer after rendering. +// Effects such as antialiasing (of points, lines, and polygons), motion +// blur, and depth of field can be created by accumulating images generated +// with different transformation matrices. +// +// Each pixel in the accumulation buffer consists of red, green, blue, and +// alpha values. The number of bits per component in the accumulation buffer +// depends on the implementation. You can examine this number by calling +// GetIntegerv four times, with arguments GL.ACCUM_RED_BITS, +// GL.ACCUM_GREEN_BITS, GL.ACCUM_BLUE_BITS, and GL.ACCUM_ALPHA_BITS. +// Regardless of the number of bits per component, the range of values stored +// by each component is (-1, 1). The accumulation buffer pixels are mapped +// one-to-one with frame buffer pixels. +// +// All accumulation buffer operations are limited to the area of the current +// scissor box and applied identically to the red, green, blue, and alpha +// components of each pixel. If a Accum operation results in a value outside +// the range (-1, 1), the contents of an accumulation buffer pixel component +// are undefined. +// +// The operations are as follows: +// +// GL.ACCUM +// Obtains R, G, B, and A values from the buffer currently selected for +// reading (see ReadBuffer). Each component value is divided by 2 n - +// 1 , where n is the number of bits allocated to each color component +// in the currently selected buffer. The result is a floating-point +// value in the range 0 1 , which is multiplied by value and added to +// the corresponding pixel component in the accumulation buffer, +// thereby updating the accumulation buffer. +// +// GL.LOAD +// Similar to GL.ACCUM, except that the current value in the +// accumulation buffer is not used in the calculation of the new value. +// That is, the R, G, B, and A values from the currently selected +// buffer are divided by 2 n - 1 , multiplied by value, and then stored +// in the corresponding accumulation buffer cell, overwriting the +// current value. +// +// GL.ADD +// Adds value to each R, G, B, and A in the accumulation buffer. +// +// GL.MULT +// Multiplies each R, G, B, and A in the accumulation buffer by value +// and returns the scaled component to its corresponding accumulation +// buffer location. +// +// GL.RETURN +// Transfers accumulation buffer values to the color buffer or buffers +// currently selected for writing. Each R, G, B, and A component is +// multiplied by value, then multiplied by 2 n - 1 , clamped to the +// range 0 2 n - 1 , and stored in the corresponding display buffer +// cell. The only fragment operations that are applied to this transfer +// are pixel ownership, scissor, dithering, and color writemasks. +// +// To clear the accumulation buffer, call ClearAccum with R, G, B, and A +// values to set it to, then call Clear with the accumulation buffer +// enabled. +// +// Error GL.INVALID_ENUM is generated if op is not an accepted value. +// GL.INVALID_OPERATION is generated if there is no accumulation buffer. +// GL.INVALID_OPERATION is generated if Accum is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) Accum(op glbase.Enum, value float32) { + C.gl1_0_glAccum(gl.funcs, C.GLenum(op), C.GLfloat(value)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexMask.xml +func (gl *GL) IndexMask(mask uint32) { + C.gl1_0_glIndexMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearIndex.xml +func (gl *GL) ClearIndex(c float32) { + C.gl1_0_glClearIndex(gl.funcs, C.GLfloat(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearAccum.xml +func (gl *GL) ClearAccum(red, green, blue, alpha float32) { + C.gl1_0_glClearAccum(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPushName.xml +func (gl *GL) PushName(name uint32) { + C.gl1_0_glPushName(gl.funcs, C.GLuint(name)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPopName.xml +func (gl *GL) PopName() { + C.gl1_0_glPopName(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPassThrough.xml +func (gl *GL) PassThrough(token float32) { + C.gl1_0_glPassThrough(gl.funcs, C.GLfloat(token)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadName.xml +func (gl *GL) LoadName(name uint32) { + C.gl1_0_glLoadName(gl.funcs, C.GLuint(name)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glInitNames.xml +func (gl *GL) InitNames() { + C.gl1_0_glInitNames(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRenderMode.xml +func (gl *GL) RenderMode(mode glbase.Enum) int32 { + glresult := C.gl1_0_glRenderMode(gl.funcs, C.GLenum(mode)) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSelectBuffer.xml +func (gl *GL) SelectBuffer(size int, buffer []glbase.Buffer) { + C.gl1_0_glSelectBuffer(gl.funcs, C.GLsizei(size), (*C.GLuint)(unsafe.Pointer(&buffer[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFeedbackBuffer.xml +func (gl *GL) FeedbackBuffer(size int, gltype glbase.Enum, buffer []float32) { + C.gl1_0_glFeedbackBuffer(gl.funcs, C.GLsizei(size), C.GLenum(gltype), (*C.GLfloat)(unsafe.Pointer(&buffer[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGeniv.xml +func (gl *GL) TexGeniv(coord, pname glbase.Enum, params []int32) { + C.gl1_0_glTexGeniv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGeni.xml +func (gl *GL) TexGeni(coord, pname glbase.Enum, param int32) { + C.gl1_0_glTexGeni(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGenfv.xml +func (gl *GL) TexGenfv(coord, pname glbase.Enum, params []float32) { + C.gl1_0_glTexGenfv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGenf.xml +func (gl *GL) TexGenf(coord, pname glbase.Enum, param float32) { + C.gl1_0_glTexGenf(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGendv.xml +func (gl *GL) TexGendv(coord, pname glbase.Enum, params []float64) { + C.gl1_0_glTexGendv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGend.xml +func (gl *GL) TexGend(coord, pname glbase.Enum, param float64) { + C.gl1_0_glTexGend(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLdouble(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnviv.xml +func (gl *GL) TexEnviv(target, pname glbase.Enum, params []int32) { + C.gl1_0_glTexEnviv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnvi.xml +func (gl *GL) TexEnvi(target, pname glbase.Enum, param int32) { + C.gl1_0_glTexEnvi(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnvfv.xml +func (gl *GL) TexEnvfv(target, pname glbase.Enum, params []float32) { + C.gl1_0_glTexEnvfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnvf.xml +func (gl *GL) TexEnvf(target, pname glbase.Enum, param float32) { + C.gl1_0_glTexEnvf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glShadeModel.xml +func (gl *GL) ShadeModel(mode glbase.Enum) { + C.gl1_0_glShadeModel(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPolygonStipple.xml +func (gl *GL) PolygonStipple(mask []uint8) { + C.gl1_0_glPolygonStipple(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&mask[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMaterialiv.xml +func (gl *GL) Materialiv(face, pname glbase.Enum, params []int32) { + C.gl1_0_glMaterialiv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMateriali.xml +func (gl *GL) Materiali(face, pname glbase.Enum, param int32) { + C.gl1_0_glMateriali(gl.funcs, C.GLenum(face), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMaterialfv.xml +func (gl *GL) Materialfv(face, pname glbase.Enum, params []float32) { + C.gl1_0_glMaterialfv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMaterialf.xml +func (gl *GL) Materialf(face, pname glbase.Enum, param float32) { + C.gl1_0_glMaterialf(gl.funcs, C.GLenum(face), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLineStipple.xml +func (gl *GL) LineStipple(factor int32, pattern uint16) { + C.gl1_0_glLineStipple(gl.funcs, C.GLint(factor), C.GLushort(pattern)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightModeliv.xml +func (gl *GL) LightModeliv(pname glbase.Enum, params []int32) { + C.gl1_0_glLightModeliv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightModeli.xml +func (gl *GL) LightModeli(pname glbase.Enum, param int32) { + C.gl1_0_glLightModeli(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightModelfv.xml +func (gl *GL) LightModelfv(pname glbase.Enum, params []float32) { + C.gl1_0_glLightModelfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightModelf.xml +func (gl *GL) LightModelf(pname glbase.Enum, param float32) { + C.gl1_0_glLightModelf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightiv.xml +func (gl *GL) Lightiv(light, pname glbase.Enum, params []int32) { + C.gl1_0_glLightiv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLighti.xml +func (gl *GL) Lighti(light, pname glbase.Enum, param int32) { + C.gl1_0_glLighti(gl.funcs, C.GLenum(light), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightfv.xml +func (gl *GL) Lightfv(light, pname glbase.Enum, params []float32) { + C.gl1_0_glLightfv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightf.xml +func (gl *GL) Lightf(light, pname glbase.Enum, param float32) { + C.gl1_0_glLightf(gl.funcs, C.GLenum(light), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogiv.xml +func (gl *GL) Fogiv(pname glbase.Enum, params []int32) { + C.gl1_0_glFogiv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogi.xml +func (gl *GL) Fogi(pname glbase.Enum, param int32) { + C.gl1_0_glFogi(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogfv.xml +func (gl *GL) Fogfv(pname glbase.Enum, params []float32) { + C.gl1_0_glFogfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogf.xml +func (gl *GL) Fogf(pname glbase.Enum, param float32) { + C.gl1_0_glFogf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorMaterial.xml +func (gl *GL) ColorMaterial(face, mode glbase.Enum) { + C.gl1_0_glColorMaterial(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClipPlane.xml +func (gl *GL) ClipPlane(plane glbase.Enum, equation []float64) { + C.gl1_0_glClipPlane(gl.funcs, C.GLenum(plane), (*C.GLdouble)(unsafe.Pointer(&equation[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4sv.xml +func (gl *GL) Vertex4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_0_glVertex4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4s.xml +func (gl *GL) Vertex4s(x, y, z, w int16) { + C.gl1_0_glVertex4s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4iv.xml +func (gl *GL) Vertex4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_0_glVertex4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4i.xml +func (gl *GL) Vertex4i(x, y, z, w int) { + C.gl1_0_glVertex4i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4fv.xml +func (gl *GL) Vertex4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_0_glVertex4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4f.xml +func (gl *GL) Vertex4f(x, y, z, w float32) { + C.gl1_0_glVertex4f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4dv.xml +func (gl *GL) Vertex4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_0_glVertex4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4d.xml +func (gl *GL) Vertex4d(x, y, z, w float64) { + C.gl1_0_glVertex4d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3sv.xml +func (gl *GL) Vertex3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_0_glVertex3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3s.xml +func (gl *GL) Vertex3s(x, y, z int16) { + C.gl1_0_glVertex3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3iv.xml +func (gl *GL) Vertex3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_0_glVertex3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3i.xml +func (gl *GL) Vertex3i(x, y, z int) { + C.gl1_0_glVertex3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3fv.xml +func (gl *GL) Vertex3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_0_glVertex3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3f.xml +func (gl *GL) Vertex3f(x, y, z float32) { + C.gl1_0_glVertex3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3dv.xml +func (gl *GL) Vertex3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_0_glVertex3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3d.xml +func (gl *GL) Vertex3d(x, y, z float64) { + C.gl1_0_glVertex3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2sv.xml +func (gl *GL) Vertex2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_0_glVertex2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2s.xml +func (gl *GL) Vertex2s(x, y int16) { + C.gl1_0_glVertex2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2iv.xml +func (gl *GL) Vertex2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_0_glVertex2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2i.xml +func (gl *GL) Vertex2i(x, y int) { + C.gl1_0_glVertex2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2fv.xml +func (gl *GL) Vertex2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_0_glVertex2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2f.xml +func (gl *GL) Vertex2f(x, y float32) { + C.gl1_0_glVertex2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2dv.xml +func (gl *GL) Vertex2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_0_glVertex2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2d.xml +func (gl *GL) Vertex2d(x, y float64) { + C.gl1_0_glVertex2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4sv.xml +func (gl *GL) TexCoord4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_0_glTexCoord4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4s.xml +func (gl *GL) TexCoord4s(s, t, r, q int16) { + C.gl1_0_glTexCoord4s(gl.funcs, C.GLshort(s), C.GLshort(t), C.GLshort(r), C.GLshort(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4iv.xml +func (gl *GL) TexCoord4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_0_glTexCoord4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4i.xml +func (gl *GL) TexCoord4i(s, t, r, q int32) { + C.gl1_0_glTexCoord4i(gl.funcs, C.GLint(s), C.GLint(t), C.GLint(r), C.GLint(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4fv.xml +func (gl *GL) TexCoord4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_0_glTexCoord4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4f.xml +func (gl *GL) TexCoord4f(s, t, r, q float32) { + C.gl1_0_glTexCoord4f(gl.funcs, C.GLfloat(s), C.GLfloat(t), C.GLfloat(r), C.GLfloat(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4dv.xml +func (gl *GL) TexCoord4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_0_glTexCoord4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4d.xml +func (gl *GL) TexCoord4d(s, t, r, q float64) { + C.gl1_0_glTexCoord4d(gl.funcs, C.GLdouble(s), C.GLdouble(t), C.GLdouble(r), C.GLdouble(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3sv.xml +func (gl *GL) TexCoord3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_0_glTexCoord3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3s.xml +func (gl *GL) TexCoord3s(s, t, r int16) { + C.gl1_0_glTexCoord3s(gl.funcs, C.GLshort(s), C.GLshort(t), C.GLshort(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3iv.xml +func (gl *GL) TexCoord3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_0_glTexCoord3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3i.xml +func (gl *GL) TexCoord3i(s, t, r int32) { + C.gl1_0_glTexCoord3i(gl.funcs, C.GLint(s), C.GLint(t), C.GLint(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3fv.xml +func (gl *GL) TexCoord3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_0_glTexCoord3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3f.xml +func (gl *GL) TexCoord3f(s, t, r float32) { + C.gl1_0_glTexCoord3f(gl.funcs, C.GLfloat(s), C.GLfloat(t), C.GLfloat(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3dv.xml +func (gl *GL) TexCoord3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_0_glTexCoord3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3d.xml +func (gl *GL) TexCoord3d(s, t, r float64) { + C.gl1_0_glTexCoord3d(gl.funcs, C.GLdouble(s), C.GLdouble(t), C.GLdouble(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2sv.xml +func (gl *GL) TexCoord2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_0_glTexCoord2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2s.xml +func (gl *GL) TexCoord2s(s, t int16) { + C.gl1_0_glTexCoord2s(gl.funcs, C.GLshort(s), C.GLshort(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2iv.xml +func (gl *GL) TexCoord2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_0_glTexCoord2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2i.xml +func (gl *GL) TexCoord2i(s, t int32) { + C.gl1_0_glTexCoord2i(gl.funcs, C.GLint(s), C.GLint(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2fv.xml +func (gl *GL) TexCoord2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_0_glTexCoord2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2f.xml +func (gl *GL) TexCoord2f(s, t float32) { + C.gl1_0_glTexCoord2f(gl.funcs, C.GLfloat(s), C.GLfloat(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2dv.xml +func (gl *GL) TexCoord2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_0_glTexCoord2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2d.xml +func (gl *GL) TexCoord2d(s, t float64) { + C.gl1_0_glTexCoord2d(gl.funcs, C.GLdouble(s), C.GLdouble(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1sv.xml +func (gl *GL) TexCoord1sv(v []int16) { + C.gl1_0_glTexCoord1sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1s.xml +func (gl *GL) TexCoord1s(s int16) { + C.gl1_0_glTexCoord1s(gl.funcs, C.GLshort(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1iv.xml +func (gl *GL) TexCoord1iv(v []int32) { + C.gl1_0_glTexCoord1iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1i.xml +func (gl *GL) TexCoord1i(s int32) { + C.gl1_0_glTexCoord1i(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1fv.xml +func (gl *GL) TexCoord1fv(v []float32) { + C.gl1_0_glTexCoord1fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1f.xml +func (gl *GL) TexCoord1f(s float32) { + C.gl1_0_glTexCoord1f(gl.funcs, C.GLfloat(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1dv.xml +func (gl *GL) TexCoord1dv(v []float64) { + C.gl1_0_glTexCoord1dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1d.xml +func (gl *GL) TexCoord1d(s float64) { + C.gl1_0_glTexCoord1d(gl.funcs, C.GLdouble(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectsv.xml +func (gl *GL) Rectsv(v1, v2 []int16) { + C.gl1_0_glRectsv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v1[0])), (*C.GLshort)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRects.xml +func (gl *GL) Rects(x1, y1, x2, y2 int16) { + C.gl1_0_glRects(gl.funcs, C.GLshort(x1), C.GLshort(y1), C.GLshort(x2), C.GLshort(y2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectiv.xml +func (gl *GL) Rectiv(v1, v2 []int32) { + C.gl1_0_glRectiv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v1[0])), (*C.GLint)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRecti.xml +func (gl *GL) Recti(x1, y1, x2, y2 int32) { + C.gl1_0_glRecti(gl.funcs, C.GLint(x1), C.GLint(y1), C.GLint(x2), C.GLint(y2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectfv.xml +func (gl *GL) Rectfv(v1, v2 []float32) { + C.gl1_0_glRectfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v1[0])), (*C.GLfloat)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectf.xml +func (gl *GL) Rectf(x1, y1, x2, y2 float32) { + C.gl1_0_glRectf(gl.funcs, C.GLfloat(x1), C.GLfloat(y1), C.GLfloat(x2), C.GLfloat(y2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectdv.xml +func (gl *GL) Rectdv(v1, v2 []float64) { + C.gl1_0_glRectdv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v1[0])), (*C.GLdouble)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectd.xml +func (gl *GL) Rectd(x1, y1, x2, y2 float64) { + C.gl1_0_glRectd(gl.funcs, C.GLdouble(x1), C.GLdouble(y1), C.GLdouble(x2), C.GLdouble(y2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4sv.xml +func (gl *GL) RasterPos4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_0_glRasterPos4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4s.xml +func (gl *GL) RasterPos4s(x, y, z, w int16) { + C.gl1_0_glRasterPos4s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4iv.xml +func (gl *GL) RasterPos4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_0_glRasterPos4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4i.xml +func (gl *GL) RasterPos4i(x, y, z, w int) { + C.gl1_0_glRasterPos4i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4fv.xml +func (gl *GL) RasterPos4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_0_glRasterPos4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4f.xml +func (gl *GL) RasterPos4f(x, y, z, w float32) { + C.gl1_0_glRasterPos4f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4dv.xml +func (gl *GL) RasterPos4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_0_glRasterPos4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4d.xml +func (gl *GL) RasterPos4d(x, y, z, w float64) { + C.gl1_0_glRasterPos4d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3sv.xml +func (gl *GL) RasterPos3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_0_glRasterPos3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3s.xml +func (gl *GL) RasterPos3s(x, y, z int16) { + C.gl1_0_glRasterPos3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3iv.xml +func (gl *GL) RasterPos3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_0_glRasterPos3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3i.xml +func (gl *GL) RasterPos3i(x, y, z int) { + C.gl1_0_glRasterPos3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3fv.xml +func (gl *GL) RasterPos3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_0_glRasterPos3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3f.xml +func (gl *GL) RasterPos3f(x, y, z float32) { + C.gl1_0_glRasterPos3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3dv.xml +func (gl *GL) RasterPos3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_0_glRasterPos3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3d.xml +func (gl *GL) RasterPos3d(x, y, z float64) { + C.gl1_0_glRasterPos3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2sv.xml +func (gl *GL) RasterPos2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_0_glRasterPos2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2s.xml +func (gl *GL) RasterPos2s(x, y int16) { + C.gl1_0_glRasterPos2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2iv.xml +func (gl *GL) RasterPos2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_0_glRasterPos2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2i.xml +func (gl *GL) RasterPos2i(x, y int) { + C.gl1_0_glRasterPos2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2fv.xml +func (gl *GL) RasterPos2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_0_glRasterPos2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2f.xml +func (gl *GL) RasterPos2f(x, y float32) { + C.gl1_0_glRasterPos2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2dv.xml +func (gl *GL) RasterPos2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_0_glRasterPos2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2d.xml +func (gl *GL) RasterPos2d(x, y float64) { + C.gl1_0_glRasterPos2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3sv.xml +func (gl *GL) Normal3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_0_glNormal3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3s.xml +func (gl *GL) Normal3s(nx, ny, nz int16) { + C.gl1_0_glNormal3s(gl.funcs, C.GLshort(nx), C.GLshort(ny), C.GLshort(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3iv.xml +func (gl *GL) Normal3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_0_glNormal3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3i.xml +func (gl *GL) Normal3i(nx, ny, nz int32) { + C.gl1_0_glNormal3i(gl.funcs, C.GLint(nx), C.GLint(ny), C.GLint(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3fv.xml +func (gl *GL) Normal3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_0_glNormal3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3f.xml +func (gl *GL) Normal3f(nx, ny, nz float32) { + C.gl1_0_glNormal3f(gl.funcs, C.GLfloat(nx), C.GLfloat(ny), C.GLfloat(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3dv.xml +func (gl *GL) Normal3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_0_glNormal3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3d.xml +func (gl *GL) Normal3d(nx, ny, nz float64) { + C.gl1_0_glNormal3d(gl.funcs, C.GLdouble(nx), C.GLdouble(ny), C.GLdouble(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3bv.xml +func (gl *GL) Normal3bv(v []byte) { + C.gl1_0_glNormal3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3b.xml +func (gl *GL) Normal3b(nx, ny, nz byte) { + C.gl1_0_glNormal3b(gl.funcs, C.GLbyte(nx), C.GLbyte(ny), C.GLbyte(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexsv.xml +func (gl *GL) Indexsv(c []int16) { + C.gl1_0_glIndexsv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexs.xml +func (gl *GL) Indexs(c int16) { + C.gl1_0_glIndexs(gl.funcs, C.GLshort(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexiv.xml +func (gl *GL) Indexiv(c []int32) { + C.gl1_0_glIndexiv(gl.funcs, (*C.GLint)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexi.xml +func (gl *GL) Indexi(c int32) { + C.gl1_0_glIndexi(gl.funcs, C.GLint(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexfv.xml +func (gl *GL) Indexfv(c []float32) { + C.gl1_0_glIndexfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexf.xml +func (gl *GL) Indexf(c float32) { + C.gl1_0_glIndexf(gl.funcs, C.GLfloat(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexdv.xml +func (gl *GL) Indexdv(c []float64) { + C.gl1_0_glIndexdv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexd.xml +func (gl *GL) Indexd(c float64) { + C.gl1_0_glIndexd(gl.funcs, C.GLdouble(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEnd.xml +func (gl *GL) End() { + C.gl1_0_glEnd(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEdgeFlagv.xml +func (gl *GL) EdgeFlagv(flag []bool) { + C.gl1_0_glEdgeFlagv(gl.funcs, (*C.GLboolean)(unsafe.Pointer(&flag[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEdgeFlag.xml +func (gl *GL) EdgeFlag(flag bool) { + C.gl1_0_glEdgeFlag(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4usv.xml +func (gl *GL) Color4usv(v []uint16) { + C.gl1_0_glColor4usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4us.xml +func (gl *GL) Color4us(red, green, blue, alpha uint16) { + C.gl1_0_glColor4us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue), C.GLushort(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4uiv.xml +func (gl *GL) Color4uiv(v []uint32) { + C.gl1_0_glColor4uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4ui.xml +func (gl *GL) Color4ui(red, green, blue, alpha uint32) { + C.gl1_0_glColor4ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue), C.GLuint(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4ubv.xml +func (gl *GL) Color4ubv(v []uint8) { + C.gl1_0_glColor4ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4ub.xml +func (gl *GL) Color4ub(red, green, blue, alpha uint8) { + C.gl1_0_glColor4ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue), C.GLubyte(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4sv.xml +func (gl *GL) Color4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_0_glColor4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4s.xml +func (gl *GL) Color4s(red, green, blue, alpha int16) { + C.gl1_0_glColor4s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue), C.GLshort(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4iv.xml +func (gl *GL) Color4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_0_glColor4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4i.xml +func (gl *GL) Color4i(red, green, blue, alpha int32) { + C.gl1_0_glColor4i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue), C.GLint(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4fv.xml +func (gl *GL) Color4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_0_glColor4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4f.xml +func (gl *GL) Color4f(red, green, blue, alpha float32) { + C.gl1_0_glColor4f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4dv.xml +func (gl *GL) Color4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_0_glColor4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4d.xml +func (gl *GL) Color4d(red, green, blue, alpha float64) { + C.gl1_0_glColor4d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue), C.GLdouble(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4bv.xml +func (gl *GL) Color4bv(v []byte) { + C.gl1_0_glColor4bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4b.xml +func (gl *GL) Color4b(red, green, blue, alpha byte) { + C.gl1_0_glColor4b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue), C.GLbyte(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3usv.xml +func (gl *GL) Color3usv(v []uint16) { + C.gl1_0_glColor3usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3us.xml +func (gl *GL) Color3us(red, green, blue uint16) { + C.gl1_0_glColor3us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3uiv.xml +func (gl *GL) Color3uiv(v []uint32) { + C.gl1_0_glColor3uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3ui.xml +func (gl *GL) Color3ui(red, green, blue uint32) { + C.gl1_0_glColor3ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3ubv.xml +func (gl *GL) Color3ubv(v []uint8) { + C.gl1_0_glColor3ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3ub.xml +func (gl *GL) Color3ub(red, green, blue uint8) { + C.gl1_0_glColor3ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3sv.xml +func (gl *GL) Color3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_0_glColor3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3s.xml +func (gl *GL) Color3s(red, green, blue int16) { + C.gl1_0_glColor3s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3iv.xml +func (gl *GL) Color3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_0_glColor3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3i.xml +func (gl *GL) Color3i(red, green, blue int32) { + C.gl1_0_glColor3i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3fv.xml +func (gl *GL) Color3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_0_glColor3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3f.xml +func (gl *GL) Color3f(red, green, blue float32) { + C.gl1_0_glColor3f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3dv.xml +func (gl *GL) Color3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_0_glColor3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3d.xml +func (gl *GL) Color3d(red, green, blue float64) { + C.gl1_0_glColor3d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3bv.xml +func (gl *GL) Color3bv(v []byte) { + C.gl1_0_glColor3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3b.xml +func (gl *GL) Color3b(red, green, blue byte) { + C.gl1_0_glColor3b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBitmap.xml +func (gl *GL) Bitmap(width, height int, xorig, yorig, xmove, ymove float32, bitmap []uint8) { + C.gl1_0_glBitmap(gl.funcs, C.GLsizei(width), C.GLsizei(height), C.GLfloat(xorig), C.GLfloat(yorig), C.GLfloat(xmove), C.GLfloat(ymove), (*C.GLubyte)(unsafe.Pointer(&bitmap[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBegin.xml +func (gl *GL) Begin(mode glbase.Enum) { + C.gl1_0_glBegin(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glListBase.xml +func (gl *GL) ListBase(base uint32) { + C.gl1_0_glListBase(gl.funcs, C.GLuint(base)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGenLists.xml +func (gl *GL) GenLists(range_ int32) uint32 { + glresult := C.gl1_0_glGenLists(gl.funcs, C.GLsizei(range_)) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDeleteLists.xml +func (gl *GL) DeleteLists(list uint32, range_ int32) { + C.gl1_0_glDeleteLists(gl.funcs, C.GLuint(list), C.GLsizei(range_)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCallLists.xml +func (gl *GL) CallLists(n int, gltype glbase.Enum, lists interface{}) { + var lists_ptr unsafe.Pointer + var lists_v = reflect.ValueOf(lists) + if lists != nil && lists_v.Kind() != reflect.Slice { + panic("parameter lists must be a slice") + } + if lists != nil { + lists_ptr = unsafe.Pointer(lists_v.Index(0).Addr().Pointer()) + } + C.gl1_0_glCallLists(gl.funcs, C.GLsizei(n), C.GLenum(gltype), lists_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCallList.xml +func (gl *GL) CallList(list uint32) { + C.gl1_0_glCallList(gl.funcs, C.GLuint(list)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEndList.xml +func (gl *GL) EndList() { + C.gl1_0_glEndList(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNewList.xml +func (gl *GL) NewList(list uint32, mode glbase.Enum) { + C.gl1_0_glNewList(gl.funcs, C.GLuint(list), C.GLenum(mode)) +} diff --git a/gl/1.1/funcs.cpp b/gl/1.1/funcs.cpp new file mode 100644 index 00000000..1c0f0adb --- /dev/null +++ b/gl/1.1/funcs.cpp @@ -0,0 +1,2022 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#include +#include + +#include "funcs.h" + +void *gl1_1_funcs() { + QOpenGLFunctions_1_1* funcs = QOpenGLContext::currentContext()->versionFunctions(); + if (!funcs) { + return 0; + } + funcs->initializeOpenGLFunctions(); + return funcs; +} + + +void gl1_1_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewport(x, y, width, height); +} + +void gl1_1_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRange(nearVal, farVal); +} + +GLboolean gl1_1_glIsEnabled(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabled(cap); +} + +void gl1_1_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameteriv(target, level, pname, params); +} + +void gl1_1_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameterfv(target, level, pname, params); +} + +void gl1_1_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameteriv(target, pname, params); +} + +void gl1_1_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterfv(target, pname, params); +} + +void gl1_1_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexImage(target, level, format, gltype, pixels); +} + +void gl1_1_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegerv(pname, params); +} + +void gl1_1_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFloatv(pname, params); +} + +GLenum gl1_1_glGetError(void *_glfuncs) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetError(); +} + +void gl1_1_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetDoublev(pname, params); +} + +void gl1_1_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleanv(pname, params); +} + +void gl1_1_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadPixels(x, y, width, height, format, gltype, pixels); +} + +void gl1_1_glReadBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadBuffer(mode); +} + +void gl1_1_glPixelStorei(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStorei(pname, param); +} + +void gl1_1_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStoref(pname, param); +} + +void gl1_1_glDepthFunc(void *_glfuncs, GLenum glfunc) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthFunc(glfunc); +} + +void gl1_1_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOp(fail, zfail, zpass); +} + +void gl1_1_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFunc(glfunc, ref, mask); +} + +void gl1_1_glLogicOp(void *_glfuncs, GLenum opcode) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLogicOp(opcode); +} + +void gl1_1_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFunc(sfactor, dfactor); +} + +void gl1_1_glFlush(void *_glfuncs) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlush(); +} + +void gl1_1_glFinish(void *_glfuncs) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFinish(); +} + +void gl1_1_glEnable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnable(cap); +} + +void gl1_1_glDisable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisable(cap); +} + +void gl1_1_glDepthMask(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthMask(flag); +} + +void gl1_1_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMask(red, green, blue, alpha); +} + +void gl1_1_glStencilMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMask(mask); +} + +void gl1_1_glClearDepth(void *_glfuncs, GLdouble depth) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearDepth(depth); +} + +void gl1_1_glClearStencil(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearStencil(s); +} + +void gl1_1_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearColor(red, green, blue, alpha); +} + +void gl1_1_glClear(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClear(mask); +} + +void gl1_1_glDrawBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffer(mode); +} + +void gl1_1_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage2D(target, level, internalFormat, width, height, border, format, gltype, pixels); +} + +void gl1_1_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage1D(target, level, internalFormat, width, border, format, gltype, pixels); +} + +void gl1_1_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteriv(target, pname, params); +} + +void gl1_1_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteri(target, pname, param); +} + +void gl1_1_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterfv(target, pname, params); +} + +void gl1_1_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterf(target, pname, param); +} + +void gl1_1_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissor(x, y, width, height); +} + +void gl1_1_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonMode(face, mode); +} + +void gl1_1_glPointSize(void *_glfuncs, GLfloat size) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointSize(size); +} + +void gl1_1_glLineWidth(void *_glfuncs, GLfloat width) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineWidth(width); +} + +void gl1_1_glHint(void *_glfuncs, GLenum target, GLenum mode) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glHint(target, mode); +} + +void gl1_1_glFrontFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrontFace(mode); +} + +void gl1_1_glCullFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCullFace(mode); +} + +void gl1_1_glIndexubv(void *_glfuncs, const GLubyte* c) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexubv(c); +} + +void gl1_1_glIndexub(void *_glfuncs, GLubyte c) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexub(c); +} + +GLboolean gl1_1_glIsTexture(void *_glfuncs, GLuint texture) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsTexture(texture); +} + +void gl1_1_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenTextures(n, textures); +} + +void gl1_1_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteTextures(n, textures); +} + +void gl1_1_glBindTexture(void *_glfuncs, GLenum target, GLuint texture) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindTexture(target, texture); +} + +void gl1_1_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, gltype, pixels); +} + +void gl1_1_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage1D(target, level, xoffset, width, format, gltype, pixels); +} + +void gl1_1_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); +} + +void gl1_1_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage1D(target, level, xoffset, x, y, width); +} + +void gl1_1_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage2D(target, level, internalFormat, x, y, width, height, border); +} + +void gl1_1_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage1D(target, level, internalFormat, x, y, width, border); +} + +void gl1_1_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonOffset(factor, units); +} + +void gl1_1_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElements(mode, count, gltype, indices); +} + +void gl1_1_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArrays(mode, first, count); +} + +void gl1_1_glTranslatef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTranslatef(x, y, z); +} + +void gl1_1_glTranslated(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTranslated(x, y, z); +} + +void gl1_1_glScalef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScalef(x, y, z); +} + +void gl1_1_glScaled(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScaled(x, y, z); +} + +void gl1_1_glRotatef(void *_glfuncs, GLfloat angle, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRotatef(angle, x, y, z); +} + +void gl1_1_glRotated(void *_glfuncs, GLdouble angle, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRotated(angle, x, y, z); +} + +void gl1_1_glPushMatrix(void *_glfuncs) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushMatrix(); +} + +void gl1_1_glPopMatrix(void *_glfuncs) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopMatrix(); +} + +void gl1_1_glOrtho(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glOrtho(left, right, bottom, top, zNear, zFar); +} + +void gl1_1_glMultMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultMatrixd(m); +} + +void gl1_1_glMultMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultMatrixf(m); +} + +void gl1_1_glMatrixMode(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMatrixMode(mode); +} + +void gl1_1_glLoadMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadMatrixd(m); +} + +void gl1_1_glLoadMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadMatrixf(m); +} + +void gl1_1_glLoadIdentity(void *_glfuncs) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadIdentity(); +} + +void gl1_1_glFrustum(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrustum(left, right, bottom, top, zNear, zFar); +} + +GLboolean gl1_1_glIsList(void *_glfuncs, GLuint list) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsList(list); +} + +void gl1_1_glGetTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGeniv(coord, pname, params); +} + +void gl1_1_glGetTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGenfv(coord, pname, params); +} + +void gl1_1_glGetTexGendv(void *_glfuncs, GLenum coord, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGendv(coord, pname, params); +} + +void gl1_1_glGetTexEnviv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexEnviv(target, pname, params); +} + +void gl1_1_glGetTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexEnvfv(target, pname, params); +} + +void gl1_1_glGetPolygonStipple(void *_glfuncs, GLubyte* mask) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPolygonStipple(mask); +} + +void gl1_1_glGetPixelMapusv(void *_glfuncs, GLenum glmap, GLushort* values) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapusv(glmap, values); +} + +void gl1_1_glGetPixelMapuiv(void *_glfuncs, GLenum glmap, GLuint* values) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapuiv(glmap, values); +} + +void gl1_1_glGetPixelMapfv(void *_glfuncs, GLenum glmap, GLfloat* values) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapfv(glmap, values); +} + +void gl1_1_glGetMaterialiv(void *_glfuncs, GLenum face, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMaterialiv(face, pname, params); +} + +void gl1_1_glGetMaterialfv(void *_glfuncs, GLenum face, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMaterialfv(face, pname, params); +} + +void gl1_1_glGetMapiv(void *_glfuncs, GLenum target, GLenum query, GLint* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapiv(target, query, v); +} + +void gl1_1_glGetMapfv(void *_glfuncs, GLenum target, GLenum query, GLfloat* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapfv(target, query, v); +} + +void gl1_1_glGetMapdv(void *_glfuncs, GLenum target, GLenum query, GLdouble* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapdv(target, query, v); +} + +void gl1_1_glGetLightiv(void *_glfuncs, GLenum light, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetLightiv(light, pname, params); +} + +void gl1_1_glGetLightfv(void *_glfuncs, GLenum light, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetLightfv(light, pname, params); +} + +void gl1_1_glGetClipPlane(void *_glfuncs, GLenum plane, GLdouble* equation) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetClipPlane(plane, equation); +} + +void gl1_1_glDrawPixels(void *_glfuncs, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawPixels(width, height, format, gltype, pixels); +} + +void gl1_1_glCopyPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum gltype) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyPixels(x, y, width, height, gltype); +} + +void gl1_1_glPixelMapusv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLushort* values) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapusv(glmap, mapsize, values); +} + +void gl1_1_glPixelMapuiv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLuint* values) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapuiv(glmap, mapsize, values); +} + +void gl1_1_glPixelMapfv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLfloat* values) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapfv(glmap, mapsize, values); +} + +void gl1_1_glPixelTransferi(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelTransferi(pname, param); +} + +void gl1_1_glPixelTransferf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelTransferf(pname, param); +} + +void gl1_1_glPixelZoom(void *_glfuncs, GLfloat xfactor, GLfloat yfactor) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelZoom(xfactor, yfactor); +} + +void gl1_1_glAlphaFunc(void *_glfuncs, GLenum glfunc, GLfloat ref) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAlphaFunc(glfunc, ref); +} + +void gl1_1_glEvalPoint2(void *_glfuncs, GLint i, GLint j) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalPoint2(i, j); +} + +void gl1_1_glEvalMesh2(void *_glfuncs, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalMesh2(mode, i1, i2, j1, j2); +} + +void gl1_1_glEvalPoint1(void *_glfuncs, GLint i) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalPoint1(i); +} + +void gl1_1_glEvalMesh1(void *_glfuncs, GLenum mode, GLint i1, GLint i2) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalMesh1(mode, i1, i2); +} + +void gl1_1_glEvalCoord2fv(void *_glfuncs, const GLfloat* u) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2fv(u); +} + +void gl1_1_glEvalCoord2f(void *_glfuncs, GLfloat u, GLfloat v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2f(u, v); +} + +void gl1_1_glEvalCoord2dv(void *_glfuncs, const GLdouble* u) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2dv(u); +} + +void gl1_1_glEvalCoord2d(void *_glfuncs, GLdouble u, GLdouble v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2d(u, v); +} + +void gl1_1_glEvalCoord1fv(void *_glfuncs, const GLfloat* u) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1fv(u); +} + +void gl1_1_glEvalCoord1f(void *_glfuncs, GLfloat u) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1f(u); +} + +void gl1_1_glEvalCoord1dv(void *_glfuncs, const GLdouble* u) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1dv(u); +} + +void gl1_1_glEvalCoord1d(void *_glfuncs, GLdouble u) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1d(u); +} + +void gl1_1_glMapGrid2f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid2f(un, u1, u2, vn, v1, v2); +} + +void gl1_1_glMapGrid2d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid2d(un, u1, u2, vn, v1, v2); +} + +void gl1_1_glMapGrid1f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid1f(un, u1, u2); +} + +void gl1_1_glMapGrid1d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid1d(un, u1, u2); +} + +void gl1_1_glMap2f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); +} + +void gl1_1_glMap2d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); +} + +void gl1_1_glMap1f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap1f(target, u1, u2, stride, order, points); +} + +void gl1_1_glMap1d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap1d(target, u1, u2, stride, order, points); +} + +void gl1_1_glPushAttrib(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushAttrib(mask); +} + +void gl1_1_glPopAttrib(void *_glfuncs) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopAttrib(); +} + +void gl1_1_glAccum(void *_glfuncs, GLenum op, GLfloat value) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAccum(op, value); +} + +void gl1_1_glIndexMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexMask(mask); +} + +void gl1_1_glClearIndex(void *_glfuncs, GLfloat c) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearIndex(c); +} + +void gl1_1_glClearAccum(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearAccum(red, green, blue, alpha); +} + +void gl1_1_glPushName(void *_glfuncs, GLuint name) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushName(name); +} + +void gl1_1_glPopName(void *_glfuncs) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopName(); +} + +void gl1_1_glPassThrough(void *_glfuncs, GLfloat token) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPassThrough(token); +} + +void gl1_1_glLoadName(void *_glfuncs, GLuint name) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadName(name); +} + +void gl1_1_glInitNames(void *_glfuncs) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInitNames(); +} + +GLint gl1_1_glRenderMode(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glRenderMode(mode); +} + +void gl1_1_glSelectBuffer(void *_glfuncs, GLsizei size, GLuint* buffer) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSelectBuffer(size, buffer); +} + +void gl1_1_glFeedbackBuffer(void *_glfuncs, GLsizei size, GLenum gltype, GLfloat* buffer) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFeedbackBuffer(size, gltype, buffer); +} + +void gl1_1_glTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGeniv(coord, pname, params); +} + +void gl1_1_glTexGeni(void *_glfuncs, GLenum coord, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGeni(coord, pname, param); +} + +void gl1_1_glTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGenfv(coord, pname, params); +} + +void gl1_1_glTexGenf(void *_glfuncs, GLenum coord, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGenf(coord, pname, param); +} + +void gl1_1_glTexGendv(void *_glfuncs, GLenum coord, GLenum pname, const GLdouble* params) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGendv(coord, pname, params); +} + +void gl1_1_glTexGend(void *_glfuncs, GLenum coord, GLenum pname, GLdouble param) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGend(coord, pname, param); +} + +void gl1_1_glTexEnviv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnviv(target, pname, params); +} + +void gl1_1_glTexEnvi(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvi(target, pname, param); +} + +void gl1_1_glTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvfv(target, pname, params); +} + +void gl1_1_glTexEnvf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvf(target, pname, param); +} + +void gl1_1_glShadeModel(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShadeModel(mode); +} + +void gl1_1_glPolygonStipple(void *_glfuncs, const GLubyte* mask) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonStipple(mask); +} + +void gl1_1_glMaterialiv(void *_glfuncs, GLenum face, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialiv(face, pname, params); +} + +void gl1_1_glMateriali(void *_glfuncs, GLenum face, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMateriali(face, pname, param); +} + +void gl1_1_glMaterialfv(void *_glfuncs, GLenum face, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialfv(face, pname, params); +} + +void gl1_1_glMaterialf(void *_glfuncs, GLenum face, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialf(face, pname, param); +} + +void gl1_1_glLineStipple(void *_glfuncs, GLint factor, GLushort pattern) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineStipple(factor, pattern); +} + +void gl1_1_glLightModeliv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModeliv(pname, params); +} + +void gl1_1_glLightModeli(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModeli(pname, param); +} + +void gl1_1_glLightModelfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModelfv(pname, params); +} + +void gl1_1_glLightModelf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModelf(pname, param); +} + +void gl1_1_glLightiv(void *_glfuncs, GLenum light, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightiv(light, pname, params); +} + +void gl1_1_glLighti(void *_glfuncs, GLenum light, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLighti(light, pname, param); +} + +void gl1_1_glLightfv(void *_glfuncs, GLenum light, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightfv(light, pname, params); +} + +void gl1_1_glLightf(void *_glfuncs, GLenum light, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightf(light, pname, param); +} + +void gl1_1_glFogiv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogiv(pname, params); +} + +void gl1_1_glFogi(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogi(pname, param); +} + +void gl1_1_glFogfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogfv(pname, params); +} + +void gl1_1_glFogf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogf(pname, param); +} + +void gl1_1_glColorMaterial(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMaterial(face, mode); +} + +void gl1_1_glClipPlane(void *_glfuncs, GLenum plane, const GLdouble* equation) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClipPlane(plane, equation); +} + +void gl1_1_glVertex4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4sv(v); +} + +void gl1_1_glVertex4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4s(x, y, z, w); +} + +void gl1_1_glVertex4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4iv(v); +} + +void gl1_1_glVertex4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4i(x, y, z, w); +} + +void gl1_1_glVertex4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4fv(v); +} + +void gl1_1_glVertex4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4f(x, y, z, w); +} + +void gl1_1_glVertex4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4dv(v); +} + +void gl1_1_glVertex4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4d(x, y, z, w); +} + +void gl1_1_glVertex3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3sv(v); +} + +void gl1_1_glVertex3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3s(x, y, z); +} + +void gl1_1_glVertex3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3iv(v); +} + +void gl1_1_glVertex3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3i(x, y, z); +} + +void gl1_1_glVertex3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3fv(v); +} + +void gl1_1_glVertex3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3f(x, y, z); +} + +void gl1_1_glVertex3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3dv(v); +} + +void gl1_1_glVertex3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3d(x, y, z); +} + +void gl1_1_glVertex2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2sv(v); +} + +void gl1_1_glVertex2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2s(x, y); +} + +void gl1_1_glVertex2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2iv(v); +} + +void gl1_1_glVertex2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2i(x, y); +} + +void gl1_1_glVertex2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2fv(v); +} + +void gl1_1_glVertex2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2f(x, y); +} + +void gl1_1_glVertex2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2dv(v); +} + +void gl1_1_glVertex2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2d(x, y); +} + +void gl1_1_glTexCoord4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4sv(v); +} + +void gl1_1_glTexCoord4s(void *_glfuncs, GLshort s, GLshort t, GLshort r, GLshort q) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4s(s, t, r, q); +} + +void gl1_1_glTexCoord4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4iv(v); +} + +void gl1_1_glTexCoord4i(void *_glfuncs, GLint s, GLint t, GLint r, GLint q) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4i(s, t, r, q); +} + +void gl1_1_glTexCoord4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4fv(v); +} + +void gl1_1_glTexCoord4f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4f(s, t, r, q); +} + +void gl1_1_glTexCoord4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4dv(v); +} + +void gl1_1_glTexCoord4d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r, GLdouble q) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4d(s, t, r, q); +} + +void gl1_1_glTexCoord3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3sv(v); +} + +void gl1_1_glTexCoord3s(void *_glfuncs, GLshort s, GLshort t, GLshort r) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3s(s, t, r); +} + +void gl1_1_glTexCoord3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3iv(v); +} + +void gl1_1_glTexCoord3i(void *_glfuncs, GLint s, GLint t, GLint r) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3i(s, t, r); +} + +void gl1_1_glTexCoord3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3fv(v); +} + +void gl1_1_glTexCoord3f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3f(s, t, r); +} + +void gl1_1_glTexCoord3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3dv(v); +} + +void gl1_1_glTexCoord3d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3d(s, t, r); +} + +void gl1_1_glTexCoord2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2sv(v); +} + +void gl1_1_glTexCoord2s(void *_glfuncs, GLshort s, GLshort t) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2s(s, t); +} + +void gl1_1_glTexCoord2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2iv(v); +} + +void gl1_1_glTexCoord2i(void *_glfuncs, GLint s, GLint t) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2i(s, t); +} + +void gl1_1_glTexCoord2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2fv(v); +} + +void gl1_1_glTexCoord2f(void *_glfuncs, GLfloat s, GLfloat t) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2f(s, t); +} + +void gl1_1_glTexCoord2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2dv(v); +} + +void gl1_1_glTexCoord2d(void *_glfuncs, GLdouble s, GLdouble t) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2d(s, t); +} + +void gl1_1_glTexCoord1sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1sv(v); +} + +void gl1_1_glTexCoord1s(void *_glfuncs, GLshort s) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1s(s); +} + +void gl1_1_glTexCoord1iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1iv(v); +} + +void gl1_1_glTexCoord1i(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1i(s); +} + +void gl1_1_glTexCoord1fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1fv(v); +} + +void gl1_1_glTexCoord1f(void *_glfuncs, GLfloat s) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1f(s); +} + +void gl1_1_glTexCoord1dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1dv(v); +} + +void gl1_1_glTexCoord1d(void *_glfuncs, GLdouble s) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1d(s); +} + +void gl1_1_glRectsv(void *_glfuncs, const GLshort* v1, const GLshort* v2) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectsv(v1, v2); +} + +void gl1_1_glRects(void *_glfuncs, GLshort x1, GLshort y1, GLshort x2, GLshort y2) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRects(x1, y1, x2, y2); +} + +void gl1_1_glRectiv(void *_glfuncs, const GLint* v1, const GLint* v2) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectiv(v1, v2); +} + +void gl1_1_glRecti(void *_glfuncs, GLint x1, GLint y1, GLint x2, GLint y2) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRecti(x1, y1, x2, y2); +} + +void gl1_1_glRectfv(void *_glfuncs, const GLfloat* v1, const GLfloat* v2) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectfv(v1, v2); +} + +void gl1_1_glRectf(void *_glfuncs, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectf(x1, y1, x2, y2); +} + +void gl1_1_glRectdv(void *_glfuncs, const GLdouble* v1, const GLdouble* v2) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectdv(v1, v2); +} + +void gl1_1_glRectd(void *_glfuncs, GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectd(x1, y1, x2, y2); +} + +void gl1_1_glRasterPos4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4sv(v); +} + +void gl1_1_glRasterPos4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4s(x, y, z, w); +} + +void gl1_1_glRasterPos4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4iv(v); +} + +void gl1_1_glRasterPos4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4i(x, y, z, w); +} + +void gl1_1_glRasterPos4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4fv(v); +} + +void gl1_1_glRasterPos4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4f(x, y, z, w); +} + +void gl1_1_glRasterPos4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4dv(v); +} + +void gl1_1_glRasterPos4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4d(x, y, z, w); +} + +void gl1_1_glRasterPos3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3sv(v); +} + +void gl1_1_glRasterPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3s(x, y, z); +} + +void gl1_1_glRasterPos3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3iv(v); +} + +void gl1_1_glRasterPos3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3i(x, y, z); +} + +void gl1_1_glRasterPos3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3fv(v); +} + +void gl1_1_glRasterPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3f(x, y, z); +} + +void gl1_1_glRasterPos3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3dv(v); +} + +void gl1_1_glRasterPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3d(x, y, z); +} + +void gl1_1_glRasterPos2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2sv(v); +} + +void gl1_1_glRasterPos2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2s(x, y); +} + +void gl1_1_glRasterPos2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2iv(v); +} + +void gl1_1_glRasterPos2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2i(x, y); +} + +void gl1_1_glRasterPos2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2fv(v); +} + +void gl1_1_glRasterPos2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2f(x, y); +} + +void gl1_1_glRasterPos2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2dv(v); +} + +void gl1_1_glRasterPos2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2d(x, y); +} + +void gl1_1_glNormal3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3sv(v); +} + +void gl1_1_glNormal3s(void *_glfuncs, GLshort nx, GLshort ny, GLshort nz) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3s(nx, ny, nz); +} + +void gl1_1_glNormal3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3iv(v); +} + +void gl1_1_glNormal3i(void *_glfuncs, GLint nx, GLint ny, GLint nz) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3i(nx, ny, nz); +} + +void gl1_1_glNormal3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3fv(v); +} + +void gl1_1_glNormal3f(void *_glfuncs, GLfloat nx, GLfloat ny, GLfloat nz) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3f(nx, ny, nz); +} + +void gl1_1_glNormal3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3dv(v); +} + +void gl1_1_glNormal3d(void *_glfuncs, GLdouble nx, GLdouble ny, GLdouble nz) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3d(nx, ny, nz); +} + +void gl1_1_glNormal3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3bv(v); +} + +void gl1_1_glNormal3b(void *_glfuncs, GLbyte nx, GLbyte ny, GLbyte nz) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3b(nx, ny, nz); +} + +void gl1_1_glIndexsv(void *_glfuncs, const GLshort* c) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexsv(c); +} + +void gl1_1_glIndexs(void *_glfuncs, GLshort c) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexs(c); +} + +void gl1_1_glIndexiv(void *_glfuncs, const GLint* c) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexiv(c); +} + +void gl1_1_glIndexi(void *_glfuncs, GLint c) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexi(c); +} + +void gl1_1_glIndexfv(void *_glfuncs, const GLfloat* c) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexfv(c); +} + +void gl1_1_glIndexf(void *_glfuncs, GLfloat c) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexf(c); +} + +void gl1_1_glIndexdv(void *_glfuncs, const GLdouble* c) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexdv(c); +} + +void gl1_1_glIndexd(void *_glfuncs, GLdouble c) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexd(c); +} + +void gl1_1_glEnd(void *_glfuncs) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnd(); +} + +void gl1_1_glEdgeFlagv(void *_glfuncs, const GLboolean* flag) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlagv(flag); +} + +void gl1_1_glEdgeFlag(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlag(flag); +} + +void gl1_1_glColor4usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4usv(v); +} + +void gl1_1_glColor4us(void *_glfuncs, GLushort red, GLushort green, GLushort blue, GLushort alpha) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4us(red, green, blue, alpha); +} + +void gl1_1_glColor4uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4uiv(v); +} + +void gl1_1_glColor4ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue, GLuint alpha) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ui(red, green, blue, alpha); +} + +void gl1_1_glColor4ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ubv(v); +} + +void gl1_1_glColor4ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ub(red, green, blue, alpha); +} + +void gl1_1_glColor4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4sv(v); +} + +void gl1_1_glColor4s(void *_glfuncs, GLshort red, GLshort green, GLshort blue, GLshort alpha) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4s(red, green, blue, alpha); +} + +void gl1_1_glColor4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4iv(v); +} + +void gl1_1_glColor4i(void *_glfuncs, GLint red, GLint green, GLint blue, GLint alpha) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4i(red, green, blue, alpha); +} + +void gl1_1_glColor4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4fv(v); +} + +void gl1_1_glColor4f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4f(red, green, blue, alpha); +} + +void gl1_1_glColor4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4dv(v); +} + +void gl1_1_glColor4d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4d(red, green, blue, alpha); +} + +void gl1_1_glColor4bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4bv(v); +} + +void gl1_1_glColor4b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4b(red, green, blue, alpha); +} + +void gl1_1_glColor3usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3usv(v); +} + +void gl1_1_glColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3us(red, green, blue); +} + +void gl1_1_glColor3uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3uiv(v); +} + +void gl1_1_glColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ui(red, green, blue); +} + +void gl1_1_glColor3ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ubv(v); +} + +void gl1_1_glColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ub(red, green, blue); +} + +void gl1_1_glColor3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3sv(v); +} + +void gl1_1_glColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3s(red, green, blue); +} + +void gl1_1_glColor3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3iv(v); +} + +void gl1_1_glColor3i(void *_glfuncs, GLint red, GLint green, GLint blue) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3i(red, green, blue); +} + +void gl1_1_glColor3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3fv(v); +} + +void gl1_1_glColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3f(red, green, blue); +} + +void gl1_1_glColor3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3dv(v); +} + +void gl1_1_glColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3d(red, green, blue); +} + +void gl1_1_glColor3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3bv(v); +} + +void gl1_1_glColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3b(red, green, blue); +} + +void gl1_1_glBitmap(void *_glfuncs, GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBitmap(width, height, xorig, yorig, xmove, ymove, bitmap); +} + +void gl1_1_glBegin(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBegin(mode); +} + +void gl1_1_glListBase(void *_glfuncs, GLuint base) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glListBase(base); +} + +GLuint gl1_1_glGenLists(void *_glfuncs, GLsizei range_) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGenLists(range_); +} + +void gl1_1_glDeleteLists(void *_glfuncs, GLuint list, GLsizei range_) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteLists(list, range_); +} + +void gl1_1_glCallLists(void *_glfuncs, GLsizei n, GLenum gltype, const GLvoid* lists) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCallLists(n, gltype, lists); +} + +void gl1_1_glCallList(void *_glfuncs, GLuint list) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCallList(list); +} + +void gl1_1_glEndList(void *_glfuncs) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndList(); +} + +void gl1_1_glNewList(void *_glfuncs, GLuint list, GLenum mode) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNewList(list, mode); +} + +void gl1_1_glPushClientAttrib(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushClientAttrib(mask); +} + +void gl1_1_glPopClientAttrib(void *_glfuncs) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopClientAttrib(); +} + +void gl1_1_glPrioritizeTextures(void *_glfuncs, GLsizei n, const GLuint* textures, const GLfloat* priorities) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPrioritizeTextures(n, textures, priorities); +} + +GLboolean gl1_1_glAreTexturesResident(void *_glfuncs, GLsizei n, const GLuint* textures, GLboolean* residences) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glAreTexturesResident(n, textures, residences); +} + +void gl1_1_glVertexPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexPointer(size, gltype, stride, pointer); +} + +void gl1_1_glTexCoordPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordPointer(size, gltype, stride, pointer); +} + +void gl1_1_glNormalPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormalPointer(gltype, stride, pointer); +} + +void gl1_1_glInterleavedArrays(void *_glfuncs, GLenum format, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInterleavedArrays(format, stride, pointer); +} + +void gl1_1_glIndexPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexPointer(gltype, stride, pointer); +} + +void gl1_1_glEnableClientState(void *_glfuncs, GLenum array) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnableClientState(array); +} + +void gl1_1_glEdgeFlagPointer(void *_glfuncs, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlagPointer(stride, pointer); +} + +void gl1_1_glDisableClientState(void *_glfuncs, GLenum array) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisableClientState(array); +} + +void gl1_1_glColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorPointer(size, gltype, stride, pointer); +} + +void gl1_1_glArrayElement(void *_glfuncs, GLint i) +{ + QOpenGLFunctions_1_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glArrayElement(i); +} + diff --git a/gl/1.1/funcs.h b/gl/1.1/funcs.h new file mode 100644 index 00000000..f89c6a45 --- /dev/null +++ b/gl/1.1/funcs.h @@ -0,0 +1,376 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#ifndef __cplusplus +#include +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef char GLchar; +typedef signed char GLbyte; /* 1-byte signed */ +typedef short GLshort; /* 2-byte signed */ +typedef int GLint; /* 4-byte signed */ +typedef unsigned char GLubyte; /* 1-byte unsigned */ +typedef unsigned short GLushort; /* 2-byte unsigned */ +typedef unsigned int GLuint; /* 4-byte unsigned */ +typedef int GLsizei; /* 4-byte signed */ +typedef float GLfloat; /* single precision float */ +typedef float GLclampf; /* single precision float in [0,1] */ +typedef double GLdouble; /* double precision float */ +typedef double GLclampd; /* double precision float in [0,1] */ +typedef int64_t GLint64; +typedef uint64_t GLuint64; +typedef ptrdiff_t GLintptr; +typedef ptrdiff_t GLsizeiptr; +typedef ptrdiff_t GLintptrARB; +typedef ptrdiff_t GLsizeiptrARB; +typedef struct __GLsync *GLsync; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +void *gl1_1_funcs(); + +void gl1_1_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl1_1_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal); +GLboolean gl1_1_glIsEnabled(void *_glfuncs, GLenum cap); +void gl1_1_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params); +void gl1_1_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params); +void gl1_1_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl1_1_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl1_1_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels); +void gl1_1_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params); +void gl1_1_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params); +GLenum gl1_1_glGetError(void *_glfuncs); +void gl1_1_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params); +void gl1_1_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params); +void gl1_1_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels); +void gl1_1_glReadBuffer(void *_glfuncs, GLenum mode); +void gl1_1_glPixelStorei(void *_glfuncs, GLenum pname, GLint param); +void gl1_1_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param); +void gl1_1_glDepthFunc(void *_glfuncs, GLenum glfunc); +void gl1_1_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass); +void gl1_1_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask); +void gl1_1_glLogicOp(void *_glfuncs, GLenum opcode); +void gl1_1_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor); +void gl1_1_glFlush(void *_glfuncs); +void gl1_1_glFinish(void *_glfuncs); +void gl1_1_glEnable(void *_glfuncs, GLenum cap); +void gl1_1_glDisable(void *_glfuncs, GLenum cap); +void gl1_1_glDepthMask(void *_glfuncs, GLboolean flag); +void gl1_1_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +void gl1_1_glStencilMask(void *_glfuncs, GLuint mask); +void gl1_1_glClearDepth(void *_glfuncs, GLdouble depth); +void gl1_1_glClearStencil(void *_glfuncs, GLint s); +void gl1_1_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl1_1_glClear(void *_glfuncs, GLbitfield mask); +void gl1_1_glDrawBuffer(void *_glfuncs, GLenum mode); +void gl1_1_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_1_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_1_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl1_1_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl1_1_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl1_1_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl1_1_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl1_1_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode); +void gl1_1_glPointSize(void *_glfuncs, GLfloat size); +void gl1_1_glLineWidth(void *_glfuncs, GLfloat width); +void gl1_1_glHint(void *_glfuncs, GLenum target, GLenum mode); +void gl1_1_glFrontFace(void *_glfuncs, GLenum mode); +void gl1_1_glCullFace(void *_glfuncs, GLenum mode); +void gl1_1_glIndexubv(void *_glfuncs, const GLubyte* c); +void gl1_1_glIndexub(void *_glfuncs, GLubyte c); +GLboolean gl1_1_glIsTexture(void *_glfuncs, GLuint texture); +void gl1_1_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures); +void gl1_1_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures); +void gl1_1_glBindTexture(void *_glfuncs, GLenum target, GLuint texture); +void gl1_1_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_1_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_1_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl1_1_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +void gl1_1_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +void gl1_1_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border); +void gl1_1_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units); +void gl1_1_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl1_1_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count); +void gl1_1_glTranslatef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl1_1_glTranslated(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl1_1_glScalef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl1_1_glScaled(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl1_1_glRotatef(void *_glfuncs, GLfloat angle, GLfloat x, GLfloat y, GLfloat z); +void gl1_1_glRotated(void *_glfuncs, GLdouble angle, GLdouble x, GLdouble y, GLdouble z); +void gl1_1_glPushMatrix(void *_glfuncs); +void gl1_1_glPopMatrix(void *_glfuncs); +void gl1_1_glOrtho(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +void gl1_1_glMultMatrixd(void *_glfuncs, const GLdouble* m); +void gl1_1_glMultMatrixf(void *_glfuncs, const GLfloat* m); +void gl1_1_glMatrixMode(void *_glfuncs, GLenum mode); +void gl1_1_glLoadMatrixd(void *_glfuncs, const GLdouble* m); +void gl1_1_glLoadMatrixf(void *_glfuncs, const GLfloat* m); +void gl1_1_glLoadIdentity(void *_glfuncs); +void gl1_1_glFrustum(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +GLboolean gl1_1_glIsList(void *_glfuncs, GLuint list); +void gl1_1_glGetTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, GLint* params); +void gl1_1_glGetTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, GLfloat* params); +void gl1_1_glGetTexGendv(void *_glfuncs, GLenum coord, GLenum pname, GLdouble* params); +void gl1_1_glGetTexEnviv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl1_1_glGetTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl1_1_glGetPolygonStipple(void *_glfuncs, GLubyte* mask); +void gl1_1_glGetPixelMapusv(void *_glfuncs, GLenum glmap, GLushort* values); +void gl1_1_glGetPixelMapuiv(void *_glfuncs, GLenum glmap, GLuint* values); +void gl1_1_glGetPixelMapfv(void *_glfuncs, GLenum glmap, GLfloat* values); +void gl1_1_glGetMaterialiv(void *_glfuncs, GLenum face, GLenum pname, GLint* params); +void gl1_1_glGetMaterialfv(void *_glfuncs, GLenum face, GLenum pname, GLfloat* params); +void gl1_1_glGetMapiv(void *_glfuncs, GLenum target, GLenum query, GLint* v); +void gl1_1_glGetMapfv(void *_glfuncs, GLenum target, GLenum query, GLfloat* v); +void gl1_1_glGetMapdv(void *_glfuncs, GLenum target, GLenum query, GLdouble* v); +void gl1_1_glGetLightiv(void *_glfuncs, GLenum light, GLenum pname, GLint* params); +void gl1_1_glGetLightfv(void *_glfuncs, GLenum light, GLenum pname, GLfloat* params); +void gl1_1_glGetClipPlane(void *_glfuncs, GLenum plane, GLdouble* equation); +void gl1_1_glDrawPixels(void *_glfuncs, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_1_glCopyPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum gltype); +void gl1_1_glPixelMapusv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLushort* values); +void gl1_1_glPixelMapuiv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLuint* values); +void gl1_1_glPixelMapfv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLfloat* values); +void gl1_1_glPixelTransferi(void *_glfuncs, GLenum pname, GLint param); +void gl1_1_glPixelTransferf(void *_glfuncs, GLenum pname, GLfloat param); +void gl1_1_glPixelZoom(void *_glfuncs, GLfloat xfactor, GLfloat yfactor); +void gl1_1_glAlphaFunc(void *_glfuncs, GLenum glfunc, GLfloat ref); +void gl1_1_glEvalPoint2(void *_glfuncs, GLint i, GLint j); +void gl1_1_glEvalMesh2(void *_glfuncs, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); +void gl1_1_glEvalPoint1(void *_glfuncs, GLint i); +void gl1_1_glEvalMesh1(void *_glfuncs, GLenum mode, GLint i1, GLint i2); +void gl1_1_glEvalCoord2fv(void *_glfuncs, const GLfloat* u); +void gl1_1_glEvalCoord2f(void *_glfuncs, GLfloat u, GLfloat v); +void gl1_1_glEvalCoord2dv(void *_glfuncs, const GLdouble* u); +void gl1_1_glEvalCoord2d(void *_glfuncs, GLdouble u, GLdouble v); +void gl1_1_glEvalCoord1fv(void *_glfuncs, const GLfloat* u); +void gl1_1_glEvalCoord1f(void *_glfuncs, GLfloat u); +void gl1_1_glEvalCoord1dv(void *_glfuncs, const GLdouble* u); +void gl1_1_glEvalCoord1d(void *_glfuncs, GLdouble u); +void gl1_1_glMapGrid2f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); +void gl1_1_glMapGrid2d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); +void gl1_1_glMapGrid1f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2); +void gl1_1_glMapGrid1d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2); +void gl1_1_glMap2f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points); +void gl1_1_glMap2d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points); +void gl1_1_glMap1f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points); +void gl1_1_glMap1d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points); +void gl1_1_glPushAttrib(void *_glfuncs, GLbitfield mask); +void gl1_1_glPopAttrib(void *_glfuncs); +void gl1_1_glAccum(void *_glfuncs, GLenum op, GLfloat value); +void gl1_1_glIndexMask(void *_glfuncs, GLuint mask); +void gl1_1_glClearIndex(void *_glfuncs, GLfloat c); +void gl1_1_glClearAccum(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl1_1_glPushName(void *_glfuncs, GLuint name); +void gl1_1_glPopName(void *_glfuncs); +void gl1_1_glPassThrough(void *_glfuncs, GLfloat token); +void gl1_1_glLoadName(void *_glfuncs, GLuint name); +void gl1_1_glInitNames(void *_glfuncs); +GLint gl1_1_glRenderMode(void *_glfuncs, GLenum mode); +void gl1_1_glSelectBuffer(void *_glfuncs, GLsizei size, GLuint* buffer); +void gl1_1_glFeedbackBuffer(void *_glfuncs, GLsizei size, GLenum gltype, GLfloat* buffer); +void gl1_1_glTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, const GLint* params); +void gl1_1_glTexGeni(void *_glfuncs, GLenum coord, GLenum pname, GLint param); +void gl1_1_glTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, const GLfloat* params); +void gl1_1_glTexGenf(void *_glfuncs, GLenum coord, GLenum pname, GLfloat param); +void gl1_1_glTexGendv(void *_glfuncs, GLenum coord, GLenum pname, const GLdouble* params); +void gl1_1_glTexGend(void *_glfuncs, GLenum coord, GLenum pname, GLdouble param); +void gl1_1_glTexEnviv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl1_1_glTexEnvi(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl1_1_glTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl1_1_glTexEnvf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl1_1_glShadeModel(void *_glfuncs, GLenum mode); +void gl1_1_glPolygonStipple(void *_glfuncs, const GLubyte* mask); +void gl1_1_glMaterialiv(void *_glfuncs, GLenum face, GLenum pname, const GLint* params); +void gl1_1_glMateriali(void *_glfuncs, GLenum face, GLenum pname, GLint param); +void gl1_1_glMaterialfv(void *_glfuncs, GLenum face, GLenum pname, const GLfloat* params); +void gl1_1_glMaterialf(void *_glfuncs, GLenum face, GLenum pname, GLfloat param); +void gl1_1_glLineStipple(void *_glfuncs, GLint factor, GLushort pattern); +void gl1_1_glLightModeliv(void *_glfuncs, GLenum pname, const GLint* params); +void gl1_1_glLightModeli(void *_glfuncs, GLenum pname, GLint param); +void gl1_1_glLightModelfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl1_1_glLightModelf(void *_glfuncs, GLenum pname, GLfloat param); +void gl1_1_glLightiv(void *_glfuncs, GLenum light, GLenum pname, const GLint* params); +void gl1_1_glLighti(void *_glfuncs, GLenum light, GLenum pname, GLint param); +void gl1_1_glLightfv(void *_glfuncs, GLenum light, GLenum pname, const GLfloat* params); +void gl1_1_glLightf(void *_glfuncs, GLenum light, GLenum pname, GLfloat param); +void gl1_1_glFogiv(void *_glfuncs, GLenum pname, const GLint* params); +void gl1_1_glFogi(void *_glfuncs, GLenum pname, GLint param); +void gl1_1_glFogfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl1_1_glFogf(void *_glfuncs, GLenum pname, GLfloat param); +void gl1_1_glColorMaterial(void *_glfuncs, GLenum face, GLenum mode); +void gl1_1_glClipPlane(void *_glfuncs, GLenum plane, const GLdouble* equation); +void gl1_1_glVertex4sv(void *_glfuncs, const GLshort* v); +void gl1_1_glVertex4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w); +void gl1_1_glVertex4iv(void *_glfuncs, const GLint* v); +void gl1_1_glVertex4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w); +void gl1_1_glVertex4fv(void *_glfuncs, const GLfloat* v); +void gl1_1_glVertex4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl1_1_glVertex4dv(void *_glfuncs, const GLdouble* v); +void gl1_1_glVertex4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl1_1_glVertex3sv(void *_glfuncs, const GLshort* v); +void gl1_1_glVertex3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl1_1_glVertex3iv(void *_glfuncs, const GLint* v); +void gl1_1_glVertex3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl1_1_glVertex3fv(void *_glfuncs, const GLfloat* v); +void gl1_1_glVertex3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl1_1_glVertex3dv(void *_glfuncs, const GLdouble* v); +void gl1_1_glVertex3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl1_1_glVertex2sv(void *_glfuncs, const GLshort* v); +void gl1_1_glVertex2s(void *_glfuncs, GLshort x, GLshort y); +void gl1_1_glVertex2iv(void *_glfuncs, const GLint* v); +void gl1_1_glVertex2i(void *_glfuncs, GLint x, GLint y); +void gl1_1_glVertex2fv(void *_glfuncs, const GLfloat* v); +void gl1_1_glVertex2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl1_1_glVertex2dv(void *_glfuncs, const GLdouble* v); +void gl1_1_glVertex2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl1_1_glTexCoord4sv(void *_glfuncs, const GLshort* v); +void gl1_1_glTexCoord4s(void *_glfuncs, GLshort s, GLshort t, GLshort r, GLshort q); +void gl1_1_glTexCoord4iv(void *_glfuncs, const GLint* v); +void gl1_1_glTexCoord4i(void *_glfuncs, GLint s, GLint t, GLint r, GLint q); +void gl1_1_glTexCoord4fv(void *_glfuncs, const GLfloat* v); +void gl1_1_glTexCoord4f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +void gl1_1_glTexCoord4dv(void *_glfuncs, const GLdouble* v); +void gl1_1_glTexCoord4d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +void gl1_1_glTexCoord3sv(void *_glfuncs, const GLshort* v); +void gl1_1_glTexCoord3s(void *_glfuncs, GLshort s, GLshort t, GLshort r); +void gl1_1_glTexCoord3iv(void *_glfuncs, const GLint* v); +void gl1_1_glTexCoord3i(void *_glfuncs, GLint s, GLint t, GLint r); +void gl1_1_glTexCoord3fv(void *_glfuncs, const GLfloat* v); +void gl1_1_glTexCoord3f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r); +void gl1_1_glTexCoord3dv(void *_glfuncs, const GLdouble* v); +void gl1_1_glTexCoord3d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r); +void gl1_1_glTexCoord2sv(void *_glfuncs, const GLshort* v); +void gl1_1_glTexCoord2s(void *_glfuncs, GLshort s, GLshort t); +void gl1_1_glTexCoord2iv(void *_glfuncs, const GLint* v); +void gl1_1_glTexCoord2i(void *_glfuncs, GLint s, GLint t); +void gl1_1_glTexCoord2fv(void *_glfuncs, const GLfloat* v); +void gl1_1_glTexCoord2f(void *_glfuncs, GLfloat s, GLfloat t); +void gl1_1_glTexCoord2dv(void *_glfuncs, const GLdouble* v); +void gl1_1_glTexCoord2d(void *_glfuncs, GLdouble s, GLdouble t); +void gl1_1_glTexCoord1sv(void *_glfuncs, const GLshort* v); +void gl1_1_glTexCoord1s(void *_glfuncs, GLshort s); +void gl1_1_glTexCoord1iv(void *_glfuncs, const GLint* v); +void gl1_1_glTexCoord1i(void *_glfuncs, GLint s); +void gl1_1_glTexCoord1fv(void *_glfuncs, const GLfloat* v); +void gl1_1_glTexCoord1f(void *_glfuncs, GLfloat s); +void gl1_1_glTexCoord1dv(void *_glfuncs, const GLdouble* v); +void gl1_1_glTexCoord1d(void *_glfuncs, GLdouble s); +void gl1_1_glRectsv(void *_glfuncs, const GLshort* v1, const GLshort* v2); +void gl1_1_glRects(void *_glfuncs, GLshort x1, GLshort y1, GLshort x2, GLshort y2); +void gl1_1_glRectiv(void *_glfuncs, const GLint* v1, const GLint* v2); +void gl1_1_glRecti(void *_glfuncs, GLint x1, GLint y1, GLint x2, GLint y2); +void gl1_1_glRectfv(void *_glfuncs, const GLfloat* v1, const GLfloat* v2); +void gl1_1_glRectf(void *_glfuncs, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); +void gl1_1_glRectdv(void *_glfuncs, const GLdouble* v1, const GLdouble* v2); +void gl1_1_glRectd(void *_glfuncs, GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); +void gl1_1_glRasterPos4sv(void *_glfuncs, const GLshort* v); +void gl1_1_glRasterPos4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w); +void gl1_1_glRasterPos4iv(void *_glfuncs, const GLint* v); +void gl1_1_glRasterPos4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w); +void gl1_1_glRasterPos4fv(void *_glfuncs, const GLfloat* v); +void gl1_1_glRasterPos4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl1_1_glRasterPos4dv(void *_glfuncs, const GLdouble* v); +void gl1_1_glRasterPos4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl1_1_glRasterPos3sv(void *_glfuncs, const GLshort* v); +void gl1_1_glRasterPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl1_1_glRasterPos3iv(void *_glfuncs, const GLint* v); +void gl1_1_glRasterPos3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl1_1_glRasterPos3fv(void *_glfuncs, const GLfloat* v); +void gl1_1_glRasterPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl1_1_glRasterPos3dv(void *_glfuncs, const GLdouble* v); +void gl1_1_glRasterPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl1_1_glRasterPos2sv(void *_glfuncs, const GLshort* v); +void gl1_1_glRasterPos2s(void *_glfuncs, GLshort x, GLshort y); +void gl1_1_glRasterPos2iv(void *_glfuncs, const GLint* v); +void gl1_1_glRasterPos2i(void *_glfuncs, GLint x, GLint y); +void gl1_1_glRasterPos2fv(void *_glfuncs, const GLfloat* v); +void gl1_1_glRasterPos2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl1_1_glRasterPos2dv(void *_glfuncs, const GLdouble* v); +void gl1_1_glRasterPos2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl1_1_glNormal3sv(void *_glfuncs, const GLshort* v); +void gl1_1_glNormal3s(void *_glfuncs, GLshort nx, GLshort ny, GLshort nz); +void gl1_1_glNormal3iv(void *_glfuncs, const GLint* v); +void gl1_1_glNormal3i(void *_glfuncs, GLint nx, GLint ny, GLint nz); +void gl1_1_glNormal3fv(void *_glfuncs, const GLfloat* v); +void gl1_1_glNormal3f(void *_glfuncs, GLfloat nx, GLfloat ny, GLfloat nz); +void gl1_1_glNormal3dv(void *_glfuncs, const GLdouble* v); +void gl1_1_glNormal3d(void *_glfuncs, GLdouble nx, GLdouble ny, GLdouble nz); +void gl1_1_glNormal3bv(void *_glfuncs, const GLbyte* v); +void gl1_1_glNormal3b(void *_glfuncs, GLbyte nx, GLbyte ny, GLbyte nz); +void gl1_1_glIndexsv(void *_glfuncs, const GLshort* c); +void gl1_1_glIndexs(void *_glfuncs, GLshort c); +void gl1_1_glIndexiv(void *_glfuncs, const GLint* c); +void gl1_1_glIndexi(void *_glfuncs, GLint c); +void gl1_1_glIndexfv(void *_glfuncs, const GLfloat* c); +void gl1_1_glIndexf(void *_glfuncs, GLfloat c); +void gl1_1_glIndexdv(void *_glfuncs, const GLdouble* c); +void gl1_1_glIndexd(void *_glfuncs, GLdouble c); +void gl1_1_glEnd(void *_glfuncs); +void gl1_1_glEdgeFlagv(void *_glfuncs, const GLboolean* flag); +void gl1_1_glEdgeFlag(void *_glfuncs, GLboolean flag); +void gl1_1_glColor4usv(void *_glfuncs, const GLushort* v); +void gl1_1_glColor4us(void *_glfuncs, GLushort red, GLushort green, GLushort blue, GLushort alpha); +void gl1_1_glColor4uiv(void *_glfuncs, const GLuint* v); +void gl1_1_glColor4ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue, GLuint alpha); +void gl1_1_glColor4ubv(void *_glfuncs, const GLubyte* v); +void gl1_1_glColor4ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); +void gl1_1_glColor4sv(void *_glfuncs, const GLshort* v); +void gl1_1_glColor4s(void *_glfuncs, GLshort red, GLshort green, GLshort blue, GLshort alpha); +void gl1_1_glColor4iv(void *_glfuncs, const GLint* v); +void gl1_1_glColor4i(void *_glfuncs, GLint red, GLint green, GLint blue, GLint alpha); +void gl1_1_glColor4fv(void *_glfuncs, const GLfloat* v); +void gl1_1_glColor4f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl1_1_glColor4dv(void *_glfuncs, const GLdouble* v); +void gl1_1_glColor4d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); +void gl1_1_glColor4bv(void *_glfuncs, const GLbyte* v); +void gl1_1_glColor4b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); +void gl1_1_glColor3usv(void *_glfuncs, const GLushort* v); +void gl1_1_glColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue); +void gl1_1_glColor3uiv(void *_glfuncs, const GLuint* v); +void gl1_1_glColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue); +void gl1_1_glColor3ubv(void *_glfuncs, const GLubyte* v); +void gl1_1_glColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue); +void gl1_1_glColor3sv(void *_glfuncs, const GLshort* v); +void gl1_1_glColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue); +void gl1_1_glColor3iv(void *_glfuncs, const GLint* v); +void gl1_1_glColor3i(void *_glfuncs, GLint red, GLint green, GLint blue); +void gl1_1_glColor3fv(void *_glfuncs, const GLfloat* v); +void gl1_1_glColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue); +void gl1_1_glColor3dv(void *_glfuncs, const GLdouble* v); +void gl1_1_glColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue); +void gl1_1_glColor3bv(void *_glfuncs, const GLbyte* v); +void gl1_1_glColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue); +void gl1_1_glBitmap(void *_glfuncs, GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap); +void gl1_1_glBegin(void *_glfuncs, GLenum mode); +void gl1_1_glListBase(void *_glfuncs, GLuint base); +GLuint gl1_1_glGenLists(void *_glfuncs, GLsizei range_); +void gl1_1_glDeleteLists(void *_glfuncs, GLuint list, GLsizei range_); +void gl1_1_glCallLists(void *_glfuncs, GLsizei n, GLenum gltype, const GLvoid* lists); +void gl1_1_glCallList(void *_glfuncs, GLuint list); +void gl1_1_glEndList(void *_glfuncs); +void gl1_1_glNewList(void *_glfuncs, GLuint list, GLenum mode); +void gl1_1_glPushClientAttrib(void *_glfuncs, GLbitfield mask); +void gl1_1_glPopClientAttrib(void *_glfuncs); +void gl1_1_glPrioritizeTextures(void *_glfuncs, GLsizei n, const GLuint* textures, const GLfloat* priorities); +GLboolean gl1_1_glAreTexturesResident(void *_glfuncs, GLsizei n, const GLuint* textures, GLboolean* residences); +void gl1_1_glVertexPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl1_1_glTexCoordPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl1_1_glNormalPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl1_1_glInterleavedArrays(void *_glfuncs, GLenum format, GLsizei stride, const GLvoid* pointer); +void gl1_1_glIndexPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl1_1_glEnableClientState(void *_glfuncs, GLenum array); +void gl1_1_glEdgeFlagPointer(void *_glfuncs, GLsizei stride, const GLvoid* pointer); +void gl1_1_glDisableClientState(void *_glfuncs, GLenum array); +void gl1_1_glColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl1_1_glArrayElement(void *_glfuncs, GLint i); + + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/gl/1.1/gl.go b/gl/1.1/gl.go new file mode 100644 index 00000000..268e1c08 --- /dev/null +++ b/gl/1.1/gl.go @@ -0,0 +1,2789 @@ +// ** file automatically generated by glgen -- do not edit manually ** + +package GL + +// #cgo CXXFLAGS: -std=c++0x -pedantic-errors -Wall -fno-strict-aliasing +// #cgo LDFLAGS: -lstdc++ +// #cgo pkg-config: Qt5Core Qt5OpenGL +// +// #include "funcs.h" +// +// void free(void*); +// +import "C" + +import ( + "fmt" + "reflect" + "unsafe" + + "gopkg.in/qml.v1/gl/glbase" +) + +// API returns a value that offers methods matching the OpenGL version 1.1 API. +// +// The returned API must not be used after the provided OpenGL context becomes invalid. +func API(context glbase.Contexter) *GL { + gl := &GL{} + gl.funcs = C.gl1_1_funcs() + if gl.funcs == nil { + panic(fmt.Errorf("OpenGL version 1.1 is not available")) + } + return gl +} + +// GL implements the OpenGL version 1.1 API. Values of this +// type must be created via the API function, and it must not be used after +// the associated OpenGL context becomes invalid. +type GL struct { + funcs unsafe.Pointer +} + +const ( + FALSE = 0 + TRUE = 1 + NONE = 0 + + BYTE = 0x1400 + UNSIGNED_BYTE = 0x1401 + SHORT = 0x1402 + UNSIGNED_SHORT = 0x1403 + INT = 0x1404 + UNSIGNED_INT = 0x1405 + FLOAT = 0x1406 + N2_BYTES = 0x1407 + N3_BYTES = 0x1408 + N4_BYTES = 0x1409 + DOUBLE = 0x140A + + ACCUM = 0x0100 + LOAD = 0x0101 + RETURN = 0x0102 + MULT = 0x0103 + ADD = 0x0104 + + ACCUM_BUFFER_BIT = 0x00000200 + ALL_ATTRIB_BITS = 0xFFFFFFFF + COLOR_BUFFER_BIT = 0x00004000 + CURRENT_BIT = 0x00000001 + DEPTH_BUFFER_BIT = 0x00000100 + ENABLE_BIT = 0x00002000 + EVAL_BIT = 0x00010000 + FOG_BIT = 0x00000080 + HINT_BIT = 0x00008000 + LIGHTING_BIT = 0x00000040 + LINE_BIT = 0x00000004 + LIST_BIT = 0x00020000 + PIXEL_MODE_BIT = 0x00000020 + POINT_BIT = 0x00000002 + POLYGON_BIT = 0x00000008 + POLYGON_STIPPLE_BIT = 0x00000010 + SCISSOR_BIT = 0x00080000 + STENCIL_BUFFER_BIT = 0x00000400 + TEXTURE_BIT = 0x00040000 + TRANSFORM_BIT = 0x00001000 + VIEWPORT_BIT = 0x00000800 + + ALWAYS = 0x0207 + EQUAL = 0x0202 + GEQUAL = 0x0206 + GREATER = 0x0204 + LEQUAL = 0x0203 + LESS = 0x0201 + NEVER = 0x0200 + NOTEQUAL = 0x0205 + + LOGIC_OP = 0x0BF1 + + DST_ALPHA = 0x0304 + ONE = 1 + ONE_MINUS_DST_ALPHA = 0x0305 + ONE_MINUS_SRC_ALPHA = 0x0303 + ONE_MINUS_SRC_COLOR = 0x0301 + SRC_ALPHA = 0x0302 + SRC_COLOR = 0x0300 + ZERO = 0 + + DST_COLOR = 0x0306 + ONE_MINUS_DST_COLOR = 0x0307 + SRC_ALPHA_SATURATE = 0x0308 + + CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF + CLIENT_PIXEL_STORE_BIT = 0x00000001 + CLIENT_VERTEX_ARRAY_BIT = 0x00000002 + + CLIP_PLANE0 = 0x3000 + CLIP_PLANE1 = 0x3001 + CLIP_PLANE2 = 0x3002 + CLIP_PLANE3 = 0x3003 + CLIP_PLANE4 = 0x3004 + CLIP_PLANE5 = 0x3005 + + BACK = 0x0405 + FRONT = 0x0404 + FRONT_AND_BACK = 0x0408 + + AMBIENT = 0x1200 + AMBIENT_AND_DIFFUSE = 0x1602 + DIFFUSE = 0x1201 + EMISSION = 0x1600 + SPECULAR = 0x1202 + + AUX0 = 0x0409 + AUX1 = 0x040A + AUX2 = 0x040B + AUX3 = 0x040C + BACK_LEFT = 0x0402 + BACK_RIGHT = 0x0403 + FRONT_LEFT = 0x0400 + FRONT_RIGHT = 0x0401 + LEFT = 0x0406 + RIGHT = 0x0407 + + ALPHA_TEST = 0x0BC0 + AUTO_NORMAL = 0x0D80 + BLEND = 0x0BE2 + COLOR_ARRAY = 0x8076 + COLOR_LOGIC_OP = 0x0BF2 + COLOR_MATERIAL = 0x0B57 + CULL_FACE = 0x0B44 + DEPTH_TEST = 0x0B71 + DITHER = 0x0BD0 + EDGE_FLAG_ARRAY = 0x8079 + FOG = 0x0B60 + INDEX_ARRAY = 0x8077 + INDEX_LOGIC_OP = 0x0BF1 + LIGHT0 = 0x4000 + LIGHT1 = 0x4001 + LIGHT2 = 0x4002 + LIGHT3 = 0x4003 + LIGHT4 = 0x4004 + LIGHT5 = 0x4005 + LIGHT6 = 0x4006 + LIGHT7 = 0x4007 + LIGHTING = 0x0B50 + LINE_SMOOTH = 0x0B20 + LINE_STIPPLE = 0x0B24 + MAP1_COLOR_4 = 0x0D90 + MAP1_INDEX = 0x0D91 + MAP1_NORMAL = 0x0D92 + MAP1_TEXTURE_COORD_1 = 0x0D93 + MAP1_TEXTURE_COORD_2 = 0x0D94 + MAP1_TEXTURE_COORD_3 = 0x0D95 + MAP1_TEXTURE_COORD_4 = 0x0D96 + MAP1_VERTEX_3 = 0x0D97 + MAP1_VERTEX_4 = 0x0D98 + MAP2_COLOR_4 = 0x0DB0 + MAP2_INDEX = 0x0DB1 + MAP2_NORMAL = 0x0DB2 + MAP2_TEXTURE_COORD_1 = 0x0DB3 + MAP2_TEXTURE_COORD_2 = 0x0DB4 + MAP2_TEXTURE_COORD_3 = 0x0DB5 + MAP2_TEXTURE_COORD_4 = 0x0DB6 + MAP2_VERTEX_3 = 0x0DB7 + MAP2_VERTEX_4 = 0x0DB8 + NORMALIZE = 0x0BA1 + NORMAL_ARRAY = 0x8075 + POINT_SMOOTH = 0x0B10 + POLYGON_OFFSET_FILL = 0x8037 + POLYGON_OFFSET_LINE = 0x2A02 + POLYGON_OFFSET_POINT = 0x2A01 + POLYGON_SMOOTH = 0x0B41 + POLYGON_STIPPLE = 0x0B42 + SCISSOR_TEST = 0x0C11 + STENCIL_TEST = 0x0B90 + TEXTURE_1D = 0x0DE0 + TEXTURE_2D = 0x0DE1 + TEXTURE_COORD_ARRAY = 0x8078 + TEXTURE_GEN_Q = 0x0C63 + TEXTURE_GEN_R = 0x0C62 + TEXTURE_GEN_S = 0x0C60 + TEXTURE_GEN_T = 0x0C61 + VERTEX_ARRAY = 0x8074 + + INVALID_ENUM = 0x0500 + INVALID_OPERATION = 0x0502 + INVALID_VALUE = 0x0501 + NO_ERROR = 0 + OUT_OF_MEMORY = 0x0505 + STACK_OVERFLOW = 0x0503 + STACK_UNDERFLOW = 0x0504 + + N2D = 0x0600 + N3D = 0x0601 + N3D_COLOR = 0x0602 + N3D_COLOR_TEXTURE = 0x0603 + N4D_COLOR_TEXTURE = 0x0604 + + BITMAP_TOKEN = 0x0704 + COPY_PIXEL_TOKEN = 0x0706 + DRAW_PIXEL_TOKEN = 0x0705 + LINE_RESET_TOKEN = 0x0707 + LINE_TOKEN = 0x0702 + PASS_THROUGH_TOKEN = 0x0700 + POINT_TOKEN = 0x0701 + POLYGON_TOKEN = 0x0703 + + EXP = 0x0800 + EXP2 = 0x0801 + LINEAR = 0x2601 + + FOG_COLOR = 0x0B66 + FOG_DENSITY = 0x0B62 + FOG_END = 0x0B64 + FOG_INDEX = 0x0B61 + FOG_MODE = 0x0B65 + FOG_START = 0x0B63 + + CCW = 0x0901 + CW = 0x0900 + + COEFF = 0x0A00 + DOMAIN = 0x0A02 + ORDER = 0x0A01 + + PIXEL_MAP_A_TO_A = 0x0C79 + PIXEL_MAP_B_TO_B = 0x0C78 + PIXEL_MAP_G_TO_G = 0x0C77 + PIXEL_MAP_I_TO_A = 0x0C75 + PIXEL_MAP_I_TO_B = 0x0C74 + PIXEL_MAP_I_TO_G = 0x0C73 + PIXEL_MAP_I_TO_I = 0x0C70 + PIXEL_MAP_I_TO_R = 0x0C72 + PIXEL_MAP_R_TO_R = 0x0C76 + PIXEL_MAP_S_TO_S = 0x0C71 + + ACCUM_ALPHA_BITS = 0x0D5B + ACCUM_BLUE_BITS = 0x0D5A + ACCUM_CLEAR_VALUE = 0x0B80 + ACCUM_GREEN_BITS = 0x0D59 + ACCUM_RED_BITS = 0x0D58 + ALPHA_BIAS = 0x0D1D + ALPHA_BITS = 0x0D55 + ALPHA_SCALE = 0x0D1C + ALPHA_TEST_FUNC = 0x0BC1 + ALPHA_TEST_REF = 0x0BC2 + ATTRIB_STACK_DEPTH = 0x0BB0 + AUX_BUFFERS = 0x0C00 + BLEND_DST = 0x0BE0 + BLEND_SRC = 0x0BE1 + BLUE_BIAS = 0x0D1B + BLUE_BITS = 0x0D54 + BLUE_SCALE = 0x0D1A + CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1 + COLOR_ARRAY_SIZE = 0x8081 + COLOR_ARRAY_STRIDE = 0x8083 + COLOR_ARRAY_TYPE = 0x8082 + COLOR_CLEAR_VALUE = 0x0C22 + COLOR_MATERIAL_FACE = 0x0B55 + COLOR_MATERIAL_PARAMETER = 0x0B56 + COLOR_WRITEMASK = 0x0C23 + CULL_FACE_MODE = 0x0B45 + CURRENT_COLOR = 0x0B00 + CURRENT_INDEX = 0x0B01 + CURRENT_NORMAL = 0x0B02 + CURRENT_RASTER_COLOR = 0x0B04 + CURRENT_RASTER_DISTANCE = 0x0B09 + CURRENT_RASTER_INDEX = 0x0B05 + CURRENT_RASTER_POSITION = 0x0B07 + CURRENT_RASTER_POSITION_VALID = 0x0B08 + CURRENT_RASTER_TEXTURE_COORDS = 0x0B06 + CURRENT_TEXTURE_COORDS = 0x0B03 + DEPTH_BIAS = 0x0D1F + DEPTH_BITS = 0x0D56 + DEPTH_CLEAR_VALUE = 0x0B73 + DEPTH_FUNC = 0x0B74 + DEPTH_RANGE = 0x0B70 + DEPTH_SCALE = 0x0D1E + DEPTH_WRITEMASK = 0x0B72 + DOUBLEBUFFER = 0x0C32 + DRAW_BUFFER = 0x0C01 + EDGE_FLAG = 0x0B43 + EDGE_FLAG_ARRAY_STRIDE = 0x808C + FEEDBACK_BUFFER_SIZE = 0x0DF1 + FEEDBACK_BUFFER_TYPE = 0x0DF2 + FOG_HINT = 0x0C54 + FRONT_FACE = 0x0B46 + GREEN_BIAS = 0x0D19 + GREEN_BITS = 0x0D53 + GREEN_SCALE = 0x0D18 + INDEX_ARRAY_STRIDE = 0x8086 + INDEX_ARRAY_TYPE = 0x8085 + INDEX_BITS = 0x0D51 + INDEX_CLEAR_VALUE = 0x0C20 + INDEX_MODE = 0x0C30 + INDEX_OFFSET = 0x0D13 + INDEX_SHIFT = 0x0D12 + INDEX_WRITEMASK = 0x0C21 + LIGHT_MODEL_AMBIENT = 0x0B53 + LIGHT_MODEL_LOCAL_VIEWER = 0x0B51 + LIGHT_MODEL_TWO_SIDE = 0x0B52 + LINE_SMOOTH_HINT = 0x0C52 + LINE_STIPPLE_PATTERN = 0x0B25 + LINE_STIPPLE_REPEAT = 0x0B26 + LINE_WIDTH = 0x0B21 + LINE_WIDTH_GRANULARITY = 0x0B23 + LINE_WIDTH_RANGE = 0x0B22 + LIST_BASE = 0x0B32 + LIST_INDEX = 0x0B33 + LIST_MODE = 0x0B30 + LOGIC_OP_MODE = 0x0BF0 + MAP1_GRID_DOMAIN = 0x0DD0 + MAP1_GRID_SEGMENTS = 0x0DD1 + MAP2_GRID_DOMAIN = 0x0DD2 + MAP2_GRID_SEGMENTS = 0x0DD3 + MAP_COLOR = 0x0D10 + MAP_STENCIL = 0x0D11 + MATRIX_MODE = 0x0BA0 + MAX_ATTRIB_STACK_DEPTH = 0x0D35 + MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B + MAX_CLIP_PLANES = 0x0D32 + MAX_EVAL_ORDER = 0x0D30 + MAX_LIGHTS = 0x0D31 + MAX_LIST_NESTING = 0x0B31 + MAX_MODELVIEW_STACK_DEPTH = 0x0D36 + MAX_NAME_STACK_DEPTH = 0x0D37 + MAX_PIXEL_MAP_TABLE = 0x0D34 + MAX_PROJECTION_STACK_DEPTH = 0x0D38 + MAX_TEXTURE_SIZE = 0x0D33 + MAX_TEXTURE_STACK_DEPTH = 0x0D39 + MAX_VIEWPORT_DIMS = 0x0D3A + MODELVIEW_MATRIX = 0x0BA6 + MODELVIEW_STACK_DEPTH = 0x0BA3 + NAME_STACK_DEPTH = 0x0D70 + NORMAL_ARRAY_STRIDE = 0x807F + NORMAL_ARRAY_TYPE = 0x807E + PACK_ALIGNMENT = 0x0D05 + PACK_LSB_FIRST = 0x0D01 + PACK_ROW_LENGTH = 0x0D02 + PACK_SKIP_PIXELS = 0x0D04 + PACK_SKIP_ROWS = 0x0D03 + PACK_SWAP_BYTES = 0x0D00 + PERSPECTIVE_CORRECTION_HINT = 0x0C50 + PIXEL_MAP_A_TO_A_SIZE = 0x0CB9 + PIXEL_MAP_B_TO_B_SIZE = 0x0CB8 + PIXEL_MAP_G_TO_G_SIZE = 0x0CB7 + PIXEL_MAP_I_TO_A_SIZE = 0x0CB5 + PIXEL_MAP_I_TO_B_SIZE = 0x0CB4 + PIXEL_MAP_I_TO_G_SIZE = 0x0CB3 + PIXEL_MAP_I_TO_I_SIZE = 0x0CB0 + PIXEL_MAP_I_TO_R_SIZE = 0x0CB2 + PIXEL_MAP_R_TO_R_SIZE = 0x0CB6 + PIXEL_MAP_S_TO_S_SIZE = 0x0CB1 + POINT_SIZE = 0x0B11 + POINT_SIZE_GRANULARITY = 0x0B13 + POINT_SIZE_RANGE = 0x0B12 + POINT_SMOOTH_HINT = 0x0C51 + POLYGON_MODE = 0x0B40 + POLYGON_OFFSET_FACTOR = 0x8038 + POLYGON_OFFSET_UNITS = 0x2A00 + POLYGON_SMOOTH_HINT = 0x0C53 + PROJECTION_MATRIX = 0x0BA7 + PROJECTION_STACK_DEPTH = 0x0BA4 + READ_BUFFER = 0x0C02 + RED_BIAS = 0x0D15 + RED_BITS = 0x0D52 + RED_SCALE = 0x0D14 + RENDER_MODE = 0x0C40 + RGBA_MODE = 0x0C31 + SCISSOR_BOX = 0x0C10 + SELECTION_BUFFER_SIZE = 0x0DF4 + SHADE_MODEL = 0x0B54 + STENCIL_BITS = 0x0D57 + STENCIL_CLEAR_VALUE = 0x0B91 + STENCIL_FAIL = 0x0B94 + STENCIL_FUNC = 0x0B92 + STENCIL_PASS_DEPTH_FAIL = 0x0B95 + STENCIL_PASS_DEPTH_PASS = 0x0B96 + STENCIL_REF = 0x0B97 + STENCIL_VALUE_MASK = 0x0B93 + STENCIL_WRITEMASK = 0x0B98 + STEREO = 0x0C33 + SUBPIXEL_BITS = 0x0D50 + TEXTURE_BINDING_1D = 0x8068 + TEXTURE_BINDING_2D = 0x8069 + TEXTURE_COORD_ARRAY_SIZE = 0x8088 + TEXTURE_COORD_ARRAY_STRIDE = 0x808A + TEXTURE_COORD_ARRAY_TYPE = 0x8089 + TEXTURE_MATRIX = 0x0BA8 + TEXTURE_STACK_DEPTH = 0x0BA5 + UNPACK_ALIGNMENT = 0x0CF5 + UNPACK_LSB_FIRST = 0x0CF1 + UNPACK_ROW_LENGTH = 0x0CF2 + UNPACK_SKIP_PIXELS = 0x0CF4 + UNPACK_SKIP_ROWS = 0x0CF3 + UNPACK_SWAP_BYTES = 0x0CF0 + VERTEX_ARRAY_SIZE = 0x807A + VERTEX_ARRAY_STRIDE = 0x807C + VERTEX_ARRAY_TYPE = 0x807B + VIEWPORT = 0x0BA2 + ZOOM_X = 0x0D16 + ZOOM_Y = 0x0D17 + + COLOR_ARRAY_POINTER = 0x8090 + EDGE_FLAG_ARRAY_POINTER = 0x8093 + FEEDBACK_BUFFER_POINTER = 0x0DF0 + INDEX_ARRAY_POINTER = 0x8091 + NORMAL_ARRAY_POINTER = 0x808F + SELECTION_BUFFER_POINTER = 0x0DF3 + TEXTURE_COORD_ARRAY_POINTER = 0x8092 + VERTEX_ARRAY_POINTER = 0x808E + + TEXTURE_ALPHA_SIZE = 0x805F + TEXTURE_BLUE_SIZE = 0x805E + TEXTURE_BORDER = 0x1005 + TEXTURE_BORDER_COLOR = 0x1004 + TEXTURE_COMPONENTS = 0x1003 + TEXTURE_GREEN_SIZE = 0x805D + TEXTURE_HEIGHT = 0x1001 + TEXTURE_INTENSITY_SIZE = 0x8061 + TEXTURE_INTERNAL_FORMAT = 0x1003 + TEXTURE_LUMINANCE_SIZE = 0x8060 + TEXTURE_MAG_FILTER = 0x2800 + TEXTURE_MIN_FILTER = 0x2801 + TEXTURE_PRIORITY = 0x8066 + TEXTURE_RED_SIZE = 0x805C + TEXTURE_RESIDENT = 0x8067 + TEXTURE_WIDTH = 0x1000 + TEXTURE_WRAP_S = 0x2802 + TEXTURE_WRAP_T = 0x2803 + + DONT_CARE = 0x1100 + FASTEST = 0x1101 + NICEST = 0x1102 + + C3F_V3F = 0x2A24 + C4F_N3F_V3F = 0x2A26 + C4UB_V2F = 0x2A22 + C4UB_V3F = 0x2A23 + N3F_V3F = 0x2A25 + T2F_C3F_V3F = 0x2A2A + T2F_C4F_N3F_V3F = 0x2A2C + T2F_C4UB_V3F = 0x2A29 + T2F_N3F_V3F = 0x2A2B + T2F_V3F = 0x2A27 + T4F_C4F_N3F_V4F = 0x2A2D + T4F_V4F = 0x2A28 + V2F = 0x2A20 + V3F = 0x2A21 + + MODULATE = 0x2100 + REPLACE = 0x1E01 + + CONSTANT_ATTENUATION = 0x1207 + LINEAR_ATTENUATION = 0x1208 + POSITION = 0x1203 + QUADRATIC_ATTENUATION = 0x1209 + SPOT_CUTOFF = 0x1206 + SPOT_DIRECTION = 0x1204 + SPOT_EXPONENT = 0x1205 + + COMPILE = 0x1300 + COMPILE_AND_EXECUTE = 0x1301 + + AND = 0x1501 + AND_INVERTED = 0x1504 + AND_REVERSE = 0x1502 + CLEAR = 0x1500 + COPY = 0x1503 + COPY_INVERTED = 0x150C + EQUIV = 0x1509 + INVERT = 0x150A + NAND = 0x150E + NOOP = 0x1505 + NOR = 0x1508 + OR = 0x1507 + OR_INVERTED = 0x150D + OR_REVERSE = 0x150B + SET = 0x150F + XOR = 0x1506 + + COLOR_INDEXES = 0x1603 + SHININESS = 0x1601 + + MODELVIEW = 0x1700 + PROJECTION = 0x1701 + TEXTURE = 0x1702 + + LINE = 0x1B01 + POINT = 0x1B00 + + FILL = 0x1B02 + + COLOR = 0x1800 + DEPTH = 0x1801 + STENCIL = 0x1802 + + ALPHA = 0x1906 + BLUE = 0x1905 + COLOR_INDEX = 0x1900 + DEPTH_COMPONENT = 0x1902 + GREEN = 0x1904 + LUMINANCE = 0x1909 + LUMINANCE_ALPHA = 0x190A + RED = 0x1903 + RGB = 0x1907 + RGBA = 0x1908 + STENCIL_INDEX = 0x1901 + + ALPHA12 = 0x803D + ALPHA16 = 0x803E + ALPHA4 = 0x803B + ALPHA8 = 0x803C + INTENSITY = 0x8049 + INTENSITY12 = 0x804C + INTENSITY16 = 0x804D + INTENSITY4 = 0x804A + INTENSITY8 = 0x804B + LUMINANCE12 = 0x8041 + LUMINANCE12_ALPHA12 = 0x8047 + LUMINANCE12_ALPHA4 = 0x8046 + LUMINANCE16 = 0x8042 + LUMINANCE16_ALPHA16 = 0x8048 + LUMINANCE4 = 0x803F + LUMINANCE4_ALPHA4 = 0x8043 + LUMINANCE6_ALPHA2 = 0x8044 + LUMINANCE8 = 0x8040 + LUMINANCE8_ALPHA8 = 0x8045 + R3_G3_B2 = 0x2A10 + RGB10 = 0x8052 + RGB10_A2 = 0x8059 + RGB12 = 0x8053 + RGB16 = 0x8054 + RGB4 = 0x804F + RGB5 = 0x8050 + RGB5_A1 = 0x8057 + RGB8 = 0x8051 + RGBA12 = 0x805A + RGBA16 = 0x805B + RGBA2 = 0x8055 + RGBA4 = 0x8056 + RGBA8 = 0x8058 + + BITMAP = 0x1A00 + + LINES = 0x0001 + LINE_LOOP = 0x0002 + LINE_STRIP = 0x0003 + POINTS = 0x0000 + POLYGON = 0x0009 + QUADS = 0x0007 + QUAD_STRIP = 0x0008 + TRIANGLES = 0x0004 + TRIANGLE_FAN = 0x0006 + TRIANGLE_STRIP = 0x0005 + + FEEDBACK = 0x1C01 + RENDER = 0x1C00 + SELECT = 0x1C02 + + FLAT = 0x1D00 + SMOOTH = 0x1D01 + + DECR = 0x1E03 + INCR = 0x1E02 + KEEP = 0x1E00 + + EXTENSIONS = 0x1F03 + RENDERER = 0x1F01 + VENDOR = 0x1F00 + VERSION = 0x1F02 + + S = 0x2000 + T = 0x2001 + R = 0x2002 + Q = 0x2003 + + DECAL = 0x2101 + + TEXTURE_ENV_COLOR = 0x2201 + TEXTURE_ENV_MODE = 0x2200 + + TEXTURE_ENV = 0x2300 + + EYE_LINEAR = 0x2400 + OBJECT_LINEAR = 0x2401 + SPHERE_MAP = 0x2402 + + EYE_PLANE = 0x2502 + OBJECT_PLANE = 0x2501 + TEXTURE_GEN_MODE = 0x2500 + + NEAREST = 0x2600 + + LINEAR_MIPMAP_LINEAR = 0x2703 + LINEAR_MIPMAP_NEAREST = 0x2701 + NEAREST_MIPMAP_LINEAR = 0x2702 + NEAREST_MIPMAP_NEAREST = 0x2700 + + PROXY_TEXTURE_1D = 0x8063 + PROXY_TEXTURE_2D = 0x8064 + + CLAMP = 0x2900 + REPEAT = 0x2901 +) + +// https://www.opengl.org/sdk/docs/man2/xhtml/glViewport.xml +func (gl *GL) Viewport(x, y, width, height int) { + C.gl1_1_glViewport(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// DepthRange specifies the mapping of depth values from normalized device +// coordinates to window coordinates. +// +// Parameter nearVal specifies the mapping of the near clipping plane to window +// coordinates (defaults to 0), while farVal specifies the mapping of the far +// clipping plane to window coordinates (defaults to 1). +// +// After clipping and division by w, depth coordinates range from -1 to 1, +// corresponding to the near and far clipping planes. DepthRange specifies a +// linear mapping of the normalized depth coordinates in this range to window +// depth coordinates. Regardless of the actual depth buffer implementation, +// window coordinate depth values are treated as though they range from 0 through 1 +// (like color components). Thus, the values accepted by DepthRange are both +// clamped to this range before they are accepted. +// +// The default setting of (0, 1) maps the near plane to 0 and the far plane to 1. +// With this mapping, the depth buffer range is fully utilized. +// +// It is not necessary that nearVal be less than farVal. Reverse mappings such as +// nearVal 1, and farVal 0 are acceptable. +// +// GL.INVALID_OPERATION is generated if DepthRange is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) DepthRange(nearVal, farVal float64) { + C.gl1_1_glDepthRange(gl.funcs, C.GLdouble(nearVal), C.GLdouble(farVal)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsEnabled.xml +func (gl *GL) IsEnabled(cap glbase.Enum) bool { + glresult := C.gl1_1_glIsEnabled(gl.funcs, C.GLenum(cap)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexLevelParameteriv.xml +func (gl *GL) GetTexLevelParameteriv(target glbase.Enum, level int, pname glbase.Enum, params []int32) { + C.gl1_1_glGetTexLevelParameteriv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexLevelParameterfv.xml +func (gl *GL) GetTexLevelParameterfv(target glbase.Enum, level int, pname glbase.Enum, params []float32) { + C.gl1_1_glGetTexLevelParameterfv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexParameteriv.xml +func (gl *GL) GetTexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_1_glGetTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexParameterfv.xml +func (gl *GL) GetTexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_1_glGetTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexImage.xml +func (gl *GL) GetTexImage(target glbase.Enum, level int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_1_glGetTexImage(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetIntegerv.xml +func (gl *GL) GetIntegerv(pname glbase.Enum, params []int32) { + C.gl1_1_glGetIntegerv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetFloatv.xml +func (gl *GL) GetFloatv(pname glbase.Enum, params []float32) { + C.gl1_1_glGetFloatv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetError.xml +func (gl *GL) GetError() glbase.Enum { + glresult := C.gl1_1_glGetError(gl.funcs) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetDoublev.xml +func (gl *GL) GetDoublev(pname glbase.Enum, params []float64) { + C.gl1_1_glGetDoublev(gl.funcs, C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetBooleanv.xml +func (gl *GL) GetBooleanv(pname glbase.Enum, params []bool) { + C.gl1_1_glGetBooleanv(gl.funcs, C.GLenum(pname), (*C.GLboolean)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glReadPixels.xml +func (gl *GL) ReadPixels(x, y, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_1_glReadPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glReadBuffer.xml +func (gl *GL) ReadBuffer(mode glbase.Enum) { + C.gl1_1_glReadBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelStorei.xml +func (gl *GL) PixelStorei(pname glbase.Enum, param int32) { + C.gl1_1_glPixelStorei(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelStoref.xml +func (gl *GL) PixelStoref(pname glbase.Enum, param float32) { + C.gl1_1_glPixelStoref(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDepthFunc.xml +func (gl *GL) DepthFunc(glfunc glbase.Enum) { + C.gl1_1_glDepthFunc(gl.funcs, C.GLenum(glfunc)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilOp.xml +func (gl *GL) StencilOp(fail, zfail, zpass glbase.Enum) { + C.gl1_1_glStencilOp(gl.funcs, C.GLenum(fail), C.GLenum(zfail), C.GLenum(zpass)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilFunc.xml +func (gl *GL) StencilFunc(glfunc glbase.Enum, ref int32, mask uint32) { + C.gl1_1_glStencilFunc(gl.funcs, C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLogicOp.xml +func (gl *GL) LogicOp(opcode glbase.Enum) { + C.gl1_1_glLogicOp(gl.funcs, C.GLenum(opcode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBlendFunc.xml +func (gl *GL) BlendFunc(sfactor, dfactor glbase.Enum) { + C.gl1_1_glBlendFunc(gl.funcs, C.GLenum(sfactor), C.GLenum(dfactor)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFlush.xml +func (gl *GL) Flush() { + C.gl1_1_glFlush(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFinish.xml +func (gl *GL) Finish() { + C.gl1_1_glFinish(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEnable.xml +func (gl *GL) Enable(cap glbase.Enum) { + C.gl1_1_glEnable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDisable.xml +func (gl *GL) Disable(cap glbase.Enum) { + C.gl1_1_glDisable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDepthMask.xml +func (gl *GL) DepthMask(flag bool) { + C.gl1_1_glDepthMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorMask.xml +func (gl *GL) ColorMask(red, green, blue, alpha bool) { + C.gl1_1_glColorMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&red)), *(*C.GLboolean)(unsafe.Pointer(&green)), *(*C.GLboolean)(unsafe.Pointer(&blue)), *(*C.GLboolean)(unsafe.Pointer(&alpha))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilMask.xml +func (gl *GL) StencilMask(mask uint32) { + C.gl1_1_glStencilMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearDepth.xml +func (gl *GL) ClearDepth(depth float64) { + C.gl1_1_glClearDepth(gl.funcs, C.GLdouble(depth)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearStencil.xml +func (gl *GL) ClearStencil(s int32) { + C.gl1_1_glClearStencil(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearColor.xml +func (gl *GL) ClearColor(red, green, blue, alpha float32) { + C.gl1_1_glClearColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClear.xml +func (gl *GL) Clear(mask glbase.Bitfield) { + C.gl1_1_glClear(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawBuffer.xml +func (gl *GL) DrawBuffer(mode glbase.Enum) { + C.gl1_1_glDrawBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexImage2D.xml +func (gl *GL) TexImage2D(target glbase.Enum, level int, internalFormat int32, width, height, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_1_glTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexImage1D.xml +func (gl *GL) TexImage1D(target glbase.Enum, level int, internalFormat int32, width, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_1_glTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameteriv.xml +func (gl *GL) TexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_1_glTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameteri.xml +func (gl *GL) TexParameteri(target, pname glbase.Enum, param int32) { + C.gl1_1_glTexParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameterfv.xml +func (gl *GL) TexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_1_glTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameterf.xml +func (gl *GL) TexParameterf(target, pname glbase.Enum, param float32) { + C.gl1_1_glTexParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glScissor.xml +func (gl *GL) Scissor(x, y, width, height int) { + C.gl1_1_glScissor(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPolygonMode.xml +func (gl *GL) PolygonMode(face, mode glbase.Enum) { + C.gl1_1_glPolygonMode(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPointSize.xml +func (gl *GL) PointSize(size float32) { + C.gl1_1_glPointSize(gl.funcs, C.GLfloat(size)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLineWidth.xml +func (gl *GL) LineWidth(width float32) { + C.gl1_1_glLineWidth(gl.funcs, C.GLfloat(width)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glHint.xml +func (gl *GL) Hint(target, mode glbase.Enum) { + C.gl1_1_glHint(gl.funcs, C.GLenum(target), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFrontFace.xml +func (gl *GL) FrontFace(mode glbase.Enum) { + C.gl1_1_glFrontFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCullFace.xml +func (gl *GL) CullFace(mode glbase.Enum) { + C.gl1_1_glCullFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexubv.xml +func (gl *GL) Indexubv(c []uint8) { + C.gl1_1_glIndexubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexub.xml +func (gl *GL) Indexub(c uint8) { + C.gl1_1_glIndexub(gl.funcs, C.GLubyte(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsTexture.xml +func (gl *GL) IsTexture(texture glbase.Texture) bool { + glresult := C.gl1_1_glIsTexture(gl.funcs, C.GLuint(texture)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenTextures returns n texture names in textures. There is no guarantee +// that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenTextures. +// +// The generated textures have no dimensionality; they assume the +// dimensionality of the texture target to which they are first bound (see +// BindTexture). +// +// Texture names returned by a call to GenTextures are not returned by +// subsequent calls, unless they are first deleted with DeleteTextures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenTextures is available in GL version 2.0 or greater. +func (gl *GL) GenTextures(n int) []glbase.Texture { + if n == 0 { + return nil + } + textures := make([]glbase.Texture, n) + C.gl1_1_glGenTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) + return textures +} + +// DeleteTextures deletes the textures objects whose names are stored +// in the textures slice. After a texture is deleted, it has no contents or +// dimensionality, and its name is free for reuse (for example by +// GenTextures). If a texture that is currently bound is deleted, the binding +// reverts to 0 (the default texture). +// +// DeleteTextures silently ignores 0's and names that do not correspond to +// existing textures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteTextures is available in GL version 2.0 or greater. +func (gl *GL) DeleteTextures(textures []glbase.Texture) { + n := len(textures) + if n == 0 { + return + } + C.gl1_1_glDeleteTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBindTexture.xml +func (gl *GL) BindTexture(target glbase.Enum, texture glbase.Texture) { + C.gl1_1_glBindTexture(gl.funcs, C.GLenum(target), C.GLuint(texture)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexSubImage2D.xml +func (gl *GL) TexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_1_glTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexSubImage1D.xml +func (gl *GL) TexSubImage1D(target glbase.Enum, level, xoffset, width int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_1_glTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexSubImage2D.xml +func (gl *GL) CopyTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, x, y, width, height int) { + C.gl1_1_glCopyTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexSubImage1D.xml +func (gl *GL) CopyTexSubImage1D(target glbase.Enum, level, xoffset, x, y, width int) { + C.gl1_1_glCopyTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexImage2D.xml +func (gl *GL) CopyTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, height, border int) { + C.gl1_1_glCopyTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexImage1D.xml +func (gl *GL) CopyTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, border int) { + C.gl1_1_glCopyTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPolygonOffset.xml +func (gl *GL) PolygonOffset(factor, units float32) { + C.gl1_1_glPolygonOffset(gl.funcs, C.GLfloat(factor), C.GLfloat(units)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawElements.xml +func (gl *GL) DrawElements(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl1_1_glDrawElements(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawArrays.xml +func (gl *GL) DrawArrays(mode glbase.Enum, first, count int) { + C.gl1_1_glDrawArrays(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTranslatef.xml +func (gl *GL) Translatef(x, y, z float32) { + C.gl1_1_glTranslatef(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTranslated.xml +func (gl *GL) Translated(x, y, z float64) { + C.gl1_1_glTranslated(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glScalef.xml +func (gl *GL) Scalef(x, y, z float32) { + C.gl1_1_glScalef(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glScaled.xml +func (gl *GL) Scaled(x, y, z float64) { + C.gl1_1_glScaled(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRotatef.xml +func (gl *GL) Rotatef(angle, x, y, z float32) { + C.gl1_1_glRotatef(gl.funcs, C.GLfloat(angle), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRotated.xml +func (gl *GL) Rotated(angle, x, y, z float64) { + C.gl1_1_glRotated(gl.funcs, C.GLdouble(angle), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPushMatrix.xml +func (gl *GL) PushMatrix() { + C.gl1_1_glPushMatrix(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPopMatrix.xml +func (gl *GL) PopMatrix() { + C.gl1_1_glPopMatrix(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glOrtho.xml +func (gl *GL) Ortho(left, right, bottom, top, zNear, zFar float64) { + C.gl1_1_glOrtho(gl.funcs, C.GLdouble(left), C.GLdouble(right), C.GLdouble(bottom), C.GLdouble(top), C.GLdouble(zNear), C.GLdouble(zFar)) +} + +// MultMatrixd multiplies the current matrix with the provided matrix. +// +// The m parameter must hold 16 consecutive elements of a 4x4 column-major matrix. +// +// The current matrix is determined by the current matrix mode (see +// MatrixMode). It is either the projection matrix, modelview matrix, or the +// texture matrix. +// +// For example, if the current matrix is C and the coordinates to be transformed +// are v = (v[0], v[1], v[2], v[3]), then the current transformation is C × v, or +// +// c[0] c[4] c[8] c[12] v[0] +// c[1] c[5] c[9] c[13] v[1] +// c[2] c[6] c[10] c[14] X v[2] +// c[3] c[7] c[11] c[15] v[3] +// +// Calling MultMatrix with an argument of m = m[0], m[1], ..., m[15] +// replaces the current transformation with (C X M) x v, or +// +// c[0] c[4] c[8] c[12] m[0] m[4] m[8] m[12] v[0] +// c[1] c[5] c[9] c[13] m[1] m[5] m[9] m[13] v[1] +// c[2] c[6] c[10] c[14] X m[2] m[6] m[10] m[14] X v[2] +// c[3] c[7] c[11] c[15] m[3] m[7] m[11] m[15] v[3] +// +// Where 'X' denotes matrix multiplication, and v is represented as a 4x1 matrix. +// +// While the elements of the matrix may be specified with single or double +// precision, the GL may store or operate on these values in less-than-single +// precision. +// +// In many computer languages, 4×4 arrays are represented in row-major +// order. The transformations just described represent these matrices in +// column-major order. The order of the multiplication is important. For +// example, if the current transformation is a rotation, and MultMatrix is +// called with a translation matrix, the translation is done directly on the +// coordinates to be transformed, while the rotation is done on the results +// of that translation. +// +// GL.INVALID_OPERATION is generated if MultMatrix is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) MultMatrixd(m []float64) { + if len(m) != 16 { + panic("parameter m must have length 16 for the 4x4 matrix") + } + C.gl1_1_glMultMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// MultMatrixf multiplies the current matrix with the provided matrix. +// +// The m parameter must hold 16 consecutive elements of a 4x4 column-major matrix. +// +// The current matrix is determined by the current matrix mode (see +// MatrixMode). It is either the projection matrix, modelview matrix, or the +// texture matrix. +// +// For example, if the current matrix is C and the coordinates to be transformed +// are v = (v[0], v[1], v[2], v[3]), then the current transformation is C × v, or +// +// c[0] c[4] c[8] c[12] v[0] +// c[1] c[5] c[9] c[13] v[1] +// c[2] c[6] c[10] c[14] X v[2] +// c[3] c[7] c[11] c[15] v[3] +// +// Calling MultMatrix with an argument of m = m[0], m[1], ..., m[15] +// replaces the current transformation with (C X M) x v, or +// +// c[0] c[4] c[8] c[12] m[0] m[4] m[8] m[12] v[0] +// c[1] c[5] c[9] c[13] m[1] m[5] m[9] m[13] v[1] +// c[2] c[6] c[10] c[14] X m[2] m[6] m[10] m[14] X v[2] +// c[3] c[7] c[11] c[15] m[3] m[7] m[11] m[15] v[3] +// +// Where 'X' denotes matrix multiplication, and v is represented as a 4x1 matrix. +// +// While the elements of the matrix may be specified with single or double +// precision, the GL may store or operate on these values in less-than-single +// precision. +// +// In many computer languages, 4×4 arrays are represented in row-major +// order. The transformations just described represent these matrices in +// column-major order. The order of the multiplication is important. For +// example, if the current transformation is a rotation, and MultMatrix is +// called with a translation matrix, the translation is done directly on the +// coordinates to be transformed, while the rotation is done on the results +// of that translation. +// +// GL.INVALID_OPERATION is generated if MultMatrix is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) MultMatrixf(m []float32) { + if len(m) != 16 { + panic("parameter m must have length 16 for the 4x4 matrix") + } + C.gl1_1_glMultMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMatrixMode.xml +func (gl *GL) MatrixMode(mode glbase.Enum) { + C.gl1_1_glMatrixMode(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadMatrixd.xml +func (gl *GL) LoadMatrixd(m []float64) { + C.gl1_1_glLoadMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadMatrixf.xml +func (gl *GL) LoadMatrixf(m []float32) { + C.gl1_1_glLoadMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadIdentity.xml +func (gl *GL) LoadIdentity() { + C.gl1_1_glLoadIdentity(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFrustum.xml +func (gl *GL) Frustum(left, right, bottom, top, zNear, zFar float64) { + C.gl1_1_glFrustum(gl.funcs, C.GLdouble(left), C.GLdouble(right), C.GLdouble(bottom), C.GLdouble(top), C.GLdouble(zNear), C.GLdouble(zFar)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsList.xml +func (gl *GL) IsList(list uint32) bool { + glresult := C.gl1_1_glIsList(gl.funcs, C.GLuint(list)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexGeniv.xml +func (gl *GL) GetTexGeniv(coord, pname glbase.Enum, params []int32) { + C.gl1_1_glGetTexGeniv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexGenfv.xml +func (gl *GL) GetTexGenfv(coord, pname glbase.Enum, params []float32) { + C.gl1_1_glGetTexGenfv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexGendv.xml +func (gl *GL) GetTexGendv(coord, pname glbase.Enum, params []float64) { + C.gl1_1_glGetTexGendv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexEnviv.xml +func (gl *GL) GetTexEnviv(target, pname glbase.Enum, params []int32) { + C.gl1_1_glGetTexEnviv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexEnvfv.xml +func (gl *GL) GetTexEnvfv(target, pname glbase.Enum, params []float32) { + C.gl1_1_glGetTexEnvfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetPolygonStipple.xml +func (gl *GL) GetPolygonStipple(mask []uint8) { + C.gl1_1_glGetPolygonStipple(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&mask[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetPixelMapusv.xml +func (gl *GL) GetPixelMapusv(glmap glbase.Enum, values []uint16) { + C.gl1_1_glGetPixelMapusv(gl.funcs, C.GLenum(glmap), (*C.GLushort)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetPixelMapuiv.xml +func (gl *GL) GetPixelMapuiv(glmap glbase.Enum, values []uint32) { + C.gl1_1_glGetPixelMapuiv(gl.funcs, C.GLenum(glmap), (*C.GLuint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetPixelMapfv.xml +func (gl *GL) GetPixelMapfv(glmap glbase.Enum, values []float32) { + C.gl1_1_glGetPixelMapfv(gl.funcs, C.GLenum(glmap), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMaterialiv.xml +func (gl *GL) GetMaterialiv(face, pname glbase.Enum, params []int32) { + C.gl1_1_glGetMaterialiv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMaterialfv.xml +func (gl *GL) GetMaterialfv(face, pname glbase.Enum, params []float32) { + C.gl1_1_glGetMaterialfv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMapiv.xml +func (gl *GL) GetMapiv(target, query glbase.Enum, v []int32) { + C.gl1_1_glGetMapiv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMapfv.xml +func (gl *GL) GetMapfv(target, query glbase.Enum, v []float32) { + C.gl1_1_glGetMapfv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMapdv.xml +func (gl *GL) GetMapdv(target, query glbase.Enum, v []float64) { + C.gl1_1_glGetMapdv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetLightiv.xml +func (gl *GL) GetLightiv(light, pname glbase.Enum, params []int32) { + C.gl1_1_glGetLightiv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetLightfv.xml +func (gl *GL) GetLightfv(light, pname glbase.Enum, params []float32) { + C.gl1_1_glGetLightfv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetClipPlane.xml +func (gl *GL) GetClipPlane(plane glbase.Enum, equation []float64) { + C.gl1_1_glGetClipPlane(gl.funcs, C.GLenum(plane), (*C.GLdouble)(unsafe.Pointer(&equation[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawPixels.xml +func (gl *GL) DrawPixels(width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_1_glDrawPixels(gl.funcs, C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyPixels.xml +func (gl *GL) CopyPixels(x, y, width, height int, gltype glbase.Enum) { + C.gl1_1_glCopyPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(gltype)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelMapusv.xml +func (gl *GL) PixelMapusv(glmap glbase.Enum, mapsize int32, values []uint16) { + C.gl1_1_glPixelMapusv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLushort)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelMapuiv.xml +func (gl *GL) PixelMapuiv(glmap glbase.Enum, mapsize int32, values []uint32) { + C.gl1_1_glPixelMapuiv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLuint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelMapfv.xml +func (gl *GL) PixelMapfv(glmap glbase.Enum, mapsize int32, values []float32) { + C.gl1_1_glPixelMapfv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelTransferi.xml +func (gl *GL) PixelTransferi(pname glbase.Enum, param int32) { + C.gl1_1_glPixelTransferi(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelTransferf.xml +func (gl *GL) PixelTransferf(pname glbase.Enum, param float32) { + C.gl1_1_glPixelTransferf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelZoom.xml +func (gl *GL) PixelZoom(xfactor, yfactor float32) { + C.gl1_1_glPixelZoom(gl.funcs, C.GLfloat(xfactor), C.GLfloat(yfactor)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glAlphaFunc.xml +func (gl *GL) AlphaFunc(glfunc glbase.Enum, ref float32) { + C.gl1_1_glAlphaFunc(gl.funcs, C.GLenum(glfunc), C.GLfloat(ref)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalPoint2.xml +func (gl *GL) EvalPoint2(i, j int32) { + C.gl1_1_glEvalPoint2(gl.funcs, C.GLint(i), C.GLint(j)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalMesh2.xml +func (gl *GL) EvalMesh2(mode glbase.Enum, i1, i2, j1, j2 int32) { + C.gl1_1_glEvalMesh2(gl.funcs, C.GLenum(mode), C.GLint(i1), C.GLint(i2), C.GLint(j1), C.GLint(j2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalPoint1.xml +func (gl *GL) EvalPoint1(i int32) { + C.gl1_1_glEvalPoint1(gl.funcs, C.GLint(i)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalMesh1.xml +func (gl *GL) EvalMesh1(mode glbase.Enum, i1, i2 int32) { + C.gl1_1_glEvalMesh1(gl.funcs, C.GLenum(mode), C.GLint(i1), C.GLint(i2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord2fv.xml +func (gl *GL) EvalCoord2fv(u []float32) { + if len(u) != 2 { + panic("parameter u has incorrect length") + } + C.gl1_1_glEvalCoord2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord2f.xml +func (gl *GL) EvalCoord2f(u, v float32) { + C.gl1_1_glEvalCoord2f(gl.funcs, C.GLfloat(u), C.GLfloat(v)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord2dv.xml +func (gl *GL) EvalCoord2dv(u []float64) { + if len(u) != 2 { + panic("parameter u has incorrect length") + } + C.gl1_1_glEvalCoord2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord2d.xml +func (gl *GL) EvalCoord2d(u, v float64) { + C.gl1_1_glEvalCoord2d(gl.funcs, C.GLdouble(u), C.GLdouble(v)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord1fv.xml +func (gl *GL) EvalCoord1fv(u []float32) { + C.gl1_1_glEvalCoord1fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord1f.xml +func (gl *GL) EvalCoord1f(u float32) { + C.gl1_1_glEvalCoord1f(gl.funcs, C.GLfloat(u)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord1dv.xml +func (gl *GL) EvalCoord1dv(u []float64) { + C.gl1_1_glEvalCoord1dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord1d.xml +func (gl *GL) EvalCoord1d(u float64) { + C.gl1_1_glEvalCoord1d(gl.funcs, C.GLdouble(u)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMapGrid2f.xml +func (gl *GL) MapGrid2f(un int32, u1, u2 float32, vn int32, v1, v2 float32) { + C.gl1_1_glMapGrid2f(gl.funcs, C.GLint(un), C.GLfloat(u1), C.GLfloat(u2), C.GLint(vn), C.GLfloat(v1), C.GLfloat(v2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMapGrid2d.xml +func (gl *GL) MapGrid2d(un int32, u1, u2 float64, vn int32, v1, v2 float64) { + C.gl1_1_glMapGrid2d(gl.funcs, C.GLint(un), C.GLdouble(u1), C.GLdouble(u2), C.GLint(vn), C.GLdouble(v1), C.GLdouble(v2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMapGrid1f.xml +func (gl *GL) MapGrid1f(un int32, u1, u2 float32) { + C.gl1_1_glMapGrid1f(gl.funcs, C.GLint(un), C.GLfloat(u1), C.GLfloat(u2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMapGrid1d.xml +func (gl *GL) MapGrid1d(un int32, u1, u2 float64) { + C.gl1_1_glMapGrid1d(gl.funcs, C.GLint(un), C.GLdouble(u1), C.GLdouble(u2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMap2f.xml +func (gl *GL) Map2f(target glbase.Enum, u1, u2 float32, ustride, uorder int32, v1, v2 float32, vstride, vorder int32, points []float32) { + C.gl1_1_glMap2f(gl.funcs, C.GLenum(target), C.GLfloat(u1), C.GLfloat(u2), C.GLint(ustride), C.GLint(uorder), C.GLfloat(v1), C.GLfloat(v2), C.GLint(vstride), C.GLint(vorder), (*C.GLfloat)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMap2d.xml +func (gl *GL) Map2d(target glbase.Enum, u1, u2 float64, ustride, uorder int32, v1, v2 float64, vstride, vorder int32, points []float64) { + C.gl1_1_glMap2d(gl.funcs, C.GLenum(target), C.GLdouble(u1), C.GLdouble(u2), C.GLint(ustride), C.GLint(uorder), C.GLdouble(v1), C.GLdouble(v2), C.GLint(vstride), C.GLint(vorder), (*C.GLdouble)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMap1f.xml +func (gl *GL) Map1f(target glbase.Enum, u1, u2 float32, stride, order int, points []float32) { + C.gl1_1_glMap1f(gl.funcs, C.GLenum(target), C.GLfloat(u1), C.GLfloat(u2), C.GLint(stride), C.GLint(order), (*C.GLfloat)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMap1d.xml +func (gl *GL) Map1d(target glbase.Enum, u1, u2 float64, stride, order int, points []float64) { + C.gl1_1_glMap1d(gl.funcs, C.GLenum(target), C.GLdouble(u1), C.GLdouble(u2), C.GLint(stride), C.GLint(order), (*C.GLdouble)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPushAttrib.xml +func (gl *GL) PushAttrib(mask glbase.Bitfield) { + C.gl1_1_glPushAttrib(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPopAttrib.xml +func (gl *GL) PopAttrib() { + C.gl1_1_glPopAttrib(gl.funcs) +} + +// Accum executes an operation on the accumulation buffer. +// +// Parameter op defines the accumulation buffer operation (GL.ACCUM, GL.LOAD, +// GL.ADD, GL.MULT, or GL.RETURN) and specifies how the value parameter is +// used. +// +// The accumulation buffer is an extended-range color buffer. Images are not +// rendered into it. Rather, images rendered into one of the color buffers +// are added to the contents of the accumulation buffer after rendering. +// Effects such as antialiasing (of points, lines, and polygons), motion +// blur, and depth of field can be created by accumulating images generated +// with different transformation matrices. +// +// Each pixel in the accumulation buffer consists of red, green, blue, and +// alpha values. The number of bits per component in the accumulation buffer +// depends on the implementation. You can examine this number by calling +// GetIntegerv four times, with arguments GL.ACCUM_RED_BITS, +// GL.ACCUM_GREEN_BITS, GL.ACCUM_BLUE_BITS, and GL.ACCUM_ALPHA_BITS. +// Regardless of the number of bits per component, the range of values stored +// by each component is (-1, 1). The accumulation buffer pixels are mapped +// one-to-one with frame buffer pixels. +// +// All accumulation buffer operations are limited to the area of the current +// scissor box and applied identically to the red, green, blue, and alpha +// components of each pixel. If a Accum operation results in a value outside +// the range (-1, 1), the contents of an accumulation buffer pixel component +// are undefined. +// +// The operations are as follows: +// +// GL.ACCUM +// Obtains R, G, B, and A values from the buffer currently selected for +// reading (see ReadBuffer). Each component value is divided by 2 n - +// 1 , where n is the number of bits allocated to each color component +// in the currently selected buffer. The result is a floating-point +// value in the range 0 1 , which is multiplied by value and added to +// the corresponding pixel component in the accumulation buffer, +// thereby updating the accumulation buffer. +// +// GL.LOAD +// Similar to GL.ACCUM, except that the current value in the +// accumulation buffer is not used in the calculation of the new value. +// That is, the R, G, B, and A values from the currently selected +// buffer are divided by 2 n - 1 , multiplied by value, and then stored +// in the corresponding accumulation buffer cell, overwriting the +// current value. +// +// GL.ADD +// Adds value to each R, G, B, and A in the accumulation buffer. +// +// GL.MULT +// Multiplies each R, G, B, and A in the accumulation buffer by value +// and returns the scaled component to its corresponding accumulation +// buffer location. +// +// GL.RETURN +// Transfers accumulation buffer values to the color buffer or buffers +// currently selected for writing. Each R, G, B, and A component is +// multiplied by value, then multiplied by 2 n - 1 , clamped to the +// range 0 2 n - 1 , and stored in the corresponding display buffer +// cell. The only fragment operations that are applied to this transfer +// are pixel ownership, scissor, dithering, and color writemasks. +// +// To clear the accumulation buffer, call ClearAccum with R, G, B, and A +// values to set it to, then call Clear with the accumulation buffer +// enabled. +// +// Error GL.INVALID_ENUM is generated if op is not an accepted value. +// GL.INVALID_OPERATION is generated if there is no accumulation buffer. +// GL.INVALID_OPERATION is generated if Accum is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) Accum(op glbase.Enum, value float32) { + C.gl1_1_glAccum(gl.funcs, C.GLenum(op), C.GLfloat(value)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexMask.xml +func (gl *GL) IndexMask(mask uint32) { + C.gl1_1_glIndexMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearIndex.xml +func (gl *GL) ClearIndex(c float32) { + C.gl1_1_glClearIndex(gl.funcs, C.GLfloat(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearAccum.xml +func (gl *GL) ClearAccum(red, green, blue, alpha float32) { + C.gl1_1_glClearAccum(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPushName.xml +func (gl *GL) PushName(name uint32) { + C.gl1_1_glPushName(gl.funcs, C.GLuint(name)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPopName.xml +func (gl *GL) PopName() { + C.gl1_1_glPopName(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPassThrough.xml +func (gl *GL) PassThrough(token float32) { + C.gl1_1_glPassThrough(gl.funcs, C.GLfloat(token)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadName.xml +func (gl *GL) LoadName(name uint32) { + C.gl1_1_glLoadName(gl.funcs, C.GLuint(name)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glInitNames.xml +func (gl *GL) InitNames() { + C.gl1_1_glInitNames(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRenderMode.xml +func (gl *GL) RenderMode(mode glbase.Enum) int32 { + glresult := C.gl1_1_glRenderMode(gl.funcs, C.GLenum(mode)) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSelectBuffer.xml +func (gl *GL) SelectBuffer(size int, buffer []glbase.Buffer) { + C.gl1_1_glSelectBuffer(gl.funcs, C.GLsizei(size), (*C.GLuint)(unsafe.Pointer(&buffer[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFeedbackBuffer.xml +func (gl *GL) FeedbackBuffer(size int, gltype glbase.Enum, buffer []float32) { + C.gl1_1_glFeedbackBuffer(gl.funcs, C.GLsizei(size), C.GLenum(gltype), (*C.GLfloat)(unsafe.Pointer(&buffer[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGeniv.xml +func (gl *GL) TexGeniv(coord, pname glbase.Enum, params []int32) { + C.gl1_1_glTexGeniv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGeni.xml +func (gl *GL) TexGeni(coord, pname glbase.Enum, param int32) { + C.gl1_1_glTexGeni(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGenfv.xml +func (gl *GL) TexGenfv(coord, pname glbase.Enum, params []float32) { + C.gl1_1_glTexGenfv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGenf.xml +func (gl *GL) TexGenf(coord, pname glbase.Enum, param float32) { + C.gl1_1_glTexGenf(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGendv.xml +func (gl *GL) TexGendv(coord, pname glbase.Enum, params []float64) { + C.gl1_1_glTexGendv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGend.xml +func (gl *GL) TexGend(coord, pname glbase.Enum, param float64) { + C.gl1_1_glTexGend(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLdouble(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnviv.xml +func (gl *GL) TexEnviv(target, pname glbase.Enum, params []int32) { + C.gl1_1_glTexEnviv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnvi.xml +func (gl *GL) TexEnvi(target, pname glbase.Enum, param int32) { + C.gl1_1_glTexEnvi(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnvfv.xml +func (gl *GL) TexEnvfv(target, pname glbase.Enum, params []float32) { + C.gl1_1_glTexEnvfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnvf.xml +func (gl *GL) TexEnvf(target, pname glbase.Enum, param float32) { + C.gl1_1_glTexEnvf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glShadeModel.xml +func (gl *GL) ShadeModel(mode glbase.Enum) { + C.gl1_1_glShadeModel(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPolygonStipple.xml +func (gl *GL) PolygonStipple(mask []uint8) { + C.gl1_1_glPolygonStipple(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&mask[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMaterialiv.xml +func (gl *GL) Materialiv(face, pname glbase.Enum, params []int32) { + C.gl1_1_glMaterialiv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMateriali.xml +func (gl *GL) Materiali(face, pname glbase.Enum, param int32) { + C.gl1_1_glMateriali(gl.funcs, C.GLenum(face), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMaterialfv.xml +func (gl *GL) Materialfv(face, pname glbase.Enum, params []float32) { + C.gl1_1_glMaterialfv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMaterialf.xml +func (gl *GL) Materialf(face, pname glbase.Enum, param float32) { + C.gl1_1_glMaterialf(gl.funcs, C.GLenum(face), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLineStipple.xml +func (gl *GL) LineStipple(factor int32, pattern uint16) { + C.gl1_1_glLineStipple(gl.funcs, C.GLint(factor), C.GLushort(pattern)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightModeliv.xml +func (gl *GL) LightModeliv(pname glbase.Enum, params []int32) { + C.gl1_1_glLightModeliv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightModeli.xml +func (gl *GL) LightModeli(pname glbase.Enum, param int32) { + C.gl1_1_glLightModeli(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightModelfv.xml +func (gl *GL) LightModelfv(pname glbase.Enum, params []float32) { + C.gl1_1_glLightModelfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightModelf.xml +func (gl *GL) LightModelf(pname glbase.Enum, param float32) { + C.gl1_1_glLightModelf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightiv.xml +func (gl *GL) Lightiv(light, pname glbase.Enum, params []int32) { + C.gl1_1_glLightiv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLighti.xml +func (gl *GL) Lighti(light, pname glbase.Enum, param int32) { + C.gl1_1_glLighti(gl.funcs, C.GLenum(light), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightfv.xml +func (gl *GL) Lightfv(light, pname glbase.Enum, params []float32) { + C.gl1_1_glLightfv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightf.xml +func (gl *GL) Lightf(light, pname glbase.Enum, param float32) { + C.gl1_1_glLightf(gl.funcs, C.GLenum(light), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogiv.xml +func (gl *GL) Fogiv(pname glbase.Enum, params []int32) { + C.gl1_1_glFogiv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogi.xml +func (gl *GL) Fogi(pname glbase.Enum, param int32) { + C.gl1_1_glFogi(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogfv.xml +func (gl *GL) Fogfv(pname glbase.Enum, params []float32) { + C.gl1_1_glFogfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogf.xml +func (gl *GL) Fogf(pname glbase.Enum, param float32) { + C.gl1_1_glFogf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorMaterial.xml +func (gl *GL) ColorMaterial(face, mode glbase.Enum) { + C.gl1_1_glColorMaterial(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClipPlane.xml +func (gl *GL) ClipPlane(plane glbase.Enum, equation []float64) { + C.gl1_1_glClipPlane(gl.funcs, C.GLenum(plane), (*C.GLdouble)(unsafe.Pointer(&equation[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4sv.xml +func (gl *GL) Vertex4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_1_glVertex4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4s.xml +func (gl *GL) Vertex4s(x, y, z, w int16) { + C.gl1_1_glVertex4s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4iv.xml +func (gl *GL) Vertex4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_1_glVertex4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4i.xml +func (gl *GL) Vertex4i(x, y, z, w int) { + C.gl1_1_glVertex4i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4fv.xml +func (gl *GL) Vertex4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_1_glVertex4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4f.xml +func (gl *GL) Vertex4f(x, y, z, w float32) { + C.gl1_1_glVertex4f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4dv.xml +func (gl *GL) Vertex4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_1_glVertex4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4d.xml +func (gl *GL) Vertex4d(x, y, z, w float64) { + C.gl1_1_glVertex4d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3sv.xml +func (gl *GL) Vertex3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_1_glVertex3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3s.xml +func (gl *GL) Vertex3s(x, y, z int16) { + C.gl1_1_glVertex3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3iv.xml +func (gl *GL) Vertex3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_1_glVertex3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3i.xml +func (gl *GL) Vertex3i(x, y, z int) { + C.gl1_1_glVertex3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3fv.xml +func (gl *GL) Vertex3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_1_glVertex3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3f.xml +func (gl *GL) Vertex3f(x, y, z float32) { + C.gl1_1_glVertex3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3dv.xml +func (gl *GL) Vertex3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_1_glVertex3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3d.xml +func (gl *GL) Vertex3d(x, y, z float64) { + C.gl1_1_glVertex3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2sv.xml +func (gl *GL) Vertex2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_1_glVertex2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2s.xml +func (gl *GL) Vertex2s(x, y int16) { + C.gl1_1_glVertex2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2iv.xml +func (gl *GL) Vertex2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_1_glVertex2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2i.xml +func (gl *GL) Vertex2i(x, y int) { + C.gl1_1_glVertex2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2fv.xml +func (gl *GL) Vertex2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_1_glVertex2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2f.xml +func (gl *GL) Vertex2f(x, y float32) { + C.gl1_1_glVertex2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2dv.xml +func (gl *GL) Vertex2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_1_glVertex2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2d.xml +func (gl *GL) Vertex2d(x, y float64) { + C.gl1_1_glVertex2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4sv.xml +func (gl *GL) TexCoord4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_1_glTexCoord4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4s.xml +func (gl *GL) TexCoord4s(s, t, r, q int16) { + C.gl1_1_glTexCoord4s(gl.funcs, C.GLshort(s), C.GLshort(t), C.GLshort(r), C.GLshort(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4iv.xml +func (gl *GL) TexCoord4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_1_glTexCoord4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4i.xml +func (gl *GL) TexCoord4i(s, t, r, q int32) { + C.gl1_1_glTexCoord4i(gl.funcs, C.GLint(s), C.GLint(t), C.GLint(r), C.GLint(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4fv.xml +func (gl *GL) TexCoord4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_1_glTexCoord4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4f.xml +func (gl *GL) TexCoord4f(s, t, r, q float32) { + C.gl1_1_glTexCoord4f(gl.funcs, C.GLfloat(s), C.GLfloat(t), C.GLfloat(r), C.GLfloat(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4dv.xml +func (gl *GL) TexCoord4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_1_glTexCoord4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4d.xml +func (gl *GL) TexCoord4d(s, t, r, q float64) { + C.gl1_1_glTexCoord4d(gl.funcs, C.GLdouble(s), C.GLdouble(t), C.GLdouble(r), C.GLdouble(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3sv.xml +func (gl *GL) TexCoord3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_1_glTexCoord3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3s.xml +func (gl *GL) TexCoord3s(s, t, r int16) { + C.gl1_1_glTexCoord3s(gl.funcs, C.GLshort(s), C.GLshort(t), C.GLshort(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3iv.xml +func (gl *GL) TexCoord3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_1_glTexCoord3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3i.xml +func (gl *GL) TexCoord3i(s, t, r int32) { + C.gl1_1_glTexCoord3i(gl.funcs, C.GLint(s), C.GLint(t), C.GLint(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3fv.xml +func (gl *GL) TexCoord3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_1_glTexCoord3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3f.xml +func (gl *GL) TexCoord3f(s, t, r float32) { + C.gl1_1_glTexCoord3f(gl.funcs, C.GLfloat(s), C.GLfloat(t), C.GLfloat(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3dv.xml +func (gl *GL) TexCoord3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_1_glTexCoord3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3d.xml +func (gl *GL) TexCoord3d(s, t, r float64) { + C.gl1_1_glTexCoord3d(gl.funcs, C.GLdouble(s), C.GLdouble(t), C.GLdouble(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2sv.xml +func (gl *GL) TexCoord2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_1_glTexCoord2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2s.xml +func (gl *GL) TexCoord2s(s, t int16) { + C.gl1_1_glTexCoord2s(gl.funcs, C.GLshort(s), C.GLshort(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2iv.xml +func (gl *GL) TexCoord2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_1_glTexCoord2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2i.xml +func (gl *GL) TexCoord2i(s, t int32) { + C.gl1_1_glTexCoord2i(gl.funcs, C.GLint(s), C.GLint(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2fv.xml +func (gl *GL) TexCoord2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_1_glTexCoord2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2f.xml +func (gl *GL) TexCoord2f(s, t float32) { + C.gl1_1_glTexCoord2f(gl.funcs, C.GLfloat(s), C.GLfloat(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2dv.xml +func (gl *GL) TexCoord2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_1_glTexCoord2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2d.xml +func (gl *GL) TexCoord2d(s, t float64) { + C.gl1_1_glTexCoord2d(gl.funcs, C.GLdouble(s), C.GLdouble(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1sv.xml +func (gl *GL) TexCoord1sv(v []int16) { + C.gl1_1_glTexCoord1sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1s.xml +func (gl *GL) TexCoord1s(s int16) { + C.gl1_1_glTexCoord1s(gl.funcs, C.GLshort(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1iv.xml +func (gl *GL) TexCoord1iv(v []int32) { + C.gl1_1_glTexCoord1iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1i.xml +func (gl *GL) TexCoord1i(s int32) { + C.gl1_1_glTexCoord1i(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1fv.xml +func (gl *GL) TexCoord1fv(v []float32) { + C.gl1_1_glTexCoord1fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1f.xml +func (gl *GL) TexCoord1f(s float32) { + C.gl1_1_glTexCoord1f(gl.funcs, C.GLfloat(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1dv.xml +func (gl *GL) TexCoord1dv(v []float64) { + C.gl1_1_glTexCoord1dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1d.xml +func (gl *GL) TexCoord1d(s float64) { + C.gl1_1_glTexCoord1d(gl.funcs, C.GLdouble(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectsv.xml +func (gl *GL) Rectsv(v1, v2 []int16) { + C.gl1_1_glRectsv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v1[0])), (*C.GLshort)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRects.xml +func (gl *GL) Rects(x1, y1, x2, y2 int16) { + C.gl1_1_glRects(gl.funcs, C.GLshort(x1), C.GLshort(y1), C.GLshort(x2), C.GLshort(y2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectiv.xml +func (gl *GL) Rectiv(v1, v2 []int32) { + C.gl1_1_glRectiv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v1[0])), (*C.GLint)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRecti.xml +func (gl *GL) Recti(x1, y1, x2, y2 int32) { + C.gl1_1_glRecti(gl.funcs, C.GLint(x1), C.GLint(y1), C.GLint(x2), C.GLint(y2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectfv.xml +func (gl *GL) Rectfv(v1, v2 []float32) { + C.gl1_1_glRectfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v1[0])), (*C.GLfloat)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectf.xml +func (gl *GL) Rectf(x1, y1, x2, y2 float32) { + C.gl1_1_glRectf(gl.funcs, C.GLfloat(x1), C.GLfloat(y1), C.GLfloat(x2), C.GLfloat(y2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectdv.xml +func (gl *GL) Rectdv(v1, v2 []float64) { + C.gl1_1_glRectdv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v1[0])), (*C.GLdouble)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectd.xml +func (gl *GL) Rectd(x1, y1, x2, y2 float64) { + C.gl1_1_glRectd(gl.funcs, C.GLdouble(x1), C.GLdouble(y1), C.GLdouble(x2), C.GLdouble(y2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4sv.xml +func (gl *GL) RasterPos4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_1_glRasterPos4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4s.xml +func (gl *GL) RasterPos4s(x, y, z, w int16) { + C.gl1_1_glRasterPos4s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4iv.xml +func (gl *GL) RasterPos4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_1_glRasterPos4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4i.xml +func (gl *GL) RasterPos4i(x, y, z, w int) { + C.gl1_1_glRasterPos4i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4fv.xml +func (gl *GL) RasterPos4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_1_glRasterPos4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4f.xml +func (gl *GL) RasterPos4f(x, y, z, w float32) { + C.gl1_1_glRasterPos4f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4dv.xml +func (gl *GL) RasterPos4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_1_glRasterPos4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4d.xml +func (gl *GL) RasterPos4d(x, y, z, w float64) { + C.gl1_1_glRasterPos4d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3sv.xml +func (gl *GL) RasterPos3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_1_glRasterPos3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3s.xml +func (gl *GL) RasterPos3s(x, y, z int16) { + C.gl1_1_glRasterPos3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3iv.xml +func (gl *GL) RasterPos3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_1_glRasterPos3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3i.xml +func (gl *GL) RasterPos3i(x, y, z int) { + C.gl1_1_glRasterPos3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3fv.xml +func (gl *GL) RasterPos3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_1_glRasterPos3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3f.xml +func (gl *GL) RasterPos3f(x, y, z float32) { + C.gl1_1_glRasterPos3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3dv.xml +func (gl *GL) RasterPos3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_1_glRasterPos3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3d.xml +func (gl *GL) RasterPos3d(x, y, z float64) { + C.gl1_1_glRasterPos3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2sv.xml +func (gl *GL) RasterPos2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_1_glRasterPos2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2s.xml +func (gl *GL) RasterPos2s(x, y int16) { + C.gl1_1_glRasterPos2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2iv.xml +func (gl *GL) RasterPos2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_1_glRasterPos2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2i.xml +func (gl *GL) RasterPos2i(x, y int) { + C.gl1_1_glRasterPos2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2fv.xml +func (gl *GL) RasterPos2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_1_glRasterPos2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2f.xml +func (gl *GL) RasterPos2f(x, y float32) { + C.gl1_1_glRasterPos2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2dv.xml +func (gl *GL) RasterPos2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_1_glRasterPos2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2d.xml +func (gl *GL) RasterPos2d(x, y float64) { + C.gl1_1_glRasterPos2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3sv.xml +func (gl *GL) Normal3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_1_glNormal3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3s.xml +func (gl *GL) Normal3s(nx, ny, nz int16) { + C.gl1_1_glNormal3s(gl.funcs, C.GLshort(nx), C.GLshort(ny), C.GLshort(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3iv.xml +func (gl *GL) Normal3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_1_glNormal3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3i.xml +func (gl *GL) Normal3i(nx, ny, nz int32) { + C.gl1_1_glNormal3i(gl.funcs, C.GLint(nx), C.GLint(ny), C.GLint(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3fv.xml +func (gl *GL) Normal3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_1_glNormal3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3f.xml +func (gl *GL) Normal3f(nx, ny, nz float32) { + C.gl1_1_glNormal3f(gl.funcs, C.GLfloat(nx), C.GLfloat(ny), C.GLfloat(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3dv.xml +func (gl *GL) Normal3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_1_glNormal3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3d.xml +func (gl *GL) Normal3d(nx, ny, nz float64) { + C.gl1_1_glNormal3d(gl.funcs, C.GLdouble(nx), C.GLdouble(ny), C.GLdouble(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3bv.xml +func (gl *GL) Normal3bv(v []byte) { + C.gl1_1_glNormal3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3b.xml +func (gl *GL) Normal3b(nx, ny, nz byte) { + C.gl1_1_glNormal3b(gl.funcs, C.GLbyte(nx), C.GLbyte(ny), C.GLbyte(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexsv.xml +func (gl *GL) Indexsv(c []int16) { + C.gl1_1_glIndexsv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexs.xml +func (gl *GL) Indexs(c int16) { + C.gl1_1_glIndexs(gl.funcs, C.GLshort(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexiv.xml +func (gl *GL) Indexiv(c []int32) { + C.gl1_1_glIndexiv(gl.funcs, (*C.GLint)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexi.xml +func (gl *GL) Indexi(c int32) { + C.gl1_1_glIndexi(gl.funcs, C.GLint(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexfv.xml +func (gl *GL) Indexfv(c []float32) { + C.gl1_1_glIndexfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexf.xml +func (gl *GL) Indexf(c float32) { + C.gl1_1_glIndexf(gl.funcs, C.GLfloat(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexdv.xml +func (gl *GL) Indexdv(c []float64) { + C.gl1_1_glIndexdv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexd.xml +func (gl *GL) Indexd(c float64) { + C.gl1_1_glIndexd(gl.funcs, C.GLdouble(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEnd.xml +func (gl *GL) End() { + C.gl1_1_glEnd(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEdgeFlagv.xml +func (gl *GL) EdgeFlagv(flag []bool) { + C.gl1_1_glEdgeFlagv(gl.funcs, (*C.GLboolean)(unsafe.Pointer(&flag[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEdgeFlag.xml +func (gl *GL) EdgeFlag(flag bool) { + C.gl1_1_glEdgeFlag(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4usv.xml +func (gl *GL) Color4usv(v []uint16) { + C.gl1_1_glColor4usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4us.xml +func (gl *GL) Color4us(red, green, blue, alpha uint16) { + C.gl1_1_glColor4us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue), C.GLushort(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4uiv.xml +func (gl *GL) Color4uiv(v []uint32) { + C.gl1_1_glColor4uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4ui.xml +func (gl *GL) Color4ui(red, green, blue, alpha uint32) { + C.gl1_1_glColor4ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue), C.GLuint(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4ubv.xml +func (gl *GL) Color4ubv(v []uint8) { + C.gl1_1_glColor4ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4ub.xml +func (gl *GL) Color4ub(red, green, blue, alpha uint8) { + C.gl1_1_glColor4ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue), C.GLubyte(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4sv.xml +func (gl *GL) Color4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_1_glColor4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4s.xml +func (gl *GL) Color4s(red, green, blue, alpha int16) { + C.gl1_1_glColor4s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue), C.GLshort(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4iv.xml +func (gl *GL) Color4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_1_glColor4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4i.xml +func (gl *GL) Color4i(red, green, blue, alpha int32) { + C.gl1_1_glColor4i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue), C.GLint(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4fv.xml +func (gl *GL) Color4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_1_glColor4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4f.xml +func (gl *GL) Color4f(red, green, blue, alpha float32) { + C.gl1_1_glColor4f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4dv.xml +func (gl *GL) Color4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_1_glColor4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4d.xml +func (gl *GL) Color4d(red, green, blue, alpha float64) { + C.gl1_1_glColor4d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue), C.GLdouble(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4bv.xml +func (gl *GL) Color4bv(v []byte) { + C.gl1_1_glColor4bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4b.xml +func (gl *GL) Color4b(red, green, blue, alpha byte) { + C.gl1_1_glColor4b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue), C.GLbyte(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3usv.xml +func (gl *GL) Color3usv(v []uint16) { + C.gl1_1_glColor3usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3us.xml +func (gl *GL) Color3us(red, green, blue uint16) { + C.gl1_1_glColor3us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3uiv.xml +func (gl *GL) Color3uiv(v []uint32) { + C.gl1_1_glColor3uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3ui.xml +func (gl *GL) Color3ui(red, green, blue uint32) { + C.gl1_1_glColor3ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3ubv.xml +func (gl *GL) Color3ubv(v []uint8) { + C.gl1_1_glColor3ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3ub.xml +func (gl *GL) Color3ub(red, green, blue uint8) { + C.gl1_1_glColor3ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3sv.xml +func (gl *GL) Color3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_1_glColor3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3s.xml +func (gl *GL) Color3s(red, green, blue int16) { + C.gl1_1_glColor3s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3iv.xml +func (gl *GL) Color3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_1_glColor3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3i.xml +func (gl *GL) Color3i(red, green, blue int32) { + C.gl1_1_glColor3i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3fv.xml +func (gl *GL) Color3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_1_glColor3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3f.xml +func (gl *GL) Color3f(red, green, blue float32) { + C.gl1_1_glColor3f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3dv.xml +func (gl *GL) Color3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_1_glColor3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3d.xml +func (gl *GL) Color3d(red, green, blue float64) { + C.gl1_1_glColor3d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3bv.xml +func (gl *GL) Color3bv(v []byte) { + C.gl1_1_glColor3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3b.xml +func (gl *GL) Color3b(red, green, blue byte) { + C.gl1_1_glColor3b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBitmap.xml +func (gl *GL) Bitmap(width, height int, xorig, yorig, xmove, ymove float32, bitmap []uint8) { + C.gl1_1_glBitmap(gl.funcs, C.GLsizei(width), C.GLsizei(height), C.GLfloat(xorig), C.GLfloat(yorig), C.GLfloat(xmove), C.GLfloat(ymove), (*C.GLubyte)(unsafe.Pointer(&bitmap[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBegin.xml +func (gl *GL) Begin(mode glbase.Enum) { + C.gl1_1_glBegin(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glListBase.xml +func (gl *GL) ListBase(base uint32) { + C.gl1_1_glListBase(gl.funcs, C.GLuint(base)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGenLists.xml +func (gl *GL) GenLists(range_ int32) uint32 { + glresult := C.gl1_1_glGenLists(gl.funcs, C.GLsizei(range_)) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDeleteLists.xml +func (gl *GL) DeleteLists(list uint32, range_ int32) { + C.gl1_1_glDeleteLists(gl.funcs, C.GLuint(list), C.GLsizei(range_)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCallLists.xml +func (gl *GL) CallLists(n int, gltype glbase.Enum, lists interface{}) { + var lists_ptr unsafe.Pointer + var lists_v = reflect.ValueOf(lists) + if lists != nil && lists_v.Kind() != reflect.Slice { + panic("parameter lists must be a slice") + } + if lists != nil { + lists_ptr = unsafe.Pointer(lists_v.Index(0).Addr().Pointer()) + } + C.gl1_1_glCallLists(gl.funcs, C.GLsizei(n), C.GLenum(gltype), lists_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCallList.xml +func (gl *GL) CallList(list uint32) { + C.gl1_1_glCallList(gl.funcs, C.GLuint(list)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEndList.xml +func (gl *GL) EndList() { + C.gl1_1_glEndList(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNewList.xml +func (gl *GL) NewList(list uint32, mode glbase.Enum) { + C.gl1_1_glNewList(gl.funcs, C.GLuint(list), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPushClientAttrib.xml +func (gl *GL) PushClientAttrib(mask glbase.Bitfield) { + C.gl1_1_glPushClientAttrib(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPopClientAttrib.xml +func (gl *GL) PopClientAttrib() { + C.gl1_1_glPopClientAttrib(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPrioritizeTextures.xml +func (gl *GL) PrioritizeTextures(n int, textures []glbase.Texture, priorities []float32) { + C.gl1_1_glPrioritizeTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0])), (*C.GLfloat)(unsafe.Pointer(&priorities[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glAreTexturesResident.xml +func (gl *GL) AreTexturesResident(n int, textures []glbase.Texture, residences []bool) bool { + glresult := C.gl1_1_glAreTexturesResident(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0])), (*C.GLboolean)(unsafe.Pointer(&residences[0]))) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexPointer.xml +func (gl *GL) VertexPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_1_glVertexPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoordPointer.xml +func (gl *GL) TexCoordPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_1_glTexCoordPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormalPointer.xml +func (gl *GL) NormalPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_1_glNormalPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glInterleavedArrays.xml +func (gl *GL) InterleavedArrays(format glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_1_glInterleavedArrays(gl.funcs, C.GLenum(format), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexPointer.xml +func (gl *GL) IndexPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_1_glIndexPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEnableClientState.xml +func (gl *GL) EnableClientState(array glbase.Enum) { + C.gl1_1_glEnableClientState(gl.funcs, C.GLenum(array)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEdgeFlagPointer.xml +func (gl *GL) EdgeFlagPointer(stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_1_glEdgeFlagPointer(gl.funcs, C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDisableClientState.xml +func (gl *GL) DisableClientState(array glbase.Enum) { + C.gl1_1_glDisableClientState(gl.funcs, C.GLenum(array)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorPointer.xml +func (gl *GL) ColorPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_1_glColorPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glArrayElement.xml +func (gl *GL) ArrayElement(i int32) { + C.gl1_1_glArrayElement(gl.funcs, C.GLint(i)) +} diff --git a/gl/1.2/funcs.cpp b/gl/1.2/funcs.cpp new file mode 100644 index 00000000..328f40f8 --- /dev/null +++ b/gl/1.2/funcs.cpp @@ -0,0 +1,2250 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#include +#include + +#include "funcs.h" + +void *gl1_2_funcs() { + QOpenGLFunctions_1_2* funcs = QOpenGLContext::currentContext()->versionFunctions(); + if (!funcs) { + return 0; + } + funcs->initializeOpenGLFunctions(); + return funcs; +} + + +void gl1_2_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewport(x, y, width, height); +} + +void gl1_2_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRange(nearVal, farVal); +} + +GLboolean gl1_2_glIsEnabled(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabled(cap); +} + +void gl1_2_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameteriv(target, level, pname, params); +} + +void gl1_2_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameterfv(target, level, pname, params); +} + +void gl1_2_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameteriv(target, pname, params); +} + +void gl1_2_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterfv(target, pname, params); +} + +void gl1_2_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexImage(target, level, format, gltype, pixels); +} + +void gl1_2_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegerv(pname, params); +} + +void gl1_2_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFloatv(pname, params); +} + +GLenum gl1_2_glGetError(void *_glfuncs) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetError(); +} + +void gl1_2_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetDoublev(pname, params); +} + +void gl1_2_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleanv(pname, params); +} + +void gl1_2_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadPixels(x, y, width, height, format, gltype, pixels); +} + +void gl1_2_glReadBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadBuffer(mode); +} + +void gl1_2_glPixelStorei(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStorei(pname, param); +} + +void gl1_2_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStoref(pname, param); +} + +void gl1_2_glDepthFunc(void *_glfuncs, GLenum glfunc) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthFunc(glfunc); +} + +void gl1_2_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOp(fail, zfail, zpass); +} + +void gl1_2_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFunc(glfunc, ref, mask); +} + +void gl1_2_glLogicOp(void *_glfuncs, GLenum opcode) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLogicOp(opcode); +} + +void gl1_2_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFunc(sfactor, dfactor); +} + +void gl1_2_glFlush(void *_glfuncs) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlush(); +} + +void gl1_2_glFinish(void *_glfuncs) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFinish(); +} + +void gl1_2_glEnable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnable(cap); +} + +void gl1_2_glDisable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisable(cap); +} + +void gl1_2_glDepthMask(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthMask(flag); +} + +void gl1_2_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMask(red, green, blue, alpha); +} + +void gl1_2_glStencilMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMask(mask); +} + +void gl1_2_glClearDepth(void *_glfuncs, GLdouble depth) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearDepth(depth); +} + +void gl1_2_glClearStencil(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearStencil(s); +} + +void gl1_2_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearColor(red, green, blue, alpha); +} + +void gl1_2_glClear(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClear(mask); +} + +void gl1_2_glDrawBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffer(mode); +} + +void gl1_2_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage2D(target, level, internalFormat, width, height, border, format, gltype, pixels); +} + +void gl1_2_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage1D(target, level, internalFormat, width, border, format, gltype, pixels); +} + +void gl1_2_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteriv(target, pname, params); +} + +void gl1_2_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteri(target, pname, param); +} + +void gl1_2_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterfv(target, pname, params); +} + +void gl1_2_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterf(target, pname, param); +} + +void gl1_2_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissor(x, y, width, height); +} + +void gl1_2_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonMode(face, mode); +} + +void gl1_2_glPointSize(void *_glfuncs, GLfloat size) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointSize(size); +} + +void gl1_2_glLineWidth(void *_glfuncs, GLfloat width) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineWidth(width); +} + +void gl1_2_glHint(void *_glfuncs, GLenum target, GLenum mode) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glHint(target, mode); +} + +void gl1_2_glFrontFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrontFace(mode); +} + +void gl1_2_glCullFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCullFace(mode); +} + +void gl1_2_glIndexubv(void *_glfuncs, const GLubyte* c) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexubv(c); +} + +void gl1_2_glIndexub(void *_glfuncs, GLubyte c) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexub(c); +} + +GLboolean gl1_2_glIsTexture(void *_glfuncs, GLuint texture) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsTexture(texture); +} + +void gl1_2_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenTextures(n, textures); +} + +void gl1_2_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteTextures(n, textures); +} + +void gl1_2_glBindTexture(void *_glfuncs, GLenum target, GLuint texture) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindTexture(target, texture); +} + +void gl1_2_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, gltype, pixels); +} + +void gl1_2_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage1D(target, level, xoffset, width, format, gltype, pixels); +} + +void gl1_2_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); +} + +void gl1_2_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage1D(target, level, xoffset, x, y, width); +} + +void gl1_2_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage2D(target, level, internalFormat, x, y, width, height, border); +} + +void gl1_2_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage1D(target, level, internalFormat, x, y, width, border); +} + +void gl1_2_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonOffset(factor, units); +} + +void gl1_2_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElements(mode, count, gltype, indices); +} + +void gl1_2_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArrays(mode, first, count); +} + +void gl1_2_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); +} + +void gl1_2_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, gltype, pixels); +} + +void gl1_2_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage3D(target, level, internalFormat, width, height, depth, border, format, gltype, pixels); +} + +void gl1_2_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawRangeElements(mode, start, end, count, gltype, indices); +} + +void gl1_2_glBlendEquation(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquation(mode); +} + +void gl1_2_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendColor(red, green, blue, alpha); +} + +void gl1_2_glTranslatef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTranslatef(x, y, z); +} + +void gl1_2_glTranslated(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTranslated(x, y, z); +} + +void gl1_2_glScalef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScalef(x, y, z); +} + +void gl1_2_glScaled(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScaled(x, y, z); +} + +void gl1_2_glRotatef(void *_glfuncs, GLfloat angle, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRotatef(angle, x, y, z); +} + +void gl1_2_glRotated(void *_glfuncs, GLdouble angle, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRotated(angle, x, y, z); +} + +void gl1_2_glPushMatrix(void *_glfuncs) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushMatrix(); +} + +void gl1_2_glPopMatrix(void *_glfuncs) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopMatrix(); +} + +void gl1_2_glOrtho(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glOrtho(left, right, bottom, top, zNear, zFar); +} + +void gl1_2_glMultMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultMatrixd(m); +} + +void gl1_2_glMultMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultMatrixf(m); +} + +void gl1_2_glMatrixMode(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMatrixMode(mode); +} + +void gl1_2_glLoadMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadMatrixd(m); +} + +void gl1_2_glLoadMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadMatrixf(m); +} + +void gl1_2_glLoadIdentity(void *_glfuncs) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadIdentity(); +} + +void gl1_2_glFrustum(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrustum(left, right, bottom, top, zNear, zFar); +} + +GLboolean gl1_2_glIsList(void *_glfuncs, GLuint list) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsList(list); +} + +void gl1_2_glGetTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGeniv(coord, pname, params); +} + +void gl1_2_glGetTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGenfv(coord, pname, params); +} + +void gl1_2_glGetTexGendv(void *_glfuncs, GLenum coord, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGendv(coord, pname, params); +} + +void gl1_2_glGetTexEnviv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexEnviv(target, pname, params); +} + +void gl1_2_glGetTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexEnvfv(target, pname, params); +} + +void gl1_2_glGetPolygonStipple(void *_glfuncs, GLubyte* mask) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPolygonStipple(mask); +} + +void gl1_2_glGetPixelMapusv(void *_glfuncs, GLenum glmap, GLushort* values) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapusv(glmap, values); +} + +void gl1_2_glGetPixelMapuiv(void *_glfuncs, GLenum glmap, GLuint* values) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapuiv(glmap, values); +} + +void gl1_2_glGetPixelMapfv(void *_glfuncs, GLenum glmap, GLfloat* values) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapfv(glmap, values); +} + +void gl1_2_glGetMaterialiv(void *_glfuncs, GLenum face, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMaterialiv(face, pname, params); +} + +void gl1_2_glGetMaterialfv(void *_glfuncs, GLenum face, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMaterialfv(face, pname, params); +} + +void gl1_2_glGetMapiv(void *_glfuncs, GLenum target, GLenum query, GLint* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapiv(target, query, v); +} + +void gl1_2_glGetMapfv(void *_glfuncs, GLenum target, GLenum query, GLfloat* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapfv(target, query, v); +} + +void gl1_2_glGetMapdv(void *_glfuncs, GLenum target, GLenum query, GLdouble* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapdv(target, query, v); +} + +void gl1_2_glGetLightiv(void *_glfuncs, GLenum light, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetLightiv(light, pname, params); +} + +void gl1_2_glGetLightfv(void *_glfuncs, GLenum light, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetLightfv(light, pname, params); +} + +void gl1_2_glGetClipPlane(void *_glfuncs, GLenum plane, GLdouble* equation) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetClipPlane(plane, equation); +} + +void gl1_2_glDrawPixels(void *_glfuncs, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawPixels(width, height, format, gltype, pixels); +} + +void gl1_2_glCopyPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum gltype) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyPixels(x, y, width, height, gltype); +} + +void gl1_2_glPixelMapusv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLushort* values) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapusv(glmap, mapsize, values); +} + +void gl1_2_glPixelMapuiv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLuint* values) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapuiv(glmap, mapsize, values); +} + +void gl1_2_glPixelMapfv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLfloat* values) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapfv(glmap, mapsize, values); +} + +void gl1_2_glPixelTransferi(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelTransferi(pname, param); +} + +void gl1_2_glPixelTransferf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelTransferf(pname, param); +} + +void gl1_2_glPixelZoom(void *_glfuncs, GLfloat xfactor, GLfloat yfactor) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelZoom(xfactor, yfactor); +} + +void gl1_2_glAlphaFunc(void *_glfuncs, GLenum glfunc, GLfloat ref) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAlphaFunc(glfunc, ref); +} + +void gl1_2_glEvalPoint2(void *_glfuncs, GLint i, GLint j) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalPoint2(i, j); +} + +void gl1_2_glEvalMesh2(void *_glfuncs, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalMesh2(mode, i1, i2, j1, j2); +} + +void gl1_2_glEvalPoint1(void *_glfuncs, GLint i) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalPoint1(i); +} + +void gl1_2_glEvalMesh1(void *_glfuncs, GLenum mode, GLint i1, GLint i2) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalMesh1(mode, i1, i2); +} + +void gl1_2_glEvalCoord2fv(void *_glfuncs, const GLfloat* u) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2fv(u); +} + +void gl1_2_glEvalCoord2f(void *_glfuncs, GLfloat u, GLfloat v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2f(u, v); +} + +void gl1_2_glEvalCoord2dv(void *_glfuncs, const GLdouble* u) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2dv(u); +} + +void gl1_2_glEvalCoord2d(void *_glfuncs, GLdouble u, GLdouble v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2d(u, v); +} + +void gl1_2_glEvalCoord1fv(void *_glfuncs, const GLfloat* u) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1fv(u); +} + +void gl1_2_glEvalCoord1f(void *_glfuncs, GLfloat u) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1f(u); +} + +void gl1_2_glEvalCoord1dv(void *_glfuncs, const GLdouble* u) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1dv(u); +} + +void gl1_2_glEvalCoord1d(void *_glfuncs, GLdouble u) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1d(u); +} + +void gl1_2_glMapGrid2f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid2f(un, u1, u2, vn, v1, v2); +} + +void gl1_2_glMapGrid2d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid2d(un, u1, u2, vn, v1, v2); +} + +void gl1_2_glMapGrid1f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid1f(un, u1, u2); +} + +void gl1_2_glMapGrid1d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid1d(un, u1, u2); +} + +void gl1_2_glMap2f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); +} + +void gl1_2_glMap2d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); +} + +void gl1_2_glMap1f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap1f(target, u1, u2, stride, order, points); +} + +void gl1_2_glMap1d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap1d(target, u1, u2, stride, order, points); +} + +void gl1_2_glPushAttrib(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushAttrib(mask); +} + +void gl1_2_glPopAttrib(void *_glfuncs) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopAttrib(); +} + +void gl1_2_glAccum(void *_glfuncs, GLenum op, GLfloat value) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAccum(op, value); +} + +void gl1_2_glIndexMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexMask(mask); +} + +void gl1_2_glClearIndex(void *_glfuncs, GLfloat c) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearIndex(c); +} + +void gl1_2_glClearAccum(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearAccum(red, green, blue, alpha); +} + +void gl1_2_glPushName(void *_glfuncs, GLuint name) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushName(name); +} + +void gl1_2_glPopName(void *_glfuncs) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopName(); +} + +void gl1_2_glPassThrough(void *_glfuncs, GLfloat token) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPassThrough(token); +} + +void gl1_2_glLoadName(void *_glfuncs, GLuint name) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadName(name); +} + +void gl1_2_glInitNames(void *_glfuncs) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInitNames(); +} + +GLint gl1_2_glRenderMode(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glRenderMode(mode); +} + +void gl1_2_glSelectBuffer(void *_glfuncs, GLsizei size, GLuint* buffer) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSelectBuffer(size, buffer); +} + +void gl1_2_glFeedbackBuffer(void *_glfuncs, GLsizei size, GLenum gltype, GLfloat* buffer) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFeedbackBuffer(size, gltype, buffer); +} + +void gl1_2_glTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGeniv(coord, pname, params); +} + +void gl1_2_glTexGeni(void *_glfuncs, GLenum coord, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGeni(coord, pname, param); +} + +void gl1_2_glTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGenfv(coord, pname, params); +} + +void gl1_2_glTexGenf(void *_glfuncs, GLenum coord, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGenf(coord, pname, param); +} + +void gl1_2_glTexGendv(void *_glfuncs, GLenum coord, GLenum pname, const GLdouble* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGendv(coord, pname, params); +} + +void gl1_2_glTexGend(void *_glfuncs, GLenum coord, GLenum pname, GLdouble param) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGend(coord, pname, param); +} + +void gl1_2_glTexEnviv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnviv(target, pname, params); +} + +void gl1_2_glTexEnvi(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvi(target, pname, param); +} + +void gl1_2_glTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvfv(target, pname, params); +} + +void gl1_2_glTexEnvf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvf(target, pname, param); +} + +void gl1_2_glShadeModel(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShadeModel(mode); +} + +void gl1_2_glPolygonStipple(void *_glfuncs, const GLubyte* mask) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonStipple(mask); +} + +void gl1_2_glMaterialiv(void *_glfuncs, GLenum face, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialiv(face, pname, params); +} + +void gl1_2_glMateriali(void *_glfuncs, GLenum face, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMateriali(face, pname, param); +} + +void gl1_2_glMaterialfv(void *_glfuncs, GLenum face, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialfv(face, pname, params); +} + +void gl1_2_glMaterialf(void *_glfuncs, GLenum face, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialf(face, pname, param); +} + +void gl1_2_glLineStipple(void *_glfuncs, GLint factor, GLushort pattern) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineStipple(factor, pattern); +} + +void gl1_2_glLightModeliv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModeliv(pname, params); +} + +void gl1_2_glLightModeli(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModeli(pname, param); +} + +void gl1_2_glLightModelfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModelfv(pname, params); +} + +void gl1_2_glLightModelf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModelf(pname, param); +} + +void gl1_2_glLightiv(void *_glfuncs, GLenum light, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightiv(light, pname, params); +} + +void gl1_2_glLighti(void *_glfuncs, GLenum light, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLighti(light, pname, param); +} + +void gl1_2_glLightfv(void *_glfuncs, GLenum light, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightfv(light, pname, params); +} + +void gl1_2_glLightf(void *_glfuncs, GLenum light, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightf(light, pname, param); +} + +void gl1_2_glFogiv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogiv(pname, params); +} + +void gl1_2_glFogi(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogi(pname, param); +} + +void gl1_2_glFogfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogfv(pname, params); +} + +void gl1_2_glFogf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogf(pname, param); +} + +void gl1_2_glColorMaterial(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMaterial(face, mode); +} + +void gl1_2_glClipPlane(void *_glfuncs, GLenum plane, const GLdouble* equation) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClipPlane(plane, equation); +} + +void gl1_2_glVertex4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4sv(v); +} + +void gl1_2_glVertex4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4s(x, y, z, w); +} + +void gl1_2_glVertex4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4iv(v); +} + +void gl1_2_glVertex4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4i(x, y, z, w); +} + +void gl1_2_glVertex4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4fv(v); +} + +void gl1_2_glVertex4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4f(x, y, z, w); +} + +void gl1_2_glVertex4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4dv(v); +} + +void gl1_2_glVertex4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4d(x, y, z, w); +} + +void gl1_2_glVertex3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3sv(v); +} + +void gl1_2_glVertex3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3s(x, y, z); +} + +void gl1_2_glVertex3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3iv(v); +} + +void gl1_2_glVertex3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3i(x, y, z); +} + +void gl1_2_glVertex3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3fv(v); +} + +void gl1_2_glVertex3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3f(x, y, z); +} + +void gl1_2_glVertex3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3dv(v); +} + +void gl1_2_glVertex3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3d(x, y, z); +} + +void gl1_2_glVertex2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2sv(v); +} + +void gl1_2_glVertex2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2s(x, y); +} + +void gl1_2_glVertex2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2iv(v); +} + +void gl1_2_glVertex2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2i(x, y); +} + +void gl1_2_glVertex2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2fv(v); +} + +void gl1_2_glVertex2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2f(x, y); +} + +void gl1_2_glVertex2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2dv(v); +} + +void gl1_2_glVertex2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2d(x, y); +} + +void gl1_2_glTexCoord4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4sv(v); +} + +void gl1_2_glTexCoord4s(void *_glfuncs, GLshort s, GLshort t, GLshort r, GLshort q) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4s(s, t, r, q); +} + +void gl1_2_glTexCoord4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4iv(v); +} + +void gl1_2_glTexCoord4i(void *_glfuncs, GLint s, GLint t, GLint r, GLint q) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4i(s, t, r, q); +} + +void gl1_2_glTexCoord4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4fv(v); +} + +void gl1_2_glTexCoord4f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4f(s, t, r, q); +} + +void gl1_2_glTexCoord4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4dv(v); +} + +void gl1_2_glTexCoord4d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r, GLdouble q) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4d(s, t, r, q); +} + +void gl1_2_glTexCoord3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3sv(v); +} + +void gl1_2_glTexCoord3s(void *_glfuncs, GLshort s, GLshort t, GLshort r) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3s(s, t, r); +} + +void gl1_2_glTexCoord3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3iv(v); +} + +void gl1_2_glTexCoord3i(void *_glfuncs, GLint s, GLint t, GLint r) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3i(s, t, r); +} + +void gl1_2_glTexCoord3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3fv(v); +} + +void gl1_2_glTexCoord3f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3f(s, t, r); +} + +void gl1_2_glTexCoord3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3dv(v); +} + +void gl1_2_glTexCoord3d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3d(s, t, r); +} + +void gl1_2_glTexCoord2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2sv(v); +} + +void gl1_2_glTexCoord2s(void *_glfuncs, GLshort s, GLshort t) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2s(s, t); +} + +void gl1_2_glTexCoord2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2iv(v); +} + +void gl1_2_glTexCoord2i(void *_glfuncs, GLint s, GLint t) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2i(s, t); +} + +void gl1_2_glTexCoord2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2fv(v); +} + +void gl1_2_glTexCoord2f(void *_glfuncs, GLfloat s, GLfloat t) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2f(s, t); +} + +void gl1_2_glTexCoord2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2dv(v); +} + +void gl1_2_glTexCoord2d(void *_glfuncs, GLdouble s, GLdouble t) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2d(s, t); +} + +void gl1_2_glTexCoord1sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1sv(v); +} + +void gl1_2_glTexCoord1s(void *_glfuncs, GLshort s) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1s(s); +} + +void gl1_2_glTexCoord1iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1iv(v); +} + +void gl1_2_glTexCoord1i(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1i(s); +} + +void gl1_2_glTexCoord1fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1fv(v); +} + +void gl1_2_glTexCoord1f(void *_glfuncs, GLfloat s) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1f(s); +} + +void gl1_2_glTexCoord1dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1dv(v); +} + +void gl1_2_glTexCoord1d(void *_glfuncs, GLdouble s) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1d(s); +} + +void gl1_2_glRectsv(void *_glfuncs, const GLshort* v1, const GLshort* v2) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectsv(v1, v2); +} + +void gl1_2_glRects(void *_glfuncs, GLshort x1, GLshort y1, GLshort x2, GLshort y2) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRects(x1, y1, x2, y2); +} + +void gl1_2_glRectiv(void *_glfuncs, const GLint* v1, const GLint* v2) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectiv(v1, v2); +} + +void gl1_2_glRecti(void *_glfuncs, GLint x1, GLint y1, GLint x2, GLint y2) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRecti(x1, y1, x2, y2); +} + +void gl1_2_glRectfv(void *_glfuncs, const GLfloat* v1, const GLfloat* v2) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectfv(v1, v2); +} + +void gl1_2_glRectf(void *_glfuncs, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectf(x1, y1, x2, y2); +} + +void gl1_2_glRectdv(void *_glfuncs, const GLdouble* v1, const GLdouble* v2) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectdv(v1, v2); +} + +void gl1_2_glRectd(void *_glfuncs, GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectd(x1, y1, x2, y2); +} + +void gl1_2_glRasterPos4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4sv(v); +} + +void gl1_2_glRasterPos4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4s(x, y, z, w); +} + +void gl1_2_glRasterPos4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4iv(v); +} + +void gl1_2_glRasterPos4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4i(x, y, z, w); +} + +void gl1_2_glRasterPos4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4fv(v); +} + +void gl1_2_glRasterPos4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4f(x, y, z, w); +} + +void gl1_2_glRasterPos4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4dv(v); +} + +void gl1_2_glRasterPos4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4d(x, y, z, w); +} + +void gl1_2_glRasterPos3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3sv(v); +} + +void gl1_2_glRasterPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3s(x, y, z); +} + +void gl1_2_glRasterPos3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3iv(v); +} + +void gl1_2_glRasterPos3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3i(x, y, z); +} + +void gl1_2_glRasterPos3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3fv(v); +} + +void gl1_2_glRasterPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3f(x, y, z); +} + +void gl1_2_glRasterPos3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3dv(v); +} + +void gl1_2_glRasterPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3d(x, y, z); +} + +void gl1_2_glRasterPos2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2sv(v); +} + +void gl1_2_glRasterPos2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2s(x, y); +} + +void gl1_2_glRasterPos2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2iv(v); +} + +void gl1_2_glRasterPos2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2i(x, y); +} + +void gl1_2_glRasterPos2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2fv(v); +} + +void gl1_2_glRasterPos2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2f(x, y); +} + +void gl1_2_glRasterPos2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2dv(v); +} + +void gl1_2_glRasterPos2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2d(x, y); +} + +void gl1_2_glNormal3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3sv(v); +} + +void gl1_2_glNormal3s(void *_glfuncs, GLshort nx, GLshort ny, GLshort nz) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3s(nx, ny, nz); +} + +void gl1_2_glNormal3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3iv(v); +} + +void gl1_2_glNormal3i(void *_glfuncs, GLint nx, GLint ny, GLint nz) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3i(nx, ny, nz); +} + +void gl1_2_glNormal3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3fv(v); +} + +void gl1_2_glNormal3f(void *_glfuncs, GLfloat nx, GLfloat ny, GLfloat nz) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3f(nx, ny, nz); +} + +void gl1_2_glNormal3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3dv(v); +} + +void gl1_2_glNormal3d(void *_glfuncs, GLdouble nx, GLdouble ny, GLdouble nz) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3d(nx, ny, nz); +} + +void gl1_2_glNormal3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3bv(v); +} + +void gl1_2_glNormal3b(void *_glfuncs, GLbyte nx, GLbyte ny, GLbyte nz) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3b(nx, ny, nz); +} + +void gl1_2_glIndexsv(void *_glfuncs, const GLshort* c) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexsv(c); +} + +void gl1_2_glIndexs(void *_glfuncs, GLshort c) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexs(c); +} + +void gl1_2_glIndexiv(void *_glfuncs, const GLint* c) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexiv(c); +} + +void gl1_2_glIndexi(void *_glfuncs, GLint c) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexi(c); +} + +void gl1_2_glIndexfv(void *_glfuncs, const GLfloat* c) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexfv(c); +} + +void gl1_2_glIndexf(void *_glfuncs, GLfloat c) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexf(c); +} + +void gl1_2_glIndexdv(void *_glfuncs, const GLdouble* c) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexdv(c); +} + +void gl1_2_glIndexd(void *_glfuncs, GLdouble c) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexd(c); +} + +void gl1_2_glEnd(void *_glfuncs) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnd(); +} + +void gl1_2_glEdgeFlagv(void *_glfuncs, const GLboolean* flag) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlagv(flag); +} + +void gl1_2_glEdgeFlag(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlag(flag); +} + +void gl1_2_glColor4usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4usv(v); +} + +void gl1_2_glColor4us(void *_glfuncs, GLushort red, GLushort green, GLushort blue, GLushort alpha) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4us(red, green, blue, alpha); +} + +void gl1_2_glColor4uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4uiv(v); +} + +void gl1_2_glColor4ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue, GLuint alpha) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ui(red, green, blue, alpha); +} + +void gl1_2_glColor4ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ubv(v); +} + +void gl1_2_glColor4ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ub(red, green, blue, alpha); +} + +void gl1_2_glColor4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4sv(v); +} + +void gl1_2_glColor4s(void *_glfuncs, GLshort red, GLshort green, GLshort blue, GLshort alpha) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4s(red, green, blue, alpha); +} + +void gl1_2_glColor4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4iv(v); +} + +void gl1_2_glColor4i(void *_glfuncs, GLint red, GLint green, GLint blue, GLint alpha) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4i(red, green, blue, alpha); +} + +void gl1_2_glColor4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4fv(v); +} + +void gl1_2_glColor4f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4f(red, green, blue, alpha); +} + +void gl1_2_glColor4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4dv(v); +} + +void gl1_2_glColor4d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4d(red, green, blue, alpha); +} + +void gl1_2_glColor4bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4bv(v); +} + +void gl1_2_glColor4b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4b(red, green, blue, alpha); +} + +void gl1_2_glColor3usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3usv(v); +} + +void gl1_2_glColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3us(red, green, blue); +} + +void gl1_2_glColor3uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3uiv(v); +} + +void gl1_2_glColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ui(red, green, blue); +} + +void gl1_2_glColor3ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ubv(v); +} + +void gl1_2_glColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ub(red, green, blue); +} + +void gl1_2_glColor3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3sv(v); +} + +void gl1_2_glColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3s(red, green, blue); +} + +void gl1_2_glColor3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3iv(v); +} + +void gl1_2_glColor3i(void *_glfuncs, GLint red, GLint green, GLint blue) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3i(red, green, blue); +} + +void gl1_2_glColor3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3fv(v); +} + +void gl1_2_glColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3f(red, green, blue); +} + +void gl1_2_glColor3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3dv(v); +} + +void gl1_2_glColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3d(red, green, blue); +} + +void gl1_2_glColor3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3bv(v); +} + +void gl1_2_glColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3b(red, green, blue); +} + +void gl1_2_glBitmap(void *_glfuncs, GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBitmap(width, height, xorig, yorig, xmove, ymove, bitmap); +} + +void gl1_2_glBegin(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBegin(mode); +} + +void gl1_2_glListBase(void *_glfuncs, GLuint base) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glListBase(base); +} + +GLuint gl1_2_glGenLists(void *_glfuncs, GLsizei range_) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGenLists(range_); +} + +void gl1_2_glDeleteLists(void *_glfuncs, GLuint list, GLsizei range_) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteLists(list, range_); +} + +void gl1_2_glCallLists(void *_glfuncs, GLsizei n, GLenum gltype, const GLvoid* lists) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCallLists(n, gltype, lists); +} + +void gl1_2_glCallList(void *_glfuncs, GLuint list) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCallList(list); +} + +void gl1_2_glEndList(void *_glfuncs) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndList(); +} + +void gl1_2_glNewList(void *_glfuncs, GLuint list, GLenum mode) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNewList(list, mode); +} + +void gl1_2_glPushClientAttrib(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushClientAttrib(mask); +} + +void gl1_2_glPopClientAttrib(void *_glfuncs) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopClientAttrib(); +} + +void gl1_2_glPrioritizeTextures(void *_glfuncs, GLsizei n, const GLuint* textures, const GLfloat* priorities) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPrioritizeTextures(n, textures, priorities); +} + +GLboolean gl1_2_glAreTexturesResident(void *_glfuncs, GLsizei n, const GLuint* textures, GLboolean* residences) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glAreTexturesResident(n, textures, residences); +} + +void gl1_2_glVertexPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexPointer(size, gltype, stride, pointer); +} + +void gl1_2_glTexCoordPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordPointer(size, gltype, stride, pointer); +} + +void gl1_2_glNormalPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormalPointer(gltype, stride, pointer); +} + +void gl1_2_glInterleavedArrays(void *_glfuncs, GLenum format, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInterleavedArrays(format, stride, pointer); +} + +void gl1_2_glIndexPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexPointer(gltype, stride, pointer); +} + +void gl1_2_glEnableClientState(void *_glfuncs, GLenum array) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnableClientState(array); +} + +void gl1_2_glEdgeFlagPointer(void *_glfuncs, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlagPointer(stride, pointer); +} + +void gl1_2_glDisableClientState(void *_glfuncs, GLenum array) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisableClientState(array); +} + +void gl1_2_glColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorPointer(size, gltype, stride, pointer); +} + +void gl1_2_glArrayElement(void *_glfuncs, GLint i) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glArrayElement(i); +} + +void gl1_2_glResetMinmax(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glResetMinmax(target); +} + +void gl1_2_glResetHistogram(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glResetHistogram(target); +} + +void gl1_2_glMinmax(void *_glfuncs, GLenum target, GLenum internalFormat, GLboolean sink) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMinmax(target, internalFormat, sink); +} + +void gl1_2_glHistogram(void *_glfuncs, GLenum target, GLsizei width, GLenum internalFormat, GLboolean sink) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glHistogram(target, width, internalFormat, sink); +} + +void gl1_2_glGetMinmaxParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmaxParameteriv(target, pname, params); +} + +void gl1_2_glGetMinmaxParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmaxParameterfv(target, pname, params); +} + +void gl1_2_glGetMinmax(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmax(target, reset, format, gltype, values); +} + +void gl1_2_glGetHistogramParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogramParameteriv(target, pname, params); +} + +void gl1_2_glGetHistogramParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogramParameterfv(target, pname, params); +} + +void gl1_2_glGetHistogram(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogram(target, reset, format, gltype, values); +} + +void gl1_2_glSeparableFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* row, const GLvoid* column) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSeparableFilter2D(target, internalFormat, width, height, format, gltype, row, column); +} + +void gl1_2_glGetSeparableFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* row, GLvoid* column, GLvoid* span) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSeparableFilter(target, format, gltype, row, column, span); +} + +void gl1_2_glGetConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionParameteriv(target, pname, params); +} + +void gl1_2_glGetConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionParameterfv(target, pname, params); +} + +void gl1_2_glGetConvolutionFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* image) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionFilter(target, format, gltype, image); +} + +void gl1_2_glCopyConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyConvolutionFilter2D(target, internalFormat, x, y, width, height); +} + +void gl1_2_glCopyConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyConvolutionFilter1D(target, internalFormat, x, y, width); +} + +void gl1_2_glConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameteriv(target, pname, params); +} + +void gl1_2_glConvolutionParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameteri(target, pname, params); +} + +void gl1_2_glConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameterfv(target, pname, params); +} + +void gl1_2_glConvolutionParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameterf(target, pname, params); +} + +void gl1_2_glConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* image) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionFilter2D(target, internalFormat, width, height, format, gltype, image); +} + +void gl1_2_glConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* image) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionFilter1D(target, internalFormat, width, format, gltype, image); +} + +void gl1_2_glCopyColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyColorSubTable(target, start, x, y, width); +} + +void gl1_2_glColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum gltype, const GLvoid* data) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorSubTable(target, start, count, format, gltype, data); +} + +void gl1_2_glGetColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTableParameteriv(target, pname, params); +} + +void gl1_2_glGetColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTableParameterfv(target, pname, params); +} + +void gl1_2_glGetColorTable(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* table) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTable(target, format, gltype, table); +} + +void gl1_2_glCopyColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyColorTable(target, internalFormat, x, y, width); +} + +void gl1_2_glColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTableParameteriv(target, pname, params); +} + +void gl1_2_glColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTableParameterfv(target, pname, params); +} + +void gl1_2_glColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* table) +{ + QOpenGLFunctions_1_2* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTable(target, internalFormat, width, format, gltype, table); +} + diff --git a/gl/1.2/funcs.h b/gl/1.2/funcs.h new file mode 100644 index 00000000..958c3493 --- /dev/null +++ b/gl/1.2/funcs.h @@ -0,0 +1,414 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#ifndef __cplusplus +#include +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef char GLchar; +typedef signed char GLbyte; /* 1-byte signed */ +typedef short GLshort; /* 2-byte signed */ +typedef int GLint; /* 4-byte signed */ +typedef unsigned char GLubyte; /* 1-byte unsigned */ +typedef unsigned short GLushort; /* 2-byte unsigned */ +typedef unsigned int GLuint; /* 4-byte unsigned */ +typedef int GLsizei; /* 4-byte signed */ +typedef float GLfloat; /* single precision float */ +typedef float GLclampf; /* single precision float in [0,1] */ +typedef double GLdouble; /* double precision float */ +typedef double GLclampd; /* double precision float in [0,1] */ +typedef int64_t GLint64; +typedef uint64_t GLuint64; +typedef ptrdiff_t GLintptr; +typedef ptrdiff_t GLsizeiptr; +typedef ptrdiff_t GLintptrARB; +typedef ptrdiff_t GLsizeiptrARB; +typedef struct __GLsync *GLsync; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +void *gl1_2_funcs(); + +void gl1_2_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl1_2_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal); +GLboolean gl1_2_glIsEnabled(void *_glfuncs, GLenum cap); +void gl1_2_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params); +void gl1_2_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params); +void gl1_2_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl1_2_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl1_2_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels); +void gl1_2_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params); +void gl1_2_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params); +GLenum gl1_2_glGetError(void *_glfuncs); +void gl1_2_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params); +void gl1_2_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params); +void gl1_2_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels); +void gl1_2_glReadBuffer(void *_glfuncs, GLenum mode); +void gl1_2_glPixelStorei(void *_glfuncs, GLenum pname, GLint param); +void gl1_2_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param); +void gl1_2_glDepthFunc(void *_glfuncs, GLenum glfunc); +void gl1_2_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass); +void gl1_2_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask); +void gl1_2_glLogicOp(void *_glfuncs, GLenum opcode); +void gl1_2_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor); +void gl1_2_glFlush(void *_glfuncs); +void gl1_2_glFinish(void *_glfuncs); +void gl1_2_glEnable(void *_glfuncs, GLenum cap); +void gl1_2_glDisable(void *_glfuncs, GLenum cap); +void gl1_2_glDepthMask(void *_glfuncs, GLboolean flag); +void gl1_2_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +void gl1_2_glStencilMask(void *_glfuncs, GLuint mask); +void gl1_2_glClearDepth(void *_glfuncs, GLdouble depth); +void gl1_2_glClearStencil(void *_glfuncs, GLint s); +void gl1_2_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl1_2_glClear(void *_glfuncs, GLbitfield mask); +void gl1_2_glDrawBuffer(void *_glfuncs, GLenum mode); +void gl1_2_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_2_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_2_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl1_2_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl1_2_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl1_2_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl1_2_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl1_2_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode); +void gl1_2_glPointSize(void *_glfuncs, GLfloat size); +void gl1_2_glLineWidth(void *_glfuncs, GLfloat width); +void gl1_2_glHint(void *_glfuncs, GLenum target, GLenum mode); +void gl1_2_glFrontFace(void *_glfuncs, GLenum mode); +void gl1_2_glCullFace(void *_glfuncs, GLenum mode); +void gl1_2_glIndexubv(void *_glfuncs, const GLubyte* c); +void gl1_2_glIndexub(void *_glfuncs, GLubyte c); +GLboolean gl1_2_glIsTexture(void *_glfuncs, GLuint texture); +void gl1_2_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures); +void gl1_2_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures); +void gl1_2_glBindTexture(void *_glfuncs, GLenum target, GLuint texture); +void gl1_2_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_2_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_2_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl1_2_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +void gl1_2_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +void gl1_2_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border); +void gl1_2_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units); +void gl1_2_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl1_2_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count); +void gl1_2_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl1_2_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_2_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_2_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl1_2_glBlendEquation(void *_glfuncs, GLenum mode); +void gl1_2_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl1_2_glTranslatef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl1_2_glTranslated(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl1_2_glScalef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl1_2_glScaled(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl1_2_glRotatef(void *_glfuncs, GLfloat angle, GLfloat x, GLfloat y, GLfloat z); +void gl1_2_glRotated(void *_glfuncs, GLdouble angle, GLdouble x, GLdouble y, GLdouble z); +void gl1_2_glPushMatrix(void *_glfuncs); +void gl1_2_glPopMatrix(void *_glfuncs); +void gl1_2_glOrtho(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +void gl1_2_glMultMatrixd(void *_glfuncs, const GLdouble* m); +void gl1_2_glMultMatrixf(void *_glfuncs, const GLfloat* m); +void gl1_2_glMatrixMode(void *_glfuncs, GLenum mode); +void gl1_2_glLoadMatrixd(void *_glfuncs, const GLdouble* m); +void gl1_2_glLoadMatrixf(void *_glfuncs, const GLfloat* m); +void gl1_2_glLoadIdentity(void *_glfuncs); +void gl1_2_glFrustum(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +GLboolean gl1_2_glIsList(void *_glfuncs, GLuint list); +void gl1_2_glGetTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, GLint* params); +void gl1_2_glGetTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, GLfloat* params); +void gl1_2_glGetTexGendv(void *_glfuncs, GLenum coord, GLenum pname, GLdouble* params); +void gl1_2_glGetTexEnviv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl1_2_glGetTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl1_2_glGetPolygonStipple(void *_glfuncs, GLubyte* mask); +void gl1_2_glGetPixelMapusv(void *_glfuncs, GLenum glmap, GLushort* values); +void gl1_2_glGetPixelMapuiv(void *_glfuncs, GLenum glmap, GLuint* values); +void gl1_2_glGetPixelMapfv(void *_glfuncs, GLenum glmap, GLfloat* values); +void gl1_2_glGetMaterialiv(void *_glfuncs, GLenum face, GLenum pname, GLint* params); +void gl1_2_glGetMaterialfv(void *_glfuncs, GLenum face, GLenum pname, GLfloat* params); +void gl1_2_glGetMapiv(void *_glfuncs, GLenum target, GLenum query, GLint* v); +void gl1_2_glGetMapfv(void *_glfuncs, GLenum target, GLenum query, GLfloat* v); +void gl1_2_glGetMapdv(void *_glfuncs, GLenum target, GLenum query, GLdouble* v); +void gl1_2_glGetLightiv(void *_glfuncs, GLenum light, GLenum pname, GLint* params); +void gl1_2_glGetLightfv(void *_glfuncs, GLenum light, GLenum pname, GLfloat* params); +void gl1_2_glGetClipPlane(void *_glfuncs, GLenum plane, GLdouble* equation); +void gl1_2_glDrawPixels(void *_glfuncs, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_2_glCopyPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum gltype); +void gl1_2_glPixelMapusv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLushort* values); +void gl1_2_glPixelMapuiv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLuint* values); +void gl1_2_glPixelMapfv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLfloat* values); +void gl1_2_glPixelTransferi(void *_glfuncs, GLenum pname, GLint param); +void gl1_2_glPixelTransferf(void *_glfuncs, GLenum pname, GLfloat param); +void gl1_2_glPixelZoom(void *_glfuncs, GLfloat xfactor, GLfloat yfactor); +void gl1_2_glAlphaFunc(void *_glfuncs, GLenum glfunc, GLfloat ref); +void gl1_2_glEvalPoint2(void *_glfuncs, GLint i, GLint j); +void gl1_2_glEvalMesh2(void *_glfuncs, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); +void gl1_2_glEvalPoint1(void *_glfuncs, GLint i); +void gl1_2_glEvalMesh1(void *_glfuncs, GLenum mode, GLint i1, GLint i2); +void gl1_2_glEvalCoord2fv(void *_glfuncs, const GLfloat* u); +void gl1_2_glEvalCoord2f(void *_glfuncs, GLfloat u, GLfloat v); +void gl1_2_glEvalCoord2dv(void *_glfuncs, const GLdouble* u); +void gl1_2_glEvalCoord2d(void *_glfuncs, GLdouble u, GLdouble v); +void gl1_2_glEvalCoord1fv(void *_glfuncs, const GLfloat* u); +void gl1_2_glEvalCoord1f(void *_glfuncs, GLfloat u); +void gl1_2_glEvalCoord1dv(void *_glfuncs, const GLdouble* u); +void gl1_2_glEvalCoord1d(void *_glfuncs, GLdouble u); +void gl1_2_glMapGrid2f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); +void gl1_2_glMapGrid2d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); +void gl1_2_glMapGrid1f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2); +void gl1_2_glMapGrid1d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2); +void gl1_2_glMap2f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points); +void gl1_2_glMap2d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points); +void gl1_2_glMap1f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points); +void gl1_2_glMap1d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points); +void gl1_2_glPushAttrib(void *_glfuncs, GLbitfield mask); +void gl1_2_glPopAttrib(void *_glfuncs); +void gl1_2_glAccum(void *_glfuncs, GLenum op, GLfloat value); +void gl1_2_glIndexMask(void *_glfuncs, GLuint mask); +void gl1_2_glClearIndex(void *_glfuncs, GLfloat c); +void gl1_2_glClearAccum(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl1_2_glPushName(void *_glfuncs, GLuint name); +void gl1_2_glPopName(void *_glfuncs); +void gl1_2_glPassThrough(void *_glfuncs, GLfloat token); +void gl1_2_glLoadName(void *_glfuncs, GLuint name); +void gl1_2_glInitNames(void *_glfuncs); +GLint gl1_2_glRenderMode(void *_glfuncs, GLenum mode); +void gl1_2_glSelectBuffer(void *_glfuncs, GLsizei size, GLuint* buffer); +void gl1_2_glFeedbackBuffer(void *_glfuncs, GLsizei size, GLenum gltype, GLfloat* buffer); +void gl1_2_glTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, const GLint* params); +void gl1_2_glTexGeni(void *_glfuncs, GLenum coord, GLenum pname, GLint param); +void gl1_2_glTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, const GLfloat* params); +void gl1_2_glTexGenf(void *_glfuncs, GLenum coord, GLenum pname, GLfloat param); +void gl1_2_glTexGendv(void *_glfuncs, GLenum coord, GLenum pname, const GLdouble* params); +void gl1_2_glTexGend(void *_glfuncs, GLenum coord, GLenum pname, GLdouble param); +void gl1_2_glTexEnviv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl1_2_glTexEnvi(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl1_2_glTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl1_2_glTexEnvf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl1_2_glShadeModel(void *_glfuncs, GLenum mode); +void gl1_2_glPolygonStipple(void *_glfuncs, const GLubyte* mask); +void gl1_2_glMaterialiv(void *_glfuncs, GLenum face, GLenum pname, const GLint* params); +void gl1_2_glMateriali(void *_glfuncs, GLenum face, GLenum pname, GLint param); +void gl1_2_glMaterialfv(void *_glfuncs, GLenum face, GLenum pname, const GLfloat* params); +void gl1_2_glMaterialf(void *_glfuncs, GLenum face, GLenum pname, GLfloat param); +void gl1_2_glLineStipple(void *_glfuncs, GLint factor, GLushort pattern); +void gl1_2_glLightModeliv(void *_glfuncs, GLenum pname, const GLint* params); +void gl1_2_glLightModeli(void *_glfuncs, GLenum pname, GLint param); +void gl1_2_glLightModelfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl1_2_glLightModelf(void *_glfuncs, GLenum pname, GLfloat param); +void gl1_2_glLightiv(void *_glfuncs, GLenum light, GLenum pname, const GLint* params); +void gl1_2_glLighti(void *_glfuncs, GLenum light, GLenum pname, GLint param); +void gl1_2_glLightfv(void *_glfuncs, GLenum light, GLenum pname, const GLfloat* params); +void gl1_2_glLightf(void *_glfuncs, GLenum light, GLenum pname, GLfloat param); +void gl1_2_glFogiv(void *_glfuncs, GLenum pname, const GLint* params); +void gl1_2_glFogi(void *_glfuncs, GLenum pname, GLint param); +void gl1_2_glFogfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl1_2_glFogf(void *_glfuncs, GLenum pname, GLfloat param); +void gl1_2_glColorMaterial(void *_glfuncs, GLenum face, GLenum mode); +void gl1_2_glClipPlane(void *_glfuncs, GLenum plane, const GLdouble* equation); +void gl1_2_glVertex4sv(void *_glfuncs, const GLshort* v); +void gl1_2_glVertex4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w); +void gl1_2_glVertex4iv(void *_glfuncs, const GLint* v); +void gl1_2_glVertex4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w); +void gl1_2_glVertex4fv(void *_glfuncs, const GLfloat* v); +void gl1_2_glVertex4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl1_2_glVertex4dv(void *_glfuncs, const GLdouble* v); +void gl1_2_glVertex4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl1_2_glVertex3sv(void *_glfuncs, const GLshort* v); +void gl1_2_glVertex3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl1_2_glVertex3iv(void *_glfuncs, const GLint* v); +void gl1_2_glVertex3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl1_2_glVertex3fv(void *_glfuncs, const GLfloat* v); +void gl1_2_glVertex3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl1_2_glVertex3dv(void *_glfuncs, const GLdouble* v); +void gl1_2_glVertex3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl1_2_glVertex2sv(void *_glfuncs, const GLshort* v); +void gl1_2_glVertex2s(void *_glfuncs, GLshort x, GLshort y); +void gl1_2_glVertex2iv(void *_glfuncs, const GLint* v); +void gl1_2_glVertex2i(void *_glfuncs, GLint x, GLint y); +void gl1_2_glVertex2fv(void *_glfuncs, const GLfloat* v); +void gl1_2_glVertex2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl1_2_glVertex2dv(void *_glfuncs, const GLdouble* v); +void gl1_2_glVertex2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl1_2_glTexCoord4sv(void *_glfuncs, const GLshort* v); +void gl1_2_glTexCoord4s(void *_glfuncs, GLshort s, GLshort t, GLshort r, GLshort q); +void gl1_2_glTexCoord4iv(void *_glfuncs, const GLint* v); +void gl1_2_glTexCoord4i(void *_glfuncs, GLint s, GLint t, GLint r, GLint q); +void gl1_2_glTexCoord4fv(void *_glfuncs, const GLfloat* v); +void gl1_2_glTexCoord4f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +void gl1_2_glTexCoord4dv(void *_glfuncs, const GLdouble* v); +void gl1_2_glTexCoord4d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +void gl1_2_glTexCoord3sv(void *_glfuncs, const GLshort* v); +void gl1_2_glTexCoord3s(void *_glfuncs, GLshort s, GLshort t, GLshort r); +void gl1_2_glTexCoord3iv(void *_glfuncs, const GLint* v); +void gl1_2_glTexCoord3i(void *_glfuncs, GLint s, GLint t, GLint r); +void gl1_2_glTexCoord3fv(void *_glfuncs, const GLfloat* v); +void gl1_2_glTexCoord3f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r); +void gl1_2_glTexCoord3dv(void *_glfuncs, const GLdouble* v); +void gl1_2_glTexCoord3d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r); +void gl1_2_glTexCoord2sv(void *_glfuncs, const GLshort* v); +void gl1_2_glTexCoord2s(void *_glfuncs, GLshort s, GLshort t); +void gl1_2_glTexCoord2iv(void *_glfuncs, const GLint* v); +void gl1_2_glTexCoord2i(void *_glfuncs, GLint s, GLint t); +void gl1_2_glTexCoord2fv(void *_glfuncs, const GLfloat* v); +void gl1_2_glTexCoord2f(void *_glfuncs, GLfloat s, GLfloat t); +void gl1_2_glTexCoord2dv(void *_glfuncs, const GLdouble* v); +void gl1_2_glTexCoord2d(void *_glfuncs, GLdouble s, GLdouble t); +void gl1_2_glTexCoord1sv(void *_glfuncs, const GLshort* v); +void gl1_2_glTexCoord1s(void *_glfuncs, GLshort s); +void gl1_2_glTexCoord1iv(void *_glfuncs, const GLint* v); +void gl1_2_glTexCoord1i(void *_glfuncs, GLint s); +void gl1_2_glTexCoord1fv(void *_glfuncs, const GLfloat* v); +void gl1_2_glTexCoord1f(void *_glfuncs, GLfloat s); +void gl1_2_glTexCoord1dv(void *_glfuncs, const GLdouble* v); +void gl1_2_glTexCoord1d(void *_glfuncs, GLdouble s); +void gl1_2_glRectsv(void *_glfuncs, const GLshort* v1, const GLshort* v2); +void gl1_2_glRects(void *_glfuncs, GLshort x1, GLshort y1, GLshort x2, GLshort y2); +void gl1_2_glRectiv(void *_glfuncs, const GLint* v1, const GLint* v2); +void gl1_2_glRecti(void *_glfuncs, GLint x1, GLint y1, GLint x2, GLint y2); +void gl1_2_glRectfv(void *_glfuncs, const GLfloat* v1, const GLfloat* v2); +void gl1_2_glRectf(void *_glfuncs, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); +void gl1_2_glRectdv(void *_glfuncs, const GLdouble* v1, const GLdouble* v2); +void gl1_2_glRectd(void *_glfuncs, GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); +void gl1_2_glRasterPos4sv(void *_glfuncs, const GLshort* v); +void gl1_2_glRasterPos4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w); +void gl1_2_glRasterPos4iv(void *_glfuncs, const GLint* v); +void gl1_2_glRasterPos4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w); +void gl1_2_glRasterPos4fv(void *_glfuncs, const GLfloat* v); +void gl1_2_glRasterPos4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl1_2_glRasterPos4dv(void *_glfuncs, const GLdouble* v); +void gl1_2_glRasterPos4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl1_2_glRasterPos3sv(void *_glfuncs, const GLshort* v); +void gl1_2_glRasterPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl1_2_glRasterPos3iv(void *_glfuncs, const GLint* v); +void gl1_2_glRasterPos3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl1_2_glRasterPos3fv(void *_glfuncs, const GLfloat* v); +void gl1_2_glRasterPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl1_2_glRasterPos3dv(void *_glfuncs, const GLdouble* v); +void gl1_2_glRasterPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl1_2_glRasterPos2sv(void *_glfuncs, const GLshort* v); +void gl1_2_glRasterPos2s(void *_glfuncs, GLshort x, GLshort y); +void gl1_2_glRasterPos2iv(void *_glfuncs, const GLint* v); +void gl1_2_glRasterPos2i(void *_glfuncs, GLint x, GLint y); +void gl1_2_glRasterPos2fv(void *_glfuncs, const GLfloat* v); +void gl1_2_glRasterPos2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl1_2_glRasterPos2dv(void *_glfuncs, const GLdouble* v); +void gl1_2_glRasterPos2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl1_2_glNormal3sv(void *_glfuncs, const GLshort* v); +void gl1_2_glNormal3s(void *_glfuncs, GLshort nx, GLshort ny, GLshort nz); +void gl1_2_glNormal3iv(void *_glfuncs, const GLint* v); +void gl1_2_glNormal3i(void *_glfuncs, GLint nx, GLint ny, GLint nz); +void gl1_2_glNormal3fv(void *_glfuncs, const GLfloat* v); +void gl1_2_glNormal3f(void *_glfuncs, GLfloat nx, GLfloat ny, GLfloat nz); +void gl1_2_glNormal3dv(void *_glfuncs, const GLdouble* v); +void gl1_2_glNormal3d(void *_glfuncs, GLdouble nx, GLdouble ny, GLdouble nz); +void gl1_2_glNormal3bv(void *_glfuncs, const GLbyte* v); +void gl1_2_glNormal3b(void *_glfuncs, GLbyte nx, GLbyte ny, GLbyte nz); +void gl1_2_glIndexsv(void *_glfuncs, const GLshort* c); +void gl1_2_glIndexs(void *_glfuncs, GLshort c); +void gl1_2_glIndexiv(void *_glfuncs, const GLint* c); +void gl1_2_glIndexi(void *_glfuncs, GLint c); +void gl1_2_glIndexfv(void *_glfuncs, const GLfloat* c); +void gl1_2_glIndexf(void *_glfuncs, GLfloat c); +void gl1_2_glIndexdv(void *_glfuncs, const GLdouble* c); +void gl1_2_glIndexd(void *_glfuncs, GLdouble c); +void gl1_2_glEnd(void *_glfuncs); +void gl1_2_glEdgeFlagv(void *_glfuncs, const GLboolean* flag); +void gl1_2_glEdgeFlag(void *_glfuncs, GLboolean flag); +void gl1_2_glColor4usv(void *_glfuncs, const GLushort* v); +void gl1_2_glColor4us(void *_glfuncs, GLushort red, GLushort green, GLushort blue, GLushort alpha); +void gl1_2_glColor4uiv(void *_glfuncs, const GLuint* v); +void gl1_2_glColor4ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue, GLuint alpha); +void gl1_2_glColor4ubv(void *_glfuncs, const GLubyte* v); +void gl1_2_glColor4ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); +void gl1_2_glColor4sv(void *_glfuncs, const GLshort* v); +void gl1_2_glColor4s(void *_glfuncs, GLshort red, GLshort green, GLshort blue, GLshort alpha); +void gl1_2_glColor4iv(void *_glfuncs, const GLint* v); +void gl1_2_glColor4i(void *_glfuncs, GLint red, GLint green, GLint blue, GLint alpha); +void gl1_2_glColor4fv(void *_glfuncs, const GLfloat* v); +void gl1_2_glColor4f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl1_2_glColor4dv(void *_glfuncs, const GLdouble* v); +void gl1_2_glColor4d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); +void gl1_2_glColor4bv(void *_glfuncs, const GLbyte* v); +void gl1_2_glColor4b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); +void gl1_2_glColor3usv(void *_glfuncs, const GLushort* v); +void gl1_2_glColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue); +void gl1_2_glColor3uiv(void *_glfuncs, const GLuint* v); +void gl1_2_glColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue); +void gl1_2_glColor3ubv(void *_glfuncs, const GLubyte* v); +void gl1_2_glColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue); +void gl1_2_glColor3sv(void *_glfuncs, const GLshort* v); +void gl1_2_glColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue); +void gl1_2_glColor3iv(void *_glfuncs, const GLint* v); +void gl1_2_glColor3i(void *_glfuncs, GLint red, GLint green, GLint blue); +void gl1_2_glColor3fv(void *_glfuncs, const GLfloat* v); +void gl1_2_glColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue); +void gl1_2_glColor3dv(void *_glfuncs, const GLdouble* v); +void gl1_2_glColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue); +void gl1_2_glColor3bv(void *_glfuncs, const GLbyte* v); +void gl1_2_glColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue); +void gl1_2_glBitmap(void *_glfuncs, GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap); +void gl1_2_glBegin(void *_glfuncs, GLenum mode); +void gl1_2_glListBase(void *_glfuncs, GLuint base); +GLuint gl1_2_glGenLists(void *_glfuncs, GLsizei range_); +void gl1_2_glDeleteLists(void *_glfuncs, GLuint list, GLsizei range_); +void gl1_2_glCallLists(void *_glfuncs, GLsizei n, GLenum gltype, const GLvoid* lists); +void gl1_2_glCallList(void *_glfuncs, GLuint list); +void gl1_2_glEndList(void *_glfuncs); +void gl1_2_glNewList(void *_glfuncs, GLuint list, GLenum mode); +void gl1_2_glPushClientAttrib(void *_glfuncs, GLbitfield mask); +void gl1_2_glPopClientAttrib(void *_glfuncs); +void gl1_2_glPrioritizeTextures(void *_glfuncs, GLsizei n, const GLuint* textures, const GLfloat* priorities); +GLboolean gl1_2_glAreTexturesResident(void *_glfuncs, GLsizei n, const GLuint* textures, GLboolean* residences); +void gl1_2_glVertexPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl1_2_glTexCoordPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl1_2_glNormalPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl1_2_glInterleavedArrays(void *_glfuncs, GLenum format, GLsizei stride, const GLvoid* pointer); +void gl1_2_glIndexPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl1_2_glEnableClientState(void *_glfuncs, GLenum array); +void gl1_2_glEdgeFlagPointer(void *_glfuncs, GLsizei stride, const GLvoid* pointer); +void gl1_2_glDisableClientState(void *_glfuncs, GLenum array); +void gl1_2_glColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl1_2_glArrayElement(void *_glfuncs, GLint i); +void gl1_2_glResetMinmax(void *_glfuncs, GLenum target); +void gl1_2_glResetHistogram(void *_glfuncs, GLenum target); +void gl1_2_glMinmax(void *_glfuncs, GLenum target, GLenum internalFormat, GLboolean sink); +void gl1_2_glHistogram(void *_glfuncs, GLenum target, GLsizei width, GLenum internalFormat, GLboolean sink); +void gl1_2_glGetMinmaxParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl1_2_glGetMinmaxParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl1_2_glGetMinmax(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values); +void gl1_2_glGetHistogramParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl1_2_glGetHistogramParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl1_2_glGetHistogram(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values); +void gl1_2_glSeparableFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* row, const GLvoid* column); +void gl1_2_glGetSeparableFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* row, GLvoid* column, GLvoid* span); +void gl1_2_glGetConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl1_2_glGetConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl1_2_glGetConvolutionFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* image); +void gl1_2_glCopyConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height); +void gl1_2_glCopyConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width); +void gl1_2_glConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl1_2_glConvolutionParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint params); +void gl1_2_glConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl1_2_glConvolutionParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat params); +void gl1_2_glConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* image); +void gl1_2_glConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* image); +void gl1_2_glCopyColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); +void gl1_2_glColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum gltype, const GLvoid* data); +void gl1_2_glGetColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl1_2_glGetColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl1_2_glGetColorTable(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* table); +void gl1_2_glCopyColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width); +void gl1_2_glColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl1_2_glColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl1_2_glColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* table); + + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/gl/1.2/gl.go b/gl/1.2/gl.go new file mode 100644 index 00000000..a3f089e7 --- /dev/null +++ b/gl/1.2/gl.go @@ -0,0 +1,3152 @@ +// ** file automatically generated by glgen -- do not edit manually ** + +package GL + +// #cgo CXXFLAGS: -std=c++0x -pedantic-errors -Wall -fno-strict-aliasing +// #cgo LDFLAGS: -lstdc++ +// #cgo pkg-config: Qt5Core Qt5OpenGL +// +// #include "funcs.h" +// +// void free(void*); +// +import "C" + +import ( + "fmt" + "reflect" + "unsafe" + + "gopkg.in/qml.v1/gl/glbase" +) + +// API returns a value that offers methods matching the OpenGL version 1.2 API. +// +// The returned API must not be used after the provided OpenGL context becomes invalid. +func API(context glbase.Contexter) *GL { + gl := &GL{} + gl.funcs = C.gl1_2_funcs() + if gl.funcs == nil { + panic(fmt.Errorf("OpenGL version 1.2 is not available")) + } + return gl +} + +// GL implements the OpenGL version 1.2 API. Values of this +// type must be created via the API function, and it must not be used after +// the associated OpenGL context becomes invalid. +type GL struct { + funcs unsafe.Pointer +} + +const ( + FALSE = 0 + TRUE = 1 + NONE = 0 + + BYTE = 0x1400 + UNSIGNED_BYTE = 0x1401 + SHORT = 0x1402 + UNSIGNED_SHORT = 0x1403 + INT = 0x1404 + UNSIGNED_INT = 0x1405 + FLOAT = 0x1406 + N2_BYTES = 0x1407 + N3_BYTES = 0x1408 + N4_BYTES = 0x1409 + DOUBLE = 0x140A + + ACCUM = 0x0100 + LOAD = 0x0101 + RETURN = 0x0102 + MULT = 0x0103 + ADD = 0x0104 + + ACCUM_BUFFER_BIT = 0x00000200 + ALL_ATTRIB_BITS = 0xFFFFFFFF + COLOR_BUFFER_BIT = 0x00004000 + CURRENT_BIT = 0x00000001 + DEPTH_BUFFER_BIT = 0x00000100 + ENABLE_BIT = 0x00002000 + EVAL_BIT = 0x00010000 + FOG_BIT = 0x00000080 + HINT_BIT = 0x00008000 + LIGHTING_BIT = 0x00000040 + LINE_BIT = 0x00000004 + LIST_BIT = 0x00020000 + PIXEL_MODE_BIT = 0x00000020 + POINT_BIT = 0x00000002 + POLYGON_BIT = 0x00000008 + POLYGON_STIPPLE_BIT = 0x00000010 + SCISSOR_BIT = 0x00080000 + STENCIL_BUFFER_BIT = 0x00000400 + TEXTURE_BIT = 0x00040000 + TRANSFORM_BIT = 0x00001000 + VIEWPORT_BIT = 0x00000800 + + ALWAYS = 0x0207 + EQUAL = 0x0202 + GEQUAL = 0x0206 + GREATER = 0x0204 + LEQUAL = 0x0203 + LESS = 0x0201 + NEVER = 0x0200 + NOTEQUAL = 0x0205 + + LOGIC_OP = 0x0BF1 + + DST_ALPHA = 0x0304 + ONE = 1 + ONE_MINUS_DST_ALPHA = 0x0305 + ONE_MINUS_SRC_ALPHA = 0x0303 + ONE_MINUS_SRC_COLOR = 0x0301 + SRC_ALPHA = 0x0302 + SRC_COLOR = 0x0300 + ZERO = 0 + + DST_COLOR = 0x0306 + ONE_MINUS_DST_COLOR = 0x0307 + SRC_ALPHA_SATURATE = 0x0308 + + CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF + CLIENT_PIXEL_STORE_BIT = 0x00000001 + CLIENT_VERTEX_ARRAY_BIT = 0x00000002 + + CLIP_PLANE0 = 0x3000 + CLIP_PLANE1 = 0x3001 + CLIP_PLANE2 = 0x3002 + CLIP_PLANE3 = 0x3003 + CLIP_PLANE4 = 0x3004 + CLIP_PLANE5 = 0x3005 + + BACK = 0x0405 + FRONT = 0x0404 + FRONT_AND_BACK = 0x0408 + + AMBIENT = 0x1200 + AMBIENT_AND_DIFFUSE = 0x1602 + DIFFUSE = 0x1201 + EMISSION = 0x1600 + SPECULAR = 0x1202 + + AUX0 = 0x0409 + AUX1 = 0x040A + AUX2 = 0x040B + AUX3 = 0x040C + BACK_LEFT = 0x0402 + BACK_RIGHT = 0x0403 + FRONT_LEFT = 0x0400 + FRONT_RIGHT = 0x0401 + LEFT = 0x0406 + RIGHT = 0x0407 + + ALPHA_TEST = 0x0BC0 + AUTO_NORMAL = 0x0D80 + BLEND = 0x0BE2 + COLOR_ARRAY = 0x8076 + COLOR_LOGIC_OP = 0x0BF2 + COLOR_MATERIAL = 0x0B57 + CULL_FACE = 0x0B44 + DEPTH_TEST = 0x0B71 + DITHER = 0x0BD0 + EDGE_FLAG_ARRAY = 0x8079 + FOG = 0x0B60 + INDEX_ARRAY = 0x8077 + INDEX_LOGIC_OP = 0x0BF1 + LIGHT0 = 0x4000 + LIGHT1 = 0x4001 + LIGHT2 = 0x4002 + LIGHT3 = 0x4003 + LIGHT4 = 0x4004 + LIGHT5 = 0x4005 + LIGHT6 = 0x4006 + LIGHT7 = 0x4007 + LIGHTING = 0x0B50 + LINE_SMOOTH = 0x0B20 + LINE_STIPPLE = 0x0B24 + MAP1_COLOR_4 = 0x0D90 + MAP1_INDEX = 0x0D91 + MAP1_NORMAL = 0x0D92 + MAP1_TEXTURE_COORD_1 = 0x0D93 + MAP1_TEXTURE_COORD_2 = 0x0D94 + MAP1_TEXTURE_COORD_3 = 0x0D95 + MAP1_TEXTURE_COORD_4 = 0x0D96 + MAP1_VERTEX_3 = 0x0D97 + MAP1_VERTEX_4 = 0x0D98 + MAP2_COLOR_4 = 0x0DB0 + MAP2_INDEX = 0x0DB1 + MAP2_NORMAL = 0x0DB2 + MAP2_TEXTURE_COORD_1 = 0x0DB3 + MAP2_TEXTURE_COORD_2 = 0x0DB4 + MAP2_TEXTURE_COORD_3 = 0x0DB5 + MAP2_TEXTURE_COORD_4 = 0x0DB6 + MAP2_VERTEX_3 = 0x0DB7 + MAP2_VERTEX_4 = 0x0DB8 + NORMALIZE = 0x0BA1 + NORMAL_ARRAY = 0x8075 + POINT_SMOOTH = 0x0B10 + POLYGON_OFFSET_FILL = 0x8037 + POLYGON_OFFSET_LINE = 0x2A02 + POLYGON_OFFSET_POINT = 0x2A01 + POLYGON_SMOOTH = 0x0B41 + POLYGON_STIPPLE = 0x0B42 + SCISSOR_TEST = 0x0C11 + STENCIL_TEST = 0x0B90 + TEXTURE_1D = 0x0DE0 + TEXTURE_2D = 0x0DE1 + TEXTURE_COORD_ARRAY = 0x8078 + TEXTURE_GEN_Q = 0x0C63 + TEXTURE_GEN_R = 0x0C62 + TEXTURE_GEN_S = 0x0C60 + TEXTURE_GEN_T = 0x0C61 + VERTEX_ARRAY = 0x8074 + + INVALID_ENUM = 0x0500 + INVALID_OPERATION = 0x0502 + INVALID_VALUE = 0x0501 + NO_ERROR = 0 + OUT_OF_MEMORY = 0x0505 + STACK_OVERFLOW = 0x0503 + STACK_UNDERFLOW = 0x0504 + + N2D = 0x0600 + N3D = 0x0601 + N3D_COLOR = 0x0602 + N3D_COLOR_TEXTURE = 0x0603 + N4D_COLOR_TEXTURE = 0x0604 + + BITMAP_TOKEN = 0x0704 + COPY_PIXEL_TOKEN = 0x0706 + DRAW_PIXEL_TOKEN = 0x0705 + LINE_RESET_TOKEN = 0x0707 + LINE_TOKEN = 0x0702 + PASS_THROUGH_TOKEN = 0x0700 + POINT_TOKEN = 0x0701 + POLYGON_TOKEN = 0x0703 + + EXP = 0x0800 + EXP2 = 0x0801 + LINEAR = 0x2601 + + FOG_COLOR = 0x0B66 + FOG_DENSITY = 0x0B62 + FOG_END = 0x0B64 + FOG_INDEX = 0x0B61 + FOG_MODE = 0x0B65 + FOG_START = 0x0B63 + + CCW = 0x0901 + CW = 0x0900 + + COEFF = 0x0A00 + DOMAIN = 0x0A02 + ORDER = 0x0A01 + + PIXEL_MAP_A_TO_A = 0x0C79 + PIXEL_MAP_B_TO_B = 0x0C78 + PIXEL_MAP_G_TO_G = 0x0C77 + PIXEL_MAP_I_TO_A = 0x0C75 + PIXEL_MAP_I_TO_B = 0x0C74 + PIXEL_MAP_I_TO_G = 0x0C73 + PIXEL_MAP_I_TO_I = 0x0C70 + PIXEL_MAP_I_TO_R = 0x0C72 + PIXEL_MAP_R_TO_R = 0x0C76 + PIXEL_MAP_S_TO_S = 0x0C71 + + ACCUM_ALPHA_BITS = 0x0D5B + ACCUM_BLUE_BITS = 0x0D5A + ACCUM_CLEAR_VALUE = 0x0B80 + ACCUM_GREEN_BITS = 0x0D59 + ACCUM_RED_BITS = 0x0D58 + ALIASED_LINE_WIDTH_RANGE = 0x846E + ALIASED_POINT_SIZE_RANGE = 0x846D + ALPHA_BIAS = 0x0D1D + ALPHA_BITS = 0x0D55 + ALPHA_SCALE = 0x0D1C + ALPHA_TEST_FUNC = 0x0BC1 + ALPHA_TEST_REF = 0x0BC2 + ATTRIB_STACK_DEPTH = 0x0BB0 + AUX_BUFFERS = 0x0C00 + BLEND_DST = 0x0BE0 + BLEND_SRC = 0x0BE1 + BLUE_BIAS = 0x0D1B + BLUE_BITS = 0x0D54 + BLUE_SCALE = 0x0D1A + CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1 + COLOR_ARRAY_SIZE = 0x8081 + COLOR_ARRAY_STRIDE = 0x8083 + COLOR_ARRAY_TYPE = 0x8082 + COLOR_CLEAR_VALUE = 0x0C22 + COLOR_MATERIAL_FACE = 0x0B55 + COLOR_MATERIAL_PARAMETER = 0x0B56 + COLOR_WRITEMASK = 0x0C23 + CULL_FACE_MODE = 0x0B45 + CURRENT_COLOR = 0x0B00 + CURRENT_INDEX = 0x0B01 + CURRENT_NORMAL = 0x0B02 + CURRENT_RASTER_COLOR = 0x0B04 + CURRENT_RASTER_DISTANCE = 0x0B09 + CURRENT_RASTER_INDEX = 0x0B05 + CURRENT_RASTER_POSITION = 0x0B07 + CURRENT_RASTER_POSITION_VALID = 0x0B08 + CURRENT_RASTER_TEXTURE_COORDS = 0x0B06 + CURRENT_TEXTURE_COORDS = 0x0B03 + DEPTH_BIAS = 0x0D1F + DEPTH_BITS = 0x0D56 + DEPTH_CLEAR_VALUE = 0x0B73 + DEPTH_FUNC = 0x0B74 + DEPTH_RANGE = 0x0B70 + DEPTH_SCALE = 0x0D1E + DEPTH_WRITEMASK = 0x0B72 + DOUBLEBUFFER = 0x0C32 + DRAW_BUFFER = 0x0C01 + EDGE_FLAG = 0x0B43 + EDGE_FLAG_ARRAY_STRIDE = 0x808C + FEEDBACK_BUFFER_SIZE = 0x0DF1 + FEEDBACK_BUFFER_TYPE = 0x0DF2 + FOG_HINT = 0x0C54 + FRONT_FACE = 0x0B46 + GREEN_BIAS = 0x0D19 + GREEN_BITS = 0x0D53 + GREEN_SCALE = 0x0D18 + INDEX_ARRAY_STRIDE = 0x8086 + INDEX_ARRAY_TYPE = 0x8085 + INDEX_BITS = 0x0D51 + INDEX_CLEAR_VALUE = 0x0C20 + INDEX_MODE = 0x0C30 + INDEX_OFFSET = 0x0D13 + INDEX_SHIFT = 0x0D12 + INDEX_WRITEMASK = 0x0C21 + LIGHT_MODEL_AMBIENT = 0x0B53 + LIGHT_MODEL_COLOR_CONTROL = 0x81F8 + LIGHT_MODEL_LOCAL_VIEWER = 0x0B51 + LIGHT_MODEL_TWO_SIDE = 0x0B52 + LINE_SMOOTH_HINT = 0x0C52 + LINE_STIPPLE_PATTERN = 0x0B25 + LINE_STIPPLE_REPEAT = 0x0B26 + LINE_WIDTH = 0x0B21 + LINE_WIDTH_GRANULARITY = 0x0B23 + LINE_WIDTH_RANGE = 0x0B22 + LIST_BASE = 0x0B32 + LIST_INDEX = 0x0B33 + LIST_MODE = 0x0B30 + LOGIC_OP_MODE = 0x0BF0 + MAP1_GRID_DOMAIN = 0x0DD0 + MAP1_GRID_SEGMENTS = 0x0DD1 + MAP2_GRID_DOMAIN = 0x0DD2 + MAP2_GRID_SEGMENTS = 0x0DD3 + MAP_COLOR = 0x0D10 + MAP_STENCIL = 0x0D11 + MATRIX_MODE = 0x0BA0 + MAX_ATTRIB_STACK_DEPTH = 0x0D35 + MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B + MAX_CLIP_PLANES = 0x0D32 + MAX_EVAL_ORDER = 0x0D30 + MAX_LIGHTS = 0x0D31 + MAX_LIST_NESTING = 0x0B31 + MAX_MODELVIEW_STACK_DEPTH = 0x0D36 + MAX_NAME_STACK_DEPTH = 0x0D37 + MAX_PIXEL_MAP_TABLE = 0x0D34 + MAX_PROJECTION_STACK_DEPTH = 0x0D38 + MAX_TEXTURE_SIZE = 0x0D33 + MAX_TEXTURE_STACK_DEPTH = 0x0D39 + MAX_VIEWPORT_DIMS = 0x0D3A + MODELVIEW_MATRIX = 0x0BA6 + MODELVIEW_STACK_DEPTH = 0x0BA3 + NAME_STACK_DEPTH = 0x0D70 + NORMAL_ARRAY_STRIDE = 0x807F + NORMAL_ARRAY_TYPE = 0x807E + PACK_ALIGNMENT = 0x0D05 + PACK_LSB_FIRST = 0x0D01 + PACK_ROW_LENGTH = 0x0D02 + PACK_SKIP_PIXELS = 0x0D04 + PACK_SKIP_ROWS = 0x0D03 + PACK_SWAP_BYTES = 0x0D00 + PERSPECTIVE_CORRECTION_HINT = 0x0C50 + PIXEL_MAP_A_TO_A_SIZE = 0x0CB9 + PIXEL_MAP_B_TO_B_SIZE = 0x0CB8 + PIXEL_MAP_G_TO_G_SIZE = 0x0CB7 + PIXEL_MAP_I_TO_A_SIZE = 0x0CB5 + PIXEL_MAP_I_TO_B_SIZE = 0x0CB4 + PIXEL_MAP_I_TO_G_SIZE = 0x0CB3 + PIXEL_MAP_I_TO_I_SIZE = 0x0CB0 + PIXEL_MAP_I_TO_R_SIZE = 0x0CB2 + PIXEL_MAP_R_TO_R_SIZE = 0x0CB6 + PIXEL_MAP_S_TO_S_SIZE = 0x0CB1 + POINT_SIZE = 0x0B11 + POINT_SIZE_GRANULARITY = 0x0B13 + POINT_SIZE_RANGE = 0x0B12 + POINT_SMOOTH_HINT = 0x0C51 + POLYGON_MODE = 0x0B40 + POLYGON_OFFSET_FACTOR = 0x8038 + POLYGON_OFFSET_UNITS = 0x2A00 + POLYGON_SMOOTH_HINT = 0x0C53 + PROJECTION_MATRIX = 0x0BA7 + PROJECTION_STACK_DEPTH = 0x0BA4 + READ_BUFFER = 0x0C02 + RED_BIAS = 0x0D15 + RED_BITS = 0x0D52 + RED_SCALE = 0x0D14 + RENDER_MODE = 0x0C40 + RGBA_MODE = 0x0C31 + SCISSOR_BOX = 0x0C10 + SELECTION_BUFFER_SIZE = 0x0DF4 + SHADE_MODEL = 0x0B54 + SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23 + SMOOTH_LINE_WIDTH_RANGE = 0x0B22 + SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13 + SMOOTH_POINT_SIZE_RANGE = 0x0B12 + STENCIL_BITS = 0x0D57 + STENCIL_CLEAR_VALUE = 0x0B91 + STENCIL_FAIL = 0x0B94 + STENCIL_FUNC = 0x0B92 + STENCIL_PASS_DEPTH_FAIL = 0x0B95 + STENCIL_PASS_DEPTH_PASS = 0x0B96 + STENCIL_REF = 0x0B97 + STENCIL_VALUE_MASK = 0x0B93 + STENCIL_WRITEMASK = 0x0B98 + STEREO = 0x0C33 + SUBPIXEL_BITS = 0x0D50 + TEXTURE_BINDING_1D = 0x8068 + TEXTURE_BINDING_2D = 0x8069 + TEXTURE_BINDING_3D = 0x806A + TEXTURE_COORD_ARRAY_SIZE = 0x8088 + TEXTURE_COORD_ARRAY_STRIDE = 0x808A + TEXTURE_COORD_ARRAY_TYPE = 0x8089 + TEXTURE_MATRIX = 0x0BA8 + TEXTURE_STACK_DEPTH = 0x0BA5 + UNPACK_ALIGNMENT = 0x0CF5 + UNPACK_LSB_FIRST = 0x0CF1 + UNPACK_ROW_LENGTH = 0x0CF2 + UNPACK_SKIP_PIXELS = 0x0CF4 + UNPACK_SKIP_ROWS = 0x0CF3 + UNPACK_SWAP_BYTES = 0x0CF0 + VERTEX_ARRAY_SIZE = 0x807A + VERTEX_ARRAY_STRIDE = 0x807C + VERTEX_ARRAY_TYPE = 0x807B + VIEWPORT = 0x0BA2 + ZOOM_X = 0x0D16 + ZOOM_Y = 0x0D17 + + COLOR_ARRAY_POINTER = 0x8090 + EDGE_FLAG_ARRAY_POINTER = 0x8093 + FEEDBACK_BUFFER_POINTER = 0x0DF0 + INDEX_ARRAY_POINTER = 0x8091 + NORMAL_ARRAY_POINTER = 0x808F + SELECTION_BUFFER_POINTER = 0x0DF3 + TEXTURE_COORD_ARRAY_POINTER = 0x8092 + VERTEX_ARRAY_POINTER = 0x808E + + TEXTURE_ALPHA_SIZE = 0x805F + TEXTURE_BLUE_SIZE = 0x805E + TEXTURE_BORDER = 0x1005 + TEXTURE_BORDER_COLOR = 0x1004 + TEXTURE_COMPONENTS = 0x1003 + TEXTURE_GREEN_SIZE = 0x805D + TEXTURE_HEIGHT = 0x1001 + TEXTURE_INTENSITY_SIZE = 0x8061 + TEXTURE_INTERNAL_FORMAT = 0x1003 + TEXTURE_LUMINANCE_SIZE = 0x8060 + TEXTURE_MAG_FILTER = 0x2800 + TEXTURE_MIN_FILTER = 0x2801 + TEXTURE_PRIORITY = 0x8066 + TEXTURE_RED_SIZE = 0x805C + TEXTURE_RESIDENT = 0x8067 + TEXTURE_WIDTH = 0x1000 + TEXTURE_WRAP_S = 0x2802 + TEXTURE_WRAP_T = 0x2803 + + DONT_CARE = 0x1100 + FASTEST = 0x1101 + NICEST = 0x1102 + + C3F_V3F = 0x2A24 + C4F_N3F_V3F = 0x2A26 + C4UB_V2F = 0x2A22 + C4UB_V3F = 0x2A23 + N3F_V3F = 0x2A25 + T2F_C3F_V3F = 0x2A2A + T2F_C4F_N3F_V3F = 0x2A2C + T2F_C4UB_V3F = 0x2A29 + T2F_N3F_V3F = 0x2A2B + T2F_V3F = 0x2A27 + T4F_C4F_N3F_V4F = 0x2A2D + T4F_V4F = 0x2A28 + V2F = 0x2A20 + V3F = 0x2A21 + + MODULATE = 0x2100 + REPLACE = 0x1E01 + + SEPARATE_SPECULAR_COLOR = 0x81FA + SINGLE_COLOR = 0x81F9 + + CONSTANT_ATTENUATION = 0x1207 + LINEAR_ATTENUATION = 0x1208 + POSITION = 0x1203 + QUADRATIC_ATTENUATION = 0x1209 + SPOT_CUTOFF = 0x1206 + SPOT_DIRECTION = 0x1204 + SPOT_EXPONENT = 0x1205 + + COMPILE = 0x1300 + COMPILE_AND_EXECUTE = 0x1301 + + AND = 0x1501 + AND_INVERTED = 0x1504 + AND_REVERSE = 0x1502 + CLEAR = 0x1500 + COPY = 0x1503 + COPY_INVERTED = 0x150C + EQUIV = 0x1509 + INVERT = 0x150A + NAND = 0x150E + NOOP = 0x1505 + NOR = 0x1508 + OR = 0x1507 + OR_INVERTED = 0x150D + OR_REVERSE = 0x150B + SET = 0x150F + XOR = 0x1506 + + COLOR_INDEXES = 0x1603 + SHININESS = 0x1601 + + MODELVIEW = 0x1700 + PROJECTION = 0x1701 + TEXTURE = 0x1702 + + LINE = 0x1B01 + POINT = 0x1B00 + + FILL = 0x1B02 + + COLOR = 0x1800 + DEPTH = 0x1801 + STENCIL = 0x1802 + + ALPHA = 0x1906 + BLUE = 0x1905 + COLOR_INDEX = 0x1900 + DEPTH_COMPONENT = 0x1902 + GREEN = 0x1904 + LUMINANCE = 0x1909 + LUMINANCE_ALPHA = 0x190A + RED = 0x1903 + RGB = 0x1907 + RGBA = 0x1908 + STENCIL_INDEX = 0x1901 + + ALPHA12 = 0x803D + ALPHA16 = 0x803E + ALPHA4 = 0x803B + ALPHA8 = 0x803C + INTENSITY = 0x8049 + INTENSITY12 = 0x804C + INTENSITY16 = 0x804D + INTENSITY4 = 0x804A + INTENSITY8 = 0x804B + LUMINANCE12 = 0x8041 + LUMINANCE12_ALPHA12 = 0x8047 + LUMINANCE12_ALPHA4 = 0x8046 + LUMINANCE16 = 0x8042 + LUMINANCE16_ALPHA16 = 0x8048 + LUMINANCE4 = 0x803F + LUMINANCE4_ALPHA4 = 0x8043 + LUMINANCE6_ALPHA2 = 0x8044 + LUMINANCE8 = 0x8040 + LUMINANCE8_ALPHA8 = 0x8045 + R3_G3_B2 = 0x2A10 + RGB10 = 0x8052 + RGB10_A2 = 0x8059 + RGB12 = 0x8053 + RGB16 = 0x8054 + RGB4 = 0x804F + RGB5 = 0x8050 + RGB5_A1 = 0x8057 + RGB8 = 0x8051 + RGBA12 = 0x805A + RGBA16 = 0x805B + RGBA2 = 0x8055 + RGBA4 = 0x8056 + RGBA8 = 0x8058 + + PACK_IMAGE_HEIGHT = 0x806C + PACK_SKIP_IMAGES = 0x806B + UNPACK_IMAGE_HEIGHT = 0x806E + UNPACK_SKIP_IMAGES = 0x806D + + BITMAP = 0x1A00 + UNSIGNED_BYTE_3_3_2 = 0x8032 + UNSIGNED_INT_10_10_10_2 = 0x8036 + UNSIGNED_INT_8_8_8_8 = 0x8035 + UNSIGNED_SHORT_4_4_4_4 = 0x8033 + UNSIGNED_SHORT_5_5_5_1 = 0x8034 + + LINES = 0x0001 + LINE_LOOP = 0x0002 + LINE_STRIP = 0x0003 + POINTS = 0x0000 + POLYGON = 0x0009 + QUADS = 0x0007 + QUAD_STRIP = 0x0008 + TRIANGLES = 0x0004 + TRIANGLE_FAN = 0x0006 + TRIANGLE_STRIP = 0x0005 + + FEEDBACK = 0x1C01 + RENDER = 0x1C00 + SELECT = 0x1C02 + + FLAT = 0x1D00 + SMOOTH = 0x1D01 + + DECR = 0x1E03 + INCR = 0x1E02 + KEEP = 0x1E00 + + EXTENSIONS = 0x1F03 + RENDERER = 0x1F01 + VENDOR = 0x1F00 + VERSION = 0x1F02 + + S = 0x2000 + T = 0x2001 + R = 0x2002 + Q = 0x2003 + + DECAL = 0x2101 + + TEXTURE_ENV_COLOR = 0x2201 + TEXTURE_ENV_MODE = 0x2200 + + TEXTURE_ENV = 0x2300 + + EYE_LINEAR = 0x2400 + OBJECT_LINEAR = 0x2401 + SPHERE_MAP = 0x2402 + + EYE_PLANE = 0x2502 + OBJECT_PLANE = 0x2501 + TEXTURE_GEN_MODE = 0x2500 + + NEAREST = 0x2600 + + LINEAR_MIPMAP_LINEAR = 0x2703 + LINEAR_MIPMAP_NEAREST = 0x2701 + NEAREST_MIPMAP_LINEAR = 0x2702 + NEAREST_MIPMAP_NEAREST = 0x2700 + + TEXTURE_WRAP_R = 0x8072 + + PROXY_TEXTURE_1D = 0x8063 + PROXY_TEXTURE_2D = 0x8064 + PROXY_TEXTURE_3D = 0x8070 + TEXTURE_3D = 0x806F + TEXTURE_BASE_LEVEL = 0x813C + TEXTURE_MAX_LEVEL = 0x813D + TEXTURE_MAX_LOD = 0x813B + TEXTURE_MIN_LOD = 0x813A + + CLAMP = 0x2900 + CLAMP_TO_EDGE = 0x812F + REPEAT = 0x2901 + + RESCALE_NORMAL = 0x803A + TEXTURE_DEPTH = 0x8071 + MAX_3D_TEXTURE_SIZE = 0x8073 + BGR = 0x80E0 + BGRA = 0x80E1 + MAX_ELEMENTS_VERTICES = 0x80E8 + MAX_ELEMENTS_INDICES = 0x80E9 + UNSIGNED_BYTE_2_3_3_REV = 0x8362 + UNSIGNED_SHORT_5_6_5 = 0x8363 + UNSIGNED_SHORT_5_6_5_REV = 0x8364 + UNSIGNED_SHORT_4_4_4_4_REV = 0x8365 + UNSIGNED_SHORT_1_5_5_5_REV = 0x8366 + UNSIGNED_INT_8_8_8_8_REV = 0x8367 + UNSIGNED_INT_2_10_10_10_REV = 0x8368 +) + +// https://www.opengl.org/sdk/docs/man2/xhtml/glViewport.xml +func (gl *GL) Viewport(x, y, width, height int) { + C.gl1_2_glViewport(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// DepthRange specifies the mapping of depth values from normalized device +// coordinates to window coordinates. +// +// Parameter nearVal specifies the mapping of the near clipping plane to window +// coordinates (defaults to 0), while farVal specifies the mapping of the far +// clipping plane to window coordinates (defaults to 1). +// +// After clipping and division by w, depth coordinates range from -1 to 1, +// corresponding to the near and far clipping planes. DepthRange specifies a +// linear mapping of the normalized depth coordinates in this range to window +// depth coordinates. Regardless of the actual depth buffer implementation, +// window coordinate depth values are treated as though they range from 0 through 1 +// (like color components). Thus, the values accepted by DepthRange are both +// clamped to this range before they are accepted. +// +// The default setting of (0, 1) maps the near plane to 0 and the far plane to 1. +// With this mapping, the depth buffer range is fully utilized. +// +// It is not necessary that nearVal be less than farVal. Reverse mappings such as +// nearVal 1, and farVal 0 are acceptable. +// +// GL.INVALID_OPERATION is generated if DepthRange is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) DepthRange(nearVal, farVal float64) { + C.gl1_2_glDepthRange(gl.funcs, C.GLdouble(nearVal), C.GLdouble(farVal)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsEnabled.xml +func (gl *GL) IsEnabled(cap glbase.Enum) bool { + glresult := C.gl1_2_glIsEnabled(gl.funcs, C.GLenum(cap)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexLevelParameteriv.xml +func (gl *GL) GetTexLevelParameteriv(target glbase.Enum, level int, pname glbase.Enum, params []int32) { + C.gl1_2_glGetTexLevelParameteriv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexLevelParameterfv.xml +func (gl *GL) GetTexLevelParameterfv(target glbase.Enum, level int, pname glbase.Enum, params []float32) { + C.gl1_2_glGetTexLevelParameterfv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexParameteriv.xml +func (gl *GL) GetTexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_2_glGetTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexParameterfv.xml +func (gl *GL) GetTexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_2_glGetTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexImage.xml +func (gl *GL) GetTexImage(target glbase.Enum, level int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_2_glGetTexImage(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetIntegerv.xml +func (gl *GL) GetIntegerv(pname glbase.Enum, params []int32) { + C.gl1_2_glGetIntegerv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetFloatv.xml +func (gl *GL) GetFloatv(pname glbase.Enum, params []float32) { + C.gl1_2_glGetFloatv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetError.xml +func (gl *GL) GetError() glbase.Enum { + glresult := C.gl1_2_glGetError(gl.funcs) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetDoublev.xml +func (gl *GL) GetDoublev(pname glbase.Enum, params []float64) { + C.gl1_2_glGetDoublev(gl.funcs, C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetBooleanv.xml +func (gl *GL) GetBooleanv(pname glbase.Enum, params []bool) { + C.gl1_2_glGetBooleanv(gl.funcs, C.GLenum(pname), (*C.GLboolean)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glReadPixels.xml +func (gl *GL) ReadPixels(x, y, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_2_glReadPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glReadBuffer.xml +func (gl *GL) ReadBuffer(mode glbase.Enum) { + C.gl1_2_glReadBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelStorei.xml +func (gl *GL) PixelStorei(pname glbase.Enum, param int32) { + C.gl1_2_glPixelStorei(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelStoref.xml +func (gl *GL) PixelStoref(pname glbase.Enum, param float32) { + C.gl1_2_glPixelStoref(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDepthFunc.xml +func (gl *GL) DepthFunc(glfunc glbase.Enum) { + C.gl1_2_glDepthFunc(gl.funcs, C.GLenum(glfunc)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilOp.xml +func (gl *GL) StencilOp(fail, zfail, zpass glbase.Enum) { + C.gl1_2_glStencilOp(gl.funcs, C.GLenum(fail), C.GLenum(zfail), C.GLenum(zpass)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilFunc.xml +func (gl *GL) StencilFunc(glfunc glbase.Enum, ref int32, mask uint32) { + C.gl1_2_glStencilFunc(gl.funcs, C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLogicOp.xml +func (gl *GL) LogicOp(opcode glbase.Enum) { + C.gl1_2_glLogicOp(gl.funcs, C.GLenum(opcode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBlendFunc.xml +func (gl *GL) BlendFunc(sfactor, dfactor glbase.Enum) { + C.gl1_2_glBlendFunc(gl.funcs, C.GLenum(sfactor), C.GLenum(dfactor)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFlush.xml +func (gl *GL) Flush() { + C.gl1_2_glFlush(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFinish.xml +func (gl *GL) Finish() { + C.gl1_2_glFinish(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEnable.xml +func (gl *GL) Enable(cap glbase.Enum) { + C.gl1_2_glEnable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDisable.xml +func (gl *GL) Disable(cap glbase.Enum) { + C.gl1_2_glDisable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDepthMask.xml +func (gl *GL) DepthMask(flag bool) { + C.gl1_2_glDepthMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorMask.xml +func (gl *GL) ColorMask(red, green, blue, alpha bool) { + C.gl1_2_glColorMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&red)), *(*C.GLboolean)(unsafe.Pointer(&green)), *(*C.GLboolean)(unsafe.Pointer(&blue)), *(*C.GLboolean)(unsafe.Pointer(&alpha))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilMask.xml +func (gl *GL) StencilMask(mask uint32) { + C.gl1_2_glStencilMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearDepth.xml +func (gl *GL) ClearDepth(depth float64) { + C.gl1_2_glClearDepth(gl.funcs, C.GLdouble(depth)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearStencil.xml +func (gl *GL) ClearStencil(s int32) { + C.gl1_2_glClearStencil(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearColor.xml +func (gl *GL) ClearColor(red, green, blue, alpha float32) { + C.gl1_2_glClearColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClear.xml +func (gl *GL) Clear(mask glbase.Bitfield) { + C.gl1_2_glClear(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawBuffer.xml +func (gl *GL) DrawBuffer(mode glbase.Enum) { + C.gl1_2_glDrawBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexImage2D.xml +func (gl *GL) TexImage2D(target glbase.Enum, level int, internalFormat int32, width, height, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_2_glTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexImage1D.xml +func (gl *GL) TexImage1D(target glbase.Enum, level int, internalFormat int32, width, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_2_glTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameteriv.xml +func (gl *GL) TexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_2_glTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameteri.xml +func (gl *GL) TexParameteri(target, pname glbase.Enum, param int32) { + C.gl1_2_glTexParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameterfv.xml +func (gl *GL) TexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_2_glTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameterf.xml +func (gl *GL) TexParameterf(target, pname glbase.Enum, param float32) { + C.gl1_2_glTexParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glScissor.xml +func (gl *GL) Scissor(x, y, width, height int) { + C.gl1_2_glScissor(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPolygonMode.xml +func (gl *GL) PolygonMode(face, mode glbase.Enum) { + C.gl1_2_glPolygonMode(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPointSize.xml +func (gl *GL) PointSize(size float32) { + C.gl1_2_glPointSize(gl.funcs, C.GLfloat(size)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLineWidth.xml +func (gl *GL) LineWidth(width float32) { + C.gl1_2_glLineWidth(gl.funcs, C.GLfloat(width)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glHint.xml +func (gl *GL) Hint(target, mode glbase.Enum) { + C.gl1_2_glHint(gl.funcs, C.GLenum(target), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFrontFace.xml +func (gl *GL) FrontFace(mode glbase.Enum) { + C.gl1_2_glFrontFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCullFace.xml +func (gl *GL) CullFace(mode glbase.Enum) { + C.gl1_2_glCullFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexubv.xml +func (gl *GL) Indexubv(c []uint8) { + C.gl1_2_glIndexubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexub.xml +func (gl *GL) Indexub(c uint8) { + C.gl1_2_glIndexub(gl.funcs, C.GLubyte(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsTexture.xml +func (gl *GL) IsTexture(texture glbase.Texture) bool { + glresult := C.gl1_2_glIsTexture(gl.funcs, C.GLuint(texture)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenTextures returns n texture names in textures. There is no guarantee +// that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenTextures. +// +// The generated textures have no dimensionality; they assume the +// dimensionality of the texture target to which they are first bound (see +// BindTexture). +// +// Texture names returned by a call to GenTextures are not returned by +// subsequent calls, unless they are first deleted with DeleteTextures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenTextures is available in GL version 2.0 or greater. +func (gl *GL) GenTextures(n int) []glbase.Texture { + if n == 0 { + return nil + } + textures := make([]glbase.Texture, n) + C.gl1_2_glGenTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) + return textures +} + +// DeleteTextures deletes the textures objects whose names are stored +// in the textures slice. After a texture is deleted, it has no contents or +// dimensionality, and its name is free for reuse (for example by +// GenTextures). If a texture that is currently bound is deleted, the binding +// reverts to 0 (the default texture). +// +// DeleteTextures silently ignores 0's and names that do not correspond to +// existing textures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteTextures is available in GL version 2.0 or greater. +func (gl *GL) DeleteTextures(textures []glbase.Texture) { + n := len(textures) + if n == 0 { + return + } + C.gl1_2_glDeleteTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBindTexture.xml +func (gl *GL) BindTexture(target glbase.Enum, texture glbase.Texture) { + C.gl1_2_glBindTexture(gl.funcs, C.GLenum(target), C.GLuint(texture)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexSubImage2D.xml +func (gl *GL) TexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_2_glTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexSubImage1D.xml +func (gl *GL) TexSubImage1D(target glbase.Enum, level, xoffset, width int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_2_glTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexSubImage2D.xml +func (gl *GL) CopyTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, x, y, width, height int) { + C.gl1_2_glCopyTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexSubImage1D.xml +func (gl *GL) CopyTexSubImage1D(target glbase.Enum, level, xoffset, x, y, width int) { + C.gl1_2_glCopyTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexImage2D.xml +func (gl *GL) CopyTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, height, border int) { + C.gl1_2_glCopyTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexImage1D.xml +func (gl *GL) CopyTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, border int) { + C.gl1_2_glCopyTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPolygonOffset.xml +func (gl *GL) PolygonOffset(factor, units float32) { + C.gl1_2_glPolygonOffset(gl.funcs, C.GLfloat(factor), C.GLfloat(units)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawElements.xml +func (gl *GL) DrawElements(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl1_2_glDrawElements(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawArrays.xml +func (gl *GL) DrawArrays(mode glbase.Enum, first, count int) { + C.gl1_2_glDrawArrays(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexSubImage3D.xml +func (gl *GL) CopyTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, x, y, width, height int) { + C.gl1_2_glCopyTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexSubImage3D.xml +func (gl *GL) TexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_2_glTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexImage3D.xml +func (gl *GL) TexImage3D(target glbase.Enum, level int, internalFormat int32, width, height int, depth int32, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_2_glTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawRangeElements.xml +func (gl *GL) DrawRangeElements(mode glbase.Enum, start, end uint32, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl1_2_glDrawRangeElements(gl.funcs, C.GLenum(mode), C.GLuint(start), C.GLuint(end), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBlendEquation.xml +func (gl *GL) BlendEquation(mode glbase.Enum) { + C.gl1_2_glBlendEquation(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBlendColor.xml +func (gl *GL) BlendColor(red, green, blue, alpha float32) { + C.gl1_2_glBlendColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTranslatef.xml +func (gl *GL) Translatef(x, y, z float32) { + C.gl1_2_glTranslatef(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTranslated.xml +func (gl *GL) Translated(x, y, z float64) { + C.gl1_2_glTranslated(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glScalef.xml +func (gl *GL) Scalef(x, y, z float32) { + C.gl1_2_glScalef(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glScaled.xml +func (gl *GL) Scaled(x, y, z float64) { + C.gl1_2_glScaled(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRotatef.xml +func (gl *GL) Rotatef(angle, x, y, z float32) { + C.gl1_2_glRotatef(gl.funcs, C.GLfloat(angle), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRotated.xml +func (gl *GL) Rotated(angle, x, y, z float64) { + C.gl1_2_glRotated(gl.funcs, C.GLdouble(angle), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPushMatrix.xml +func (gl *GL) PushMatrix() { + C.gl1_2_glPushMatrix(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPopMatrix.xml +func (gl *GL) PopMatrix() { + C.gl1_2_glPopMatrix(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glOrtho.xml +func (gl *GL) Ortho(left, right, bottom, top, zNear, zFar float64) { + C.gl1_2_glOrtho(gl.funcs, C.GLdouble(left), C.GLdouble(right), C.GLdouble(bottom), C.GLdouble(top), C.GLdouble(zNear), C.GLdouble(zFar)) +} + +// MultMatrixd multiplies the current matrix with the provided matrix. +// +// The m parameter must hold 16 consecutive elements of a 4x4 column-major matrix. +// +// The current matrix is determined by the current matrix mode (see +// MatrixMode). It is either the projection matrix, modelview matrix, or the +// texture matrix. +// +// For example, if the current matrix is C and the coordinates to be transformed +// are v = (v[0], v[1], v[2], v[3]), then the current transformation is C × v, or +// +// c[0] c[4] c[8] c[12] v[0] +// c[1] c[5] c[9] c[13] v[1] +// c[2] c[6] c[10] c[14] X v[2] +// c[3] c[7] c[11] c[15] v[3] +// +// Calling MultMatrix with an argument of m = m[0], m[1], ..., m[15] +// replaces the current transformation with (C X M) x v, or +// +// c[0] c[4] c[8] c[12] m[0] m[4] m[8] m[12] v[0] +// c[1] c[5] c[9] c[13] m[1] m[5] m[9] m[13] v[1] +// c[2] c[6] c[10] c[14] X m[2] m[6] m[10] m[14] X v[2] +// c[3] c[7] c[11] c[15] m[3] m[7] m[11] m[15] v[3] +// +// Where 'X' denotes matrix multiplication, and v is represented as a 4x1 matrix. +// +// While the elements of the matrix may be specified with single or double +// precision, the GL may store or operate on these values in less-than-single +// precision. +// +// In many computer languages, 4×4 arrays are represented in row-major +// order. The transformations just described represent these matrices in +// column-major order. The order of the multiplication is important. For +// example, if the current transformation is a rotation, and MultMatrix is +// called with a translation matrix, the translation is done directly on the +// coordinates to be transformed, while the rotation is done on the results +// of that translation. +// +// GL.INVALID_OPERATION is generated if MultMatrix is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) MultMatrixd(m []float64) { + if len(m) != 16 { + panic("parameter m must have length 16 for the 4x4 matrix") + } + C.gl1_2_glMultMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// MultMatrixf multiplies the current matrix with the provided matrix. +// +// The m parameter must hold 16 consecutive elements of a 4x4 column-major matrix. +// +// The current matrix is determined by the current matrix mode (see +// MatrixMode). It is either the projection matrix, modelview matrix, or the +// texture matrix. +// +// For example, if the current matrix is C and the coordinates to be transformed +// are v = (v[0], v[1], v[2], v[3]), then the current transformation is C × v, or +// +// c[0] c[4] c[8] c[12] v[0] +// c[1] c[5] c[9] c[13] v[1] +// c[2] c[6] c[10] c[14] X v[2] +// c[3] c[7] c[11] c[15] v[3] +// +// Calling MultMatrix with an argument of m = m[0], m[1], ..., m[15] +// replaces the current transformation with (C X M) x v, or +// +// c[0] c[4] c[8] c[12] m[0] m[4] m[8] m[12] v[0] +// c[1] c[5] c[9] c[13] m[1] m[5] m[9] m[13] v[1] +// c[2] c[6] c[10] c[14] X m[2] m[6] m[10] m[14] X v[2] +// c[3] c[7] c[11] c[15] m[3] m[7] m[11] m[15] v[3] +// +// Where 'X' denotes matrix multiplication, and v is represented as a 4x1 matrix. +// +// While the elements of the matrix may be specified with single or double +// precision, the GL may store or operate on these values in less-than-single +// precision. +// +// In many computer languages, 4×4 arrays are represented in row-major +// order. The transformations just described represent these matrices in +// column-major order. The order of the multiplication is important. For +// example, if the current transformation is a rotation, and MultMatrix is +// called with a translation matrix, the translation is done directly on the +// coordinates to be transformed, while the rotation is done on the results +// of that translation. +// +// GL.INVALID_OPERATION is generated if MultMatrix is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) MultMatrixf(m []float32) { + if len(m) != 16 { + panic("parameter m must have length 16 for the 4x4 matrix") + } + C.gl1_2_glMultMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMatrixMode.xml +func (gl *GL) MatrixMode(mode glbase.Enum) { + C.gl1_2_glMatrixMode(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadMatrixd.xml +func (gl *GL) LoadMatrixd(m []float64) { + C.gl1_2_glLoadMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadMatrixf.xml +func (gl *GL) LoadMatrixf(m []float32) { + C.gl1_2_glLoadMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadIdentity.xml +func (gl *GL) LoadIdentity() { + C.gl1_2_glLoadIdentity(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFrustum.xml +func (gl *GL) Frustum(left, right, bottom, top, zNear, zFar float64) { + C.gl1_2_glFrustum(gl.funcs, C.GLdouble(left), C.GLdouble(right), C.GLdouble(bottom), C.GLdouble(top), C.GLdouble(zNear), C.GLdouble(zFar)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsList.xml +func (gl *GL) IsList(list uint32) bool { + glresult := C.gl1_2_glIsList(gl.funcs, C.GLuint(list)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexGeniv.xml +func (gl *GL) GetTexGeniv(coord, pname glbase.Enum, params []int32) { + C.gl1_2_glGetTexGeniv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexGenfv.xml +func (gl *GL) GetTexGenfv(coord, pname glbase.Enum, params []float32) { + C.gl1_2_glGetTexGenfv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexGendv.xml +func (gl *GL) GetTexGendv(coord, pname glbase.Enum, params []float64) { + C.gl1_2_glGetTexGendv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexEnviv.xml +func (gl *GL) GetTexEnviv(target, pname glbase.Enum, params []int32) { + C.gl1_2_glGetTexEnviv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexEnvfv.xml +func (gl *GL) GetTexEnvfv(target, pname glbase.Enum, params []float32) { + C.gl1_2_glGetTexEnvfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetPolygonStipple.xml +func (gl *GL) GetPolygonStipple(mask []uint8) { + C.gl1_2_glGetPolygonStipple(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&mask[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetPixelMapusv.xml +func (gl *GL) GetPixelMapusv(glmap glbase.Enum, values []uint16) { + C.gl1_2_glGetPixelMapusv(gl.funcs, C.GLenum(glmap), (*C.GLushort)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetPixelMapuiv.xml +func (gl *GL) GetPixelMapuiv(glmap glbase.Enum, values []uint32) { + C.gl1_2_glGetPixelMapuiv(gl.funcs, C.GLenum(glmap), (*C.GLuint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetPixelMapfv.xml +func (gl *GL) GetPixelMapfv(glmap glbase.Enum, values []float32) { + C.gl1_2_glGetPixelMapfv(gl.funcs, C.GLenum(glmap), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMaterialiv.xml +func (gl *GL) GetMaterialiv(face, pname glbase.Enum, params []int32) { + C.gl1_2_glGetMaterialiv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMaterialfv.xml +func (gl *GL) GetMaterialfv(face, pname glbase.Enum, params []float32) { + C.gl1_2_glGetMaterialfv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMapiv.xml +func (gl *GL) GetMapiv(target, query glbase.Enum, v []int32) { + C.gl1_2_glGetMapiv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMapfv.xml +func (gl *GL) GetMapfv(target, query glbase.Enum, v []float32) { + C.gl1_2_glGetMapfv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMapdv.xml +func (gl *GL) GetMapdv(target, query glbase.Enum, v []float64) { + C.gl1_2_glGetMapdv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetLightiv.xml +func (gl *GL) GetLightiv(light, pname glbase.Enum, params []int32) { + C.gl1_2_glGetLightiv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetLightfv.xml +func (gl *GL) GetLightfv(light, pname glbase.Enum, params []float32) { + C.gl1_2_glGetLightfv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetClipPlane.xml +func (gl *GL) GetClipPlane(plane glbase.Enum, equation []float64) { + C.gl1_2_glGetClipPlane(gl.funcs, C.GLenum(plane), (*C.GLdouble)(unsafe.Pointer(&equation[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawPixels.xml +func (gl *GL) DrawPixels(width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_2_glDrawPixels(gl.funcs, C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyPixels.xml +func (gl *GL) CopyPixels(x, y, width, height int, gltype glbase.Enum) { + C.gl1_2_glCopyPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(gltype)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelMapusv.xml +func (gl *GL) PixelMapusv(glmap glbase.Enum, mapsize int32, values []uint16) { + C.gl1_2_glPixelMapusv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLushort)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelMapuiv.xml +func (gl *GL) PixelMapuiv(glmap glbase.Enum, mapsize int32, values []uint32) { + C.gl1_2_glPixelMapuiv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLuint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelMapfv.xml +func (gl *GL) PixelMapfv(glmap glbase.Enum, mapsize int32, values []float32) { + C.gl1_2_glPixelMapfv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelTransferi.xml +func (gl *GL) PixelTransferi(pname glbase.Enum, param int32) { + C.gl1_2_glPixelTransferi(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelTransferf.xml +func (gl *GL) PixelTransferf(pname glbase.Enum, param float32) { + C.gl1_2_glPixelTransferf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelZoom.xml +func (gl *GL) PixelZoom(xfactor, yfactor float32) { + C.gl1_2_glPixelZoom(gl.funcs, C.GLfloat(xfactor), C.GLfloat(yfactor)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glAlphaFunc.xml +func (gl *GL) AlphaFunc(glfunc glbase.Enum, ref float32) { + C.gl1_2_glAlphaFunc(gl.funcs, C.GLenum(glfunc), C.GLfloat(ref)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalPoint2.xml +func (gl *GL) EvalPoint2(i, j int32) { + C.gl1_2_glEvalPoint2(gl.funcs, C.GLint(i), C.GLint(j)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalMesh2.xml +func (gl *GL) EvalMesh2(mode glbase.Enum, i1, i2, j1, j2 int32) { + C.gl1_2_glEvalMesh2(gl.funcs, C.GLenum(mode), C.GLint(i1), C.GLint(i2), C.GLint(j1), C.GLint(j2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalPoint1.xml +func (gl *GL) EvalPoint1(i int32) { + C.gl1_2_glEvalPoint1(gl.funcs, C.GLint(i)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalMesh1.xml +func (gl *GL) EvalMesh1(mode glbase.Enum, i1, i2 int32) { + C.gl1_2_glEvalMesh1(gl.funcs, C.GLenum(mode), C.GLint(i1), C.GLint(i2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord2fv.xml +func (gl *GL) EvalCoord2fv(u []float32) { + if len(u) != 2 { + panic("parameter u has incorrect length") + } + C.gl1_2_glEvalCoord2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord2f.xml +func (gl *GL) EvalCoord2f(u, v float32) { + C.gl1_2_glEvalCoord2f(gl.funcs, C.GLfloat(u), C.GLfloat(v)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord2dv.xml +func (gl *GL) EvalCoord2dv(u []float64) { + if len(u) != 2 { + panic("parameter u has incorrect length") + } + C.gl1_2_glEvalCoord2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord2d.xml +func (gl *GL) EvalCoord2d(u, v float64) { + C.gl1_2_glEvalCoord2d(gl.funcs, C.GLdouble(u), C.GLdouble(v)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord1fv.xml +func (gl *GL) EvalCoord1fv(u []float32) { + C.gl1_2_glEvalCoord1fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord1f.xml +func (gl *GL) EvalCoord1f(u float32) { + C.gl1_2_glEvalCoord1f(gl.funcs, C.GLfloat(u)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord1dv.xml +func (gl *GL) EvalCoord1dv(u []float64) { + C.gl1_2_glEvalCoord1dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord1d.xml +func (gl *GL) EvalCoord1d(u float64) { + C.gl1_2_glEvalCoord1d(gl.funcs, C.GLdouble(u)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMapGrid2f.xml +func (gl *GL) MapGrid2f(un int32, u1, u2 float32, vn int32, v1, v2 float32) { + C.gl1_2_glMapGrid2f(gl.funcs, C.GLint(un), C.GLfloat(u1), C.GLfloat(u2), C.GLint(vn), C.GLfloat(v1), C.GLfloat(v2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMapGrid2d.xml +func (gl *GL) MapGrid2d(un int32, u1, u2 float64, vn int32, v1, v2 float64) { + C.gl1_2_glMapGrid2d(gl.funcs, C.GLint(un), C.GLdouble(u1), C.GLdouble(u2), C.GLint(vn), C.GLdouble(v1), C.GLdouble(v2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMapGrid1f.xml +func (gl *GL) MapGrid1f(un int32, u1, u2 float32) { + C.gl1_2_glMapGrid1f(gl.funcs, C.GLint(un), C.GLfloat(u1), C.GLfloat(u2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMapGrid1d.xml +func (gl *GL) MapGrid1d(un int32, u1, u2 float64) { + C.gl1_2_glMapGrid1d(gl.funcs, C.GLint(un), C.GLdouble(u1), C.GLdouble(u2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMap2f.xml +func (gl *GL) Map2f(target glbase.Enum, u1, u2 float32, ustride, uorder int32, v1, v2 float32, vstride, vorder int32, points []float32) { + C.gl1_2_glMap2f(gl.funcs, C.GLenum(target), C.GLfloat(u1), C.GLfloat(u2), C.GLint(ustride), C.GLint(uorder), C.GLfloat(v1), C.GLfloat(v2), C.GLint(vstride), C.GLint(vorder), (*C.GLfloat)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMap2d.xml +func (gl *GL) Map2d(target glbase.Enum, u1, u2 float64, ustride, uorder int32, v1, v2 float64, vstride, vorder int32, points []float64) { + C.gl1_2_glMap2d(gl.funcs, C.GLenum(target), C.GLdouble(u1), C.GLdouble(u2), C.GLint(ustride), C.GLint(uorder), C.GLdouble(v1), C.GLdouble(v2), C.GLint(vstride), C.GLint(vorder), (*C.GLdouble)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMap1f.xml +func (gl *GL) Map1f(target glbase.Enum, u1, u2 float32, stride, order int, points []float32) { + C.gl1_2_glMap1f(gl.funcs, C.GLenum(target), C.GLfloat(u1), C.GLfloat(u2), C.GLint(stride), C.GLint(order), (*C.GLfloat)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMap1d.xml +func (gl *GL) Map1d(target glbase.Enum, u1, u2 float64, stride, order int, points []float64) { + C.gl1_2_glMap1d(gl.funcs, C.GLenum(target), C.GLdouble(u1), C.GLdouble(u2), C.GLint(stride), C.GLint(order), (*C.GLdouble)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPushAttrib.xml +func (gl *GL) PushAttrib(mask glbase.Bitfield) { + C.gl1_2_glPushAttrib(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPopAttrib.xml +func (gl *GL) PopAttrib() { + C.gl1_2_glPopAttrib(gl.funcs) +} + +// Accum executes an operation on the accumulation buffer. +// +// Parameter op defines the accumulation buffer operation (GL.ACCUM, GL.LOAD, +// GL.ADD, GL.MULT, or GL.RETURN) and specifies how the value parameter is +// used. +// +// The accumulation buffer is an extended-range color buffer. Images are not +// rendered into it. Rather, images rendered into one of the color buffers +// are added to the contents of the accumulation buffer after rendering. +// Effects such as antialiasing (of points, lines, and polygons), motion +// blur, and depth of field can be created by accumulating images generated +// with different transformation matrices. +// +// Each pixel in the accumulation buffer consists of red, green, blue, and +// alpha values. The number of bits per component in the accumulation buffer +// depends on the implementation. You can examine this number by calling +// GetIntegerv four times, with arguments GL.ACCUM_RED_BITS, +// GL.ACCUM_GREEN_BITS, GL.ACCUM_BLUE_BITS, and GL.ACCUM_ALPHA_BITS. +// Regardless of the number of bits per component, the range of values stored +// by each component is (-1, 1). The accumulation buffer pixels are mapped +// one-to-one with frame buffer pixels. +// +// All accumulation buffer operations are limited to the area of the current +// scissor box and applied identically to the red, green, blue, and alpha +// components of each pixel. If a Accum operation results in a value outside +// the range (-1, 1), the contents of an accumulation buffer pixel component +// are undefined. +// +// The operations are as follows: +// +// GL.ACCUM +// Obtains R, G, B, and A values from the buffer currently selected for +// reading (see ReadBuffer). Each component value is divided by 2 n - +// 1 , where n is the number of bits allocated to each color component +// in the currently selected buffer. The result is a floating-point +// value in the range 0 1 , which is multiplied by value and added to +// the corresponding pixel component in the accumulation buffer, +// thereby updating the accumulation buffer. +// +// GL.LOAD +// Similar to GL.ACCUM, except that the current value in the +// accumulation buffer is not used in the calculation of the new value. +// That is, the R, G, B, and A values from the currently selected +// buffer are divided by 2 n - 1 , multiplied by value, and then stored +// in the corresponding accumulation buffer cell, overwriting the +// current value. +// +// GL.ADD +// Adds value to each R, G, B, and A in the accumulation buffer. +// +// GL.MULT +// Multiplies each R, G, B, and A in the accumulation buffer by value +// and returns the scaled component to its corresponding accumulation +// buffer location. +// +// GL.RETURN +// Transfers accumulation buffer values to the color buffer or buffers +// currently selected for writing. Each R, G, B, and A component is +// multiplied by value, then multiplied by 2 n - 1 , clamped to the +// range 0 2 n - 1 , and stored in the corresponding display buffer +// cell. The only fragment operations that are applied to this transfer +// are pixel ownership, scissor, dithering, and color writemasks. +// +// To clear the accumulation buffer, call ClearAccum with R, G, B, and A +// values to set it to, then call Clear with the accumulation buffer +// enabled. +// +// Error GL.INVALID_ENUM is generated if op is not an accepted value. +// GL.INVALID_OPERATION is generated if there is no accumulation buffer. +// GL.INVALID_OPERATION is generated if Accum is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) Accum(op glbase.Enum, value float32) { + C.gl1_2_glAccum(gl.funcs, C.GLenum(op), C.GLfloat(value)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexMask.xml +func (gl *GL) IndexMask(mask uint32) { + C.gl1_2_glIndexMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearIndex.xml +func (gl *GL) ClearIndex(c float32) { + C.gl1_2_glClearIndex(gl.funcs, C.GLfloat(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearAccum.xml +func (gl *GL) ClearAccum(red, green, blue, alpha float32) { + C.gl1_2_glClearAccum(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPushName.xml +func (gl *GL) PushName(name uint32) { + C.gl1_2_glPushName(gl.funcs, C.GLuint(name)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPopName.xml +func (gl *GL) PopName() { + C.gl1_2_glPopName(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPassThrough.xml +func (gl *GL) PassThrough(token float32) { + C.gl1_2_glPassThrough(gl.funcs, C.GLfloat(token)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadName.xml +func (gl *GL) LoadName(name uint32) { + C.gl1_2_glLoadName(gl.funcs, C.GLuint(name)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glInitNames.xml +func (gl *GL) InitNames() { + C.gl1_2_glInitNames(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRenderMode.xml +func (gl *GL) RenderMode(mode glbase.Enum) int32 { + glresult := C.gl1_2_glRenderMode(gl.funcs, C.GLenum(mode)) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSelectBuffer.xml +func (gl *GL) SelectBuffer(size int, buffer []glbase.Buffer) { + C.gl1_2_glSelectBuffer(gl.funcs, C.GLsizei(size), (*C.GLuint)(unsafe.Pointer(&buffer[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFeedbackBuffer.xml +func (gl *GL) FeedbackBuffer(size int, gltype glbase.Enum, buffer []float32) { + C.gl1_2_glFeedbackBuffer(gl.funcs, C.GLsizei(size), C.GLenum(gltype), (*C.GLfloat)(unsafe.Pointer(&buffer[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGeniv.xml +func (gl *GL) TexGeniv(coord, pname glbase.Enum, params []int32) { + C.gl1_2_glTexGeniv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGeni.xml +func (gl *GL) TexGeni(coord, pname glbase.Enum, param int32) { + C.gl1_2_glTexGeni(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGenfv.xml +func (gl *GL) TexGenfv(coord, pname glbase.Enum, params []float32) { + C.gl1_2_glTexGenfv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGenf.xml +func (gl *GL) TexGenf(coord, pname glbase.Enum, param float32) { + C.gl1_2_glTexGenf(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGendv.xml +func (gl *GL) TexGendv(coord, pname glbase.Enum, params []float64) { + C.gl1_2_glTexGendv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGend.xml +func (gl *GL) TexGend(coord, pname glbase.Enum, param float64) { + C.gl1_2_glTexGend(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLdouble(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnviv.xml +func (gl *GL) TexEnviv(target, pname glbase.Enum, params []int32) { + C.gl1_2_glTexEnviv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnvi.xml +func (gl *GL) TexEnvi(target, pname glbase.Enum, param int32) { + C.gl1_2_glTexEnvi(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnvfv.xml +func (gl *GL) TexEnvfv(target, pname glbase.Enum, params []float32) { + C.gl1_2_glTexEnvfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnvf.xml +func (gl *GL) TexEnvf(target, pname glbase.Enum, param float32) { + C.gl1_2_glTexEnvf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glShadeModel.xml +func (gl *GL) ShadeModel(mode glbase.Enum) { + C.gl1_2_glShadeModel(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPolygonStipple.xml +func (gl *GL) PolygonStipple(mask []uint8) { + C.gl1_2_glPolygonStipple(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&mask[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMaterialiv.xml +func (gl *GL) Materialiv(face, pname glbase.Enum, params []int32) { + C.gl1_2_glMaterialiv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMateriali.xml +func (gl *GL) Materiali(face, pname glbase.Enum, param int32) { + C.gl1_2_glMateriali(gl.funcs, C.GLenum(face), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMaterialfv.xml +func (gl *GL) Materialfv(face, pname glbase.Enum, params []float32) { + C.gl1_2_glMaterialfv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMaterialf.xml +func (gl *GL) Materialf(face, pname glbase.Enum, param float32) { + C.gl1_2_glMaterialf(gl.funcs, C.GLenum(face), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLineStipple.xml +func (gl *GL) LineStipple(factor int32, pattern uint16) { + C.gl1_2_glLineStipple(gl.funcs, C.GLint(factor), C.GLushort(pattern)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightModeliv.xml +func (gl *GL) LightModeliv(pname glbase.Enum, params []int32) { + C.gl1_2_glLightModeliv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightModeli.xml +func (gl *GL) LightModeli(pname glbase.Enum, param int32) { + C.gl1_2_glLightModeli(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightModelfv.xml +func (gl *GL) LightModelfv(pname glbase.Enum, params []float32) { + C.gl1_2_glLightModelfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightModelf.xml +func (gl *GL) LightModelf(pname glbase.Enum, param float32) { + C.gl1_2_glLightModelf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightiv.xml +func (gl *GL) Lightiv(light, pname glbase.Enum, params []int32) { + C.gl1_2_glLightiv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLighti.xml +func (gl *GL) Lighti(light, pname glbase.Enum, param int32) { + C.gl1_2_glLighti(gl.funcs, C.GLenum(light), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightfv.xml +func (gl *GL) Lightfv(light, pname glbase.Enum, params []float32) { + C.gl1_2_glLightfv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightf.xml +func (gl *GL) Lightf(light, pname glbase.Enum, param float32) { + C.gl1_2_glLightf(gl.funcs, C.GLenum(light), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogiv.xml +func (gl *GL) Fogiv(pname glbase.Enum, params []int32) { + C.gl1_2_glFogiv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogi.xml +func (gl *GL) Fogi(pname glbase.Enum, param int32) { + C.gl1_2_glFogi(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogfv.xml +func (gl *GL) Fogfv(pname glbase.Enum, params []float32) { + C.gl1_2_glFogfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogf.xml +func (gl *GL) Fogf(pname glbase.Enum, param float32) { + C.gl1_2_glFogf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorMaterial.xml +func (gl *GL) ColorMaterial(face, mode glbase.Enum) { + C.gl1_2_glColorMaterial(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClipPlane.xml +func (gl *GL) ClipPlane(plane glbase.Enum, equation []float64) { + C.gl1_2_glClipPlane(gl.funcs, C.GLenum(plane), (*C.GLdouble)(unsafe.Pointer(&equation[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4sv.xml +func (gl *GL) Vertex4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_2_glVertex4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4s.xml +func (gl *GL) Vertex4s(x, y, z, w int16) { + C.gl1_2_glVertex4s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4iv.xml +func (gl *GL) Vertex4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_2_glVertex4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4i.xml +func (gl *GL) Vertex4i(x, y, z, w int) { + C.gl1_2_glVertex4i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4fv.xml +func (gl *GL) Vertex4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_2_glVertex4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4f.xml +func (gl *GL) Vertex4f(x, y, z, w float32) { + C.gl1_2_glVertex4f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4dv.xml +func (gl *GL) Vertex4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_2_glVertex4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4d.xml +func (gl *GL) Vertex4d(x, y, z, w float64) { + C.gl1_2_glVertex4d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3sv.xml +func (gl *GL) Vertex3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_2_glVertex3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3s.xml +func (gl *GL) Vertex3s(x, y, z int16) { + C.gl1_2_glVertex3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3iv.xml +func (gl *GL) Vertex3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_2_glVertex3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3i.xml +func (gl *GL) Vertex3i(x, y, z int) { + C.gl1_2_glVertex3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3fv.xml +func (gl *GL) Vertex3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_2_glVertex3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3f.xml +func (gl *GL) Vertex3f(x, y, z float32) { + C.gl1_2_glVertex3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3dv.xml +func (gl *GL) Vertex3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_2_glVertex3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3d.xml +func (gl *GL) Vertex3d(x, y, z float64) { + C.gl1_2_glVertex3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2sv.xml +func (gl *GL) Vertex2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_2_glVertex2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2s.xml +func (gl *GL) Vertex2s(x, y int16) { + C.gl1_2_glVertex2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2iv.xml +func (gl *GL) Vertex2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_2_glVertex2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2i.xml +func (gl *GL) Vertex2i(x, y int) { + C.gl1_2_glVertex2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2fv.xml +func (gl *GL) Vertex2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_2_glVertex2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2f.xml +func (gl *GL) Vertex2f(x, y float32) { + C.gl1_2_glVertex2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2dv.xml +func (gl *GL) Vertex2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_2_glVertex2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2d.xml +func (gl *GL) Vertex2d(x, y float64) { + C.gl1_2_glVertex2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4sv.xml +func (gl *GL) TexCoord4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_2_glTexCoord4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4s.xml +func (gl *GL) TexCoord4s(s, t, r, q int16) { + C.gl1_2_glTexCoord4s(gl.funcs, C.GLshort(s), C.GLshort(t), C.GLshort(r), C.GLshort(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4iv.xml +func (gl *GL) TexCoord4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_2_glTexCoord4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4i.xml +func (gl *GL) TexCoord4i(s, t, r, q int32) { + C.gl1_2_glTexCoord4i(gl.funcs, C.GLint(s), C.GLint(t), C.GLint(r), C.GLint(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4fv.xml +func (gl *GL) TexCoord4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_2_glTexCoord4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4f.xml +func (gl *GL) TexCoord4f(s, t, r, q float32) { + C.gl1_2_glTexCoord4f(gl.funcs, C.GLfloat(s), C.GLfloat(t), C.GLfloat(r), C.GLfloat(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4dv.xml +func (gl *GL) TexCoord4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_2_glTexCoord4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4d.xml +func (gl *GL) TexCoord4d(s, t, r, q float64) { + C.gl1_2_glTexCoord4d(gl.funcs, C.GLdouble(s), C.GLdouble(t), C.GLdouble(r), C.GLdouble(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3sv.xml +func (gl *GL) TexCoord3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_2_glTexCoord3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3s.xml +func (gl *GL) TexCoord3s(s, t, r int16) { + C.gl1_2_glTexCoord3s(gl.funcs, C.GLshort(s), C.GLshort(t), C.GLshort(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3iv.xml +func (gl *GL) TexCoord3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_2_glTexCoord3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3i.xml +func (gl *GL) TexCoord3i(s, t, r int32) { + C.gl1_2_glTexCoord3i(gl.funcs, C.GLint(s), C.GLint(t), C.GLint(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3fv.xml +func (gl *GL) TexCoord3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_2_glTexCoord3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3f.xml +func (gl *GL) TexCoord3f(s, t, r float32) { + C.gl1_2_glTexCoord3f(gl.funcs, C.GLfloat(s), C.GLfloat(t), C.GLfloat(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3dv.xml +func (gl *GL) TexCoord3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_2_glTexCoord3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3d.xml +func (gl *GL) TexCoord3d(s, t, r float64) { + C.gl1_2_glTexCoord3d(gl.funcs, C.GLdouble(s), C.GLdouble(t), C.GLdouble(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2sv.xml +func (gl *GL) TexCoord2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_2_glTexCoord2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2s.xml +func (gl *GL) TexCoord2s(s, t int16) { + C.gl1_2_glTexCoord2s(gl.funcs, C.GLshort(s), C.GLshort(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2iv.xml +func (gl *GL) TexCoord2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_2_glTexCoord2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2i.xml +func (gl *GL) TexCoord2i(s, t int32) { + C.gl1_2_glTexCoord2i(gl.funcs, C.GLint(s), C.GLint(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2fv.xml +func (gl *GL) TexCoord2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_2_glTexCoord2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2f.xml +func (gl *GL) TexCoord2f(s, t float32) { + C.gl1_2_glTexCoord2f(gl.funcs, C.GLfloat(s), C.GLfloat(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2dv.xml +func (gl *GL) TexCoord2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_2_glTexCoord2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2d.xml +func (gl *GL) TexCoord2d(s, t float64) { + C.gl1_2_glTexCoord2d(gl.funcs, C.GLdouble(s), C.GLdouble(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1sv.xml +func (gl *GL) TexCoord1sv(v []int16) { + C.gl1_2_glTexCoord1sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1s.xml +func (gl *GL) TexCoord1s(s int16) { + C.gl1_2_glTexCoord1s(gl.funcs, C.GLshort(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1iv.xml +func (gl *GL) TexCoord1iv(v []int32) { + C.gl1_2_glTexCoord1iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1i.xml +func (gl *GL) TexCoord1i(s int32) { + C.gl1_2_glTexCoord1i(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1fv.xml +func (gl *GL) TexCoord1fv(v []float32) { + C.gl1_2_glTexCoord1fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1f.xml +func (gl *GL) TexCoord1f(s float32) { + C.gl1_2_glTexCoord1f(gl.funcs, C.GLfloat(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1dv.xml +func (gl *GL) TexCoord1dv(v []float64) { + C.gl1_2_glTexCoord1dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1d.xml +func (gl *GL) TexCoord1d(s float64) { + C.gl1_2_glTexCoord1d(gl.funcs, C.GLdouble(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectsv.xml +func (gl *GL) Rectsv(v1, v2 []int16) { + C.gl1_2_glRectsv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v1[0])), (*C.GLshort)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRects.xml +func (gl *GL) Rects(x1, y1, x2, y2 int16) { + C.gl1_2_glRects(gl.funcs, C.GLshort(x1), C.GLshort(y1), C.GLshort(x2), C.GLshort(y2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectiv.xml +func (gl *GL) Rectiv(v1, v2 []int32) { + C.gl1_2_glRectiv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v1[0])), (*C.GLint)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRecti.xml +func (gl *GL) Recti(x1, y1, x2, y2 int32) { + C.gl1_2_glRecti(gl.funcs, C.GLint(x1), C.GLint(y1), C.GLint(x2), C.GLint(y2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectfv.xml +func (gl *GL) Rectfv(v1, v2 []float32) { + C.gl1_2_glRectfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v1[0])), (*C.GLfloat)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectf.xml +func (gl *GL) Rectf(x1, y1, x2, y2 float32) { + C.gl1_2_glRectf(gl.funcs, C.GLfloat(x1), C.GLfloat(y1), C.GLfloat(x2), C.GLfloat(y2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectdv.xml +func (gl *GL) Rectdv(v1, v2 []float64) { + C.gl1_2_glRectdv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v1[0])), (*C.GLdouble)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectd.xml +func (gl *GL) Rectd(x1, y1, x2, y2 float64) { + C.gl1_2_glRectd(gl.funcs, C.GLdouble(x1), C.GLdouble(y1), C.GLdouble(x2), C.GLdouble(y2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4sv.xml +func (gl *GL) RasterPos4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_2_glRasterPos4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4s.xml +func (gl *GL) RasterPos4s(x, y, z, w int16) { + C.gl1_2_glRasterPos4s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4iv.xml +func (gl *GL) RasterPos4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_2_glRasterPos4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4i.xml +func (gl *GL) RasterPos4i(x, y, z, w int) { + C.gl1_2_glRasterPos4i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4fv.xml +func (gl *GL) RasterPos4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_2_glRasterPos4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4f.xml +func (gl *GL) RasterPos4f(x, y, z, w float32) { + C.gl1_2_glRasterPos4f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4dv.xml +func (gl *GL) RasterPos4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_2_glRasterPos4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4d.xml +func (gl *GL) RasterPos4d(x, y, z, w float64) { + C.gl1_2_glRasterPos4d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3sv.xml +func (gl *GL) RasterPos3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_2_glRasterPos3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3s.xml +func (gl *GL) RasterPos3s(x, y, z int16) { + C.gl1_2_glRasterPos3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3iv.xml +func (gl *GL) RasterPos3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_2_glRasterPos3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3i.xml +func (gl *GL) RasterPos3i(x, y, z int) { + C.gl1_2_glRasterPos3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3fv.xml +func (gl *GL) RasterPos3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_2_glRasterPos3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3f.xml +func (gl *GL) RasterPos3f(x, y, z float32) { + C.gl1_2_glRasterPos3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3dv.xml +func (gl *GL) RasterPos3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_2_glRasterPos3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3d.xml +func (gl *GL) RasterPos3d(x, y, z float64) { + C.gl1_2_glRasterPos3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2sv.xml +func (gl *GL) RasterPos2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_2_glRasterPos2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2s.xml +func (gl *GL) RasterPos2s(x, y int16) { + C.gl1_2_glRasterPos2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2iv.xml +func (gl *GL) RasterPos2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_2_glRasterPos2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2i.xml +func (gl *GL) RasterPos2i(x, y int) { + C.gl1_2_glRasterPos2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2fv.xml +func (gl *GL) RasterPos2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_2_glRasterPos2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2f.xml +func (gl *GL) RasterPos2f(x, y float32) { + C.gl1_2_glRasterPos2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2dv.xml +func (gl *GL) RasterPos2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_2_glRasterPos2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2d.xml +func (gl *GL) RasterPos2d(x, y float64) { + C.gl1_2_glRasterPos2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3sv.xml +func (gl *GL) Normal3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_2_glNormal3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3s.xml +func (gl *GL) Normal3s(nx, ny, nz int16) { + C.gl1_2_glNormal3s(gl.funcs, C.GLshort(nx), C.GLshort(ny), C.GLshort(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3iv.xml +func (gl *GL) Normal3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_2_glNormal3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3i.xml +func (gl *GL) Normal3i(nx, ny, nz int32) { + C.gl1_2_glNormal3i(gl.funcs, C.GLint(nx), C.GLint(ny), C.GLint(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3fv.xml +func (gl *GL) Normal3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_2_glNormal3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3f.xml +func (gl *GL) Normal3f(nx, ny, nz float32) { + C.gl1_2_glNormal3f(gl.funcs, C.GLfloat(nx), C.GLfloat(ny), C.GLfloat(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3dv.xml +func (gl *GL) Normal3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_2_glNormal3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3d.xml +func (gl *GL) Normal3d(nx, ny, nz float64) { + C.gl1_2_glNormal3d(gl.funcs, C.GLdouble(nx), C.GLdouble(ny), C.GLdouble(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3bv.xml +func (gl *GL) Normal3bv(v []byte) { + C.gl1_2_glNormal3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3b.xml +func (gl *GL) Normal3b(nx, ny, nz byte) { + C.gl1_2_glNormal3b(gl.funcs, C.GLbyte(nx), C.GLbyte(ny), C.GLbyte(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexsv.xml +func (gl *GL) Indexsv(c []int16) { + C.gl1_2_glIndexsv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexs.xml +func (gl *GL) Indexs(c int16) { + C.gl1_2_glIndexs(gl.funcs, C.GLshort(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexiv.xml +func (gl *GL) Indexiv(c []int32) { + C.gl1_2_glIndexiv(gl.funcs, (*C.GLint)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexi.xml +func (gl *GL) Indexi(c int32) { + C.gl1_2_glIndexi(gl.funcs, C.GLint(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexfv.xml +func (gl *GL) Indexfv(c []float32) { + C.gl1_2_glIndexfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexf.xml +func (gl *GL) Indexf(c float32) { + C.gl1_2_glIndexf(gl.funcs, C.GLfloat(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexdv.xml +func (gl *GL) Indexdv(c []float64) { + C.gl1_2_glIndexdv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexd.xml +func (gl *GL) Indexd(c float64) { + C.gl1_2_glIndexd(gl.funcs, C.GLdouble(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEnd.xml +func (gl *GL) End() { + C.gl1_2_glEnd(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEdgeFlagv.xml +func (gl *GL) EdgeFlagv(flag []bool) { + C.gl1_2_glEdgeFlagv(gl.funcs, (*C.GLboolean)(unsafe.Pointer(&flag[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEdgeFlag.xml +func (gl *GL) EdgeFlag(flag bool) { + C.gl1_2_glEdgeFlag(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4usv.xml +func (gl *GL) Color4usv(v []uint16) { + C.gl1_2_glColor4usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4us.xml +func (gl *GL) Color4us(red, green, blue, alpha uint16) { + C.gl1_2_glColor4us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue), C.GLushort(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4uiv.xml +func (gl *GL) Color4uiv(v []uint32) { + C.gl1_2_glColor4uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4ui.xml +func (gl *GL) Color4ui(red, green, blue, alpha uint32) { + C.gl1_2_glColor4ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue), C.GLuint(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4ubv.xml +func (gl *GL) Color4ubv(v []uint8) { + C.gl1_2_glColor4ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4ub.xml +func (gl *GL) Color4ub(red, green, blue, alpha uint8) { + C.gl1_2_glColor4ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue), C.GLubyte(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4sv.xml +func (gl *GL) Color4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_2_glColor4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4s.xml +func (gl *GL) Color4s(red, green, blue, alpha int16) { + C.gl1_2_glColor4s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue), C.GLshort(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4iv.xml +func (gl *GL) Color4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_2_glColor4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4i.xml +func (gl *GL) Color4i(red, green, blue, alpha int32) { + C.gl1_2_glColor4i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue), C.GLint(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4fv.xml +func (gl *GL) Color4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_2_glColor4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4f.xml +func (gl *GL) Color4f(red, green, blue, alpha float32) { + C.gl1_2_glColor4f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4dv.xml +func (gl *GL) Color4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_2_glColor4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4d.xml +func (gl *GL) Color4d(red, green, blue, alpha float64) { + C.gl1_2_glColor4d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue), C.GLdouble(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4bv.xml +func (gl *GL) Color4bv(v []byte) { + C.gl1_2_glColor4bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4b.xml +func (gl *GL) Color4b(red, green, blue, alpha byte) { + C.gl1_2_glColor4b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue), C.GLbyte(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3usv.xml +func (gl *GL) Color3usv(v []uint16) { + C.gl1_2_glColor3usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3us.xml +func (gl *GL) Color3us(red, green, blue uint16) { + C.gl1_2_glColor3us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3uiv.xml +func (gl *GL) Color3uiv(v []uint32) { + C.gl1_2_glColor3uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3ui.xml +func (gl *GL) Color3ui(red, green, blue uint32) { + C.gl1_2_glColor3ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3ubv.xml +func (gl *GL) Color3ubv(v []uint8) { + C.gl1_2_glColor3ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3ub.xml +func (gl *GL) Color3ub(red, green, blue uint8) { + C.gl1_2_glColor3ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3sv.xml +func (gl *GL) Color3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_2_glColor3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3s.xml +func (gl *GL) Color3s(red, green, blue int16) { + C.gl1_2_glColor3s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3iv.xml +func (gl *GL) Color3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_2_glColor3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3i.xml +func (gl *GL) Color3i(red, green, blue int32) { + C.gl1_2_glColor3i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3fv.xml +func (gl *GL) Color3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_2_glColor3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3f.xml +func (gl *GL) Color3f(red, green, blue float32) { + C.gl1_2_glColor3f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3dv.xml +func (gl *GL) Color3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_2_glColor3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3d.xml +func (gl *GL) Color3d(red, green, blue float64) { + C.gl1_2_glColor3d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3bv.xml +func (gl *GL) Color3bv(v []byte) { + C.gl1_2_glColor3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3b.xml +func (gl *GL) Color3b(red, green, blue byte) { + C.gl1_2_glColor3b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBitmap.xml +func (gl *GL) Bitmap(width, height int, xorig, yorig, xmove, ymove float32, bitmap []uint8) { + C.gl1_2_glBitmap(gl.funcs, C.GLsizei(width), C.GLsizei(height), C.GLfloat(xorig), C.GLfloat(yorig), C.GLfloat(xmove), C.GLfloat(ymove), (*C.GLubyte)(unsafe.Pointer(&bitmap[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBegin.xml +func (gl *GL) Begin(mode glbase.Enum) { + C.gl1_2_glBegin(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glListBase.xml +func (gl *GL) ListBase(base uint32) { + C.gl1_2_glListBase(gl.funcs, C.GLuint(base)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGenLists.xml +func (gl *GL) GenLists(range_ int32) uint32 { + glresult := C.gl1_2_glGenLists(gl.funcs, C.GLsizei(range_)) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDeleteLists.xml +func (gl *GL) DeleteLists(list uint32, range_ int32) { + C.gl1_2_glDeleteLists(gl.funcs, C.GLuint(list), C.GLsizei(range_)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCallLists.xml +func (gl *GL) CallLists(n int, gltype glbase.Enum, lists interface{}) { + var lists_ptr unsafe.Pointer + var lists_v = reflect.ValueOf(lists) + if lists != nil && lists_v.Kind() != reflect.Slice { + panic("parameter lists must be a slice") + } + if lists != nil { + lists_ptr = unsafe.Pointer(lists_v.Index(0).Addr().Pointer()) + } + C.gl1_2_glCallLists(gl.funcs, C.GLsizei(n), C.GLenum(gltype), lists_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCallList.xml +func (gl *GL) CallList(list uint32) { + C.gl1_2_glCallList(gl.funcs, C.GLuint(list)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEndList.xml +func (gl *GL) EndList() { + C.gl1_2_glEndList(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNewList.xml +func (gl *GL) NewList(list uint32, mode glbase.Enum) { + C.gl1_2_glNewList(gl.funcs, C.GLuint(list), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPushClientAttrib.xml +func (gl *GL) PushClientAttrib(mask glbase.Bitfield) { + C.gl1_2_glPushClientAttrib(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPopClientAttrib.xml +func (gl *GL) PopClientAttrib() { + C.gl1_2_glPopClientAttrib(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPrioritizeTextures.xml +func (gl *GL) PrioritizeTextures(n int, textures []glbase.Texture, priorities []float32) { + C.gl1_2_glPrioritizeTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0])), (*C.GLfloat)(unsafe.Pointer(&priorities[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glAreTexturesResident.xml +func (gl *GL) AreTexturesResident(n int, textures []glbase.Texture, residences []bool) bool { + glresult := C.gl1_2_glAreTexturesResident(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0])), (*C.GLboolean)(unsafe.Pointer(&residences[0]))) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexPointer.xml +func (gl *GL) VertexPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_2_glVertexPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoordPointer.xml +func (gl *GL) TexCoordPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_2_glTexCoordPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormalPointer.xml +func (gl *GL) NormalPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_2_glNormalPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glInterleavedArrays.xml +func (gl *GL) InterleavedArrays(format glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_2_glInterleavedArrays(gl.funcs, C.GLenum(format), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexPointer.xml +func (gl *GL) IndexPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_2_glIndexPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEnableClientState.xml +func (gl *GL) EnableClientState(array glbase.Enum) { + C.gl1_2_glEnableClientState(gl.funcs, C.GLenum(array)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEdgeFlagPointer.xml +func (gl *GL) EdgeFlagPointer(stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_2_glEdgeFlagPointer(gl.funcs, C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDisableClientState.xml +func (gl *GL) DisableClientState(array glbase.Enum) { + C.gl1_2_glDisableClientState(gl.funcs, C.GLenum(array)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorPointer.xml +func (gl *GL) ColorPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_2_glColorPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glArrayElement.xml +func (gl *GL) ArrayElement(i int32) { + C.gl1_2_glArrayElement(gl.funcs, C.GLint(i)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glResetMinmax.xml +func (gl *GL) ResetMinmax(target glbase.Enum) { + C.gl1_2_glResetMinmax(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glResetHistogram.xml +func (gl *GL) ResetHistogram(target glbase.Enum) { + C.gl1_2_glResetHistogram(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMinmax.xml +func (gl *GL) Minmax(target, internalFormat glbase.Enum, sink bool) { + C.gl1_2_glMinmax(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), *(*C.GLboolean)(unsafe.Pointer(&sink))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glHistogram.xml +func (gl *GL) Histogram(target glbase.Enum, width int, internalFormat glbase.Enum, sink bool) { + C.gl1_2_glHistogram(gl.funcs, C.GLenum(target), C.GLsizei(width), C.GLenum(internalFormat), *(*C.GLboolean)(unsafe.Pointer(&sink))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMinmaxParameteriv.xml +func (gl *GL) GetMinmaxParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_2_glGetMinmaxParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMinmaxParameterfv.xml +func (gl *GL) GetMinmaxParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_2_glGetMinmaxParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMinmax.xml +func (gl *GL) GetMinmax(target glbase.Enum, reset bool, format, gltype glbase.Enum, values interface{}) { + var values_ptr unsafe.Pointer + var values_v = reflect.ValueOf(values) + if values != nil && values_v.Kind() != reflect.Slice { + panic("parameter values must be a slice") + } + if values != nil { + values_ptr = unsafe.Pointer(values_v.Index(0).Addr().Pointer()) + } + C.gl1_2_glGetMinmax(gl.funcs, C.GLenum(target), *(*C.GLboolean)(unsafe.Pointer(&reset)), C.GLenum(format), C.GLenum(gltype), values_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetHistogramParameteriv.xml +func (gl *GL) GetHistogramParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_2_glGetHistogramParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetHistogramParameterfv.xml +func (gl *GL) GetHistogramParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_2_glGetHistogramParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetHistogram.xml +func (gl *GL) GetHistogram(target glbase.Enum, reset bool, format, gltype glbase.Enum, values interface{}) { + var values_ptr unsafe.Pointer + var values_v = reflect.ValueOf(values) + if values != nil && values_v.Kind() != reflect.Slice { + panic("parameter values must be a slice") + } + if values != nil { + values_ptr = unsafe.Pointer(values_v.Index(0).Addr().Pointer()) + } + C.gl1_2_glGetHistogram(gl.funcs, C.GLenum(target), *(*C.GLboolean)(unsafe.Pointer(&reset)), C.GLenum(format), C.GLenum(gltype), values_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSeparableFilter2D.xml +func (gl *GL) SeparableFilter2D(target, internalFormat glbase.Enum, width, height int, format, gltype glbase.Enum, row, column interface{}) { + var row_ptr unsafe.Pointer + var row_v = reflect.ValueOf(row) + if row != nil && row_v.Kind() != reflect.Slice { + panic("parameter row must be a slice") + } + if row != nil { + row_ptr = unsafe.Pointer(row_v.Index(0).Addr().Pointer()) + } + var column_ptr unsafe.Pointer + var column_v = reflect.ValueOf(column) + if column != nil && column_v.Kind() != reflect.Slice { + panic("parameter column must be a slice") + } + if column != nil { + column_ptr = unsafe.Pointer(column_v.Index(0).Addr().Pointer()) + } + C.gl1_2_glSeparableFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), row_ptr, column_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetSeparableFilter.xml +func (gl *GL) GetSeparableFilter(target, format, gltype glbase.Enum, row, column, span interface{}) { + var row_ptr unsafe.Pointer + var row_v = reflect.ValueOf(row) + if row != nil && row_v.Kind() != reflect.Slice { + panic("parameter row must be a slice") + } + if row != nil { + row_ptr = unsafe.Pointer(row_v.Index(0).Addr().Pointer()) + } + var column_ptr unsafe.Pointer + var column_v = reflect.ValueOf(column) + if column != nil && column_v.Kind() != reflect.Slice { + panic("parameter column must be a slice") + } + if column != nil { + column_ptr = unsafe.Pointer(column_v.Index(0).Addr().Pointer()) + } + var span_ptr unsafe.Pointer + var span_v = reflect.ValueOf(span) + if span != nil && span_v.Kind() != reflect.Slice { + panic("parameter span must be a slice") + } + if span != nil { + span_ptr = unsafe.Pointer(span_v.Index(0).Addr().Pointer()) + } + C.gl1_2_glGetSeparableFilter(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), row_ptr, column_ptr, span_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetConvolutionParameteriv.xml +func (gl *GL) GetConvolutionParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_2_glGetConvolutionParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetConvolutionParameterfv.xml +func (gl *GL) GetConvolutionParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_2_glGetConvolutionParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetConvolutionFilter.xml +func (gl *GL) GetConvolutionFilter(target, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl1_2_glGetConvolutionFilter(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyConvolutionFilter2D.xml +func (gl *GL) CopyConvolutionFilter2D(target, internalFormat glbase.Enum, x, y, width, height int) { + C.gl1_2_glCopyConvolutionFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyConvolutionFilter1D.xml +func (gl *GL) CopyConvolutionFilter1D(target, internalFormat glbase.Enum, x, y, width int) { + C.gl1_2_glCopyConvolutionFilter1D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionParameteriv.xml +func (gl *GL) ConvolutionParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_2_glConvolutionParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionParameteri.xml +func (gl *GL) ConvolutionParameteri(target, pname glbase.Enum, params int32) { + C.gl1_2_glConvolutionParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(params)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionParameterfv.xml +func (gl *GL) ConvolutionParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_2_glConvolutionParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionParameterf.xml +func (gl *GL) ConvolutionParameterf(target, pname glbase.Enum, params float32) { + C.gl1_2_glConvolutionParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(params)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionFilter2D.xml +func (gl *GL) ConvolutionFilter2D(target, internalFormat glbase.Enum, width, height int, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl1_2_glConvolutionFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionFilter1D.xml +func (gl *GL) ConvolutionFilter1D(target, internalFormat glbase.Enum, width int, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl1_2_glConvolutionFilter1D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyColorSubTable.xml +func (gl *GL) CopyColorSubTable(target glbase.Enum, start int32, x, y, width int) { + C.gl1_2_glCopyColorSubTable(gl.funcs, C.GLenum(target), C.GLsizei(start), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorSubTable.xml +func (gl *GL) ColorSubTable(target glbase.Enum, start int32, count int, format, gltype glbase.Enum, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl1_2_glColorSubTable(gl.funcs, C.GLenum(target), C.GLsizei(start), C.GLsizei(count), C.GLenum(format), C.GLenum(gltype), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetColorTableParameteriv.xml +func (gl *GL) GetColorTableParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_2_glGetColorTableParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetColorTableParameterfv.xml +func (gl *GL) GetColorTableParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_2_glGetColorTableParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetColorTable.xml +func (gl *GL) GetColorTable(target, format, gltype glbase.Enum, table interface{}) { + var table_ptr unsafe.Pointer + var table_v = reflect.ValueOf(table) + if table != nil && table_v.Kind() != reflect.Slice { + panic("parameter table must be a slice") + } + if table != nil { + table_ptr = unsafe.Pointer(table_v.Index(0).Addr().Pointer()) + } + C.gl1_2_glGetColorTable(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), table_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyColorTable.xml +func (gl *GL) CopyColorTable(target, internalFormat glbase.Enum, x, y, width int) { + C.gl1_2_glCopyColorTable(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorTableParameteriv.xml +func (gl *GL) ColorTableParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_2_glColorTableParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorTableParameterfv.xml +func (gl *GL) ColorTableParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_2_glColorTableParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorTable.xml +func (gl *GL) ColorTable(target, internalFormat glbase.Enum, width int, format, gltype glbase.Enum, table interface{}) { + var table_ptr unsafe.Pointer + var table_v = reflect.ValueOf(table) + if table != nil && table_v.Kind() != reflect.Slice { + panic("parameter table must be a slice") + } + if table != nil { + table_ptr = unsafe.Pointer(table_v.Index(0).Addr().Pointer()) + } + C.gl1_2_glColorTable(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), table_ptr) +} diff --git a/gl/1.3/funcs.cpp b/gl/1.3/funcs.cpp new file mode 100644 index 00000000..582d2090 --- /dev/null +++ b/gl/1.3/funcs.cpp @@ -0,0 +1,2526 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#include +#include + +#include "funcs.h" + +void *gl1_3_funcs() { + QOpenGLFunctions_1_3* funcs = QOpenGLContext::currentContext()->versionFunctions(); + if (!funcs) { + return 0; + } + funcs->initializeOpenGLFunctions(); + return funcs; +} + + +void gl1_3_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewport(x, y, width, height); +} + +void gl1_3_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRange(nearVal, farVal); +} + +GLboolean gl1_3_glIsEnabled(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabled(cap); +} + +void gl1_3_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameteriv(target, level, pname, params); +} + +void gl1_3_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameterfv(target, level, pname, params); +} + +void gl1_3_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameteriv(target, pname, params); +} + +void gl1_3_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterfv(target, pname, params); +} + +void gl1_3_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexImage(target, level, format, gltype, pixels); +} + +void gl1_3_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegerv(pname, params); +} + +void gl1_3_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFloatv(pname, params); +} + +GLenum gl1_3_glGetError(void *_glfuncs) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetError(); +} + +void gl1_3_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetDoublev(pname, params); +} + +void gl1_3_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleanv(pname, params); +} + +void gl1_3_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadPixels(x, y, width, height, format, gltype, pixels); +} + +void gl1_3_glReadBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadBuffer(mode); +} + +void gl1_3_glPixelStorei(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStorei(pname, param); +} + +void gl1_3_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStoref(pname, param); +} + +void gl1_3_glDepthFunc(void *_glfuncs, GLenum glfunc) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthFunc(glfunc); +} + +void gl1_3_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOp(fail, zfail, zpass); +} + +void gl1_3_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFunc(glfunc, ref, mask); +} + +void gl1_3_glLogicOp(void *_glfuncs, GLenum opcode) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLogicOp(opcode); +} + +void gl1_3_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFunc(sfactor, dfactor); +} + +void gl1_3_glFlush(void *_glfuncs) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlush(); +} + +void gl1_3_glFinish(void *_glfuncs) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFinish(); +} + +void gl1_3_glEnable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnable(cap); +} + +void gl1_3_glDisable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisable(cap); +} + +void gl1_3_glDepthMask(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthMask(flag); +} + +void gl1_3_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMask(red, green, blue, alpha); +} + +void gl1_3_glStencilMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMask(mask); +} + +void gl1_3_glClearDepth(void *_glfuncs, GLdouble depth) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearDepth(depth); +} + +void gl1_3_glClearStencil(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearStencil(s); +} + +void gl1_3_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearColor(red, green, blue, alpha); +} + +void gl1_3_glClear(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClear(mask); +} + +void gl1_3_glDrawBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffer(mode); +} + +void gl1_3_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage2D(target, level, internalFormat, width, height, border, format, gltype, pixels); +} + +void gl1_3_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage1D(target, level, internalFormat, width, border, format, gltype, pixels); +} + +void gl1_3_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteriv(target, pname, params); +} + +void gl1_3_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteri(target, pname, param); +} + +void gl1_3_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterfv(target, pname, params); +} + +void gl1_3_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterf(target, pname, param); +} + +void gl1_3_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissor(x, y, width, height); +} + +void gl1_3_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonMode(face, mode); +} + +void gl1_3_glPointSize(void *_glfuncs, GLfloat size) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointSize(size); +} + +void gl1_3_glLineWidth(void *_glfuncs, GLfloat width) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineWidth(width); +} + +void gl1_3_glHint(void *_glfuncs, GLenum target, GLenum mode) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glHint(target, mode); +} + +void gl1_3_glFrontFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrontFace(mode); +} + +void gl1_3_glCullFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCullFace(mode); +} + +void gl1_3_glIndexubv(void *_glfuncs, const GLubyte* c) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexubv(c); +} + +void gl1_3_glIndexub(void *_glfuncs, GLubyte c) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexub(c); +} + +GLboolean gl1_3_glIsTexture(void *_glfuncs, GLuint texture) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsTexture(texture); +} + +void gl1_3_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenTextures(n, textures); +} + +void gl1_3_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteTextures(n, textures); +} + +void gl1_3_glBindTexture(void *_glfuncs, GLenum target, GLuint texture) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindTexture(target, texture); +} + +void gl1_3_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, gltype, pixels); +} + +void gl1_3_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage1D(target, level, xoffset, width, format, gltype, pixels); +} + +void gl1_3_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); +} + +void gl1_3_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage1D(target, level, xoffset, x, y, width); +} + +void gl1_3_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage2D(target, level, internalFormat, x, y, width, height, border); +} + +void gl1_3_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage1D(target, level, internalFormat, x, y, width, border); +} + +void gl1_3_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonOffset(factor, units); +} + +void gl1_3_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElements(mode, count, gltype, indices); +} + +void gl1_3_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArrays(mode, first, count); +} + +void gl1_3_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); +} + +void gl1_3_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, gltype, pixels); +} + +void gl1_3_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage3D(target, level, internalFormat, width, height, depth, border, format, gltype, pixels); +} + +void gl1_3_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawRangeElements(mode, start, end, count, gltype, indices); +} + +void gl1_3_glBlendEquation(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquation(mode); +} + +void gl1_3_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendColor(red, green, blue, alpha); +} + +void gl1_3_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetCompressedTexImage(target, level, img); +} + +void gl1_3_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data); +} + +void gl1_3_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); +} + +void gl1_3_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); +} + +void gl1_3_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage1D(target, level, internalFormat, width, border, imageSize, data); +} + +void gl1_3_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data); +} + +void gl1_3_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage3D(target, level, internalFormat, width, height, depth, border, imageSize, data); +} + +void gl1_3_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSampleCoverage(value, invert); +} + +void gl1_3_glActiveTexture(void *_glfuncs, GLenum texture) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glActiveTexture(texture); +} + +void gl1_3_glTranslatef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTranslatef(x, y, z); +} + +void gl1_3_glTranslated(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTranslated(x, y, z); +} + +void gl1_3_glScalef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScalef(x, y, z); +} + +void gl1_3_glScaled(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScaled(x, y, z); +} + +void gl1_3_glRotatef(void *_glfuncs, GLfloat angle, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRotatef(angle, x, y, z); +} + +void gl1_3_glRotated(void *_glfuncs, GLdouble angle, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRotated(angle, x, y, z); +} + +void gl1_3_glPushMatrix(void *_glfuncs) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushMatrix(); +} + +void gl1_3_glPopMatrix(void *_glfuncs) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopMatrix(); +} + +void gl1_3_glOrtho(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glOrtho(left, right, bottom, top, zNear, zFar); +} + +void gl1_3_glMultMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultMatrixd(m); +} + +void gl1_3_glMultMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultMatrixf(m); +} + +void gl1_3_glMatrixMode(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMatrixMode(mode); +} + +void gl1_3_glLoadMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadMatrixd(m); +} + +void gl1_3_glLoadMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadMatrixf(m); +} + +void gl1_3_glLoadIdentity(void *_glfuncs) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadIdentity(); +} + +void gl1_3_glFrustum(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrustum(left, right, bottom, top, zNear, zFar); +} + +GLboolean gl1_3_glIsList(void *_glfuncs, GLuint list) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsList(list); +} + +void gl1_3_glGetTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGeniv(coord, pname, params); +} + +void gl1_3_glGetTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGenfv(coord, pname, params); +} + +void gl1_3_glGetTexGendv(void *_glfuncs, GLenum coord, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGendv(coord, pname, params); +} + +void gl1_3_glGetTexEnviv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexEnviv(target, pname, params); +} + +void gl1_3_glGetTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexEnvfv(target, pname, params); +} + +void gl1_3_glGetPolygonStipple(void *_glfuncs, GLubyte* mask) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPolygonStipple(mask); +} + +void gl1_3_glGetPixelMapusv(void *_glfuncs, GLenum glmap, GLushort* values) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapusv(glmap, values); +} + +void gl1_3_glGetPixelMapuiv(void *_glfuncs, GLenum glmap, GLuint* values) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapuiv(glmap, values); +} + +void gl1_3_glGetPixelMapfv(void *_glfuncs, GLenum glmap, GLfloat* values) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapfv(glmap, values); +} + +void gl1_3_glGetMaterialiv(void *_glfuncs, GLenum face, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMaterialiv(face, pname, params); +} + +void gl1_3_glGetMaterialfv(void *_glfuncs, GLenum face, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMaterialfv(face, pname, params); +} + +void gl1_3_glGetMapiv(void *_glfuncs, GLenum target, GLenum query, GLint* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapiv(target, query, v); +} + +void gl1_3_glGetMapfv(void *_glfuncs, GLenum target, GLenum query, GLfloat* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapfv(target, query, v); +} + +void gl1_3_glGetMapdv(void *_glfuncs, GLenum target, GLenum query, GLdouble* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapdv(target, query, v); +} + +void gl1_3_glGetLightiv(void *_glfuncs, GLenum light, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetLightiv(light, pname, params); +} + +void gl1_3_glGetLightfv(void *_glfuncs, GLenum light, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetLightfv(light, pname, params); +} + +void gl1_3_glGetClipPlane(void *_glfuncs, GLenum plane, GLdouble* equation) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetClipPlane(plane, equation); +} + +void gl1_3_glDrawPixels(void *_glfuncs, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawPixels(width, height, format, gltype, pixels); +} + +void gl1_3_glCopyPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum gltype) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyPixels(x, y, width, height, gltype); +} + +void gl1_3_glPixelMapusv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLushort* values) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapusv(glmap, mapsize, values); +} + +void gl1_3_glPixelMapuiv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLuint* values) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapuiv(glmap, mapsize, values); +} + +void gl1_3_glPixelMapfv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLfloat* values) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapfv(glmap, mapsize, values); +} + +void gl1_3_glPixelTransferi(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelTransferi(pname, param); +} + +void gl1_3_glPixelTransferf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelTransferf(pname, param); +} + +void gl1_3_glPixelZoom(void *_glfuncs, GLfloat xfactor, GLfloat yfactor) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelZoom(xfactor, yfactor); +} + +void gl1_3_glAlphaFunc(void *_glfuncs, GLenum glfunc, GLfloat ref) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAlphaFunc(glfunc, ref); +} + +void gl1_3_glEvalPoint2(void *_glfuncs, GLint i, GLint j) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalPoint2(i, j); +} + +void gl1_3_glEvalMesh2(void *_glfuncs, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalMesh2(mode, i1, i2, j1, j2); +} + +void gl1_3_glEvalPoint1(void *_glfuncs, GLint i) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalPoint1(i); +} + +void gl1_3_glEvalMesh1(void *_glfuncs, GLenum mode, GLint i1, GLint i2) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalMesh1(mode, i1, i2); +} + +void gl1_3_glEvalCoord2fv(void *_glfuncs, const GLfloat* u) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2fv(u); +} + +void gl1_3_glEvalCoord2f(void *_glfuncs, GLfloat u, GLfloat v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2f(u, v); +} + +void gl1_3_glEvalCoord2dv(void *_glfuncs, const GLdouble* u) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2dv(u); +} + +void gl1_3_glEvalCoord2d(void *_glfuncs, GLdouble u, GLdouble v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2d(u, v); +} + +void gl1_3_glEvalCoord1fv(void *_glfuncs, const GLfloat* u) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1fv(u); +} + +void gl1_3_glEvalCoord1f(void *_glfuncs, GLfloat u) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1f(u); +} + +void gl1_3_glEvalCoord1dv(void *_glfuncs, const GLdouble* u) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1dv(u); +} + +void gl1_3_glEvalCoord1d(void *_glfuncs, GLdouble u) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1d(u); +} + +void gl1_3_glMapGrid2f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid2f(un, u1, u2, vn, v1, v2); +} + +void gl1_3_glMapGrid2d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid2d(un, u1, u2, vn, v1, v2); +} + +void gl1_3_glMapGrid1f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid1f(un, u1, u2); +} + +void gl1_3_glMapGrid1d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid1d(un, u1, u2); +} + +void gl1_3_glMap2f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); +} + +void gl1_3_glMap2d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); +} + +void gl1_3_glMap1f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap1f(target, u1, u2, stride, order, points); +} + +void gl1_3_glMap1d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap1d(target, u1, u2, stride, order, points); +} + +void gl1_3_glPushAttrib(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushAttrib(mask); +} + +void gl1_3_glPopAttrib(void *_glfuncs) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopAttrib(); +} + +void gl1_3_glAccum(void *_glfuncs, GLenum op, GLfloat value) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAccum(op, value); +} + +void gl1_3_glIndexMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexMask(mask); +} + +void gl1_3_glClearIndex(void *_glfuncs, GLfloat c) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearIndex(c); +} + +void gl1_3_glClearAccum(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearAccum(red, green, blue, alpha); +} + +void gl1_3_glPushName(void *_glfuncs, GLuint name) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushName(name); +} + +void gl1_3_glPopName(void *_glfuncs) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopName(); +} + +void gl1_3_glPassThrough(void *_glfuncs, GLfloat token) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPassThrough(token); +} + +void gl1_3_glLoadName(void *_glfuncs, GLuint name) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadName(name); +} + +void gl1_3_glInitNames(void *_glfuncs) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInitNames(); +} + +GLint gl1_3_glRenderMode(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glRenderMode(mode); +} + +void gl1_3_glSelectBuffer(void *_glfuncs, GLsizei size, GLuint* buffer) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSelectBuffer(size, buffer); +} + +void gl1_3_glFeedbackBuffer(void *_glfuncs, GLsizei size, GLenum gltype, GLfloat* buffer) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFeedbackBuffer(size, gltype, buffer); +} + +void gl1_3_glTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGeniv(coord, pname, params); +} + +void gl1_3_glTexGeni(void *_glfuncs, GLenum coord, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGeni(coord, pname, param); +} + +void gl1_3_glTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGenfv(coord, pname, params); +} + +void gl1_3_glTexGenf(void *_glfuncs, GLenum coord, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGenf(coord, pname, param); +} + +void gl1_3_glTexGendv(void *_glfuncs, GLenum coord, GLenum pname, const GLdouble* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGendv(coord, pname, params); +} + +void gl1_3_glTexGend(void *_glfuncs, GLenum coord, GLenum pname, GLdouble param) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGend(coord, pname, param); +} + +void gl1_3_glTexEnviv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnviv(target, pname, params); +} + +void gl1_3_glTexEnvi(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvi(target, pname, param); +} + +void gl1_3_glTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvfv(target, pname, params); +} + +void gl1_3_glTexEnvf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvf(target, pname, param); +} + +void gl1_3_glShadeModel(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShadeModel(mode); +} + +void gl1_3_glPolygonStipple(void *_glfuncs, const GLubyte* mask) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonStipple(mask); +} + +void gl1_3_glMaterialiv(void *_glfuncs, GLenum face, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialiv(face, pname, params); +} + +void gl1_3_glMateriali(void *_glfuncs, GLenum face, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMateriali(face, pname, param); +} + +void gl1_3_glMaterialfv(void *_glfuncs, GLenum face, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialfv(face, pname, params); +} + +void gl1_3_glMaterialf(void *_glfuncs, GLenum face, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialf(face, pname, param); +} + +void gl1_3_glLineStipple(void *_glfuncs, GLint factor, GLushort pattern) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineStipple(factor, pattern); +} + +void gl1_3_glLightModeliv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModeliv(pname, params); +} + +void gl1_3_glLightModeli(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModeli(pname, param); +} + +void gl1_3_glLightModelfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModelfv(pname, params); +} + +void gl1_3_glLightModelf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModelf(pname, param); +} + +void gl1_3_glLightiv(void *_glfuncs, GLenum light, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightiv(light, pname, params); +} + +void gl1_3_glLighti(void *_glfuncs, GLenum light, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLighti(light, pname, param); +} + +void gl1_3_glLightfv(void *_glfuncs, GLenum light, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightfv(light, pname, params); +} + +void gl1_3_glLightf(void *_glfuncs, GLenum light, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightf(light, pname, param); +} + +void gl1_3_glFogiv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogiv(pname, params); +} + +void gl1_3_glFogi(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogi(pname, param); +} + +void gl1_3_glFogfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogfv(pname, params); +} + +void gl1_3_glFogf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogf(pname, param); +} + +void gl1_3_glColorMaterial(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMaterial(face, mode); +} + +void gl1_3_glClipPlane(void *_glfuncs, GLenum plane, const GLdouble* equation) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClipPlane(plane, equation); +} + +void gl1_3_glVertex4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4sv(v); +} + +void gl1_3_glVertex4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4s(x, y, z, w); +} + +void gl1_3_glVertex4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4iv(v); +} + +void gl1_3_glVertex4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4i(x, y, z, w); +} + +void gl1_3_glVertex4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4fv(v); +} + +void gl1_3_glVertex4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4f(x, y, z, w); +} + +void gl1_3_glVertex4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4dv(v); +} + +void gl1_3_glVertex4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4d(x, y, z, w); +} + +void gl1_3_glVertex3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3sv(v); +} + +void gl1_3_glVertex3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3s(x, y, z); +} + +void gl1_3_glVertex3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3iv(v); +} + +void gl1_3_glVertex3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3i(x, y, z); +} + +void gl1_3_glVertex3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3fv(v); +} + +void gl1_3_glVertex3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3f(x, y, z); +} + +void gl1_3_glVertex3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3dv(v); +} + +void gl1_3_glVertex3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3d(x, y, z); +} + +void gl1_3_glVertex2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2sv(v); +} + +void gl1_3_glVertex2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2s(x, y); +} + +void gl1_3_glVertex2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2iv(v); +} + +void gl1_3_glVertex2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2i(x, y); +} + +void gl1_3_glVertex2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2fv(v); +} + +void gl1_3_glVertex2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2f(x, y); +} + +void gl1_3_glVertex2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2dv(v); +} + +void gl1_3_glVertex2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2d(x, y); +} + +void gl1_3_glTexCoord4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4sv(v); +} + +void gl1_3_glTexCoord4s(void *_glfuncs, GLshort s, GLshort t, GLshort r, GLshort q) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4s(s, t, r, q); +} + +void gl1_3_glTexCoord4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4iv(v); +} + +void gl1_3_glTexCoord4i(void *_glfuncs, GLint s, GLint t, GLint r, GLint q) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4i(s, t, r, q); +} + +void gl1_3_glTexCoord4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4fv(v); +} + +void gl1_3_glTexCoord4f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4f(s, t, r, q); +} + +void gl1_3_glTexCoord4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4dv(v); +} + +void gl1_3_glTexCoord4d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r, GLdouble q) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4d(s, t, r, q); +} + +void gl1_3_glTexCoord3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3sv(v); +} + +void gl1_3_glTexCoord3s(void *_glfuncs, GLshort s, GLshort t, GLshort r) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3s(s, t, r); +} + +void gl1_3_glTexCoord3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3iv(v); +} + +void gl1_3_glTexCoord3i(void *_glfuncs, GLint s, GLint t, GLint r) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3i(s, t, r); +} + +void gl1_3_glTexCoord3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3fv(v); +} + +void gl1_3_glTexCoord3f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3f(s, t, r); +} + +void gl1_3_glTexCoord3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3dv(v); +} + +void gl1_3_glTexCoord3d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3d(s, t, r); +} + +void gl1_3_glTexCoord2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2sv(v); +} + +void gl1_3_glTexCoord2s(void *_glfuncs, GLshort s, GLshort t) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2s(s, t); +} + +void gl1_3_glTexCoord2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2iv(v); +} + +void gl1_3_glTexCoord2i(void *_glfuncs, GLint s, GLint t) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2i(s, t); +} + +void gl1_3_glTexCoord2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2fv(v); +} + +void gl1_3_glTexCoord2f(void *_glfuncs, GLfloat s, GLfloat t) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2f(s, t); +} + +void gl1_3_glTexCoord2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2dv(v); +} + +void gl1_3_glTexCoord2d(void *_glfuncs, GLdouble s, GLdouble t) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2d(s, t); +} + +void gl1_3_glTexCoord1sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1sv(v); +} + +void gl1_3_glTexCoord1s(void *_glfuncs, GLshort s) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1s(s); +} + +void gl1_3_glTexCoord1iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1iv(v); +} + +void gl1_3_glTexCoord1i(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1i(s); +} + +void gl1_3_glTexCoord1fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1fv(v); +} + +void gl1_3_glTexCoord1f(void *_glfuncs, GLfloat s) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1f(s); +} + +void gl1_3_glTexCoord1dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1dv(v); +} + +void gl1_3_glTexCoord1d(void *_glfuncs, GLdouble s) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1d(s); +} + +void gl1_3_glRectsv(void *_glfuncs, const GLshort* v1, const GLshort* v2) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectsv(v1, v2); +} + +void gl1_3_glRects(void *_glfuncs, GLshort x1, GLshort y1, GLshort x2, GLshort y2) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRects(x1, y1, x2, y2); +} + +void gl1_3_glRectiv(void *_glfuncs, const GLint* v1, const GLint* v2) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectiv(v1, v2); +} + +void gl1_3_glRecti(void *_glfuncs, GLint x1, GLint y1, GLint x2, GLint y2) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRecti(x1, y1, x2, y2); +} + +void gl1_3_glRectfv(void *_glfuncs, const GLfloat* v1, const GLfloat* v2) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectfv(v1, v2); +} + +void gl1_3_glRectf(void *_glfuncs, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectf(x1, y1, x2, y2); +} + +void gl1_3_glRectdv(void *_glfuncs, const GLdouble* v1, const GLdouble* v2) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectdv(v1, v2); +} + +void gl1_3_glRectd(void *_glfuncs, GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectd(x1, y1, x2, y2); +} + +void gl1_3_glRasterPos4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4sv(v); +} + +void gl1_3_glRasterPos4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4s(x, y, z, w); +} + +void gl1_3_glRasterPos4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4iv(v); +} + +void gl1_3_glRasterPos4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4i(x, y, z, w); +} + +void gl1_3_glRasterPos4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4fv(v); +} + +void gl1_3_glRasterPos4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4f(x, y, z, w); +} + +void gl1_3_glRasterPos4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4dv(v); +} + +void gl1_3_glRasterPos4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4d(x, y, z, w); +} + +void gl1_3_glRasterPos3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3sv(v); +} + +void gl1_3_glRasterPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3s(x, y, z); +} + +void gl1_3_glRasterPos3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3iv(v); +} + +void gl1_3_glRasterPos3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3i(x, y, z); +} + +void gl1_3_glRasterPos3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3fv(v); +} + +void gl1_3_glRasterPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3f(x, y, z); +} + +void gl1_3_glRasterPos3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3dv(v); +} + +void gl1_3_glRasterPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3d(x, y, z); +} + +void gl1_3_glRasterPos2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2sv(v); +} + +void gl1_3_glRasterPos2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2s(x, y); +} + +void gl1_3_glRasterPos2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2iv(v); +} + +void gl1_3_glRasterPos2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2i(x, y); +} + +void gl1_3_glRasterPos2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2fv(v); +} + +void gl1_3_glRasterPos2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2f(x, y); +} + +void gl1_3_glRasterPos2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2dv(v); +} + +void gl1_3_glRasterPos2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2d(x, y); +} + +void gl1_3_glNormal3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3sv(v); +} + +void gl1_3_glNormal3s(void *_glfuncs, GLshort nx, GLshort ny, GLshort nz) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3s(nx, ny, nz); +} + +void gl1_3_glNormal3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3iv(v); +} + +void gl1_3_glNormal3i(void *_glfuncs, GLint nx, GLint ny, GLint nz) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3i(nx, ny, nz); +} + +void gl1_3_glNormal3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3fv(v); +} + +void gl1_3_glNormal3f(void *_glfuncs, GLfloat nx, GLfloat ny, GLfloat nz) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3f(nx, ny, nz); +} + +void gl1_3_glNormal3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3dv(v); +} + +void gl1_3_glNormal3d(void *_glfuncs, GLdouble nx, GLdouble ny, GLdouble nz) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3d(nx, ny, nz); +} + +void gl1_3_glNormal3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3bv(v); +} + +void gl1_3_glNormal3b(void *_glfuncs, GLbyte nx, GLbyte ny, GLbyte nz) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3b(nx, ny, nz); +} + +void gl1_3_glIndexsv(void *_glfuncs, const GLshort* c) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexsv(c); +} + +void gl1_3_glIndexs(void *_glfuncs, GLshort c) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexs(c); +} + +void gl1_3_glIndexiv(void *_glfuncs, const GLint* c) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexiv(c); +} + +void gl1_3_glIndexi(void *_glfuncs, GLint c) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexi(c); +} + +void gl1_3_glIndexfv(void *_glfuncs, const GLfloat* c) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexfv(c); +} + +void gl1_3_glIndexf(void *_glfuncs, GLfloat c) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexf(c); +} + +void gl1_3_glIndexdv(void *_glfuncs, const GLdouble* c) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexdv(c); +} + +void gl1_3_glIndexd(void *_glfuncs, GLdouble c) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexd(c); +} + +void gl1_3_glEnd(void *_glfuncs) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnd(); +} + +void gl1_3_glEdgeFlagv(void *_glfuncs, const GLboolean* flag) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlagv(flag); +} + +void gl1_3_glEdgeFlag(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlag(flag); +} + +void gl1_3_glColor4usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4usv(v); +} + +void gl1_3_glColor4us(void *_glfuncs, GLushort red, GLushort green, GLushort blue, GLushort alpha) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4us(red, green, blue, alpha); +} + +void gl1_3_glColor4uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4uiv(v); +} + +void gl1_3_glColor4ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue, GLuint alpha) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ui(red, green, blue, alpha); +} + +void gl1_3_glColor4ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ubv(v); +} + +void gl1_3_glColor4ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ub(red, green, blue, alpha); +} + +void gl1_3_glColor4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4sv(v); +} + +void gl1_3_glColor4s(void *_glfuncs, GLshort red, GLshort green, GLshort blue, GLshort alpha) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4s(red, green, blue, alpha); +} + +void gl1_3_glColor4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4iv(v); +} + +void gl1_3_glColor4i(void *_glfuncs, GLint red, GLint green, GLint blue, GLint alpha) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4i(red, green, blue, alpha); +} + +void gl1_3_glColor4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4fv(v); +} + +void gl1_3_glColor4f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4f(red, green, blue, alpha); +} + +void gl1_3_glColor4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4dv(v); +} + +void gl1_3_glColor4d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4d(red, green, blue, alpha); +} + +void gl1_3_glColor4bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4bv(v); +} + +void gl1_3_glColor4b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4b(red, green, blue, alpha); +} + +void gl1_3_glColor3usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3usv(v); +} + +void gl1_3_glColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3us(red, green, blue); +} + +void gl1_3_glColor3uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3uiv(v); +} + +void gl1_3_glColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ui(red, green, blue); +} + +void gl1_3_glColor3ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ubv(v); +} + +void gl1_3_glColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ub(red, green, blue); +} + +void gl1_3_glColor3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3sv(v); +} + +void gl1_3_glColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3s(red, green, blue); +} + +void gl1_3_glColor3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3iv(v); +} + +void gl1_3_glColor3i(void *_glfuncs, GLint red, GLint green, GLint blue) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3i(red, green, blue); +} + +void gl1_3_glColor3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3fv(v); +} + +void gl1_3_glColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3f(red, green, blue); +} + +void gl1_3_glColor3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3dv(v); +} + +void gl1_3_glColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3d(red, green, blue); +} + +void gl1_3_glColor3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3bv(v); +} + +void gl1_3_glColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3b(red, green, blue); +} + +void gl1_3_glBitmap(void *_glfuncs, GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBitmap(width, height, xorig, yorig, xmove, ymove, bitmap); +} + +void gl1_3_glBegin(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBegin(mode); +} + +void gl1_3_glListBase(void *_glfuncs, GLuint base) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glListBase(base); +} + +GLuint gl1_3_glGenLists(void *_glfuncs, GLsizei range_) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGenLists(range_); +} + +void gl1_3_glDeleteLists(void *_glfuncs, GLuint list, GLsizei range_) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteLists(list, range_); +} + +void gl1_3_glCallLists(void *_glfuncs, GLsizei n, GLenum gltype, const GLvoid* lists) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCallLists(n, gltype, lists); +} + +void gl1_3_glCallList(void *_glfuncs, GLuint list) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCallList(list); +} + +void gl1_3_glEndList(void *_glfuncs) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndList(); +} + +void gl1_3_glNewList(void *_glfuncs, GLuint list, GLenum mode) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNewList(list, mode); +} + +void gl1_3_glPushClientAttrib(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushClientAttrib(mask); +} + +void gl1_3_glPopClientAttrib(void *_glfuncs) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopClientAttrib(); +} + +void gl1_3_glPrioritizeTextures(void *_glfuncs, GLsizei n, const GLuint* textures, const GLfloat* priorities) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPrioritizeTextures(n, textures, priorities); +} + +GLboolean gl1_3_glAreTexturesResident(void *_glfuncs, GLsizei n, const GLuint* textures, GLboolean* residences) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glAreTexturesResident(n, textures, residences); +} + +void gl1_3_glVertexPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexPointer(size, gltype, stride, pointer); +} + +void gl1_3_glTexCoordPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordPointer(size, gltype, stride, pointer); +} + +void gl1_3_glNormalPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormalPointer(gltype, stride, pointer); +} + +void gl1_3_glInterleavedArrays(void *_glfuncs, GLenum format, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInterleavedArrays(format, stride, pointer); +} + +void gl1_3_glIndexPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexPointer(gltype, stride, pointer); +} + +void gl1_3_glEnableClientState(void *_glfuncs, GLenum array) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnableClientState(array); +} + +void gl1_3_glEdgeFlagPointer(void *_glfuncs, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlagPointer(stride, pointer); +} + +void gl1_3_glDisableClientState(void *_glfuncs, GLenum array) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisableClientState(array); +} + +void gl1_3_glColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorPointer(size, gltype, stride, pointer); +} + +void gl1_3_glArrayElement(void *_glfuncs, GLint i) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glArrayElement(i); +} + +void gl1_3_glResetMinmax(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glResetMinmax(target); +} + +void gl1_3_glResetHistogram(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glResetHistogram(target); +} + +void gl1_3_glMinmax(void *_glfuncs, GLenum target, GLenum internalFormat, GLboolean sink) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMinmax(target, internalFormat, sink); +} + +void gl1_3_glHistogram(void *_glfuncs, GLenum target, GLsizei width, GLenum internalFormat, GLboolean sink) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glHistogram(target, width, internalFormat, sink); +} + +void gl1_3_glGetMinmaxParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmaxParameteriv(target, pname, params); +} + +void gl1_3_glGetMinmaxParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmaxParameterfv(target, pname, params); +} + +void gl1_3_glGetMinmax(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmax(target, reset, format, gltype, values); +} + +void gl1_3_glGetHistogramParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogramParameteriv(target, pname, params); +} + +void gl1_3_glGetHistogramParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogramParameterfv(target, pname, params); +} + +void gl1_3_glGetHistogram(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogram(target, reset, format, gltype, values); +} + +void gl1_3_glSeparableFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* row, const GLvoid* column) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSeparableFilter2D(target, internalFormat, width, height, format, gltype, row, column); +} + +void gl1_3_glGetSeparableFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* row, GLvoid* column, GLvoid* span) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSeparableFilter(target, format, gltype, row, column, span); +} + +void gl1_3_glGetConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionParameteriv(target, pname, params); +} + +void gl1_3_glGetConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionParameterfv(target, pname, params); +} + +void gl1_3_glGetConvolutionFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* image) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionFilter(target, format, gltype, image); +} + +void gl1_3_glCopyConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyConvolutionFilter2D(target, internalFormat, x, y, width, height); +} + +void gl1_3_glCopyConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyConvolutionFilter1D(target, internalFormat, x, y, width); +} + +void gl1_3_glConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameteriv(target, pname, params); +} + +void gl1_3_glConvolutionParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameteri(target, pname, params); +} + +void gl1_3_glConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameterfv(target, pname, params); +} + +void gl1_3_glConvolutionParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameterf(target, pname, params); +} + +void gl1_3_glConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* image) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionFilter2D(target, internalFormat, width, height, format, gltype, image); +} + +void gl1_3_glConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* image) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionFilter1D(target, internalFormat, width, format, gltype, image); +} + +void gl1_3_glCopyColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyColorSubTable(target, start, x, y, width); +} + +void gl1_3_glColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum gltype, const GLvoid* data) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorSubTable(target, start, count, format, gltype, data); +} + +void gl1_3_glGetColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTableParameteriv(target, pname, params); +} + +void gl1_3_glGetColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTableParameterfv(target, pname, params); +} + +void gl1_3_glGetColorTable(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* table) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTable(target, format, gltype, table); +} + +void gl1_3_glCopyColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyColorTable(target, internalFormat, x, y, width); +} + +void gl1_3_glColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTableParameteriv(target, pname, params); +} + +void gl1_3_glColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTableParameterfv(target, pname, params); +} + +void gl1_3_glColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* table) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTable(target, internalFormat, width, format, gltype, table); +} + +void gl1_3_glMultTransposeMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultTransposeMatrixd(m); +} + +void gl1_3_glMultTransposeMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultTransposeMatrixf(m); +} + +void gl1_3_glLoadTransposeMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadTransposeMatrixd(m); +} + +void gl1_3_glLoadTransposeMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadTransposeMatrixf(m); +} + +void gl1_3_glMultiTexCoord4sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4sv(target, v); +} + +void gl1_3_glMultiTexCoord4s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r, GLshort q) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4s(target, s, t, r, q); +} + +void gl1_3_glMultiTexCoord4iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4iv(target, v); +} + +void gl1_3_glMultiTexCoord4i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r, GLint q) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4i(target, s, t, r, q); +} + +void gl1_3_glMultiTexCoord4fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4fv(target, v); +} + +void gl1_3_glMultiTexCoord4f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4f(target, s, t, r, q); +} + +void gl1_3_glMultiTexCoord4dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4dv(target, v); +} + +void gl1_3_glMultiTexCoord4d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4d(target, s, t, r, q); +} + +void gl1_3_glMultiTexCoord3sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3sv(target, v); +} + +void gl1_3_glMultiTexCoord3s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3s(target, s, t, r); +} + +void gl1_3_glMultiTexCoord3iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3iv(target, v); +} + +void gl1_3_glMultiTexCoord3i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3i(target, s, t, r); +} + +void gl1_3_glMultiTexCoord3fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3fv(target, v); +} + +void gl1_3_glMultiTexCoord3f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3f(target, s, t, r); +} + +void gl1_3_glMultiTexCoord3dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3dv(target, v); +} + +void gl1_3_glMultiTexCoord3d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3d(target, s, t, r); +} + +void gl1_3_glMultiTexCoord2sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2sv(target, v); +} + +void gl1_3_glMultiTexCoord2s(void *_glfuncs, GLenum target, GLshort s, GLshort t) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2s(target, s, t); +} + +void gl1_3_glMultiTexCoord2iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2iv(target, v); +} + +void gl1_3_glMultiTexCoord2i(void *_glfuncs, GLenum target, GLint s, GLint t) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2i(target, s, t); +} + +void gl1_3_glMultiTexCoord2fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2fv(target, v); +} + +void gl1_3_glMultiTexCoord2f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2f(target, s, t); +} + +void gl1_3_glMultiTexCoord2dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2dv(target, v); +} + +void gl1_3_glMultiTexCoord2d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2d(target, s, t); +} + +void gl1_3_glMultiTexCoord1sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1sv(target, v); +} + +void gl1_3_glMultiTexCoord1s(void *_glfuncs, GLenum target, GLshort s) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1s(target, s); +} + +void gl1_3_glMultiTexCoord1iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1iv(target, v); +} + +void gl1_3_glMultiTexCoord1i(void *_glfuncs, GLenum target, GLint s) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1i(target, s); +} + +void gl1_3_glMultiTexCoord1fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1fv(target, v); +} + +void gl1_3_glMultiTexCoord1f(void *_glfuncs, GLenum target, GLfloat s) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1f(target, s); +} + +void gl1_3_glMultiTexCoord1dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1dv(target, v); +} + +void gl1_3_glMultiTexCoord1d(void *_glfuncs, GLenum target, GLdouble s) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1d(target, s); +} + +void gl1_3_glClientActiveTexture(void *_glfuncs, GLenum texture) +{ + QOpenGLFunctions_1_3* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClientActiveTexture(texture); +} + diff --git a/gl/1.3/funcs.h b/gl/1.3/funcs.h new file mode 100644 index 00000000..9d394438 --- /dev/null +++ b/gl/1.3/funcs.h @@ -0,0 +1,460 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#ifndef __cplusplus +#include +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef char GLchar; +typedef signed char GLbyte; /* 1-byte signed */ +typedef short GLshort; /* 2-byte signed */ +typedef int GLint; /* 4-byte signed */ +typedef unsigned char GLubyte; /* 1-byte unsigned */ +typedef unsigned short GLushort; /* 2-byte unsigned */ +typedef unsigned int GLuint; /* 4-byte unsigned */ +typedef int GLsizei; /* 4-byte signed */ +typedef float GLfloat; /* single precision float */ +typedef float GLclampf; /* single precision float in [0,1] */ +typedef double GLdouble; /* double precision float */ +typedef double GLclampd; /* double precision float in [0,1] */ +typedef int64_t GLint64; +typedef uint64_t GLuint64; +typedef ptrdiff_t GLintptr; +typedef ptrdiff_t GLsizeiptr; +typedef ptrdiff_t GLintptrARB; +typedef ptrdiff_t GLsizeiptrARB; +typedef struct __GLsync *GLsync; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +void *gl1_3_funcs(); + +void gl1_3_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl1_3_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal); +GLboolean gl1_3_glIsEnabled(void *_glfuncs, GLenum cap); +void gl1_3_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params); +void gl1_3_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params); +void gl1_3_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl1_3_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl1_3_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels); +void gl1_3_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params); +void gl1_3_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params); +GLenum gl1_3_glGetError(void *_glfuncs); +void gl1_3_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params); +void gl1_3_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params); +void gl1_3_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels); +void gl1_3_glReadBuffer(void *_glfuncs, GLenum mode); +void gl1_3_glPixelStorei(void *_glfuncs, GLenum pname, GLint param); +void gl1_3_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param); +void gl1_3_glDepthFunc(void *_glfuncs, GLenum glfunc); +void gl1_3_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass); +void gl1_3_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask); +void gl1_3_glLogicOp(void *_glfuncs, GLenum opcode); +void gl1_3_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor); +void gl1_3_glFlush(void *_glfuncs); +void gl1_3_glFinish(void *_glfuncs); +void gl1_3_glEnable(void *_glfuncs, GLenum cap); +void gl1_3_glDisable(void *_glfuncs, GLenum cap); +void gl1_3_glDepthMask(void *_glfuncs, GLboolean flag); +void gl1_3_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +void gl1_3_glStencilMask(void *_glfuncs, GLuint mask); +void gl1_3_glClearDepth(void *_glfuncs, GLdouble depth); +void gl1_3_glClearStencil(void *_glfuncs, GLint s); +void gl1_3_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl1_3_glClear(void *_glfuncs, GLbitfield mask); +void gl1_3_glDrawBuffer(void *_glfuncs, GLenum mode); +void gl1_3_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_3_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_3_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl1_3_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl1_3_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl1_3_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl1_3_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl1_3_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode); +void gl1_3_glPointSize(void *_glfuncs, GLfloat size); +void gl1_3_glLineWidth(void *_glfuncs, GLfloat width); +void gl1_3_glHint(void *_glfuncs, GLenum target, GLenum mode); +void gl1_3_glFrontFace(void *_glfuncs, GLenum mode); +void gl1_3_glCullFace(void *_glfuncs, GLenum mode); +void gl1_3_glIndexubv(void *_glfuncs, const GLubyte* c); +void gl1_3_glIndexub(void *_glfuncs, GLubyte c); +GLboolean gl1_3_glIsTexture(void *_glfuncs, GLuint texture); +void gl1_3_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures); +void gl1_3_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures); +void gl1_3_glBindTexture(void *_glfuncs, GLenum target, GLuint texture); +void gl1_3_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_3_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_3_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl1_3_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +void gl1_3_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +void gl1_3_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border); +void gl1_3_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units); +void gl1_3_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl1_3_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count); +void gl1_3_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl1_3_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_3_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_3_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl1_3_glBlendEquation(void *_glfuncs, GLenum mode); +void gl1_3_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl1_3_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img); +void gl1_3_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl1_3_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl1_3_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl1_3_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data); +void gl1_3_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data); +void gl1_3_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data); +void gl1_3_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert); +void gl1_3_glActiveTexture(void *_glfuncs, GLenum texture); +void gl1_3_glTranslatef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl1_3_glTranslated(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl1_3_glScalef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl1_3_glScaled(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl1_3_glRotatef(void *_glfuncs, GLfloat angle, GLfloat x, GLfloat y, GLfloat z); +void gl1_3_glRotated(void *_glfuncs, GLdouble angle, GLdouble x, GLdouble y, GLdouble z); +void gl1_3_glPushMatrix(void *_glfuncs); +void gl1_3_glPopMatrix(void *_glfuncs); +void gl1_3_glOrtho(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +void gl1_3_glMultMatrixd(void *_glfuncs, const GLdouble* m); +void gl1_3_glMultMatrixf(void *_glfuncs, const GLfloat* m); +void gl1_3_glMatrixMode(void *_glfuncs, GLenum mode); +void gl1_3_glLoadMatrixd(void *_glfuncs, const GLdouble* m); +void gl1_3_glLoadMatrixf(void *_glfuncs, const GLfloat* m); +void gl1_3_glLoadIdentity(void *_glfuncs); +void gl1_3_glFrustum(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +GLboolean gl1_3_glIsList(void *_glfuncs, GLuint list); +void gl1_3_glGetTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, GLint* params); +void gl1_3_glGetTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, GLfloat* params); +void gl1_3_glGetTexGendv(void *_glfuncs, GLenum coord, GLenum pname, GLdouble* params); +void gl1_3_glGetTexEnviv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl1_3_glGetTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl1_3_glGetPolygonStipple(void *_glfuncs, GLubyte* mask); +void gl1_3_glGetPixelMapusv(void *_glfuncs, GLenum glmap, GLushort* values); +void gl1_3_glGetPixelMapuiv(void *_glfuncs, GLenum glmap, GLuint* values); +void gl1_3_glGetPixelMapfv(void *_glfuncs, GLenum glmap, GLfloat* values); +void gl1_3_glGetMaterialiv(void *_glfuncs, GLenum face, GLenum pname, GLint* params); +void gl1_3_glGetMaterialfv(void *_glfuncs, GLenum face, GLenum pname, GLfloat* params); +void gl1_3_glGetMapiv(void *_glfuncs, GLenum target, GLenum query, GLint* v); +void gl1_3_glGetMapfv(void *_glfuncs, GLenum target, GLenum query, GLfloat* v); +void gl1_3_glGetMapdv(void *_glfuncs, GLenum target, GLenum query, GLdouble* v); +void gl1_3_glGetLightiv(void *_glfuncs, GLenum light, GLenum pname, GLint* params); +void gl1_3_glGetLightfv(void *_glfuncs, GLenum light, GLenum pname, GLfloat* params); +void gl1_3_glGetClipPlane(void *_glfuncs, GLenum plane, GLdouble* equation); +void gl1_3_glDrawPixels(void *_glfuncs, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_3_glCopyPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum gltype); +void gl1_3_glPixelMapusv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLushort* values); +void gl1_3_glPixelMapuiv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLuint* values); +void gl1_3_glPixelMapfv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLfloat* values); +void gl1_3_glPixelTransferi(void *_glfuncs, GLenum pname, GLint param); +void gl1_3_glPixelTransferf(void *_glfuncs, GLenum pname, GLfloat param); +void gl1_3_glPixelZoom(void *_glfuncs, GLfloat xfactor, GLfloat yfactor); +void gl1_3_glAlphaFunc(void *_glfuncs, GLenum glfunc, GLfloat ref); +void gl1_3_glEvalPoint2(void *_glfuncs, GLint i, GLint j); +void gl1_3_glEvalMesh2(void *_glfuncs, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); +void gl1_3_glEvalPoint1(void *_glfuncs, GLint i); +void gl1_3_glEvalMesh1(void *_glfuncs, GLenum mode, GLint i1, GLint i2); +void gl1_3_glEvalCoord2fv(void *_glfuncs, const GLfloat* u); +void gl1_3_glEvalCoord2f(void *_glfuncs, GLfloat u, GLfloat v); +void gl1_3_glEvalCoord2dv(void *_glfuncs, const GLdouble* u); +void gl1_3_glEvalCoord2d(void *_glfuncs, GLdouble u, GLdouble v); +void gl1_3_glEvalCoord1fv(void *_glfuncs, const GLfloat* u); +void gl1_3_glEvalCoord1f(void *_glfuncs, GLfloat u); +void gl1_3_glEvalCoord1dv(void *_glfuncs, const GLdouble* u); +void gl1_3_glEvalCoord1d(void *_glfuncs, GLdouble u); +void gl1_3_glMapGrid2f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); +void gl1_3_glMapGrid2d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); +void gl1_3_glMapGrid1f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2); +void gl1_3_glMapGrid1d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2); +void gl1_3_glMap2f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points); +void gl1_3_glMap2d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points); +void gl1_3_glMap1f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points); +void gl1_3_glMap1d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points); +void gl1_3_glPushAttrib(void *_glfuncs, GLbitfield mask); +void gl1_3_glPopAttrib(void *_glfuncs); +void gl1_3_glAccum(void *_glfuncs, GLenum op, GLfloat value); +void gl1_3_glIndexMask(void *_glfuncs, GLuint mask); +void gl1_3_glClearIndex(void *_glfuncs, GLfloat c); +void gl1_3_glClearAccum(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl1_3_glPushName(void *_glfuncs, GLuint name); +void gl1_3_glPopName(void *_glfuncs); +void gl1_3_glPassThrough(void *_glfuncs, GLfloat token); +void gl1_3_glLoadName(void *_glfuncs, GLuint name); +void gl1_3_glInitNames(void *_glfuncs); +GLint gl1_3_glRenderMode(void *_glfuncs, GLenum mode); +void gl1_3_glSelectBuffer(void *_glfuncs, GLsizei size, GLuint* buffer); +void gl1_3_glFeedbackBuffer(void *_glfuncs, GLsizei size, GLenum gltype, GLfloat* buffer); +void gl1_3_glTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, const GLint* params); +void gl1_3_glTexGeni(void *_glfuncs, GLenum coord, GLenum pname, GLint param); +void gl1_3_glTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, const GLfloat* params); +void gl1_3_glTexGenf(void *_glfuncs, GLenum coord, GLenum pname, GLfloat param); +void gl1_3_glTexGendv(void *_glfuncs, GLenum coord, GLenum pname, const GLdouble* params); +void gl1_3_glTexGend(void *_glfuncs, GLenum coord, GLenum pname, GLdouble param); +void gl1_3_glTexEnviv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl1_3_glTexEnvi(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl1_3_glTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl1_3_glTexEnvf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl1_3_glShadeModel(void *_glfuncs, GLenum mode); +void gl1_3_glPolygonStipple(void *_glfuncs, const GLubyte* mask); +void gl1_3_glMaterialiv(void *_glfuncs, GLenum face, GLenum pname, const GLint* params); +void gl1_3_glMateriali(void *_glfuncs, GLenum face, GLenum pname, GLint param); +void gl1_3_glMaterialfv(void *_glfuncs, GLenum face, GLenum pname, const GLfloat* params); +void gl1_3_glMaterialf(void *_glfuncs, GLenum face, GLenum pname, GLfloat param); +void gl1_3_glLineStipple(void *_glfuncs, GLint factor, GLushort pattern); +void gl1_3_glLightModeliv(void *_glfuncs, GLenum pname, const GLint* params); +void gl1_3_glLightModeli(void *_glfuncs, GLenum pname, GLint param); +void gl1_3_glLightModelfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl1_3_glLightModelf(void *_glfuncs, GLenum pname, GLfloat param); +void gl1_3_glLightiv(void *_glfuncs, GLenum light, GLenum pname, const GLint* params); +void gl1_3_glLighti(void *_glfuncs, GLenum light, GLenum pname, GLint param); +void gl1_3_glLightfv(void *_glfuncs, GLenum light, GLenum pname, const GLfloat* params); +void gl1_3_glLightf(void *_glfuncs, GLenum light, GLenum pname, GLfloat param); +void gl1_3_glFogiv(void *_glfuncs, GLenum pname, const GLint* params); +void gl1_3_glFogi(void *_glfuncs, GLenum pname, GLint param); +void gl1_3_glFogfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl1_3_glFogf(void *_glfuncs, GLenum pname, GLfloat param); +void gl1_3_glColorMaterial(void *_glfuncs, GLenum face, GLenum mode); +void gl1_3_glClipPlane(void *_glfuncs, GLenum plane, const GLdouble* equation); +void gl1_3_glVertex4sv(void *_glfuncs, const GLshort* v); +void gl1_3_glVertex4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w); +void gl1_3_glVertex4iv(void *_glfuncs, const GLint* v); +void gl1_3_glVertex4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w); +void gl1_3_glVertex4fv(void *_glfuncs, const GLfloat* v); +void gl1_3_glVertex4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl1_3_glVertex4dv(void *_glfuncs, const GLdouble* v); +void gl1_3_glVertex4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl1_3_glVertex3sv(void *_glfuncs, const GLshort* v); +void gl1_3_glVertex3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl1_3_glVertex3iv(void *_glfuncs, const GLint* v); +void gl1_3_glVertex3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl1_3_glVertex3fv(void *_glfuncs, const GLfloat* v); +void gl1_3_glVertex3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl1_3_glVertex3dv(void *_glfuncs, const GLdouble* v); +void gl1_3_glVertex3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl1_3_glVertex2sv(void *_glfuncs, const GLshort* v); +void gl1_3_glVertex2s(void *_glfuncs, GLshort x, GLshort y); +void gl1_3_glVertex2iv(void *_glfuncs, const GLint* v); +void gl1_3_glVertex2i(void *_glfuncs, GLint x, GLint y); +void gl1_3_glVertex2fv(void *_glfuncs, const GLfloat* v); +void gl1_3_glVertex2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl1_3_glVertex2dv(void *_glfuncs, const GLdouble* v); +void gl1_3_glVertex2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl1_3_glTexCoord4sv(void *_glfuncs, const GLshort* v); +void gl1_3_glTexCoord4s(void *_glfuncs, GLshort s, GLshort t, GLshort r, GLshort q); +void gl1_3_glTexCoord4iv(void *_glfuncs, const GLint* v); +void gl1_3_glTexCoord4i(void *_glfuncs, GLint s, GLint t, GLint r, GLint q); +void gl1_3_glTexCoord4fv(void *_glfuncs, const GLfloat* v); +void gl1_3_glTexCoord4f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +void gl1_3_glTexCoord4dv(void *_glfuncs, const GLdouble* v); +void gl1_3_glTexCoord4d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +void gl1_3_glTexCoord3sv(void *_glfuncs, const GLshort* v); +void gl1_3_glTexCoord3s(void *_glfuncs, GLshort s, GLshort t, GLshort r); +void gl1_3_glTexCoord3iv(void *_glfuncs, const GLint* v); +void gl1_3_glTexCoord3i(void *_glfuncs, GLint s, GLint t, GLint r); +void gl1_3_glTexCoord3fv(void *_glfuncs, const GLfloat* v); +void gl1_3_glTexCoord3f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r); +void gl1_3_glTexCoord3dv(void *_glfuncs, const GLdouble* v); +void gl1_3_glTexCoord3d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r); +void gl1_3_glTexCoord2sv(void *_glfuncs, const GLshort* v); +void gl1_3_glTexCoord2s(void *_glfuncs, GLshort s, GLshort t); +void gl1_3_glTexCoord2iv(void *_glfuncs, const GLint* v); +void gl1_3_glTexCoord2i(void *_glfuncs, GLint s, GLint t); +void gl1_3_glTexCoord2fv(void *_glfuncs, const GLfloat* v); +void gl1_3_glTexCoord2f(void *_glfuncs, GLfloat s, GLfloat t); +void gl1_3_glTexCoord2dv(void *_glfuncs, const GLdouble* v); +void gl1_3_glTexCoord2d(void *_glfuncs, GLdouble s, GLdouble t); +void gl1_3_glTexCoord1sv(void *_glfuncs, const GLshort* v); +void gl1_3_glTexCoord1s(void *_glfuncs, GLshort s); +void gl1_3_glTexCoord1iv(void *_glfuncs, const GLint* v); +void gl1_3_glTexCoord1i(void *_glfuncs, GLint s); +void gl1_3_glTexCoord1fv(void *_glfuncs, const GLfloat* v); +void gl1_3_glTexCoord1f(void *_glfuncs, GLfloat s); +void gl1_3_glTexCoord1dv(void *_glfuncs, const GLdouble* v); +void gl1_3_glTexCoord1d(void *_glfuncs, GLdouble s); +void gl1_3_glRectsv(void *_glfuncs, const GLshort* v1, const GLshort* v2); +void gl1_3_glRects(void *_glfuncs, GLshort x1, GLshort y1, GLshort x2, GLshort y2); +void gl1_3_glRectiv(void *_glfuncs, const GLint* v1, const GLint* v2); +void gl1_3_glRecti(void *_glfuncs, GLint x1, GLint y1, GLint x2, GLint y2); +void gl1_3_glRectfv(void *_glfuncs, const GLfloat* v1, const GLfloat* v2); +void gl1_3_glRectf(void *_glfuncs, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); +void gl1_3_glRectdv(void *_glfuncs, const GLdouble* v1, const GLdouble* v2); +void gl1_3_glRectd(void *_glfuncs, GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); +void gl1_3_glRasterPos4sv(void *_glfuncs, const GLshort* v); +void gl1_3_glRasterPos4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w); +void gl1_3_glRasterPos4iv(void *_glfuncs, const GLint* v); +void gl1_3_glRasterPos4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w); +void gl1_3_glRasterPos4fv(void *_glfuncs, const GLfloat* v); +void gl1_3_glRasterPos4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl1_3_glRasterPos4dv(void *_glfuncs, const GLdouble* v); +void gl1_3_glRasterPos4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl1_3_glRasterPos3sv(void *_glfuncs, const GLshort* v); +void gl1_3_glRasterPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl1_3_glRasterPos3iv(void *_glfuncs, const GLint* v); +void gl1_3_glRasterPos3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl1_3_glRasterPos3fv(void *_glfuncs, const GLfloat* v); +void gl1_3_glRasterPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl1_3_glRasterPos3dv(void *_glfuncs, const GLdouble* v); +void gl1_3_glRasterPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl1_3_glRasterPos2sv(void *_glfuncs, const GLshort* v); +void gl1_3_glRasterPos2s(void *_glfuncs, GLshort x, GLshort y); +void gl1_3_glRasterPos2iv(void *_glfuncs, const GLint* v); +void gl1_3_glRasterPos2i(void *_glfuncs, GLint x, GLint y); +void gl1_3_glRasterPos2fv(void *_glfuncs, const GLfloat* v); +void gl1_3_glRasterPos2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl1_3_glRasterPos2dv(void *_glfuncs, const GLdouble* v); +void gl1_3_glRasterPos2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl1_3_glNormal3sv(void *_glfuncs, const GLshort* v); +void gl1_3_glNormal3s(void *_glfuncs, GLshort nx, GLshort ny, GLshort nz); +void gl1_3_glNormal3iv(void *_glfuncs, const GLint* v); +void gl1_3_glNormal3i(void *_glfuncs, GLint nx, GLint ny, GLint nz); +void gl1_3_glNormal3fv(void *_glfuncs, const GLfloat* v); +void gl1_3_glNormal3f(void *_glfuncs, GLfloat nx, GLfloat ny, GLfloat nz); +void gl1_3_glNormal3dv(void *_glfuncs, const GLdouble* v); +void gl1_3_glNormal3d(void *_glfuncs, GLdouble nx, GLdouble ny, GLdouble nz); +void gl1_3_glNormal3bv(void *_glfuncs, const GLbyte* v); +void gl1_3_glNormal3b(void *_glfuncs, GLbyte nx, GLbyte ny, GLbyte nz); +void gl1_3_glIndexsv(void *_glfuncs, const GLshort* c); +void gl1_3_glIndexs(void *_glfuncs, GLshort c); +void gl1_3_glIndexiv(void *_glfuncs, const GLint* c); +void gl1_3_glIndexi(void *_glfuncs, GLint c); +void gl1_3_glIndexfv(void *_glfuncs, const GLfloat* c); +void gl1_3_glIndexf(void *_glfuncs, GLfloat c); +void gl1_3_glIndexdv(void *_glfuncs, const GLdouble* c); +void gl1_3_glIndexd(void *_glfuncs, GLdouble c); +void gl1_3_glEnd(void *_glfuncs); +void gl1_3_glEdgeFlagv(void *_glfuncs, const GLboolean* flag); +void gl1_3_glEdgeFlag(void *_glfuncs, GLboolean flag); +void gl1_3_glColor4usv(void *_glfuncs, const GLushort* v); +void gl1_3_glColor4us(void *_glfuncs, GLushort red, GLushort green, GLushort blue, GLushort alpha); +void gl1_3_glColor4uiv(void *_glfuncs, const GLuint* v); +void gl1_3_glColor4ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue, GLuint alpha); +void gl1_3_glColor4ubv(void *_glfuncs, const GLubyte* v); +void gl1_3_glColor4ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); +void gl1_3_glColor4sv(void *_glfuncs, const GLshort* v); +void gl1_3_glColor4s(void *_glfuncs, GLshort red, GLshort green, GLshort blue, GLshort alpha); +void gl1_3_glColor4iv(void *_glfuncs, const GLint* v); +void gl1_3_glColor4i(void *_glfuncs, GLint red, GLint green, GLint blue, GLint alpha); +void gl1_3_glColor4fv(void *_glfuncs, const GLfloat* v); +void gl1_3_glColor4f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl1_3_glColor4dv(void *_glfuncs, const GLdouble* v); +void gl1_3_glColor4d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); +void gl1_3_glColor4bv(void *_glfuncs, const GLbyte* v); +void gl1_3_glColor4b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); +void gl1_3_glColor3usv(void *_glfuncs, const GLushort* v); +void gl1_3_glColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue); +void gl1_3_glColor3uiv(void *_glfuncs, const GLuint* v); +void gl1_3_glColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue); +void gl1_3_glColor3ubv(void *_glfuncs, const GLubyte* v); +void gl1_3_glColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue); +void gl1_3_glColor3sv(void *_glfuncs, const GLshort* v); +void gl1_3_glColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue); +void gl1_3_glColor3iv(void *_glfuncs, const GLint* v); +void gl1_3_glColor3i(void *_glfuncs, GLint red, GLint green, GLint blue); +void gl1_3_glColor3fv(void *_glfuncs, const GLfloat* v); +void gl1_3_glColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue); +void gl1_3_glColor3dv(void *_glfuncs, const GLdouble* v); +void gl1_3_glColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue); +void gl1_3_glColor3bv(void *_glfuncs, const GLbyte* v); +void gl1_3_glColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue); +void gl1_3_glBitmap(void *_glfuncs, GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap); +void gl1_3_glBegin(void *_glfuncs, GLenum mode); +void gl1_3_glListBase(void *_glfuncs, GLuint base); +GLuint gl1_3_glGenLists(void *_glfuncs, GLsizei range_); +void gl1_3_glDeleteLists(void *_glfuncs, GLuint list, GLsizei range_); +void gl1_3_glCallLists(void *_glfuncs, GLsizei n, GLenum gltype, const GLvoid* lists); +void gl1_3_glCallList(void *_glfuncs, GLuint list); +void gl1_3_glEndList(void *_glfuncs); +void gl1_3_glNewList(void *_glfuncs, GLuint list, GLenum mode); +void gl1_3_glPushClientAttrib(void *_glfuncs, GLbitfield mask); +void gl1_3_glPopClientAttrib(void *_glfuncs); +void gl1_3_glPrioritizeTextures(void *_glfuncs, GLsizei n, const GLuint* textures, const GLfloat* priorities); +GLboolean gl1_3_glAreTexturesResident(void *_glfuncs, GLsizei n, const GLuint* textures, GLboolean* residences); +void gl1_3_glVertexPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl1_3_glTexCoordPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl1_3_glNormalPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl1_3_glInterleavedArrays(void *_glfuncs, GLenum format, GLsizei stride, const GLvoid* pointer); +void gl1_3_glIndexPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl1_3_glEnableClientState(void *_glfuncs, GLenum array); +void gl1_3_glEdgeFlagPointer(void *_glfuncs, GLsizei stride, const GLvoid* pointer); +void gl1_3_glDisableClientState(void *_glfuncs, GLenum array); +void gl1_3_glColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl1_3_glArrayElement(void *_glfuncs, GLint i); +void gl1_3_glResetMinmax(void *_glfuncs, GLenum target); +void gl1_3_glResetHistogram(void *_glfuncs, GLenum target); +void gl1_3_glMinmax(void *_glfuncs, GLenum target, GLenum internalFormat, GLboolean sink); +void gl1_3_glHistogram(void *_glfuncs, GLenum target, GLsizei width, GLenum internalFormat, GLboolean sink); +void gl1_3_glGetMinmaxParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl1_3_glGetMinmaxParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl1_3_glGetMinmax(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values); +void gl1_3_glGetHistogramParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl1_3_glGetHistogramParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl1_3_glGetHistogram(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values); +void gl1_3_glSeparableFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* row, const GLvoid* column); +void gl1_3_glGetSeparableFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* row, GLvoid* column, GLvoid* span); +void gl1_3_glGetConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl1_3_glGetConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl1_3_glGetConvolutionFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* image); +void gl1_3_glCopyConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height); +void gl1_3_glCopyConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width); +void gl1_3_glConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl1_3_glConvolutionParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint params); +void gl1_3_glConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl1_3_glConvolutionParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat params); +void gl1_3_glConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* image); +void gl1_3_glConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* image); +void gl1_3_glCopyColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); +void gl1_3_glColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum gltype, const GLvoid* data); +void gl1_3_glGetColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl1_3_glGetColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl1_3_glGetColorTable(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* table); +void gl1_3_glCopyColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width); +void gl1_3_glColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl1_3_glColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl1_3_glColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* table); +void gl1_3_glMultTransposeMatrixd(void *_glfuncs, const GLdouble* m); +void gl1_3_glMultTransposeMatrixf(void *_glfuncs, const GLfloat* m); +void gl1_3_glLoadTransposeMatrixd(void *_glfuncs, const GLdouble* m); +void gl1_3_glLoadTransposeMatrixf(void *_glfuncs, const GLfloat* m); +void gl1_3_glMultiTexCoord4sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl1_3_glMultiTexCoord4s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); +void gl1_3_glMultiTexCoord4iv(void *_glfuncs, GLenum target, const GLint* v); +void gl1_3_glMultiTexCoord4i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r, GLint q); +void gl1_3_glMultiTexCoord4fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl1_3_glMultiTexCoord4f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +void gl1_3_glMultiTexCoord4dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl1_3_glMultiTexCoord4d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +void gl1_3_glMultiTexCoord3sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl1_3_glMultiTexCoord3s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r); +void gl1_3_glMultiTexCoord3iv(void *_glfuncs, GLenum target, const GLint* v); +void gl1_3_glMultiTexCoord3i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r); +void gl1_3_glMultiTexCoord3fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl1_3_glMultiTexCoord3f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r); +void gl1_3_glMultiTexCoord3dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl1_3_glMultiTexCoord3d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r); +void gl1_3_glMultiTexCoord2sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl1_3_glMultiTexCoord2s(void *_glfuncs, GLenum target, GLshort s, GLshort t); +void gl1_3_glMultiTexCoord2iv(void *_glfuncs, GLenum target, const GLint* v); +void gl1_3_glMultiTexCoord2i(void *_glfuncs, GLenum target, GLint s, GLint t); +void gl1_3_glMultiTexCoord2fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl1_3_glMultiTexCoord2f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t); +void gl1_3_glMultiTexCoord2dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl1_3_glMultiTexCoord2d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t); +void gl1_3_glMultiTexCoord1sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl1_3_glMultiTexCoord1s(void *_glfuncs, GLenum target, GLshort s); +void gl1_3_glMultiTexCoord1iv(void *_glfuncs, GLenum target, const GLint* v); +void gl1_3_glMultiTexCoord1i(void *_glfuncs, GLenum target, GLint s); +void gl1_3_glMultiTexCoord1fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl1_3_glMultiTexCoord1f(void *_glfuncs, GLenum target, GLfloat s); +void gl1_3_glMultiTexCoord1dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl1_3_glMultiTexCoord1d(void *_glfuncs, GLenum target, GLdouble s); +void gl1_3_glClientActiveTexture(void *_glfuncs, GLenum texture); + + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/gl/1.3/gl.go b/gl/1.3/gl.go new file mode 100644 index 00000000..6df8965a --- /dev/null +++ b/gl/1.3/gl.go @@ -0,0 +1,3571 @@ +// ** file automatically generated by glgen -- do not edit manually ** + +package GL + +// #cgo CXXFLAGS: -std=c++0x -pedantic-errors -Wall -fno-strict-aliasing +// #cgo LDFLAGS: -lstdc++ +// #cgo pkg-config: Qt5Core Qt5OpenGL +// +// #include "funcs.h" +// +// void free(void*); +// +import "C" + +import ( + "fmt" + "reflect" + "unsafe" + + "gopkg.in/qml.v1/gl/glbase" +) + +// API returns a value that offers methods matching the OpenGL version 1.3 API. +// +// The returned API must not be used after the provided OpenGL context becomes invalid. +func API(context glbase.Contexter) *GL { + gl := &GL{} + gl.funcs = C.gl1_3_funcs() + if gl.funcs == nil { + panic(fmt.Errorf("OpenGL version 1.3 is not available")) + } + return gl +} + +// GL implements the OpenGL version 1.3 API. Values of this +// type must be created via the API function, and it must not be used after +// the associated OpenGL context becomes invalid. +type GL struct { + funcs unsafe.Pointer +} + +const ( + FALSE = 0 + TRUE = 1 + NONE = 0 + + BYTE = 0x1400 + UNSIGNED_BYTE = 0x1401 + SHORT = 0x1402 + UNSIGNED_SHORT = 0x1403 + INT = 0x1404 + UNSIGNED_INT = 0x1405 + FLOAT = 0x1406 + N2_BYTES = 0x1407 + N3_BYTES = 0x1408 + N4_BYTES = 0x1409 + DOUBLE = 0x140A + + ACCUM = 0x0100 + LOAD = 0x0101 + RETURN = 0x0102 + MULT = 0x0103 + ADD = 0x0104 + + ACCUM_BUFFER_BIT = 0x00000200 + ALL_ATTRIB_BITS = 0xFFFFFFFF + COLOR_BUFFER_BIT = 0x00004000 + CURRENT_BIT = 0x00000001 + DEPTH_BUFFER_BIT = 0x00000100 + ENABLE_BIT = 0x00002000 + EVAL_BIT = 0x00010000 + FOG_BIT = 0x00000080 + HINT_BIT = 0x00008000 + LIGHTING_BIT = 0x00000040 + LINE_BIT = 0x00000004 + LIST_BIT = 0x00020000 + MULTISAMPLE_BIT = 0x20000000 + PIXEL_MODE_BIT = 0x00000020 + POINT_BIT = 0x00000002 + POLYGON_BIT = 0x00000008 + POLYGON_STIPPLE_BIT = 0x00000010 + SCISSOR_BIT = 0x00080000 + STENCIL_BUFFER_BIT = 0x00000400 + TEXTURE_BIT = 0x00040000 + TRANSFORM_BIT = 0x00001000 + VIEWPORT_BIT = 0x00000800 + + ALWAYS = 0x0207 + EQUAL = 0x0202 + GEQUAL = 0x0206 + GREATER = 0x0204 + LEQUAL = 0x0203 + LESS = 0x0201 + NEVER = 0x0200 + NOTEQUAL = 0x0205 + + LOGIC_OP = 0x0BF1 + + DST_ALPHA = 0x0304 + ONE = 1 + ONE_MINUS_DST_ALPHA = 0x0305 + ONE_MINUS_SRC_ALPHA = 0x0303 + ONE_MINUS_SRC_COLOR = 0x0301 + SRC_ALPHA = 0x0302 + SRC_COLOR = 0x0300 + ZERO = 0 + + DST_COLOR = 0x0306 + ONE_MINUS_DST_COLOR = 0x0307 + SRC_ALPHA_SATURATE = 0x0308 + + CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF + CLIENT_PIXEL_STORE_BIT = 0x00000001 + CLIENT_VERTEX_ARRAY_BIT = 0x00000002 + + CLIP_PLANE0 = 0x3000 + CLIP_PLANE1 = 0x3001 + CLIP_PLANE2 = 0x3002 + CLIP_PLANE3 = 0x3003 + CLIP_PLANE4 = 0x3004 + CLIP_PLANE5 = 0x3005 + + BACK = 0x0405 + FRONT = 0x0404 + FRONT_AND_BACK = 0x0408 + + AMBIENT = 0x1200 + AMBIENT_AND_DIFFUSE = 0x1602 + DIFFUSE = 0x1201 + EMISSION = 0x1600 + SPECULAR = 0x1202 + + AUX0 = 0x0409 + AUX1 = 0x040A + AUX2 = 0x040B + AUX3 = 0x040C + BACK_LEFT = 0x0402 + BACK_RIGHT = 0x0403 + FRONT_LEFT = 0x0400 + FRONT_RIGHT = 0x0401 + LEFT = 0x0406 + RIGHT = 0x0407 + + ALPHA_TEST = 0x0BC0 + AUTO_NORMAL = 0x0D80 + BLEND = 0x0BE2 + COLOR_ARRAY = 0x8076 + COLOR_LOGIC_OP = 0x0BF2 + COLOR_MATERIAL = 0x0B57 + CULL_FACE = 0x0B44 + DEPTH_TEST = 0x0B71 + DITHER = 0x0BD0 + EDGE_FLAG_ARRAY = 0x8079 + FOG = 0x0B60 + INDEX_ARRAY = 0x8077 + INDEX_LOGIC_OP = 0x0BF1 + LIGHT0 = 0x4000 + LIGHT1 = 0x4001 + LIGHT2 = 0x4002 + LIGHT3 = 0x4003 + LIGHT4 = 0x4004 + LIGHT5 = 0x4005 + LIGHT6 = 0x4006 + LIGHT7 = 0x4007 + LIGHTING = 0x0B50 + LINE_SMOOTH = 0x0B20 + LINE_STIPPLE = 0x0B24 + MAP1_COLOR_4 = 0x0D90 + MAP1_INDEX = 0x0D91 + MAP1_NORMAL = 0x0D92 + MAP1_TEXTURE_COORD_1 = 0x0D93 + MAP1_TEXTURE_COORD_2 = 0x0D94 + MAP1_TEXTURE_COORD_3 = 0x0D95 + MAP1_TEXTURE_COORD_4 = 0x0D96 + MAP1_VERTEX_3 = 0x0D97 + MAP1_VERTEX_4 = 0x0D98 + MAP2_COLOR_4 = 0x0DB0 + MAP2_INDEX = 0x0DB1 + MAP2_NORMAL = 0x0DB2 + MAP2_TEXTURE_COORD_1 = 0x0DB3 + MAP2_TEXTURE_COORD_2 = 0x0DB4 + MAP2_TEXTURE_COORD_3 = 0x0DB5 + MAP2_TEXTURE_COORD_4 = 0x0DB6 + MAP2_VERTEX_3 = 0x0DB7 + MAP2_VERTEX_4 = 0x0DB8 + NORMALIZE = 0x0BA1 + NORMAL_ARRAY = 0x8075 + POINT_SMOOTH = 0x0B10 + POLYGON_OFFSET_FILL = 0x8037 + POLYGON_OFFSET_LINE = 0x2A02 + POLYGON_OFFSET_POINT = 0x2A01 + POLYGON_SMOOTH = 0x0B41 + POLYGON_STIPPLE = 0x0B42 + SCISSOR_TEST = 0x0C11 + STENCIL_TEST = 0x0B90 + TEXTURE_1D = 0x0DE0 + TEXTURE_2D = 0x0DE1 + TEXTURE_COORD_ARRAY = 0x8078 + TEXTURE_GEN_Q = 0x0C63 + TEXTURE_GEN_R = 0x0C62 + TEXTURE_GEN_S = 0x0C60 + TEXTURE_GEN_T = 0x0C61 + VERTEX_ARRAY = 0x8074 + + INVALID_ENUM = 0x0500 + INVALID_OPERATION = 0x0502 + INVALID_VALUE = 0x0501 + NO_ERROR = 0 + OUT_OF_MEMORY = 0x0505 + STACK_OVERFLOW = 0x0503 + STACK_UNDERFLOW = 0x0504 + + N2D = 0x0600 + N3D = 0x0601 + N3D_COLOR = 0x0602 + N3D_COLOR_TEXTURE = 0x0603 + N4D_COLOR_TEXTURE = 0x0604 + + BITMAP_TOKEN = 0x0704 + COPY_PIXEL_TOKEN = 0x0706 + DRAW_PIXEL_TOKEN = 0x0705 + LINE_RESET_TOKEN = 0x0707 + LINE_TOKEN = 0x0702 + PASS_THROUGH_TOKEN = 0x0700 + POINT_TOKEN = 0x0701 + POLYGON_TOKEN = 0x0703 + + EXP = 0x0800 + EXP2 = 0x0801 + LINEAR = 0x2601 + + FOG_COLOR = 0x0B66 + FOG_DENSITY = 0x0B62 + FOG_END = 0x0B64 + FOG_INDEX = 0x0B61 + FOG_MODE = 0x0B65 + FOG_START = 0x0B63 + + CCW = 0x0901 + CW = 0x0900 + + COEFF = 0x0A00 + DOMAIN = 0x0A02 + ORDER = 0x0A01 + + PIXEL_MAP_A_TO_A = 0x0C79 + PIXEL_MAP_B_TO_B = 0x0C78 + PIXEL_MAP_G_TO_G = 0x0C77 + PIXEL_MAP_I_TO_A = 0x0C75 + PIXEL_MAP_I_TO_B = 0x0C74 + PIXEL_MAP_I_TO_G = 0x0C73 + PIXEL_MAP_I_TO_I = 0x0C70 + PIXEL_MAP_I_TO_R = 0x0C72 + PIXEL_MAP_R_TO_R = 0x0C76 + PIXEL_MAP_S_TO_S = 0x0C71 + + ACCUM_ALPHA_BITS = 0x0D5B + ACCUM_BLUE_BITS = 0x0D5A + ACCUM_CLEAR_VALUE = 0x0B80 + ACCUM_GREEN_BITS = 0x0D59 + ACCUM_RED_BITS = 0x0D58 + ALIASED_LINE_WIDTH_RANGE = 0x846E + ALIASED_POINT_SIZE_RANGE = 0x846D + ALPHA_BIAS = 0x0D1D + ALPHA_BITS = 0x0D55 + ALPHA_SCALE = 0x0D1C + ALPHA_TEST_FUNC = 0x0BC1 + ALPHA_TEST_REF = 0x0BC2 + ATTRIB_STACK_DEPTH = 0x0BB0 + AUX_BUFFERS = 0x0C00 + BLEND_DST = 0x0BE0 + BLEND_SRC = 0x0BE1 + BLUE_BIAS = 0x0D1B + BLUE_BITS = 0x0D54 + BLUE_SCALE = 0x0D1A + CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1 + COLOR_ARRAY_SIZE = 0x8081 + COLOR_ARRAY_STRIDE = 0x8083 + COLOR_ARRAY_TYPE = 0x8082 + COLOR_CLEAR_VALUE = 0x0C22 + COLOR_MATERIAL_FACE = 0x0B55 + COLOR_MATERIAL_PARAMETER = 0x0B56 + COLOR_WRITEMASK = 0x0C23 + CULL_FACE_MODE = 0x0B45 + CURRENT_COLOR = 0x0B00 + CURRENT_INDEX = 0x0B01 + CURRENT_NORMAL = 0x0B02 + CURRENT_RASTER_COLOR = 0x0B04 + CURRENT_RASTER_DISTANCE = 0x0B09 + CURRENT_RASTER_INDEX = 0x0B05 + CURRENT_RASTER_POSITION = 0x0B07 + CURRENT_RASTER_POSITION_VALID = 0x0B08 + CURRENT_RASTER_TEXTURE_COORDS = 0x0B06 + CURRENT_TEXTURE_COORDS = 0x0B03 + DEPTH_BIAS = 0x0D1F + DEPTH_BITS = 0x0D56 + DEPTH_CLEAR_VALUE = 0x0B73 + DEPTH_FUNC = 0x0B74 + DEPTH_RANGE = 0x0B70 + DEPTH_SCALE = 0x0D1E + DEPTH_WRITEMASK = 0x0B72 + DOUBLEBUFFER = 0x0C32 + DRAW_BUFFER = 0x0C01 + EDGE_FLAG = 0x0B43 + EDGE_FLAG_ARRAY_STRIDE = 0x808C + FEEDBACK_BUFFER_SIZE = 0x0DF1 + FEEDBACK_BUFFER_TYPE = 0x0DF2 + FOG_HINT = 0x0C54 + FRONT_FACE = 0x0B46 + GREEN_BIAS = 0x0D19 + GREEN_BITS = 0x0D53 + GREEN_SCALE = 0x0D18 + INDEX_ARRAY_STRIDE = 0x8086 + INDEX_ARRAY_TYPE = 0x8085 + INDEX_BITS = 0x0D51 + INDEX_CLEAR_VALUE = 0x0C20 + INDEX_MODE = 0x0C30 + INDEX_OFFSET = 0x0D13 + INDEX_SHIFT = 0x0D12 + INDEX_WRITEMASK = 0x0C21 + LIGHT_MODEL_AMBIENT = 0x0B53 + LIGHT_MODEL_COLOR_CONTROL = 0x81F8 + LIGHT_MODEL_LOCAL_VIEWER = 0x0B51 + LIGHT_MODEL_TWO_SIDE = 0x0B52 + LINE_SMOOTH_HINT = 0x0C52 + LINE_STIPPLE_PATTERN = 0x0B25 + LINE_STIPPLE_REPEAT = 0x0B26 + LINE_WIDTH = 0x0B21 + LINE_WIDTH_GRANULARITY = 0x0B23 + LINE_WIDTH_RANGE = 0x0B22 + LIST_BASE = 0x0B32 + LIST_INDEX = 0x0B33 + LIST_MODE = 0x0B30 + LOGIC_OP_MODE = 0x0BF0 + MAP1_GRID_DOMAIN = 0x0DD0 + MAP1_GRID_SEGMENTS = 0x0DD1 + MAP2_GRID_DOMAIN = 0x0DD2 + MAP2_GRID_SEGMENTS = 0x0DD3 + MAP_COLOR = 0x0D10 + MAP_STENCIL = 0x0D11 + MATRIX_MODE = 0x0BA0 + MAX_ATTRIB_STACK_DEPTH = 0x0D35 + MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B + MAX_CLIP_PLANES = 0x0D32 + MAX_EVAL_ORDER = 0x0D30 + MAX_LIGHTS = 0x0D31 + MAX_LIST_NESTING = 0x0B31 + MAX_MODELVIEW_STACK_DEPTH = 0x0D36 + MAX_NAME_STACK_DEPTH = 0x0D37 + MAX_PIXEL_MAP_TABLE = 0x0D34 + MAX_PROJECTION_STACK_DEPTH = 0x0D38 + MAX_TEXTURE_SIZE = 0x0D33 + MAX_TEXTURE_STACK_DEPTH = 0x0D39 + MAX_VIEWPORT_DIMS = 0x0D3A + MODELVIEW_MATRIX = 0x0BA6 + MODELVIEW_STACK_DEPTH = 0x0BA3 + NAME_STACK_DEPTH = 0x0D70 + NORMAL_ARRAY_STRIDE = 0x807F + NORMAL_ARRAY_TYPE = 0x807E + PACK_ALIGNMENT = 0x0D05 + PACK_LSB_FIRST = 0x0D01 + PACK_ROW_LENGTH = 0x0D02 + PACK_SKIP_PIXELS = 0x0D04 + PACK_SKIP_ROWS = 0x0D03 + PACK_SWAP_BYTES = 0x0D00 + PERSPECTIVE_CORRECTION_HINT = 0x0C50 + PIXEL_MAP_A_TO_A_SIZE = 0x0CB9 + PIXEL_MAP_B_TO_B_SIZE = 0x0CB8 + PIXEL_MAP_G_TO_G_SIZE = 0x0CB7 + PIXEL_MAP_I_TO_A_SIZE = 0x0CB5 + PIXEL_MAP_I_TO_B_SIZE = 0x0CB4 + PIXEL_MAP_I_TO_G_SIZE = 0x0CB3 + PIXEL_MAP_I_TO_I_SIZE = 0x0CB0 + PIXEL_MAP_I_TO_R_SIZE = 0x0CB2 + PIXEL_MAP_R_TO_R_SIZE = 0x0CB6 + PIXEL_MAP_S_TO_S_SIZE = 0x0CB1 + POINT_SIZE = 0x0B11 + POINT_SIZE_GRANULARITY = 0x0B13 + POINT_SIZE_RANGE = 0x0B12 + POINT_SMOOTH_HINT = 0x0C51 + POLYGON_MODE = 0x0B40 + POLYGON_OFFSET_FACTOR = 0x8038 + POLYGON_OFFSET_UNITS = 0x2A00 + POLYGON_SMOOTH_HINT = 0x0C53 + PROJECTION_MATRIX = 0x0BA7 + PROJECTION_STACK_DEPTH = 0x0BA4 + READ_BUFFER = 0x0C02 + RED_BIAS = 0x0D15 + RED_BITS = 0x0D52 + RED_SCALE = 0x0D14 + RENDER_MODE = 0x0C40 + RGBA_MODE = 0x0C31 + SCISSOR_BOX = 0x0C10 + SELECTION_BUFFER_SIZE = 0x0DF4 + SHADE_MODEL = 0x0B54 + SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23 + SMOOTH_LINE_WIDTH_RANGE = 0x0B22 + SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13 + SMOOTH_POINT_SIZE_RANGE = 0x0B12 + STENCIL_BITS = 0x0D57 + STENCIL_CLEAR_VALUE = 0x0B91 + STENCIL_FAIL = 0x0B94 + STENCIL_FUNC = 0x0B92 + STENCIL_PASS_DEPTH_FAIL = 0x0B95 + STENCIL_PASS_DEPTH_PASS = 0x0B96 + STENCIL_REF = 0x0B97 + STENCIL_VALUE_MASK = 0x0B93 + STENCIL_WRITEMASK = 0x0B98 + STEREO = 0x0C33 + SUBPIXEL_BITS = 0x0D50 + TEXTURE_BINDING_1D = 0x8068 + TEXTURE_BINDING_2D = 0x8069 + TEXTURE_BINDING_3D = 0x806A + TEXTURE_COORD_ARRAY_SIZE = 0x8088 + TEXTURE_COORD_ARRAY_STRIDE = 0x808A + TEXTURE_COORD_ARRAY_TYPE = 0x8089 + TEXTURE_MATRIX = 0x0BA8 + TEXTURE_STACK_DEPTH = 0x0BA5 + UNPACK_ALIGNMENT = 0x0CF5 + UNPACK_LSB_FIRST = 0x0CF1 + UNPACK_ROW_LENGTH = 0x0CF2 + UNPACK_SKIP_PIXELS = 0x0CF4 + UNPACK_SKIP_ROWS = 0x0CF3 + UNPACK_SWAP_BYTES = 0x0CF0 + VERTEX_ARRAY_SIZE = 0x807A + VERTEX_ARRAY_STRIDE = 0x807C + VERTEX_ARRAY_TYPE = 0x807B + VIEWPORT = 0x0BA2 + ZOOM_X = 0x0D16 + ZOOM_Y = 0x0D17 + + COLOR_ARRAY_POINTER = 0x8090 + EDGE_FLAG_ARRAY_POINTER = 0x8093 + FEEDBACK_BUFFER_POINTER = 0x0DF0 + INDEX_ARRAY_POINTER = 0x8091 + NORMAL_ARRAY_POINTER = 0x808F + SELECTION_BUFFER_POINTER = 0x0DF3 + TEXTURE_COORD_ARRAY_POINTER = 0x8092 + VERTEX_ARRAY_POINTER = 0x808E + + TEXTURE_ALPHA_SIZE = 0x805F + TEXTURE_BLUE_SIZE = 0x805E + TEXTURE_BORDER = 0x1005 + TEXTURE_BORDER_COLOR = 0x1004 + TEXTURE_COMPONENTS = 0x1003 + TEXTURE_GREEN_SIZE = 0x805D + TEXTURE_HEIGHT = 0x1001 + TEXTURE_INTENSITY_SIZE = 0x8061 + TEXTURE_INTERNAL_FORMAT = 0x1003 + TEXTURE_LUMINANCE_SIZE = 0x8060 + TEXTURE_MAG_FILTER = 0x2800 + TEXTURE_MIN_FILTER = 0x2801 + TEXTURE_PRIORITY = 0x8066 + TEXTURE_RED_SIZE = 0x805C + TEXTURE_RESIDENT = 0x8067 + TEXTURE_WIDTH = 0x1000 + TEXTURE_WRAP_S = 0x2802 + TEXTURE_WRAP_T = 0x2803 + + DONT_CARE = 0x1100 + FASTEST = 0x1101 + NICEST = 0x1102 + + TEXTURE_COMPRESSION_HINT = 0x84EF + + C3F_V3F = 0x2A24 + C4F_N3F_V3F = 0x2A26 + C4UB_V2F = 0x2A22 + C4UB_V3F = 0x2A23 + N3F_V3F = 0x2A25 + T2F_C3F_V3F = 0x2A2A + T2F_C4F_N3F_V3F = 0x2A2C + T2F_C4UB_V3F = 0x2A29 + T2F_N3F_V3F = 0x2A2B + T2F_V3F = 0x2A27 + T4F_C4F_N3F_V4F = 0x2A2D + T4F_V4F = 0x2A28 + V2F = 0x2A20 + V3F = 0x2A21 + + MODULATE = 0x2100 + REPLACE = 0x1E01 + + SEPARATE_SPECULAR_COLOR = 0x81FA + SINGLE_COLOR = 0x81F9 + + CONSTANT_ATTENUATION = 0x1207 + LINEAR_ATTENUATION = 0x1208 + POSITION = 0x1203 + QUADRATIC_ATTENUATION = 0x1209 + SPOT_CUTOFF = 0x1206 + SPOT_DIRECTION = 0x1204 + SPOT_EXPONENT = 0x1205 + + COMPILE = 0x1300 + COMPILE_AND_EXECUTE = 0x1301 + + AND = 0x1501 + AND_INVERTED = 0x1504 + AND_REVERSE = 0x1502 + CLEAR = 0x1500 + COPY = 0x1503 + COPY_INVERTED = 0x150C + EQUIV = 0x1509 + INVERT = 0x150A + NAND = 0x150E + NOOP = 0x1505 + NOR = 0x1508 + OR = 0x1507 + OR_INVERTED = 0x150D + OR_REVERSE = 0x150B + SET = 0x150F + XOR = 0x1506 + + COLOR_INDEXES = 0x1603 + SHININESS = 0x1601 + + MODELVIEW = 0x1700 + PROJECTION = 0x1701 + TEXTURE = 0x1702 + + LINE = 0x1B01 + POINT = 0x1B00 + + FILL = 0x1B02 + + COLOR = 0x1800 + DEPTH = 0x1801 + STENCIL = 0x1802 + + ALPHA = 0x1906 + BLUE = 0x1905 + COLOR_INDEX = 0x1900 + DEPTH_COMPONENT = 0x1902 + GREEN = 0x1904 + LUMINANCE = 0x1909 + LUMINANCE_ALPHA = 0x190A + RED = 0x1903 + RGB = 0x1907 + RGBA = 0x1908 + STENCIL_INDEX = 0x1901 + + ALPHA12 = 0x803D + ALPHA16 = 0x803E + ALPHA4 = 0x803B + ALPHA8 = 0x803C + INTENSITY = 0x8049 + INTENSITY12 = 0x804C + INTENSITY16 = 0x804D + INTENSITY4 = 0x804A + INTENSITY8 = 0x804B + LUMINANCE12 = 0x8041 + LUMINANCE12_ALPHA12 = 0x8047 + LUMINANCE12_ALPHA4 = 0x8046 + LUMINANCE16 = 0x8042 + LUMINANCE16_ALPHA16 = 0x8048 + LUMINANCE4 = 0x803F + LUMINANCE4_ALPHA4 = 0x8043 + LUMINANCE6_ALPHA2 = 0x8044 + LUMINANCE8 = 0x8040 + LUMINANCE8_ALPHA8 = 0x8045 + R3_G3_B2 = 0x2A10 + RGB10 = 0x8052 + RGB10_A2 = 0x8059 + RGB12 = 0x8053 + RGB16 = 0x8054 + RGB4 = 0x804F + RGB5 = 0x8050 + RGB5_A1 = 0x8057 + RGB8 = 0x8051 + RGBA12 = 0x805A + RGBA16 = 0x805B + RGBA2 = 0x8055 + RGBA4 = 0x8056 + RGBA8 = 0x8058 + + PACK_IMAGE_HEIGHT = 0x806C + PACK_SKIP_IMAGES = 0x806B + UNPACK_IMAGE_HEIGHT = 0x806E + UNPACK_SKIP_IMAGES = 0x806D + + BITMAP = 0x1A00 + UNSIGNED_BYTE_3_3_2 = 0x8032 + UNSIGNED_INT_10_10_10_2 = 0x8036 + UNSIGNED_INT_8_8_8_8 = 0x8035 + UNSIGNED_SHORT_4_4_4_4 = 0x8033 + UNSIGNED_SHORT_5_5_5_1 = 0x8034 + + LINES = 0x0001 + LINE_LOOP = 0x0002 + LINE_STRIP = 0x0003 + POINTS = 0x0000 + POLYGON = 0x0009 + QUADS = 0x0007 + QUAD_STRIP = 0x0008 + TRIANGLES = 0x0004 + TRIANGLE_FAN = 0x0006 + TRIANGLE_STRIP = 0x0005 + + FEEDBACK = 0x1C01 + RENDER = 0x1C00 + SELECT = 0x1C02 + + FLAT = 0x1D00 + SMOOTH = 0x1D01 + + DECR = 0x1E03 + INCR = 0x1E02 + KEEP = 0x1E00 + + EXTENSIONS = 0x1F03 + RENDERER = 0x1F01 + VENDOR = 0x1F00 + VERSION = 0x1F02 + + S = 0x2000 + T = 0x2001 + R = 0x2002 + Q = 0x2003 + + DECAL = 0x2101 + + TEXTURE_ENV_COLOR = 0x2201 + TEXTURE_ENV_MODE = 0x2200 + + TEXTURE_ENV = 0x2300 + + EYE_LINEAR = 0x2400 + OBJECT_LINEAR = 0x2401 + SPHERE_MAP = 0x2402 + + EYE_PLANE = 0x2502 + OBJECT_PLANE = 0x2501 + TEXTURE_GEN_MODE = 0x2500 + + NEAREST = 0x2600 + + LINEAR_MIPMAP_LINEAR = 0x2703 + LINEAR_MIPMAP_NEAREST = 0x2701 + NEAREST_MIPMAP_LINEAR = 0x2702 + NEAREST_MIPMAP_NEAREST = 0x2700 + + TEXTURE_WRAP_R = 0x8072 + + PROXY_TEXTURE_1D = 0x8063 + PROXY_TEXTURE_2D = 0x8064 + PROXY_TEXTURE_3D = 0x8070 + TEXTURE_3D = 0x806F + TEXTURE_BASE_LEVEL = 0x813C + TEXTURE_MAX_LEVEL = 0x813D + TEXTURE_MAX_LOD = 0x813B + TEXTURE_MIN_LOD = 0x813A + + CLAMP = 0x2900 + CLAMP_TO_BORDER = 0x812D + CLAMP_TO_EDGE = 0x812F + REPEAT = 0x2901 + + RESCALE_NORMAL = 0x803A + TEXTURE_DEPTH = 0x8071 + MAX_3D_TEXTURE_SIZE = 0x8073 + MULTISAMPLE = 0x809D + SAMPLE_ALPHA_TO_COVERAGE = 0x809E + SAMPLE_ALPHA_TO_ONE = 0x809F + SAMPLE_COVERAGE = 0x80A0 + SAMPLE_BUFFERS = 0x80A8 + SAMPLES = 0x80A9 + SAMPLE_COVERAGE_VALUE = 0x80AA + SAMPLE_COVERAGE_INVERT = 0x80AB + BGR = 0x80E0 + BGRA = 0x80E1 + MAX_ELEMENTS_VERTICES = 0x80E8 + MAX_ELEMENTS_INDICES = 0x80E9 + UNSIGNED_BYTE_2_3_3_REV = 0x8362 + UNSIGNED_SHORT_5_6_5 = 0x8363 + UNSIGNED_SHORT_5_6_5_REV = 0x8364 + UNSIGNED_SHORT_4_4_4_4_REV = 0x8365 + UNSIGNED_SHORT_1_5_5_5_REV = 0x8366 + UNSIGNED_INT_8_8_8_8_REV = 0x8367 + UNSIGNED_INT_2_10_10_10_REV = 0x8368 + TEXTURE0 = 0x84C0 + TEXTURE1 = 0x84C1 + TEXTURE2 = 0x84C2 + TEXTURE3 = 0x84C3 + TEXTURE4 = 0x84C4 + TEXTURE5 = 0x84C5 + TEXTURE6 = 0x84C6 + TEXTURE7 = 0x84C7 + TEXTURE8 = 0x84C8 + TEXTURE9 = 0x84C9 + TEXTURE10 = 0x84CA + TEXTURE11 = 0x84CB + TEXTURE12 = 0x84CC + TEXTURE13 = 0x84CD + TEXTURE14 = 0x84CE + TEXTURE15 = 0x84CF + TEXTURE16 = 0x84D0 + TEXTURE17 = 0x84D1 + TEXTURE18 = 0x84D2 + TEXTURE19 = 0x84D3 + TEXTURE20 = 0x84D4 + TEXTURE21 = 0x84D5 + TEXTURE22 = 0x84D6 + TEXTURE23 = 0x84D7 + TEXTURE24 = 0x84D8 + TEXTURE25 = 0x84D9 + TEXTURE26 = 0x84DA + TEXTURE27 = 0x84DB + TEXTURE28 = 0x84DC + TEXTURE29 = 0x84DD + TEXTURE30 = 0x84DE + TEXTURE31 = 0x84DF + ACTIVE_TEXTURE = 0x84E0 + CLIENT_ACTIVE_TEXTURE = 0x84E1 + MAX_TEXTURE_UNITS = 0x84E2 + TRANSPOSE_MODELVIEW_MATRIX = 0x84E3 + TRANSPOSE_PROJECTION_MATRIX = 0x84E4 + TRANSPOSE_TEXTURE_MATRIX = 0x84E5 + TRANSPOSE_COLOR_MATRIX = 0x84E6 + SUBTRACT = 0x84E7 + COMPRESSED_ALPHA = 0x84E9 + COMPRESSED_LUMINANCE = 0x84EA + COMPRESSED_LUMINANCE_ALPHA = 0x84EB + COMPRESSED_INTENSITY = 0x84EC + COMPRESSED_RGB = 0x84ED + COMPRESSED_RGBA = 0x84EE + NORMAL_MAP = 0x8511 + REFLECTION_MAP = 0x8512 + TEXTURE_CUBE_MAP = 0x8513 + TEXTURE_BINDING_CUBE_MAP = 0x8514 + TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515 + TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516 + TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517 + TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518 + TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519 + TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A + PROXY_TEXTURE_CUBE_MAP = 0x851B + MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C + COMBINE = 0x8570 + COMBINE_RGB = 0x8571 + COMBINE_ALPHA = 0x8572 + RGB_SCALE = 0x8573 + ADD_SIGNED = 0x8574 + INTERPOLATE = 0x8575 + CONSTANT = 0x8576 + PRIMARY_COLOR = 0x8577 + PREVIOUS = 0x8578 + SOURCE0_RGB = 0x8580 + SOURCE1_RGB = 0x8581 + SOURCE2_RGB = 0x8582 + SOURCE0_ALPHA = 0x8588 + SOURCE1_ALPHA = 0x8589 + SOURCE2_ALPHA = 0x858A + OPERAND0_RGB = 0x8590 + OPERAND1_RGB = 0x8591 + OPERAND2_RGB = 0x8592 + OPERAND0_ALPHA = 0x8598 + OPERAND1_ALPHA = 0x8599 + OPERAND2_ALPHA = 0x859A + TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0 + TEXTURE_COMPRESSED = 0x86A1 + NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2 + COMPRESSED_TEXTURE_FORMATS = 0x86A3 + DOT3_RGB = 0x86AE + DOT3_RGBA = 0x86AF +) + +// https://www.opengl.org/sdk/docs/man2/xhtml/glViewport.xml +func (gl *GL) Viewport(x, y, width, height int) { + C.gl1_3_glViewport(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// DepthRange specifies the mapping of depth values from normalized device +// coordinates to window coordinates. +// +// Parameter nearVal specifies the mapping of the near clipping plane to window +// coordinates (defaults to 0), while farVal specifies the mapping of the far +// clipping plane to window coordinates (defaults to 1). +// +// After clipping and division by w, depth coordinates range from -1 to 1, +// corresponding to the near and far clipping planes. DepthRange specifies a +// linear mapping of the normalized depth coordinates in this range to window +// depth coordinates. Regardless of the actual depth buffer implementation, +// window coordinate depth values are treated as though they range from 0 through 1 +// (like color components). Thus, the values accepted by DepthRange are both +// clamped to this range before they are accepted. +// +// The default setting of (0, 1) maps the near plane to 0 and the far plane to 1. +// With this mapping, the depth buffer range is fully utilized. +// +// It is not necessary that nearVal be less than farVal. Reverse mappings such as +// nearVal 1, and farVal 0 are acceptable. +// +// GL.INVALID_OPERATION is generated if DepthRange is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) DepthRange(nearVal, farVal float64) { + C.gl1_3_glDepthRange(gl.funcs, C.GLdouble(nearVal), C.GLdouble(farVal)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsEnabled.xml +func (gl *GL) IsEnabled(cap glbase.Enum) bool { + glresult := C.gl1_3_glIsEnabled(gl.funcs, C.GLenum(cap)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexLevelParameteriv.xml +func (gl *GL) GetTexLevelParameteriv(target glbase.Enum, level int, pname glbase.Enum, params []int32) { + C.gl1_3_glGetTexLevelParameteriv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexLevelParameterfv.xml +func (gl *GL) GetTexLevelParameterfv(target glbase.Enum, level int, pname glbase.Enum, params []float32) { + C.gl1_3_glGetTexLevelParameterfv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexParameteriv.xml +func (gl *GL) GetTexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_3_glGetTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexParameterfv.xml +func (gl *GL) GetTexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_3_glGetTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexImage.xml +func (gl *GL) GetTexImage(target glbase.Enum, level int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glGetTexImage(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetIntegerv.xml +func (gl *GL) GetIntegerv(pname glbase.Enum, params []int32) { + C.gl1_3_glGetIntegerv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetFloatv.xml +func (gl *GL) GetFloatv(pname glbase.Enum, params []float32) { + C.gl1_3_glGetFloatv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetError.xml +func (gl *GL) GetError() glbase.Enum { + glresult := C.gl1_3_glGetError(gl.funcs) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetDoublev.xml +func (gl *GL) GetDoublev(pname glbase.Enum, params []float64) { + C.gl1_3_glGetDoublev(gl.funcs, C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetBooleanv.xml +func (gl *GL) GetBooleanv(pname glbase.Enum, params []bool) { + C.gl1_3_glGetBooleanv(gl.funcs, C.GLenum(pname), (*C.GLboolean)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glReadPixels.xml +func (gl *GL) ReadPixels(x, y, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glReadPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glReadBuffer.xml +func (gl *GL) ReadBuffer(mode glbase.Enum) { + C.gl1_3_glReadBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelStorei.xml +func (gl *GL) PixelStorei(pname glbase.Enum, param int32) { + C.gl1_3_glPixelStorei(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelStoref.xml +func (gl *GL) PixelStoref(pname glbase.Enum, param float32) { + C.gl1_3_glPixelStoref(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDepthFunc.xml +func (gl *GL) DepthFunc(glfunc glbase.Enum) { + C.gl1_3_glDepthFunc(gl.funcs, C.GLenum(glfunc)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilOp.xml +func (gl *GL) StencilOp(fail, zfail, zpass glbase.Enum) { + C.gl1_3_glStencilOp(gl.funcs, C.GLenum(fail), C.GLenum(zfail), C.GLenum(zpass)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilFunc.xml +func (gl *GL) StencilFunc(glfunc glbase.Enum, ref int32, mask uint32) { + C.gl1_3_glStencilFunc(gl.funcs, C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLogicOp.xml +func (gl *GL) LogicOp(opcode glbase.Enum) { + C.gl1_3_glLogicOp(gl.funcs, C.GLenum(opcode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBlendFunc.xml +func (gl *GL) BlendFunc(sfactor, dfactor glbase.Enum) { + C.gl1_3_glBlendFunc(gl.funcs, C.GLenum(sfactor), C.GLenum(dfactor)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFlush.xml +func (gl *GL) Flush() { + C.gl1_3_glFlush(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFinish.xml +func (gl *GL) Finish() { + C.gl1_3_glFinish(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEnable.xml +func (gl *GL) Enable(cap glbase.Enum) { + C.gl1_3_glEnable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDisable.xml +func (gl *GL) Disable(cap glbase.Enum) { + C.gl1_3_glDisable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDepthMask.xml +func (gl *GL) DepthMask(flag bool) { + C.gl1_3_glDepthMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorMask.xml +func (gl *GL) ColorMask(red, green, blue, alpha bool) { + C.gl1_3_glColorMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&red)), *(*C.GLboolean)(unsafe.Pointer(&green)), *(*C.GLboolean)(unsafe.Pointer(&blue)), *(*C.GLboolean)(unsafe.Pointer(&alpha))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilMask.xml +func (gl *GL) StencilMask(mask uint32) { + C.gl1_3_glStencilMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearDepth.xml +func (gl *GL) ClearDepth(depth float64) { + C.gl1_3_glClearDepth(gl.funcs, C.GLdouble(depth)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearStencil.xml +func (gl *GL) ClearStencil(s int32) { + C.gl1_3_glClearStencil(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearColor.xml +func (gl *GL) ClearColor(red, green, blue, alpha float32) { + C.gl1_3_glClearColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClear.xml +func (gl *GL) Clear(mask glbase.Bitfield) { + C.gl1_3_glClear(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawBuffer.xml +func (gl *GL) DrawBuffer(mode glbase.Enum) { + C.gl1_3_glDrawBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexImage2D.xml +func (gl *GL) TexImage2D(target glbase.Enum, level int, internalFormat int32, width, height, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexImage1D.xml +func (gl *GL) TexImage1D(target glbase.Enum, level int, internalFormat int32, width, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameteriv.xml +func (gl *GL) TexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_3_glTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameteri.xml +func (gl *GL) TexParameteri(target, pname glbase.Enum, param int32) { + C.gl1_3_glTexParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameterfv.xml +func (gl *GL) TexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_3_glTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameterf.xml +func (gl *GL) TexParameterf(target, pname glbase.Enum, param float32) { + C.gl1_3_glTexParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glScissor.xml +func (gl *GL) Scissor(x, y, width, height int) { + C.gl1_3_glScissor(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPolygonMode.xml +func (gl *GL) PolygonMode(face, mode glbase.Enum) { + C.gl1_3_glPolygonMode(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPointSize.xml +func (gl *GL) PointSize(size float32) { + C.gl1_3_glPointSize(gl.funcs, C.GLfloat(size)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLineWidth.xml +func (gl *GL) LineWidth(width float32) { + C.gl1_3_glLineWidth(gl.funcs, C.GLfloat(width)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glHint.xml +func (gl *GL) Hint(target, mode glbase.Enum) { + C.gl1_3_glHint(gl.funcs, C.GLenum(target), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFrontFace.xml +func (gl *GL) FrontFace(mode glbase.Enum) { + C.gl1_3_glFrontFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCullFace.xml +func (gl *GL) CullFace(mode glbase.Enum) { + C.gl1_3_glCullFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexubv.xml +func (gl *GL) Indexubv(c []uint8) { + C.gl1_3_glIndexubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexub.xml +func (gl *GL) Indexub(c uint8) { + C.gl1_3_glIndexub(gl.funcs, C.GLubyte(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsTexture.xml +func (gl *GL) IsTexture(texture glbase.Texture) bool { + glresult := C.gl1_3_glIsTexture(gl.funcs, C.GLuint(texture)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenTextures returns n texture names in textures. There is no guarantee +// that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenTextures. +// +// The generated textures have no dimensionality; they assume the +// dimensionality of the texture target to which they are first bound (see +// BindTexture). +// +// Texture names returned by a call to GenTextures are not returned by +// subsequent calls, unless they are first deleted with DeleteTextures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenTextures is available in GL version 2.0 or greater. +func (gl *GL) GenTextures(n int) []glbase.Texture { + if n == 0 { + return nil + } + textures := make([]glbase.Texture, n) + C.gl1_3_glGenTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) + return textures +} + +// DeleteTextures deletes the textures objects whose names are stored +// in the textures slice. After a texture is deleted, it has no contents or +// dimensionality, and its name is free for reuse (for example by +// GenTextures). If a texture that is currently bound is deleted, the binding +// reverts to 0 (the default texture). +// +// DeleteTextures silently ignores 0's and names that do not correspond to +// existing textures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteTextures is available in GL version 2.0 or greater. +func (gl *GL) DeleteTextures(textures []glbase.Texture) { + n := len(textures) + if n == 0 { + return + } + C.gl1_3_glDeleteTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBindTexture.xml +func (gl *GL) BindTexture(target glbase.Enum, texture glbase.Texture) { + C.gl1_3_glBindTexture(gl.funcs, C.GLenum(target), C.GLuint(texture)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexSubImage2D.xml +func (gl *GL) TexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexSubImage1D.xml +func (gl *GL) TexSubImage1D(target glbase.Enum, level, xoffset, width int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexSubImage2D.xml +func (gl *GL) CopyTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, x, y, width, height int) { + C.gl1_3_glCopyTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexSubImage1D.xml +func (gl *GL) CopyTexSubImage1D(target glbase.Enum, level, xoffset, x, y, width int) { + C.gl1_3_glCopyTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexImage2D.xml +func (gl *GL) CopyTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, height, border int) { + C.gl1_3_glCopyTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexImage1D.xml +func (gl *GL) CopyTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, border int) { + C.gl1_3_glCopyTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPolygonOffset.xml +func (gl *GL) PolygonOffset(factor, units float32) { + C.gl1_3_glPolygonOffset(gl.funcs, C.GLfloat(factor), C.GLfloat(units)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawElements.xml +func (gl *GL) DrawElements(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glDrawElements(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawArrays.xml +func (gl *GL) DrawArrays(mode glbase.Enum, first, count int) { + C.gl1_3_glDrawArrays(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexSubImage3D.xml +func (gl *GL) CopyTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, x, y, width, height int) { + C.gl1_3_glCopyTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexSubImage3D.xml +func (gl *GL) TexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexImage3D.xml +func (gl *GL) TexImage3D(target glbase.Enum, level int, internalFormat int32, width, height int, depth int32, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawRangeElements.xml +func (gl *GL) DrawRangeElements(mode glbase.Enum, start, end uint32, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glDrawRangeElements(gl.funcs, C.GLenum(mode), C.GLuint(start), C.GLuint(end), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBlendEquation.xml +func (gl *GL) BlendEquation(mode glbase.Enum) { + C.gl1_3_glBlendEquation(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBlendColor.xml +func (gl *GL) BlendColor(red, green, blue, alpha float32) { + C.gl1_3_glBlendColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetCompressedTexImage.xml +func (gl *GL) GetCompressedTexImage(target glbase.Enum, level int, img interface{}) { + var img_ptr unsafe.Pointer + var img_v = reflect.ValueOf(img) + if img != nil && img_v.Kind() != reflect.Slice { + panic("parameter img must be a slice") + } + if img != nil { + img_ptr = unsafe.Pointer(img_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glGetCompressedTexImage(gl.funcs, C.GLenum(target), C.GLint(level), img_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCompressedTexSubImage1D.xml +func (gl *GL) CompressedTexSubImage1D(target glbase.Enum, level, xoffset, width int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glCompressedTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCompressedTexSubImage2D.xml +func (gl *GL) CompressedTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glCompressedTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCompressedTexSubImage3D.xml +func (gl *GL) CompressedTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glCompressedTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCompressedTexImage1D.xml +func (gl *GL) CompressedTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, width, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glCompressedTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCompressedTexImage2D.xml +func (gl *GL) CompressedTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glCompressedTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCompressedTexImage3D.xml +func (gl *GL) CompressedTexImage3D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height int, depth int32, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glCompressedTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSampleCoverage.xml +func (gl *GL) SampleCoverage(value float32, invert bool) { + C.gl1_3_glSampleCoverage(gl.funcs, C.GLfloat(value), *(*C.GLboolean)(unsafe.Pointer(&invert))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glActiveTexture.xml +func (gl *GL) ActiveTexture(texture glbase.Enum) { + C.gl1_3_glActiveTexture(gl.funcs, C.GLenum(texture)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTranslatef.xml +func (gl *GL) Translatef(x, y, z float32) { + C.gl1_3_glTranslatef(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTranslated.xml +func (gl *GL) Translated(x, y, z float64) { + C.gl1_3_glTranslated(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glScalef.xml +func (gl *GL) Scalef(x, y, z float32) { + C.gl1_3_glScalef(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glScaled.xml +func (gl *GL) Scaled(x, y, z float64) { + C.gl1_3_glScaled(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRotatef.xml +func (gl *GL) Rotatef(angle, x, y, z float32) { + C.gl1_3_glRotatef(gl.funcs, C.GLfloat(angle), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRotated.xml +func (gl *GL) Rotated(angle, x, y, z float64) { + C.gl1_3_glRotated(gl.funcs, C.GLdouble(angle), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPushMatrix.xml +func (gl *GL) PushMatrix() { + C.gl1_3_glPushMatrix(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPopMatrix.xml +func (gl *GL) PopMatrix() { + C.gl1_3_glPopMatrix(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glOrtho.xml +func (gl *GL) Ortho(left, right, bottom, top, zNear, zFar float64) { + C.gl1_3_glOrtho(gl.funcs, C.GLdouble(left), C.GLdouble(right), C.GLdouble(bottom), C.GLdouble(top), C.GLdouble(zNear), C.GLdouble(zFar)) +} + +// MultMatrixd multiplies the current matrix with the provided matrix. +// +// The m parameter must hold 16 consecutive elements of a 4x4 column-major matrix. +// +// The current matrix is determined by the current matrix mode (see +// MatrixMode). It is either the projection matrix, modelview matrix, or the +// texture matrix. +// +// For example, if the current matrix is C and the coordinates to be transformed +// are v = (v[0], v[1], v[2], v[3]), then the current transformation is C × v, or +// +// c[0] c[4] c[8] c[12] v[0] +// c[1] c[5] c[9] c[13] v[1] +// c[2] c[6] c[10] c[14] X v[2] +// c[3] c[7] c[11] c[15] v[3] +// +// Calling MultMatrix with an argument of m = m[0], m[1], ..., m[15] +// replaces the current transformation with (C X M) x v, or +// +// c[0] c[4] c[8] c[12] m[0] m[4] m[8] m[12] v[0] +// c[1] c[5] c[9] c[13] m[1] m[5] m[9] m[13] v[1] +// c[2] c[6] c[10] c[14] X m[2] m[6] m[10] m[14] X v[2] +// c[3] c[7] c[11] c[15] m[3] m[7] m[11] m[15] v[3] +// +// Where 'X' denotes matrix multiplication, and v is represented as a 4x1 matrix. +// +// While the elements of the matrix may be specified with single or double +// precision, the GL may store or operate on these values in less-than-single +// precision. +// +// In many computer languages, 4×4 arrays are represented in row-major +// order. The transformations just described represent these matrices in +// column-major order. The order of the multiplication is important. For +// example, if the current transformation is a rotation, and MultMatrix is +// called with a translation matrix, the translation is done directly on the +// coordinates to be transformed, while the rotation is done on the results +// of that translation. +// +// GL.INVALID_OPERATION is generated if MultMatrix is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) MultMatrixd(m []float64) { + if len(m) != 16 { + panic("parameter m must have length 16 for the 4x4 matrix") + } + C.gl1_3_glMultMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// MultMatrixf multiplies the current matrix with the provided matrix. +// +// The m parameter must hold 16 consecutive elements of a 4x4 column-major matrix. +// +// The current matrix is determined by the current matrix mode (see +// MatrixMode). It is either the projection matrix, modelview matrix, or the +// texture matrix. +// +// For example, if the current matrix is C and the coordinates to be transformed +// are v = (v[0], v[1], v[2], v[3]), then the current transformation is C × v, or +// +// c[0] c[4] c[8] c[12] v[0] +// c[1] c[5] c[9] c[13] v[1] +// c[2] c[6] c[10] c[14] X v[2] +// c[3] c[7] c[11] c[15] v[3] +// +// Calling MultMatrix with an argument of m = m[0], m[1], ..., m[15] +// replaces the current transformation with (C X M) x v, or +// +// c[0] c[4] c[8] c[12] m[0] m[4] m[8] m[12] v[0] +// c[1] c[5] c[9] c[13] m[1] m[5] m[9] m[13] v[1] +// c[2] c[6] c[10] c[14] X m[2] m[6] m[10] m[14] X v[2] +// c[3] c[7] c[11] c[15] m[3] m[7] m[11] m[15] v[3] +// +// Where 'X' denotes matrix multiplication, and v is represented as a 4x1 matrix. +// +// While the elements of the matrix may be specified with single or double +// precision, the GL may store or operate on these values in less-than-single +// precision. +// +// In many computer languages, 4×4 arrays are represented in row-major +// order. The transformations just described represent these matrices in +// column-major order. The order of the multiplication is important. For +// example, if the current transformation is a rotation, and MultMatrix is +// called with a translation matrix, the translation is done directly on the +// coordinates to be transformed, while the rotation is done on the results +// of that translation. +// +// GL.INVALID_OPERATION is generated if MultMatrix is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) MultMatrixf(m []float32) { + if len(m) != 16 { + panic("parameter m must have length 16 for the 4x4 matrix") + } + C.gl1_3_glMultMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMatrixMode.xml +func (gl *GL) MatrixMode(mode glbase.Enum) { + C.gl1_3_glMatrixMode(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadMatrixd.xml +func (gl *GL) LoadMatrixd(m []float64) { + C.gl1_3_glLoadMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadMatrixf.xml +func (gl *GL) LoadMatrixf(m []float32) { + C.gl1_3_glLoadMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadIdentity.xml +func (gl *GL) LoadIdentity() { + C.gl1_3_glLoadIdentity(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFrustum.xml +func (gl *GL) Frustum(left, right, bottom, top, zNear, zFar float64) { + C.gl1_3_glFrustum(gl.funcs, C.GLdouble(left), C.GLdouble(right), C.GLdouble(bottom), C.GLdouble(top), C.GLdouble(zNear), C.GLdouble(zFar)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsList.xml +func (gl *GL) IsList(list uint32) bool { + glresult := C.gl1_3_glIsList(gl.funcs, C.GLuint(list)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexGeniv.xml +func (gl *GL) GetTexGeniv(coord, pname glbase.Enum, params []int32) { + C.gl1_3_glGetTexGeniv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexGenfv.xml +func (gl *GL) GetTexGenfv(coord, pname glbase.Enum, params []float32) { + C.gl1_3_glGetTexGenfv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexGendv.xml +func (gl *GL) GetTexGendv(coord, pname glbase.Enum, params []float64) { + C.gl1_3_glGetTexGendv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexEnviv.xml +func (gl *GL) GetTexEnviv(target, pname glbase.Enum, params []int32) { + C.gl1_3_glGetTexEnviv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexEnvfv.xml +func (gl *GL) GetTexEnvfv(target, pname glbase.Enum, params []float32) { + C.gl1_3_glGetTexEnvfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetPolygonStipple.xml +func (gl *GL) GetPolygonStipple(mask []uint8) { + C.gl1_3_glGetPolygonStipple(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&mask[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetPixelMapusv.xml +func (gl *GL) GetPixelMapusv(glmap glbase.Enum, values []uint16) { + C.gl1_3_glGetPixelMapusv(gl.funcs, C.GLenum(glmap), (*C.GLushort)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetPixelMapuiv.xml +func (gl *GL) GetPixelMapuiv(glmap glbase.Enum, values []uint32) { + C.gl1_3_glGetPixelMapuiv(gl.funcs, C.GLenum(glmap), (*C.GLuint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetPixelMapfv.xml +func (gl *GL) GetPixelMapfv(glmap glbase.Enum, values []float32) { + C.gl1_3_glGetPixelMapfv(gl.funcs, C.GLenum(glmap), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMaterialiv.xml +func (gl *GL) GetMaterialiv(face, pname glbase.Enum, params []int32) { + C.gl1_3_glGetMaterialiv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMaterialfv.xml +func (gl *GL) GetMaterialfv(face, pname glbase.Enum, params []float32) { + C.gl1_3_glGetMaterialfv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMapiv.xml +func (gl *GL) GetMapiv(target, query glbase.Enum, v []int32) { + C.gl1_3_glGetMapiv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMapfv.xml +func (gl *GL) GetMapfv(target, query glbase.Enum, v []float32) { + C.gl1_3_glGetMapfv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMapdv.xml +func (gl *GL) GetMapdv(target, query glbase.Enum, v []float64) { + C.gl1_3_glGetMapdv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetLightiv.xml +func (gl *GL) GetLightiv(light, pname glbase.Enum, params []int32) { + C.gl1_3_glGetLightiv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetLightfv.xml +func (gl *GL) GetLightfv(light, pname glbase.Enum, params []float32) { + C.gl1_3_glGetLightfv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetClipPlane.xml +func (gl *GL) GetClipPlane(plane glbase.Enum, equation []float64) { + C.gl1_3_glGetClipPlane(gl.funcs, C.GLenum(plane), (*C.GLdouble)(unsafe.Pointer(&equation[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawPixels.xml +func (gl *GL) DrawPixels(width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glDrawPixels(gl.funcs, C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyPixels.xml +func (gl *GL) CopyPixels(x, y, width, height int, gltype glbase.Enum) { + C.gl1_3_glCopyPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(gltype)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelMapusv.xml +func (gl *GL) PixelMapusv(glmap glbase.Enum, mapsize int32, values []uint16) { + C.gl1_3_glPixelMapusv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLushort)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelMapuiv.xml +func (gl *GL) PixelMapuiv(glmap glbase.Enum, mapsize int32, values []uint32) { + C.gl1_3_glPixelMapuiv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLuint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelMapfv.xml +func (gl *GL) PixelMapfv(glmap glbase.Enum, mapsize int32, values []float32) { + C.gl1_3_glPixelMapfv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelTransferi.xml +func (gl *GL) PixelTransferi(pname glbase.Enum, param int32) { + C.gl1_3_glPixelTransferi(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelTransferf.xml +func (gl *GL) PixelTransferf(pname glbase.Enum, param float32) { + C.gl1_3_glPixelTransferf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelZoom.xml +func (gl *GL) PixelZoom(xfactor, yfactor float32) { + C.gl1_3_glPixelZoom(gl.funcs, C.GLfloat(xfactor), C.GLfloat(yfactor)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glAlphaFunc.xml +func (gl *GL) AlphaFunc(glfunc glbase.Enum, ref float32) { + C.gl1_3_glAlphaFunc(gl.funcs, C.GLenum(glfunc), C.GLfloat(ref)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalPoint2.xml +func (gl *GL) EvalPoint2(i, j int32) { + C.gl1_3_glEvalPoint2(gl.funcs, C.GLint(i), C.GLint(j)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalMesh2.xml +func (gl *GL) EvalMesh2(mode glbase.Enum, i1, i2, j1, j2 int32) { + C.gl1_3_glEvalMesh2(gl.funcs, C.GLenum(mode), C.GLint(i1), C.GLint(i2), C.GLint(j1), C.GLint(j2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalPoint1.xml +func (gl *GL) EvalPoint1(i int32) { + C.gl1_3_glEvalPoint1(gl.funcs, C.GLint(i)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalMesh1.xml +func (gl *GL) EvalMesh1(mode glbase.Enum, i1, i2 int32) { + C.gl1_3_glEvalMesh1(gl.funcs, C.GLenum(mode), C.GLint(i1), C.GLint(i2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord2fv.xml +func (gl *GL) EvalCoord2fv(u []float32) { + if len(u) != 2 { + panic("parameter u has incorrect length") + } + C.gl1_3_glEvalCoord2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord2f.xml +func (gl *GL) EvalCoord2f(u, v float32) { + C.gl1_3_glEvalCoord2f(gl.funcs, C.GLfloat(u), C.GLfloat(v)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord2dv.xml +func (gl *GL) EvalCoord2dv(u []float64) { + if len(u) != 2 { + panic("parameter u has incorrect length") + } + C.gl1_3_glEvalCoord2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord2d.xml +func (gl *GL) EvalCoord2d(u, v float64) { + C.gl1_3_glEvalCoord2d(gl.funcs, C.GLdouble(u), C.GLdouble(v)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord1fv.xml +func (gl *GL) EvalCoord1fv(u []float32) { + C.gl1_3_glEvalCoord1fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord1f.xml +func (gl *GL) EvalCoord1f(u float32) { + C.gl1_3_glEvalCoord1f(gl.funcs, C.GLfloat(u)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord1dv.xml +func (gl *GL) EvalCoord1dv(u []float64) { + C.gl1_3_glEvalCoord1dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord1d.xml +func (gl *GL) EvalCoord1d(u float64) { + C.gl1_3_glEvalCoord1d(gl.funcs, C.GLdouble(u)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMapGrid2f.xml +func (gl *GL) MapGrid2f(un int32, u1, u2 float32, vn int32, v1, v2 float32) { + C.gl1_3_glMapGrid2f(gl.funcs, C.GLint(un), C.GLfloat(u1), C.GLfloat(u2), C.GLint(vn), C.GLfloat(v1), C.GLfloat(v2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMapGrid2d.xml +func (gl *GL) MapGrid2d(un int32, u1, u2 float64, vn int32, v1, v2 float64) { + C.gl1_3_glMapGrid2d(gl.funcs, C.GLint(un), C.GLdouble(u1), C.GLdouble(u2), C.GLint(vn), C.GLdouble(v1), C.GLdouble(v2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMapGrid1f.xml +func (gl *GL) MapGrid1f(un int32, u1, u2 float32) { + C.gl1_3_glMapGrid1f(gl.funcs, C.GLint(un), C.GLfloat(u1), C.GLfloat(u2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMapGrid1d.xml +func (gl *GL) MapGrid1d(un int32, u1, u2 float64) { + C.gl1_3_glMapGrid1d(gl.funcs, C.GLint(un), C.GLdouble(u1), C.GLdouble(u2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMap2f.xml +func (gl *GL) Map2f(target glbase.Enum, u1, u2 float32, ustride, uorder int32, v1, v2 float32, vstride, vorder int32, points []float32) { + C.gl1_3_glMap2f(gl.funcs, C.GLenum(target), C.GLfloat(u1), C.GLfloat(u2), C.GLint(ustride), C.GLint(uorder), C.GLfloat(v1), C.GLfloat(v2), C.GLint(vstride), C.GLint(vorder), (*C.GLfloat)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMap2d.xml +func (gl *GL) Map2d(target glbase.Enum, u1, u2 float64, ustride, uorder int32, v1, v2 float64, vstride, vorder int32, points []float64) { + C.gl1_3_glMap2d(gl.funcs, C.GLenum(target), C.GLdouble(u1), C.GLdouble(u2), C.GLint(ustride), C.GLint(uorder), C.GLdouble(v1), C.GLdouble(v2), C.GLint(vstride), C.GLint(vorder), (*C.GLdouble)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMap1f.xml +func (gl *GL) Map1f(target glbase.Enum, u1, u2 float32, stride, order int, points []float32) { + C.gl1_3_glMap1f(gl.funcs, C.GLenum(target), C.GLfloat(u1), C.GLfloat(u2), C.GLint(stride), C.GLint(order), (*C.GLfloat)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMap1d.xml +func (gl *GL) Map1d(target glbase.Enum, u1, u2 float64, stride, order int, points []float64) { + C.gl1_3_glMap1d(gl.funcs, C.GLenum(target), C.GLdouble(u1), C.GLdouble(u2), C.GLint(stride), C.GLint(order), (*C.GLdouble)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPushAttrib.xml +func (gl *GL) PushAttrib(mask glbase.Bitfield) { + C.gl1_3_glPushAttrib(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPopAttrib.xml +func (gl *GL) PopAttrib() { + C.gl1_3_glPopAttrib(gl.funcs) +} + +// Accum executes an operation on the accumulation buffer. +// +// Parameter op defines the accumulation buffer operation (GL.ACCUM, GL.LOAD, +// GL.ADD, GL.MULT, or GL.RETURN) and specifies how the value parameter is +// used. +// +// The accumulation buffer is an extended-range color buffer. Images are not +// rendered into it. Rather, images rendered into one of the color buffers +// are added to the contents of the accumulation buffer after rendering. +// Effects such as antialiasing (of points, lines, and polygons), motion +// blur, and depth of field can be created by accumulating images generated +// with different transformation matrices. +// +// Each pixel in the accumulation buffer consists of red, green, blue, and +// alpha values. The number of bits per component in the accumulation buffer +// depends on the implementation. You can examine this number by calling +// GetIntegerv four times, with arguments GL.ACCUM_RED_BITS, +// GL.ACCUM_GREEN_BITS, GL.ACCUM_BLUE_BITS, and GL.ACCUM_ALPHA_BITS. +// Regardless of the number of bits per component, the range of values stored +// by each component is (-1, 1). The accumulation buffer pixels are mapped +// one-to-one with frame buffer pixels. +// +// All accumulation buffer operations are limited to the area of the current +// scissor box and applied identically to the red, green, blue, and alpha +// components of each pixel. If a Accum operation results in a value outside +// the range (-1, 1), the contents of an accumulation buffer pixel component +// are undefined. +// +// The operations are as follows: +// +// GL.ACCUM +// Obtains R, G, B, and A values from the buffer currently selected for +// reading (see ReadBuffer). Each component value is divided by 2 n - +// 1 , where n is the number of bits allocated to each color component +// in the currently selected buffer. The result is a floating-point +// value in the range 0 1 , which is multiplied by value and added to +// the corresponding pixel component in the accumulation buffer, +// thereby updating the accumulation buffer. +// +// GL.LOAD +// Similar to GL.ACCUM, except that the current value in the +// accumulation buffer is not used in the calculation of the new value. +// That is, the R, G, B, and A values from the currently selected +// buffer are divided by 2 n - 1 , multiplied by value, and then stored +// in the corresponding accumulation buffer cell, overwriting the +// current value. +// +// GL.ADD +// Adds value to each R, G, B, and A in the accumulation buffer. +// +// GL.MULT +// Multiplies each R, G, B, and A in the accumulation buffer by value +// and returns the scaled component to its corresponding accumulation +// buffer location. +// +// GL.RETURN +// Transfers accumulation buffer values to the color buffer or buffers +// currently selected for writing. Each R, G, B, and A component is +// multiplied by value, then multiplied by 2 n - 1 , clamped to the +// range 0 2 n - 1 , and stored in the corresponding display buffer +// cell. The only fragment operations that are applied to this transfer +// are pixel ownership, scissor, dithering, and color writemasks. +// +// To clear the accumulation buffer, call ClearAccum with R, G, B, and A +// values to set it to, then call Clear with the accumulation buffer +// enabled. +// +// Error GL.INVALID_ENUM is generated if op is not an accepted value. +// GL.INVALID_OPERATION is generated if there is no accumulation buffer. +// GL.INVALID_OPERATION is generated if Accum is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) Accum(op glbase.Enum, value float32) { + C.gl1_3_glAccum(gl.funcs, C.GLenum(op), C.GLfloat(value)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexMask.xml +func (gl *GL) IndexMask(mask uint32) { + C.gl1_3_glIndexMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearIndex.xml +func (gl *GL) ClearIndex(c float32) { + C.gl1_3_glClearIndex(gl.funcs, C.GLfloat(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearAccum.xml +func (gl *GL) ClearAccum(red, green, blue, alpha float32) { + C.gl1_3_glClearAccum(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPushName.xml +func (gl *GL) PushName(name uint32) { + C.gl1_3_glPushName(gl.funcs, C.GLuint(name)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPopName.xml +func (gl *GL) PopName() { + C.gl1_3_glPopName(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPassThrough.xml +func (gl *GL) PassThrough(token float32) { + C.gl1_3_glPassThrough(gl.funcs, C.GLfloat(token)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadName.xml +func (gl *GL) LoadName(name uint32) { + C.gl1_3_glLoadName(gl.funcs, C.GLuint(name)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glInitNames.xml +func (gl *GL) InitNames() { + C.gl1_3_glInitNames(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRenderMode.xml +func (gl *GL) RenderMode(mode glbase.Enum) int32 { + glresult := C.gl1_3_glRenderMode(gl.funcs, C.GLenum(mode)) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSelectBuffer.xml +func (gl *GL) SelectBuffer(size int, buffer []glbase.Buffer) { + C.gl1_3_glSelectBuffer(gl.funcs, C.GLsizei(size), (*C.GLuint)(unsafe.Pointer(&buffer[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFeedbackBuffer.xml +func (gl *GL) FeedbackBuffer(size int, gltype glbase.Enum, buffer []float32) { + C.gl1_3_glFeedbackBuffer(gl.funcs, C.GLsizei(size), C.GLenum(gltype), (*C.GLfloat)(unsafe.Pointer(&buffer[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGeniv.xml +func (gl *GL) TexGeniv(coord, pname glbase.Enum, params []int32) { + C.gl1_3_glTexGeniv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGeni.xml +func (gl *GL) TexGeni(coord, pname glbase.Enum, param int32) { + C.gl1_3_glTexGeni(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGenfv.xml +func (gl *GL) TexGenfv(coord, pname glbase.Enum, params []float32) { + C.gl1_3_glTexGenfv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGenf.xml +func (gl *GL) TexGenf(coord, pname glbase.Enum, param float32) { + C.gl1_3_glTexGenf(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGendv.xml +func (gl *GL) TexGendv(coord, pname glbase.Enum, params []float64) { + C.gl1_3_glTexGendv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGend.xml +func (gl *GL) TexGend(coord, pname glbase.Enum, param float64) { + C.gl1_3_glTexGend(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLdouble(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnviv.xml +func (gl *GL) TexEnviv(target, pname glbase.Enum, params []int32) { + C.gl1_3_glTexEnviv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnvi.xml +func (gl *GL) TexEnvi(target, pname glbase.Enum, param int32) { + C.gl1_3_glTexEnvi(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnvfv.xml +func (gl *GL) TexEnvfv(target, pname glbase.Enum, params []float32) { + C.gl1_3_glTexEnvfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnvf.xml +func (gl *GL) TexEnvf(target, pname glbase.Enum, param float32) { + C.gl1_3_glTexEnvf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glShadeModel.xml +func (gl *GL) ShadeModel(mode glbase.Enum) { + C.gl1_3_glShadeModel(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPolygonStipple.xml +func (gl *GL) PolygonStipple(mask []uint8) { + C.gl1_3_glPolygonStipple(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&mask[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMaterialiv.xml +func (gl *GL) Materialiv(face, pname glbase.Enum, params []int32) { + C.gl1_3_glMaterialiv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMateriali.xml +func (gl *GL) Materiali(face, pname glbase.Enum, param int32) { + C.gl1_3_glMateriali(gl.funcs, C.GLenum(face), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMaterialfv.xml +func (gl *GL) Materialfv(face, pname glbase.Enum, params []float32) { + C.gl1_3_glMaterialfv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMaterialf.xml +func (gl *GL) Materialf(face, pname glbase.Enum, param float32) { + C.gl1_3_glMaterialf(gl.funcs, C.GLenum(face), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLineStipple.xml +func (gl *GL) LineStipple(factor int32, pattern uint16) { + C.gl1_3_glLineStipple(gl.funcs, C.GLint(factor), C.GLushort(pattern)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightModeliv.xml +func (gl *GL) LightModeliv(pname glbase.Enum, params []int32) { + C.gl1_3_glLightModeliv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightModeli.xml +func (gl *GL) LightModeli(pname glbase.Enum, param int32) { + C.gl1_3_glLightModeli(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightModelfv.xml +func (gl *GL) LightModelfv(pname glbase.Enum, params []float32) { + C.gl1_3_glLightModelfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightModelf.xml +func (gl *GL) LightModelf(pname glbase.Enum, param float32) { + C.gl1_3_glLightModelf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightiv.xml +func (gl *GL) Lightiv(light, pname glbase.Enum, params []int32) { + C.gl1_3_glLightiv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLighti.xml +func (gl *GL) Lighti(light, pname glbase.Enum, param int32) { + C.gl1_3_glLighti(gl.funcs, C.GLenum(light), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightfv.xml +func (gl *GL) Lightfv(light, pname glbase.Enum, params []float32) { + C.gl1_3_glLightfv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightf.xml +func (gl *GL) Lightf(light, pname glbase.Enum, param float32) { + C.gl1_3_glLightf(gl.funcs, C.GLenum(light), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogiv.xml +func (gl *GL) Fogiv(pname glbase.Enum, params []int32) { + C.gl1_3_glFogiv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogi.xml +func (gl *GL) Fogi(pname glbase.Enum, param int32) { + C.gl1_3_glFogi(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogfv.xml +func (gl *GL) Fogfv(pname glbase.Enum, params []float32) { + C.gl1_3_glFogfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogf.xml +func (gl *GL) Fogf(pname glbase.Enum, param float32) { + C.gl1_3_glFogf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorMaterial.xml +func (gl *GL) ColorMaterial(face, mode glbase.Enum) { + C.gl1_3_glColorMaterial(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClipPlane.xml +func (gl *GL) ClipPlane(plane glbase.Enum, equation []float64) { + C.gl1_3_glClipPlane(gl.funcs, C.GLenum(plane), (*C.GLdouble)(unsafe.Pointer(&equation[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4sv.xml +func (gl *GL) Vertex4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_3_glVertex4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4s.xml +func (gl *GL) Vertex4s(x, y, z, w int16) { + C.gl1_3_glVertex4s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4iv.xml +func (gl *GL) Vertex4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_3_glVertex4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4i.xml +func (gl *GL) Vertex4i(x, y, z, w int) { + C.gl1_3_glVertex4i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4fv.xml +func (gl *GL) Vertex4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_3_glVertex4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4f.xml +func (gl *GL) Vertex4f(x, y, z, w float32) { + C.gl1_3_glVertex4f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4dv.xml +func (gl *GL) Vertex4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_3_glVertex4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4d.xml +func (gl *GL) Vertex4d(x, y, z, w float64) { + C.gl1_3_glVertex4d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3sv.xml +func (gl *GL) Vertex3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_3_glVertex3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3s.xml +func (gl *GL) Vertex3s(x, y, z int16) { + C.gl1_3_glVertex3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3iv.xml +func (gl *GL) Vertex3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_3_glVertex3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3i.xml +func (gl *GL) Vertex3i(x, y, z int) { + C.gl1_3_glVertex3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3fv.xml +func (gl *GL) Vertex3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_3_glVertex3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3f.xml +func (gl *GL) Vertex3f(x, y, z float32) { + C.gl1_3_glVertex3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3dv.xml +func (gl *GL) Vertex3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_3_glVertex3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3d.xml +func (gl *GL) Vertex3d(x, y, z float64) { + C.gl1_3_glVertex3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2sv.xml +func (gl *GL) Vertex2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_3_glVertex2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2s.xml +func (gl *GL) Vertex2s(x, y int16) { + C.gl1_3_glVertex2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2iv.xml +func (gl *GL) Vertex2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_3_glVertex2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2i.xml +func (gl *GL) Vertex2i(x, y int) { + C.gl1_3_glVertex2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2fv.xml +func (gl *GL) Vertex2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_3_glVertex2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2f.xml +func (gl *GL) Vertex2f(x, y float32) { + C.gl1_3_glVertex2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2dv.xml +func (gl *GL) Vertex2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_3_glVertex2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2d.xml +func (gl *GL) Vertex2d(x, y float64) { + C.gl1_3_glVertex2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4sv.xml +func (gl *GL) TexCoord4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_3_glTexCoord4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4s.xml +func (gl *GL) TexCoord4s(s, t, r, q int16) { + C.gl1_3_glTexCoord4s(gl.funcs, C.GLshort(s), C.GLshort(t), C.GLshort(r), C.GLshort(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4iv.xml +func (gl *GL) TexCoord4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_3_glTexCoord4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4i.xml +func (gl *GL) TexCoord4i(s, t, r, q int32) { + C.gl1_3_glTexCoord4i(gl.funcs, C.GLint(s), C.GLint(t), C.GLint(r), C.GLint(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4fv.xml +func (gl *GL) TexCoord4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_3_glTexCoord4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4f.xml +func (gl *GL) TexCoord4f(s, t, r, q float32) { + C.gl1_3_glTexCoord4f(gl.funcs, C.GLfloat(s), C.GLfloat(t), C.GLfloat(r), C.GLfloat(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4dv.xml +func (gl *GL) TexCoord4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_3_glTexCoord4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4d.xml +func (gl *GL) TexCoord4d(s, t, r, q float64) { + C.gl1_3_glTexCoord4d(gl.funcs, C.GLdouble(s), C.GLdouble(t), C.GLdouble(r), C.GLdouble(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3sv.xml +func (gl *GL) TexCoord3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_3_glTexCoord3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3s.xml +func (gl *GL) TexCoord3s(s, t, r int16) { + C.gl1_3_glTexCoord3s(gl.funcs, C.GLshort(s), C.GLshort(t), C.GLshort(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3iv.xml +func (gl *GL) TexCoord3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_3_glTexCoord3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3i.xml +func (gl *GL) TexCoord3i(s, t, r int32) { + C.gl1_3_glTexCoord3i(gl.funcs, C.GLint(s), C.GLint(t), C.GLint(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3fv.xml +func (gl *GL) TexCoord3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_3_glTexCoord3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3f.xml +func (gl *GL) TexCoord3f(s, t, r float32) { + C.gl1_3_glTexCoord3f(gl.funcs, C.GLfloat(s), C.GLfloat(t), C.GLfloat(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3dv.xml +func (gl *GL) TexCoord3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_3_glTexCoord3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3d.xml +func (gl *GL) TexCoord3d(s, t, r float64) { + C.gl1_3_glTexCoord3d(gl.funcs, C.GLdouble(s), C.GLdouble(t), C.GLdouble(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2sv.xml +func (gl *GL) TexCoord2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_3_glTexCoord2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2s.xml +func (gl *GL) TexCoord2s(s, t int16) { + C.gl1_3_glTexCoord2s(gl.funcs, C.GLshort(s), C.GLshort(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2iv.xml +func (gl *GL) TexCoord2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_3_glTexCoord2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2i.xml +func (gl *GL) TexCoord2i(s, t int32) { + C.gl1_3_glTexCoord2i(gl.funcs, C.GLint(s), C.GLint(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2fv.xml +func (gl *GL) TexCoord2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_3_glTexCoord2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2f.xml +func (gl *GL) TexCoord2f(s, t float32) { + C.gl1_3_glTexCoord2f(gl.funcs, C.GLfloat(s), C.GLfloat(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2dv.xml +func (gl *GL) TexCoord2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_3_glTexCoord2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2d.xml +func (gl *GL) TexCoord2d(s, t float64) { + C.gl1_3_glTexCoord2d(gl.funcs, C.GLdouble(s), C.GLdouble(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1sv.xml +func (gl *GL) TexCoord1sv(v []int16) { + C.gl1_3_glTexCoord1sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1s.xml +func (gl *GL) TexCoord1s(s int16) { + C.gl1_3_glTexCoord1s(gl.funcs, C.GLshort(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1iv.xml +func (gl *GL) TexCoord1iv(v []int32) { + C.gl1_3_glTexCoord1iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1i.xml +func (gl *GL) TexCoord1i(s int32) { + C.gl1_3_glTexCoord1i(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1fv.xml +func (gl *GL) TexCoord1fv(v []float32) { + C.gl1_3_glTexCoord1fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1f.xml +func (gl *GL) TexCoord1f(s float32) { + C.gl1_3_glTexCoord1f(gl.funcs, C.GLfloat(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1dv.xml +func (gl *GL) TexCoord1dv(v []float64) { + C.gl1_3_glTexCoord1dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1d.xml +func (gl *GL) TexCoord1d(s float64) { + C.gl1_3_glTexCoord1d(gl.funcs, C.GLdouble(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectsv.xml +func (gl *GL) Rectsv(v1, v2 []int16) { + C.gl1_3_glRectsv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v1[0])), (*C.GLshort)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRects.xml +func (gl *GL) Rects(x1, y1, x2, y2 int16) { + C.gl1_3_glRects(gl.funcs, C.GLshort(x1), C.GLshort(y1), C.GLshort(x2), C.GLshort(y2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectiv.xml +func (gl *GL) Rectiv(v1, v2 []int32) { + C.gl1_3_glRectiv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v1[0])), (*C.GLint)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRecti.xml +func (gl *GL) Recti(x1, y1, x2, y2 int32) { + C.gl1_3_glRecti(gl.funcs, C.GLint(x1), C.GLint(y1), C.GLint(x2), C.GLint(y2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectfv.xml +func (gl *GL) Rectfv(v1, v2 []float32) { + C.gl1_3_glRectfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v1[0])), (*C.GLfloat)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectf.xml +func (gl *GL) Rectf(x1, y1, x2, y2 float32) { + C.gl1_3_glRectf(gl.funcs, C.GLfloat(x1), C.GLfloat(y1), C.GLfloat(x2), C.GLfloat(y2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectdv.xml +func (gl *GL) Rectdv(v1, v2 []float64) { + C.gl1_3_glRectdv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v1[0])), (*C.GLdouble)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectd.xml +func (gl *GL) Rectd(x1, y1, x2, y2 float64) { + C.gl1_3_glRectd(gl.funcs, C.GLdouble(x1), C.GLdouble(y1), C.GLdouble(x2), C.GLdouble(y2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4sv.xml +func (gl *GL) RasterPos4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_3_glRasterPos4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4s.xml +func (gl *GL) RasterPos4s(x, y, z, w int16) { + C.gl1_3_glRasterPos4s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4iv.xml +func (gl *GL) RasterPos4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_3_glRasterPos4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4i.xml +func (gl *GL) RasterPos4i(x, y, z, w int) { + C.gl1_3_glRasterPos4i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4fv.xml +func (gl *GL) RasterPos4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_3_glRasterPos4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4f.xml +func (gl *GL) RasterPos4f(x, y, z, w float32) { + C.gl1_3_glRasterPos4f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4dv.xml +func (gl *GL) RasterPos4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_3_glRasterPos4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4d.xml +func (gl *GL) RasterPos4d(x, y, z, w float64) { + C.gl1_3_glRasterPos4d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3sv.xml +func (gl *GL) RasterPos3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_3_glRasterPos3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3s.xml +func (gl *GL) RasterPos3s(x, y, z int16) { + C.gl1_3_glRasterPos3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3iv.xml +func (gl *GL) RasterPos3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_3_glRasterPos3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3i.xml +func (gl *GL) RasterPos3i(x, y, z int) { + C.gl1_3_glRasterPos3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3fv.xml +func (gl *GL) RasterPos3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_3_glRasterPos3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3f.xml +func (gl *GL) RasterPos3f(x, y, z float32) { + C.gl1_3_glRasterPos3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3dv.xml +func (gl *GL) RasterPos3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_3_glRasterPos3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3d.xml +func (gl *GL) RasterPos3d(x, y, z float64) { + C.gl1_3_glRasterPos3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2sv.xml +func (gl *GL) RasterPos2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_3_glRasterPos2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2s.xml +func (gl *GL) RasterPos2s(x, y int16) { + C.gl1_3_glRasterPos2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2iv.xml +func (gl *GL) RasterPos2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_3_glRasterPos2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2i.xml +func (gl *GL) RasterPos2i(x, y int) { + C.gl1_3_glRasterPos2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2fv.xml +func (gl *GL) RasterPos2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_3_glRasterPos2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2f.xml +func (gl *GL) RasterPos2f(x, y float32) { + C.gl1_3_glRasterPos2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2dv.xml +func (gl *GL) RasterPos2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_3_glRasterPos2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2d.xml +func (gl *GL) RasterPos2d(x, y float64) { + C.gl1_3_glRasterPos2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3sv.xml +func (gl *GL) Normal3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_3_glNormal3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3s.xml +func (gl *GL) Normal3s(nx, ny, nz int16) { + C.gl1_3_glNormal3s(gl.funcs, C.GLshort(nx), C.GLshort(ny), C.GLshort(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3iv.xml +func (gl *GL) Normal3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_3_glNormal3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3i.xml +func (gl *GL) Normal3i(nx, ny, nz int32) { + C.gl1_3_glNormal3i(gl.funcs, C.GLint(nx), C.GLint(ny), C.GLint(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3fv.xml +func (gl *GL) Normal3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_3_glNormal3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3f.xml +func (gl *GL) Normal3f(nx, ny, nz float32) { + C.gl1_3_glNormal3f(gl.funcs, C.GLfloat(nx), C.GLfloat(ny), C.GLfloat(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3dv.xml +func (gl *GL) Normal3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_3_glNormal3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3d.xml +func (gl *GL) Normal3d(nx, ny, nz float64) { + C.gl1_3_glNormal3d(gl.funcs, C.GLdouble(nx), C.GLdouble(ny), C.GLdouble(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3bv.xml +func (gl *GL) Normal3bv(v []byte) { + C.gl1_3_glNormal3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3b.xml +func (gl *GL) Normal3b(nx, ny, nz byte) { + C.gl1_3_glNormal3b(gl.funcs, C.GLbyte(nx), C.GLbyte(ny), C.GLbyte(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexsv.xml +func (gl *GL) Indexsv(c []int16) { + C.gl1_3_glIndexsv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexs.xml +func (gl *GL) Indexs(c int16) { + C.gl1_3_glIndexs(gl.funcs, C.GLshort(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexiv.xml +func (gl *GL) Indexiv(c []int32) { + C.gl1_3_glIndexiv(gl.funcs, (*C.GLint)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexi.xml +func (gl *GL) Indexi(c int32) { + C.gl1_3_glIndexi(gl.funcs, C.GLint(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexfv.xml +func (gl *GL) Indexfv(c []float32) { + C.gl1_3_glIndexfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexf.xml +func (gl *GL) Indexf(c float32) { + C.gl1_3_glIndexf(gl.funcs, C.GLfloat(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexdv.xml +func (gl *GL) Indexdv(c []float64) { + C.gl1_3_glIndexdv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexd.xml +func (gl *GL) Indexd(c float64) { + C.gl1_3_glIndexd(gl.funcs, C.GLdouble(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEnd.xml +func (gl *GL) End() { + C.gl1_3_glEnd(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEdgeFlagv.xml +func (gl *GL) EdgeFlagv(flag []bool) { + C.gl1_3_glEdgeFlagv(gl.funcs, (*C.GLboolean)(unsafe.Pointer(&flag[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEdgeFlag.xml +func (gl *GL) EdgeFlag(flag bool) { + C.gl1_3_glEdgeFlag(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4usv.xml +func (gl *GL) Color4usv(v []uint16) { + C.gl1_3_glColor4usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4us.xml +func (gl *GL) Color4us(red, green, blue, alpha uint16) { + C.gl1_3_glColor4us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue), C.GLushort(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4uiv.xml +func (gl *GL) Color4uiv(v []uint32) { + C.gl1_3_glColor4uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4ui.xml +func (gl *GL) Color4ui(red, green, blue, alpha uint32) { + C.gl1_3_glColor4ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue), C.GLuint(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4ubv.xml +func (gl *GL) Color4ubv(v []uint8) { + C.gl1_3_glColor4ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4ub.xml +func (gl *GL) Color4ub(red, green, blue, alpha uint8) { + C.gl1_3_glColor4ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue), C.GLubyte(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4sv.xml +func (gl *GL) Color4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_3_glColor4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4s.xml +func (gl *GL) Color4s(red, green, blue, alpha int16) { + C.gl1_3_glColor4s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue), C.GLshort(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4iv.xml +func (gl *GL) Color4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_3_glColor4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4i.xml +func (gl *GL) Color4i(red, green, blue, alpha int32) { + C.gl1_3_glColor4i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue), C.GLint(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4fv.xml +func (gl *GL) Color4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_3_glColor4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4f.xml +func (gl *GL) Color4f(red, green, blue, alpha float32) { + C.gl1_3_glColor4f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4dv.xml +func (gl *GL) Color4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_3_glColor4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4d.xml +func (gl *GL) Color4d(red, green, blue, alpha float64) { + C.gl1_3_glColor4d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue), C.GLdouble(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4bv.xml +func (gl *GL) Color4bv(v []byte) { + C.gl1_3_glColor4bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4b.xml +func (gl *GL) Color4b(red, green, blue, alpha byte) { + C.gl1_3_glColor4b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue), C.GLbyte(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3usv.xml +func (gl *GL) Color3usv(v []uint16) { + C.gl1_3_glColor3usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3us.xml +func (gl *GL) Color3us(red, green, blue uint16) { + C.gl1_3_glColor3us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3uiv.xml +func (gl *GL) Color3uiv(v []uint32) { + C.gl1_3_glColor3uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3ui.xml +func (gl *GL) Color3ui(red, green, blue uint32) { + C.gl1_3_glColor3ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3ubv.xml +func (gl *GL) Color3ubv(v []uint8) { + C.gl1_3_glColor3ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3ub.xml +func (gl *GL) Color3ub(red, green, blue uint8) { + C.gl1_3_glColor3ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3sv.xml +func (gl *GL) Color3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_3_glColor3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3s.xml +func (gl *GL) Color3s(red, green, blue int16) { + C.gl1_3_glColor3s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3iv.xml +func (gl *GL) Color3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_3_glColor3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3i.xml +func (gl *GL) Color3i(red, green, blue int32) { + C.gl1_3_glColor3i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3fv.xml +func (gl *GL) Color3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_3_glColor3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3f.xml +func (gl *GL) Color3f(red, green, blue float32) { + C.gl1_3_glColor3f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3dv.xml +func (gl *GL) Color3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_3_glColor3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3d.xml +func (gl *GL) Color3d(red, green, blue float64) { + C.gl1_3_glColor3d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3bv.xml +func (gl *GL) Color3bv(v []byte) { + C.gl1_3_glColor3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3b.xml +func (gl *GL) Color3b(red, green, blue byte) { + C.gl1_3_glColor3b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBitmap.xml +func (gl *GL) Bitmap(width, height int, xorig, yorig, xmove, ymove float32, bitmap []uint8) { + C.gl1_3_glBitmap(gl.funcs, C.GLsizei(width), C.GLsizei(height), C.GLfloat(xorig), C.GLfloat(yorig), C.GLfloat(xmove), C.GLfloat(ymove), (*C.GLubyte)(unsafe.Pointer(&bitmap[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBegin.xml +func (gl *GL) Begin(mode glbase.Enum) { + C.gl1_3_glBegin(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glListBase.xml +func (gl *GL) ListBase(base uint32) { + C.gl1_3_glListBase(gl.funcs, C.GLuint(base)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGenLists.xml +func (gl *GL) GenLists(range_ int32) uint32 { + glresult := C.gl1_3_glGenLists(gl.funcs, C.GLsizei(range_)) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDeleteLists.xml +func (gl *GL) DeleteLists(list uint32, range_ int32) { + C.gl1_3_glDeleteLists(gl.funcs, C.GLuint(list), C.GLsizei(range_)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCallLists.xml +func (gl *GL) CallLists(n int, gltype glbase.Enum, lists interface{}) { + var lists_ptr unsafe.Pointer + var lists_v = reflect.ValueOf(lists) + if lists != nil && lists_v.Kind() != reflect.Slice { + panic("parameter lists must be a slice") + } + if lists != nil { + lists_ptr = unsafe.Pointer(lists_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glCallLists(gl.funcs, C.GLsizei(n), C.GLenum(gltype), lists_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCallList.xml +func (gl *GL) CallList(list uint32) { + C.gl1_3_glCallList(gl.funcs, C.GLuint(list)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEndList.xml +func (gl *GL) EndList() { + C.gl1_3_glEndList(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNewList.xml +func (gl *GL) NewList(list uint32, mode glbase.Enum) { + C.gl1_3_glNewList(gl.funcs, C.GLuint(list), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPushClientAttrib.xml +func (gl *GL) PushClientAttrib(mask glbase.Bitfield) { + C.gl1_3_glPushClientAttrib(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPopClientAttrib.xml +func (gl *GL) PopClientAttrib() { + C.gl1_3_glPopClientAttrib(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPrioritizeTextures.xml +func (gl *GL) PrioritizeTextures(n int, textures []glbase.Texture, priorities []float32) { + C.gl1_3_glPrioritizeTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0])), (*C.GLfloat)(unsafe.Pointer(&priorities[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glAreTexturesResident.xml +func (gl *GL) AreTexturesResident(n int, textures []glbase.Texture, residences []bool) bool { + glresult := C.gl1_3_glAreTexturesResident(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0])), (*C.GLboolean)(unsafe.Pointer(&residences[0]))) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexPointer.xml +func (gl *GL) VertexPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glVertexPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoordPointer.xml +func (gl *GL) TexCoordPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glTexCoordPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormalPointer.xml +func (gl *GL) NormalPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glNormalPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glInterleavedArrays.xml +func (gl *GL) InterleavedArrays(format glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glInterleavedArrays(gl.funcs, C.GLenum(format), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexPointer.xml +func (gl *GL) IndexPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glIndexPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEnableClientState.xml +func (gl *GL) EnableClientState(array glbase.Enum) { + C.gl1_3_glEnableClientState(gl.funcs, C.GLenum(array)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEdgeFlagPointer.xml +func (gl *GL) EdgeFlagPointer(stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glEdgeFlagPointer(gl.funcs, C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDisableClientState.xml +func (gl *GL) DisableClientState(array glbase.Enum) { + C.gl1_3_glDisableClientState(gl.funcs, C.GLenum(array)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorPointer.xml +func (gl *GL) ColorPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glColorPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glArrayElement.xml +func (gl *GL) ArrayElement(i int32) { + C.gl1_3_glArrayElement(gl.funcs, C.GLint(i)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glResetMinmax.xml +func (gl *GL) ResetMinmax(target glbase.Enum) { + C.gl1_3_glResetMinmax(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glResetHistogram.xml +func (gl *GL) ResetHistogram(target glbase.Enum) { + C.gl1_3_glResetHistogram(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMinmax.xml +func (gl *GL) Minmax(target, internalFormat glbase.Enum, sink bool) { + C.gl1_3_glMinmax(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), *(*C.GLboolean)(unsafe.Pointer(&sink))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glHistogram.xml +func (gl *GL) Histogram(target glbase.Enum, width int, internalFormat glbase.Enum, sink bool) { + C.gl1_3_glHistogram(gl.funcs, C.GLenum(target), C.GLsizei(width), C.GLenum(internalFormat), *(*C.GLboolean)(unsafe.Pointer(&sink))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMinmaxParameteriv.xml +func (gl *GL) GetMinmaxParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_3_glGetMinmaxParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMinmaxParameterfv.xml +func (gl *GL) GetMinmaxParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_3_glGetMinmaxParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMinmax.xml +func (gl *GL) GetMinmax(target glbase.Enum, reset bool, format, gltype glbase.Enum, values interface{}) { + var values_ptr unsafe.Pointer + var values_v = reflect.ValueOf(values) + if values != nil && values_v.Kind() != reflect.Slice { + panic("parameter values must be a slice") + } + if values != nil { + values_ptr = unsafe.Pointer(values_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glGetMinmax(gl.funcs, C.GLenum(target), *(*C.GLboolean)(unsafe.Pointer(&reset)), C.GLenum(format), C.GLenum(gltype), values_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetHistogramParameteriv.xml +func (gl *GL) GetHistogramParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_3_glGetHistogramParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetHistogramParameterfv.xml +func (gl *GL) GetHistogramParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_3_glGetHistogramParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetHistogram.xml +func (gl *GL) GetHistogram(target glbase.Enum, reset bool, format, gltype glbase.Enum, values interface{}) { + var values_ptr unsafe.Pointer + var values_v = reflect.ValueOf(values) + if values != nil && values_v.Kind() != reflect.Slice { + panic("parameter values must be a slice") + } + if values != nil { + values_ptr = unsafe.Pointer(values_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glGetHistogram(gl.funcs, C.GLenum(target), *(*C.GLboolean)(unsafe.Pointer(&reset)), C.GLenum(format), C.GLenum(gltype), values_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSeparableFilter2D.xml +func (gl *GL) SeparableFilter2D(target, internalFormat glbase.Enum, width, height int, format, gltype glbase.Enum, row, column interface{}) { + var row_ptr unsafe.Pointer + var row_v = reflect.ValueOf(row) + if row != nil && row_v.Kind() != reflect.Slice { + panic("parameter row must be a slice") + } + if row != nil { + row_ptr = unsafe.Pointer(row_v.Index(0).Addr().Pointer()) + } + var column_ptr unsafe.Pointer + var column_v = reflect.ValueOf(column) + if column != nil && column_v.Kind() != reflect.Slice { + panic("parameter column must be a slice") + } + if column != nil { + column_ptr = unsafe.Pointer(column_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glSeparableFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), row_ptr, column_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetSeparableFilter.xml +func (gl *GL) GetSeparableFilter(target, format, gltype glbase.Enum, row, column, span interface{}) { + var row_ptr unsafe.Pointer + var row_v = reflect.ValueOf(row) + if row != nil && row_v.Kind() != reflect.Slice { + panic("parameter row must be a slice") + } + if row != nil { + row_ptr = unsafe.Pointer(row_v.Index(0).Addr().Pointer()) + } + var column_ptr unsafe.Pointer + var column_v = reflect.ValueOf(column) + if column != nil && column_v.Kind() != reflect.Slice { + panic("parameter column must be a slice") + } + if column != nil { + column_ptr = unsafe.Pointer(column_v.Index(0).Addr().Pointer()) + } + var span_ptr unsafe.Pointer + var span_v = reflect.ValueOf(span) + if span != nil && span_v.Kind() != reflect.Slice { + panic("parameter span must be a slice") + } + if span != nil { + span_ptr = unsafe.Pointer(span_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glGetSeparableFilter(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), row_ptr, column_ptr, span_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetConvolutionParameteriv.xml +func (gl *GL) GetConvolutionParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_3_glGetConvolutionParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetConvolutionParameterfv.xml +func (gl *GL) GetConvolutionParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_3_glGetConvolutionParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetConvolutionFilter.xml +func (gl *GL) GetConvolutionFilter(target, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glGetConvolutionFilter(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyConvolutionFilter2D.xml +func (gl *GL) CopyConvolutionFilter2D(target, internalFormat glbase.Enum, x, y, width, height int) { + C.gl1_3_glCopyConvolutionFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyConvolutionFilter1D.xml +func (gl *GL) CopyConvolutionFilter1D(target, internalFormat glbase.Enum, x, y, width int) { + C.gl1_3_glCopyConvolutionFilter1D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionParameteriv.xml +func (gl *GL) ConvolutionParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_3_glConvolutionParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionParameteri.xml +func (gl *GL) ConvolutionParameteri(target, pname glbase.Enum, params int32) { + C.gl1_3_glConvolutionParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(params)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionParameterfv.xml +func (gl *GL) ConvolutionParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_3_glConvolutionParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionParameterf.xml +func (gl *GL) ConvolutionParameterf(target, pname glbase.Enum, params float32) { + C.gl1_3_glConvolutionParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(params)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionFilter2D.xml +func (gl *GL) ConvolutionFilter2D(target, internalFormat glbase.Enum, width, height int, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glConvolutionFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionFilter1D.xml +func (gl *GL) ConvolutionFilter1D(target, internalFormat glbase.Enum, width int, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glConvolutionFilter1D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyColorSubTable.xml +func (gl *GL) CopyColorSubTable(target glbase.Enum, start int32, x, y, width int) { + C.gl1_3_glCopyColorSubTable(gl.funcs, C.GLenum(target), C.GLsizei(start), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorSubTable.xml +func (gl *GL) ColorSubTable(target glbase.Enum, start int32, count int, format, gltype glbase.Enum, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glColorSubTable(gl.funcs, C.GLenum(target), C.GLsizei(start), C.GLsizei(count), C.GLenum(format), C.GLenum(gltype), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetColorTableParameteriv.xml +func (gl *GL) GetColorTableParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_3_glGetColorTableParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetColorTableParameterfv.xml +func (gl *GL) GetColorTableParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_3_glGetColorTableParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetColorTable.xml +func (gl *GL) GetColorTable(target, format, gltype glbase.Enum, table interface{}) { + var table_ptr unsafe.Pointer + var table_v = reflect.ValueOf(table) + if table != nil && table_v.Kind() != reflect.Slice { + panic("parameter table must be a slice") + } + if table != nil { + table_ptr = unsafe.Pointer(table_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glGetColorTable(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), table_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyColorTable.xml +func (gl *GL) CopyColorTable(target, internalFormat glbase.Enum, x, y, width int) { + C.gl1_3_glCopyColorTable(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorTableParameteriv.xml +func (gl *GL) ColorTableParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_3_glColorTableParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorTableParameterfv.xml +func (gl *GL) ColorTableParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_3_glColorTableParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorTable.xml +func (gl *GL) ColorTable(target, internalFormat glbase.Enum, width int, format, gltype glbase.Enum, table interface{}) { + var table_ptr unsafe.Pointer + var table_v = reflect.ValueOf(table) + if table != nil && table_v.Kind() != reflect.Slice { + panic("parameter table must be a slice") + } + if table != nil { + table_ptr = unsafe.Pointer(table_v.Index(0).Addr().Pointer()) + } + C.gl1_3_glColorTable(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), table_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultTransposeMatrixd.xml +func (gl *GL) MultTransposeMatrixd(m []float64) { + C.gl1_3_glMultTransposeMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultTransposeMatrixf.xml +func (gl *GL) MultTransposeMatrixf(m []float32) { + C.gl1_3_glMultTransposeMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadTransposeMatrixd.xml +func (gl *GL) LoadTransposeMatrixd(m []float64) { + C.gl1_3_glLoadTransposeMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadTransposeMatrixf.xml +func (gl *GL) LoadTransposeMatrixf(m []float32) { + C.gl1_3_glLoadTransposeMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4sv.xml +func (gl *GL) MultiTexCoord4sv(target glbase.Enum, v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_3_glMultiTexCoord4sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4s.xml +func (gl *GL) MultiTexCoord4s(target glbase.Enum, s, t, r, q int16) { + C.gl1_3_glMultiTexCoord4s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t), C.GLshort(r), C.GLshort(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4iv.xml +func (gl *GL) MultiTexCoord4iv(target glbase.Enum, v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_3_glMultiTexCoord4iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4i.xml +func (gl *GL) MultiTexCoord4i(target glbase.Enum, s, t, r, q int32) { + C.gl1_3_glMultiTexCoord4i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t), C.GLint(r), C.GLint(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4fv.xml +func (gl *GL) MultiTexCoord4fv(target glbase.Enum, v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_3_glMultiTexCoord4fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4f.xml +func (gl *GL) MultiTexCoord4f(target glbase.Enum, s, t, r, q float32) { + C.gl1_3_glMultiTexCoord4f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t), C.GLfloat(r), C.GLfloat(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4dv.xml +func (gl *GL) MultiTexCoord4dv(target glbase.Enum, v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_3_glMultiTexCoord4dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4d.xml +func (gl *GL) MultiTexCoord4d(target glbase.Enum, s, t, r, q float64) { + C.gl1_3_glMultiTexCoord4d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t), C.GLdouble(r), C.GLdouble(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3sv.xml +func (gl *GL) MultiTexCoord3sv(target glbase.Enum, v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_3_glMultiTexCoord3sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3s.xml +func (gl *GL) MultiTexCoord3s(target glbase.Enum, s, t, r int16) { + C.gl1_3_glMultiTexCoord3s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t), C.GLshort(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3iv.xml +func (gl *GL) MultiTexCoord3iv(target glbase.Enum, v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_3_glMultiTexCoord3iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3i.xml +func (gl *GL) MultiTexCoord3i(target glbase.Enum, s, t, r int32) { + C.gl1_3_glMultiTexCoord3i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t), C.GLint(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3fv.xml +func (gl *GL) MultiTexCoord3fv(target glbase.Enum, v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_3_glMultiTexCoord3fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3f.xml +func (gl *GL) MultiTexCoord3f(target glbase.Enum, s, t, r float32) { + C.gl1_3_glMultiTexCoord3f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t), C.GLfloat(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3dv.xml +func (gl *GL) MultiTexCoord3dv(target glbase.Enum, v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_3_glMultiTexCoord3dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3d.xml +func (gl *GL) MultiTexCoord3d(target glbase.Enum, s, t, r float64) { + C.gl1_3_glMultiTexCoord3d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t), C.GLdouble(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2sv.xml +func (gl *GL) MultiTexCoord2sv(target glbase.Enum, v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_3_glMultiTexCoord2sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2s.xml +func (gl *GL) MultiTexCoord2s(target glbase.Enum, s, t int16) { + C.gl1_3_glMultiTexCoord2s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2iv.xml +func (gl *GL) MultiTexCoord2iv(target glbase.Enum, v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_3_glMultiTexCoord2iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2i.xml +func (gl *GL) MultiTexCoord2i(target glbase.Enum, s, t int32) { + C.gl1_3_glMultiTexCoord2i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2fv.xml +func (gl *GL) MultiTexCoord2fv(target glbase.Enum, v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_3_glMultiTexCoord2fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2f.xml +func (gl *GL) MultiTexCoord2f(target glbase.Enum, s, t float32) { + C.gl1_3_glMultiTexCoord2f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2dv.xml +func (gl *GL) MultiTexCoord2dv(target glbase.Enum, v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_3_glMultiTexCoord2dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2d.xml +func (gl *GL) MultiTexCoord2d(target glbase.Enum, s, t float64) { + C.gl1_3_glMultiTexCoord2d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1sv.xml +func (gl *GL) MultiTexCoord1sv(target glbase.Enum, v []int16) { + C.gl1_3_glMultiTexCoord1sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1s.xml +func (gl *GL) MultiTexCoord1s(target glbase.Enum, s int16) { + C.gl1_3_glMultiTexCoord1s(gl.funcs, C.GLenum(target), C.GLshort(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1iv.xml +func (gl *GL) MultiTexCoord1iv(target glbase.Enum, v []int32) { + C.gl1_3_glMultiTexCoord1iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1i.xml +func (gl *GL) MultiTexCoord1i(target glbase.Enum, s int32) { + C.gl1_3_glMultiTexCoord1i(gl.funcs, C.GLenum(target), C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1fv.xml +func (gl *GL) MultiTexCoord1fv(target glbase.Enum, v []float32) { + C.gl1_3_glMultiTexCoord1fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1f.xml +func (gl *GL) MultiTexCoord1f(target glbase.Enum, s float32) { + C.gl1_3_glMultiTexCoord1f(gl.funcs, C.GLenum(target), C.GLfloat(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1dv.xml +func (gl *GL) MultiTexCoord1dv(target glbase.Enum, v []float64) { + C.gl1_3_glMultiTexCoord1dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1d.xml +func (gl *GL) MultiTexCoord1d(target glbase.Enum, s float64) { + C.gl1_3_glMultiTexCoord1d(gl.funcs, C.GLenum(target), C.GLdouble(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClientActiveTexture.xml +func (gl *GL) ClientActiveTexture(texture glbase.Enum) { + C.gl1_3_glClientActiveTexture(gl.funcs, C.GLenum(texture)) +} diff --git a/gl/1.4/funcs.cpp b/gl/1.4/funcs.cpp new file mode 100644 index 00000000..0aed105f --- /dev/null +++ b/gl/1.4/funcs.cpp @@ -0,0 +1,2790 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#include +#include + +#include "funcs.h" + +void *gl1_4_funcs() { + QOpenGLFunctions_1_4* funcs = QOpenGLContext::currentContext()->versionFunctions(); + if (!funcs) { + return 0; + } + funcs->initializeOpenGLFunctions(); + return funcs; +} + + +void gl1_4_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewport(x, y, width, height); +} + +void gl1_4_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRange(nearVal, farVal); +} + +GLboolean gl1_4_glIsEnabled(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabled(cap); +} + +void gl1_4_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameteriv(target, level, pname, params); +} + +void gl1_4_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameterfv(target, level, pname, params); +} + +void gl1_4_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameteriv(target, pname, params); +} + +void gl1_4_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterfv(target, pname, params); +} + +void gl1_4_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexImage(target, level, format, gltype, pixels); +} + +void gl1_4_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegerv(pname, params); +} + +void gl1_4_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFloatv(pname, params); +} + +GLenum gl1_4_glGetError(void *_glfuncs) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetError(); +} + +void gl1_4_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetDoublev(pname, params); +} + +void gl1_4_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleanv(pname, params); +} + +void gl1_4_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadPixels(x, y, width, height, format, gltype, pixels); +} + +void gl1_4_glReadBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadBuffer(mode); +} + +void gl1_4_glPixelStorei(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStorei(pname, param); +} + +void gl1_4_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStoref(pname, param); +} + +void gl1_4_glDepthFunc(void *_glfuncs, GLenum glfunc) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthFunc(glfunc); +} + +void gl1_4_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOp(fail, zfail, zpass); +} + +void gl1_4_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFunc(glfunc, ref, mask); +} + +void gl1_4_glLogicOp(void *_glfuncs, GLenum opcode) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLogicOp(opcode); +} + +void gl1_4_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFunc(sfactor, dfactor); +} + +void gl1_4_glFlush(void *_glfuncs) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlush(); +} + +void gl1_4_glFinish(void *_glfuncs) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFinish(); +} + +void gl1_4_glEnable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnable(cap); +} + +void gl1_4_glDisable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisable(cap); +} + +void gl1_4_glDepthMask(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthMask(flag); +} + +void gl1_4_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMask(red, green, blue, alpha); +} + +void gl1_4_glStencilMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMask(mask); +} + +void gl1_4_glClearDepth(void *_glfuncs, GLdouble depth) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearDepth(depth); +} + +void gl1_4_glClearStencil(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearStencil(s); +} + +void gl1_4_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearColor(red, green, blue, alpha); +} + +void gl1_4_glClear(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClear(mask); +} + +void gl1_4_glDrawBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffer(mode); +} + +void gl1_4_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage2D(target, level, internalFormat, width, height, border, format, gltype, pixels); +} + +void gl1_4_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage1D(target, level, internalFormat, width, border, format, gltype, pixels); +} + +void gl1_4_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteriv(target, pname, params); +} + +void gl1_4_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteri(target, pname, param); +} + +void gl1_4_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterfv(target, pname, params); +} + +void gl1_4_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterf(target, pname, param); +} + +void gl1_4_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissor(x, y, width, height); +} + +void gl1_4_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonMode(face, mode); +} + +void gl1_4_glPointSize(void *_glfuncs, GLfloat size) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointSize(size); +} + +void gl1_4_glLineWidth(void *_glfuncs, GLfloat width) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineWidth(width); +} + +void gl1_4_glHint(void *_glfuncs, GLenum target, GLenum mode) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glHint(target, mode); +} + +void gl1_4_glFrontFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrontFace(mode); +} + +void gl1_4_glCullFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCullFace(mode); +} + +void gl1_4_glIndexubv(void *_glfuncs, const GLubyte* c) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexubv(c); +} + +void gl1_4_glIndexub(void *_glfuncs, GLubyte c) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexub(c); +} + +GLboolean gl1_4_glIsTexture(void *_glfuncs, GLuint texture) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsTexture(texture); +} + +void gl1_4_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenTextures(n, textures); +} + +void gl1_4_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteTextures(n, textures); +} + +void gl1_4_glBindTexture(void *_glfuncs, GLenum target, GLuint texture) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindTexture(target, texture); +} + +void gl1_4_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, gltype, pixels); +} + +void gl1_4_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage1D(target, level, xoffset, width, format, gltype, pixels); +} + +void gl1_4_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); +} + +void gl1_4_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage1D(target, level, xoffset, x, y, width); +} + +void gl1_4_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage2D(target, level, internalFormat, x, y, width, height, border); +} + +void gl1_4_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage1D(target, level, internalFormat, x, y, width, border); +} + +void gl1_4_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonOffset(factor, units); +} + +void gl1_4_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElements(mode, count, gltype, indices); +} + +void gl1_4_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArrays(mode, first, count); +} + +void gl1_4_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); +} + +void gl1_4_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, gltype, pixels); +} + +void gl1_4_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage3D(target, level, internalFormat, width, height, depth, border, format, gltype, pixels); +} + +void gl1_4_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawRangeElements(mode, start, end, count, gltype, indices); +} + +void gl1_4_glBlendEquation(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquation(mode); +} + +void gl1_4_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendColor(red, green, blue, alpha); +} + +void gl1_4_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetCompressedTexImage(target, level, img); +} + +void gl1_4_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data); +} + +void gl1_4_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); +} + +void gl1_4_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); +} + +void gl1_4_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage1D(target, level, internalFormat, width, border, imageSize, data); +} + +void gl1_4_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data); +} + +void gl1_4_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage3D(target, level, internalFormat, width, height, depth, border, imageSize, data); +} + +void gl1_4_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSampleCoverage(value, invert); +} + +void gl1_4_glActiveTexture(void *_glfuncs, GLenum texture) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glActiveTexture(texture); +} + +void gl1_4_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteriv(pname, params); +} + +void gl1_4_glPointParameteri(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteri(pname, param); +} + +void gl1_4_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterfv(pname, params); +} + +void gl1_4_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterf(pname, param); +} + +void gl1_4_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiDrawArrays(mode, first, count, drawcount); +} + +void gl1_4_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); +} + +void gl1_4_glTranslatef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTranslatef(x, y, z); +} + +void gl1_4_glTranslated(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTranslated(x, y, z); +} + +void gl1_4_glScalef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScalef(x, y, z); +} + +void gl1_4_glScaled(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScaled(x, y, z); +} + +void gl1_4_glRotatef(void *_glfuncs, GLfloat angle, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRotatef(angle, x, y, z); +} + +void gl1_4_glRotated(void *_glfuncs, GLdouble angle, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRotated(angle, x, y, z); +} + +void gl1_4_glPushMatrix(void *_glfuncs) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushMatrix(); +} + +void gl1_4_glPopMatrix(void *_glfuncs) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopMatrix(); +} + +void gl1_4_glOrtho(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glOrtho(left, right, bottom, top, zNear, zFar); +} + +void gl1_4_glMultMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultMatrixd(m); +} + +void gl1_4_glMultMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultMatrixf(m); +} + +void gl1_4_glMatrixMode(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMatrixMode(mode); +} + +void gl1_4_glLoadMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadMatrixd(m); +} + +void gl1_4_glLoadMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadMatrixf(m); +} + +void gl1_4_glLoadIdentity(void *_glfuncs) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadIdentity(); +} + +void gl1_4_glFrustum(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrustum(left, right, bottom, top, zNear, zFar); +} + +GLboolean gl1_4_glIsList(void *_glfuncs, GLuint list) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsList(list); +} + +void gl1_4_glGetTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGeniv(coord, pname, params); +} + +void gl1_4_glGetTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGenfv(coord, pname, params); +} + +void gl1_4_glGetTexGendv(void *_glfuncs, GLenum coord, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGendv(coord, pname, params); +} + +void gl1_4_glGetTexEnviv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexEnviv(target, pname, params); +} + +void gl1_4_glGetTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexEnvfv(target, pname, params); +} + +void gl1_4_glGetPolygonStipple(void *_glfuncs, GLubyte* mask) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPolygonStipple(mask); +} + +void gl1_4_glGetPixelMapusv(void *_glfuncs, GLenum glmap, GLushort* values) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapusv(glmap, values); +} + +void gl1_4_glGetPixelMapuiv(void *_glfuncs, GLenum glmap, GLuint* values) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapuiv(glmap, values); +} + +void gl1_4_glGetPixelMapfv(void *_glfuncs, GLenum glmap, GLfloat* values) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapfv(glmap, values); +} + +void gl1_4_glGetMaterialiv(void *_glfuncs, GLenum face, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMaterialiv(face, pname, params); +} + +void gl1_4_glGetMaterialfv(void *_glfuncs, GLenum face, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMaterialfv(face, pname, params); +} + +void gl1_4_glGetMapiv(void *_glfuncs, GLenum target, GLenum query, GLint* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapiv(target, query, v); +} + +void gl1_4_glGetMapfv(void *_glfuncs, GLenum target, GLenum query, GLfloat* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapfv(target, query, v); +} + +void gl1_4_glGetMapdv(void *_glfuncs, GLenum target, GLenum query, GLdouble* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapdv(target, query, v); +} + +void gl1_4_glGetLightiv(void *_glfuncs, GLenum light, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetLightiv(light, pname, params); +} + +void gl1_4_glGetLightfv(void *_glfuncs, GLenum light, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetLightfv(light, pname, params); +} + +void gl1_4_glGetClipPlane(void *_glfuncs, GLenum plane, GLdouble* equation) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetClipPlane(plane, equation); +} + +void gl1_4_glDrawPixels(void *_glfuncs, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawPixels(width, height, format, gltype, pixels); +} + +void gl1_4_glCopyPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum gltype) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyPixels(x, y, width, height, gltype); +} + +void gl1_4_glPixelMapusv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLushort* values) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapusv(glmap, mapsize, values); +} + +void gl1_4_glPixelMapuiv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLuint* values) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapuiv(glmap, mapsize, values); +} + +void gl1_4_glPixelMapfv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLfloat* values) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapfv(glmap, mapsize, values); +} + +void gl1_4_glPixelTransferi(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelTransferi(pname, param); +} + +void gl1_4_glPixelTransferf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelTransferf(pname, param); +} + +void gl1_4_glPixelZoom(void *_glfuncs, GLfloat xfactor, GLfloat yfactor) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelZoom(xfactor, yfactor); +} + +void gl1_4_glAlphaFunc(void *_glfuncs, GLenum glfunc, GLfloat ref) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAlphaFunc(glfunc, ref); +} + +void gl1_4_glEvalPoint2(void *_glfuncs, GLint i, GLint j) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalPoint2(i, j); +} + +void gl1_4_glEvalMesh2(void *_glfuncs, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalMesh2(mode, i1, i2, j1, j2); +} + +void gl1_4_glEvalPoint1(void *_glfuncs, GLint i) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalPoint1(i); +} + +void gl1_4_glEvalMesh1(void *_glfuncs, GLenum mode, GLint i1, GLint i2) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalMesh1(mode, i1, i2); +} + +void gl1_4_glEvalCoord2fv(void *_glfuncs, const GLfloat* u) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2fv(u); +} + +void gl1_4_glEvalCoord2f(void *_glfuncs, GLfloat u, GLfloat v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2f(u, v); +} + +void gl1_4_glEvalCoord2dv(void *_glfuncs, const GLdouble* u) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2dv(u); +} + +void gl1_4_glEvalCoord2d(void *_glfuncs, GLdouble u, GLdouble v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2d(u, v); +} + +void gl1_4_glEvalCoord1fv(void *_glfuncs, const GLfloat* u) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1fv(u); +} + +void gl1_4_glEvalCoord1f(void *_glfuncs, GLfloat u) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1f(u); +} + +void gl1_4_glEvalCoord1dv(void *_glfuncs, const GLdouble* u) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1dv(u); +} + +void gl1_4_glEvalCoord1d(void *_glfuncs, GLdouble u) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1d(u); +} + +void gl1_4_glMapGrid2f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid2f(un, u1, u2, vn, v1, v2); +} + +void gl1_4_glMapGrid2d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid2d(un, u1, u2, vn, v1, v2); +} + +void gl1_4_glMapGrid1f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid1f(un, u1, u2); +} + +void gl1_4_glMapGrid1d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid1d(un, u1, u2); +} + +void gl1_4_glMap2f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); +} + +void gl1_4_glMap2d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); +} + +void gl1_4_glMap1f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap1f(target, u1, u2, stride, order, points); +} + +void gl1_4_glMap1d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap1d(target, u1, u2, stride, order, points); +} + +void gl1_4_glPushAttrib(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushAttrib(mask); +} + +void gl1_4_glPopAttrib(void *_glfuncs) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopAttrib(); +} + +void gl1_4_glAccum(void *_glfuncs, GLenum op, GLfloat value) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAccum(op, value); +} + +void gl1_4_glIndexMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexMask(mask); +} + +void gl1_4_glClearIndex(void *_glfuncs, GLfloat c) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearIndex(c); +} + +void gl1_4_glClearAccum(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearAccum(red, green, blue, alpha); +} + +void gl1_4_glPushName(void *_glfuncs, GLuint name) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushName(name); +} + +void gl1_4_glPopName(void *_glfuncs) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopName(); +} + +void gl1_4_glPassThrough(void *_glfuncs, GLfloat token) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPassThrough(token); +} + +void gl1_4_glLoadName(void *_glfuncs, GLuint name) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadName(name); +} + +void gl1_4_glInitNames(void *_glfuncs) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInitNames(); +} + +GLint gl1_4_glRenderMode(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glRenderMode(mode); +} + +void gl1_4_glSelectBuffer(void *_glfuncs, GLsizei size, GLuint* buffer) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSelectBuffer(size, buffer); +} + +void gl1_4_glFeedbackBuffer(void *_glfuncs, GLsizei size, GLenum gltype, GLfloat* buffer) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFeedbackBuffer(size, gltype, buffer); +} + +void gl1_4_glTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGeniv(coord, pname, params); +} + +void gl1_4_glTexGeni(void *_glfuncs, GLenum coord, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGeni(coord, pname, param); +} + +void gl1_4_glTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGenfv(coord, pname, params); +} + +void gl1_4_glTexGenf(void *_glfuncs, GLenum coord, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGenf(coord, pname, param); +} + +void gl1_4_glTexGendv(void *_glfuncs, GLenum coord, GLenum pname, const GLdouble* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGendv(coord, pname, params); +} + +void gl1_4_glTexGend(void *_glfuncs, GLenum coord, GLenum pname, GLdouble param) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGend(coord, pname, param); +} + +void gl1_4_glTexEnviv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnviv(target, pname, params); +} + +void gl1_4_glTexEnvi(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvi(target, pname, param); +} + +void gl1_4_glTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvfv(target, pname, params); +} + +void gl1_4_glTexEnvf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvf(target, pname, param); +} + +void gl1_4_glShadeModel(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShadeModel(mode); +} + +void gl1_4_glPolygonStipple(void *_glfuncs, const GLubyte* mask) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonStipple(mask); +} + +void gl1_4_glMaterialiv(void *_glfuncs, GLenum face, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialiv(face, pname, params); +} + +void gl1_4_glMateriali(void *_glfuncs, GLenum face, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMateriali(face, pname, param); +} + +void gl1_4_glMaterialfv(void *_glfuncs, GLenum face, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialfv(face, pname, params); +} + +void gl1_4_glMaterialf(void *_glfuncs, GLenum face, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialf(face, pname, param); +} + +void gl1_4_glLineStipple(void *_glfuncs, GLint factor, GLushort pattern) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineStipple(factor, pattern); +} + +void gl1_4_glLightModeliv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModeliv(pname, params); +} + +void gl1_4_glLightModeli(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModeli(pname, param); +} + +void gl1_4_glLightModelfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModelfv(pname, params); +} + +void gl1_4_glLightModelf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModelf(pname, param); +} + +void gl1_4_glLightiv(void *_glfuncs, GLenum light, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightiv(light, pname, params); +} + +void gl1_4_glLighti(void *_glfuncs, GLenum light, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLighti(light, pname, param); +} + +void gl1_4_glLightfv(void *_glfuncs, GLenum light, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightfv(light, pname, params); +} + +void gl1_4_glLightf(void *_glfuncs, GLenum light, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightf(light, pname, param); +} + +void gl1_4_glFogiv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogiv(pname, params); +} + +void gl1_4_glFogi(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogi(pname, param); +} + +void gl1_4_glFogfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogfv(pname, params); +} + +void gl1_4_glFogf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogf(pname, param); +} + +void gl1_4_glColorMaterial(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMaterial(face, mode); +} + +void gl1_4_glClipPlane(void *_glfuncs, GLenum plane, const GLdouble* equation) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClipPlane(plane, equation); +} + +void gl1_4_glVertex4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4sv(v); +} + +void gl1_4_glVertex4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4s(x, y, z, w); +} + +void gl1_4_glVertex4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4iv(v); +} + +void gl1_4_glVertex4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4i(x, y, z, w); +} + +void gl1_4_glVertex4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4fv(v); +} + +void gl1_4_glVertex4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4f(x, y, z, w); +} + +void gl1_4_glVertex4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4dv(v); +} + +void gl1_4_glVertex4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4d(x, y, z, w); +} + +void gl1_4_glVertex3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3sv(v); +} + +void gl1_4_glVertex3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3s(x, y, z); +} + +void gl1_4_glVertex3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3iv(v); +} + +void gl1_4_glVertex3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3i(x, y, z); +} + +void gl1_4_glVertex3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3fv(v); +} + +void gl1_4_glVertex3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3f(x, y, z); +} + +void gl1_4_glVertex3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3dv(v); +} + +void gl1_4_glVertex3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3d(x, y, z); +} + +void gl1_4_glVertex2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2sv(v); +} + +void gl1_4_glVertex2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2s(x, y); +} + +void gl1_4_glVertex2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2iv(v); +} + +void gl1_4_glVertex2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2i(x, y); +} + +void gl1_4_glVertex2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2fv(v); +} + +void gl1_4_glVertex2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2f(x, y); +} + +void gl1_4_glVertex2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2dv(v); +} + +void gl1_4_glVertex2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2d(x, y); +} + +void gl1_4_glTexCoord4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4sv(v); +} + +void gl1_4_glTexCoord4s(void *_glfuncs, GLshort s, GLshort t, GLshort r, GLshort q) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4s(s, t, r, q); +} + +void gl1_4_glTexCoord4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4iv(v); +} + +void gl1_4_glTexCoord4i(void *_glfuncs, GLint s, GLint t, GLint r, GLint q) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4i(s, t, r, q); +} + +void gl1_4_glTexCoord4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4fv(v); +} + +void gl1_4_glTexCoord4f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4f(s, t, r, q); +} + +void gl1_4_glTexCoord4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4dv(v); +} + +void gl1_4_glTexCoord4d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r, GLdouble q) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4d(s, t, r, q); +} + +void gl1_4_glTexCoord3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3sv(v); +} + +void gl1_4_glTexCoord3s(void *_glfuncs, GLshort s, GLshort t, GLshort r) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3s(s, t, r); +} + +void gl1_4_glTexCoord3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3iv(v); +} + +void gl1_4_glTexCoord3i(void *_glfuncs, GLint s, GLint t, GLint r) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3i(s, t, r); +} + +void gl1_4_glTexCoord3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3fv(v); +} + +void gl1_4_glTexCoord3f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3f(s, t, r); +} + +void gl1_4_glTexCoord3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3dv(v); +} + +void gl1_4_glTexCoord3d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3d(s, t, r); +} + +void gl1_4_glTexCoord2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2sv(v); +} + +void gl1_4_glTexCoord2s(void *_glfuncs, GLshort s, GLshort t) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2s(s, t); +} + +void gl1_4_glTexCoord2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2iv(v); +} + +void gl1_4_glTexCoord2i(void *_glfuncs, GLint s, GLint t) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2i(s, t); +} + +void gl1_4_glTexCoord2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2fv(v); +} + +void gl1_4_glTexCoord2f(void *_glfuncs, GLfloat s, GLfloat t) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2f(s, t); +} + +void gl1_4_glTexCoord2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2dv(v); +} + +void gl1_4_glTexCoord2d(void *_glfuncs, GLdouble s, GLdouble t) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2d(s, t); +} + +void gl1_4_glTexCoord1sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1sv(v); +} + +void gl1_4_glTexCoord1s(void *_glfuncs, GLshort s) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1s(s); +} + +void gl1_4_glTexCoord1iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1iv(v); +} + +void gl1_4_glTexCoord1i(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1i(s); +} + +void gl1_4_glTexCoord1fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1fv(v); +} + +void gl1_4_glTexCoord1f(void *_glfuncs, GLfloat s) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1f(s); +} + +void gl1_4_glTexCoord1dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1dv(v); +} + +void gl1_4_glTexCoord1d(void *_glfuncs, GLdouble s) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1d(s); +} + +void gl1_4_glRectsv(void *_glfuncs, const GLshort* v1, const GLshort* v2) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectsv(v1, v2); +} + +void gl1_4_glRects(void *_glfuncs, GLshort x1, GLshort y1, GLshort x2, GLshort y2) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRects(x1, y1, x2, y2); +} + +void gl1_4_glRectiv(void *_glfuncs, const GLint* v1, const GLint* v2) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectiv(v1, v2); +} + +void gl1_4_glRecti(void *_glfuncs, GLint x1, GLint y1, GLint x2, GLint y2) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRecti(x1, y1, x2, y2); +} + +void gl1_4_glRectfv(void *_glfuncs, const GLfloat* v1, const GLfloat* v2) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectfv(v1, v2); +} + +void gl1_4_glRectf(void *_glfuncs, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectf(x1, y1, x2, y2); +} + +void gl1_4_glRectdv(void *_glfuncs, const GLdouble* v1, const GLdouble* v2) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectdv(v1, v2); +} + +void gl1_4_glRectd(void *_glfuncs, GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectd(x1, y1, x2, y2); +} + +void gl1_4_glRasterPos4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4sv(v); +} + +void gl1_4_glRasterPos4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4s(x, y, z, w); +} + +void gl1_4_glRasterPos4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4iv(v); +} + +void gl1_4_glRasterPos4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4i(x, y, z, w); +} + +void gl1_4_glRasterPos4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4fv(v); +} + +void gl1_4_glRasterPos4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4f(x, y, z, w); +} + +void gl1_4_glRasterPos4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4dv(v); +} + +void gl1_4_glRasterPos4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4d(x, y, z, w); +} + +void gl1_4_glRasterPos3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3sv(v); +} + +void gl1_4_glRasterPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3s(x, y, z); +} + +void gl1_4_glRasterPos3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3iv(v); +} + +void gl1_4_glRasterPos3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3i(x, y, z); +} + +void gl1_4_glRasterPos3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3fv(v); +} + +void gl1_4_glRasterPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3f(x, y, z); +} + +void gl1_4_glRasterPos3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3dv(v); +} + +void gl1_4_glRasterPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3d(x, y, z); +} + +void gl1_4_glRasterPos2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2sv(v); +} + +void gl1_4_glRasterPos2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2s(x, y); +} + +void gl1_4_glRasterPos2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2iv(v); +} + +void gl1_4_glRasterPos2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2i(x, y); +} + +void gl1_4_glRasterPos2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2fv(v); +} + +void gl1_4_glRasterPos2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2f(x, y); +} + +void gl1_4_glRasterPos2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2dv(v); +} + +void gl1_4_glRasterPos2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2d(x, y); +} + +void gl1_4_glNormal3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3sv(v); +} + +void gl1_4_glNormal3s(void *_glfuncs, GLshort nx, GLshort ny, GLshort nz) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3s(nx, ny, nz); +} + +void gl1_4_glNormal3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3iv(v); +} + +void gl1_4_glNormal3i(void *_glfuncs, GLint nx, GLint ny, GLint nz) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3i(nx, ny, nz); +} + +void gl1_4_glNormal3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3fv(v); +} + +void gl1_4_glNormal3f(void *_glfuncs, GLfloat nx, GLfloat ny, GLfloat nz) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3f(nx, ny, nz); +} + +void gl1_4_glNormal3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3dv(v); +} + +void gl1_4_glNormal3d(void *_glfuncs, GLdouble nx, GLdouble ny, GLdouble nz) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3d(nx, ny, nz); +} + +void gl1_4_glNormal3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3bv(v); +} + +void gl1_4_glNormal3b(void *_glfuncs, GLbyte nx, GLbyte ny, GLbyte nz) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3b(nx, ny, nz); +} + +void gl1_4_glIndexsv(void *_glfuncs, const GLshort* c) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexsv(c); +} + +void gl1_4_glIndexs(void *_glfuncs, GLshort c) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexs(c); +} + +void gl1_4_glIndexiv(void *_glfuncs, const GLint* c) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexiv(c); +} + +void gl1_4_glIndexi(void *_glfuncs, GLint c) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexi(c); +} + +void gl1_4_glIndexfv(void *_glfuncs, const GLfloat* c) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexfv(c); +} + +void gl1_4_glIndexf(void *_glfuncs, GLfloat c) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexf(c); +} + +void gl1_4_glIndexdv(void *_glfuncs, const GLdouble* c) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexdv(c); +} + +void gl1_4_glIndexd(void *_glfuncs, GLdouble c) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexd(c); +} + +void gl1_4_glEnd(void *_glfuncs) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnd(); +} + +void gl1_4_glEdgeFlagv(void *_glfuncs, const GLboolean* flag) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlagv(flag); +} + +void gl1_4_glEdgeFlag(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlag(flag); +} + +void gl1_4_glColor4usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4usv(v); +} + +void gl1_4_glColor4us(void *_glfuncs, GLushort red, GLushort green, GLushort blue, GLushort alpha) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4us(red, green, blue, alpha); +} + +void gl1_4_glColor4uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4uiv(v); +} + +void gl1_4_glColor4ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue, GLuint alpha) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ui(red, green, blue, alpha); +} + +void gl1_4_glColor4ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ubv(v); +} + +void gl1_4_glColor4ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ub(red, green, blue, alpha); +} + +void gl1_4_glColor4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4sv(v); +} + +void gl1_4_glColor4s(void *_glfuncs, GLshort red, GLshort green, GLshort blue, GLshort alpha) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4s(red, green, blue, alpha); +} + +void gl1_4_glColor4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4iv(v); +} + +void gl1_4_glColor4i(void *_glfuncs, GLint red, GLint green, GLint blue, GLint alpha) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4i(red, green, blue, alpha); +} + +void gl1_4_glColor4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4fv(v); +} + +void gl1_4_glColor4f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4f(red, green, blue, alpha); +} + +void gl1_4_glColor4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4dv(v); +} + +void gl1_4_glColor4d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4d(red, green, blue, alpha); +} + +void gl1_4_glColor4bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4bv(v); +} + +void gl1_4_glColor4b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4b(red, green, blue, alpha); +} + +void gl1_4_glColor3usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3usv(v); +} + +void gl1_4_glColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3us(red, green, blue); +} + +void gl1_4_glColor3uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3uiv(v); +} + +void gl1_4_glColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ui(red, green, blue); +} + +void gl1_4_glColor3ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ubv(v); +} + +void gl1_4_glColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ub(red, green, blue); +} + +void gl1_4_glColor3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3sv(v); +} + +void gl1_4_glColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3s(red, green, blue); +} + +void gl1_4_glColor3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3iv(v); +} + +void gl1_4_glColor3i(void *_glfuncs, GLint red, GLint green, GLint blue) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3i(red, green, blue); +} + +void gl1_4_glColor3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3fv(v); +} + +void gl1_4_glColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3f(red, green, blue); +} + +void gl1_4_glColor3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3dv(v); +} + +void gl1_4_glColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3d(red, green, blue); +} + +void gl1_4_glColor3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3bv(v); +} + +void gl1_4_glColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3b(red, green, blue); +} + +void gl1_4_glBitmap(void *_glfuncs, GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBitmap(width, height, xorig, yorig, xmove, ymove, bitmap); +} + +void gl1_4_glBegin(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBegin(mode); +} + +void gl1_4_glListBase(void *_glfuncs, GLuint base) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glListBase(base); +} + +GLuint gl1_4_glGenLists(void *_glfuncs, GLsizei range_) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGenLists(range_); +} + +void gl1_4_glDeleteLists(void *_glfuncs, GLuint list, GLsizei range_) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteLists(list, range_); +} + +void gl1_4_glCallLists(void *_glfuncs, GLsizei n, GLenum gltype, const GLvoid* lists) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCallLists(n, gltype, lists); +} + +void gl1_4_glCallList(void *_glfuncs, GLuint list) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCallList(list); +} + +void gl1_4_glEndList(void *_glfuncs) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndList(); +} + +void gl1_4_glNewList(void *_glfuncs, GLuint list, GLenum mode) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNewList(list, mode); +} + +void gl1_4_glPushClientAttrib(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushClientAttrib(mask); +} + +void gl1_4_glPopClientAttrib(void *_glfuncs) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopClientAttrib(); +} + +void gl1_4_glPrioritizeTextures(void *_glfuncs, GLsizei n, const GLuint* textures, const GLfloat* priorities) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPrioritizeTextures(n, textures, priorities); +} + +GLboolean gl1_4_glAreTexturesResident(void *_glfuncs, GLsizei n, const GLuint* textures, GLboolean* residences) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glAreTexturesResident(n, textures, residences); +} + +void gl1_4_glVertexPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexPointer(size, gltype, stride, pointer); +} + +void gl1_4_glTexCoordPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordPointer(size, gltype, stride, pointer); +} + +void gl1_4_glNormalPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormalPointer(gltype, stride, pointer); +} + +void gl1_4_glInterleavedArrays(void *_glfuncs, GLenum format, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInterleavedArrays(format, stride, pointer); +} + +void gl1_4_glIndexPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexPointer(gltype, stride, pointer); +} + +void gl1_4_glEnableClientState(void *_glfuncs, GLenum array) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnableClientState(array); +} + +void gl1_4_glEdgeFlagPointer(void *_glfuncs, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlagPointer(stride, pointer); +} + +void gl1_4_glDisableClientState(void *_glfuncs, GLenum array) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisableClientState(array); +} + +void gl1_4_glColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorPointer(size, gltype, stride, pointer); +} + +void gl1_4_glArrayElement(void *_glfuncs, GLint i) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glArrayElement(i); +} + +void gl1_4_glResetMinmax(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glResetMinmax(target); +} + +void gl1_4_glResetHistogram(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glResetHistogram(target); +} + +void gl1_4_glMinmax(void *_glfuncs, GLenum target, GLenum internalFormat, GLboolean sink) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMinmax(target, internalFormat, sink); +} + +void gl1_4_glHistogram(void *_glfuncs, GLenum target, GLsizei width, GLenum internalFormat, GLboolean sink) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glHistogram(target, width, internalFormat, sink); +} + +void gl1_4_glGetMinmaxParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmaxParameteriv(target, pname, params); +} + +void gl1_4_glGetMinmaxParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmaxParameterfv(target, pname, params); +} + +void gl1_4_glGetMinmax(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmax(target, reset, format, gltype, values); +} + +void gl1_4_glGetHistogramParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogramParameteriv(target, pname, params); +} + +void gl1_4_glGetHistogramParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogramParameterfv(target, pname, params); +} + +void gl1_4_glGetHistogram(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogram(target, reset, format, gltype, values); +} + +void gl1_4_glSeparableFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* row, const GLvoid* column) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSeparableFilter2D(target, internalFormat, width, height, format, gltype, row, column); +} + +void gl1_4_glGetSeparableFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* row, GLvoid* column, GLvoid* span) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSeparableFilter(target, format, gltype, row, column, span); +} + +void gl1_4_glGetConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionParameteriv(target, pname, params); +} + +void gl1_4_glGetConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionParameterfv(target, pname, params); +} + +void gl1_4_glGetConvolutionFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* image) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionFilter(target, format, gltype, image); +} + +void gl1_4_glCopyConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyConvolutionFilter2D(target, internalFormat, x, y, width, height); +} + +void gl1_4_glCopyConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyConvolutionFilter1D(target, internalFormat, x, y, width); +} + +void gl1_4_glConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameteriv(target, pname, params); +} + +void gl1_4_glConvolutionParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameteri(target, pname, params); +} + +void gl1_4_glConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameterfv(target, pname, params); +} + +void gl1_4_glConvolutionParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameterf(target, pname, params); +} + +void gl1_4_glConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* image) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionFilter2D(target, internalFormat, width, height, format, gltype, image); +} + +void gl1_4_glConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* image) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionFilter1D(target, internalFormat, width, format, gltype, image); +} + +void gl1_4_glCopyColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyColorSubTable(target, start, x, y, width); +} + +void gl1_4_glColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum gltype, const GLvoid* data) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorSubTable(target, start, count, format, gltype, data); +} + +void gl1_4_glGetColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTableParameteriv(target, pname, params); +} + +void gl1_4_glGetColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTableParameterfv(target, pname, params); +} + +void gl1_4_glGetColorTable(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* table) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTable(target, format, gltype, table); +} + +void gl1_4_glCopyColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyColorTable(target, internalFormat, x, y, width); +} + +void gl1_4_glColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTableParameteriv(target, pname, params); +} + +void gl1_4_glColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTableParameterfv(target, pname, params); +} + +void gl1_4_glColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* table) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTable(target, internalFormat, width, format, gltype, table); +} + +void gl1_4_glMultTransposeMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultTransposeMatrixd(m); +} + +void gl1_4_glMultTransposeMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultTransposeMatrixf(m); +} + +void gl1_4_glLoadTransposeMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadTransposeMatrixd(m); +} + +void gl1_4_glLoadTransposeMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadTransposeMatrixf(m); +} + +void gl1_4_glMultiTexCoord4sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4sv(target, v); +} + +void gl1_4_glMultiTexCoord4s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r, GLshort q) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4s(target, s, t, r, q); +} + +void gl1_4_glMultiTexCoord4iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4iv(target, v); +} + +void gl1_4_glMultiTexCoord4i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r, GLint q) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4i(target, s, t, r, q); +} + +void gl1_4_glMultiTexCoord4fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4fv(target, v); +} + +void gl1_4_glMultiTexCoord4f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4f(target, s, t, r, q); +} + +void gl1_4_glMultiTexCoord4dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4dv(target, v); +} + +void gl1_4_glMultiTexCoord4d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4d(target, s, t, r, q); +} + +void gl1_4_glMultiTexCoord3sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3sv(target, v); +} + +void gl1_4_glMultiTexCoord3s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3s(target, s, t, r); +} + +void gl1_4_glMultiTexCoord3iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3iv(target, v); +} + +void gl1_4_glMultiTexCoord3i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3i(target, s, t, r); +} + +void gl1_4_glMultiTexCoord3fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3fv(target, v); +} + +void gl1_4_glMultiTexCoord3f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3f(target, s, t, r); +} + +void gl1_4_glMultiTexCoord3dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3dv(target, v); +} + +void gl1_4_glMultiTexCoord3d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3d(target, s, t, r); +} + +void gl1_4_glMultiTexCoord2sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2sv(target, v); +} + +void gl1_4_glMultiTexCoord2s(void *_glfuncs, GLenum target, GLshort s, GLshort t) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2s(target, s, t); +} + +void gl1_4_glMultiTexCoord2iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2iv(target, v); +} + +void gl1_4_glMultiTexCoord2i(void *_glfuncs, GLenum target, GLint s, GLint t) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2i(target, s, t); +} + +void gl1_4_glMultiTexCoord2fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2fv(target, v); +} + +void gl1_4_glMultiTexCoord2f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2f(target, s, t); +} + +void gl1_4_glMultiTexCoord2dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2dv(target, v); +} + +void gl1_4_glMultiTexCoord2d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2d(target, s, t); +} + +void gl1_4_glMultiTexCoord1sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1sv(target, v); +} + +void gl1_4_glMultiTexCoord1s(void *_glfuncs, GLenum target, GLshort s) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1s(target, s); +} + +void gl1_4_glMultiTexCoord1iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1iv(target, v); +} + +void gl1_4_glMultiTexCoord1i(void *_glfuncs, GLenum target, GLint s) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1i(target, s); +} + +void gl1_4_glMultiTexCoord1fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1fv(target, v); +} + +void gl1_4_glMultiTexCoord1f(void *_glfuncs, GLenum target, GLfloat s) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1f(target, s); +} + +void gl1_4_glMultiTexCoord1dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1dv(target, v); +} + +void gl1_4_glMultiTexCoord1d(void *_glfuncs, GLenum target, GLdouble s) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1d(target, s); +} + +void gl1_4_glClientActiveTexture(void *_glfuncs, GLenum texture) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClientActiveTexture(texture); +} + +void gl1_4_glWindowPos3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3sv(v); +} + +void gl1_4_glWindowPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3s(x, y, z); +} + +void gl1_4_glWindowPos3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3iv(v); +} + +void gl1_4_glWindowPos3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3i(x, y, z); +} + +void gl1_4_glWindowPos3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3fv(v); +} + +void gl1_4_glWindowPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3f(x, y, z); +} + +void gl1_4_glWindowPos3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3dv(v); +} + +void gl1_4_glWindowPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3d(x, y, z); +} + +void gl1_4_glWindowPos2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2sv(v); +} + +void gl1_4_glWindowPos2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2s(x, y); +} + +void gl1_4_glWindowPos2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2iv(v); +} + +void gl1_4_glWindowPos2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2i(x, y); +} + +void gl1_4_glWindowPos2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2fv(v); +} + +void gl1_4_glWindowPos2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2f(x, y); +} + +void gl1_4_glWindowPos2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2dv(v); +} + +void gl1_4_glWindowPos2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2d(x, y); +} + +void gl1_4_glSecondaryColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColorPointer(size, gltype, stride, pointer); +} + +void gl1_4_glSecondaryColor3usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3usv(v); +} + +void gl1_4_glSecondaryColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3us(red, green, blue); +} + +void gl1_4_glSecondaryColor3uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3uiv(v); +} + +void gl1_4_glSecondaryColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3ui(red, green, blue); +} + +void gl1_4_glSecondaryColor3ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3ubv(v); +} + +void gl1_4_glSecondaryColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3ub(red, green, blue); +} + +void gl1_4_glSecondaryColor3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3sv(v); +} + +void gl1_4_glSecondaryColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3s(red, green, blue); +} + +void gl1_4_glSecondaryColor3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3iv(v); +} + +void gl1_4_glSecondaryColor3i(void *_glfuncs, GLint red, GLint green, GLint blue) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3i(red, green, blue); +} + +void gl1_4_glSecondaryColor3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3fv(v); +} + +void gl1_4_glSecondaryColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3f(red, green, blue); +} + +void gl1_4_glSecondaryColor3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3dv(v); +} + +void gl1_4_glSecondaryColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3d(red, green, blue); +} + +void gl1_4_glSecondaryColor3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3bv(v); +} + +void gl1_4_glSecondaryColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3b(red, green, blue); +} + +void gl1_4_glFogCoordPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordPointer(gltype, stride, pointer); +} + +void gl1_4_glFogCoorddv(void *_glfuncs, const GLdouble* coord) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoorddv(coord); +} + +void gl1_4_glFogCoordd(void *_glfuncs, GLdouble coord) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordd(coord); +} + +void gl1_4_glFogCoordfv(void *_glfuncs, const GLfloat* coord) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordfv(coord); +} + +void gl1_4_glFogCoordf(void *_glfuncs, GLfloat coord) +{ + QOpenGLFunctions_1_4* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordf(coord); +} + diff --git a/gl/1.4/funcs.h b/gl/1.4/funcs.h new file mode 100644 index 00000000..ea657e08 --- /dev/null +++ b/gl/1.4/funcs.h @@ -0,0 +1,504 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#ifndef __cplusplus +#include +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef char GLchar; +typedef signed char GLbyte; /* 1-byte signed */ +typedef short GLshort; /* 2-byte signed */ +typedef int GLint; /* 4-byte signed */ +typedef unsigned char GLubyte; /* 1-byte unsigned */ +typedef unsigned short GLushort; /* 2-byte unsigned */ +typedef unsigned int GLuint; /* 4-byte unsigned */ +typedef int GLsizei; /* 4-byte signed */ +typedef float GLfloat; /* single precision float */ +typedef float GLclampf; /* single precision float in [0,1] */ +typedef double GLdouble; /* double precision float */ +typedef double GLclampd; /* double precision float in [0,1] */ +typedef int64_t GLint64; +typedef uint64_t GLuint64; +typedef ptrdiff_t GLintptr; +typedef ptrdiff_t GLsizeiptr; +typedef ptrdiff_t GLintptrARB; +typedef ptrdiff_t GLsizeiptrARB; +typedef struct __GLsync *GLsync; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +void *gl1_4_funcs(); + +void gl1_4_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl1_4_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal); +GLboolean gl1_4_glIsEnabled(void *_glfuncs, GLenum cap); +void gl1_4_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params); +void gl1_4_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params); +void gl1_4_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl1_4_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl1_4_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels); +void gl1_4_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params); +void gl1_4_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params); +GLenum gl1_4_glGetError(void *_glfuncs); +void gl1_4_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params); +void gl1_4_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params); +void gl1_4_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels); +void gl1_4_glReadBuffer(void *_glfuncs, GLenum mode); +void gl1_4_glPixelStorei(void *_glfuncs, GLenum pname, GLint param); +void gl1_4_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param); +void gl1_4_glDepthFunc(void *_glfuncs, GLenum glfunc); +void gl1_4_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass); +void gl1_4_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask); +void gl1_4_glLogicOp(void *_glfuncs, GLenum opcode); +void gl1_4_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor); +void gl1_4_glFlush(void *_glfuncs); +void gl1_4_glFinish(void *_glfuncs); +void gl1_4_glEnable(void *_glfuncs, GLenum cap); +void gl1_4_glDisable(void *_glfuncs, GLenum cap); +void gl1_4_glDepthMask(void *_glfuncs, GLboolean flag); +void gl1_4_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +void gl1_4_glStencilMask(void *_glfuncs, GLuint mask); +void gl1_4_glClearDepth(void *_glfuncs, GLdouble depth); +void gl1_4_glClearStencil(void *_glfuncs, GLint s); +void gl1_4_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl1_4_glClear(void *_glfuncs, GLbitfield mask); +void gl1_4_glDrawBuffer(void *_glfuncs, GLenum mode); +void gl1_4_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_4_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_4_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl1_4_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl1_4_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl1_4_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl1_4_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl1_4_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode); +void gl1_4_glPointSize(void *_glfuncs, GLfloat size); +void gl1_4_glLineWidth(void *_glfuncs, GLfloat width); +void gl1_4_glHint(void *_glfuncs, GLenum target, GLenum mode); +void gl1_4_glFrontFace(void *_glfuncs, GLenum mode); +void gl1_4_glCullFace(void *_glfuncs, GLenum mode); +void gl1_4_glIndexubv(void *_glfuncs, const GLubyte* c); +void gl1_4_glIndexub(void *_glfuncs, GLubyte c); +GLboolean gl1_4_glIsTexture(void *_glfuncs, GLuint texture); +void gl1_4_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures); +void gl1_4_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures); +void gl1_4_glBindTexture(void *_glfuncs, GLenum target, GLuint texture); +void gl1_4_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_4_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_4_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl1_4_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +void gl1_4_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +void gl1_4_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border); +void gl1_4_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units); +void gl1_4_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl1_4_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count); +void gl1_4_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl1_4_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_4_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_4_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl1_4_glBlendEquation(void *_glfuncs, GLenum mode); +void gl1_4_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl1_4_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img); +void gl1_4_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl1_4_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl1_4_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl1_4_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data); +void gl1_4_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data); +void gl1_4_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data); +void gl1_4_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert); +void gl1_4_glActiveTexture(void *_glfuncs, GLenum texture); +void gl1_4_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params); +void gl1_4_glPointParameteri(void *_glfuncs, GLenum pname, GLint param); +void gl1_4_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl1_4_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param); +void gl1_4_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount); +void gl1_4_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +void gl1_4_glTranslatef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl1_4_glTranslated(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl1_4_glScalef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl1_4_glScaled(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl1_4_glRotatef(void *_glfuncs, GLfloat angle, GLfloat x, GLfloat y, GLfloat z); +void gl1_4_glRotated(void *_glfuncs, GLdouble angle, GLdouble x, GLdouble y, GLdouble z); +void gl1_4_glPushMatrix(void *_glfuncs); +void gl1_4_glPopMatrix(void *_glfuncs); +void gl1_4_glOrtho(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +void gl1_4_glMultMatrixd(void *_glfuncs, const GLdouble* m); +void gl1_4_glMultMatrixf(void *_glfuncs, const GLfloat* m); +void gl1_4_glMatrixMode(void *_glfuncs, GLenum mode); +void gl1_4_glLoadMatrixd(void *_glfuncs, const GLdouble* m); +void gl1_4_glLoadMatrixf(void *_glfuncs, const GLfloat* m); +void gl1_4_glLoadIdentity(void *_glfuncs); +void gl1_4_glFrustum(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +GLboolean gl1_4_glIsList(void *_glfuncs, GLuint list); +void gl1_4_glGetTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, GLint* params); +void gl1_4_glGetTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, GLfloat* params); +void gl1_4_glGetTexGendv(void *_glfuncs, GLenum coord, GLenum pname, GLdouble* params); +void gl1_4_glGetTexEnviv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl1_4_glGetTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl1_4_glGetPolygonStipple(void *_glfuncs, GLubyte* mask); +void gl1_4_glGetPixelMapusv(void *_glfuncs, GLenum glmap, GLushort* values); +void gl1_4_glGetPixelMapuiv(void *_glfuncs, GLenum glmap, GLuint* values); +void gl1_4_glGetPixelMapfv(void *_glfuncs, GLenum glmap, GLfloat* values); +void gl1_4_glGetMaterialiv(void *_glfuncs, GLenum face, GLenum pname, GLint* params); +void gl1_4_glGetMaterialfv(void *_glfuncs, GLenum face, GLenum pname, GLfloat* params); +void gl1_4_glGetMapiv(void *_glfuncs, GLenum target, GLenum query, GLint* v); +void gl1_4_glGetMapfv(void *_glfuncs, GLenum target, GLenum query, GLfloat* v); +void gl1_4_glGetMapdv(void *_glfuncs, GLenum target, GLenum query, GLdouble* v); +void gl1_4_glGetLightiv(void *_glfuncs, GLenum light, GLenum pname, GLint* params); +void gl1_4_glGetLightfv(void *_glfuncs, GLenum light, GLenum pname, GLfloat* params); +void gl1_4_glGetClipPlane(void *_glfuncs, GLenum plane, GLdouble* equation); +void gl1_4_glDrawPixels(void *_glfuncs, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_4_glCopyPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum gltype); +void gl1_4_glPixelMapusv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLushort* values); +void gl1_4_glPixelMapuiv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLuint* values); +void gl1_4_glPixelMapfv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLfloat* values); +void gl1_4_glPixelTransferi(void *_glfuncs, GLenum pname, GLint param); +void gl1_4_glPixelTransferf(void *_glfuncs, GLenum pname, GLfloat param); +void gl1_4_glPixelZoom(void *_glfuncs, GLfloat xfactor, GLfloat yfactor); +void gl1_4_glAlphaFunc(void *_glfuncs, GLenum glfunc, GLfloat ref); +void gl1_4_glEvalPoint2(void *_glfuncs, GLint i, GLint j); +void gl1_4_glEvalMesh2(void *_glfuncs, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); +void gl1_4_glEvalPoint1(void *_glfuncs, GLint i); +void gl1_4_glEvalMesh1(void *_glfuncs, GLenum mode, GLint i1, GLint i2); +void gl1_4_glEvalCoord2fv(void *_glfuncs, const GLfloat* u); +void gl1_4_glEvalCoord2f(void *_glfuncs, GLfloat u, GLfloat v); +void gl1_4_glEvalCoord2dv(void *_glfuncs, const GLdouble* u); +void gl1_4_glEvalCoord2d(void *_glfuncs, GLdouble u, GLdouble v); +void gl1_4_glEvalCoord1fv(void *_glfuncs, const GLfloat* u); +void gl1_4_glEvalCoord1f(void *_glfuncs, GLfloat u); +void gl1_4_glEvalCoord1dv(void *_glfuncs, const GLdouble* u); +void gl1_4_glEvalCoord1d(void *_glfuncs, GLdouble u); +void gl1_4_glMapGrid2f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); +void gl1_4_glMapGrid2d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); +void gl1_4_glMapGrid1f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2); +void gl1_4_glMapGrid1d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2); +void gl1_4_glMap2f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points); +void gl1_4_glMap2d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points); +void gl1_4_glMap1f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points); +void gl1_4_glMap1d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points); +void gl1_4_glPushAttrib(void *_glfuncs, GLbitfield mask); +void gl1_4_glPopAttrib(void *_glfuncs); +void gl1_4_glAccum(void *_glfuncs, GLenum op, GLfloat value); +void gl1_4_glIndexMask(void *_glfuncs, GLuint mask); +void gl1_4_glClearIndex(void *_glfuncs, GLfloat c); +void gl1_4_glClearAccum(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl1_4_glPushName(void *_glfuncs, GLuint name); +void gl1_4_glPopName(void *_glfuncs); +void gl1_4_glPassThrough(void *_glfuncs, GLfloat token); +void gl1_4_glLoadName(void *_glfuncs, GLuint name); +void gl1_4_glInitNames(void *_glfuncs); +GLint gl1_4_glRenderMode(void *_glfuncs, GLenum mode); +void gl1_4_glSelectBuffer(void *_glfuncs, GLsizei size, GLuint* buffer); +void gl1_4_glFeedbackBuffer(void *_glfuncs, GLsizei size, GLenum gltype, GLfloat* buffer); +void gl1_4_glTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, const GLint* params); +void gl1_4_glTexGeni(void *_glfuncs, GLenum coord, GLenum pname, GLint param); +void gl1_4_glTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, const GLfloat* params); +void gl1_4_glTexGenf(void *_glfuncs, GLenum coord, GLenum pname, GLfloat param); +void gl1_4_glTexGendv(void *_glfuncs, GLenum coord, GLenum pname, const GLdouble* params); +void gl1_4_glTexGend(void *_glfuncs, GLenum coord, GLenum pname, GLdouble param); +void gl1_4_glTexEnviv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl1_4_glTexEnvi(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl1_4_glTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl1_4_glTexEnvf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl1_4_glShadeModel(void *_glfuncs, GLenum mode); +void gl1_4_glPolygonStipple(void *_glfuncs, const GLubyte* mask); +void gl1_4_glMaterialiv(void *_glfuncs, GLenum face, GLenum pname, const GLint* params); +void gl1_4_glMateriali(void *_glfuncs, GLenum face, GLenum pname, GLint param); +void gl1_4_glMaterialfv(void *_glfuncs, GLenum face, GLenum pname, const GLfloat* params); +void gl1_4_glMaterialf(void *_glfuncs, GLenum face, GLenum pname, GLfloat param); +void gl1_4_glLineStipple(void *_glfuncs, GLint factor, GLushort pattern); +void gl1_4_glLightModeliv(void *_glfuncs, GLenum pname, const GLint* params); +void gl1_4_glLightModeli(void *_glfuncs, GLenum pname, GLint param); +void gl1_4_glLightModelfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl1_4_glLightModelf(void *_glfuncs, GLenum pname, GLfloat param); +void gl1_4_glLightiv(void *_glfuncs, GLenum light, GLenum pname, const GLint* params); +void gl1_4_glLighti(void *_glfuncs, GLenum light, GLenum pname, GLint param); +void gl1_4_glLightfv(void *_glfuncs, GLenum light, GLenum pname, const GLfloat* params); +void gl1_4_glLightf(void *_glfuncs, GLenum light, GLenum pname, GLfloat param); +void gl1_4_glFogiv(void *_glfuncs, GLenum pname, const GLint* params); +void gl1_4_glFogi(void *_glfuncs, GLenum pname, GLint param); +void gl1_4_glFogfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl1_4_glFogf(void *_glfuncs, GLenum pname, GLfloat param); +void gl1_4_glColorMaterial(void *_glfuncs, GLenum face, GLenum mode); +void gl1_4_glClipPlane(void *_glfuncs, GLenum plane, const GLdouble* equation); +void gl1_4_glVertex4sv(void *_glfuncs, const GLshort* v); +void gl1_4_glVertex4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w); +void gl1_4_glVertex4iv(void *_glfuncs, const GLint* v); +void gl1_4_glVertex4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w); +void gl1_4_glVertex4fv(void *_glfuncs, const GLfloat* v); +void gl1_4_glVertex4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl1_4_glVertex4dv(void *_glfuncs, const GLdouble* v); +void gl1_4_glVertex4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl1_4_glVertex3sv(void *_glfuncs, const GLshort* v); +void gl1_4_glVertex3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl1_4_glVertex3iv(void *_glfuncs, const GLint* v); +void gl1_4_glVertex3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl1_4_glVertex3fv(void *_glfuncs, const GLfloat* v); +void gl1_4_glVertex3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl1_4_glVertex3dv(void *_glfuncs, const GLdouble* v); +void gl1_4_glVertex3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl1_4_glVertex2sv(void *_glfuncs, const GLshort* v); +void gl1_4_glVertex2s(void *_glfuncs, GLshort x, GLshort y); +void gl1_4_glVertex2iv(void *_glfuncs, const GLint* v); +void gl1_4_glVertex2i(void *_glfuncs, GLint x, GLint y); +void gl1_4_glVertex2fv(void *_glfuncs, const GLfloat* v); +void gl1_4_glVertex2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl1_4_glVertex2dv(void *_glfuncs, const GLdouble* v); +void gl1_4_glVertex2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl1_4_glTexCoord4sv(void *_glfuncs, const GLshort* v); +void gl1_4_glTexCoord4s(void *_glfuncs, GLshort s, GLshort t, GLshort r, GLshort q); +void gl1_4_glTexCoord4iv(void *_glfuncs, const GLint* v); +void gl1_4_glTexCoord4i(void *_glfuncs, GLint s, GLint t, GLint r, GLint q); +void gl1_4_glTexCoord4fv(void *_glfuncs, const GLfloat* v); +void gl1_4_glTexCoord4f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +void gl1_4_glTexCoord4dv(void *_glfuncs, const GLdouble* v); +void gl1_4_glTexCoord4d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +void gl1_4_glTexCoord3sv(void *_glfuncs, const GLshort* v); +void gl1_4_glTexCoord3s(void *_glfuncs, GLshort s, GLshort t, GLshort r); +void gl1_4_glTexCoord3iv(void *_glfuncs, const GLint* v); +void gl1_4_glTexCoord3i(void *_glfuncs, GLint s, GLint t, GLint r); +void gl1_4_glTexCoord3fv(void *_glfuncs, const GLfloat* v); +void gl1_4_glTexCoord3f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r); +void gl1_4_glTexCoord3dv(void *_glfuncs, const GLdouble* v); +void gl1_4_glTexCoord3d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r); +void gl1_4_glTexCoord2sv(void *_glfuncs, const GLshort* v); +void gl1_4_glTexCoord2s(void *_glfuncs, GLshort s, GLshort t); +void gl1_4_glTexCoord2iv(void *_glfuncs, const GLint* v); +void gl1_4_glTexCoord2i(void *_glfuncs, GLint s, GLint t); +void gl1_4_glTexCoord2fv(void *_glfuncs, const GLfloat* v); +void gl1_4_glTexCoord2f(void *_glfuncs, GLfloat s, GLfloat t); +void gl1_4_glTexCoord2dv(void *_glfuncs, const GLdouble* v); +void gl1_4_glTexCoord2d(void *_glfuncs, GLdouble s, GLdouble t); +void gl1_4_glTexCoord1sv(void *_glfuncs, const GLshort* v); +void gl1_4_glTexCoord1s(void *_glfuncs, GLshort s); +void gl1_4_glTexCoord1iv(void *_glfuncs, const GLint* v); +void gl1_4_glTexCoord1i(void *_glfuncs, GLint s); +void gl1_4_glTexCoord1fv(void *_glfuncs, const GLfloat* v); +void gl1_4_glTexCoord1f(void *_glfuncs, GLfloat s); +void gl1_4_glTexCoord1dv(void *_glfuncs, const GLdouble* v); +void gl1_4_glTexCoord1d(void *_glfuncs, GLdouble s); +void gl1_4_glRectsv(void *_glfuncs, const GLshort* v1, const GLshort* v2); +void gl1_4_glRects(void *_glfuncs, GLshort x1, GLshort y1, GLshort x2, GLshort y2); +void gl1_4_glRectiv(void *_glfuncs, const GLint* v1, const GLint* v2); +void gl1_4_glRecti(void *_glfuncs, GLint x1, GLint y1, GLint x2, GLint y2); +void gl1_4_glRectfv(void *_glfuncs, const GLfloat* v1, const GLfloat* v2); +void gl1_4_glRectf(void *_glfuncs, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); +void gl1_4_glRectdv(void *_glfuncs, const GLdouble* v1, const GLdouble* v2); +void gl1_4_glRectd(void *_glfuncs, GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); +void gl1_4_glRasterPos4sv(void *_glfuncs, const GLshort* v); +void gl1_4_glRasterPos4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w); +void gl1_4_glRasterPos4iv(void *_glfuncs, const GLint* v); +void gl1_4_glRasterPos4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w); +void gl1_4_glRasterPos4fv(void *_glfuncs, const GLfloat* v); +void gl1_4_glRasterPos4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl1_4_glRasterPos4dv(void *_glfuncs, const GLdouble* v); +void gl1_4_glRasterPos4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl1_4_glRasterPos3sv(void *_glfuncs, const GLshort* v); +void gl1_4_glRasterPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl1_4_glRasterPos3iv(void *_glfuncs, const GLint* v); +void gl1_4_glRasterPos3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl1_4_glRasterPos3fv(void *_glfuncs, const GLfloat* v); +void gl1_4_glRasterPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl1_4_glRasterPos3dv(void *_glfuncs, const GLdouble* v); +void gl1_4_glRasterPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl1_4_glRasterPos2sv(void *_glfuncs, const GLshort* v); +void gl1_4_glRasterPos2s(void *_glfuncs, GLshort x, GLshort y); +void gl1_4_glRasterPos2iv(void *_glfuncs, const GLint* v); +void gl1_4_glRasterPos2i(void *_glfuncs, GLint x, GLint y); +void gl1_4_glRasterPos2fv(void *_glfuncs, const GLfloat* v); +void gl1_4_glRasterPos2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl1_4_glRasterPos2dv(void *_glfuncs, const GLdouble* v); +void gl1_4_glRasterPos2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl1_4_glNormal3sv(void *_glfuncs, const GLshort* v); +void gl1_4_glNormal3s(void *_glfuncs, GLshort nx, GLshort ny, GLshort nz); +void gl1_4_glNormal3iv(void *_glfuncs, const GLint* v); +void gl1_4_glNormal3i(void *_glfuncs, GLint nx, GLint ny, GLint nz); +void gl1_4_glNormal3fv(void *_glfuncs, const GLfloat* v); +void gl1_4_glNormal3f(void *_glfuncs, GLfloat nx, GLfloat ny, GLfloat nz); +void gl1_4_glNormal3dv(void *_glfuncs, const GLdouble* v); +void gl1_4_glNormal3d(void *_glfuncs, GLdouble nx, GLdouble ny, GLdouble nz); +void gl1_4_glNormal3bv(void *_glfuncs, const GLbyte* v); +void gl1_4_glNormal3b(void *_glfuncs, GLbyte nx, GLbyte ny, GLbyte nz); +void gl1_4_glIndexsv(void *_glfuncs, const GLshort* c); +void gl1_4_glIndexs(void *_glfuncs, GLshort c); +void gl1_4_glIndexiv(void *_glfuncs, const GLint* c); +void gl1_4_glIndexi(void *_glfuncs, GLint c); +void gl1_4_glIndexfv(void *_glfuncs, const GLfloat* c); +void gl1_4_glIndexf(void *_glfuncs, GLfloat c); +void gl1_4_glIndexdv(void *_glfuncs, const GLdouble* c); +void gl1_4_glIndexd(void *_glfuncs, GLdouble c); +void gl1_4_glEnd(void *_glfuncs); +void gl1_4_glEdgeFlagv(void *_glfuncs, const GLboolean* flag); +void gl1_4_glEdgeFlag(void *_glfuncs, GLboolean flag); +void gl1_4_glColor4usv(void *_glfuncs, const GLushort* v); +void gl1_4_glColor4us(void *_glfuncs, GLushort red, GLushort green, GLushort blue, GLushort alpha); +void gl1_4_glColor4uiv(void *_glfuncs, const GLuint* v); +void gl1_4_glColor4ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue, GLuint alpha); +void gl1_4_glColor4ubv(void *_glfuncs, const GLubyte* v); +void gl1_4_glColor4ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); +void gl1_4_glColor4sv(void *_glfuncs, const GLshort* v); +void gl1_4_glColor4s(void *_glfuncs, GLshort red, GLshort green, GLshort blue, GLshort alpha); +void gl1_4_glColor4iv(void *_glfuncs, const GLint* v); +void gl1_4_glColor4i(void *_glfuncs, GLint red, GLint green, GLint blue, GLint alpha); +void gl1_4_glColor4fv(void *_glfuncs, const GLfloat* v); +void gl1_4_glColor4f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl1_4_glColor4dv(void *_glfuncs, const GLdouble* v); +void gl1_4_glColor4d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); +void gl1_4_glColor4bv(void *_glfuncs, const GLbyte* v); +void gl1_4_glColor4b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); +void gl1_4_glColor3usv(void *_glfuncs, const GLushort* v); +void gl1_4_glColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue); +void gl1_4_glColor3uiv(void *_glfuncs, const GLuint* v); +void gl1_4_glColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue); +void gl1_4_glColor3ubv(void *_glfuncs, const GLubyte* v); +void gl1_4_glColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue); +void gl1_4_glColor3sv(void *_glfuncs, const GLshort* v); +void gl1_4_glColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue); +void gl1_4_glColor3iv(void *_glfuncs, const GLint* v); +void gl1_4_glColor3i(void *_glfuncs, GLint red, GLint green, GLint blue); +void gl1_4_glColor3fv(void *_glfuncs, const GLfloat* v); +void gl1_4_glColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue); +void gl1_4_glColor3dv(void *_glfuncs, const GLdouble* v); +void gl1_4_glColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue); +void gl1_4_glColor3bv(void *_glfuncs, const GLbyte* v); +void gl1_4_glColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue); +void gl1_4_glBitmap(void *_glfuncs, GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap); +void gl1_4_glBegin(void *_glfuncs, GLenum mode); +void gl1_4_glListBase(void *_glfuncs, GLuint base); +GLuint gl1_4_glGenLists(void *_glfuncs, GLsizei range_); +void gl1_4_glDeleteLists(void *_glfuncs, GLuint list, GLsizei range_); +void gl1_4_glCallLists(void *_glfuncs, GLsizei n, GLenum gltype, const GLvoid* lists); +void gl1_4_glCallList(void *_glfuncs, GLuint list); +void gl1_4_glEndList(void *_glfuncs); +void gl1_4_glNewList(void *_glfuncs, GLuint list, GLenum mode); +void gl1_4_glPushClientAttrib(void *_glfuncs, GLbitfield mask); +void gl1_4_glPopClientAttrib(void *_glfuncs); +void gl1_4_glPrioritizeTextures(void *_glfuncs, GLsizei n, const GLuint* textures, const GLfloat* priorities); +GLboolean gl1_4_glAreTexturesResident(void *_glfuncs, GLsizei n, const GLuint* textures, GLboolean* residences); +void gl1_4_glVertexPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl1_4_glTexCoordPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl1_4_glNormalPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl1_4_glInterleavedArrays(void *_glfuncs, GLenum format, GLsizei stride, const GLvoid* pointer); +void gl1_4_glIndexPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl1_4_glEnableClientState(void *_glfuncs, GLenum array); +void gl1_4_glEdgeFlagPointer(void *_glfuncs, GLsizei stride, const GLvoid* pointer); +void gl1_4_glDisableClientState(void *_glfuncs, GLenum array); +void gl1_4_glColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl1_4_glArrayElement(void *_glfuncs, GLint i); +void gl1_4_glResetMinmax(void *_glfuncs, GLenum target); +void gl1_4_glResetHistogram(void *_glfuncs, GLenum target); +void gl1_4_glMinmax(void *_glfuncs, GLenum target, GLenum internalFormat, GLboolean sink); +void gl1_4_glHistogram(void *_glfuncs, GLenum target, GLsizei width, GLenum internalFormat, GLboolean sink); +void gl1_4_glGetMinmaxParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl1_4_glGetMinmaxParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl1_4_glGetMinmax(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values); +void gl1_4_glGetHistogramParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl1_4_glGetHistogramParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl1_4_glGetHistogram(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values); +void gl1_4_glSeparableFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* row, const GLvoid* column); +void gl1_4_glGetSeparableFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* row, GLvoid* column, GLvoid* span); +void gl1_4_glGetConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl1_4_glGetConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl1_4_glGetConvolutionFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* image); +void gl1_4_glCopyConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height); +void gl1_4_glCopyConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width); +void gl1_4_glConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl1_4_glConvolutionParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint params); +void gl1_4_glConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl1_4_glConvolutionParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat params); +void gl1_4_glConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* image); +void gl1_4_glConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* image); +void gl1_4_glCopyColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); +void gl1_4_glColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum gltype, const GLvoid* data); +void gl1_4_glGetColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl1_4_glGetColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl1_4_glGetColorTable(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* table); +void gl1_4_glCopyColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width); +void gl1_4_glColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl1_4_glColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl1_4_glColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* table); +void gl1_4_glMultTransposeMatrixd(void *_glfuncs, const GLdouble* m); +void gl1_4_glMultTransposeMatrixf(void *_glfuncs, const GLfloat* m); +void gl1_4_glLoadTransposeMatrixd(void *_glfuncs, const GLdouble* m); +void gl1_4_glLoadTransposeMatrixf(void *_glfuncs, const GLfloat* m); +void gl1_4_glMultiTexCoord4sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl1_4_glMultiTexCoord4s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); +void gl1_4_glMultiTexCoord4iv(void *_glfuncs, GLenum target, const GLint* v); +void gl1_4_glMultiTexCoord4i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r, GLint q); +void gl1_4_glMultiTexCoord4fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl1_4_glMultiTexCoord4f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +void gl1_4_glMultiTexCoord4dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl1_4_glMultiTexCoord4d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +void gl1_4_glMultiTexCoord3sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl1_4_glMultiTexCoord3s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r); +void gl1_4_glMultiTexCoord3iv(void *_glfuncs, GLenum target, const GLint* v); +void gl1_4_glMultiTexCoord3i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r); +void gl1_4_glMultiTexCoord3fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl1_4_glMultiTexCoord3f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r); +void gl1_4_glMultiTexCoord3dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl1_4_glMultiTexCoord3d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r); +void gl1_4_glMultiTexCoord2sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl1_4_glMultiTexCoord2s(void *_glfuncs, GLenum target, GLshort s, GLshort t); +void gl1_4_glMultiTexCoord2iv(void *_glfuncs, GLenum target, const GLint* v); +void gl1_4_glMultiTexCoord2i(void *_glfuncs, GLenum target, GLint s, GLint t); +void gl1_4_glMultiTexCoord2fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl1_4_glMultiTexCoord2f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t); +void gl1_4_glMultiTexCoord2dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl1_4_glMultiTexCoord2d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t); +void gl1_4_glMultiTexCoord1sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl1_4_glMultiTexCoord1s(void *_glfuncs, GLenum target, GLshort s); +void gl1_4_glMultiTexCoord1iv(void *_glfuncs, GLenum target, const GLint* v); +void gl1_4_glMultiTexCoord1i(void *_glfuncs, GLenum target, GLint s); +void gl1_4_glMultiTexCoord1fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl1_4_glMultiTexCoord1f(void *_glfuncs, GLenum target, GLfloat s); +void gl1_4_glMultiTexCoord1dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl1_4_glMultiTexCoord1d(void *_glfuncs, GLenum target, GLdouble s); +void gl1_4_glClientActiveTexture(void *_glfuncs, GLenum texture); +void gl1_4_glWindowPos3sv(void *_glfuncs, const GLshort* v); +void gl1_4_glWindowPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl1_4_glWindowPos3iv(void *_glfuncs, const GLint* v); +void gl1_4_glWindowPos3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl1_4_glWindowPos3fv(void *_glfuncs, const GLfloat* v); +void gl1_4_glWindowPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl1_4_glWindowPos3dv(void *_glfuncs, const GLdouble* v); +void gl1_4_glWindowPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl1_4_glWindowPos2sv(void *_glfuncs, const GLshort* v); +void gl1_4_glWindowPos2s(void *_glfuncs, GLshort x, GLshort y); +void gl1_4_glWindowPos2iv(void *_glfuncs, const GLint* v); +void gl1_4_glWindowPos2i(void *_glfuncs, GLint x, GLint y); +void gl1_4_glWindowPos2fv(void *_glfuncs, const GLfloat* v); +void gl1_4_glWindowPos2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl1_4_glWindowPos2dv(void *_glfuncs, const GLdouble* v); +void gl1_4_glWindowPos2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl1_4_glSecondaryColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl1_4_glSecondaryColor3usv(void *_glfuncs, const GLushort* v); +void gl1_4_glSecondaryColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue); +void gl1_4_glSecondaryColor3uiv(void *_glfuncs, const GLuint* v); +void gl1_4_glSecondaryColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue); +void gl1_4_glSecondaryColor3ubv(void *_glfuncs, const GLubyte* v); +void gl1_4_glSecondaryColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue); +void gl1_4_glSecondaryColor3sv(void *_glfuncs, const GLshort* v); +void gl1_4_glSecondaryColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue); +void gl1_4_glSecondaryColor3iv(void *_glfuncs, const GLint* v); +void gl1_4_glSecondaryColor3i(void *_glfuncs, GLint red, GLint green, GLint blue); +void gl1_4_glSecondaryColor3fv(void *_glfuncs, const GLfloat* v); +void gl1_4_glSecondaryColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue); +void gl1_4_glSecondaryColor3dv(void *_glfuncs, const GLdouble* v); +void gl1_4_glSecondaryColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue); +void gl1_4_glSecondaryColor3bv(void *_glfuncs, const GLbyte* v); +void gl1_4_glSecondaryColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue); +void gl1_4_glFogCoordPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl1_4_glFogCoorddv(void *_glfuncs, const GLdouble* coord); +void gl1_4_glFogCoordd(void *_glfuncs, GLdouble coord); +void gl1_4_glFogCoordfv(void *_glfuncs, const GLfloat* coord); +void gl1_4_glFogCoordf(void *_glfuncs, GLfloat coord); + + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/gl/1.4/gl.go b/gl/1.4/gl.go new file mode 100644 index 00000000..6ddbc244 --- /dev/null +++ b/gl/1.4/gl.go @@ -0,0 +1,3892 @@ +// ** file automatically generated by glgen -- do not edit manually ** + +package GL + +// #cgo CXXFLAGS: -std=c++0x -pedantic-errors -Wall -fno-strict-aliasing +// #cgo LDFLAGS: -lstdc++ +// #cgo pkg-config: Qt5Core Qt5OpenGL +// +// #include "funcs.h" +// +// void free(void*); +// +import "C" + +import ( + "fmt" + "reflect" + "unsafe" + + "gopkg.in/qml.v1/gl/glbase" +) + +// API returns a value that offers methods matching the OpenGL version 1.4 API. +// +// The returned API must not be used after the provided OpenGL context becomes invalid. +func API(context glbase.Contexter) *GL { + gl := &GL{} + gl.funcs = C.gl1_4_funcs() + if gl.funcs == nil { + panic(fmt.Errorf("OpenGL version 1.4 is not available")) + } + return gl +} + +// GL implements the OpenGL version 1.4 API. Values of this +// type must be created via the API function, and it must not be used after +// the associated OpenGL context becomes invalid. +type GL struct { + funcs unsafe.Pointer +} + +const ( + FALSE = 0 + TRUE = 1 + NONE = 0 + + BYTE = 0x1400 + UNSIGNED_BYTE = 0x1401 + SHORT = 0x1402 + UNSIGNED_SHORT = 0x1403 + INT = 0x1404 + UNSIGNED_INT = 0x1405 + FLOAT = 0x1406 + N2_BYTES = 0x1407 + N3_BYTES = 0x1408 + N4_BYTES = 0x1409 + DOUBLE = 0x140A + + ACCUM = 0x0100 + LOAD = 0x0101 + RETURN = 0x0102 + MULT = 0x0103 + ADD = 0x0104 + + ACCUM_BUFFER_BIT = 0x00000200 + ALL_ATTRIB_BITS = 0xFFFFFFFF + COLOR_BUFFER_BIT = 0x00004000 + CURRENT_BIT = 0x00000001 + DEPTH_BUFFER_BIT = 0x00000100 + ENABLE_BIT = 0x00002000 + EVAL_BIT = 0x00010000 + FOG_BIT = 0x00000080 + HINT_BIT = 0x00008000 + LIGHTING_BIT = 0x00000040 + LINE_BIT = 0x00000004 + LIST_BIT = 0x00020000 + MULTISAMPLE_BIT = 0x20000000 + PIXEL_MODE_BIT = 0x00000020 + POINT_BIT = 0x00000002 + POLYGON_BIT = 0x00000008 + POLYGON_STIPPLE_BIT = 0x00000010 + SCISSOR_BIT = 0x00080000 + STENCIL_BUFFER_BIT = 0x00000400 + TEXTURE_BIT = 0x00040000 + TRANSFORM_BIT = 0x00001000 + VIEWPORT_BIT = 0x00000800 + + ALWAYS = 0x0207 + EQUAL = 0x0202 + GEQUAL = 0x0206 + GREATER = 0x0204 + LEQUAL = 0x0203 + LESS = 0x0201 + NEVER = 0x0200 + NOTEQUAL = 0x0205 + + LOGIC_OP = 0x0BF1 + + DST_ALPHA = 0x0304 + ONE = 1 + ONE_MINUS_DST_ALPHA = 0x0305 + ONE_MINUS_SRC_ALPHA = 0x0303 + ONE_MINUS_SRC_COLOR = 0x0301 + SRC_ALPHA = 0x0302 + SRC_COLOR = 0x0300 + ZERO = 0 + + DST_COLOR = 0x0306 + ONE_MINUS_DST_COLOR = 0x0307 + SRC_ALPHA_SATURATE = 0x0308 + + CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF + CLIENT_PIXEL_STORE_BIT = 0x00000001 + CLIENT_VERTEX_ARRAY_BIT = 0x00000002 + + CLIP_PLANE0 = 0x3000 + CLIP_PLANE1 = 0x3001 + CLIP_PLANE2 = 0x3002 + CLIP_PLANE3 = 0x3003 + CLIP_PLANE4 = 0x3004 + CLIP_PLANE5 = 0x3005 + + BACK = 0x0405 + FRONT = 0x0404 + FRONT_AND_BACK = 0x0408 + + AMBIENT = 0x1200 + AMBIENT_AND_DIFFUSE = 0x1602 + DIFFUSE = 0x1201 + EMISSION = 0x1600 + SPECULAR = 0x1202 + + AUX0 = 0x0409 + AUX1 = 0x040A + AUX2 = 0x040B + AUX3 = 0x040C + BACK_LEFT = 0x0402 + BACK_RIGHT = 0x0403 + FRONT_LEFT = 0x0400 + FRONT_RIGHT = 0x0401 + LEFT = 0x0406 + RIGHT = 0x0407 + + ALPHA_TEST = 0x0BC0 + AUTO_NORMAL = 0x0D80 + BLEND = 0x0BE2 + COLOR_ARRAY = 0x8076 + COLOR_LOGIC_OP = 0x0BF2 + COLOR_MATERIAL = 0x0B57 + CULL_FACE = 0x0B44 + DEPTH_TEST = 0x0B71 + DITHER = 0x0BD0 + EDGE_FLAG_ARRAY = 0x8079 + FOG = 0x0B60 + INDEX_ARRAY = 0x8077 + INDEX_LOGIC_OP = 0x0BF1 + LIGHT0 = 0x4000 + LIGHT1 = 0x4001 + LIGHT2 = 0x4002 + LIGHT3 = 0x4003 + LIGHT4 = 0x4004 + LIGHT5 = 0x4005 + LIGHT6 = 0x4006 + LIGHT7 = 0x4007 + LIGHTING = 0x0B50 + LINE_SMOOTH = 0x0B20 + LINE_STIPPLE = 0x0B24 + MAP1_COLOR_4 = 0x0D90 + MAP1_INDEX = 0x0D91 + MAP1_NORMAL = 0x0D92 + MAP1_TEXTURE_COORD_1 = 0x0D93 + MAP1_TEXTURE_COORD_2 = 0x0D94 + MAP1_TEXTURE_COORD_3 = 0x0D95 + MAP1_TEXTURE_COORD_4 = 0x0D96 + MAP1_VERTEX_3 = 0x0D97 + MAP1_VERTEX_4 = 0x0D98 + MAP2_COLOR_4 = 0x0DB0 + MAP2_INDEX = 0x0DB1 + MAP2_NORMAL = 0x0DB2 + MAP2_TEXTURE_COORD_1 = 0x0DB3 + MAP2_TEXTURE_COORD_2 = 0x0DB4 + MAP2_TEXTURE_COORD_3 = 0x0DB5 + MAP2_TEXTURE_COORD_4 = 0x0DB6 + MAP2_VERTEX_3 = 0x0DB7 + MAP2_VERTEX_4 = 0x0DB8 + NORMALIZE = 0x0BA1 + NORMAL_ARRAY = 0x8075 + POINT_SMOOTH = 0x0B10 + POLYGON_OFFSET_FILL = 0x8037 + POLYGON_OFFSET_LINE = 0x2A02 + POLYGON_OFFSET_POINT = 0x2A01 + POLYGON_SMOOTH = 0x0B41 + POLYGON_STIPPLE = 0x0B42 + SCISSOR_TEST = 0x0C11 + STENCIL_TEST = 0x0B90 + TEXTURE_1D = 0x0DE0 + TEXTURE_2D = 0x0DE1 + TEXTURE_COORD_ARRAY = 0x8078 + TEXTURE_GEN_Q = 0x0C63 + TEXTURE_GEN_R = 0x0C62 + TEXTURE_GEN_S = 0x0C60 + TEXTURE_GEN_T = 0x0C61 + VERTEX_ARRAY = 0x8074 + + INVALID_ENUM = 0x0500 + INVALID_OPERATION = 0x0502 + INVALID_VALUE = 0x0501 + NO_ERROR = 0 + OUT_OF_MEMORY = 0x0505 + STACK_OVERFLOW = 0x0503 + STACK_UNDERFLOW = 0x0504 + + N2D = 0x0600 + N3D = 0x0601 + N3D_COLOR = 0x0602 + N3D_COLOR_TEXTURE = 0x0603 + N4D_COLOR_TEXTURE = 0x0604 + + BITMAP_TOKEN = 0x0704 + COPY_PIXEL_TOKEN = 0x0706 + DRAW_PIXEL_TOKEN = 0x0705 + LINE_RESET_TOKEN = 0x0707 + LINE_TOKEN = 0x0702 + PASS_THROUGH_TOKEN = 0x0700 + POINT_TOKEN = 0x0701 + POLYGON_TOKEN = 0x0703 + + EXP = 0x0800 + EXP2 = 0x0801 + LINEAR = 0x2601 + + FOG_COLOR = 0x0B66 + FOG_DENSITY = 0x0B62 + FOG_END = 0x0B64 + FOG_INDEX = 0x0B61 + FOG_MODE = 0x0B65 + FOG_START = 0x0B63 + + CCW = 0x0901 + CW = 0x0900 + + COEFF = 0x0A00 + DOMAIN = 0x0A02 + ORDER = 0x0A01 + + PIXEL_MAP_A_TO_A = 0x0C79 + PIXEL_MAP_B_TO_B = 0x0C78 + PIXEL_MAP_G_TO_G = 0x0C77 + PIXEL_MAP_I_TO_A = 0x0C75 + PIXEL_MAP_I_TO_B = 0x0C74 + PIXEL_MAP_I_TO_G = 0x0C73 + PIXEL_MAP_I_TO_I = 0x0C70 + PIXEL_MAP_I_TO_R = 0x0C72 + PIXEL_MAP_R_TO_R = 0x0C76 + PIXEL_MAP_S_TO_S = 0x0C71 + + ACCUM_ALPHA_BITS = 0x0D5B + ACCUM_BLUE_BITS = 0x0D5A + ACCUM_CLEAR_VALUE = 0x0B80 + ACCUM_GREEN_BITS = 0x0D59 + ACCUM_RED_BITS = 0x0D58 + ALIASED_LINE_WIDTH_RANGE = 0x846E + ALIASED_POINT_SIZE_RANGE = 0x846D + ALPHA_BIAS = 0x0D1D + ALPHA_BITS = 0x0D55 + ALPHA_SCALE = 0x0D1C + ALPHA_TEST_FUNC = 0x0BC1 + ALPHA_TEST_REF = 0x0BC2 + ATTRIB_STACK_DEPTH = 0x0BB0 + AUX_BUFFERS = 0x0C00 + BLEND_DST = 0x0BE0 + BLEND_SRC = 0x0BE1 + BLUE_BIAS = 0x0D1B + BLUE_BITS = 0x0D54 + BLUE_SCALE = 0x0D1A + CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1 + COLOR_ARRAY_SIZE = 0x8081 + COLOR_ARRAY_STRIDE = 0x8083 + COLOR_ARRAY_TYPE = 0x8082 + COLOR_CLEAR_VALUE = 0x0C22 + COLOR_MATERIAL_FACE = 0x0B55 + COLOR_MATERIAL_PARAMETER = 0x0B56 + COLOR_WRITEMASK = 0x0C23 + CULL_FACE_MODE = 0x0B45 + CURRENT_COLOR = 0x0B00 + CURRENT_INDEX = 0x0B01 + CURRENT_NORMAL = 0x0B02 + CURRENT_RASTER_COLOR = 0x0B04 + CURRENT_RASTER_DISTANCE = 0x0B09 + CURRENT_RASTER_INDEX = 0x0B05 + CURRENT_RASTER_POSITION = 0x0B07 + CURRENT_RASTER_POSITION_VALID = 0x0B08 + CURRENT_RASTER_TEXTURE_COORDS = 0x0B06 + CURRENT_TEXTURE_COORDS = 0x0B03 + DEPTH_BIAS = 0x0D1F + DEPTH_BITS = 0x0D56 + DEPTH_CLEAR_VALUE = 0x0B73 + DEPTH_FUNC = 0x0B74 + DEPTH_RANGE = 0x0B70 + DEPTH_SCALE = 0x0D1E + DEPTH_WRITEMASK = 0x0B72 + DOUBLEBUFFER = 0x0C32 + DRAW_BUFFER = 0x0C01 + EDGE_FLAG = 0x0B43 + EDGE_FLAG_ARRAY_STRIDE = 0x808C + FEEDBACK_BUFFER_SIZE = 0x0DF1 + FEEDBACK_BUFFER_TYPE = 0x0DF2 + FOG_HINT = 0x0C54 + FRONT_FACE = 0x0B46 + GREEN_BIAS = 0x0D19 + GREEN_BITS = 0x0D53 + GREEN_SCALE = 0x0D18 + INDEX_ARRAY_STRIDE = 0x8086 + INDEX_ARRAY_TYPE = 0x8085 + INDEX_BITS = 0x0D51 + INDEX_CLEAR_VALUE = 0x0C20 + INDEX_MODE = 0x0C30 + INDEX_OFFSET = 0x0D13 + INDEX_SHIFT = 0x0D12 + INDEX_WRITEMASK = 0x0C21 + LIGHT_MODEL_AMBIENT = 0x0B53 + LIGHT_MODEL_COLOR_CONTROL = 0x81F8 + LIGHT_MODEL_LOCAL_VIEWER = 0x0B51 + LIGHT_MODEL_TWO_SIDE = 0x0B52 + LINE_SMOOTH_HINT = 0x0C52 + LINE_STIPPLE_PATTERN = 0x0B25 + LINE_STIPPLE_REPEAT = 0x0B26 + LINE_WIDTH = 0x0B21 + LINE_WIDTH_GRANULARITY = 0x0B23 + LINE_WIDTH_RANGE = 0x0B22 + LIST_BASE = 0x0B32 + LIST_INDEX = 0x0B33 + LIST_MODE = 0x0B30 + LOGIC_OP_MODE = 0x0BF0 + MAP1_GRID_DOMAIN = 0x0DD0 + MAP1_GRID_SEGMENTS = 0x0DD1 + MAP2_GRID_DOMAIN = 0x0DD2 + MAP2_GRID_SEGMENTS = 0x0DD3 + MAP_COLOR = 0x0D10 + MAP_STENCIL = 0x0D11 + MATRIX_MODE = 0x0BA0 + MAX_ATTRIB_STACK_DEPTH = 0x0D35 + MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B + MAX_CLIP_PLANES = 0x0D32 + MAX_EVAL_ORDER = 0x0D30 + MAX_LIGHTS = 0x0D31 + MAX_LIST_NESTING = 0x0B31 + MAX_MODELVIEW_STACK_DEPTH = 0x0D36 + MAX_NAME_STACK_DEPTH = 0x0D37 + MAX_PIXEL_MAP_TABLE = 0x0D34 + MAX_PROJECTION_STACK_DEPTH = 0x0D38 + MAX_TEXTURE_SIZE = 0x0D33 + MAX_TEXTURE_STACK_DEPTH = 0x0D39 + MAX_VIEWPORT_DIMS = 0x0D3A + MODELVIEW_MATRIX = 0x0BA6 + MODELVIEW_STACK_DEPTH = 0x0BA3 + NAME_STACK_DEPTH = 0x0D70 + NORMAL_ARRAY_STRIDE = 0x807F + NORMAL_ARRAY_TYPE = 0x807E + PACK_ALIGNMENT = 0x0D05 + PACK_LSB_FIRST = 0x0D01 + PACK_ROW_LENGTH = 0x0D02 + PACK_SKIP_PIXELS = 0x0D04 + PACK_SKIP_ROWS = 0x0D03 + PACK_SWAP_BYTES = 0x0D00 + PERSPECTIVE_CORRECTION_HINT = 0x0C50 + PIXEL_MAP_A_TO_A_SIZE = 0x0CB9 + PIXEL_MAP_B_TO_B_SIZE = 0x0CB8 + PIXEL_MAP_G_TO_G_SIZE = 0x0CB7 + PIXEL_MAP_I_TO_A_SIZE = 0x0CB5 + PIXEL_MAP_I_TO_B_SIZE = 0x0CB4 + PIXEL_MAP_I_TO_G_SIZE = 0x0CB3 + PIXEL_MAP_I_TO_I_SIZE = 0x0CB0 + PIXEL_MAP_I_TO_R_SIZE = 0x0CB2 + PIXEL_MAP_R_TO_R_SIZE = 0x0CB6 + PIXEL_MAP_S_TO_S_SIZE = 0x0CB1 + POINT_SIZE = 0x0B11 + POINT_SIZE_GRANULARITY = 0x0B13 + POINT_SIZE_RANGE = 0x0B12 + POINT_SMOOTH_HINT = 0x0C51 + POLYGON_MODE = 0x0B40 + POLYGON_OFFSET_FACTOR = 0x8038 + POLYGON_OFFSET_UNITS = 0x2A00 + POLYGON_SMOOTH_HINT = 0x0C53 + PROJECTION_MATRIX = 0x0BA7 + PROJECTION_STACK_DEPTH = 0x0BA4 + READ_BUFFER = 0x0C02 + RED_BIAS = 0x0D15 + RED_BITS = 0x0D52 + RED_SCALE = 0x0D14 + RENDER_MODE = 0x0C40 + RGBA_MODE = 0x0C31 + SCISSOR_BOX = 0x0C10 + SELECTION_BUFFER_SIZE = 0x0DF4 + SHADE_MODEL = 0x0B54 + SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23 + SMOOTH_LINE_WIDTH_RANGE = 0x0B22 + SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13 + SMOOTH_POINT_SIZE_RANGE = 0x0B12 + STENCIL_BITS = 0x0D57 + STENCIL_CLEAR_VALUE = 0x0B91 + STENCIL_FAIL = 0x0B94 + STENCIL_FUNC = 0x0B92 + STENCIL_PASS_DEPTH_FAIL = 0x0B95 + STENCIL_PASS_DEPTH_PASS = 0x0B96 + STENCIL_REF = 0x0B97 + STENCIL_VALUE_MASK = 0x0B93 + STENCIL_WRITEMASK = 0x0B98 + STEREO = 0x0C33 + SUBPIXEL_BITS = 0x0D50 + TEXTURE_BINDING_1D = 0x8068 + TEXTURE_BINDING_2D = 0x8069 + TEXTURE_BINDING_3D = 0x806A + TEXTURE_COORD_ARRAY_SIZE = 0x8088 + TEXTURE_COORD_ARRAY_STRIDE = 0x808A + TEXTURE_COORD_ARRAY_TYPE = 0x8089 + TEXTURE_MATRIX = 0x0BA8 + TEXTURE_STACK_DEPTH = 0x0BA5 + UNPACK_ALIGNMENT = 0x0CF5 + UNPACK_LSB_FIRST = 0x0CF1 + UNPACK_ROW_LENGTH = 0x0CF2 + UNPACK_SKIP_PIXELS = 0x0CF4 + UNPACK_SKIP_ROWS = 0x0CF3 + UNPACK_SWAP_BYTES = 0x0CF0 + VERTEX_ARRAY_SIZE = 0x807A + VERTEX_ARRAY_STRIDE = 0x807C + VERTEX_ARRAY_TYPE = 0x807B + VIEWPORT = 0x0BA2 + ZOOM_X = 0x0D16 + ZOOM_Y = 0x0D17 + + COLOR_ARRAY_POINTER = 0x8090 + EDGE_FLAG_ARRAY_POINTER = 0x8093 + FEEDBACK_BUFFER_POINTER = 0x0DF0 + INDEX_ARRAY_POINTER = 0x8091 + NORMAL_ARRAY_POINTER = 0x808F + SELECTION_BUFFER_POINTER = 0x0DF3 + TEXTURE_COORD_ARRAY_POINTER = 0x8092 + VERTEX_ARRAY_POINTER = 0x808E + + TEXTURE_ALPHA_SIZE = 0x805F + TEXTURE_BLUE_SIZE = 0x805E + TEXTURE_BORDER = 0x1005 + TEXTURE_BORDER_COLOR = 0x1004 + TEXTURE_COMPONENTS = 0x1003 + TEXTURE_GREEN_SIZE = 0x805D + TEXTURE_HEIGHT = 0x1001 + TEXTURE_INTENSITY_SIZE = 0x8061 + TEXTURE_INTERNAL_FORMAT = 0x1003 + TEXTURE_LUMINANCE_SIZE = 0x8060 + TEXTURE_MAG_FILTER = 0x2800 + TEXTURE_MIN_FILTER = 0x2801 + TEXTURE_PRIORITY = 0x8066 + TEXTURE_RED_SIZE = 0x805C + TEXTURE_RESIDENT = 0x8067 + TEXTURE_WIDTH = 0x1000 + TEXTURE_WRAP_S = 0x2802 + TEXTURE_WRAP_T = 0x2803 + + DONT_CARE = 0x1100 + FASTEST = 0x1101 + NICEST = 0x1102 + + GENERATE_MIPMAP_HINT = 0x8192 + TEXTURE_COMPRESSION_HINT = 0x84EF + + C3F_V3F = 0x2A24 + C4F_N3F_V3F = 0x2A26 + C4UB_V2F = 0x2A22 + C4UB_V3F = 0x2A23 + N3F_V3F = 0x2A25 + T2F_C3F_V3F = 0x2A2A + T2F_C4F_N3F_V3F = 0x2A2C + T2F_C4UB_V3F = 0x2A29 + T2F_N3F_V3F = 0x2A2B + T2F_V3F = 0x2A27 + T4F_C4F_N3F_V4F = 0x2A2D + T4F_V4F = 0x2A28 + V2F = 0x2A20 + V3F = 0x2A21 + + MODULATE = 0x2100 + REPLACE = 0x1E01 + + SEPARATE_SPECULAR_COLOR = 0x81FA + SINGLE_COLOR = 0x81F9 + + CONSTANT_ATTENUATION = 0x1207 + LINEAR_ATTENUATION = 0x1208 + POSITION = 0x1203 + QUADRATIC_ATTENUATION = 0x1209 + SPOT_CUTOFF = 0x1206 + SPOT_DIRECTION = 0x1204 + SPOT_EXPONENT = 0x1205 + + COMPILE = 0x1300 + COMPILE_AND_EXECUTE = 0x1301 + + AND = 0x1501 + AND_INVERTED = 0x1504 + AND_REVERSE = 0x1502 + CLEAR = 0x1500 + COPY = 0x1503 + COPY_INVERTED = 0x150C + EQUIV = 0x1509 + INVERT = 0x150A + NAND = 0x150E + NOOP = 0x1505 + NOR = 0x1508 + OR = 0x1507 + OR_INVERTED = 0x150D + OR_REVERSE = 0x150B + SET = 0x150F + XOR = 0x1506 + + COLOR_INDEXES = 0x1603 + SHININESS = 0x1601 + + MODELVIEW = 0x1700 + PROJECTION = 0x1701 + TEXTURE = 0x1702 + + LINE = 0x1B01 + POINT = 0x1B00 + + FILL = 0x1B02 + + COLOR = 0x1800 + DEPTH = 0x1801 + STENCIL = 0x1802 + + ALPHA = 0x1906 + BLUE = 0x1905 + COLOR_INDEX = 0x1900 + DEPTH_COMPONENT = 0x1902 + GREEN = 0x1904 + LUMINANCE = 0x1909 + LUMINANCE_ALPHA = 0x190A + RED = 0x1903 + RGB = 0x1907 + RGBA = 0x1908 + STENCIL_INDEX = 0x1901 + + ALPHA12 = 0x803D + ALPHA16 = 0x803E + ALPHA4 = 0x803B + ALPHA8 = 0x803C + INTENSITY = 0x8049 + INTENSITY12 = 0x804C + INTENSITY16 = 0x804D + INTENSITY4 = 0x804A + INTENSITY8 = 0x804B + LUMINANCE12 = 0x8041 + LUMINANCE12_ALPHA12 = 0x8047 + LUMINANCE12_ALPHA4 = 0x8046 + LUMINANCE16 = 0x8042 + LUMINANCE16_ALPHA16 = 0x8048 + LUMINANCE4 = 0x803F + LUMINANCE4_ALPHA4 = 0x8043 + LUMINANCE6_ALPHA2 = 0x8044 + LUMINANCE8 = 0x8040 + LUMINANCE8_ALPHA8 = 0x8045 + R3_G3_B2 = 0x2A10 + RGB10 = 0x8052 + RGB10_A2 = 0x8059 + RGB12 = 0x8053 + RGB16 = 0x8054 + RGB4 = 0x804F + RGB5 = 0x8050 + RGB5_A1 = 0x8057 + RGB8 = 0x8051 + RGBA12 = 0x805A + RGBA16 = 0x805B + RGBA2 = 0x8055 + RGBA4 = 0x8056 + RGBA8 = 0x8058 + + PACK_IMAGE_HEIGHT = 0x806C + PACK_SKIP_IMAGES = 0x806B + UNPACK_IMAGE_HEIGHT = 0x806E + UNPACK_SKIP_IMAGES = 0x806D + + BITMAP = 0x1A00 + UNSIGNED_BYTE_3_3_2 = 0x8032 + UNSIGNED_INT_10_10_10_2 = 0x8036 + UNSIGNED_INT_8_8_8_8 = 0x8035 + UNSIGNED_SHORT_4_4_4_4 = 0x8033 + UNSIGNED_SHORT_5_5_5_1 = 0x8034 + + POINT_DISTANCE_ATTENUATION = 0x8129 + POINT_FADE_THRESHOLD_SIZE = 0x8128 + POINT_SIZE_MAX = 0x8127 + POINT_SIZE_MIN = 0x8126 + + LINES = 0x0001 + LINE_LOOP = 0x0002 + LINE_STRIP = 0x0003 + POINTS = 0x0000 + POLYGON = 0x0009 + QUADS = 0x0007 + QUAD_STRIP = 0x0008 + TRIANGLES = 0x0004 + TRIANGLE_FAN = 0x0006 + TRIANGLE_STRIP = 0x0005 + + FEEDBACK = 0x1C01 + RENDER = 0x1C00 + SELECT = 0x1C02 + + FLAT = 0x1D00 + SMOOTH = 0x1D01 + + DECR = 0x1E03 + INCR = 0x1E02 + KEEP = 0x1E00 + + EXTENSIONS = 0x1F03 + RENDERER = 0x1F01 + VENDOR = 0x1F00 + VERSION = 0x1F02 + + S = 0x2000 + T = 0x2001 + R = 0x2002 + Q = 0x2003 + + DECAL = 0x2101 + + TEXTURE_ENV_COLOR = 0x2201 + TEXTURE_ENV_MODE = 0x2200 + + TEXTURE_ENV = 0x2300 + + EYE_LINEAR = 0x2400 + OBJECT_LINEAR = 0x2401 + SPHERE_MAP = 0x2402 + + EYE_PLANE = 0x2502 + OBJECT_PLANE = 0x2501 + TEXTURE_GEN_MODE = 0x2500 + + NEAREST = 0x2600 + + LINEAR_MIPMAP_LINEAR = 0x2703 + LINEAR_MIPMAP_NEAREST = 0x2701 + NEAREST_MIPMAP_LINEAR = 0x2702 + NEAREST_MIPMAP_NEAREST = 0x2700 + + GENERATE_MIPMAP = 0x8191 + TEXTURE_WRAP_R = 0x8072 + + PROXY_TEXTURE_1D = 0x8063 + PROXY_TEXTURE_2D = 0x8064 + PROXY_TEXTURE_3D = 0x8070 + TEXTURE_3D = 0x806F + TEXTURE_BASE_LEVEL = 0x813C + TEXTURE_MAX_LEVEL = 0x813D + TEXTURE_MAX_LOD = 0x813B + TEXTURE_MIN_LOD = 0x813A + + CLAMP = 0x2900 + CLAMP_TO_BORDER = 0x812D + CLAMP_TO_EDGE = 0x812F + REPEAT = 0x2901 + + CONSTANT_COLOR = 0x8001 + ONE_MINUS_CONSTANT_COLOR = 0x8002 + CONSTANT_ALPHA = 0x8003 + ONE_MINUS_CONSTANT_ALPHA = 0x8004 + FUNC_ADD = 0x8006 + MIN = 0x8007 + MAX = 0x8008 + FUNC_SUBTRACT = 0x800A + FUNC_REVERSE_SUBTRACT = 0x800B + RESCALE_NORMAL = 0x803A + TEXTURE_DEPTH = 0x8071 + MAX_3D_TEXTURE_SIZE = 0x8073 + MULTISAMPLE = 0x809D + SAMPLE_ALPHA_TO_COVERAGE = 0x809E + SAMPLE_ALPHA_TO_ONE = 0x809F + SAMPLE_COVERAGE = 0x80A0 + SAMPLE_BUFFERS = 0x80A8 + SAMPLES = 0x80A9 + SAMPLE_COVERAGE_VALUE = 0x80AA + SAMPLE_COVERAGE_INVERT = 0x80AB + BLEND_DST_RGB = 0x80C8 + BLEND_SRC_RGB = 0x80C9 + BLEND_DST_ALPHA = 0x80CA + BLEND_SRC_ALPHA = 0x80CB + BGR = 0x80E0 + BGRA = 0x80E1 + MAX_ELEMENTS_VERTICES = 0x80E8 + MAX_ELEMENTS_INDICES = 0x80E9 + DEPTH_COMPONENT16 = 0x81A5 + DEPTH_COMPONENT24 = 0x81A6 + DEPTH_COMPONENT32 = 0x81A7 + UNSIGNED_BYTE_2_3_3_REV = 0x8362 + UNSIGNED_SHORT_5_6_5 = 0x8363 + UNSIGNED_SHORT_5_6_5_REV = 0x8364 + UNSIGNED_SHORT_4_4_4_4_REV = 0x8365 + UNSIGNED_SHORT_1_5_5_5_REV = 0x8366 + UNSIGNED_INT_8_8_8_8_REV = 0x8367 + UNSIGNED_INT_2_10_10_10_REV = 0x8368 + MIRRORED_REPEAT = 0x8370 + FOG_COORDINATE_SOURCE = 0x8450 + FOG_COORDINATE = 0x8451 + FRAGMENT_DEPTH = 0x8452 + CURRENT_FOG_COORDINATE = 0x8453 + FOG_COORDINATE_ARRAY_TYPE = 0x8454 + FOG_COORDINATE_ARRAY_STRIDE = 0x8455 + FOG_COORDINATE_ARRAY_POINTER = 0x8456 + FOG_COORDINATE_ARRAY = 0x8457 + COLOR_SUM = 0x8458 + CURRENT_SECONDARY_COLOR = 0x8459 + SECONDARY_COLOR_ARRAY_SIZE = 0x845A + SECONDARY_COLOR_ARRAY_TYPE = 0x845B + SECONDARY_COLOR_ARRAY_STRIDE = 0x845C + SECONDARY_COLOR_ARRAY_POINTER = 0x845D + SECONDARY_COLOR_ARRAY = 0x845E + TEXTURE0 = 0x84C0 + TEXTURE1 = 0x84C1 + TEXTURE2 = 0x84C2 + TEXTURE3 = 0x84C3 + TEXTURE4 = 0x84C4 + TEXTURE5 = 0x84C5 + TEXTURE6 = 0x84C6 + TEXTURE7 = 0x84C7 + TEXTURE8 = 0x84C8 + TEXTURE9 = 0x84C9 + TEXTURE10 = 0x84CA + TEXTURE11 = 0x84CB + TEXTURE12 = 0x84CC + TEXTURE13 = 0x84CD + TEXTURE14 = 0x84CE + TEXTURE15 = 0x84CF + TEXTURE16 = 0x84D0 + TEXTURE17 = 0x84D1 + TEXTURE18 = 0x84D2 + TEXTURE19 = 0x84D3 + TEXTURE20 = 0x84D4 + TEXTURE21 = 0x84D5 + TEXTURE22 = 0x84D6 + TEXTURE23 = 0x84D7 + TEXTURE24 = 0x84D8 + TEXTURE25 = 0x84D9 + TEXTURE26 = 0x84DA + TEXTURE27 = 0x84DB + TEXTURE28 = 0x84DC + TEXTURE29 = 0x84DD + TEXTURE30 = 0x84DE + TEXTURE31 = 0x84DF + ACTIVE_TEXTURE = 0x84E0 + CLIENT_ACTIVE_TEXTURE = 0x84E1 + MAX_TEXTURE_UNITS = 0x84E2 + TRANSPOSE_MODELVIEW_MATRIX = 0x84E3 + TRANSPOSE_PROJECTION_MATRIX = 0x84E4 + TRANSPOSE_TEXTURE_MATRIX = 0x84E5 + TRANSPOSE_COLOR_MATRIX = 0x84E6 + SUBTRACT = 0x84E7 + COMPRESSED_ALPHA = 0x84E9 + COMPRESSED_LUMINANCE = 0x84EA + COMPRESSED_LUMINANCE_ALPHA = 0x84EB + COMPRESSED_INTENSITY = 0x84EC + COMPRESSED_RGB = 0x84ED + COMPRESSED_RGBA = 0x84EE + MAX_TEXTURE_LOD_BIAS = 0x84FD + TEXTURE_FILTER_CONTROL = 0x8500 + TEXTURE_LOD_BIAS = 0x8501 + INCR_WRAP = 0x8507 + DECR_WRAP = 0x8508 + NORMAL_MAP = 0x8511 + REFLECTION_MAP = 0x8512 + TEXTURE_CUBE_MAP = 0x8513 + TEXTURE_BINDING_CUBE_MAP = 0x8514 + TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515 + TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516 + TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517 + TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518 + TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519 + TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A + PROXY_TEXTURE_CUBE_MAP = 0x851B + MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C + COMBINE = 0x8570 + COMBINE_RGB = 0x8571 + COMBINE_ALPHA = 0x8572 + RGB_SCALE = 0x8573 + ADD_SIGNED = 0x8574 + INTERPOLATE = 0x8575 + CONSTANT = 0x8576 + PRIMARY_COLOR = 0x8577 + PREVIOUS = 0x8578 + SOURCE0_RGB = 0x8580 + SOURCE1_RGB = 0x8581 + SOURCE2_RGB = 0x8582 + SOURCE0_ALPHA = 0x8588 + SOURCE1_ALPHA = 0x8589 + SOURCE2_ALPHA = 0x858A + OPERAND0_RGB = 0x8590 + OPERAND1_RGB = 0x8591 + OPERAND2_RGB = 0x8592 + OPERAND0_ALPHA = 0x8598 + OPERAND1_ALPHA = 0x8599 + OPERAND2_ALPHA = 0x859A + TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0 + TEXTURE_COMPRESSED = 0x86A1 + NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2 + COMPRESSED_TEXTURE_FORMATS = 0x86A3 + DOT3_RGB = 0x86AE + DOT3_RGBA = 0x86AF + TEXTURE_DEPTH_SIZE = 0x884A + DEPTH_TEXTURE_MODE = 0x884B + TEXTURE_COMPARE_MODE = 0x884C + TEXTURE_COMPARE_FUNC = 0x884D + COMPARE_R_TO_TEXTURE = 0x884E +) + +// https://www.opengl.org/sdk/docs/man2/xhtml/glViewport.xml +func (gl *GL) Viewport(x, y, width, height int) { + C.gl1_4_glViewport(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// DepthRange specifies the mapping of depth values from normalized device +// coordinates to window coordinates. +// +// Parameter nearVal specifies the mapping of the near clipping plane to window +// coordinates (defaults to 0), while farVal specifies the mapping of the far +// clipping plane to window coordinates (defaults to 1). +// +// After clipping and division by w, depth coordinates range from -1 to 1, +// corresponding to the near and far clipping planes. DepthRange specifies a +// linear mapping of the normalized depth coordinates in this range to window +// depth coordinates. Regardless of the actual depth buffer implementation, +// window coordinate depth values are treated as though they range from 0 through 1 +// (like color components). Thus, the values accepted by DepthRange are both +// clamped to this range before they are accepted. +// +// The default setting of (0, 1) maps the near plane to 0 and the far plane to 1. +// With this mapping, the depth buffer range is fully utilized. +// +// It is not necessary that nearVal be less than farVal. Reverse mappings such as +// nearVal 1, and farVal 0 are acceptable. +// +// GL.INVALID_OPERATION is generated if DepthRange is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) DepthRange(nearVal, farVal float64) { + C.gl1_4_glDepthRange(gl.funcs, C.GLdouble(nearVal), C.GLdouble(farVal)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsEnabled.xml +func (gl *GL) IsEnabled(cap glbase.Enum) bool { + glresult := C.gl1_4_glIsEnabled(gl.funcs, C.GLenum(cap)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexLevelParameteriv.xml +func (gl *GL) GetTexLevelParameteriv(target glbase.Enum, level int, pname glbase.Enum, params []int32) { + C.gl1_4_glGetTexLevelParameteriv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexLevelParameterfv.xml +func (gl *GL) GetTexLevelParameterfv(target glbase.Enum, level int, pname glbase.Enum, params []float32) { + C.gl1_4_glGetTexLevelParameterfv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexParameteriv.xml +func (gl *GL) GetTexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_4_glGetTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexParameterfv.xml +func (gl *GL) GetTexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_4_glGetTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexImage.xml +func (gl *GL) GetTexImage(target glbase.Enum, level int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glGetTexImage(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetIntegerv.xml +func (gl *GL) GetIntegerv(pname glbase.Enum, params []int32) { + C.gl1_4_glGetIntegerv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetFloatv.xml +func (gl *GL) GetFloatv(pname glbase.Enum, params []float32) { + C.gl1_4_glGetFloatv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetError.xml +func (gl *GL) GetError() glbase.Enum { + glresult := C.gl1_4_glGetError(gl.funcs) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetDoublev.xml +func (gl *GL) GetDoublev(pname glbase.Enum, params []float64) { + C.gl1_4_glGetDoublev(gl.funcs, C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetBooleanv.xml +func (gl *GL) GetBooleanv(pname glbase.Enum, params []bool) { + C.gl1_4_glGetBooleanv(gl.funcs, C.GLenum(pname), (*C.GLboolean)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glReadPixels.xml +func (gl *GL) ReadPixels(x, y, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glReadPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glReadBuffer.xml +func (gl *GL) ReadBuffer(mode glbase.Enum) { + C.gl1_4_glReadBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelStorei.xml +func (gl *GL) PixelStorei(pname glbase.Enum, param int32) { + C.gl1_4_glPixelStorei(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelStoref.xml +func (gl *GL) PixelStoref(pname glbase.Enum, param float32) { + C.gl1_4_glPixelStoref(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDepthFunc.xml +func (gl *GL) DepthFunc(glfunc glbase.Enum) { + C.gl1_4_glDepthFunc(gl.funcs, C.GLenum(glfunc)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilOp.xml +func (gl *GL) StencilOp(fail, zfail, zpass glbase.Enum) { + C.gl1_4_glStencilOp(gl.funcs, C.GLenum(fail), C.GLenum(zfail), C.GLenum(zpass)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilFunc.xml +func (gl *GL) StencilFunc(glfunc glbase.Enum, ref int32, mask uint32) { + C.gl1_4_glStencilFunc(gl.funcs, C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLogicOp.xml +func (gl *GL) LogicOp(opcode glbase.Enum) { + C.gl1_4_glLogicOp(gl.funcs, C.GLenum(opcode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBlendFunc.xml +func (gl *GL) BlendFunc(sfactor, dfactor glbase.Enum) { + C.gl1_4_glBlendFunc(gl.funcs, C.GLenum(sfactor), C.GLenum(dfactor)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFlush.xml +func (gl *GL) Flush() { + C.gl1_4_glFlush(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFinish.xml +func (gl *GL) Finish() { + C.gl1_4_glFinish(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEnable.xml +func (gl *GL) Enable(cap glbase.Enum) { + C.gl1_4_glEnable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDisable.xml +func (gl *GL) Disable(cap glbase.Enum) { + C.gl1_4_glDisable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDepthMask.xml +func (gl *GL) DepthMask(flag bool) { + C.gl1_4_glDepthMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorMask.xml +func (gl *GL) ColorMask(red, green, blue, alpha bool) { + C.gl1_4_glColorMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&red)), *(*C.GLboolean)(unsafe.Pointer(&green)), *(*C.GLboolean)(unsafe.Pointer(&blue)), *(*C.GLboolean)(unsafe.Pointer(&alpha))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilMask.xml +func (gl *GL) StencilMask(mask uint32) { + C.gl1_4_glStencilMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearDepth.xml +func (gl *GL) ClearDepth(depth float64) { + C.gl1_4_glClearDepth(gl.funcs, C.GLdouble(depth)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearStencil.xml +func (gl *GL) ClearStencil(s int32) { + C.gl1_4_glClearStencil(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearColor.xml +func (gl *GL) ClearColor(red, green, blue, alpha float32) { + C.gl1_4_glClearColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClear.xml +func (gl *GL) Clear(mask glbase.Bitfield) { + C.gl1_4_glClear(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawBuffer.xml +func (gl *GL) DrawBuffer(mode glbase.Enum) { + C.gl1_4_glDrawBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexImage2D.xml +func (gl *GL) TexImage2D(target glbase.Enum, level int, internalFormat int32, width, height, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexImage1D.xml +func (gl *GL) TexImage1D(target glbase.Enum, level int, internalFormat int32, width, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameteriv.xml +func (gl *GL) TexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_4_glTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameteri.xml +func (gl *GL) TexParameteri(target, pname glbase.Enum, param int32) { + C.gl1_4_glTexParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameterfv.xml +func (gl *GL) TexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_4_glTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameterf.xml +func (gl *GL) TexParameterf(target, pname glbase.Enum, param float32) { + C.gl1_4_glTexParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glScissor.xml +func (gl *GL) Scissor(x, y, width, height int) { + C.gl1_4_glScissor(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPolygonMode.xml +func (gl *GL) PolygonMode(face, mode glbase.Enum) { + C.gl1_4_glPolygonMode(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPointSize.xml +func (gl *GL) PointSize(size float32) { + C.gl1_4_glPointSize(gl.funcs, C.GLfloat(size)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLineWidth.xml +func (gl *GL) LineWidth(width float32) { + C.gl1_4_glLineWidth(gl.funcs, C.GLfloat(width)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glHint.xml +func (gl *GL) Hint(target, mode glbase.Enum) { + C.gl1_4_glHint(gl.funcs, C.GLenum(target), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFrontFace.xml +func (gl *GL) FrontFace(mode glbase.Enum) { + C.gl1_4_glFrontFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCullFace.xml +func (gl *GL) CullFace(mode glbase.Enum) { + C.gl1_4_glCullFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexubv.xml +func (gl *GL) Indexubv(c []uint8) { + C.gl1_4_glIndexubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexub.xml +func (gl *GL) Indexub(c uint8) { + C.gl1_4_glIndexub(gl.funcs, C.GLubyte(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsTexture.xml +func (gl *GL) IsTexture(texture glbase.Texture) bool { + glresult := C.gl1_4_glIsTexture(gl.funcs, C.GLuint(texture)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenTextures returns n texture names in textures. There is no guarantee +// that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenTextures. +// +// The generated textures have no dimensionality; they assume the +// dimensionality of the texture target to which they are first bound (see +// BindTexture). +// +// Texture names returned by a call to GenTextures are not returned by +// subsequent calls, unless they are first deleted with DeleteTextures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenTextures is available in GL version 2.0 or greater. +func (gl *GL) GenTextures(n int) []glbase.Texture { + if n == 0 { + return nil + } + textures := make([]glbase.Texture, n) + C.gl1_4_glGenTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) + return textures +} + +// DeleteTextures deletes the textures objects whose names are stored +// in the textures slice. After a texture is deleted, it has no contents or +// dimensionality, and its name is free for reuse (for example by +// GenTextures). If a texture that is currently bound is deleted, the binding +// reverts to 0 (the default texture). +// +// DeleteTextures silently ignores 0's and names that do not correspond to +// existing textures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteTextures is available in GL version 2.0 or greater. +func (gl *GL) DeleteTextures(textures []glbase.Texture) { + n := len(textures) + if n == 0 { + return + } + C.gl1_4_glDeleteTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBindTexture.xml +func (gl *GL) BindTexture(target glbase.Enum, texture glbase.Texture) { + C.gl1_4_glBindTexture(gl.funcs, C.GLenum(target), C.GLuint(texture)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexSubImage2D.xml +func (gl *GL) TexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexSubImage1D.xml +func (gl *GL) TexSubImage1D(target glbase.Enum, level, xoffset, width int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexSubImage2D.xml +func (gl *GL) CopyTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, x, y, width, height int) { + C.gl1_4_glCopyTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexSubImage1D.xml +func (gl *GL) CopyTexSubImage1D(target glbase.Enum, level, xoffset, x, y, width int) { + C.gl1_4_glCopyTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexImage2D.xml +func (gl *GL) CopyTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, height, border int) { + C.gl1_4_glCopyTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexImage1D.xml +func (gl *GL) CopyTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, border int) { + C.gl1_4_glCopyTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPolygonOffset.xml +func (gl *GL) PolygonOffset(factor, units float32) { + C.gl1_4_glPolygonOffset(gl.funcs, C.GLfloat(factor), C.GLfloat(units)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawElements.xml +func (gl *GL) DrawElements(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glDrawElements(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawArrays.xml +func (gl *GL) DrawArrays(mode glbase.Enum, first, count int) { + C.gl1_4_glDrawArrays(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexSubImage3D.xml +func (gl *GL) CopyTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, x, y, width, height int) { + C.gl1_4_glCopyTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexSubImage3D.xml +func (gl *GL) TexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexImage3D.xml +func (gl *GL) TexImage3D(target glbase.Enum, level int, internalFormat int32, width, height int, depth int32, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawRangeElements.xml +func (gl *GL) DrawRangeElements(mode glbase.Enum, start, end uint32, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glDrawRangeElements(gl.funcs, C.GLenum(mode), C.GLuint(start), C.GLuint(end), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBlendEquation.xml +func (gl *GL) BlendEquation(mode glbase.Enum) { + C.gl1_4_glBlendEquation(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBlendColor.xml +func (gl *GL) BlendColor(red, green, blue, alpha float32) { + C.gl1_4_glBlendColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetCompressedTexImage.xml +func (gl *GL) GetCompressedTexImage(target glbase.Enum, level int, img interface{}) { + var img_ptr unsafe.Pointer + var img_v = reflect.ValueOf(img) + if img != nil && img_v.Kind() != reflect.Slice { + panic("parameter img must be a slice") + } + if img != nil { + img_ptr = unsafe.Pointer(img_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glGetCompressedTexImage(gl.funcs, C.GLenum(target), C.GLint(level), img_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCompressedTexSubImage1D.xml +func (gl *GL) CompressedTexSubImage1D(target glbase.Enum, level, xoffset, width int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glCompressedTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCompressedTexSubImage2D.xml +func (gl *GL) CompressedTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glCompressedTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCompressedTexSubImage3D.xml +func (gl *GL) CompressedTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glCompressedTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCompressedTexImage1D.xml +func (gl *GL) CompressedTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, width, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glCompressedTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCompressedTexImage2D.xml +func (gl *GL) CompressedTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glCompressedTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCompressedTexImage3D.xml +func (gl *GL) CompressedTexImage3D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height int, depth int32, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glCompressedTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSampleCoverage.xml +func (gl *GL) SampleCoverage(value float32, invert bool) { + C.gl1_4_glSampleCoverage(gl.funcs, C.GLfloat(value), *(*C.GLboolean)(unsafe.Pointer(&invert))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glActiveTexture.xml +func (gl *GL) ActiveTexture(texture glbase.Enum) { + C.gl1_4_glActiveTexture(gl.funcs, C.GLenum(texture)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPointParameteriv.xml +func (gl *GL) PointParameteriv(pname glbase.Enum, params []int32) { + C.gl1_4_glPointParameteriv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPointParameteri.xml +func (gl *GL) PointParameteri(pname glbase.Enum, param int32) { + C.gl1_4_glPointParameteri(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPointParameterfv.xml +func (gl *GL) PointParameterfv(pname glbase.Enum, params []float32) { + C.gl1_4_glPointParameterfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPointParameterf.xml +func (gl *GL) PointParameterf(pname glbase.Enum, param float32) { + C.gl1_4_glPointParameterf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiDrawArrays.xml +func (gl *GL) MultiDrawArrays(mode glbase.Enum, first, count []int, drawcount int32) { + C.gl1_4_glMultiDrawArrays(gl.funcs, C.GLenum(mode), (*C.GLint)(unsafe.Pointer(&first[0])), (*C.GLsizei)(unsafe.Pointer(&count[0])), C.GLsizei(drawcount)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBlendFuncSeparate.xml +func (gl *GL) BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha glbase.Enum) { + C.gl1_4_glBlendFuncSeparate(gl.funcs, C.GLenum(sfactorRGB), C.GLenum(dfactorRGB), C.GLenum(sfactorAlpha), C.GLenum(dfactorAlpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTranslatef.xml +func (gl *GL) Translatef(x, y, z float32) { + C.gl1_4_glTranslatef(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTranslated.xml +func (gl *GL) Translated(x, y, z float64) { + C.gl1_4_glTranslated(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glScalef.xml +func (gl *GL) Scalef(x, y, z float32) { + C.gl1_4_glScalef(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glScaled.xml +func (gl *GL) Scaled(x, y, z float64) { + C.gl1_4_glScaled(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRotatef.xml +func (gl *GL) Rotatef(angle, x, y, z float32) { + C.gl1_4_glRotatef(gl.funcs, C.GLfloat(angle), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRotated.xml +func (gl *GL) Rotated(angle, x, y, z float64) { + C.gl1_4_glRotated(gl.funcs, C.GLdouble(angle), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPushMatrix.xml +func (gl *GL) PushMatrix() { + C.gl1_4_glPushMatrix(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPopMatrix.xml +func (gl *GL) PopMatrix() { + C.gl1_4_glPopMatrix(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glOrtho.xml +func (gl *GL) Ortho(left, right, bottom, top, zNear, zFar float64) { + C.gl1_4_glOrtho(gl.funcs, C.GLdouble(left), C.GLdouble(right), C.GLdouble(bottom), C.GLdouble(top), C.GLdouble(zNear), C.GLdouble(zFar)) +} + +// MultMatrixd multiplies the current matrix with the provided matrix. +// +// The m parameter must hold 16 consecutive elements of a 4x4 column-major matrix. +// +// The current matrix is determined by the current matrix mode (see +// MatrixMode). It is either the projection matrix, modelview matrix, or the +// texture matrix. +// +// For example, if the current matrix is C and the coordinates to be transformed +// are v = (v[0], v[1], v[2], v[3]), then the current transformation is C × v, or +// +// c[0] c[4] c[8] c[12] v[0] +// c[1] c[5] c[9] c[13] v[1] +// c[2] c[6] c[10] c[14] X v[2] +// c[3] c[7] c[11] c[15] v[3] +// +// Calling MultMatrix with an argument of m = m[0], m[1], ..., m[15] +// replaces the current transformation with (C X M) x v, or +// +// c[0] c[4] c[8] c[12] m[0] m[4] m[8] m[12] v[0] +// c[1] c[5] c[9] c[13] m[1] m[5] m[9] m[13] v[1] +// c[2] c[6] c[10] c[14] X m[2] m[6] m[10] m[14] X v[2] +// c[3] c[7] c[11] c[15] m[3] m[7] m[11] m[15] v[3] +// +// Where 'X' denotes matrix multiplication, and v is represented as a 4x1 matrix. +// +// While the elements of the matrix may be specified with single or double +// precision, the GL may store or operate on these values in less-than-single +// precision. +// +// In many computer languages, 4×4 arrays are represented in row-major +// order. The transformations just described represent these matrices in +// column-major order. The order of the multiplication is important. For +// example, if the current transformation is a rotation, and MultMatrix is +// called with a translation matrix, the translation is done directly on the +// coordinates to be transformed, while the rotation is done on the results +// of that translation. +// +// GL.INVALID_OPERATION is generated if MultMatrix is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) MultMatrixd(m []float64) { + if len(m) != 16 { + panic("parameter m must have length 16 for the 4x4 matrix") + } + C.gl1_4_glMultMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// MultMatrixf multiplies the current matrix with the provided matrix. +// +// The m parameter must hold 16 consecutive elements of a 4x4 column-major matrix. +// +// The current matrix is determined by the current matrix mode (see +// MatrixMode). It is either the projection matrix, modelview matrix, or the +// texture matrix. +// +// For example, if the current matrix is C and the coordinates to be transformed +// are v = (v[0], v[1], v[2], v[3]), then the current transformation is C × v, or +// +// c[0] c[4] c[8] c[12] v[0] +// c[1] c[5] c[9] c[13] v[1] +// c[2] c[6] c[10] c[14] X v[2] +// c[3] c[7] c[11] c[15] v[3] +// +// Calling MultMatrix with an argument of m = m[0], m[1], ..., m[15] +// replaces the current transformation with (C X M) x v, or +// +// c[0] c[4] c[8] c[12] m[0] m[4] m[8] m[12] v[0] +// c[1] c[5] c[9] c[13] m[1] m[5] m[9] m[13] v[1] +// c[2] c[6] c[10] c[14] X m[2] m[6] m[10] m[14] X v[2] +// c[3] c[7] c[11] c[15] m[3] m[7] m[11] m[15] v[3] +// +// Where 'X' denotes matrix multiplication, and v is represented as a 4x1 matrix. +// +// While the elements of the matrix may be specified with single or double +// precision, the GL may store or operate on these values in less-than-single +// precision. +// +// In many computer languages, 4×4 arrays are represented in row-major +// order. The transformations just described represent these matrices in +// column-major order. The order of the multiplication is important. For +// example, if the current transformation is a rotation, and MultMatrix is +// called with a translation matrix, the translation is done directly on the +// coordinates to be transformed, while the rotation is done on the results +// of that translation. +// +// GL.INVALID_OPERATION is generated if MultMatrix is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) MultMatrixf(m []float32) { + if len(m) != 16 { + panic("parameter m must have length 16 for the 4x4 matrix") + } + C.gl1_4_glMultMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMatrixMode.xml +func (gl *GL) MatrixMode(mode glbase.Enum) { + C.gl1_4_glMatrixMode(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadMatrixd.xml +func (gl *GL) LoadMatrixd(m []float64) { + C.gl1_4_glLoadMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadMatrixf.xml +func (gl *GL) LoadMatrixf(m []float32) { + C.gl1_4_glLoadMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadIdentity.xml +func (gl *GL) LoadIdentity() { + C.gl1_4_glLoadIdentity(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFrustum.xml +func (gl *GL) Frustum(left, right, bottom, top, zNear, zFar float64) { + C.gl1_4_glFrustum(gl.funcs, C.GLdouble(left), C.GLdouble(right), C.GLdouble(bottom), C.GLdouble(top), C.GLdouble(zNear), C.GLdouble(zFar)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsList.xml +func (gl *GL) IsList(list uint32) bool { + glresult := C.gl1_4_glIsList(gl.funcs, C.GLuint(list)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexGeniv.xml +func (gl *GL) GetTexGeniv(coord, pname glbase.Enum, params []int32) { + C.gl1_4_glGetTexGeniv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexGenfv.xml +func (gl *GL) GetTexGenfv(coord, pname glbase.Enum, params []float32) { + C.gl1_4_glGetTexGenfv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexGendv.xml +func (gl *GL) GetTexGendv(coord, pname glbase.Enum, params []float64) { + C.gl1_4_glGetTexGendv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexEnviv.xml +func (gl *GL) GetTexEnviv(target, pname glbase.Enum, params []int32) { + C.gl1_4_glGetTexEnviv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexEnvfv.xml +func (gl *GL) GetTexEnvfv(target, pname glbase.Enum, params []float32) { + C.gl1_4_glGetTexEnvfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetPolygonStipple.xml +func (gl *GL) GetPolygonStipple(mask []uint8) { + C.gl1_4_glGetPolygonStipple(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&mask[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetPixelMapusv.xml +func (gl *GL) GetPixelMapusv(glmap glbase.Enum, values []uint16) { + C.gl1_4_glGetPixelMapusv(gl.funcs, C.GLenum(glmap), (*C.GLushort)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetPixelMapuiv.xml +func (gl *GL) GetPixelMapuiv(glmap glbase.Enum, values []uint32) { + C.gl1_4_glGetPixelMapuiv(gl.funcs, C.GLenum(glmap), (*C.GLuint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetPixelMapfv.xml +func (gl *GL) GetPixelMapfv(glmap glbase.Enum, values []float32) { + C.gl1_4_glGetPixelMapfv(gl.funcs, C.GLenum(glmap), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMaterialiv.xml +func (gl *GL) GetMaterialiv(face, pname glbase.Enum, params []int32) { + C.gl1_4_glGetMaterialiv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMaterialfv.xml +func (gl *GL) GetMaterialfv(face, pname glbase.Enum, params []float32) { + C.gl1_4_glGetMaterialfv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMapiv.xml +func (gl *GL) GetMapiv(target, query glbase.Enum, v []int32) { + C.gl1_4_glGetMapiv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMapfv.xml +func (gl *GL) GetMapfv(target, query glbase.Enum, v []float32) { + C.gl1_4_glGetMapfv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMapdv.xml +func (gl *GL) GetMapdv(target, query glbase.Enum, v []float64) { + C.gl1_4_glGetMapdv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetLightiv.xml +func (gl *GL) GetLightiv(light, pname glbase.Enum, params []int32) { + C.gl1_4_glGetLightiv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetLightfv.xml +func (gl *GL) GetLightfv(light, pname glbase.Enum, params []float32) { + C.gl1_4_glGetLightfv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetClipPlane.xml +func (gl *GL) GetClipPlane(plane glbase.Enum, equation []float64) { + C.gl1_4_glGetClipPlane(gl.funcs, C.GLenum(plane), (*C.GLdouble)(unsafe.Pointer(&equation[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawPixels.xml +func (gl *GL) DrawPixels(width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glDrawPixels(gl.funcs, C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyPixels.xml +func (gl *GL) CopyPixels(x, y, width, height int, gltype glbase.Enum) { + C.gl1_4_glCopyPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(gltype)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelMapusv.xml +func (gl *GL) PixelMapusv(glmap glbase.Enum, mapsize int32, values []uint16) { + C.gl1_4_glPixelMapusv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLushort)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelMapuiv.xml +func (gl *GL) PixelMapuiv(glmap glbase.Enum, mapsize int32, values []uint32) { + C.gl1_4_glPixelMapuiv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLuint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelMapfv.xml +func (gl *GL) PixelMapfv(glmap glbase.Enum, mapsize int32, values []float32) { + C.gl1_4_glPixelMapfv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelTransferi.xml +func (gl *GL) PixelTransferi(pname glbase.Enum, param int32) { + C.gl1_4_glPixelTransferi(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelTransferf.xml +func (gl *GL) PixelTransferf(pname glbase.Enum, param float32) { + C.gl1_4_glPixelTransferf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelZoom.xml +func (gl *GL) PixelZoom(xfactor, yfactor float32) { + C.gl1_4_glPixelZoom(gl.funcs, C.GLfloat(xfactor), C.GLfloat(yfactor)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glAlphaFunc.xml +func (gl *GL) AlphaFunc(glfunc glbase.Enum, ref float32) { + C.gl1_4_glAlphaFunc(gl.funcs, C.GLenum(glfunc), C.GLfloat(ref)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalPoint2.xml +func (gl *GL) EvalPoint2(i, j int32) { + C.gl1_4_glEvalPoint2(gl.funcs, C.GLint(i), C.GLint(j)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalMesh2.xml +func (gl *GL) EvalMesh2(mode glbase.Enum, i1, i2, j1, j2 int32) { + C.gl1_4_glEvalMesh2(gl.funcs, C.GLenum(mode), C.GLint(i1), C.GLint(i2), C.GLint(j1), C.GLint(j2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalPoint1.xml +func (gl *GL) EvalPoint1(i int32) { + C.gl1_4_glEvalPoint1(gl.funcs, C.GLint(i)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalMesh1.xml +func (gl *GL) EvalMesh1(mode glbase.Enum, i1, i2 int32) { + C.gl1_4_glEvalMesh1(gl.funcs, C.GLenum(mode), C.GLint(i1), C.GLint(i2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord2fv.xml +func (gl *GL) EvalCoord2fv(u []float32) { + if len(u) != 2 { + panic("parameter u has incorrect length") + } + C.gl1_4_glEvalCoord2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord2f.xml +func (gl *GL) EvalCoord2f(u, v float32) { + C.gl1_4_glEvalCoord2f(gl.funcs, C.GLfloat(u), C.GLfloat(v)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord2dv.xml +func (gl *GL) EvalCoord2dv(u []float64) { + if len(u) != 2 { + panic("parameter u has incorrect length") + } + C.gl1_4_glEvalCoord2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord2d.xml +func (gl *GL) EvalCoord2d(u, v float64) { + C.gl1_4_glEvalCoord2d(gl.funcs, C.GLdouble(u), C.GLdouble(v)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord1fv.xml +func (gl *GL) EvalCoord1fv(u []float32) { + C.gl1_4_glEvalCoord1fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord1f.xml +func (gl *GL) EvalCoord1f(u float32) { + C.gl1_4_glEvalCoord1f(gl.funcs, C.GLfloat(u)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord1dv.xml +func (gl *GL) EvalCoord1dv(u []float64) { + C.gl1_4_glEvalCoord1dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord1d.xml +func (gl *GL) EvalCoord1d(u float64) { + C.gl1_4_glEvalCoord1d(gl.funcs, C.GLdouble(u)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMapGrid2f.xml +func (gl *GL) MapGrid2f(un int32, u1, u2 float32, vn int32, v1, v2 float32) { + C.gl1_4_glMapGrid2f(gl.funcs, C.GLint(un), C.GLfloat(u1), C.GLfloat(u2), C.GLint(vn), C.GLfloat(v1), C.GLfloat(v2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMapGrid2d.xml +func (gl *GL) MapGrid2d(un int32, u1, u2 float64, vn int32, v1, v2 float64) { + C.gl1_4_glMapGrid2d(gl.funcs, C.GLint(un), C.GLdouble(u1), C.GLdouble(u2), C.GLint(vn), C.GLdouble(v1), C.GLdouble(v2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMapGrid1f.xml +func (gl *GL) MapGrid1f(un int32, u1, u2 float32) { + C.gl1_4_glMapGrid1f(gl.funcs, C.GLint(un), C.GLfloat(u1), C.GLfloat(u2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMapGrid1d.xml +func (gl *GL) MapGrid1d(un int32, u1, u2 float64) { + C.gl1_4_glMapGrid1d(gl.funcs, C.GLint(un), C.GLdouble(u1), C.GLdouble(u2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMap2f.xml +func (gl *GL) Map2f(target glbase.Enum, u1, u2 float32, ustride, uorder int32, v1, v2 float32, vstride, vorder int32, points []float32) { + C.gl1_4_glMap2f(gl.funcs, C.GLenum(target), C.GLfloat(u1), C.GLfloat(u2), C.GLint(ustride), C.GLint(uorder), C.GLfloat(v1), C.GLfloat(v2), C.GLint(vstride), C.GLint(vorder), (*C.GLfloat)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMap2d.xml +func (gl *GL) Map2d(target glbase.Enum, u1, u2 float64, ustride, uorder int32, v1, v2 float64, vstride, vorder int32, points []float64) { + C.gl1_4_glMap2d(gl.funcs, C.GLenum(target), C.GLdouble(u1), C.GLdouble(u2), C.GLint(ustride), C.GLint(uorder), C.GLdouble(v1), C.GLdouble(v2), C.GLint(vstride), C.GLint(vorder), (*C.GLdouble)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMap1f.xml +func (gl *GL) Map1f(target glbase.Enum, u1, u2 float32, stride, order int, points []float32) { + C.gl1_4_glMap1f(gl.funcs, C.GLenum(target), C.GLfloat(u1), C.GLfloat(u2), C.GLint(stride), C.GLint(order), (*C.GLfloat)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMap1d.xml +func (gl *GL) Map1d(target glbase.Enum, u1, u2 float64, stride, order int, points []float64) { + C.gl1_4_glMap1d(gl.funcs, C.GLenum(target), C.GLdouble(u1), C.GLdouble(u2), C.GLint(stride), C.GLint(order), (*C.GLdouble)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPushAttrib.xml +func (gl *GL) PushAttrib(mask glbase.Bitfield) { + C.gl1_4_glPushAttrib(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPopAttrib.xml +func (gl *GL) PopAttrib() { + C.gl1_4_glPopAttrib(gl.funcs) +} + +// Accum executes an operation on the accumulation buffer. +// +// Parameter op defines the accumulation buffer operation (GL.ACCUM, GL.LOAD, +// GL.ADD, GL.MULT, or GL.RETURN) and specifies how the value parameter is +// used. +// +// The accumulation buffer is an extended-range color buffer. Images are not +// rendered into it. Rather, images rendered into one of the color buffers +// are added to the contents of the accumulation buffer after rendering. +// Effects such as antialiasing (of points, lines, and polygons), motion +// blur, and depth of field can be created by accumulating images generated +// with different transformation matrices. +// +// Each pixel in the accumulation buffer consists of red, green, blue, and +// alpha values. The number of bits per component in the accumulation buffer +// depends on the implementation. You can examine this number by calling +// GetIntegerv four times, with arguments GL.ACCUM_RED_BITS, +// GL.ACCUM_GREEN_BITS, GL.ACCUM_BLUE_BITS, and GL.ACCUM_ALPHA_BITS. +// Regardless of the number of bits per component, the range of values stored +// by each component is (-1, 1). The accumulation buffer pixels are mapped +// one-to-one with frame buffer pixels. +// +// All accumulation buffer operations are limited to the area of the current +// scissor box and applied identically to the red, green, blue, and alpha +// components of each pixel. If a Accum operation results in a value outside +// the range (-1, 1), the contents of an accumulation buffer pixel component +// are undefined. +// +// The operations are as follows: +// +// GL.ACCUM +// Obtains R, G, B, and A values from the buffer currently selected for +// reading (see ReadBuffer). Each component value is divided by 2 n - +// 1 , where n is the number of bits allocated to each color component +// in the currently selected buffer. The result is a floating-point +// value in the range 0 1 , which is multiplied by value and added to +// the corresponding pixel component in the accumulation buffer, +// thereby updating the accumulation buffer. +// +// GL.LOAD +// Similar to GL.ACCUM, except that the current value in the +// accumulation buffer is not used in the calculation of the new value. +// That is, the R, G, B, and A values from the currently selected +// buffer are divided by 2 n - 1 , multiplied by value, and then stored +// in the corresponding accumulation buffer cell, overwriting the +// current value. +// +// GL.ADD +// Adds value to each R, G, B, and A in the accumulation buffer. +// +// GL.MULT +// Multiplies each R, G, B, and A in the accumulation buffer by value +// and returns the scaled component to its corresponding accumulation +// buffer location. +// +// GL.RETURN +// Transfers accumulation buffer values to the color buffer or buffers +// currently selected for writing. Each R, G, B, and A component is +// multiplied by value, then multiplied by 2 n - 1 , clamped to the +// range 0 2 n - 1 , and stored in the corresponding display buffer +// cell. The only fragment operations that are applied to this transfer +// are pixel ownership, scissor, dithering, and color writemasks. +// +// To clear the accumulation buffer, call ClearAccum with R, G, B, and A +// values to set it to, then call Clear with the accumulation buffer +// enabled. +// +// Error GL.INVALID_ENUM is generated if op is not an accepted value. +// GL.INVALID_OPERATION is generated if there is no accumulation buffer. +// GL.INVALID_OPERATION is generated if Accum is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) Accum(op glbase.Enum, value float32) { + C.gl1_4_glAccum(gl.funcs, C.GLenum(op), C.GLfloat(value)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexMask.xml +func (gl *GL) IndexMask(mask uint32) { + C.gl1_4_glIndexMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearIndex.xml +func (gl *GL) ClearIndex(c float32) { + C.gl1_4_glClearIndex(gl.funcs, C.GLfloat(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearAccum.xml +func (gl *GL) ClearAccum(red, green, blue, alpha float32) { + C.gl1_4_glClearAccum(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPushName.xml +func (gl *GL) PushName(name uint32) { + C.gl1_4_glPushName(gl.funcs, C.GLuint(name)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPopName.xml +func (gl *GL) PopName() { + C.gl1_4_glPopName(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPassThrough.xml +func (gl *GL) PassThrough(token float32) { + C.gl1_4_glPassThrough(gl.funcs, C.GLfloat(token)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadName.xml +func (gl *GL) LoadName(name uint32) { + C.gl1_4_glLoadName(gl.funcs, C.GLuint(name)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glInitNames.xml +func (gl *GL) InitNames() { + C.gl1_4_glInitNames(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRenderMode.xml +func (gl *GL) RenderMode(mode glbase.Enum) int32 { + glresult := C.gl1_4_glRenderMode(gl.funcs, C.GLenum(mode)) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSelectBuffer.xml +func (gl *GL) SelectBuffer(size int, buffer []glbase.Buffer) { + C.gl1_4_glSelectBuffer(gl.funcs, C.GLsizei(size), (*C.GLuint)(unsafe.Pointer(&buffer[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFeedbackBuffer.xml +func (gl *GL) FeedbackBuffer(size int, gltype glbase.Enum, buffer []float32) { + C.gl1_4_glFeedbackBuffer(gl.funcs, C.GLsizei(size), C.GLenum(gltype), (*C.GLfloat)(unsafe.Pointer(&buffer[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGeniv.xml +func (gl *GL) TexGeniv(coord, pname glbase.Enum, params []int32) { + C.gl1_4_glTexGeniv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGeni.xml +func (gl *GL) TexGeni(coord, pname glbase.Enum, param int32) { + C.gl1_4_glTexGeni(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGenfv.xml +func (gl *GL) TexGenfv(coord, pname glbase.Enum, params []float32) { + C.gl1_4_glTexGenfv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGenf.xml +func (gl *GL) TexGenf(coord, pname glbase.Enum, param float32) { + C.gl1_4_glTexGenf(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGendv.xml +func (gl *GL) TexGendv(coord, pname glbase.Enum, params []float64) { + C.gl1_4_glTexGendv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGend.xml +func (gl *GL) TexGend(coord, pname glbase.Enum, param float64) { + C.gl1_4_glTexGend(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLdouble(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnviv.xml +func (gl *GL) TexEnviv(target, pname glbase.Enum, params []int32) { + C.gl1_4_glTexEnviv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnvi.xml +func (gl *GL) TexEnvi(target, pname glbase.Enum, param int32) { + C.gl1_4_glTexEnvi(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnvfv.xml +func (gl *GL) TexEnvfv(target, pname glbase.Enum, params []float32) { + C.gl1_4_glTexEnvfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnvf.xml +func (gl *GL) TexEnvf(target, pname glbase.Enum, param float32) { + C.gl1_4_glTexEnvf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glShadeModel.xml +func (gl *GL) ShadeModel(mode glbase.Enum) { + C.gl1_4_glShadeModel(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPolygonStipple.xml +func (gl *GL) PolygonStipple(mask []uint8) { + C.gl1_4_glPolygonStipple(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&mask[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMaterialiv.xml +func (gl *GL) Materialiv(face, pname glbase.Enum, params []int32) { + C.gl1_4_glMaterialiv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMateriali.xml +func (gl *GL) Materiali(face, pname glbase.Enum, param int32) { + C.gl1_4_glMateriali(gl.funcs, C.GLenum(face), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMaterialfv.xml +func (gl *GL) Materialfv(face, pname glbase.Enum, params []float32) { + C.gl1_4_glMaterialfv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMaterialf.xml +func (gl *GL) Materialf(face, pname glbase.Enum, param float32) { + C.gl1_4_glMaterialf(gl.funcs, C.GLenum(face), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLineStipple.xml +func (gl *GL) LineStipple(factor int32, pattern uint16) { + C.gl1_4_glLineStipple(gl.funcs, C.GLint(factor), C.GLushort(pattern)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightModeliv.xml +func (gl *GL) LightModeliv(pname glbase.Enum, params []int32) { + C.gl1_4_glLightModeliv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightModeli.xml +func (gl *GL) LightModeli(pname glbase.Enum, param int32) { + C.gl1_4_glLightModeli(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightModelfv.xml +func (gl *GL) LightModelfv(pname glbase.Enum, params []float32) { + C.gl1_4_glLightModelfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightModelf.xml +func (gl *GL) LightModelf(pname glbase.Enum, param float32) { + C.gl1_4_glLightModelf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightiv.xml +func (gl *GL) Lightiv(light, pname glbase.Enum, params []int32) { + C.gl1_4_glLightiv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLighti.xml +func (gl *GL) Lighti(light, pname glbase.Enum, param int32) { + C.gl1_4_glLighti(gl.funcs, C.GLenum(light), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightfv.xml +func (gl *GL) Lightfv(light, pname glbase.Enum, params []float32) { + C.gl1_4_glLightfv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightf.xml +func (gl *GL) Lightf(light, pname glbase.Enum, param float32) { + C.gl1_4_glLightf(gl.funcs, C.GLenum(light), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogiv.xml +func (gl *GL) Fogiv(pname glbase.Enum, params []int32) { + C.gl1_4_glFogiv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogi.xml +func (gl *GL) Fogi(pname glbase.Enum, param int32) { + C.gl1_4_glFogi(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogfv.xml +func (gl *GL) Fogfv(pname glbase.Enum, params []float32) { + C.gl1_4_glFogfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogf.xml +func (gl *GL) Fogf(pname glbase.Enum, param float32) { + C.gl1_4_glFogf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorMaterial.xml +func (gl *GL) ColorMaterial(face, mode glbase.Enum) { + C.gl1_4_glColorMaterial(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClipPlane.xml +func (gl *GL) ClipPlane(plane glbase.Enum, equation []float64) { + C.gl1_4_glClipPlane(gl.funcs, C.GLenum(plane), (*C.GLdouble)(unsafe.Pointer(&equation[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4sv.xml +func (gl *GL) Vertex4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_4_glVertex4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4s.xml +func (gl *GL) Vertex4s(x, y, z, w int16) { + C.gl1_4_glVertex4s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4iv.xml +func (gl *GL) Vertex4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_4_glVertex4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4i.xml +func (gl *GL) Vertex4i(x, y, z, w int) { + C.gl1_4_glVertex4i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4fv.xml +func (gl *GL) Vertex4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_4_glVertex4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4f.xml +func (gl *GL) Vertex4f(x, y, z, w float32) { + C.gl1_4_glVertex4f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4dv.xml +func (gl *GL) Vertex4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_4_glVertex4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4d.xml +func (gl *GL) Vertex4d(x, y, z, w float64) { + C.gl1_4_glVertex4d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3sv.xml +func (gl *GL) Vertex3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_4_glVertex3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3s.xml +func (gl *GL) Vertex3s(x, y, z int16) { + C.gl1_4_glVertex3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3iv.xml +func (gl *GL) Vertex3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_4_glVertex3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3i.xml +func (gl *GL) Vertex3i(x, y, z int) { + C.gl1_4_glVertex3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3fv.xml +func (gl *GL) Vertex3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_4_glVertex3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3f.xml +func (gl *GL) Vertex3f(x, y, z float32) { + C.gl1_4_glVertex3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3dv.xml +func (gl *GL) Vertex3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_4_glVertex3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3d.xml +func (gl *GL) Vertex3d(x, y, z float64) { + C.gl1_4_glVertex3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2sv.xml +func (gl *GL) Vertex2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_4_glVertex2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2s.xml +func (gl *GL) Vertex2s(x, y int16) { + C.gl1_4_glVertex2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2iv.xml +func (gl *GL) Vertex2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_4_glVertex2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2i.xml +func (gl *GL) Vertex2i(x, y int) { + C.gl1_4_glVertex2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2fv.xml +func (gl *GL) Vertex2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_4_glVertex2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2f.xml +func (gl *GL) Vertex2f(x, y float32) { + C.gl1_4_glVertex2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2dv.xml +func (gl *GL) Vertex2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_4_glVertex2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2d.xml +func (gl *GL) Vertex2d(x, y float64) { + C.gl1_4_glVertex2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4sv.xml +func (gl *GL) TexCoord4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_4_glTexCoord4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4s.xml +func (gl *GL) TexCoord4s(s, t, r, q int16) { + C.gl1_4_glTexCoord4s(gl.funcs, C.GLshort(s), C.GLshort(t), C.GLshort(r), C.GLshort(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4iv.xml +func (gl *GL) TexCoord4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_4_glTexCoord4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4i.xml +func (gl *GL) TexCoord4i(s, t, r, q int32) { + C.gl1_4_glTexCoord4i(gl.funcs, C.GLint(s), C.GLint(t), C.GLint(r), C.GLint(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4fv.xml +func (gl *GL) TexCoord4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_4_glTexCoord4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4f.xml +func (gl *GL) TexCoord4f(s, t, r, q float32) { + C.gl1_4_glTexCoord4f(gl.funcs, C.GLfloat(s), C.GLfloat(t), C.GLfloat(r), C.GLfloat(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4dv.xml +func (gl *GL) TexCoord4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_4_glTexCoord4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4d.xml +func (gl *GL) TexCoord4d(s, t, r, q float64) { + C.gl1_4_glTexCoord4d(gl.funcs, C.GLdouble(s), C.GLdouble(t), C.GLdouble(r), C.GLdouble(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3sv.xml +func (gl *GL) TexCoord3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_4_glTexCoord3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3s.xml +func (gl *GL) TexCoord3s(s, t, r int16) { + C.gl1_4_glTexCoord3s(gl.funcs, C.GLshort(s), C.GLshort(t), C.GLshort(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3iv.xml +func (gl *GL) TexCoord3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_4_glTexCoord3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3i.xml +func (gl *GL) TexCoord3i(s, t, r int32) { + C.gl1_4_glTexCoord3i(gl.funcs, C.GLint(s), C.GLint(t), C.GLint(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3fv.xml +func (gl *GL) TexCoord3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_4_glTexCoord3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3f.xml +func (gl *GL) TexCoord3f(s, t, r float32) { + C.gl1_4_glTexCoord3f(gl.funcs, C.GLfloat(s), C.GLfloat(t), C.GLfloat(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3dv.xml +func (gl *GL) TexCoord3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_4_glTexCoord3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3d.xml +func (gl *GL) TexCoord3d(s, t, r float64) { + C.gl1_4_glTexCoord3d(gl.funcs, C.GLdouble(s), C.GLdouble(t), C.GLdouble(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2sv.xml +func (gl *GL) TexCoord2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_4_glTexCoord2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2s.xml +func (gl *GL) TexCoord2s(s, t int16) { + C.gl1_4_glTexCoord2s(gl.funcs, C.GLshort(s), C.GLshort(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2iv.xml +func (gl *GL) TexCoord2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_4_glTexCoord2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2i.xml +func (gl *GL) TexCoord2i(s, t int32) { + C.gl1_4_glTexCoord2i(gl.funcs, C.GLint(s), C.GLint(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2fv.xml +func (gl *GL) TexCoord2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_4_glTexCoord2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2f.xml +func (gl *GL) TexCoord2f(s, t float32) { + C.gl1_4_glTexCoord2f(gl.funcs, C.GLfloat(s), C.GLfloat(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2dv.xml +func (gl *GL) TexCoord2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_4_glTexCoord2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2d.xml +func (gl *GL) TexCoord2d(s, t float64) { + C.gl1_4_glTexCoord2d(gl.funcs, C.GLdouble(s), C.GLdouble(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1sv.xml +func (gl *GL) TexCoord1sv(v []int16) { + C.gl1_4_glTexCoord1sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1s.xml +func (gl *GL) TexCoord1s(s int16) { + C.gl1_4_glTexCoord1s(gl.funcs, C.GLshort(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1iv.xml +func (gl *GL) TexCoord1iv(v []int32) { + C.gl1_4_glTexCoord1iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1i.xml +func (gl *GL) TexCoord1i(s int32) { + C.gl1_4_glTexCoord1i(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1fv.xml +func (gl *GL) TexCoord1fv(v []float32) { + C.gl1_4_glTexCoord1fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1f.xml +func (gl *GL) TexCoord1f(s float32) { + C.gl1_4_glTexCoord1f(gl.funcs, C.GLfloat(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1dv.xml +func (gl *GL) TexCoord1dv(v []float64) { + C.gl1_4_glTexCoord1dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1d.xml +func (gl *GL) TexCoord1d(s float64) { + C.gl1_4_glTexCoord1d(gl.funcs, C.GLdouble(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectsv.xml +func (gl *GL) Rectsv(v1, v2 []int16) { + C.gl1_4_glRectsv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v1[0])), (*C.GLshort)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRects.xml +func (gl *GL) Rects(x1, y1, x2, y2 int16) { + C.gl1_4_glRects(gl.funcs, C.GLshort(x1), C.GLshort(y1), C.GLshort(x2), C.GLshort(y2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectiv.xml +func (gl *GL) Rectiv(v1, v2 []int32) { + C.gl1_4_glRectiv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v1[0])), (*C.GLint)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRecti.xml +func (gl *GL) Recti(x1, y1, x2, y2 int32) { + C.gl1_4_glRecti(gl.funcs, C.GLint(x1), C.GLint(y1), C.GLint(x2), C.GLint(y2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectfv.xml +func (gl *GL) Rectfv(v1, v2 []float32) { + C.gl1_4_glRectfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v1[0])), (*C.GLfloat)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectf.xml +func (gl *GL) Rectf(x1, y1, x2, y2 float32) { + C.gl1_4_glRectf(gl.funcs, C.GLfloat(x1), C.GLfloat(y1), C.GLfloat(x2), C.GLfloat(y2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectdv.xml +func (gl *GL) Rectdv(v1, v2 []float64) { + C.gl1_4_glRectdv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v1[0])), (*C.GLdouble)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectd.xml +func (gl *GL) Rectd(x1, y1, x2, y2 float64) { + C.gl1_4_glRectd(gl.funcs, C.GLdouble(x1), C.GLdouble(y1), C.GLdouble(x2), C.GLdouble(y2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4sv.xml +func (gl *GL) RasterPos4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_4_glRasterPos4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4s.xml +func (gl *GL) RasterPos4s(x, y, z, w int16) { + C.gl1_4_glRasterPos4s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4iv.xml +func (gl *GL) RasterPos4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_4_glRasterPos4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4i.xml +func (gl *GL) RasterPos4i(x, y, z, w int) { + C.gl1_4_glRasterPos4i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4fv.xml +func (gl *GL) RasterPos4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_4_glRasterPos4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4f.xml +func (gl *GL) RasterPos4f(x, y, z, w float32) { + C.gl1_4_glRasterPos4f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4dv.xml +func (gl *GL) RasterPos4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_4_glRasterPos4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4d.xml +func (gl *GL) RasterPos4d(x, y, z, w float64) { + C.gl1_4_glRasterPos4d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3sv.xml +func (gl *GL) RasterPos3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_4_glRasterPos3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3s.xml +func (gl *GL) RasterPos3s(x, y, z int16) { + C.gl1_4_glRasterPos3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3iv.xml +func (gl *GL) RasterPos3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_4_glRasterPos3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3i.xml +func (gl *GL) RasterPos3i(x, y, z int) { + C.gl1_4_glRasterPos3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3fv.xml +func (gl *GL) RasterPos3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_4_glRasterPos3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3f.xml +func (gl *GL) RasterPos3f(x, y, z float32) { + C.gl1_4_glRasterPos3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3dv.xml +func (gl *GL) RasterPos3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_4_glRasterPos3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3d.xml +func (gl *GL) RasterPos3d(x, y, z float64) { + C.gl1_4_glRasterPos3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2sv.xml +func (gl *GL) RasterPos2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_4_glRasterPos2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2s.xml +func (gl *GL) RasterPos2s(x, y int16) { + C.gl1_4_glRasterPos2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2iv.xml +func (gl *GL) RasterPos2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_4_glRasterPos2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2i.xml +func (gl *GL) RasterPos2i(x, y int) { + C.gl1_4_glRasterPos2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2fv.xml +func (gl *GL) RasterPos2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_4_glRasterPos2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2f.xml +func (gl *GL) RasterPos2f(x, y float32) { + C.gl1_4_glRasterPos2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2dv.xml +func (gl *GL) RasterPos2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_4_glRasterPos2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2d.xml +func (gl *GL) RasterPos2d(x, y float64) { + C.gl1_4_glRasterPos2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3sv.xml +func (gl *GL) Normal3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_4_glNormal3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3s.xml +func (gl *GL) Normal3s(nx, ny, nz int16) { + C.gl1_4_glNormal3s(gl.funcs, C.GLshort(nx), C.GLshort(ny), C.GLshort(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3iv.xml +func (gl *GL) Normal3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_4_glNormal3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3i.xml +func (gl *GL) Normal3i(nx, ny, nz int32) { + C.gl1_4_glNormal3i(gl.funcs, C.GLint(nx), C.GLint(ny), C.GLint(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3fv.xml +func (gl *GL) Normal3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_4_glNormal3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3f.xml +func (gl *GL) Normal3f(nx, ny, nz float32) { + C.gl1_4_glNormal3f(gl.funcs, C.GLfloat(nx), C.GLfloat(ny), C.GLfloat(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3dv.xml +func (gl *GL) Normal3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_4_glNormal3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3d.xml +func (gl *GL) Normal3d(nx, ny, nz float64) { + C.gl1_4_glNormal3d(gl.funcs, C.GLdouble(nx), C.GLdouble(ny), C.GLdouble(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3bv.xml +func (gl *GL) Normal3bv(v []byte) { + C.gl1_4_glNormal3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3b.xml +func (gl *GL) Normal3b(nx, ny, nz byte) { + C.gl1_4_glNormal3b(gl.funcs, C.GLbyte(nx), C.GLbyte(ny), C.GLbyte(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexsv.xml +func (gl *GL) Indexsv(c []int16) { + C.gl1_4_glIndexsv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexs.xml +func (gl *GL) Indexs(c int16) { + C.gl1_4_glIndexs(gl.funcs, C.GLshort(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexiv.xml +func (gl *GL) Indexiv(c []int32) { + C.gl1_4_glIndexiv(gl.funcs, (*C.GLint)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexi.xml +func (gl *GL) Indexi(c int32) { + C.gl1_4_glIndexi(gl.funcs, C.GLint(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexfv.xml +func (gl *GL) Indexfv(c []float32) { + C.gl1_4_glIndexfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexf.xml +func (gl *GL) Indexf(c float32) { + C.gl1_4_glIndexf(gl.funcs, C.GLfloat(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexdv.xml +func (gl *GL) Indexdv(c []float64) { + C.gl1_4_glIndexdv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexd.xml +func (gl *GL) Indexd(c float64) { + C.gl1_4_glIndexd(gl.funcs, C.GLdouble(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEnd.xml +func (gl *GL) End() { + C.gl1_4_glEnd(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEdgeFlagv.xml +func (gl *GL) EdgeFlagv(flag []bool) { + C.gl1_4_glEdgeFlagv(gl.funcs, (*C.GLboolean)(unsafe.Pointer(&flag[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEdgeFlag.xml +func (gl *GL) EdgeFlag(flag bool) { + C.gl1_4_glEdgeFlag(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4usv.xml +func (gl *GL) Color4usv(v []uint16) { + C.gl1_4_glColor4usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4us.xml +func (gl *GL) Color4us(red, green, blue, alpha uint16) { + C.gl1_4_glColor4us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue), C.GLushort(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4uiv.xml +func (gl *GL) Color4uiv(v []uint32) { + C.gl1_4_glColor4uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4ui.xml +func (gl *GL) Color4ui(red, green, blue, alpha uint32) { + C.gl1_4_glColor4ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue), C.GLuint(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4ubv.xml +func (gl *GL) Color4ubv(v []uint8) { + C.gl1_4_glColor4ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4ub.xml +func (gl *GL) Color4ub(red, green, blue, alpha uint8) { + C.gl1_4_glColor4ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue), C.GLubyte(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4sv.xml +func (gl *GL) Color4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_4_glColor4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4s.xml +func (gl *GL) Color4s(red, green, blue, alpha int16) { + C.gl1_4_glColor4s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue), C.GLshort(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4iv.xml +func (gl *GL) Color4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_4_glColor4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4i.xml +func (gl *GL) Color4i(red, green, blue, alpha int32) { + C.gl1_4_glColor4i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue), C.GLint(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4fv.xml +func (gl *GL) Color4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_4_glColor4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4f.xml +func (gl *GL) Color4f(red, green, blue, alpha float32) { + C.gl1_4_glColor4f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4dv.xml +func (gl *GL) Color4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_4_glColor4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4d.xml +func (gl *GL) Color4d(red, green, blue, alpha float64) { + C.gl1_4_glColor4d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue), C.GLdouble(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4bv.xml +func (gl *GL) Color4bv(v []byte) { + C.gl1_4_glColor4bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4b.xml +func (gl *GL) Color4b(red, green, blue, alpha byte) { + C.gl1_4_glColor4b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue), C.GLbyte(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3usv.xml +func (gl *GL) Color3usv(v []uint16) { + C.gl1_4_glColor3usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3us.xml +func (gl *GL) Color3us(red, green, blue uint16) { + C.gl1_4_glColor3us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3uiv.xml +func (gl *GL) Color3uiv(v []uint32) { + C.gl1_4_glColor3uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3ui.xml +func (gl *GL) Color3ui(red, green, blue uint32) { + C.gl1_4_glColor3ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3ubv.xml +func (gl *GL) Color3ubv(v []uint8) { + C.gl1_4_glColor3ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3ub.xml +func (gl *GL) Color3ub(red, green, blue uint8) { + C.gl1_4_glColor3ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3sv.xml +func (gl *GL) Color3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_4_glColor3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3s.xml +func (gl *GL) Color3s(red, green, blue int16) { + C.gl1_4_glColor3s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3iv.xml +func (gl *GL) Color3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_4_glColor3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3i.xml +func (gl *GL) Color3i(red, green, blue int32) { + C.gl1_4_glColor3i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3fv.xml +func (gl *GL) Color3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_4_glColor3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3f.xml +func (gl *GL) Color3f(red, green, blue float32) { + C.gl1_4_glColor3f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3dv.xml +func (gl *GL) Color3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_4_glColor3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3d.xml +func (gl *GL) Color3d(red, green, blue float64) { + C.gl1_4_glColor3d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3bv.xml +func (gl *GL) Color3bv(v []byte) { + C.gl1_4_glColor3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3b.xml +func (gl *GL) Color3b(red, green, blue byte) { + C.gl1_4_glColor3b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBitmap.xml +func (gl *GL) Bitmap(width, height int, xorig, yorig, xmove, ymove float32, bitmap []uint8) { + C.gl1_4_glBitmap(gl.funcs, C.GLsizei(width), C.GLsizei(height), C.GLfloat(xorig), C.GLfloat(yorig), C.GLfloat(xmove), C.GLfloat(ymove), (*C.GLubyte)(unsafe.Pointer(&bitmap[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBegin.xml +func (gl *GL) Begin(mode glbase.Enum) { + C.gl1_4_glBegin(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glListBase.xml +func (gl *GL) ListBase(base uint32) { + C.gl1_4_glListBase(gl.funcs, C.GLuint(base)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGenLists.xml +func (gl *GL) GenLists(range_ int32) uint32 { + glresult := C.gl1_4_glGenLists(gl.funcs, C.GLsizei(range_)) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDeleteLists.xml +func (gl *GL) DeleteLists(list uint32, range_ int32) { + C.gl1_4_glDeleteLists(gl.funcs, C.GLuint(list), C.GLsizei(range_)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCallLists.xml +func (gl *GL) CallLists(n int, gltype glbase.Enum, lists interface{}) { + var lists_ptr unsafe.Pointer + var lists_v = reflect.ValueOf(lists) + if lists != nil && lists_v.Kind() != reflect.Slice { + panic("parameter lists must be a slice") + } + if lists != nil { + lists_ptr = unsafe.Pointer(lists_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glCallLists(gl.funcs, C.GLsizei(n), C.GLenum(gltype), lists_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCallList.xml +func (gl *GL) CallList(list uint32) { + C.gl1_4_glCallList(gl.funcs, C.GLuint(list)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEndList.xml +func (gl *GL) EndList() { + C.gl1_4_glEndList(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNewList.xml +func (gl *GL) NewList(list uint32, mode glbase.Enum) { + C.gl1_4_glNewList(gl.funcs, C.GLuint(list), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPushClientAttrib.xml +func (gl *GL) PushClientAttrib(mask glbase.Bitfield) { + C.gl1_4_glPushClientAttrib(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPopClientAttrib.xml +func (gl *GL) PopClientAttrib() { + C.gl1_4_glPopClientAttrib(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPrioritizeTextures.xml +func (gl *GL) PrioritizeTextures(n int, textures []glbase.Texture, priorities []float32) { + C.gl1_4_glPrioritizeTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0])), (*C.GLfloat)(unsafe.Pointer(&priorities[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glAreTexturesResident.xml +func (gl *GL) AreTexturesResident(n int, textures []glbase.Texture, residences []bool) bool { + glresult := C.gl1_4_glAreTexturesResident(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0])), (*C.GLboolean)(unsafe.Pointer(&residences[0]))) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexPointer.xml +func (gl *GL) VertexPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glVertexPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoordPointer.xml +func (gl *GL) TexCoordPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glTexCoordPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormalPointer.xml +func (gl *GL) NormalPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glNormalPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glInterleavedArrays.xml +func (gl *GL) InterleavedArrays(format glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glInterleavedArrays(gl.funcs, C.GLenum(format), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexPointer.xml +func (gl *GL) IndexPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glIndexPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEnableClientState.xml +func (gl *GL) EnableClientState(array glbase.Enum) { + C.gl1_4_glEnableClientState(gl.funcs, C.GLenum(array)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEdgeFlagPointer.xml +func (gl *GL) EdgeFlagPointer(stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glEdgeFlagPointer(gl.funcs, C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDisableClientState.xml +func (gl *GL) DisableClientState(array glbase.Enum) { + C.gl1_4_glDisableClientState(gl.funcs, C.GLenum(array)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorPointer.xml +func (gl *GL) ColorPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glColorPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glArrayElement.xml +func (gl *GL) ArrayElement(i int32) { + C.gl1_4_glArrayElement(gl.funcs, C.GLint(i)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glResetMinmax.xml +func (gl *GL) ResetMinmax(target glbase.Enum) { + C.gl1_4_glResetMinmax(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glResetHistogram.xml +func (gl *GL) ResetHistogram(target glbase.Enum) { + C.gl1_4_glResetHistogram(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMinmax.xml +func (gl *GL) Minmax(target, internalFormat glbase.Enum, sink bool) { + C.gl1_4_glMinmax(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), *(*C.GLboolean)(unsafe.Pointer(&sink))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glHistogram.xml +func (gl *GL) Histogram(target glbase.Enum, width int, internalFormat glbase.Enum, sink bool) { + C.gl1_4_glHistogram(gl.funcs, C.GLenum(target), C.GLsizei(width), C.GLenum(internalFormat), *(*C.GLboolean)(unsafe.Pointer(&sink))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMinmaxParameteriv.xml +func (gl *GL) GetMinmaxParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_4_glGetMinmaxParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMinmaxParameterfv.xml +func (gl *GL) GetMinmaxParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_4_glGetMinmaxParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMinmax.xml +func (gl *GL) GetMinmax(target glbase.Enum, reset bool, format, gltype glbase.Enum, values interface{}) { + var values_ptr unsafe.Pointer + var values_v = reflect.ValueOf(values) + if values != nil && values_v.Kind() != reflect.Slice { + panic("parameter values must be a slice") + } + if values != nil { + values_ptr = unsafe.Pointer(values_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glGetMinmax(gl.funcs, C.GLenum(target), *(*C.GLboolean)(unsafe.Pointer(&reset)), C.GLenum(format), C.GLenum(gltype), values_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetHistogramParameteriv.xml +func (gl *GL) GetHistogramParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_4_glGetHistogramParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetHistogramParameterfv.xml +func (gl *GL) GetHistogramParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_4_glGetHistogramParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetHistogram.xml +func (gl *GL) GetHistogram(target glbase.Enum, reset bool, format, gltype glbase.Enum, values interface{}) { + var values_ptr unsafe.Pointer + var values_v = reflect.ValueOf(values) + if values != nil && values_v.Kind() != reflect.Slice { + panic("parameter values must be a slice") + } + if values != nil { + values_ptr = unsafe.Pointer(values_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glGetHistogram(gl.funcs, C.GLenum(target), *(*C.GLboolean)(unsafe.Pointer(&reset)), C.GLenum(format), C.GLenum(gltype), values_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSeparableFilter2D.xml +func (gl *GL) SeparableFilter2D(target, internalFormat glbase.Enum, width, height int, format, gltype glbase.Enum, row, column interface{}) { + var row_ptr unsafe.Pointer + var row_v = reflect.ValueOf(row) + if row != nil && row_v.Kind() != reflect.Slice { + panic("parameter row must be a slice") + } + if row != nil { + row_ptr = unsafe.Pointer(row_v.Index(0).Addr().Pointer()) + } + var column_ptr unsafe.Pointer + var column_v = reflect.ValueOf(column) + if column != nil && column_v.Kind() != reflect.Slice { + panic("parameter column must be a slice") + } + if column != nil { + column_ptr = unsafe.Pointer(column_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glSeparableFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), row_ptr, column_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetSeparableFilter.xml +func (gl *GL) GetSeparableFilter(target, format, gltype glbase.Enum, row, column, span interface{}) { + var row_ptr unsafe.Pointer + var row_v = reflect.ValueOf(row) + if row != nil && row_v.Kind() != reflect.Slice { + panic("parameter row must be a slice") + } + if row != nil { + row_ptr = unsafe.Pointer(row_v.Index(0).Addr().Pointer()) + } + var column_ptr unsafe.Pointer + var column_v = reflect.ValueOf(column) + if column != nil && column_v.Kind() != reflect.Slice { + panic("parameter column must be a slice") + } + if column != nil { + column_ptr = unsafe.Pointer(column_v.Index(0).Addr().Pointer()) + } + var span_ptr unsafe.Pointer + var span_v = reflect.ValueOf(span) + if span != nil && span_v.Kind() != reflect.Slice { + panic("parameter span must be a slice") + } + if span != nil { + span_ptr = unsafe.Pointer(span_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glGetSeparableFilter(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), row_ptr, column_ptr, span_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetConvolutionParameteriv.xml +func (gl *GL) GetConvolutionParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_4_glGetConvolutionParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetConvolutionParameterfv.xml +func (gl *GL) GetConvolutionParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_4_glGetConvolutionParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetConvolutionFilter.xml +func (gl *GL) GetConvolutionFilter(target, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glGetConvolutionFilter(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyConvolutionFilter2D.xml +func (gl *GL) CopyConvolutionFilter2D(target, internalFormat glbase.Enum, x, y, width, height int) { + C.gl1_4_glCopyConvolutionFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyConvolutionFilter1D.xml +func (gl *GL) CopyConvolutionFilter1D(target, internalFormat glbase.Enum, x, y, width int) { + C.gl1_4_glCopyConvolutionFilter1D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionParameteriv.xml +func (gl *GL) ConvolutionParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_4_glConvolutionParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionParameteri.xml +func (gl *GL) ConvolutionParameteri(target, pname glbase.Enum, params int32) { + C.gl1_4_glConvolutionParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(params)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionParameterfv.xml +func (gl *GL) ConvolutionParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_4_glConvolutionParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionParameterf.xml +func (gl *GL) ConvolutionParameterf(target, pname glbase.Enum, params float32) { + C.gl1_4_glConvolutionParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(params)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionFilter2D.xml +func (gl *GL) ConvolutionFilter2D(target, internalFormat glbase.Enum, width, height int, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glConvolutionFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionFilter1D.xml +func (gl *GL) ConvolutionFilter1D(target, internalFormat glbase.Enum, width int, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glConvolutionFilter1D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyColorSubTable.xml +func (gl *GL) CopyColorSubTable(target glbase.Enum, start int32, x, y, width int) { + C.gl1_4_glCopyColorSubTable(gl.funcs, C.GLenum(target), C.GLsizei(start), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorSubTable.xml +func (gl *GL) ColorSubTable(target glbase.Enum, start int32, count int, format, gltype glbase.Enum, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glColorSubTable(gl.funcs, C.GLenum(target), C.GLsizei(start), C.GLsizei(count), C.GLenum(format), C.GLenum(gltype), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetColorTableParameteriv.xml +func (gl *GL) GetColorTableParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_4_glGetColorTableParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetColorTableParameterfv.xml +func (gl *GL) GetColorTableParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_4_glGetColorTableParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetColorTable.xml +func (gl *GL) GetColorTable(target, format, gltype glbase.Enum, table interface{}) { + var table_ptr unsafe.Pointer + var table_v = reflect.ValueOf(table) + if table != nil && table_v.Kind() != reflect.Slice { + panic("parameter table must be a slice") + } + if table != nil { + table_ptr = unsafe.Pointer(table_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glGetColorTable(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), table_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyColorTable.xml +func (gl *GL) CopyColorTable(target, internalFormat glbase.Enum, x, y, width int) { + C.gl1_4_glCopyColorTable(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorTableParameteriv.xml +func (gl *GL) ColorTableParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_4_glColorTableParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorTableParameterfv.xml +func (gl *GL) ColorTableParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_4_glColorTableParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorTable.xml +func (gl *GL) ColorTable(target, internalFormat glbase.Enum, width int, format, gltype glbase.Enum, table interface{}) { + var table_ptr unsafe.Pointer + var table_v = reflect.ValueOf(table) + if table != nil && table_v.Kind() != reflect.Slice { + panic("parameter table must be a slice") + } + if table != nil { + table_ptr = unsafe.Pointer(table_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glColorTable(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), table_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultTransposeMatrixd.xml +func (gl *GL) MultTransposeMatrixd(m []float64) { + C.gl1_4_glMultTransposeMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultTransposeMatrixf.xml +func (gl *GL) MultTransposeMatrixf(m []float32) { + C.gl1_4_glMultTransposeMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadTransposeMatrixd.xml +func (gl *GL) LoadTransposeMatrixd(m []float64) { + C.gl1_4_glLoadTransposeMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadTransposeMatrixf.xml +func (gl *GL) LoadTransposeMatrixf(m []float32) { + C.gl1_4_glLoadTransposeMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4sv.xml +func (gl *GL) MultiTexCoord4sv(target glbase.Enum, v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_4_glMultiTexCoord4sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4s.xml +func (gl *GL) MultiTexCoord4s(target glbase.Enum, s, t, r, q int16) { + C.gl1_4_glMultiTexCoord4s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t), C.GLshort(r), C.GLshort(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4iv.xml +func (gl *GL) MultiTexCoord4iv(target glbase.Enum, v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_4_glMultiTexCoord4iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4i.xml +func (gl *GL) MultiTexCoord4i(target glbase.Enum, s, t, r, q int32) { + C.gl1_4_glMultiTexCoord4i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t), C.GLint(r), C.GLint(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4fv.xml +func (gl *GL) MultiTexCoord4fv(target glbase.Enum, v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_4_glMultiTexCoord4fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4f.xml +func (gl *GL) MultiTexCoord4f(target glbase.Enum, s, t, r, q float32) { + C.gl1_4_glMultiTexCoord4f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t), C.GLfloat(r), C.GLfloat(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4dv.xml +func (gl *GL) MultiTexCoord4dv(target glbase.Enum, v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_4_glMultiTexCoord4dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4d.xml +func (gl *GL) MultiTexCoord4d(target glbase.Enum, s, t, r, q float64) { + C.gl1_4_glMultiTexCoord4d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t), C.GLdouble(r), C.GLdouble(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3sv.xml +func (gl *GL) MultiTexCoord3sv(target glbase.Enum, v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_4_glMultiTexCoord3sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3s.xml +func (gl *GL) MultiTexCoord3s(target glbase.Enum, s, t, r int16) { + C.gl1_4_glMultiTexCoord3s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t), C.GLshort(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3iv.xml +func (gl *GL) MultiTexCoord3iv(target glbase.Enum, v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_4_glMultiTexCoord3iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3i.xml +func (gl *GL) MultiTexCoord3i(target glbase.Enum, s, t, r int32) { + C.gl1_4_glMultiTexCoord3i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t), C.GLint(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3fv.xml +func (gl *GL) MultiTexCoord3fv(target glbase.Enum, v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_4_glMultiTexCoord3fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3f.xml +func (gl *GL) MultiTexCoord3f(target glbase.Enum, s, t, r float32) { + C.gl1_4_glMultiTexCoord3f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t), C.GLfloat(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3dv.xml +func (gl *GL) MultiTexCoord3dv(target glbase.Enum, v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_4_glMultiTexCoord3dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3d.xml +func (gl *GL) MultiTexCoord3d(target glbase.Enum, s, t, r float64) { + C.gl1_4_glMultiTexCoord3d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t), C.GLdouble(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2sv.xml +func (gl *GL) MultiTexCoord2sv(target glbase.Enum, v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_4_glMultiTexCoord2sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2s.xml +func (gl *GL) MultiTexCoord2s(target glbase.Enum, s, t int16) { + C.gl1_4_glMultiTexCoord2s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2iv.xml +func (gl *GL) MultiTexCoord2iv(target glbase.Enum, v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_4_glMultiTexCoord2iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2i.xml +func (gl *GL) MultiTexCoord2i(target glbase.Enum, s, t int32) { + C.gl1_4_glMultiTexCoord2i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2fv.xml +func (gl *GL) MultiTexCoord2fv(target glbase.Enum, v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_4_glMultiTexCoord2fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2f.xml +func (gl *GL) MultiTexCoord2f(target glbase.Enum, s, t float32) { + C.gl1_4_glMultiTexCoord2f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2dv.xml +func (gl *GL) MultiTexCoord2dv(target glbase.Enum, v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_4_glMultiTexCoord2dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2d.xml +func (gl *GL) MultiTexCoord2d(target glbase.Enum, s, t float64) { + C.gl1_4_glMultiTexCoord2d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1sv.xml +func (gl *GL) MultiTexCoord1sv(target glbase.Enum, v []int16) { + C.gl1_4_glMultiTexCoord1sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1s.xml +func (gl *GL) MultiTexCoord1s(target glbase.Enum, s int16) { + C.gl1_4_glMultiTexCoord1s(gl.funcs, C.GLenum(target), C.GLshort(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1iv.xml +func (gl *GL) MultiTexCoord1iv(target glbase.Enum, v []int32) { + C.gl1_4_glMultiTexCoord1iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1i.xml +func (gl *GL) MultiTexCoord1i(target glbase.Enum, s int32) { + C.gl1_4_glMultiTexCoord1i(gl.funcs, C.GLenum(target), C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1fv.xml +func (gl *GL) MultiTexCoord1fv(target glbase.Enum, v []float32) { + C.gl1_4_glMultiTexCoord1fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1f.xml +func (gl *GL) MultiTexCoord1f(target glbase.Enum, s float32) { + C.gl1_4_glMultiTexCoord1f(gl.funcs, C.GLenum(target), C.GLfloat(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1dv.xml +func (gl *GL) MultiTexCoord1dv(target glbase.Enum, v []float64) { + C.gl1_4_glMultiTexCoord1dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1d.xml +func (gl *GL) MultiTexCoord1d(target glbase.Enum, s float64) { + C.gl1_4_glMultiTexCoord1d(gl.funcs, C.GLenum(target), C.GLdouble(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClientActiveTexture.xml +func (gl *GL) ClientActiveTexture(texture glbase.Enum) { + C.gl1_4_glClientActiveTexture(gl.funcs, C.GLenum(texture)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos3sv.xml +func (gl *GL) WindowPos3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_4_glWindowPos3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos3s.xml +func (gl *GL) WindowPos3s(x, y, z int16) { + C.gl1_4_glWindowPos3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos3iv.xml +func (gl *GL) WindowPos3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_4_glWindowPos3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos3i.xml +func (gl *GL) WindowPos3i(x, y, z int) { + C.gl1_4_glWindowPos3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos3fv.xml +func (gl *GL) WindowPos3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_4_glWindowPos3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos3f.xml +func (gl *GL) WindowPos3f(x, y, z float32) { + C.gl1_4_glWindowPos3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos3dv.xml +func (gl *GL) WindowPos3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_4_glWindowPos3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos3d.xml +func (gl *GL) WindowPos3d(x, y, z float64) { + C.gl1_4_glWindowPos3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos2sv.xml +func (gl *GL) WindowPos2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_4_glWindowPos2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos2s.xml +func (gl *GL) WindowPos2s(x, y int16) { + C.gl1_4_glWindowPos2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos2iv.xml +func (gl *GL) WindowPos2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_4_glWindowPos2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos2i.xml +func (gl *GL) WindowPos2i(x, y int) { + C.gl1_4_glWindowPos2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos2fv.xml +func (gl *GL) WindowPos2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_4_glWindowPos2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos2f.xml +func (gl *GL) WindowPos2f(x, y float32) { + C.gl1_4_glWindowPos2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos2dv.xml +func (gl *GL) WindowPos2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_4_glWindowPos2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos2d.xml +func (gl *GL) WindowPos2d(x, y float64) { + C.gl1_4_glWindowPos2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColorPointer.xml +func (gl *GL) SecondaryColorPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glSecondaryColorPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3usv.xml +func (gl *GL) SecondaryColor3usv(v []uint16) { + C.gl1_4_glSecondaryColor3usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3us.xml +func (gl *GL) SecondaryColor3us(red, green, blue uint16) { + C.gl1_4_glSecondaryColor3us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3uiv.xml +func (gl *GL) SecondaryColor3uiv(v []uint32) { + C.gl1_4_glSecondaryColor3uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3ui.xml +func (gl *GL) SecondaryColor3ui(red, green, blue uint32) { + C.gl1_4_glSecondaryColor3ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3ubv.xml +func (gl *GL) SecondaryColor3ubv(v []uint8) { + C.gl1_4_glSecondaryColor3ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3ub.xml +func (gl *GL) SecondaryColor3ub(red, green, blue uint8) { + C.gl1_4_glSecondaryColor3ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3sv.xml +func (gl *GL) SecondaryColor3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_4_glSecondaryColor3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3s.xml +func (gl *GL) SecondaryColor3s(red, green, blue int16) { + C.gl1_4_glSecondaryColor3s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3iv.xml +func (gl *GL) SecondaryColor3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_4_glSecondaryColor3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3i.xml +func (gl *GL) SecondaryColor3i(red, green, blue int32) { + C.gl1_4_glSecondaryColor3i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3fv.xml +func (gl *GL) SecondaryColor3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_4_glSecondaryColor3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3f.xml +func (gl *GL) SecondaryColor3f(red, green, blue float32) { + C.gl1_4_glSecondaryColor3f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3dv.xml +func (gl *GL) SecondaryColor3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_4_glSecondaryColor3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3d.xml +func (gl *GL) SecondaryColor3d(red, green, blue float64) { + C.gl1_4_glSecondaryColor3d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3bv.xml +func (gl *GL) SecondaryColor3bv(v []byte) { + C.gl1_4_glSecondaryColor3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3b.xml +func (gl *GL) SecondaryColor3b(red, green, blue byte) { + C.gl1_4_glSecondaryColor3b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogCoordPointer.xml +func (gl *GL) FogCoordPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_4_glFogCoordPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogCoorddv.xml +func (gl *GL) FogCoorddv(coord []float64) { + C.gl1_4_glFogCoorddv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&coord[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogCoordd.xml +func (gl *GL) FogCoordd(coord float64) { + C.gl1_4_glFogCoordd(gl.funcs, C.GLdouble(coord)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogCoordfv.xml +func (gl *GL) FogCoordfv(coord []float32) { + C.gl1_4_glFogCoordfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&coord[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogCoordf.xml +func (gl *GL) FogCoordf(coord float32) { + C.gl1_4_glFogCoordf(gl.funcs, C.GLfloat(coord)) +} diff --git a/gl/1.5/funcs.cpp b/gl/1.5/funcs.cpp new file mode 100644 index 00000000..6158162f --- /dev/null +++ b/gl/1.5/funcs.cpp @@ -0,0 +1,2892 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#include +#include + +#include "funcs.h" + +void *gl1_5_funcs() { + QOpenGLFunctions_1_5* funcs = QOpenGLContext::currentContext()->versionFunctions(); + if (!funcs) { + return 0; + } + funcs->initializeOpenGLFunctions(); + return funcs; +} + + +void gl1_5_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewport(x, y, width, height); +} + +void gl1_5_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRange(nearVal, farVal); +} + +GLboolean gl1_5_glIsEnabled(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabled(cap); +} + +void gl1_5_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameteriv(target, level, pname, params); +} + +void gl1_5_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameterfv(target, level, pname, params); +} + +void gl1_5_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameteriv(target, pname, params); +} + +void gl1_5_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterfv(target, pname, params); +} + +void gl1_5_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexImage(target, level, format, gltype, pixels); +} + +void gl1_5_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegerv(pname, params); +} + +void gl1_5_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFloatv(pname, params); +} + +GLenum gl1_5_glGetError(void *_glfuncs) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetError(); +} + +void gl1_5_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetDoublev(pname, params); +} + +void gl1_5_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleanv(pname, params); +} + +void gl1_5_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadPixels(x, y, width, height, format, gltype, pixels); +} + +void gl1_5_glReadBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadBuffer(mode); +} + +void gl1_5_glPixelStorei(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStorei(pname, param); +} + +void gl1_5_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStoref(pname, param); +} + +void gl1_5_glDepthFunc(void *_glfuncs, GLenum glfunc) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthFunc(glfunc); +} + +void gl1_5_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOp(fail, zfail, zpass); +} + +void gl1_5_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFunc(glfunc, ref, mask); +} + +void gl1_5_glLogicOp(void *_glfuncs, GLenum opcode) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLogicOp(opcode); +} + +void gl1_5_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFunc(sfactor, dfactor); +} + +void gl1_5_glFlush(void *_glfuncs) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlush(); +} + +void gl1_5_glFinish(void *_glfuncs) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFinish(); +} + +void gl1_5_glEnable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnable(cap); +} + +void gl1_5_glDisable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisable(cap); +} + +void gl1_5_glDepthMask(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthMask(flag); +} + +void gl1_5_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMask(red, green, blue, alpha); +} + +void gl1_5_glStencilMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMask(mask); +} + +void gl1_5_glClearDepth(void *_glfuncs, GLdouble depth) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearDepth(depth); +} + +void gl1_5_glClearStencil(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearStencil(s); +} + +void gl1_5_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearColor(red, green, blue, alpha); +} + +void gl1_5_glClear(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClear(mask); +} + +void gl1_5_glDrawBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffer(mode); +} + +void gl1_5_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage2D(target, level, internalFormat, width, height, border, format, gltype, pixels); +} + +void gl1_5_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage1D(target, level, internalFormat, width, border, format, gltype, pixels); +} + +void gl1_5_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteriv(target, pname, params); +} + +void gl1_5_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteri(target, pname, param); +} + +void gl1_5_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterfv(target, pname, params); +} + +void gl1_5_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterf(target, pname, param); +} + +void gl1_5_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissor(x, y, width, height); +} + +void gl1_5_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonMode(face, mode); +} + +void gl1_5_glPointSize(void *_glfuncs, GLfloat size) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointSize(size); +} + +void gl1_5_glLineWidth(void *_glfuncs, GLfloat width) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineWidth(width); +} + +void gl1_5_glHint(void *_glfuncs, GLenum target, GLenum mode) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glHint(target, mode); +} + +void gl1_5_glFrontFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrontFace(mode); +} + +void gl1_5_glCullFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCullFace(mode); +} + +void gl1_5_glIndexubv(void *_glfuncs, const GLubyte* c) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexubv(c); +} + +void gl1_5_glIndexub(void *_glfuncs, GLubyte c) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexub(c); +} + +GLboolean gl1_5_glIsTexture(void *_glfuncs, GLuint texture) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsTexture(texture); +} + +void gl1_5_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenTextures(n, textures); +} + +void gl1_5_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteTextures(n, textures); +} + +void gl1_5_glBindTexture(void *_glfuncs, GLenum target, GLuint texture) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindTexture(target, texture); +} + +void gl1_5_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, gltype, pixels); +} + +void gl1_5_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage1D(target, level, xoffset, width, format, gltype, pixels); +} + +void gl1_5_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); +} + +void gl1_5_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage1D(target, level, xoffset, x, y, width); +} + +void gl1_5_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage2D(target, level, internalFormat, x, y, width, height, border); +} + +void gl1_5_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage1D(target, level, internalFormat, x, y, width, border); +} + +void gl1_5_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonOffset(factor, units); +} + +void gl1_5_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElements(mode, count, gltype, indices); +} + +void gl1_5_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArrays(mode, first, count); +} + +void gl1_5_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); +} + +void gl1_5_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, gltype, pixels); +} + +void gl1_5_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage3D(target, level, internalFormat, width, height, depth, border, format, gltype, pixels); +} + +void gl1_5_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawRangeElements(mode, start, end, count, gltype, indices); +} + +void gl1_5_glBlendEquation(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquation(mode); +} + +void gl1_5_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendColor(red, green, blue, alpha); +} + +void gl1_5_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetCompressedTexImage(target, level, img); +} + +void gl1_5_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data); +} + +void gl1_5_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); +} + +void gl1_5_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); +} + +void gl1_5_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage1D(target, level, internalFormat, width, border, imageSize, data); +} + +void gl1_5_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data); +} + +void gl1_5_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage3D(target, level, internalFormat, width, height, depth, border, imageSize, data); +} + +void gl1_5_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSampleCoverage(value, invert); +} + +void gl1_5_glActiveTexture(void *_glfuncs, GLenum texture) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glActiveTexture(texture); +} + +void gl1_5_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteriv(pname, params); +} + +void gl1_5_glPointParameteri(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteri(pname, param); +} + +void gl1_5_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterfv(pname, params); +} + +void gl1_5_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterf(pname, param); +} + +void gl1_5_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiDrawArrays(mode, first, count, drawcount); +} + +void gl1_5_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); +} + +void gl1_5_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferParameteriv(target, pname, params); +} + +GLboolean gl1_5_glUnmapBuffer(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glUnmapBuffer(target); +} + +void gl1_5_glGetBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferSubData(target, offset, size, data); +} + +void gl1_5_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferSubData(target, offset, size, data); +} + +void gl1_5_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferData(target, size, data, usage); +} + +GLboolean gl1_5_glIsBuffer(void *_glfuncs, GLuint buffer) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsBuffer(buffer); +} + +void gl1_5_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenBuffers(n, buffers); +} + +void gl1_5_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteBuffers(n, buffers); +} + +void gl1_5_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBuffer(target, buffer); +} + +void gl1_5_glGetQueryObjectuiv(void *_glfuncs, GLuint id, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectuiv(id, pname, params); +} + +void gl1_5_glGetQueryObjectiv(void *_glfuncs, GLuint id, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectiv(id, pname, params); +} + +void gl1_5_glGetQueryiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryiv(target, pname, params); +} + +void gl1_5_glEndQuery(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndQuery(target); +} + +void gl1_5_glBeginQuery(void *_glfuncs, GLenum target, GLuint id) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginQuery(target, id); +} + +GLboolean gl1_5_glIsQuery(void *_glfuncs, GLuint id) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsQuery(id); +} + +void gl1_5_glDeleteQueries(void *_glfuncs, GLsizei n, const GLuint* ids) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteQueries(n, ids); +} + +void gl1_5_glGenQueries(void *_glfuncs, GLsizei n, GLuint* ids) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenQueries(n, ids); +} + +void gl1_5_glTranslatef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTranslatef(x, y, z); +} + +void gl1_5_glTranslated(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTranslated(x, y, z); +} + +void gl1_5_glScalef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScalef(x, y, z); +} + +void gl1_5_glScaled(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScaled(x, y, z); +} + +void gl1_5_glRotatef(void *_glfuncs, GLfloat angle, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRotatef(angle, x, y, z); +} + +void gl1_5_glRotated(void *_glfuncs, GLdouble angle, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRotated(angle, x, y, z); +} + +void gl1_5_glPushMatrix(void *_glfuncs) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushMatrix(); +} + +void gl1_5_glPopMatrix(void *_glfuncs) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopMatrix(); +} + +void gl1_5_glOrtho(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glOrtho(left, right, bottom, top, zNear, zFar); +} + +void gl1_5_glMultMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultMatrixd(m); +} + +void gl1_5_glMultMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultMatrixf(m); +} + +void gl1_5_glMatrixMode(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMatrixMode(mode); +} + +void gl1_5_glLoadMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadMatrixd(m); +} + +void gl1_5_glLoadMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadMatrixf(m); +} + +void gl1_5_glLoadIdentity(void *_glfuncs) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadIdentity(); +} + +void gl1_5_glFrustum(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrustum(left, right, bottom, top, zNear, zFar); +} + +GLboolean gl1_5_glIsList(void *_glfuncs, GLuint list) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsList(list); +} + +void gl1_5_glGetTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGeniv(coord, pname, params); +} + +void gl1_5_glGetTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGenfv(coord, pname, params); +} + +void gl1_5_glGetTexGendv(void *_glfuncs, GLenum coord, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGendv(coord, pname, params); +} + +void gl1_5_glGetTexEnviv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexEnviv(target, pname, params); +} + +void gl1_5_glGetTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexEnvfv(target, pname, params); +} + +void gl1_5_glGetPolygonStipple(void *_glfuncs, GLubyte* mask) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPolygonStipple(mask); +} + +void gl1_5_glGetPixelMapusv(void *_glfuncs, GLenum glmap, GLushort* values) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapusv(glmap, values); +} + +void gl1_5_glGetPixelMapuiv(void *_glfuncs, GLenum glmap, GLuint* values) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapuiv(glmap, values); +} + +void gl1_5_glGetPixelMapfv(void *_glfuncs, GLenum glmap, GLfloat* values) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapfv(glmap, values); +} + +void gl1_5_glGetMaterialiv(void *_glfuncs, GLenum face, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMaterialiv(face, pname, params); +} + +void gl1_5_glGetMaterialfv(void *_glfuncs, GLenum face, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMaterialfv(face, pname, params); +} + +void gl1_5_glGetMapiv(void *_glfuncs, GLenum target, GLenum query, GLint* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapiv(target, query, v); +} + +void gl1_5_glGetMapfv(void *_glfuncs, GLenum target, GLenum query, GLfloat* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapfv(target, query, v); +} + +void gl1_5_glGetMapdv(void *_glfuncs, GLenum target, GLenum query, GLdouble* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapdv(target, query, v); +} + +void gl1_5_glGetLightiv(void *_glfuncs, GLenum light, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetLightiv(light, pname, params); +} + +void gl1_5_glGetLightfv(void *_glfuncs, GLenum light, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetLightfv(light, pname, params); +} + +void gl1_5_glGetClipPlane(void *_glfuncs, GLenum plane, GLdouble* equation) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetClipPlane(plane, equation); +} + +void gl1_5_glDrawPixels(void *_glfuncs, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawPixels(width, height, format, gltype, pixels); +} + +void gl1_5_glCopyPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum gltype) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyPixels(x, y, width, height, gltype); +} + +void gl1_5_glPixelMapusv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLushort* values) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapusv(glmap, mapsize, values); +} + +void gl1_5_glPixelMapuiv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLuint* values) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapuiv(glmap, mapsize, values); +} + +void gl1_5_glPixelMapfv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLfloat* values) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapfv(glmap, mapsize, values); +} + +void gl1_5_glPixelTransferi(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelTransferi(pname, param); +} + +void gl1_5_glPixelTransferf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelTransferf(pname, param); +} + +void gl1_5_glPixelZoom(void *_glfuncs, GLfloat xfactor, GLfloat yfactor) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelZoom(xfactor, yfactor); +} + +void gl1_5_glAlphaFunc(void *_glfuncs, GLenum glfunc, GLfloat ref) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAlphaFunc(glfunc, ref); +} + +void gl1_5_glEvalPoint2(void *_glfuncs, GLint i, GLint j) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalPoint2(i, j); +} + +void gl1_5_glEvalMesh2(void *_glfuncs, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalMesh2(mode, i1, i2, j1, j2); +} + +void gl1_5_glEvalPoint1(void *_glfuncs, GLint i) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalPoint1(i); +} + +void gl1_5_glEvalMesh1(void *_glfuncs, GLenum mode, GLint i1, GLint i2) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalMesh1(mode, i1, i2); +} + +void gl1_5_glEvalCoord2fv(void *_glfuncs, const GLfloat* u) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2fv(u); +} + +void gl1_5_glEvalCoord2f(void *_glfuncs, GLfloat u, GLfloat v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2f(u, v); +} + +void gl1_5_glEvalCoord2dv(void *_glfuncs, const GLdouble* u) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2dv(u); +} + +void gl1_5_glEvalCoord2d(void *_glfuncs, GLdouble u, GLdouble v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2d(u, v); +} + +void gl1_5_glEvalCoord1fv(void *_glfuncs, const GLfloat* u) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1fv(u); +} + +void gl1_5_glEvalCoord1f(void *_glfuncs, GLfloat u) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1f(u); +} + +void gl1_5_glEvalCoord1dv(void *_glfuncs, const GLdouble* u) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1dv(u); +} + +void gl1_5_glEvalCoord1d(void *_glfuncs, GLdouble u) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1d(u); +} + +void gl1_5_glMapGrid2f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid2f(un, u1, u2, vn, v1, v2); +} + +void gl1_5_glMapGrid2d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid2d(un, u1, u2, vn, v1, v2); +} + +void gl1_5_glMapGrid1f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid1f(un, u1, u2); +} + +void gl1_5_glMapGrid1d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid1d(un, u1, u2); +} + +void gl1_5_glMap2f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); +} + +void gl1_5_glMap2d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); +} + +void gl1_5_glMap1f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap1f(target, u1, u2, stride, order, points); +} + +void gl1_5_glMap1d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap1d(target, u1, u2, stride, order, points); +} + +void gl1_5_glPushAttrib(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushAttrib(mask); +} + +void gl1_5_glPopAttrib(void *_glfuncs) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopAttrib(); +} + +void gl1_5_glAccum(void *_glfuncs, GLenum op, GLfloat value) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAccum(op, value); +} + +void gl1_5_glIndexMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexMask(mask); +} + +void gl1_5_glClearIndex(void *_glfuncs, GLfloat c) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearIndex(c); +} + +void gl1_5_glClearAccum(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearAccum(red, green, blue, alpha); +} + +void gl1_5_glPushName(void *_glfuncs, GLuint name) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushName(name); +} + +void gl1_5_glPopName(void *_glfuncs) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopName(); +} + +void gl1_5_glPassThrough(void *_glfuncs, GLfloat token) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPassThrough(token); +} + +void gl1_5_glLoadName(void *_glfuncs, GLuint name) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadName(name); +} + +void gl1_5_glInitNames(void *_glfuncs) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInitNames(); +} + +GLint gl1_5_glRenderMode(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glRenderMode(mode); +} + +void gl1_5_glSelectBuffer(void *_glfuncs, GLsizei size, GLuint* buffer) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSelectBuffer(size, buffer); +} + +void gl1_5_glFeedbackBuffer(void *_glfuncs, GLsizei size, GLenum gltype, GLfloat* buffer) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFeedbackBuffer(size, gltype, buffer); +} + +void gl1_5_glTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGeniv(coord, pname, params); +} + +void gl1_5_glTexGeni(void *_glfuncs, GLenum coord, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGeni(coord, pname, param); +} + +void gl1_5_glTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGenfv(coord, pname, params); +} + +void gl1_5_glTexGenf(void *_glfuncs, GLenum coord, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGenf(coord, pname, param); +} + +void gl1_5_glTexGendv(void *_glfuncs, GLenum coord, GLenum pname, const GLdouble* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGendv(coord, pname, params); +} + +void gl1_5_glTexGend(void *_glfuncs, GLenum coord, GLenum pname, GLdouble param) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGend(coord, pname, param); +} + +void gl1_5_glTexEnviv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnviv(target, pname, params); +} + +void gl1_5_glTexEnvi(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvi(target, pname, param); +} + +void gl1_5_glTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvfv(target, pname, params); +} + +void gl1_5_glTexEnvf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvf(target, pname, param); +} + +void gl1_5_glShadeModel(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShadeModel(mode); +} + +void gl1_5_glPolygonStipple(void *_glfuncs, const GLubyte* mask) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonStipple(mask); +} + +void gl1_5_glMaterialiv(void *_glfuncs, GLenum face, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialiv(face, pname, params); +} + +void gl1_5_glMateriali(void *_glfuncs, GLenum face, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMateriali(face, pname, param); +} + +void gl1_5_glMaterialfv(void *_glfuncs, GLenum face, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialfv(face, pname, params); +} + +void gl1_5_glMaterialf(void *_glfuncs, GLenum face, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialf(face, pname, param); +} + +void gl1_5_glLineStipple(void *_glfuncs, GLint factor, GLushort pattern) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineStipple(factor, pattern); +} + +void gl1_5_glLightModeliv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModeliv(pname, params); +} + +void gl1_5_glLightModeli(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModeli(pname, param); +} + +void gl1_5_glLightModelfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModelfv(pname, params); +} + +void gl1_5_glLightModelf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModelf(pname, param); +} + +void gl1_5_glLightiv(void *_glfuncs, GLenum light, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightiv(light, pname, params); +} + +void gl1_5_glLighti(void *_glfuncs, GLenum light, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLighti(light, pname, param); +} + +void gl1_5_glLightfv(void *_glfuncs, GLenum light, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightfv(light, pname, params); +} + +void gl1_5_glLightf(void *_glfuncs, GLenum light, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightf(light, pname, param); +} + +void gl1_5_glFogiv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogiv(pname, params); +} + +void gl1_5_glFogi(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogi(pname, param); +} + +void gl1_5_glFogfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogfv(pname, params); +} + +void gl1_5_glFogf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogf(pname, param); +} + +void gl1_5_glColorMaterial(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMaterial(face, mode); +} + +void gl1_5_glClipPlane(void *_glfuncs, GLenum plane, const GLdouble* equation) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClipPlane(plane, equation); +} + +void gl1_5_glVertex4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4sv(v); +} + +void gl1_5_glVertex4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4s(x, y, z, w); +} + +void gl1_5_glVertex4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4iv(v); +} + +void gl1_5_glVertex4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4i(x, y, z, w); +} + +void gl1_5_glVertex4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4fv(v); +} + +void gl1_5_glVertex4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4f(x, y, z, w); +} + +void gl1_5_glVertex4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4dv(v); +} + +void gl1_5_glVertex4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4d(x, y, z, w); +} + +void gl1_5_glVertex3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3sv(v); +} + +void gl1_5_glVertex3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3s(x, y, z); +} + +void gl1_5_glVertex3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3iv(v); +} + +void gl1_5_glVertex3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3i(x, y, z); +} + +void gl1_5_glVertex3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3fv(v); +} + +void gl1_5_glVertex3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3f(x, y, z); +} + +void gl1_5_glVertex3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3dv(v); +} + +void gl1_5_glVertex3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3d(x, y, z); +} + +void gl1_5_glVertex2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2sv(v); +} + +void gl1_5_glVertex2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2s(x, y); +} + +void gl1_5_glVertex2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2iv(v); +} + +void gl1_5_glVertex2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2i(x, y); +} + +void gl1_5_glVertex2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2fv(v); +} + +void gl1_5_glVertex2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2f(x, y); +} + +void gl1_5_glVertex2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2dv(v); +} + +void gl1_5_glVertex2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2d(x, y); +} + +void gl1_5_glTexCoord4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4sv(v); +} + +void gl1_5_glTexCoord4s(void *_glfuncs, GLshort s, GLshort t, GLshort r, GLshort q) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4s(s, t, r, q); +} + +void gl1_5_glTexCoord4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4iv(v); +} + +void gl1_5_glTexCoord4i(void *_glfuncs, GLint s, GLint t, GLint r, GLint q) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4i(s, t, r, q); +} + +void gl1_5_glTexCoord4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4fv(v); +} + +void gl1_5_glTexCoord4f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4f(s, t, r, q); +} + +void gl1_5_glTexCoord4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4dv(v); +} + +void gl1_5_glTexCoord4d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r, GLdouble q) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4d(s, t, r, q); +} + +void gl1_5_glTexCoord3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3sv(v); +} + +void gl1_5_glTexCoord3s(void *_glfuncs, GLshort s, GLshort t, GLshort r) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3s(s, t, r); +} + +void gl1_5_glTexCoord3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3iv(v); +} + +void gl1_5_glTexCoord3i(void *_glfuncs, GLint s, GLint t, GLint r) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3i(s, t, r); +} + +void gl1_5_glTexCoord3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3fv(v); +} + +void gl1_5_glTexCoord3f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3f(s, t, r); +} + +void gl1_5_glTexCoord3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3dv(v); +} + +void gl1_5_glTexCoord3d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3d(s, t, r); +} + +void gl1_5_glTexCoord2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2sv(v); +} + +void gl1_5_glTexCoord2s(void *_glfuncs, GLshort s, GLshort t) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2s(s, t); +} + +void gl1_5_glTexCoord2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2iv(v); +} + +void gl1_5_glTexCoord2i(void *_glfuncs, GLint s, GLint t) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2i(s, t); +} + +void gl1_5_glTexCoord2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2fv(v); +} + +void gl1_5_glTexCoord2f(void *_glfuncs, GLfloat s, GLfloat t) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2f(s, t); +} + +void gl1_5_glTexCoord2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2dv(v); +} + +void gl1_5_glTexCoord2d(void *_glfuncs, GLdouble s, GLdouble t) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2d(s, t); +} + +void gl1_5_glTexCoord1sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1sv(v); +} + +void gl1_5_glTexCoord1s(void *_glfuncs, GLshort s) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1s(s); +} + +void gl1_5_glTexCoord1iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1iv(v); +} + +void gl1_5_glTexCoord1i(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1i(s); +} + +void gl1_5_glTexCoord1fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1fv(v); +} + +void gl1_5_glTexCoord1f(void *_glfuncs, GLfloat s) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1f(s); +} + +void gl1_5_glTexCoord1dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1dv(v); +} + +void gl1_5_glTexCoord1d(void *_glfuncs, GLdouble s) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1d(s); +} + +void gl1_5_glRectsv(void *_glfuncs, const GLshort* v1, const GLshort* v2) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectsv(v1, v2); +} + +void gl1_5_glRects(void *_glfuncs, GLshort x1, GLshort y1, GLshort x2, GLshort y2) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRects(x1, y1, x2, y2); +} + +void gl1_5_glRectiv(void *_glfuncs, const GLint* v1, const GLint* v2) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectiv(v1, v2); +} + +void gl1_5_glRecti(void *_glfuncs, GLint x1, GLint y1, GLint x2, GLint y2) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRecti(x1, y1, x2, y2); +} + +void gl1_5_glRectfv(void *_glfuncs, const GLfloat* v1, const GLfloat* v2) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectfv(v1, v2); +} + +void gl1_5_glRectf(void *_glfuncs, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectf(x1, y1, x2, y2); +} + +void gl1_5_glRectdv(void *_glfuncs, const GLdouble* v1, const GLdouble* v2) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectdv(v1, v2); +} + +void gl1_5_glRectd(void *_glfuncs, GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectd(x1, y1, x2, y2); +} + +void gl1_5_glRasterPos4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4sv(v); +} + +void gl1_5_glRasterPos4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4s(x, y, z, w); +} + +void gl1_5_glRasterPos4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4iv(v); +} + +void gl1_5_glRasterPos4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4i(x, y, z, w); +} + +void gl1_5_glRasterPos4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4fv(v); +} + +void gl1_5_glRasterPos4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4f(x, y, z, w); +} + +void gl1_5_glRasterPos4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4dv(v); +} + +void gl1_5_glRasterPos4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4d(x, y, z, w); +} + +void gl1_5_glRasterPos3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3sv(v); +} + +void gl1_5_glRasterPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3s(x, y, z); +} + +void gl1_5_glRasterPos3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3iv(v); +} + +void gl1_5_glRasterPos3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3i(x, y, z); +} + +void gl1_5_glRasterPos3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3fv(v); +} + +void gl1_5_glRasterPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3f(x, y, z); +} + +void gl1_5_glRasterPos3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3dv(v); +} + +void gl1_5_glRasterPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3d(x, y, z); +} + +void gl1_5_glRasterPos2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2sv(v); +} + +void gl1_5_glRasterPos2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2s(x, y); +} + +void gl1_5_glRasterPos2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2iv(v); +} + +void gl1_5_glRasterPos2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2i(x, y); +} + +void gl1_5_glRasterPos2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2fv(v); +} + +void gl1_5_glRasterPos2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2f(x, y); +} + +void gl1_5_glRasterPos2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2dv(v); +} + +void gl1_5_glRasterPos2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2d(x, y); +} + +void gl1_5_glNormal3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3sv(v); +} + +void gl1_5_glNormal3s(void *_glfuncs, GLshort nx, GLshort ny, GLshort nz) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3s(nx, ny, nz); +} + +void gl1_5_glNormal3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3iv(v); +} + +void gl1_5_glNormal3i(void *_glfuncs, GLint nx, GLint ny, GLint nz) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3i(nx, ny, nz); +} + +void gl1_5_glNormal3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3fv(v); +} + +void gl1_5_glNormal3f(void *_glfuncs, GLfloat nx, GLfloat ny, GLfloat nz) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3f(nx, ny, nz); +} + +void gl1_5_glNormal3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3dv(v); +} + +void gl1_5_glNormal3d(void *_glfuncs, GLdouble nx, GLdouble ny, GLdouble nz) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3d(nx, ny, nz); +} + +void gl1_5_glNormal3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3bv(v); +} + +void gl1_5_glNormal3b(void *_glfuncs, GLbyte nx, GLbyte ny, GLbyte nz) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3b(nx, ny, nz); +} + +void gl1_5_glIndexsv(void *_glfuncs, const GLshort* c) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexsv(c); +} + +void gl1_5_glIndexs(void *_glfuncs, GLshort c) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexs(c); +} + +void gl1_5_glIndexiv(void *_glfuncs, const GLint* c) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexiv(c); +} + +void gl1_5_glIndexi(void *_glfuncs, GLint c) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexi(c); +} + +void gl1_5_glIndexfv(void *_glfuncs, const GLfloat* c) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexfv(c); +} + +void gl1_5_glIndexf(void *_glfuncs, GLfloat c) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexf(c); +} + +void gl1_5_glIndexdv(void *_glfuncs, const GLdouble* c) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexdv(c); +} + +void gl1_5_glIndexd(void *_glfuncs, GLdouble c) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexd(c); +} + +void gl1_5_glEnd(void *_glfuncs) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnd(); +} + +void gl1_5_glEdgeFlagv(void *_glfuncs, const GLboolean* flag) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlagv(flag); +} + +void gl1_5_glEdgeFlag(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlag(flag); +} + +void gl1_5_glColor4usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4usv(v); +} + +void gl1_5_glColor4us(void *_glfuncs, GLushort red, GLushort green, GLushort blue, GLushort alpha) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4us(red, green, blue, alpha); +} + +void gl1_5_glColor4uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4uiv(v); +} + +void gl1_5_glColor4ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue, GLuint alpha) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ui(red, green, blue, alpha); +} + +void gl1_5_glColor4ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ubv(v); +} + +void gl1_5_glColor4ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ub(red, green, blue, alpha); +} + +void gl1_5_glColor4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4sv(v); +} + +void gl1_5_glColor4s(void *_glfuncs, GLshort red, GLshort green, GLshort blue, GLshort alpha) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4s(red, green, blue, alpha); +} + +void gl1_5_glColor4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4iv(v); +} + +void gl1_5_glColor4i(void *_glfuncs, GLint red, GLint green, GLint blue, GLint alpha) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4i(red, green, blue, alpha); +} + +void gl1_5_glColor4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4fv(v); +} + +void gl1_5_glColor4f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4f(red, green, blue, alpha); +} + +void gl1_5_glColor4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4dv(v); +} + +void gl1_5_glColor4d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4d(red, green, blue, alpha); +} + +void gl1_5_glColor4bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4bv(v); +} + +void gl1_5_glColor4b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4b(red, green, blue, alpha); +} + +void gl1_5_glColor3usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3usv(v); +} + +void gl1_5_glColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3us(red, green, blue); +} + +void gl1_5_glColor3uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3uiv(v); +} + +void gl1_5_glColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ui(red, green, blue); +} + +void gl1_5_glColor3ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ubv(v); +} + +void gl1_5_glColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ub(red, green, blue); +} + +void gl1_5_glColor3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3sv(v); +} + +void gl1_5_glColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3s(red, green, blue); +} + +void gl1_5_glColor3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3iv(v); +} + +void gl1_5_glColor3i(void *_glfuncs, GLint red, GLint green, GLint blue) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3i(red, green, blue); +} + +void gl1_5_glColor3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3fv(v); +} + +void gl1_5_glColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3f(red, green, blue); +} + +void gl1_5_glColor3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3dv(v); +} + +void gl1_5_glColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3d(red, green, blue); +} + +void gl1_5_glColor3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3bv(v); +} + +void gl1_5_glColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3b(red, green, blue); +} + +void gl1_5_glBitmap(void *_glfuncs, GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBitmap(width, height, xorig, yorig, xmove, ymove, bitmap); +} + +void gl1_5_glBegin(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBegin(mode); +} + +void gl1_5_glListBase(void *_glfuncs, GLuint base) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glListBase(base); +} + +GLuint gl1_5_glGenLists(void *_glfuncs, GLsizei range_) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGenLists(range_); +} + +void gl1_5_glDeleteLists(void *_glfuncs, GLuint list, GLsizei range_) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteLists(list, range_); +} + +void gl1_5_glCallLists(void *_glfuncs, GLsizei n, GLenum gltype, const GLvoid* lists) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCallLists(n, gltype, lists); +} + +void gl1_5_glCallList(void *_glfuncs, GLuint list) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCallList(list); +} + +void gl1_5_glEndList(void *_glfuncs) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndList(); +} + +void gl1_5_glNewList(void *_glfuncs, GLuint list, GLenum mode) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNewList(list, mode); +} + +void gl1_5_glPushClientAttrib(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushClientAttrib(mask); +} + +void gl1_5_glPopClientAttrib(void *_glfuncs) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopClientAttrib(); +} + +void gl1_5_glPrioritizeTextures(void *_glfuncs, GLsizei n, const GLuint* textures, const GLfloat* priorities) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPrioritizeTextures(n, textures, priorities); +} + +GLboolean gl1_5_glAreTexturesResident(void *_glfuncs, GLsizei n, const GLuint* textures, GLboolean* residences) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glAreTexturesResident(n, textures, residences); +} + +void gl1_5_glVertexPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexPointer(size, gltype, stride, pointer); +} + +void gl1_5_glTexCoordPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordPointer(size, gltype, stride, pointer); +} + +void gl1_5_glNormalPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormalPointer(gltype, stride, pointer); +} + +void gl1_5_glInterleavedArrays(void *_glfuncs, GLenum format, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInterleavedArrays(format, stride, pointer); +} + +void gl1_5_glIndexPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexPointer(gltype, stride, pointer); +} + +void gl1_5_glEnableClientState(void *_glfuncs, GLenum array) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnableClientState(array); +} + +void gl1_5_glEdgeFlagPointer(void *_glfuncs, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlagPointer(stride, pointer); +} + +void gl1_5_glDisableClientState(void *_glfuncs, GLenum array) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisableClientState(array); +} + +void gl1_5_glColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorPointer(size, gltype, stride, pointer); +} + +void gl1_5_glArrayElement(void *_glfuncs, GLint i) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glArrayElement(i); +} + +void gl1_5_glResetMinmax(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glResetMinmax(target); +} + +void gl1_5_glResetHistogram(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glResetHistogram(target); +} + +void gl1_5_glMinmax(void *_glfuncs, GLenum target, GLenum internalFormat, GLboolean sink) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMinmax(target, internalFormat, sink); +} + +void gl1_5_glHistogram(void *_glfuncs, GLenum target, GLsizei width, GLenum internalFormat, GLboolean sink) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glHistogram(target, width, internalFormat, sink); +} + +void gl1_5_glGetMinmaxParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmaxParameteriv(target, pname, params); +} + +void gl1_5_glGetMinmaxParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmaxParameterfv(target, pname, params); +} + +void gl1_5_glGetMinmax(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmax(target, reset, format, gltype, values); +} + +void gl1_5_glGetHistogramParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogramParameteriv(target, pname, params); +} + +void gl1_5_glGetHistogramParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogramParameterfv(target, pname, params); +} + +void gl1_5_glGetHistogram(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogram(target, reset, format, gltype, values); +} + +void gl1_5_glSeparableFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* row, const GLvoid* column) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSeparableFilter2D(target, internalFormat, width, height, format, gltype, row, column); +} + +void gl1_5_glGetSeparableFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* row, GLvoid* column, GLvoid* span) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSeparableFilter(target, format, gltype, row, column, span); +} + +void gl1_5_glGetConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionParameteriv(target, pname, params); +} + +void gl1_5_glGetConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionParameterfv(target, pname, params); +} + +void gl1_5_glGetConvolutionFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* image) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionFilter(target, format, gltype, image); +} + +void gl1_5_glCopyConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyConvolutionFilter2D(target, internalFormat, x, y, width, height); +} + +void gl1_5_glCopyConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyConvolutionFilter1D(target, internalFormat, x, y, width); +} + +void gl1_5_glConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameteriv(target, pname, params); +} + +void gl1_5_glConvolutionParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameteri(target, pname, params); +} + +void gl1_5_glConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameterfv(target, pname, params); +} + +void gl1_5_glConvolutionParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameterf(target, pname, params); +} + +void gl1_5_glConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* image) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionFilter2D(target, internalFormat, width, height, format, gltype, image); +} + +void gl1_5_glConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* image) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionFilter1D(target, internalFormat, width, format, gltype, image); +} + +void gl1_5_glCopyColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyColorSubTable(target, start, x, y, width); +} + +void gl1_5_glColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum gltype, const GLvoid* data) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorSubTable(target, start, count, format, gltype, data); +} + +void gl1_5_glGetColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTableParameteriv(target, pname, params); +} + +void gl1_5_glGetColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTableParameterfv(target, pname, params); +} + +void gl1_5_glGetColorTable(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* table) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTable(target, format, gltype, table); +} + +void gl1_5_glCopyColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyColorTable(target, internalFormat, x, y, width); +} + +void gl1_5_glColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTableParameteriv(target, pname, params); +} + +void gl1_5_glColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTableParameterfv(target, pname, params); +} + +void gl1_5_glColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* table) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTable(target, internalFormat, width, format, gltype, table); +} + +void gl1_5_glMultTransposeMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultTransposeMatrixd(m); +} + +void gl1_5_glMultTransposeMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultTransposeMatrixf(m); +} + +void gl1_5_glLoadTransposeMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadTransposeMatrixd(m); +} + +void gl1_5_glLoadTransposeMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadTransposeMatrixf(m); +} + +void gl1_5_glMultiTexCoord4sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4sv(target, v); +} + +void gl1_5_glMultiTexCoord4s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r, GLshort q) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4s(target, s, t, r, q); +} + +void gl1_5_glMultiTexCoord4iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4iv(target, v); +} + +void gl1_5_glMultiTexCoord4i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r, GLint q) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4i(target, s, t, r, q); +} + +void gl1_5_glMultiTexCoord4fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4fv(target, v); +} + +void gl1_5_glMultiTexCoord4f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4f(target, s, t, r, q); +} + +void gl1_5_glMultiTexCoord4dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4dv(target, v); +} + +void gl1_5_glMultiTexCoord4d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4d(target, s, t, r, q); +} + +void gl1_5_glMultiTexCoord3sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3sv(target, v); +} + +void gl1_5_glMultiTexCoord3s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3s(target, s, t, r); +} + +void gl1_5_glMultiTexCoord3iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3iv(target, v); +} + +void gl1_5_glMultiTexCoord3i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3i(target, s, t, r); +} + +void gl1_5_glMultiTexCoord3fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3fv(target, v); +} + +void gl1_5_glMultiTexCoord3f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3f(target, s, t, r); +} + +void gl1_5_glMultiTexCoord3dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3dv(target, v); +} + +void gl1_5_glMultiTexCoord3d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3d(target, s, t, r); +} + +void gl1_5_glMultiTexCoord2sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2sv(target, v); +} + +void gl1_5_glMultiTexCoord2s(void *_glfuncs, GLenum target, GLshort s, GLshort t) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2s(target, s, t); +} + +void gl1_5_glMultiTexCoord2iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2iv(target, v); +} + +void gl1_5_glMultiTexCoord2i(void *_glfuncs, GLenum target, GLint s, GLint t) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2i(target, s, t); +} + +void gl1_5_glMultiTexCoord2fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2fv(target, v); +} + +void gl1_5_glMultiTexCoord2f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2f(target, s, t); +} + +void gl1_5_glMultiTexCoord2dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2dv(target, v); +} + +void gl1_5_glMultiTexCoord2d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2d(target, s, t); +} + +void gl1_5_glMultiTexCoord1sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1sv(target, v); +} + +void gl1_5_glMultiTexCoord1s(void *_glfuncs, GLenum target, GLshort s) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1s(target, s); +} + +void gl1_5_glMultiTexCoord1iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1iv(target, v); +} + +void gl1_5_glMultiTexCoord1i(void *_glfuncs, GLenum target, GLint s) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1i(target, s); +} + +void gl1_5_glMultiTexCoord1fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1fv(target, v); +} + +void gl1_5_glMultiTexCoord1f(void *_glfuncs, GLenum target, GLfloat s) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1f(target, s); +} + +void gl1_5_glMultiTexCoord1dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1dv(target, v); +} + +void gl1_5_glMultiTexCoord1d(void *_glfuncs, GLenum target, GLdouble s) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1d(target, s); +} + +void gl1_5_glClientActiveTexture(void *_glfuncs, GLenum texture) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClientActiveTexture(texture); +} + +void gl1_5_glWindowPos3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3sv(v); +} + +void gl1_5_glWindowPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3s(x, y, z); +} + +void gl1_5_glWindowPos3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3iv(v); +} + +void gl1_5_glWindowPos3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3i(x, y, z); +} + +void gl1_5_glWindowPos3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3fv(v); +} + +void gl1_5_glWindowPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3f(x, y, z); +} + +void gl1_5_glWindowPos3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3dv(v); +} + +void gl1_5_glWindowPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3d(x, y, z); +} + +void gl1_5_glWindowPos2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2sv(v); +} + +void gl1_5_glWindowPos2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2s(x, y); +} + +void gl1_5_glWindowPos2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2iv(v); +} + +void gl1_5_glWindowPos2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2i(x, y); +} + +void gl1_5_glWindowPos2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2fv(v); +} + +void gl1_5_glWindowPos2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2f(x, y); +} + +void gl1_5_glWindowPos2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2dv(v); +} + +void gl1_5_glWindowPos2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2d(x, y); +} + +void gl1_5_glSecondaryColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColorPointer(size, gltype, stride, pointer); +} + +void gl1_5_glSecondaryColor3usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3usv(v); +} + +void gl1_5_glSecondaryColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3us(red, green, blue); +} + +void gl1_5_glSecondaryColor3uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3uiv(v); +} + +void gl1_5_glSecondaryColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3ui(red, green, blue); +} + +void gl1_5_glSecondaryColor3ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3ubv(v); +} + +void gl1_5_glSecondaryColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3ub(red, green, blue); +} + +void gl1_5_glSecondaryColor3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3sv(v); +} + +void gl1_5_glSecondaryColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3s(red, green, blue); +} + +void gl1_5_glSecondaryColor3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3iv(v); +} + +void gl1_5_glSecondaryColor3i(void *_glfuncs, GLint red, GLint green, GLint blue) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3i(red, green, blue); +} + +void gl1_5_glSecondaryColor3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3fv(v); +} + +void gl1_5_glSecondaryColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3f(red, green, blue); +} + +void gl1_5_glSecondaryColor3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3dv(v); +} + +void gl1_5_glSecondaryColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3d(red, green, blue); +} + +void gl1_5_glSecondaryColor3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3bv(v); +} + +void gl1_5_glSecondaryColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3b(red, green, blue); +} + +void gl1_5_glFogCoordPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordPointer(gltype, stride, pointer); +} + +void gl1_5_glFogCoorddv(void *_glfuncs, const GLdouble* coord) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoorddv(coord); +} + +void gl1_5_glFogCoordd(void *_glfuncs, GLdouble coord) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordd(coord); +} + +void gl1_5_glFogCoordfv(void *_glfuncs, const GLfloat* coord) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordfv(coord); +} + +void gl1_5_glFogCoordf(void *_glfuncs, GLfloat coord) +{ + QOpenGLFunctions_1_5* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordf(coord); +} + diff --git a/gl/1.5/funcs.h b/gl/1.5/funcs.h new file mode 100644 index 00000000..d971f2dc --- /dev/null +++ b/gl/1.5/funcs.h @@ -0,0 +1,521 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#ifndef __cplusplus +#include +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef char GLchar; +typedef signed char GLbyte; /* 1-byte signed */ +typedef short GLshort; /* 2-byte signed */ +typedef int GLint; /* 4-byte signed */ +typedef unsigned char GLubyte; /* 1-byte unsigned */ +typedef unsigned short GLushort; /* 2-byte unsigned */ +typedef unsigned int GLuint; /* 4-byte unsigned */ +typedef int GLsizei; /* 4-byte signed */ +typedef float GLfloat; /* single precision float */ +typedef float GLclampf; /* single precision float in [0,1] */ +typedef double GLdouble; /* double precision float */ +typedef double GLclampd; /* double precision float in [0,1] */ +typedef int64_t GLint64; +typedef uint64_t GLuint64; +typedef ptrdiff_t GLintptr; +typedef ptrdiff_t GLsizeiptr; +typedef ptrdiff_t GLintptrARB; +typedef ptrdiff_t GLsizeiptrARB; +typedef struct __GLsync *GLsync; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +void *gl1_5_funcs(); + +void gl1_5_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl1_5_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal); +GLboolean gl1_5_glIsEnabled(void *_glfuncs, GLenum cap); +void gl1_5_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params); +void gl1_5_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params); +void gl1_5_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl1_5_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl1_5_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels); +void gl1_5_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params); +void gl1_5_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params); +GLenum gl1_5_glGetError(void *_glfuncs); +void gl1_5_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params); +void gl1_5_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params); +void gl1_5_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels); +void gl1_5_glReadBuffer(void *_glfuncs, GLenum mode); +void gl1_5_glPixelStorei(void *_glfuncs, GLenum pname, GLint param); +void gl1_5_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param); +void gl1_5_glDepthFunc(void *_glfuncs, GLenum glfunc); +void gl1_5_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass); +void gl1_5_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask); +void gl1_5_glLogicOp(void *_glfuncs, GLenum opcode); +void gl1_5_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor); +void gl1_5_glFlush(void *_glfuncs); +void gl1_5_glFinish(void *_glfuncs); +void gl1_5_glEnable(void *_glfuncs, GLenum cap); +void gl1_5_glDisable(void *_glfuncs, GLenum cap); +void gl1_5_glDepthMask(void *_glfuncs, GLboolean flag); +void gl1_5_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +void gl1_5_glStencilMask(void *_glfuncs, GLuint mask); +void gl1_5_glClearDepth(void *_glfuncs, GLdouble depth); +void gl1_5_glClearStencil(void *_glfuncs, GLint s); +void gl1_5_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl1_5_glClear(void *_glfuncs, GLbitfield mask); +void gl1_5_glDrawBuffer(void *_glfuncs, GLenum mode); +void gl1_5_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_5_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_5_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl1_5_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl1_5_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl1_5_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl1_5_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl1_5_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode); +void gl1_5_glPointSize(void *_glfuncs, GLfloat size); +void gl1_5_glLineWidth(void *_glfuncs, GLfloat width); +void gl1_5_glHint(void *_glfuncs, GLenum target, GLenum mode); +void gl1_5_glFrontFace(void *_glfuncs, GLenum mode); +void gl1_5_glCullFace(void *_glfuncs, GLenum mode); +void gl1_5_glIndexubv(void *_glfuncs, const GLubyte* c); +void gl1_5_glIndexub(void *_glfuncs, GLubyte c); +GLboolean gl1_5_glIsTexture(void *_glfuncs, GLuint texture); +void gl1_5_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures); +void gl1_5_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures); +void gl1_5_glBindTexture(void *_glfuncs, GLenum target, GLuint texture); +void gl1_5_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_5_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_5_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl1_5_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +void gl1_5_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +void gl1_5_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border); +void gl1_5_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units); +void gl1_5_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl1_5_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count); +void gl1_5_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl1_5_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_5_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_5_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl1_5_glBlendEquation(void *_glfuncs, GLenum mode); +void gl1_5_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl1_5_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img); +void gl1_5_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl1_5_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl1_5_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl1_5_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data); +void gl1_5_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data); +void gl1_5_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data); +void gl1_5_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert); +void gl1_5_glActiveTexture(void *_glfuncs, GLenum texture); +void gl1_5_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params); +void gl1_5_glPointParameteri(void *_glfuncs, GLenum pname, GLint param); +void gl1_5_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl1_5_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param); +void gl1_5_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount); +void gl1_5_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +void gl1_5_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +GLboolean gl1_5_glUnmapBuffer(void *_glfuncs, GLenum target); +void gl1_5_glGetBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data); +void gl1_5_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data); +void gl1_5_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage); +GLboolean gl1_5_glIsBuffer(void *_glfuncs, GLuint buffer); +void gl1_5_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers); +void gl1_5_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers); +void gl1_5_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer); +void gl1_5_glGetQueryObjectuiv(void *_glfuncs, GLuint id, GLenum pname, GLuint* params); +void gl1_5_glGetQueryObjectiv(void *_glfuncs, GLuint id, GLenum pname, GLint* params); +void gl1_5_glGetQueryiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl1_5_glEndQuery(void *_glfuncs, GLenum target); +void gl1_5_glBeginQuery(void *_glfuncs, GLenum target, GLuint id); +GLboolean gl1_5_glIsQuery(void *_glfuncs, GLuint id); +void gl1_5_glDeleteQueries(void *_glfuncs, GLsizei n, const GLuint* ids); +void gl1_5_glGenQueries(void *_glfuncs, GLsizei n, GLuint* ids); +void gl1_5_glTranslatef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl1_5_glTranslated(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl1_5_glScalef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl1_5_glScaled(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl1_5_glRotatef(void *_glfuncs, GLfloat angle, GLfloat x, GLfloat y, GLfloat z); +void gl1_5_glRotated(void *_glfuncs, GLdouble angle, GLdouble x, GLdouble y, GLdouble z); +void gl1_5_glPushMatrix(void *_glfuncs); +void gl1_5_glPopMatrix(void *_glfuncs); +void gl1_5_glOrtho(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +void gl1_5_glMultMatrixd(void *_glfuncs, const GLdouble* m); +void gl1_5_glMultMatrixf(void *_glfuncs, const GLfloat* m); +void gl1_5_glMatrixMode(void *_glfuncs, GLenum mode); +void gl1_5_glLoadMatrixd(void *_glfuncs, const GLdouble* m); +void gl1_5_glLoadMatrixf(void *_glfuncs, const GLfloat* m); +void gl1_5_glLoadIdentity(void *_glfuncs); +void gl1_5_glFrustum(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +GLboolean gl1_5_glIsList(void *_glfuncs, GLuint list); +void gl1_5_glGetTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, GLint* params); +void gl1_5_glGetTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, GLfloat* params); +void gl1_5_glGetTexGendv(void *_glfuncs, GLenum coord, GLenum pname, GLdouble* params); +void gl1_5_glGetTexEnviv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl1_5_glGetTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl1_5_glGetPolygonStipple(void *_glfuncs, GLubyte* mask); +void gl1_5_glGetPixelMapusv(void *_glfuncs, GLenum glmap, GLushort* values); +void gl1_5_glGetPixelMapuiv(void *_glfuncs, GLenum glmap, GLuint* values); +void gl1_5_glGetPixelMapfv(void *_glfuncs, GLenum glmap, GLfloat* values); +void gl1_5_glGetMaterialiv(void *_glfuncs, GLenum face, GLenum pname, GLint* params); +void gl1_5_glGetMaterialfv(void *_glfuncs, GLenum face, GLenum pname, GLfloat* params); +void gl1_5_glGetMapiv(void *_glfuncs, GLenum target, GLenum query, GLint* v); +void gl1_5_glGetMapfv(void *_glfuncs, GLenum target, GLenum query, GLfloat* v); +void gl1_5_glGetMapdv(void *_glfuncs, GLenum target, GLenum query, GLdouble* v); +void gl1_5_glGetLightiv(void *_glfuncs, GLenum light, GLenum pname, GLint* params); +void gl1_5_glGetLightfv(void *_glfuncs, GLenum light, GLenum pname, GLfloat* params); +void gl1_5_glGetClipPlane(void *_glfuncs, GLenum plane, GLdouble* equation); +void gl1_5_glDrawPixels(void *_glfuncs, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl1_5_glCopyPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum gltype); +void gl1_5_glPixelMapusv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLushort* values); +void gl1_5_glPixelMapuiv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLuint* values); +void gl1_5_glPixelMapfv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLfloat* values); +void gl1_5_glPixelTransferi(void *_glfuncs, GLenum pname, GLint param); +void gl1_5_glPixelTransferf(void *_glfuncs, GLenum pname, GLfloat param); +void gl1_5_glPixelZoom(void *_glfuncs, GLfloat xfactor, GLfloat yfactor); +void gl1_5_glAlphaFunc(void *_glfuncs, GLenum glfunc, GLfloat ref); +void gl1_5_glEvalPoint2(void *_glfuncs, GLint i, GLint j); +void gl1_5_glEvalMesh2(void *_glfuncs, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); +void gl1_5_glEvalPoint1(void *_glfuncs, GLint i); +void gl1_5_glEvalMesh1(void *_glfuncs, GLenum mode, GLint i1, GLint i2); +void gl1_5_glEvalCoord2fv(void *_glfuncs, const GLfloat* u); +void gl1_5_glEvalCoord2f(void *_glfuncs, GLfloat u, GLfloat v); +void gl1_5_glEvalCoord2dv(void *_glfuncs, const GLdouble* u); +void gl1_5_glEvalCoord2d(void *_glfuncs, GLdouble u, GLdouble v); +void gl1_5_glEvalCoord1fv(void *_glfuncs, const GLfloat* u); +void gl1_5_glEvalCoord1f(void *_glfuncs, GLfloat u); +void gl1_5_glEvalCoord1dv(void *_glfuncs, const GLdouble* u); +void gl1_5_glEvalCoord1d(void *_glfuncs, GLdouble u); +void gl1_5_glMapGrid2f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); +void gl1_5_glMapGrid2d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); +void gl1_5_glMapGrid1f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2); +void gl1_5_glMapGrid1d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2); +void gl1_5_glMap2f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points); +void gl1_5_glMap2d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points); +void gl1_5_glMap1f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points); +void gl1_5_glMap1d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points); +void gl1_5_glPushAttrib(void *_glfuncs, GLbitfield mask); +void gl1_5_glPopAttrib(void *_glfuncs); +void gl1_5_glAccum(void *_glfuncs, GLenum op, GLfloat value); +void gl1_5_glIndexMask(void *_glfuncs, GLuint mask); +void gl1_5_glClearIndex(void *_glfuncs, GLfloat c); +void gl1_5_glClearAccum(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl1_5_glPushName(void *_glfuncs, GLuint name); +void gl1_5_glPopName(void *_glfuncs); +void gl1_5_glPassThrough(void *_glfuncs, GLfloat token); +void gl1_5_glLoadName(void *_glfuncs, GLuint name); +void gl1_5_glInitNames(void *_glfuncs); +GLint gl1_5_glRenderMode(void *_glfuncs, GLenum mode); +void gl1_5_glSelectBuffer(void *_glfuncs, GLsizei size, GLuint* buffer); +void gl1_5_glFeedbackBuffer(void *_glfuncs, GLsizei size, GLenum gltype, GLfloat* buffer); +void gl1_5_glTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, const GLint* params); +void gl1_5_glTexGeni(void *_glfuncs, GLenum coord, GLenum pname, GLint param); +void gl1_5_glTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, const GLfloat* params); +void gl1_5_glTexGenf(void *_glfuncs, GLenum coord, GLenum pname, GLfloat param); +void gl1_5_glTexGendv(void *_glfuncs, GLenum coord, GLenum pname, const GLdouble* params); +void gl1_5_glTexGend(void *_glfuncs, GLenum coord, GLenum pname, GLdouble param); +void gl1_5_glTexEnviv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl1_5_glTexEnvi(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl1_5_glTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl1_5_glTexEnvf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl1_5_glShadeModel(void *_glfuncs, GLenum mode); +void gl1_5_glPolygonStipple(void *_glfuncs, const GLubyte* mask); +void gl1_5_glMaterialiv(void *_glfuncs, GLenum face, GLenum pname, const GLint* params); +void gl1_5_glMateriali(void *_glfuncs, GLenum face, GLenum pname, GLint param); +void gl1_5_glMaterialfv(void *_glfuncs, GLenum face, GLenum pname, const GLfloat* params); +void gl1_5_glMaterialf(void *_glfuncs, GLenum face, GLenum pname, GLfloat param); +void gl1_5_glLineStipple(void *_glfuncs, GLint factor, GLushort pattern); +void gl1_5_glLightModeliv(void *_glfuncs, GLenum pname, const GLint* params); +void gl1_5_glLightModeli(void *_glfuncs, GLenum pname, GLint param); +void gl1_5_glLightModelfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl1_5_glLightModelf(void *_glfuncs, GLenum pname, GLfloat param); +void gl1_5_glLightiv(void *_glfuncs, GLenum light, GLenum pname, const GLint* params); +void gl1_5_glLighti(void *_glfuncs, GLenum light, GLenum pname, GLint param); +void gl1_5_glLightfv(void *_glfuncs, GLenum light, GLenum pname, const GLfloat* params); +void gl1_5_glLightf(void *_glfuncs, GLenum light, GLenum pname, GLfloat param); +void gl1_5_glFogiv(void *_glfuncs, GLenum pname, const GLint* params); +void gl1_5_glFogi(void *_glfuncs, GLenum pname, GLint param); +void gl1_5_glFogfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl1_5_glFogf(void *_glfuncs, GLenum pname, GLfloat param); +void gl1_5_glColorMaterial(void *_glfuncs, GLenum face, GLenum mode); +void gl1_5_glClipPlane(void *_glfuncs, GLenum plane, const GLdouble* equation); +void gl1_5_glVertex4sv(void *_glfuncs, const GLshort* v); +void gl1_5_glVertex4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w); +void gl1_5_glVertex4iv(void *_glfuncs, const GLint* v); +void gl1_5_glVertex4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w); +void gl1_5_glVertex4fv(void *_glfuncs, const GLfloat* v); +void gl1_5_glVertex4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl1_5_glVertex4dv(void *_glfuncs, const GLdouble* v); +void gl1_5_glVertex4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl1_5_glVertex3sv(void *_glfuncs, const GLshort* v); +void gl1_5_glVertex3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl1_5_glVertex3iv(void *_glfuncs, const GLint* v); +void gl1_5_glVertex3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl1_5_glVertex3fv(void *_glfuncs, const GLfloat* v); +void gl1_5_glVertex3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl1_5_glVertex3dv(void *_glfuncs, const GLdouble* v); +void gl1_5_glVertex3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl1_5_glVertex2sv(void *_glfuncs, const GLshort* v); +void gl1_5_glVertex2s(void *_glfuncs, GLshort x, GLshort y); +void gl1_5_glVertex2iv(void *_glfuncs, const GLint* v); +void gl1_5_glVertex2i(void *_glfuncs, GLint x, GLint y); +void gl1_5_glVertex2fv(void *_glfuncs, const GLfloat* v); +void gl1_5_glVertex2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl1_5_glVertex2dv(void *_glfuncs, const GLdouble* v); +void gl1_5_glVertex2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl1_5_glTexCoord4sv(void *_glfuncs, const GLshort* v); +void gl1_5_glTexCoord4s(void *_glfuncs, GLshort s, GLshort t, GLshort r, GLshort q); +void gl1_5_glTexCoord4iv(void *_glfuncs, const GLint* v); +void gl1_5_glTexCoord4i(void *_glfuncs, GLint s, GLint t, GLint r, GLint q); +void gl1_5_glTexCoord4fv(void *_glfuncs, const GLfloat* v); +void gl1_5_glTexCoord4f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +void gl1_5_glTexCoord4dv(void *_glfuncs, const GLdouble* v); +void gl1_5_glTexCoord4d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +void gl1_5_glTexCoord3sv(void *_glfuncs, const GLshort* v); +void gl1_5_glTexCoord3s(void *_glfuncs, GLshort s, GLshort t, GLshort r); +void gl1_5_glTexCoord3iv(void *_glfuncs, const GLint* v); +void gl1_5_glTexCoord3i(void *_glfuncs, GLint s, GLint t, GLint r); +void gl1_5_glTexCoord3fv(void *_glfuncs, const GLfloat* v); +void gl1_5_glTexCoord3f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r); +void gl1_5_glTexCoord3dv(void *_glfuncs, const GLdouble* v); +void gl1_5_glTexCoord3d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r); +void gl1_5_glTexCoord2sv(void *_glfuncs, const GLshort* v); +void gl1_5_glTexCoord2s(void *_glfuncs, GLshort s, GLshort t); +void gl1_5_glTexCoord2iv(void *_glfuncs, const GLint* v); +void gl1_5_glTexCoord2i(void *_glfuncs, GLint s, GLint t); +void gl1_5_glTexCoord2fv(void *_glfuncs, const GLfloat* v); +void gl1_5_glTexCoord2f(void *_glfuncs, GLfloat s, GLfloat t); +void gl1_5_glTexCoord2dv(void *_glfuncs, const GLdouble* v); +void gl1_5_glTexCoord2d(void *_glfuncs, GLdouble s, GLdouble t); +void gl1_5_glTexCoord1sv(void *_glfuncs, const GLshort* v); +void gl1_5_glTexCoord1s(void *_glfuncs, GLshort s); +void gl1_5_glTexCoord1iv(void *_glfuncs, const GLint* v); +void gl1_5_glTexCoord1i(void *_glfuncs, GLint s); +void gl1_5_glTexCoord1fv(void *_glfuncs, const GLfloat* v); +void gl1_5_glTexCoord1f(void *_glfuncs, GLfloat s); +void gl1_5_glTexCoord1dv(void *_glfuncs, const GLdouble* v); +void gl1_5_glTexCoord1d(void *_glfuncs, GLdouble s); +void gl1_5_glRectsv(void *_glfuncs, const GLshort* v1, const GLshort* v2); +void gl1_5_glRects(void *_glfuncs, GLshort x1, GLshort y1, GLshort x2, GLshort y2); +void gl1_5_glRectiv(void *_glfuncs, const GLint* v1, const GLint* v2); +void gl1_5_glRecti(void *_glfuncs, GLint x1, GLint y1, GLint x2, GLint y2); +void gl1_5_glRectfv(void *_glfuncs, const GLfloat* v1, const GLfloat* v2); +void gl1_5_glRectf(void *_glfuncs, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); +void gl1_5_glRectdv(void *_glfuncs, const GLdouble* v1, const GLdouble* v2); +void gl1_5_glRectd(void *_glfuncs, GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); +void gl1_5_glRasterPos4sv(void *_glfuncs, const GLshort* v); +void gl1_5_glRasterPos4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w); +void gl1_5_glRasterPos4iv(void *_glfuncs, const GLint* v); +void gl1_5_glRasterPos4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w); +void gl1_5_glRasterPos4fv(void *_glfuncs, const GLfloat* v); +void gl1_5_glRasterPos4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl1_5_glRasterPos4dv(void *_glfuncs, const GLdouble* v); +void gl1_5_glRasterPos4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl1_5_glRasterPos3sv(void *_glfuncs, const GLshort* v); +void gl1_5_glRasterPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl1_5_glRasterPos3iv(void *_glfuncs, const GLint* v); +void gl1_5_glRasterPos3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl1_5_glRasterPos3fv(void *_glfuncs, const GLfloat* v); +void gl1_5_glRasterPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl1_5_glRasterPos3dv(void *_glfuncs, const GLdouble* v); +void gl1_5_glRasterPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl1_5_glRasterPos2sv(void *_glfuncs, const GLshort* v); +void gl1_5_glRasterPos2s(void *_glfuncs, GLshort x, GLshort y); +void gl1_5_glRasterPos2iv(void *_glfuncs, const GLint* v); +void gl1_5_glRasterPos2i(void *_glfuncs, GLint x, GLint y); +void gl1_5_glRasterPos2fv(void *_glfuncs, const GLfloat* v); +void gl1_5_glRasterPos2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl1_5_glRasterPos2dv(void *_glfuncs, const GLdouble* v); +void gl1_5_glRasterPos2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl1_5_glNormal3sv(void *_glfuncs, const GLshort* v); +void gl1_5_glNormal3s(void *_glfuncs, GLshort nx, GLshort ny, GLshort nz); +void gl1_5_glNormal3iv(void *_glfuncs, const GLint* v); +void gl1_5_glNormal3i(void *_glfuncs, GLint nx, GLint ny, GLint nz); +void gl1_5_glNormal3fv(void *_glfuncs, const GLfloat* v); +void gl1_5_glNormal3f(void *_glfuncs, GLfloat nx, GLfloat ny, GLfloat nz); +void gl1_5_glNormal3dv(void *_glfuncs, const GLdouble* v); +void gl1_5_glNormal3d(void *_glfuncs, GLdouble nx, GLdouble ny, GLdouble nz); +void gl1_5_glNormal3bv(void *_glfuncs, const GLbyte* v); +void gl1_5_glNormal3b(void *_glfuncs, GLbyte nx, GLbyte ny, GLbyte nz); +void gl1_5_glIndexsv(void *_glfuncs, const GLshort* c); +void gl1_5_glIndexs(void *_glfuncs, GLshort c); +void gl1_5_glIndexiv(void *_glfuncs, const GLint* c); +void gl1_5_glIndexi(void *_glfuncs, GLint c); +void gl1_5_glIndexfv(void *_glfuncs, const GLfloat* c); +void gl1_5_glIndexf(void *_glfuncs, GLfloat c); +void gl1_5_glIndexdv(void *_glfuncs, const GLdouble* c); +void gl1_5_glIndexd(void *_glfuncs, GLdouble c); +void gl1_5_glEnd(void *_glfuncs); +void gl1_5_glEdgeFlagv(void *_glfuncs, const GLboolean* flag); +void gl1_5_glEdgeFlag(void *_glfuncs, GLboolean flag); +void gl1_5_glColor4usv(void *_glfuncs, const GLushort* v); +void gl1_5_glColor4us(void *_glfuncs, GLushort red, GLushort green, GLushort blue, GLushort alpha); +void gl1_5_glColor4uiv(void *_glfuncs, const GLuint* v); +void gl1_5_glColor4ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue, GLuint alpha); +void gl1_5_glColor4ubv(void *_glfuncs, const GLubyte* v); +void gl1_5_glColor4ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); +void gl1_5_glColor4sv(void *_glfuncs, const GLshort* v); +void gl1_5_glColor4s(void *_glfuncs, GLshort red, GLshort green, GLshort blue, GLshort alpha); +void gl1_5_glColor4iv(void *_glfuncs, const GLint* v); +void gl1_5_glColor4i(void *_glfuncs, GLint red, GLint green, GLint blue, GLint alpha); +void gl1_5_glColor4fv(void *_glfuncs, const GLfloat* v); +void gl1_5_glColor4f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl1_5_glColor4dv(void *_glfuncs, const GLdouble* v); +void gl1_5_glColor4d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); +void gl1_5_glColor4bv(void *_glfuncs, const GLbyte* v); +void gl1_5_glColor4b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); +void gl1_5_glColor3usv(void *_glfuncs, const GLushort* v); +void gl1_5_glColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue); +void gl1_5_glColor3uiv(void *_glfuncs, const GLuint* v); +void gl1_5_glColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue); +void gl1_5_glColor3ubv(void *_glfuncs, const GLubyte* v); +void gl1_5_glColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue); +void gl1_5_glColor3sv(void *_glfuncs, const GLshort* v); +void gl1_5_glColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue); +void gl1_5_glColor3iv(void *_glfuncs, const GLint* v); +void gl1_5_glColor3i(void *_glfuncs, GLint red, GLint green, GLint blue); +void gl1_5_glColor3fv(void *_glfuncs, const GLfloat* v); +void gl1_5_glColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue); +void gl1_5_glColor3dv(void *_glfuncs, const GLdouble* v); +void gl1_5_glColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue); +void gl1_5_glColor3bv(void *_glfuncs, const GLbyte* v); +void gl1_5_glColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue); +void gl1_5_glBitmap(void *_glfuncs, GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap); +void gl1_5_glBegin(void *_glfuncs, GLenum mode); +void gl1_5_glListBase(void *_glfuncs, GLuint base); +GLuint gl1_5_glGenLists(void *_glfuncs, GLsizei range_); +void gl1_5_glDeleteLists(void *_glfuncs, GLuint list, GLsizei range_); +void gl1_5_glCallLists(void *_glfuncs, GLsizei n, GLenum gltype, const GLvoid* lists); +void gl1_5_glCallList(void *_glfuncs, GLuint list); +void gl1_5_glEndList(void *_glfuncs); +void gl1_5_glNewList(void *_glfuncs, GLuint list, GLenum mode); +void gl1_5_glPushClientAttrib(void *_glfuncs, GLbitfield mask); +void gl1_5_glPopClientAttrib(void *_glfuncs); +void gl1_5_glPrioritizeTextures(void *_glfuncs, GLsizei n, const GLuint* textures, const GLfloat* priorities); +GLboolean gl1_5_glAreTexturesResident(void *_glfuncs, GLsizei n, const GLuint* textures, GLboolean* residences); +void gl1_5_glVertexPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl1_5_glTexCoordPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl1_5_glNormalPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl1_5_glInterleavedArrays(void *_glfuncs, GLenum format, GLsizei stride, const GLvoid* pointer); +void gl1_5_glIndexPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl1_5_glEnableClientState(void *_glfuncs, GLenum array); +void gl1_5_glEdgeFlagPointer(void *_glfuncs, GLsizei stride, const GLvoid* pointer); +void gl1_5_glDisableClientState(void *_glfuncs, GLenum array); +void gl1_5_glColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl1_5_glArrayElement(void *_glfuncs, GLint i); +void gl1_5_glResetMinmax(void *_glfuncs, GLenum target); +void gl1_5_glResetHistogram(void *_glfuncs, GLenum target); +void gl1_5_glMinmax(void *_glfuncs, GLenum target, GLenum internalFormat, GLboolean sink); +void gl1_5_glHistogram(void *_glfuncs, GLenum target, GLsizei width, GLenum internalFormat, GLboolean sink); +void gl1_5_glGetMinmaxParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl1_5_glGetMinmaxParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl1_5_glGetMinmax(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values); +void gl1_5_glGetHistogramParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl1_5_glGetHistogramParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl1_5_glGetHistogram(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values); +void gl1_5_glSeparableFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* row, const GLvoid* column); +void gl1_5_glGetSeparableFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* row, GLvoid* column, GLvoid* span); +void gl1_5_glGetConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl1_5_glGetConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl1_5_glGetConvolutionFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* image); +void gl1_5_glCopyConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height); +void gl1_5_glCopyConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width); +void gl1_5_glConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl1_5_glConvolutionParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint params); +void gl1_5_glConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl1_5_glConvolutionParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat params); +void gl1_5_glConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* image); +void gl1_5_glConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* image); +void gl1_5_glCopyColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); +void gl1_5_glColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum gltype, const GLvoid* data); +void gl1_5_glGetColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl1_5_glGetColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl1_5_glGetColorTable(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* table); +void gl1_5_glCopyColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width); +void gl1_5_glColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl1_5_glColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl1_5_glColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* table); +void gl1_5_glMultTransposeMatrixd(void *_glfuncs, const GLdouble* m); +void gl1_5_glMultTransposeMatrixf(void *_glfuncs, const GLfloat* m); +void gl1_5_glLoadTransposeMatrixd(void *_glfuncs, const GLdouble* m); +void gl1_5_glLoadTransposeMatrixf(void *_glfuncs, const GLfloat* m); +void gl1_5_glMultiTexCoord4sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl1_5_glMultiTexCoord4s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); +void gl1_5_glMultiTexCoord4iv(void *_glfuncs, GLenum target, const GLint* v); +void gl1_5_glMultiTexCoord4i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r, GLint q); +void gl1_5_glMultiTexCoord4fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl1_5_glMultiTexCoord4f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +void gl1_5_glMultiTexCoord4dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl1_5_glMultiTexCoord4d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +void gl1_5_glMultiTexCoord3sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl1_5_glMultiTexCoord3s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r); +void gl1_5_glMultiTexCoord3iv(void *_glfuncs, GLenum target, const GLint* v); +void gl1_5_glMultiTexCoord3i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r); +void gl1_5_glMultiTexCoord3fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl1_5_glMultiTexCoord3f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r); +void gl1_5_glMultiTexCoord3dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl1_5_glMultiTexCoord3d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r); +void gl1_5_glMultiTexCoord2sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl1_5_glMultiTexCoord2s(void *_glfuncs, GLenum target, GLshort s, GLshort t); +void gl1_5_glMultiTexCoord2iv(void *_glfuncs, GLenum target, const GLint* v); +void gl1_5_glMultiTexCoord2i(void *_glfuncs, GLenum target, GLint s, GLint t); +void gl1_5_glMultiTexCoord2fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl1_5_glMultiTexCoord2f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t); +void gl1_5_glMultiTexCoord2dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl1_5_glMultiTexCoord2d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t); +void gl1_5_glMultiTexCoord1sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl1_5_glMultiTexCoord1s(void *_glfuncs, GLenum target, GLshort s); +void gl1_5_glMultiTexCoord1iv(void *_glfuncs, GLenum target, const GLint* v); +void gl1_5_glMultiTexCoord1i(void *_glfuncs, GLenum target, GLint s); +void gl1_5_glMultiTexCoord1fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl1_5_glMultiTexCoord1f(void *_glfuncs, GLenum target, GLfloat s); +void gl1_5_glMultiTexCoord1dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl1_5_glMultiTexCoord1d(void *_glfuncs, GLenum target, GLdouble s); +void gl1_5_glClientActiveTexture(void *_glfuncs, GLenum texture); +void gl1_5_glWindowPos3sv(void *_glfuncs, const GLshort* v); +void gl1_5_glWindowPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl1_5_glWindowPos3iv(void *_glfuncs, const GLint* v); +void gl1_5_glWindowPos3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl1_5_glWindowPos3fv(void *_glfuncs, const GLfloat* v); +void gl1_5_glWindowPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl1_5_glWindowPos3dv(void *_glfuncs, const GLdouble* v); +void gl1_5_glWindowPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl1_5_glWindowPos2sv(void *_glfuncs, const GLshort* v); +void gl1_5_glWindowPos2s(void *_glfuncs, GLshort x, GLshort y); +void gl1_5_glWindowPos2iv(void *_glfuncs, const GLint* v); +void gl1_5_glWindowPos2i(void *_glfuncs, GLint x, GLint y); +void gl1_5_glWindowPos2fv(void *_glfuncs, const GLfloat* v); +void gl1_5_glWindowPos2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl1_5_glWindowPos2dv(void *_glfuncs, const GLdouble* v); +void gl1_5_glWindowPos2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl1_5_glSecondaryColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl1_5_glSecondaryColor3usv(void *_glfuncs, const GLushort* v); +void gl1_5_glSecondaryColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue); +void gl1_5_glSecondaryColor3uiv(void *_glfuncs, const GLuint* v); +void gl1_5_glSecondaryColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue); +void gl1_5_glSecondaryColor3ubv(void *_glfuncs, const GLubyte* v); +void gl1_5_glSecondaryColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue); +void gl1_5_glSecondaryColor3sv(void *_glfuncs, const GLshort* v); +void gl1_5_glSecondaryColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue); +void gl1_5_glSecondaryColor3iv(void *_glfuncs, const GLint* v); +void gl1_5_glSecondaryColor3i(void *_glfuncs, GLint red, GLint green, GLint blue); +void gl1_5_glSecondaryColor3fv(void *_glfuncs, const GLfloat* v); +void gl1_5_glSecondaryColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue); +void gl1_5_glSecondaryColor3dv(void *_glfuncs, const GLdouble* v); +void gl1_5_glSecondaryColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue); +void gl1_5_glSecondaryColor3bv(void *_glfuncs, const GLbyte* v); +void gl1_5_glSecondaryColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue); +void gl1_5_glFogCoordPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl1_5_glFogCoorddv(void *_glfuncs, const GLdouble* coord); +void gl1_5_glFogCoordd(void *_glfuncs, GLdouble coord); +void gl1_5_glFogCoordfv(void *_glfuncs, const GLfloat* coord); +void gl1_5_glFogCoordf(void *_glfuncs, GLfloat coord); + + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/gl/1.5/gl.go b/gl/1.5/gl.go new file mode 100644 index 00000000..463f66f4 --- /dev/null +++ b/gl/1.5/gl.go @@ -0,0 +1,4237 @@ +// ** file automatically generated by glgen -- do not edit manually ** + +package GL + +// #cgo CXXFLAGS: -std=c++0x -pedantic-errors -Wall -fno-strict-aliasing +// #cgo LDFLAGS: -lstdc++ +// #cgo pkg-config: Qt5Core Qt5OpenGL +// +// #include "funcs.h" +// +// void free(void*); +// +import "C" + +import ( + "fmt" + "reflect" + "unsafe" + + "gopkg.in/qml.v1/gl/glbase" +) + +// API returns a value that offers methods matching the OpenGL version 1.5 API. +// +// The returned API must not be used after the provided OpenGL context becomes invalid. +func API(context glbase.Contexter) *GL { + gl := &GL{} + gl.funcs = C.gl1_5_funcs() + if gl.funcs == nil { + panic(fmt.Errorf("OpenGL version 1.5 is not available")) + } + return gl +} + +// GL implements the OpenGL version 1.5 API. Values of this +// type must be created via the API function, and it must not be used after +// the associated OpenGL context becomes invalid. +type GL struct { + funcs unsafe.Pointer +} + +const ( + FALSE = 0 + TRUE = 1 + NONE = 0 + + BYTE = 0x1400 + UNSIGNED_BYTE = 0x1401 + SHORT = 0x1402 + UNSIGNED_SHORT = 0x1403 + INT = 0x1404 + UNSIGNED_INT = 0x1405 + FLOAT = 0x1406 + N2_BYTES = 0x1407 + N3_BYTES = 0x1408 + N4_BYTES = 0x1409 + DOUBLE = 0x140A + + ACCUM = 0x0100 + LOAD = 0x0101 + RETURN = 0x0102 + MULT = 0x0103 + ADD = 0x0104 + + ACCUM_BUFFER_BIT = 0x00000200 + ALL_ATTRIB_BITS = 0xFFFFFFFF + COLOR_BUFFER_BIT = 0x00004000 + CURRENT_BIT = 0x00000001 + DEPTH_BUFFER_BIT = 0x00000100 + ENABLE_BIT = 0x00002000 + EVAL_BIT = 0x00010000 + FOG_BIT = 0x00000080 + HINT_BIT = 0x00008000 + LIGHTING_BIT = 0x00000040 + LINE_BIT = 0x00000004 + LIST_BIT = 0x00020000 + MULTISAMPLE_BIT = 0x20000000 + PIXEL_MODE_BIT = 0x00000020 + POINT_BIT = 0x00000002 + POLYGON_BIT = 0x00000008 + POLYGON_STIPPLE_BIT = 0x00000010 + SCISSOR_BIT = 0x00080000 + STENCIL_BUFFER_BIT = 0x00000400 + TEXTURE_BIT = 0x00040000 + TRANSFORM_BIT = 0x00001000 + VIEWPORT_BIT = 0x00000800 + + ALWAYS = 0x0207 + EQUAL = 0x0202 + GEQUAL = 0x0206 + GREATER = 0x0204 + LEQUAL = 0x0203 + LESS = 0x0201 + NEVER = 0x0200 + NOTEQUAL = 0x0205 + + LOGIC_OP = 0x0BF1 + + DST_ALPHA = 0x0304 + ONE = 1 + ONE_MINUS_DST_ALPHA = 0x0305 + ONE_MINUS_SRC_ALPHA = 0x0303 + ONE_MINUS_SRC_COLOR = 0x0301 + SRC_ALPHA = 0x0302 + SRC_COLOR = 0x0300 + ZERO = 0 + + DST_COLOR = 0x0306 + ONE_MINUS_DST_COLOR = 0x0307 + SRC_ALPHA_SATURATE = 0x0308 + + CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF + CLIENT_PIXEL_STORE_BIT = 0x00000001 + CLIENT_VERTEX_ARRAY_BIT = 0x00000002 + + CLIP_PLANE0 = 0x3000 + CLIP_PLANE1 = 0x3001 + CLIP_PLANE2 = 0x3002 + CLIP_PLANE3 = 0x3003 + CLIP_PLANE4 = 0x3004 + CLIP_PLANE5 = 0x3005 + + BACK = 0x0405 + FRONT = 0x0404 + FRONT_AND_BACK = 0x0408 + + AMBIENT = 0x1200 + AMBIENT_AND_DIFFUSE = 0x1602 + DIFFUSE = 0x1201 + EMISSION = 0x1600 + SPECULAR = 0x1202 + + AUX0 = 0x0409 + AUX1 = 0x040A + AUX2 = 0x040B + AUX3 = 0x040C + BACK_LEFT = 0x0402 + BACK_RIGHT = 0x0403 + FRONT_LEFT = 0x0400 + FRONT_RIGHT = 0x0401 + LEFT = 0x0406 + RIGHT = 0x0407 + + ALPHA_TEST = 0x0BC0 + AUTO_NORMAL = 0x0D80 + BLEND = 0x0BE2 + COLOR_ARRAY = 0x8076 + COLOR_LOGIC_OP = 0x0BF2 + COLOR_MATERIAL = 0x0B57 + CULL_FACE = 0x0B44 + DEPTH_TEST = 0x0B71 + DITHER = 0x0BD0 + EDGE_FLAG_ARRAY = 0x8079 + FOG = 0x0B60 + INDEX_ARRAY = 0x8077 + INDEX_LOGIC_OP = 0x0BF1 + LIGHT0 = 0x4000 + LIGHT1 = 0x4001 + LIGHT2 = 0x4002 + LIGHT3 = 0x4003 + LIGHT4 = 0x4004 + LIGHT5 = 0x4005 + LIGHT6 = 0x4006 + LIGHT7 = 0x4007 + LIGHTING = 0x0B50 + LINE_SMOOTH = 0x0B20 + LINE_STIPPLE = 0x0B24 + MAP1_COLOR_4 = 0x0D90 + MAP1_INDEX = 0x0D91 + MAP1_NORMAL = 0x0D92 + MAP1_TEXTURE_COORD_1 = 0x0D93 + MAP1_TEXTURE_COORD_2 = 0x0D94 + MAP1_TEXTURE_COORD_3 = 0x0D95 + MAP1_TEXTURE_COORD_4 = 0x0D96 + MAP1_VERTEX_3 = 0x0D97 + MAP1_VERTEX_4 = 0x0D98 + MAP2_COLOR_4 = 0x0DB0 + MAP2_INDEX = 0x0DB1 + MAP2_NORMAL = 0x0DB2 + MAP2_TEXTURE_COORD_1 = 0x0DB3 + MAP2_TEXTURE_COORD_2 = 0x0DB4 + MAP2_TEXTURE_COORD_3 = 0x0DB5 + MAP2_TEXTURE_COORD_4 = 0x0DB6 + MAP2_VERTEX_3 = 0x0DB7 + MAP2_VERTEX_4 = 0x0DB8 + NORMALIZE = 0x0BA1 + NORMAL_ARRAY = 0x8075 + POINT_SMOOTH = 0x0B10 + POLYGON_OFFSET_FILL = 0x8037 + POLYGON_OFFSET_LINE = 0x2A02 + POLYGON_OFFSET_POINT = 0x2A01 + POLYGON_SMOOTH = 0x0B41 + POLYGON_STIPPLE = 0x0B42 + SCISSOR_TEST = 0x0C11 + STENCIL_TEST = 0x0B90 + TEXTURE_1D = 0x0DE0 + TEXTURE_2D = 0x0DE1 + TEXTURE_COORD_ARRAY = 0x8078 + TEXTURE_GEN_Q = 0x0C63 + TEXTURE_GEN_R = 0x0C62 + TEXTURE_GEN_S = 0x0C60 + TEXTURE_GEN_T = 0x0C61 + VERTEX_ARRAY = 0x8074 + + INVALID_ENUM = 0x0500 + INVALID_OPERATION = 0x0502 + INVALID_VALUE = 0x0501 + NO_ERROR = 0 + OUT_OF_MEMORY = 0x0505 + STACK_OVERFLOW = 0x0503 + STACK_UNDERFLOW = 0x0504 + + N2D = 0x0600 + N3D = 0x0601 + N3D_COLOR = 0x0602 + N3D_COLOR_TEXTURE = 0x0603 + N4D_COLOR_TEXTURE = 0x0604 + + BITMAP_TOKEN = 0x0704 + COPY_PIXEL_TOKEN = 0x0706 + DRAW_PIXEL_TOKEN = 0x0705 + LINE_RESET_TOKEN = 0x0707 + LINE_TOKEN = 0x0702 + PASS_THROUGH_TOKEN = 0x0700 + POINT_TOKEN = 0x0701 + POLYGON_TOKEN = 0x0703 + + EXP = 0x0800 + EXP2 = 0x0801 + LINEAR = 0x2601 + + FOG_COLOR = 0x0B66 + FOG_DENSITY = 0x0B62 + FOG_END = 0x0B64 + FOG_INDEX = 0x0B61 + FOG_MODE = 0x0B65 + FOG_START = 0x0B63 + + CCW = 0x0901 + CW = 0x0900 + + COEFF = 0x0A00 + DOMAIN = 0x0A02 + ORDER = 0x0A01 + + PIXEL_MAP_A_TO_A = 0x0C79 + PIXEL_MAP_B_TO_B = 0x0C78 + PIXEL_MAP_G_TO_G = 0x0C77 + PIXEL_MAP_I_TO_A = 0x0C75 + PIXEL_MAP_I_TO_B = 0x0C74 + PIXEL_MAP_I_TO_G = 0x0C73 + PIXEL_MAP_I_TO_I = 0x0C70 + PIXEL_MAP_I_TO_R = 0x0C72 + PIXEL_MAP_R_TO_R = 0x0C76 + PIXEL_MAP_S_TO_S = 0x0C71 + + ACCUM_ALPHA_BITS = 0x0D5B + ACCUM_BLUE_BITS = 0x0D5A + ACCUM_CLEAR_VALUE = 0x0B80 + ACCUM_GREEN_BITS = 0x0D59 + ACCUM_RED_BITS = 0x0D58 + ALIASED_LINE_WIDTH_RANGE = 0x846E + ALIASED_POINT_SIZE_RANGE = 0x846D + ALPHA_BIAS = 0x0D1D + ALPHA_BITS = 0x0D55 + ALPHA_SCALE = 0x0D1C + ALPHA_TEST_FUNC = 0x0BC1 + ALPHA_TEST_REF = 0x0BC2 + ATTRIB_STACK_DEPTH = 0x0BB0 + AUX_BUFFERS = 0x0C00 + BLEND_DST = 0x0BE0 + BLEND_SRC = 0x0BE1 + BLUE_BIAS = 0x0D1B + BLUE_BITS = 0x0D54 + BLUE_SCALE = 0x0D1A + CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1 + COLOR_ARRAY_SIZE = 0x8081 + COLOR_ARRAY_STRIDE = 0x8083 + COLOR_ARRAY_TYPE = 0x8082 + COLOR_CLEAR_VALUE = 0x0C22 + COLOR_MATERIAL_FACE = 0x0B55 + COLOR_MATERIAL_PARAMETER = 0x0B56 + COLOR_WRITEMASK = 0x0C23 + CULL_FACE_MODE = 0x0B45 + CURRENT_COLOR = 0x0B00 + CURRENT_INDEX = 0x0B01 + CURRENT_NORMAL = 0x0B02 + CURRENT_RASTER_COLOR = 0x0B04 + CURRENT_RASTER_DISTANCE = 0x0B09 + CURRENT_RASTER_INDEX = 0x0B05 + CURRENT_RASTER_POSITION = 0x0B07 + CURRENT_RASTER_POSITION_VALID = 0x0B08 + CURRENT_RASTER_TEXTURE_COORDS = 0x0B06 + CURRENT_TEXTURE_COORDS = 0x0B03 + DEPTH_BIAS = 0x0D1F + DEPTH_BITS = 0x0D56 + DEPTH_CLEAR_VALUE = 0x0B73 + DEPTH_FUNC = 0x0B74 + DEPTH_RANGE = 0x0B70 + DEPTH_SCALE = 0x0D1E + DEPTH_WRITEMASK = 0x0B72 + DOUBLEBUFFER = 0x0C32 + DRAW_BUFFER = 0x0C01 + EDGE_FLAG = 0x0B43 + EDGE_FLAG_ARRAY_STRIDE = 0x808C + FEEDBACK_BUFFER_SIZE = 0x0DF1 + FEEDBACK_BUFFER_TYPE = 0x0DF2 + FOG_HINT = 0x0C54 + FRONT_FACE = 0x0B46 + GREEN_BIAS = 0x0D19 + GREEN_BITS = 0x0D53 + GREEN_SCALE = 0x0D18 + INDEX_ARRAY_STRIDE = 0x8086 + INDEX_ARRAY_TYPE = 0x8085 + INDEX_BITS = 0x0D51 + INDEX_CLEAR_VALUE = 0x0C20 + INDEX_MODE = 0x0C30 + INDEX_OFFSET = 0x0D13 + INDEX_SHIFT = 0x0D12 + INDEX_WRITEMASK = 0x0C21 + LIGHT_MODEL_AMBIENT = 0x0B53 + LIGHT_MODEL_COLOR_CONTROL = 0x81F8 + LIGHT_MODEL_LOCAL_VIEWER = 0x0B51 + LIGHT_MODEL_TWO_SIDE = 0x0B52 + LINE_SMOOTH_HINT = 0x0C52 + LINE_STIPPLE_PATTERN = 0x0B25 + LINE_STIPPLE_REPEAT = 0x0B26 + LINE_WIDTH = 0x0B21 + LINE_WIDTH_GRANULARITY = 0x0B23 + LINE_WIDTH_RANGE = 0x0B22 + LIST_BASE = 0x0B32 + LIST_INDEX = 0x0B33 + LIST_MODE = 0x0B30 + LOGIC_OP_MODE = 0x0BF0 + MAP1_GRID_DOMAIN = 0x0DD0 + MAP1_GRID_SEGMENTS = 0x0DD1 + MAP2_GRID_DOMAIN = 0x0DD2 + MAP2_GRID_SEGMENTS = 0x0DD3 + MAP_COLOR = 0x0D10 + MAP_STENCIL = 0x0D11 + MATRIX_MODE = 0x0BA0 + MAX_ATTRIB_STACK_DEPTH = 0x0D35 + MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B + MAX_CLIP_PLANES = 0x0D32 + MAX_EVAL_ORDER = 0x0D30 + MAX_LIGHTS = 0x0D31 + MAX_LIST_NESTING = 0x0B31 + MAX_MODELVIEW_STACK_DEPTH = 0x0D36 + MAX_NAME_STACK_DEPTH = 0x0D37 + MAX_PIXEL_MAP_TABLE = 0x0D34 + MAX_PROJECTION_STACK_DEPTH = 0x0D38 + MAX_TEXTURE_SIZE = 0x0D33 + MAX_TEXTURE_STACK_DEPTH = 0x0D39 + MAX_VIEWPORT_DIMS = 0x0D3A + MODELVIEW_MATRIX = 0x0BA6 + MODELVIEW_STACK_DEPTH = 0x0BA3 + NAME_STACK_DEPTH = 0x0D70 + NORMAL_ARRAY_STRIDE = 0x807F + NORMAL_ARRAY_TYPE = 0x807E + PACK_ALIGNMENT = 0x0D05 + PACK_LSB_FIRST = 0x0D01 + PACK_ROW_LENGTH = 0x0D02 + PACK_SKIP_PIXELS = 0x0D04 + PACK_SKIP_ROWS = 0x0D03 + PACK_SWAP_BYTES = 0x0D00 + PERSPECTIVE_CORRECTION_HINT = 0x0C50 + PIXEL_MAP_A_TO_A_SIZE = 0x0CB9 + PIXEL_MAP_B_TO_B_SIZE = 0x0CB8 + PIXEL_MAP_G_TO_G_SIZE = 0x0CB7 + PIXEL_MAP_I_TO_A_SIZE = 0x0CB5 + PIXEL_MAP_I_TO_B_SIZE = 0x0CB4 + PIXEL_MAP_I_TO_G_SIZE = 0x0CB3 + PIXEL_MAP_I_TO_I_SIZE = 0x0CB0 + PIXEL_MAP_I_TO_R_SIZE = 0x0CB2 + PIXEL_MAP_R_TO_R_SIZE = 0x0CB6 + PIXEL_MAP_S_TO_S_SIZE = 0x0CB1 + POINT_SIZE = 0x0B11 + POINT_SIZE_GRANULARITY = 0x0B13 + POINT_SIZE_RANGE = 0x0B12 + POINT_SMOOTH_HINT = 0x0C51 + POLYGON_MODE = 0x0B40 + POLYGON_OFFSET_FACTOR = 0x8038 + POLYGON_OFFSET_UNITS = 0x2A00 + POLYGON_SMOOTH_HINT = 0x0C53 + PROJECTION_MATRIX = 0x0BA7 + PROJECTION_STACK_DEPTH = 0x0BA4 + READ_BUFFER = 0x0C02 + RED_BIAS = 0x0D15 + RED_BITS = 0x0D52 + RED_SCALE = 0x0D14 + RENDER_MODE = 0x0C40 + RGBA_MODE = 0x0C31 + SCISSOR_BOX = 0x0C10 + SELECTION_BUFFER_SIZE = 0x0DF4 + SHADE_MODEL = 0x0B54 + SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23 + SMOOTH_LINE_WIDTH_RANGE = 0x0B22 + SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13 + SMOOTH_POINT_SIZE_RANGE = 0x0B12 + STENCIL_BITS = 0x0D57 + STENCIL_CLEAR_VALUE = 0x0B91 + STENCIL_FAIL = 0x0B94 + STENCIL_FUNC = 0x0B92 + STENCIL_PASS_DEPTH_FAIL = 0x0B95 + STENCIL_PASS_DEPTH_PASS = 0x0B96 + STENCIL_REF = 0x0B97 + STENCIL_VALUE_MASK = 0x0B93 + STENCIL_WRITEMASK = 0x0B98 + STEREO = 0x0C33 + SUBPIXEL_BITS = 0x0D50 + TEXTURE_BINDING_1D = 0x8068 + TEXTURE_BINDING_2D = 0x8069 + TEXTURE_BINDING_3D = 0x806A + TEXTURE_COORD_ARRAY_SIZE = 0x8088 + TEXTURE_COORD_ARRAY_STRIDE = 0x808A + TEXTURE_COORD_ARRAY_TYPE = 0x8089 + TEXTURE_MATRIX = 0x0BA8 + TEXTURE_STACK_DEPTH = 0x0BA5 + UNPACK_ALIGNMENT = 0x0CF5 + UNPACK_LSB_FIRST = 0x0CF1 + UNPACK_ROW_LENGTH = 0x0CF2 + UNPACK_SKIP_PIXELS = 0x0CF4 + UNPACK_SKIP_ROWS = 0x0CF3 + UNPACK_SWAP_BYTES = 0x0CF0 + VERTEX_ARRAY_SIZE = 0x807A + VERTEX_ARRAY_STRIDE = 0x807C + VERTEX_ARRAY_TYPE = 0x807B + VIEWPORT = 0x0BA2 + ZOOM_X = 0x0D16 + ZOOM_Y = 0x0D17 + + COLOR_ARRAY_POINTER = 0x8090 + EDGE_FLAG_ARRAY_POINTER = 0x8093 + FEEDBACK_BUFFER_POINTER = 0x0DF0 + INDEX_ARRAY_POINTER = 0x8091 + NORMAL_ARRAY_POINTER = 0x808F + SELECTION_BUFFER_POINTER = 0x0DF3 + TEXTURE_COORD_ARRAY_POINTER = 0x8092 + VERTEX_ARRAY_POINTER = 0x808E + + TEXTURE_ALPHA_SIZE = 0x805F + TEXTURE_BLUE_SIZE = 0x805E + TEXTURE_BORDER = 0x1005 + TEXTURE_BORDER_COLOR = 0x1004 + TEXTURE_COMPONENTS = 0x1003 + TEXTURE_GREEN_SIZE = 0x805D + TEXTURE_HEIGHT = 0x1001 + TEXTURE_INTENSITY_SIZE = 0x8061 + TEXTURE_INTERNAL_FORMAT = 0x1003 + TEXTURE_LUMINANCE_SIZE = 0x8060 + TEXTURE_MAG_FILTER = 0x2800 + TEXTURE_MIN_FILTER = 0x2801 + TEXTURE_PRIORITY = 0x8066 + TEXTURE_RED_SIZE = 0x805C + TEXTURE_RESIDENT = 0x8067 + TEXTURE_WIDTH = 0x1000 + TEXTURE_WRAP_S = 0x2802 + TEXTURE_WRAP_T = 0x2803 + + DONT_CARE = 0x1100 + FASTEST = 0x1101 + NICEST = 0x1102 + + GENERATE_MIPMAP_HINT = 0x8192 + TEXTURE_COMPRESSION_HINT = 0x84EF + + C3F_V3F = 0x2A24 + C4F_N3F_V3F = 0x2A26 + C4UB_V2F = 0x2A22 + C4UB_V3F = 0x2A23 + N3F_V3F = 0x2A25 + T2F_C3F_V3F = 0x2A2A + T2F_C4F_N3F_V3F = 0x2A2C + T2F_C4UB_V3F = 0x2A29 + T2F_N3F_V3F = 0x2A2B + T2F_V3F = 0x2A27 + T4F_C4F_N3F_V4F = 0x2A2D + T4F_V4F = 0x2A28 + V2F = 0x2A20 + V3F = 0x2A21 + + MODULATE = 0x2100 + REPLACE = 0x1E01 + + SEPARATE_SPECULAR_COLOR = 0x81FA + SINGLE_COLOR = 0x81F9 + + CONSTANT_ATTENUATION = 0x1207 + LINEAR_ATTENUATION = 0x1208 + POSITION = 0x1203 + QUADRATIC_ATTENUATION = 0x1209 + SPOT_CUTOFF = 0x1206 + SPOT_DIRECTION = 0x1204 + SPOT_EXPONENT = 0x1205 + + COMPILE = 0x1300 + COMPILE_AND_EXECUTE = 0x1301 + + AND = 0x1501 + AND_INVERTED = 0x1504 + AND_REVERSE = 0x1502 + CLEAR = 0x1500 + COPY = 0x1503 + COPY_INVERTED = 0x150C + EQUIV = 0x1509 + INVERT = 0x150A + NAND = 0x150E + NOOP = 0x1505 + NOR = 0x1508 + OR = 0x1507 + OR_INVERTED = 0x150D + OR_REVERSE = 0x150B + SET = 0x150F + XOR = 0x1506 + + COLOR_INDEXES = 0x1603 + SHININESS = 0x1601 + + MODELVIEW = 0x1700 + PROJECTION = 0x1701 + TEXTURE = 0x1702 + + LINE = 0x1B01 + POINT = 0x1B00 + + FILL = 0x1B02 + + COLOR = 0x1800 + DEPTH = 0x1801 + STENCIL = 0x1802 + + ALPHA = 0x1906 + BLUE = 0x1905 + COLOR_INDEX = 0x1900 + DEPTH_COMPONENT = 0x1902 + GREEN = 0x1904 + LUMINANCE = 0x1909 + LUMINANCE_ALPHA = 0x190A + RED = 0x1903 + RGB = 0x1907 + RGBA = 0x1908 + STENCIL_INDEX = 0x1901 + + ALPHA12 = 0x803D + ALPHA16 = 0x803E + ALPHA4 = 0x803B + ALPHA8 = 0x803C + INTENSITY = 0x8049 + INTENSITY12 = 0x804C + INTENSITY16 = 0x804D + INTENSITY4 = 0x804A + INTENSITY8 = 0x804B + LUMINANCE12 = 0x8041 + LUMINANCE12_ALPHA12 = 0x8047 + LUMINANCE12_ALPHA4 = 0x8046 + LUMINANCE16 = 0x8042 + LUMINANCE16_ALPHA16 = 0x8048 + LUMINANCE4 = 0x803F + LUMINANCE4_ALPHA4 = 0x8043 + LUMINANCE6_ALPHA2 = 0x8044 + LUMINANCE8 = 0x8040 + LUMINANCE8_ALPHA8 = 0x8045 + R3_G3_B2 = 0x2A10 + RGB10 = 0x8052 + RGB10_A2 = 0x8059 + RGB12 = 0x8053 + RGB16 = 0x8054 + RGB4 = 0x804F + RGB5 = 0x8050 + RGB5_A1 = 0x8057 + RGB8 = 0x8051 + RGBA12 = 0x805A + RGBA16 = 0x805B + RGBA2 = 0x8055 + RGBA4 = 0x8056 + RGBA8 = 0x8058 + + PACK_IMAGE_HEIGHT = 0x806C + PACK_SKIP_IMAGES = 0x806B + UNPACK_IMAGE_HEIGHT = 0x806E + UNPACK_SKIP_IMAGES = 0x806D + + BITMAP = 0x1A00 + UNSIGNED_BYTE_3_3_2 = 0x8032 + UNSIGNED_INT_10_10_10_2 = 0x8036 + UNSIGNED_INT_8_8_8_8 = 0x8035 + UNSIGNED_SHORT_4_4_4_4 = 0x8033 + UNSIGNED_SHORT_5_5_5_1 = 0x8034 + + POINT_DISTANCE_ATTENUATION = 0x8129 + POINT_FADE_THRESHOLD_SIZE = 0x8128 + POINT_SIZE_MAX = 0x8127 + POINT_SIZE_MIN = 0x8126 + + LINES = 0x0001 + LINE_LOOP = 0x0002 + LINE_STRIP = 0x0003 + POINTS = 0x0000 + POLYGON = 0x0009 + QUADS = 0x0007 + QUAD_STRIP = 0x0008 + TRIANGLES = 0x0004 + TRIANGLE_FAN = 0x0006 + TRIANGLE_STRIP = 0x0005 + + FEEDBACK = 0x1C01 + RENDER = 0x1C00 + SELECT = 0x1C02 + + FLAT = 0x1D00 + SMOOTH = 0x1D01 + + DECR = 0x1E03 + INCR = 0x1E02 + KEEP = 0x1E00 + + EXTENSIONS = 0x1F03 + RENDERER = 0x1F01 + VENDOR = 0x1F00 + VERSION = 0x1F02 + + S = 0x2000 + T = 0x2001 + R = 0x2002 + Q = 0x2003 + + DECAL = 0x2101 + + TEXTURE_ENV_COLOR = 0x2201 + TEXTURE_ENV_MODE = 0x2200 + + TEXTURE_ENV = 0x2300 + + EYE_LINEAR = 0x2400 + OBJECT_LINEAR = 0x2401 + SPHERE_MAP = 0x2402 + + EYE_PLANE = 0x2502 + OBJECT_PLANE = 0x2501 + TEXTURE_GEN_MODE = 0x2500 + + NEAREST = 0x2600 + + LINEAR_MIPMAP_LINEAR = 0x2703 + LINEAR_MIPMAP_NEAREST = 0x2701 + NEAREST_MIPMAP_LINEAR = 0x2702 + NEAREST_MIPMAP_NEAREST = 0x2700 + + GENERATE_MIPMAP = 0x8191 + TEXTURE_WRAP_R = 0x8072 + + PROXY_TEXTURE_1D = 0x8063 + PROXY_TEXTURE_2D = 0x8064 + PROXY_TEXTURE_3D = 0x8070 + TEXTURE_3D = 0x806F + TEXTURE_BASE_LEVEL = 0x813C + TEXTURE_MAX_LEVEL = 0x813D + TEXTURE_MAX_LOD = 0x813B + TEXTURE_MIN_LOD = 0x813A + + CLAMP = 0x2900 + CLAMP_TO_BORDER = 0x812D + CLAMP_TO_EDGE = 0x812F + REPEAT = 0x2901 + + CONSTANT_COLOR = 0x8001 + ONE_MINUS_CONSTANT_COLOR = 0x8002 + CONSTANT_ALPHA = 0x8003 + ONE_MINUS_CONSTANT_ALPHA = 0x8004 + FUNC_ADD = 0x8006 + MIN = 0x8007 + MAX = 0x8008 + FUNC_SUBTRACT = 0x800A + FUNC_REVERSE_SUBTRACT = 0x800B + RESCALE_NORMAL = 0x803A + TEXTURE_DEPTH = 0x8071 + MAX_3D_TEXTURE_SIZE = 0x8073 + MULTISAMPLE = 0x809D + SAMPLE_ALPHA_TO_COVERAGE = 0x809E + SAMPLE_ALPHA_TO_ONE = 0x809F + SAMPLE_COVERAGE = 0x80A0 + SAMPLE_BUFFERS = 0x80A8 + SAMPLES = 0x80A9 + SAMPLE_COVERAGE_VALUE = 0x80AA + SAMPLE_COVERAGE_INVERT = 0x80AB + BLEND_DST_RGB = 0x80C8 + BLEND_SRC_RGB = 0x80C9 + BLEND_DST_ALPHA = 0x80CA + BLEND_SRC_ALPHA = 0x80CB + BGR = 0x80E0 + BGRA = 0x80E1 + MAX_ELEMENTS_VERTICES = 0x80E8 + MAX_ELEMENTS_INDICES = 0x80E9 + DEPTH_COMPONENT16 = 0x81A5 + DEPTH_COMPONENT24 = 0x81A6 + DEPTH_COMPONENT32 = 0x81A7 + UNSIGNED_BYTE_2_3_3_REV = 0x8362 + UNSIGNED_SHORT_5_6_5 = 0x8363 + UNSIGNED_SHORT_5_6_5_REV = 0x8364 + UNSIGNED_SHORT_4_4_4_4_REV = 0x8365 + UNSIGNED_SHORT_1_5_5_5_REV = 0x8366 + UNSIGNED_INT_8_8_8_8_REV = 0x8367 + UNSIGNED_INT_2_10_10_10_REV = 0x8368 + MIRRORED_REPEAT = 0x8370 + FOG_COORDINATE_SOURCE = 0x8450 + FOG_COORD_SRC = 0x8450 + FOG_COORDINATE = 0x8451 + FOG_COORD = 0x8451 + FRAGMENT_DEPTH = 0x8452 + CURRENT_FOG_COORDINATE = 0x8453 + CURRENT_FOG_COORD = 0x8453 + FOG_COORDINATE_ARRAY_TYPE = 0x8454 + FOG_COORD_ARRAY_TYPE = 0x8454 + FOG_COORDINATE_ARRAY_STRIDE = 0x8455 + FOG_COORD_ARRAY_STRIDE = 0x8455 + FOG_COORDINATE_ARRAY_POINTER = 0x8456 + FOG_COORD_ARRAY_POINTER = 0x8456 + FOG_COORDINATE_ARRAY = 0x8457 + FOG_COORD_ARRAY = 0x8457 + COLOR_SUM = 0x8458 + CURRENT_SECONDARY_COLOR = 0x8459 + SECONDARY_COLOR_ARRAY_SIZE = 0x845A + SECONDARY_COLOR_ARRAY_TYPE = 0x845B + SECONDARY_COLOR_ARRAY_STRIDE = 0x845C + SECONDARY_COLOR_ARRAY_POINTER = 0x845D + SECONDARY_COLOR_ARRAY = 0x845E + TEXTURE0 = 0x84C0 + TEXTURE1 = 0x84C1 + TEXTURE2 = 0x84C2 + TEXTURE3 = 0x84C3 + TEXTURE4 = 0x84C4 + TEXTURE5 = 0x84C5 + TEXTURE6 = 0x84C6 + TEXTURE7 = 0x84C7 + TEXTURE8 = 0x84C8 + TEXTURE9 = 0x84C9 + TEXTURE10 = 0x84CA + TEXTURE11 = 0x84CB + TEXTURE12 = 0x84CC + TEXTURE13 = 0x84CD + TEXTURE14 = 0x84CE + TEXTURE15 = 0x84CF + TEXTURE16 = 0x84D0 + TEXTURE17 = 0x84D1 + TEXTURE18 = 0x84D2 + TEXTURE19 = 0x84D3 + TEXTURE20 = 0x84D4 + TEXTURE21 = 0x84D5 + TEXTURE22 = 0x84D6 + TEXTURE23 = 0x84D7 + TEXTURE24 = 0x84D8 + TEXTURE25 = 0x84D9 + TEXTURE26 = 0x84DA + TEXTURE27 = 0x84DB + TEXTURE28 = 0x84DC + TEXTURE29 = 0x84DD + TEXTURE30 = 0x84DE + TEXTURE31 = 0x84DF + ACTIVE_TEXTURE = 0x84E0 + CLIENT_ACTIVE_TEXTURE = 0x84E1 + MAX_TEXTURE_UNITS = 0x84E2 + TRANSPOSE_MODELVIEW_MATRIX = 0x84E3 + TRANSPOSE_PROJECTION_MATRIX = 0x84E4 + TRANSPOSE_TEXTURE_MATRIX = 0x84E5 + TRANSPOSE_COLOR_MATRIX = 0x84E6 + SUBTRACT = 0x84E7 + COMPRESSED_ALPHA = 0x84E9 + COMPRESSED_LUMINANCE = 0x84EA + COMPRESSED_LUMINANCE_ALPHA = 0x84EB + COMPRESSED_INTENSITY = 0x84EC + COMPRESSED_RGB = 0x84ED + COMPRESSED_RGBA = 0x84EE + MAX_TEXTURE_LOD_BIAS = 0x84FD + TEXTURE_FILTER_CONTROL = 0x8500 + TEXTURE_LOD_BIAS = 0x8501 + INCR_WRAP = 0x8507 + DECR_WRAP = 0x8508 + NORMAL_MAP = 0x8511 + REFLECTION_MAP = 0x8512 + TEXTURE_CUBE_MAP = 0x8513 + TEXTURE_BINDING_CUBE_MAP = 0x8514 + TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515 + TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516 + TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517 + TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518 + TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519 + TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A + PROXY_TEXTURE_CUBE_MAP = 0x851B + MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C + COMBINE = 0x8570 + COMBINE_RGB = 0x8571 + COMBINE_ALPHA = 0x8572 + RGB_SCALE = 0x8573 + ADD_SIGNED = 0x8574 + INTERPOLATE = 0x8575 + CONSTANT = 0x8576 + PRIMARY_COLOR = 0x8577 + PREVIOUS = 0x8578 + SOURCE0_RGB = 0x8580 + SRC0_RGB = 0x8580 + SOURCE1_RGB = 0x8581 + SRC1_RGB = 0x8581 + SOURCE2_RGB = 0x8582 + SRC2_RGB = 0x8582 + SOURCE0_ALPHA = 0x8588 + SRC0_ALPHA = 0x8588 + SOURCE1_ALPHA = 0x8589 + SRC1_ALPHA = 0x8589 + SOURCE2_ALPHA = 0x858A + SRC2_ALPHA = 0x858A + OPERAND0_RGB = 0x8590 + OPERAND1_RGB = 0x8591 + OPERAND2_RGB = 0x8592 + OPERAND0_ALPHA = 0x8598 + OPERAND1_ALPHA = 0x8599 + OPERAND2_ALPHA = 0x859A + TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0 + TEXTURE_COMPRESSED = 0x86A1 + NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2 + COMPRESSED_TEXTURE_FORMATS = 0x86A3 + DOT3_RGB = 0x86AE + DOT3_RGBA = 0x86AF + BUFFER_SIZE = 0x8764 + BUFFER_USAGE = 0x8765 + TEXTURE_DEPTH_SIZE = 0x884A + DEPTH_TEXTURE_MODE = 0x884B + TEXTURE_COMPARE_MODE = 0x884C + TEXTURE_COMPARE_FUNC = 0x884D + COMPARE_R_TO_TEXTURE = 0x884E + QUERY_COUNTER_BITS = 0x8864 + CURRENT_QUERY = 0x8865 + QUERY_RESULT = 0x8866 + QUERY_RESULT_AVAILABLE = 0x8867 + ARRAY_BUFFER = 0x8892 + ELEMENT_ARRAY_BUFFER = 0x8893 + ARRAY_BUFFER_BINDING = 0x8894 + ELEMENT_ARRAY_BUFFER_BINDING = 0x8895 + VERTEX_ARRAY_BUFFER_BINDING = 0x8896 + NORMAL_ARRAY_BUFFER_BINDING = 0x8897 + COLOR_ARRAY_BUFFER_BINDING = 0x8898 + INDEX_ARRAY_BUFFER_BINDING = 0x8899 + TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A + EDGE_FLAG_ARRAY_BUFFER_BINDING = 0x889B + SECONDARY_COLOR_ARRAY_BUFFER_BINDING = 0x889C + FOG_COORDINATE_ARRAY_BUFFER_BINDING = 0x889D + FOG_COORD_ARRAY_BUFFER_BINDING = 0x889D + WEIGHT_ARRAY_BUFFER_BINDING = 0x889E + VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F + READ_ONLY = 0x88B8 + WRITE_ONLY = 0x88B9 + READ_WRITE = 0x88BA + BUFFER_ACCESS = 0x88BB + BUFFER_MAPPED = 0x88BC + BUFFER_MAP_POINTER = 0x88BD + STREAM_DRAW = 0x88E0 + STREAM_READ = 0x88E1 + STREAM_COPY = 0x88E2 + STATIC_DRAW = 0x88E4 + STATIC_READ = 0x88E5 + STATIC_COPY = 0x88E6 + DYNAMIC_DRAW = 0x88E8 + DYNAMIC_READ = 0x88E9 + DYNAMIC_COPY = 0x88EA + SAMPLES_PASSED = 0x8914 +) + +// https://www.opengl.org/sdk/docs/man2/xhtml/glViewport.xml +func (gl *GL) Viewport(x, y, width, height int) { + C.gl1_5_glViewport(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// DepthRange specifies the mapping of depth values from normalized device +// coordinates to window coordinates. +// +// Parameter nearVal specifies the mapping of the near clipping plane to window +// coordinates (defaults to 0), while farVal specifies the mapping of the far +// clipping plane to window coordinates (defaults to 1). +// +// After clipping and division by w, depth coordinates range from -1 to 1, +// corresponding to the near and far clipping planes. DepthRange specifies a +// linear mapping of the normalized depth coordinates in this range to window +// depth coordinates. Regardless of the actual depth buffer implementation, +// window coordinate depth values are treated as though they range from 0 through 1 +// (like color components). Thus, the values accepted by DepthRange are both +// clamped to this range before they are accepted. +// +// The default setting of (0, 1) maps the near plane to 0 and the far plane to 1. +// With this mapping, the depth buffer range is fully utilized. +// +// It is not necessary that nearVal be less than farVal. Reverse mappings such as +// nearVal 1, and farVal 0 are acceptable. +// +// GL.INVALID_OPERATION is generated if DepthRange is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) DepthRange(nearVal, farVal float64) { + C.gl1_5_glDepthRange(gl.funcs, C.GLdouble(nearVal), C.GLdouble(farVal)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsEnabled.xml +func (gl *GL) IsEnabled(cap glbase.Enum) bool { + glresult := C.gl1_5_glIsEnabled(gl.funcs, C.GLenum(cap)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexLevelParameteriv.xml +func (gl *GL) GetTexLevelParameteriv(target glbase.Enum, level int, pname glbase.Enum, params []int32) { + C.gl1_5_glGetTexLevelParameteriv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexLevelParameterfv.xml +func (gl *GL) GetTexLevelParameterfv(target glbase.Enum, level int, pname glbase.Enum, params []float32) { + C.gl1_5_glGetTexLevelParameterfv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexParameteriv.xml +func (gl *GL) GetTexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_5_glGetTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexParameterfv.xml +func (gl *GL) GetTexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_5_glGetTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexImage.xml +func (gl *GL) GetTexImage(target glbase.Enum, level int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glGetTexImage(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetIntegerv.xml +func (gl *GL) GetIntegerv(pname glbase.Enum, params []int32) { + C.gl1_5_glGetIntegerv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetFloatv.xml +func (gl *GL) GetFloatv(pname glbase.Enum, params []float32) { + C.gl1_5_glGetFloatv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetError.xml +func (gl *GL) GetError() glbase.Enum { + glresult := C.gl1_5_glGetError(gl.funcs) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetDoublev.xml +func (gl *GL) GetDoublev(pname glbase.Enum, params []float64) { + C.gl1_5_glGetDoublev(gl.funcs, C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetBooleanv.xml +func (gl *GL) GetBooleanv(pname glbase.Enum, params []bool) { + C.gl1_5_glGetBooleanv(gl.funcs, C.GLenum(pname), (*C.GLboolean)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glReadPixels.xml +func (gl *GL) ReadPixels(x, y, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glReadPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glReadBuffer.xml +func (gl *GL) ReadBuffer(mode glbase.Enum) { + C.gl1_5_glReadBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelStorei.xml +func (gl *GL) PixelStorei(pname glbase.Enum, param int32) { + C.gl1_5_glPixelStorei(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelStoref.xml +func (gl *GL) PixelStoref(pname glbase.Enum, param float32) { + C.gl1_5_glPixelStoref(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDepthFunc.xml +func (gl *GL) DepthFunc(glfunc glbase.Enum) { + C.gl1_5_glDepthFunc(gl.funcs, C.GLenum(glfunc)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilOp.xml +func (gl *GL) StencilOp(fail, zfail, zpass glbase.Enum) { + C.gl1_5_glStencilOp(gl.funcs, C.GLenum(fail), C.GLenum(zfail), C.GLenum(zpass)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilFunc.xml +func (gl *GL) StencilFunc(glfunc glbase.Enum, ref int32, mask uint32) { + C.gl1_5_glStencilFunc(gl.funcs, C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLogicOp.xml +func (gl *GL) LogicOp(opcode glbase.Enum) { + C.gl1_5_glLogicOp(gl.funcs, C.GLenum(opcode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBlendFunc.xml +func (gl *GL) BlendFunc(sfactor, dfactor glbase.Enum) { + C.gl1_5_glBlendFunc(gl.funcs, C.GLenum(sfactor), C.GLenum(dfactor)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFlush.xml +func (gl *GL) Flush() { + C.gl1_5_glFlush(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFinish.xml +func (gl *GL) Finish() { + C.gl1_5_glFinish(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEnable.xml +func (gl *GL) Enable(cap glbase.Enum) { + C.gl1_5_glEnable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDisable.xml +func (gl *GL) Disable(cap glbase.Enum) { + C.gl1_5_glDisable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDepthMask.xml +func (gl *GL) DepthMask(flag bool) { + C.gl1_5_glDepthMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorMask.xml +func (gl *GL) ColorMask(red, green, blue, alpha bool) { + C.gl1_5_glColorMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&red)), *(*C.GLboolean)(unsafe.Pointer(&green)), *(*C.GLboolean)(unsafe.Pointer(&blue)), *(*C.GLboolean)(unsafe.Pointer(&alpha))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilMask.xml +func (gl *GL) StencilMask(mask uint32) { + C.gl1_5_glStencilMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearDepth.xml +func (gl *GL) ClearDepth(depth float64) { + C.gl1_5_glClearDepth(gl.funcs, C.GLdouble(depth)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearStencil.xml +func (gl *GL) ClearStencil(s int32) { + C.gl1_5_glClearStencil(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearColor.xml +func (gl *GL) ClearColor(red, green, blue, alpha float32) { + C.gl1_5_glClearColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClear.xml +func (gl *GL) Clear(mask glbase.Bitfield) { + C.gl1_5_glClear(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawBuffer.xml +func (gl *GL) DrawBuffer(mode glbase.Enum) { + C.gl1_5_glDrawBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexImage2D.xml +func (gl *GL) TexImage2D(target glbase.Enum, level int, internalFormat int32, width, height, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexImage1D.xml +func (gl *GL) TexImage1D(target glbase.Enum, level int, internalFormat int32, width, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameteriv.xml +func (gl *GL) TexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_5_glTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameteri.xml +func (gl *GL) TexParameteri(target, pname glbase.Enum, param int32) { + C.gl1_5_glTexParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameterfv.xml +func (gl *GL) TexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_5_glTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameterf.xml +func (gl *GL) TexParameterf(target, pname glbase.Enum, param float32) { + C.gl1_5_glTexParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glScissor.xml +func (gl *GL) Scissor(x, y, width, height int) { + C.gl1_5_glScissor(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPolygonMode.xml +func (gl *GL) PolygonMode(face, mode glbase.Enum) { + C.gl1_5_glPolygonMode(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPointSize.xml +func (gl *GL) PointSize(size float32) { + C.gl1_5_glPointSize(gl.funcs, C.GLfloat(size)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLineWidth.xml +func (gl *GL) LineWidth(width float32) { + C.gl1_5_glLineWidth(gl.funcs, C.GLfloat(width)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glHint.xml +func (gl *GL) Hint(target, mode glbase.Enum) { + C.gl1_5_glHint(gl.funcs, C.GLenum(target), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFrontFace.xml +func (gl *GL) FrontFace(mode glbase.Enum) { + C.gl1_5_glFrontFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCullFace.xml +func (gl *GL) CullFace(mode glbase.Enum) { + C.gl1_5_glCullFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexubv.xml +func (gl *GL) Indexubv(c []uint8) { + C.gl1_5_glIndexubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexub.xml +func (gl *GL) Indexub(c uint8) { + C.gl1_5_glIndexub(gl.funcs, C.GLubyte(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsTexture.xml +func (gl *GL) IsTexture(texture glbase.Texture) bool { + glresult := C.gl1_5_glIsTexture(gl.funcs, C.GLuint(texture)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenTextures returns n texture names in textures. There is no guarantee +// that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenTextures. +// +// The generated textures have no dimensionality; they assume the +// dimensionality of the texture target to which they are first bound (see +// BindTexture). +// +// Texture names returned by a call to GenTextures are not returned by +// subsequent calls, unless they are first deleted with DeleteTextures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenTextures is available in GL version 2.0 or greater. +func (gl *GL) GenTextures(n int) []glbase.Texture { + if n == 0 { + return nil + } + textures := make([]glbase.Texture, n) + C.gl1_5_glGenTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) + return textures +} + +// DeleteTextures deletes the textures objects whose names are stored +// in the textures slice. After a texture is deleted, it has no contents or +// dimensionality, and its name is free for reuse (for example by +// GenTextures). If a texture that is currently bound is deleted, the binding +// reverts to 0 (the default texture). +// +// DeleteTextures silently ignores 0's and names that do not correspond to +// existing textures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteTextures is available in GL version 2.0 or greater. +func (gl *GL) DeleteTextures(textures []glbase.Texture) { + n := len(textures) + if n == 0 { + return + } + C.gl1_5_glDeleteTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBindTexture.xml +func (gl *GL) BindTexture(target glbase.Enum, texture glbase.Texture) { + C.gl1_5_glBindTexture(gl.funcs, C.GLenum(target), C.GLuint(texture)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexSubImage2D.xml +func (gl *GL) TexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexSubImage1D.xml +func (gl *GL) TexSubImage1D(target glbase.Enum, level, xoffset, width int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexSubImage2D.xml +func (gl *GL) CopyTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, x, y, width, height int) { + C.gl1_5_glCopyTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexSubImage1D.xml +func (gl *GL) CopyTexSubImage1D(target glbase.Enum, level, xoffset, x, y, width int) { + C.gl1_5_glCopyTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexImage2D.xml +func (gl *GL) CopyTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, height, border int) { + C.gl1_5_glCopyTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexImage1D.xml +func (gl *GL) CopyTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, border int) { + C.gl1_5_glCopyTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPolygonOffset.xml +func (gl *GL) PolygonOffset(factor, units float32) { + C.gl1_5_glPolygonOffset(gl.funcs, C.GLfloat(factor), C.GLfloat(units)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawElements.xml +func (gl *GL) DrawElements(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glDrawElements(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawArrays.xml +func (gl *GL) DrawArrays(mode glbase.Enum, first, count int) { + C.gl1_5_glDrawArrays(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexSubImage3D.xml +func (gl *GL) CopyTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, x, y, width, height int) { + C.gl1_5_glCopyTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexSubImage3D.xml +func (gl *GL) TexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexImage3D.xml +func (gl *GL) TexImage3D(target glbase.Enum, level int, internalFormat int32, width, height int, depth int32, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawRangeElements.xml +func (gl *GL) DrawRangeElements(mode glbase.Enum, start, end uint32, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glDrawRangeElements(gl.funcs, C.GLenum(mode), C.GLuint(start), C.GLuint(end), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBlendEquation.xml +func (gl *GL) BlendEquation(mode glbase.Enum) { + C.gl1_5_glBlendEquation(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBlendColor.xml +func (gl *GL) BlendColor(red, green, blue, alpha float32) { + C.gl1_5_glBlendColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetCompressedTexImage.xml +func (gl *GL) GetCompressedTexImage(target glbase.Enum, level int, img interface{}) { + var img_ptr unsafe.Pointer + var img_v = reflect.ValueOf(img) + if img != nil && img_v.Kind() != reflect.Slice { + panic("parameter img must be a slice") + } + if img != nil { + img_ptr = unsafe.Pointer(img_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glGetCompressedTexImage(gl.funcs, C.GLenum(target), C.GLint(level), img_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCompressedTexSubImage1D.xml +func (gl *GL) CompressedTexSubImage1D(target glbase.Enum, level, xoffset, width int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glCompressedTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCompressedTexSubImage2D.xml +func (gl *GL) CompressedTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glCompressedTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCompressedTexSubImage3D.xml +func (gl *GL) CompressedTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glCompressedTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCompressedTexImage1D.xml +func (gl *GL) CompressedTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, width, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glCompressedTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCompressedTexImage2D.xml +func (gl *GL) CompressedTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glCompressedTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCompressedTexImage3D.xml +func (gl *GL) CompressedTexImage3D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height int, depth int32, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glCompressedTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSampleCoverage.xml +func (gl *GL) SampleCoverage(value float32, invert bool) { + C.gl1_5_glSampleCoverage(gl.funcs, C.GLfloat(value), *(*C.GLboolean)(unsafe.Pointer(&invert))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glActiveTexture.xml +func (gl *GL) ActiveTexture(texture glbase.Enum) { + C.gl1_5_glActiveTexture(gl.funcs, C.GLenum(texture)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPointParameteriv.xml +func (gl *GL) PointParameteriv(pname glbase.Enum, params []int32) { + C.gl1_5_glPointParameteriv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPointParameteri.xml +func (gl *GL) PointParameteri(pname glbase.Enum, param int32) { + C.gl1_5_glPointParameteri(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPointParameterfv.xml +func (gl *GL) PointParameterfv(pname glbase.Enum, params []float32) { + C.gl1_5_glPointParameterfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPointParameterf.xml +func (gl *GL) PointParameterf(pname glbase.Enum, param float32) { + C.gl1_5_glPointParameterf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiDrawArrays.xml +func (gl *GL) MultiDrawArrays(mode glbase.Enum, first, count []int, drawcount int32) { + C.gl1_5_glMultiDrawArrays(gl.funcs, C.GLenum(mode), (*C.GLint)(unsafe.Pointer(&first[0])), (*C.GLsizei)(unsafe.Pointer(&count[0])), C.GLsizei(drawcount)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBlendFuncSeparate.xml +func (gl *GL) BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha glbase.Enum) { + C.gl1_5_glBlendFuncSeparate(gl.funcs, C.GLenum(sfactorRGB), C.GLenum(dfactorRGB), C.GLenum(sfactorAlpha), C.GLenum(dfactorAlpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetBufferParameteriv.xml +func (gl *GL) GetBufferParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_5_glGetBufferParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glUnmapBuffer.xml +func (gl *GL) UnmapBuffer(target glbase.Enum) bool { + glresult := C.gl1_5_glUnmapBuffer(gl.funcs, C.GLenum(target)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetBufferSubData.xml +func (gl *GL) GetBufferSubData(target glbase.Enum, offset, size int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glGetBufferSubData(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(size), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBufferSubData.xml +func (gl *GL) BufferSubData(target glbase.Enum, offset, size int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glBufferSubData(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(size), data_ptr) +} + +// BufferData creates a new data store for the buffer object currently +// bound to target. Any pre-existing data store is deleted. The new data +// store is created with the specified size in bytes and usage. If data is +// not nil, it must be a slice that is used to initialize the data store. +// In that case the size parameter is ignored and the store size will match +// the slice data size. +// +// In its initial state, the new data store is not mapped, it has a NULL +// mapped pointer, and its mapped access is GL.READ_WRITE. +// +// The target constant must be one of GL.ARRAY_BUFFER, GL.COPY_READ_BUFFER, +// GL.COPY_WRITE_BUFFER, GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER, +// GL.PIXEL_UNPACK_BUFFER, GL.TEXTURE_BUFFER, GL.TRANSFORM_FEEDBACK_BUFFER, +// or GL.UNIFORM_BUFFER. +// +// The usage parameter is a hint to the GL implementation as to how a buffer +// object's data store will be accessed. This enables the GL implementation +// to make more intelligent decisions that may significantly impact buffer +// object performance. It does not, however, constrain the actual usage of +// the data store. usage can be broken down into two parts: first, the +// frequency of access (modification and usage), and second, the nature of +// that access. +// +// A usage frequency of STREAM and nature of DRAW is specified via the +// constant GL.STREAM_DRAW, for example. +// +// The usage frequency of access may be one of: +// +// STREAM +// The data store contents will be modified once and used at most a few times. +// +// STATIC +// The data store contents will be modified once and used many times. +// +// DYNAMIC +// The data store contents will be modified repeatedly and used many times. +// +// The usage nature of access may be one of: +// +// DRAW +// The data store contents are modified by the application, and used as +// the source for GL drawing and image specification commands. +// +// READ +// The data store contents are modified by reading data from the GL, +// and used to return that data when queried by the application. +// +// COPY +// The data store contents are modified by reading data from the GL, +// and used as the source for GL drawing and image specification +// commands. +// +// Clients must align data elements consistent with the requirements of the +// client platform, with an additional base-level requirement that an offset +// within a buffer to a datum comprising N bytes be a multiple of N. +// +// Error GL.INVALID_ENUM is generated if target is not one of the accepted +// buffer targets. GL.INVALID_ENUM is generated if usage is not +// GL.STREAM_DRAW, GL.STREAM_READ, GL.STREAM_COPY, GL.STATIC_DRAW, +// GL.STATIC_READ, GL.STATIC_COPY, GL.DYNAMIC_DRAW, GL.DYNAMIC_READ, or +// GL.DYNAMIC_COPY. GL.INVALID_VALUE is generated if size is negative. +// GL.INVALID_OPERATION is generated if the reserved buffer object name 0 is +// bound to target. GL.OUT_OF_MEMORY is generated if the GL is unable to +// create a data store with the specified size. +func (gl *GL) BufferData(target glbase.Enum, size int, data interface{}, usage glbase.Enum) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + if data != nil { + size = int(data_v.Type().Size()) * data_v.Len() + } + C.gl1_5_glBufferData(gl.funcs, C.GLenum(target), C.GLsizeiptr(size), data_ptr, C.GLenum(usage)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsBuffer.xml +func (gl *GL) IsBuffer(buffer glbase.Buffer) bool { + glresult := C.gl1_5_glIsBuffer(gl.funcs, C.GLuint(buffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenBuffers returns n buffer object names. There is no guarantee that +// the names form a contiguous set of integers; however, it is guaranteed +// that none of the returned names was in use immediately before the call to +// GenBuffers. +// +// Buffer object names returned by a call to GenBuffers are not returned by +// subsequent calls, unless they are first deleted with DeleteBuffers. +// +// No buffer objects are associated with the returned buffer object names +// until they are first bound by calling BindBuffer. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if GenBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// GenBuffers is available in GL version 1.5 or greater. +func (gl *GL) GenBuffers(n int) []glbase.Buffer { + if n == 0 { + return nil + } + buffers := make([]glbase.Buffer, n) + C.gl1_5_glGenBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) + return buffers +} + +// DeleteBuffers deletes the buffer objects whose names are stored in the +// buffers slice. +// +// After a buffer object is deleted, it has no contents, and its name is free +// for reuse (for example by GenBuffers). If a buffer object that is +// currently bound is deleted, the binding reverts to 0 (the absence of any +// buffer object, which reverts to client memory usage). +// +// DeleteBuffers silently ignores 0's and names that do not correspond to +// existing buffer objects. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if DeleteBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// DeleteBuffers is available in GL version 1.5 or greater. +func (gl *GL) DeleteBuffers(buffers []glbase.Buffer) { + n := len(buffers) + if n == 0 { + return + } + C.gl1_5_glDeleteBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) +} + +// BindBuffer creates or puts in use a named buffer object. +// Calling BindBuffer with target set to GL.ARRAY_BUFFER, +// GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER or GL.PIXEL_UNPACK_BUFFER +// and buffer set to the name of the new buffer object binds the buffer +// object name to the target. When a buffer object is bound to a target, the +// previous binding for that target is automatically broken. +// +// Buffer object names are unsigned integers. The value zero is reserved, but +// there is no default buffer object for each buffer object target. Instead, +// buffer set to zero effectively unbinds any buffer object previously bound, +// and restores client memory usage for that buffer object target. Buffer +// object names and the corresponding buffer object contents are local to the +// shared display-list space (see XCreateContext) of the current GL rendering +// context; two rendering contexts share buffer object names only if they +// also share display lists. +// +// GenBuffers may be called to generate a set of new buffer object names. +// +// The state of a buffer object immediately after it is first bound is an +// unmapped zero-sized memory buffer with GL.READ_WRITE access and +// GL.STATIC_DRAW usage. +// +// While a non-zero buffer object name is bound, GL operations on the target +// to which it is bound affect the bound buffer object, and queries of the +// target to which it is bound return state from the bound buffer object. +// While buffer object name zero is bound, as in the initial state, attempts +// to modify or query state on the target to which it is bound generates an +// GL.INVALID_OPERATION error. +// +// When vertex array pointer state is changed, for example by a call to +// NormalPointer, the current buffer object binding (GL.ARRAY_BUFFER_BINDING) +// is copied into the corresponding client state for the vertex array type +// being changed, for example GL.NORMAL_ARRAY_BUFFER_BINDING. While a +// non-zero buffer object is bound to the GL.ARRAY_BUFFER target, the vertex +// array pointer parameter that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.ELEMENT_ARRAY_BUFFER +// target, the indices parameter of DrawElements, DrawRangeElements, or +// MultiDrawElements that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_PACK_BUFFER +// target, the following commands are affected: GetCompressedTexImage, +// GetConvolutionFilter, GetHistogram, GetMinmax, GetPixelMap, +// GetPolygonStipple, GetSeparableFilter, GetTexImage, and ReadPixels. The +// pointer parameter that is traditionally interpreted as a pointer to +// client-side memory where the pixels are to be packed is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_UNPACK_BUFFER +// target, the following commands are affected: Bitmap, ColorSubTable, +// ColorTable, CompressedTexImage1D, CompressedTexImage2D, +// CompressedTexImage3D, CompressedTexSubImage1D, CompressedTexSubImage2D, +// CompressedTexSubImage3D, ConvolutionFilter1D, ConvolutionFilter2D, +// DrawPixels, PixelMap, PolygonStipple, SeparableFilter2D, TexImage1D, +// TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, and TexSubImage3D. +// The pointer parameter that is traditionally interpreted as a pointer to +// client-side memory from which the pixels are to be unpacked is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// A buffer object binding created with BindBuffer remains active until a +// different buffer object name is bound to the same target, or until the +// bound buffer object is deleted with DeleteBuffers. +// +// Once created, a named buffer object may be re-bound to any target as often +// as needed. However, the GL implementation may make choices about how to +// optimize the storage of a buffer object based on its initial binding +// target. +// +// Error GL.INVALID_ENUM is generated if target is not one of the allowable +// values. GL.INVALID_OPERATION is generated if BindBuffer is executed +// between the execution of Begin and the corresponding execution of End. +// +// BindBuffer is available in GL version 1.5 or greater. +func (gl *GL) BindBuffer(target glbase.Enum, buffer glbase.Buffer) { + C.gl1_5_glBindBuffer(gl.funcs, C.GLenum(target), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetQueryObjectuiv.xml +func (gl *GL) GetQueryObjectuiv(id uint32, pname glbase.Enum, params []uint32) { + C.gl1_5_glGetQueryObjectuiv(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetQueryObjectiv.xml +func (gl *GL) GetQueryObjectiv(id uint32, pname glbase.Enum, params []int32) { + C.gl1_5_glGetQueryObjectiv(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetQueryiv.xml +func (gl *GL) GetQueryiv(target, pname glbase.Enum, params []int32) { + C.gl1_5_glGetQueryiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEndQuery.xml +func (gl *GL) EndQuery(target glbase.Enum) { + C.gl1_5_glEndQuery(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBeginQuery.xml +func (gl *GL) BeginQuery(target glbase.Enum, id uint32) { + C.gl1_5_glBeginQuery(gl.funcs, C.GLenum(target), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsQuery.xml +func (gl *GL) IsQuery(id uint32) bool { + glresult := C.gl1_5_glIsQuery(gl.funcs, C.GLuint(id)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDeleteQueries.xml +func (gl *GL) DeleteQueries(n int, ids []uint32) { + C.gl1_5_glDeleteQueries(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGenQueries.xml +func (gl *GL) GenQueries(n int, ids []uint32) { + C.gl1_5_glGenQueries(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTranslatef.xml +func (gl *GL) Translatef(x, y, z float32) { + C.gl1_5_glTranslatef(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTranslated.xml +func (gl *GL) Translated(x, y, z float64) { + C.gl1_5_glTranslated(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glScalef.xml +func (gl *GL) Scalef(x, y, z float32) { + C.gl1_5_glScalef(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glScaled.xml +func (gl *GL) Scaled(x, y, z float64) { + C.gl1_5_glScaled(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRotatef.xml +func (gl *GL) Rotatef(angle, x, y, z float32) { + C.gl1_5_glRotatef(gl.funcs, C.GLfloat(angle), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRotated.xml +func (gl *GL) Rotated(angle, x, y, z float64) { + C.gl1_5_glRotated(gl.funcs, C.GLdouble(angle), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPushMatrix.xml +func (gl *GL) PushMatrix() { + C.gl1_5_glPushMatrix(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPopMatrix.xml +func (gl *GL) PopMatrix() { + C.gl1_5_glPopMatrix(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glOrtho.xml +func (gl *GL) Ortho(left, right, bottom, top, zNear, zFar float64) { + C.gl1_5_glOrtho(gl.funcs, C.GLdouble(left), C.GLdouble(right), C.GLdouble(bottom), C.GLdouble(top), C.GLdouble(zNear), C.GLdouble(zFar)) +} + +// MultMatrixd multiplies the current matrix with the provided matrix. +// +// The m parameter must hold 16 consecutive elements of a 4x4 column-major matrix. +// +// The current matrix is determined by the current matrix mode (see +// MatrixMode). It is either the projection matrix, modelview matrix, or the +// texture matrix. +// +// For example, if the current matrix is C and the coordinates to be transformed +// are v = (v[0], v[1], v[2], v[3]), then the current transformation is C × v, or +// +// c[0] c[4] c[8] c[12] v[0] +// c[1] c[5] c[9] c[13] v[1] +// c[2] c[6] c[10] c[14] X v[2] +// c[3] c[7] c[11] c[15] v[3] +// +// Calling MultMatrix with an argument of m = m[0], m[1], ..., m[15] +// replaces the current transformation with (C X M) x v, or +// +// c[0] c[4] c[8] c[12] m[0] m[4] m[8] m[12] v[0] +// c[1] c[5] c[9] c[13] m[1] m[5] m[9] m[13] v[1] +// c[2] c[6] c[10] c[14] X m[2] m[6] m[10] m[14] X v[2] +// c[3] c[7] c[11] c[15] m[3] m[7] m[11] m[15] v[3] +// +// Where 'X' denotes matrix multiplication, and v is represented as a 4x1 matrix. +// +// While the elements of the matrix may be specified with single or double +// precision, the GL may store or operate on these values in less-than-single +// precision. +// +// In many computer languages, 4×4 arrays are represented in row-major +// order. The transformations just described represent these matrices in +// column-major order. The order of the multiplication is important. For +// example, if the current transformation is a rotation, and MultMatrix is +// called with a translation matrix, the translation is done directly on the +// coordinates to be transformed, while the rotation is done on the results +// of that translation. +// +// GL.INVALID_OPERATION is generated if MultMatrix is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) MultMatrixd(m []float64) { + if len(m) != 16 { + panic("parameter m must have length 16 for the 4x4 matrix") + } + C.gl1_5_glMultMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// MultMatrixf multiplies the current matrix with the provided matrix. +// +// The m parameter must hold 16 consecutive elements of a 4x4 column-major matrix. +// +// The current matrix is determined by the current matrix mode (see +// MatrixMode). It is either the projection matrix, modelview matrix, or the +// texture matrix. +// +// For example, if the current matrix is C and the coordinates to be transformed +// are v = (v[0], v[1], v[2], v[3]), then the current transformation is C × v, or +// +// c[0] c[4] c[8] c[12] v[0] +// c[1] c[5] c[9] c[13] v[1] +// c[2] c[6] c[10] c[14] X v[2] +// c[3] c[7] c[11] c[15] v[3] +// +// Calling MultMatrix with an argument of m = m[0], m[1], ..., m[15] +// replaces the current transformation with (C X M) x v, or +// +// c[0] c[4] c[8] c[12] m[0] m[4] m[8] m[12] v[0] +// c[1] c[5] c[9] c[13] m[1] m[5] m[9] m[13] v[1] +// c[2] c[6] c[10] c[14] X m[2] m[6] m[10] m[14] X v[2] +// c[3] c[7] c[11] c[15] m[3] m[7] m[11] m[15] v[3] +// +// Where 'X' denotes matrix multiplication, and v is represented as a 4x1 matrix. +// +// While the elements of the matrix may be specified with single or double +// precision, the GL may store or operate on these values in less-than-single +// precision. +// +// In many computer languages, 4×4 arrays are represented in row-major +// order. The transformations just described represent these matrices in +// column-major order. The order of the multiplication is important. For +// example, if the current transformation is a rotation, and MultMatrix is +// called with a translation matrix, the translation is done directly on the +// coordinates to be transformed, while the rotation is done on the results +// of that translation. +// +// GL.INVALID_OPERATION is generated if MultMatrix is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) MultMatrixf(m []float32) { + if len(m) != 16 { + panic("parameter m must have length 16 for the 4x4 matrix") + } + C.gl1_5_glMultMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMatrixMode.xml +func (gl *GL) MatrixMode(mode glbase.Enum) { + C.gl1_5_glMatrixMode(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadMatrixd.xml +func (gl *GL) LoadMatrixd(m []float64) { + C.gl1_5_glLoadMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadMatrixf.xml +func (gl *GL) LoadMatrixf(m []float32) { + C.gl1_5_glLoadMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadIdentity.xml +func (gl *GL) LoadIdentity() { + C.gl1_5_glLoadIdentity(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFrustum.xml +func (gl *GL) Frustum(left, right, bottom, top, zNear, zFar float64) { + C.gl1_5_glFrustum(gl.funcs, C.GLdouble(left), C.GLdouble(right), C.GLdouble(bottom), C.GLdouble(top), C.GLdouble(zNear), C.GLdouble(zFar)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsList.xml +func (gl *GL) IsList(list uint32) bool { + glresult := C.gl1_5_glIsList(gl.funcs, C.GLuint(list)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexGeniv.xml +func (gl *GL) GetTexGeniv(coord, pname glbase.Enum, params []int32) { + C.gl1_5_glGetTexGeniv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexGenfv.xml +func (gl *GL) GetTexGenfv(coord, pname glbase.Enum, params []float32) { + C.gl1_5_glGetTexGenfv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexGendv.xml +func (gl *GL) GetTexGendv(coord, pname glbase.Enum, params []float64) { + C.gl1_5_glGetTexGendv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexEnviv.xml +func (gl *GL) GetTexEnviv(target, pname glbase.Enum, params []int32) { + C.gl1_5_glGetTexEnviv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexEnvfv.xml +func (gl *GL) GetTexEnvfv(target, pname glbase.Enum, params []float32) { + C.gl1_5_glGetTexEnvfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetPolygonStipple.xml +func (gl *GL) GetPolygonStipple(mask []uint8) { + C.gl1_5_glGetPolygonStipple(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&mask[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetPixelMapusv.xml +func (gl *GL) GetPixelMapusv(glmap glbase.Enum, values []uint16) { + C.gl1_5_glGetPixelMapusv(gl.funcs, C.GLenum(glmap), (*C.GLushort)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetPixelMapuiv.xml +func (gl *GL) GetPixelMapuiv(glmap glbase.Enum, values []uint32) { + C.gl1_5_glGetPixelMapuiv(gl.funcs, C.GLenum(glmap), (*C.GLuint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetPixelMapfv.xml +func (gl *GL) GetPixelMapfv(glmap glbase.Enum, values []float32) { + C.gl1_5_glGetPixelMapfv(gl.funcs, C.GLenum(glmap), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMaterialiv.xml +func (gl *GL) GetMaterialiv(face, pname glbase.Enum, params []int32) { + C.gl1_5_glGetMaterialiv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMaterialfv.xml +func (gl *GL) GetMaterialfv(face, pname glbase.Enum, params []float32) { + C.gl1_5_glGetMaterialfv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMapiv.xml +func (gl *GL) GetMapiv(target, query glbase.Enum, v []int32) { + C.gl1_5_glGetMapiv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMapfv.xml +func (gl *GL) GetMapfv(target, query glbase.Enum, v []float32) { + C.gl1_5_glGetMapfv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMapdv.xml +func (gl *GL) GetMapdv(target, query glbase.Enum, v []float64) { + C.gl1_5_glGetMapdv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetLightiv.xml +func (gl *GL) GetLightiv(light, pname glbase.Enum, params []int32) { + C.gl1_5_glGetLightiv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetLightfv.xml +func (gl *GL) GetLightfv(light, pname glbase.Enum, params []float32) { + C.gl1_5_glGetLightfv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetClipPlane.xml +func (gl *GL) GetClipPlane(plane glbase.Enum, equation []float64) { + C.gl1_5_glGetClipPlane(gl.funcs, C.GLenum(plane), (*C.GLdouble)(unsafe.Pointer(&equation[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawPixels.xml +func (gl *GL) DrawPixels(width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glDrawPixels(gl.funcs, C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyPixels.xml +func (gl *GL) CopyPixels(x, y, width, height int, gltype glbase.Enum) { + C.gl1_5_glCopyPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(gltype)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelMapusv.xml +func (gl *GL) PixelMapusv(glmap glbase.Enum, mapsize int32, values []uint16) { + C.gl1_5_glPixelMapusv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLushort)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelMapuiv.xml +func (gl *GL) PixelMapuiv(glmap glbase.Enum, mapsize int32, values []uint32) { + C.gl1_5_glPixelMapuiv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLuint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelMapfv.xml +func (gl *GL) PixelMapfv(glmap glbase.Enum, mapsize int32, values []float32) { + C.gl1_5_glPixelMapfv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelTransferi.xml +func (gl *GL) PixelTransferi(pname glbase.Enum, param int32) { + C.gl1_5_glPixelTransferi(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelTransferf.xml +func (gl *GL) PixelTransferf(pname glbase.Enum, param float32) { + C.gl1_5_glPixelTransferf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelZoom.xml +func (gl *GL) PixelZoom(xfactor, yfactor float32) { + C.gl1_5_glPixelZoom(gl.funcs, C.GLfloat(xfactor), C.GLfloat(yfactor)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glAlphaFunc.xml +func (gl *GL) AlphaFunc(glfunc glbase.Enum, ref float32) { + C.gl1_5_glAlphaFunc(gl.funcs, C.GLenum(glfunc), C.GLfloat(ref)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalPoint2.xml +func (gl *GL) EvalPoint2(i, j int32) { + C.gl1_5_glEvalPoint2(gl.funcs, C.GLint(i), C.GLint(j)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalMesh2.xml +func (gl *GL) EvalMesh2(mode glbase.Enum, i1, i2, j1, j2 int32) { + C.gl1_5_glEvalMesh2(gl.funcs, C.GLenum(mode), C.GLint(i1), C.GLint(i2), C.GLint(j1), C.GLint(j2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalPoint1.xml +func (gl *GL) EvalPoint1(i int32) { + C.gl1_5_glEvalPoint1(gl.funcs, C.GLint(i)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalMesh1.xml +func (gl *GL) EvalMesh1(mode glbase.Enum, i1, i2 int32) { + C.gl1_5_glEvalMesh1(gl.funcs, C.GLenum(mode), C.GLint(i1), C.GLint(i2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord2fv.xml +func (gl *GL) EvalCoord2fv(u []float32) { + if len(u) != 2 { + panic("parameter u has incorrect length") + } + C.gl1_5_glEvalCoord2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord2f.xml +func (gl *GL) EvalCoord2f(u, v float32) { + C.gl1_5_glEvalCoord2f(gl.funcs, C.GLfloat(u), C.GLfloat(v)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord2dv.xml +func (gl *GL) EvalCoord2dv(u []float64) { + if len(u) != 2 { + panic("parameter u has incorrect length") + } + C.gl1_5_glEvalCoord2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord2d.xml +func (gl *GL) EvalCoord2d(u, v float64) { + C.gl1_5_glEvalCoord2d(gl.funcs, C.GLdouble(u), C.GLdouble(v)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord1fv.xml +func (gl *GL) EvalCoord1fv(u []float32) { + C.gl1_5_glEvalCoord1fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord1f.xml +func (gl *GL) EvalCoord1f(u float32) { + C.gl1_5_glEvalCoord1f(gl.funcs, C.GLfloat(u)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord1dv.xml +func (gl *GL) EvalCoord1dv(u []float64) { + C.gl1_5_glEvalCoord1dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord1d.xml +func (gl *GL) EvalCoord1d(u float64) { + C.gl1_5_glEvalCoord1d(gl.funcs, C.GLdouble(u)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMapGrid2f.xml +func (gl *GL) MapGrid2f(un int32, u1, u2 float32, vn int32, v1, v2 float32) { + C.gl1_5_glMapGrid2f(gl.funcs, C.GLint(un), C.GLfloat(u1), C.GLfloat(u2), C.GLint(vn), C.GLfloat(v1), C.GLfloat(v2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMapGrid2d.xml +func (gl *GL) MapGrid2d(un int32, u1, u2 float64, vn int32, v1, v2 float64) { + C.gl1_5_glMapGrid2d(gl.funcs, C.GLint(un), C.GLdouble(u1), C.GLdouble(u2), C.GLint(vn), C.GLdouble(v1), C.GLdouble(v2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMapGrid1f.xml +func (gl *GL) MapGrid1f(un int32, u1, u2 float32) { + C.gl1_5_glMapGrid1f(gl.funcs, C.GLint(un), C.GLfloat(u1), C.GLfloat(u2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMapGrid1d.xml +func (gl *GL) MapGrid1d(un int32, u1, u2 float64) { + C.gl1_5_glMapGrid1d(gl.funcs, C.GLint(un), C.GLdouble(u1), C.GLdouble(u2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMap2f.xml +func (gl *GL) Map2f(target glbase.Enum, u1, u2 float32, ustride, uorder int32, v1, v2 float32, vstride, vorder int32, points []float32) { + C.gl1_5_glMap2f(gl.funcs, C.GLenum(target), C.GLfloat(u1), C.GLfloat(u2), C.GLint(ustride), C.GLint(uorder), C.GLfloat(v1), C.GLfloat(v2), C.GLint(vstride), C.GLint(vorder), (*C.GLfloat)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMap2d.xml +func (gl *GL) Map2d(target glbase.Enum, u1, u2 float64, ustride, uorder int32, v1, v2 float64, vstride, vorder int32, points []float64) { + C.gl1_5_glMap2d(gl.funcs, C.GLenum(target), C.GLdouble(u1), C.GLdouble(u2), C.GLint(ustride), C.GLint(uorder), C.GLdouble(v1), C.GLdouble(v2), C.GLint(vstride), C.GLint(vorder), (*C.GLdouble)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMap1f.xml +func (gl *GL) Map1f(target glbase.Enum, u1, u2 float32, stride, order int, points []float32) { + C.gl1_5_glMap1f(gl.funcs, C.GLenum(target), C.GLfloat(u1), C.GLfloat(u2), C.GLint(stride), C.GLint(order), (*C.GLfloat)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMap1d.xml +func (gl *GL) Map1d(target glbase.Enum, u1, u2 float64, stride, order int, points []float64) { + C.gl1_5_glMap1d(gl.funcs, C.GLenum(target), C.GLdouble(u1), C.GLdouble(u2), C.GLint(stride), C.GLint(order), (*C.GLdouble)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPushAttrib.xml +func (gl *GL) PushAttrib(mask glbase.Bitfield) { + C.gl1_5_glPushAttrib(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPopAttrib.xml +func (gl *GL) PopAttrib() { + C.gl1_5_glPopAttrib(gl.funcs) +} + +// Accum executes an operation on the accumulation buffer. +// +// Parameter op defines the accumulation buffer operation (GL.ACCUM, GL.LOAD, +// GL.ADD, GL.MULT, or GL.RETURN) and specifies how the value parameter is +// used. +// +// The accumulation buffer is an extended-range color buffer. Images are not +// rendered into it. Rather, images rendered into one of the color buffers +// are added to the contents of the accumulation buffer after rendering. +// Effects such as antialiasing (of points, lines, and polygons), motion +// blur, and depth of field can be created by accumulating images generated +// with different transformation matrices. +// +// Each pixel in the accumulation buffer consists of red, green, blue, and +// alpha values. The number of bits per component in the accumulation buffer +// depends on the implementation. You can examine this number by calling +// GetIntegerv four times, with arguments GL.ACCUM_RED_BITS, +// GL.ACCUM_GREEN_BITS, GL.ACCUM_BLUE_BITS, and GL.ACCUM_ALPHA_BITS. +// Regardless of the number of bits per component, the range of values stored +// by each component is (-1, 1). The accumulation buffer pixels are mapped +// one-to-one with frame buffer pixels. +// +// All accumulation buffer operations are limited to the area of the current +// scissor box and applied identically to the red, green, blue, and alpha +// components of each pixel. If a Accum operation results in a value outside +// the range (-1, 1), the contents of an accumulation buffer pixel component +// are undefined. +// +// The operations are as follows: +// +// GL.ACCUM +// Obtains R, G, B, and A values from the buffer currently selected for +// reading (see ReadBuffer). Each component value is divided by 2 n - +// 1 , where n is the number of bits allocated to each color component +// in the currently selected buffer. The result is a floating-point +// value in the range 0 1 , which is multiplied by value and added to +// the corresponding pixel component in the accumulation buffer, +// thereby updating the accumulation buffer. +// +// GL.LOAD +// Similar to GL.ACCUM, except that the current value in the +// accumulation buffer is not used in the calculation of the new value. +// That is, the R, G, B, and A values from the currently selected +// buffer are divided by 2 n - 1 , multiplied by value, and then stored +// in the corresponding accumulation buffer cell, overwriting the +// current value. +// +// GL.ADD +// Adds value to each R, G, B, and A in the accumulation buffer. +// +// GL.MULT +// Multiplies each R, G, B, and A in the accumulation buffer by value +// and returns the scaled component to its corresponding accumulation +// buffer location. +// +// GL.RETURN +// Transfers accumulation buffer values to the color buffer or buffers +// currently selected for writing. Each R, G, B, and A component is +// multiplied by value, then multiplied by 2 n - 1 , clamped to the +// range 0 2 n - 1 , and stored in the corresponding display buffer +// cell. The only fragment operations that are applied to this transfer +// are pixel ownership, scissor, dithering, and color writemasks. +// +// To clear the accumulation buffer, call ClearAccum with R, G, B, and A +// values to set it to, then call Clear with the accumulation buffer +// enabled. +// +// Error GL.INVALID_ENUM is generated if op is not an accepted value. +// GL.INVALID_OPERATION is generated if there is no accumulation buffer. +// GL.INVALID_OPERATION is generated if Accum is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) Accum(op glbase.Enum, value float32) { + C.gl1_5_glAccum(gl.funcs, C.GLenum(op), C.GLfloat(value)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexMask.xml +func (gl *GL) IndexMask(mask uint32) { + C.gl1_5_glIndexMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearIndex.xml +func (gl *GL) ClearIndex(c float32) { + C.gl1_5_glClearIndex(gl.funcs, C.GLfloat(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearAccum.xml +func (gl *GL) ClearAccum(red, green, blue, alpha float32) { + C.gl1_5_glClearAccum(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPushName.xml +func (gl *GL) PushName(name uint32) { + C.gl1_5_glPushName(gl.funcs, C.GLuint(name)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPopName.xml +func (gl *GL) PopName() { + C.gl1_5_glPopName(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPassThrough.xml +func (gl *GL) PassThrough(token float32) { + C.gl1_5_glPassThrough(gl.funcs, C.GLfloat(token)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadName.xml +func (gl *GL) LoadName(name uint32) { + C.gl1_5_glLoadName(gl.funcs, C.GLuint(name)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glInitNames.xml +func (gl *GL) InitNames() { + C.gl1_5_glInitNames(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRenderMode.xml +func (gl *GL) RenderMode(mode glbase.Enum) int32 { + glresult := C.gl1_5_glRenderMode(gl.funcs, C.GLenum(mode)) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSelectBuffer.xml +func (gl *GL) SelectBuffer(size int, buffer []glbase.Buffer) { + C.gl1_5_glSelectBuffer(gl.funcs, C.GLsizei(size), (*C.GLuint)(unsafe.Pointer(&buffer[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFeedbackBuffer.xml +func (gl *GL) FeedbackBuffer(size int, gltype glbase.Enum, buffer []float32) { + C.gl1_5_glFeedbackBuffer(gl.funcs, C.GLsizei(size), C.GLenum(gltype), (*C.GLfloat)(unsafe.Pointer(&buffer[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGeniv.xml +func (gl *GL) TexGeniv(coord, pname glbase.Enum, params []int32) { + C.gl1_5_glTexGeniv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGeni.xml +func (gl *GL) TexGeni(coord, pname glbase.Enum, param int32) { + C.gl1_5_glTexGeni(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGenfv.xml +func (gl *GL) TexGenfv(coord, pname glbase.Enum, params []float32) { + C.gl1_5_glTexGenfv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGenf.xml +func (gl *GL) TexGenf(coord, pname glbase.Enum, param float32) { + C.gl1_5_glTexGenf(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGendv.xml +func (gl *GL) TexGendv(coord, pname glbase.Enum, params []float64) { + C.gl1_5_glTexGendv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGend.xml +func (gl *GL) TexGend(coord, pname glbase.Enum, param float64) { + C.gl1_5_glTexGend(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLdouble(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnviv.xml +func (gl *GL) TexEnviv(target, pname glbase.Enum, params []int32) { + C.gl1_5_glTexEnviv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnvi.xml +func (gl *GL) TexEnvi(target, pname glbase.Enum, param int32) { + C.gl1_5_glTexEnvi(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnvfv.xml +func (gl *GL) TexEnvfv(target, pname glbase.Enum, params []float32) { + C.gl1_5_glTexEnvfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnvf.xml +func (gl *GL) TexEnvf(target, pname glbase.Enum, param float32) { + C.gl1_5_glTexEnvf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glShadeModel.xml +func (gl *GL) ShadeModel(mode glbase.Enum) { + C.gl1_5_glShadeModel(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPolygonStipple.xml +func (gl *GL) PolygonStipple(mask []uint8) { + C.gl1_5_glPolygonStipple(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&mask[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMaterialiv.xml +func (gl *GL) Materialiv(face, pname glbase.Enum, params []int32) { + C.gl1_5_glMaterialiv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMateriali.xml +func (gl *GL) Materiali(face, pname glbase.Enum, param int32) { + C.gl1_5_glMateriali(gl.funcs, C.GLenum(face), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMaterialfv.xml +func (gl *GL) Materialfv(face, pname glbase.Enum, params []float32) { + C.gl1_5_glMaterialfv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMaterialf.xml +func (gl *GL) Materialf(face, pname glbase.Enum, param float32) { + C.gl1_5_glMaterialf(gl.funcs, C.GLenum(face), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLineStipple.xml +func (gl *GL) LineStipple(factor int32, pattern uint16) { + C.gl1_5_glLineStipple(gl.funcs, C.GLint(factor), C.GLushort(pattern)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightModeliv.xml +func (gl *GL) LightModeliv(pname glbase.Enum, params []int32) { + C.gl1_5_glLightModeliv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightModeli.xml +func (gl *GL) LightModeli(pname glbase.Enum, param int32) { + C.gl1_5_glLightModeli(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightModelfv.xml +func (gl *GL) LightModelfv(pname glbase.Enum, params []float32) { + C.gl1_5_glLightModelfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightModelf.xml +func (gl *GL) LightModelf(pname glbase.Enum, param float32) { + C.gl1_5_glLightModelf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightiv.xml +func (gl *GL) Lightiv(light, pname glbase.Enum, params []int32) { + C.gl1_5_glLightiv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLighti.xml +func (gl *GL) Lighti(light, pname glbase.Enum, param int32) { + C.gl1_5_glLighti(gl.funcs, C.GLenum(light), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightfv.xml +func (gl *GL) Lightfv(light, pname glbase.Enum, params []float32) { + C.gl1_5_glLightfv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightf.xml +func (gl *GL) Lightf(light, pname glbase.Enum, param float32) { + C.gl1_5_glLightf(gl.funcs, C.GLenum(light), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogiv.xml +func (gl *GL) Fogiv(pname glbase.Enum, params []int32) { + C.gl1_5_glFogiv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogi.xml +func (gl *GL) Fogi(pname glbase.Enum, param int32) { + C.gl1_5_glFogi(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogfv.xml +func (gl *GL) Fogfv(pname glbase.Enum, params []float32) { + C.gl1_5_glFogfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogf.xml +func (gl *GL) Fogf(pname glbase.Enum, param float32) { + C.gl1_5_glFogf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorMaterial.xml +func (gl *GL) ColorMaterial(face, mode glbase.Enum) { + C.gl1_5_glColorMaterial(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClipPlane.xml +func (gl *GL) ClipPlane(plane glbase.Enum, equation []float64) { + C.gl1_5_glClipPlane(gl.funcs, C.GLenum(plane), (*C.GLdouble)(unsafe.Pointer(&equation[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4sv.xml +func (gl *GL) Vertex4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_5_glVertex4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4s.xml +func (gl *GL) Vertex4s(x, y, z, w int16) { + C.gl1_5_glVertex4s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4iv.xml +func (gl *GL) Vertex4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_5_glVertex4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4i.xml +func (gl *GL) Vertex4i(x, y, z, w int) { + C.gl1_5_glVertex4i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4fv.xml +func (gl *GL) Vertex4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_5_glVertex4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4f.xml +func (gl *GL) Vertex4f(x, y, z, w float32) { + C.gl1_5_glVertex4f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4dv.xml +func (gl *GL) Vertex4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_5_glVertex4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4d.xml +func (gl *GL) Vertex4d(x, y, z, w float64) { + C.gl1_5_glVertex4d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3sv.xml +func (gl *GL) Vertex3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_5_glVertex3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3s.xml +func (gl *GL) Vertex3s(x, y, z int16) { + C.gl1_5_glVertex3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3iv.xml +func (gl *GL) Vertex3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_5_glVertex3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3i.xml +func (gl *GL) Vertex3i(x, y, z int) { + C.gl1_5_glVertex3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3fv.xml +func (gl *GL) Vertex3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_5_glVertex3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3f.xml +func (gl *GL) Vertex3f(x, y, z float32) { + C.gl1_5_glVertex3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3dv.xml +func (gl *GL) Vertex3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_5_glVertex3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3d.xml +func (gl *GL) Vertex3d(x, y, z float64) { + C.gl1_5_glVertex3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2sv.xml +func (gl *GL) Vertex2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_5_glVertex2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2s.xml +func (gl *GL) Vertex2s(x, y int16) { + C.gl1_5_glVertex2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2iv.xml +func (gl *GL) Vertex2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_5_glVertex2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2i.xml +func (gl *GL) Vertex2i(x, y int) { + C.gl1_5_glVertex2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2fv.xml +func (gl *GL) Vertex2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_5_glVertex2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2f.xml +func (gl *GL) Vertex2f(x, y float32) { + C.gl1_5_glVertex2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2dv.xml +func (gl *GL) Vertex2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_5_glVertex2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2d.xml +func (gl *GL) Vertex2d(x, y float64) { + C.gl1_5_glVertex2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4sv.xml +func (gl *GL) TexCoord4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_5_glTexCoord4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4s.xml +func (gl *GL) TexCoord4s(s, t, r, q int16) { + C.gl1_5_glTexCoord4s(gl.funcs, C.GLshort(s), C.GLshort(t), C.GLshort(r), C.GLshort(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4iv.xml +func (gl *GL) TexCoord4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_5_glTexCoord4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4i.xml +func (gl *GL) TexCoord4i(s, t, r, q int32) { + C.gl1_5_glTexCoord4i(gl.funcs, C.GLint(s), C.GLint(t), C.GLint(r), C.GLint(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4fv.xml +func (gl *GL) TexCoord4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_5_glTexCoord4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4f.xml +func (gl *GL) TexCoord4f(s, t, r, q float32) { + C.gl1_5_glTexCoord4f(gl.funcs, C.GLfloat(s), C.GLfloat(t), C.GLfloat(r), C.GLfloat(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4dv.xml +func (gl *GL) TexCoord4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_5_glTexCoord4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4d.xml +func (gl *GL) TexCoord4d(s, t, r, q float64) { + C.gl1_5_glTexCoord4d(gl.funcs, C.GLdouble(s), C.GLdouble(t), C.GLdouble(r), C.GLdouble(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3sv.xml +func (gl *GL) TexCoord3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_5_glTexCoord3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3s.xml +func (gl *GL) TexCoord3s(s, t, r int16) { + C.gl1_5_glTexCoord3s(gl.funcs, C.GLshort(s), C.GLshort(t), C.GLshort(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3iv.xml +func (gl *GL) TexCoord3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_5_glTexCoord3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3i.xml +func (gl *GL) TexCoord3i(s, t, r int32) { + C.gl1_5_glTexCoord3i(gl.funcs, C.GLint(s), C.GLint(t), C.GLint(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3fv.xml +func (gl *GL) TexCoord3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_5_glTexCoord3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3f.xml +func (gl *GL) TexCoord3f(s, t, r float32) { + C.gl1_5_glTexCoord3f(gl.funcs, C.GLfloat(s), C.GLfloat(t), C.GLfloat(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3dv.xml +func (gl *GL) TexCoord3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_5_glTexCoord3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3d.xml +func (gl *GL) TexCoord3d(s, t, r float64) { + C.gl1_5_glTexCoord3d(gl.funcs, C.GLdouble(s), C.GLdouble(t), C.GLdouble(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2sv.xml +func (gl *GL) TexCoord2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_5_glTexCoord2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2s.xml +func (gl *GL) TexCoord2s(s, t int16) { + C.gl1_5_glTexCoord2s(gl.funcs, C.GLshort(s), C.GLshort(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2iv.xml +func (gl *GL) TexCoord2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_5_glTexCoord2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2i.xml +func (gl *GL) TexCoord2i(s, t int32) { + C.gl1_5_glTexCoord2i(gl.funcs, C.GLint(s), C.GLint(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2fv.xml +func (gl *GL) TexCoord2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_5_glTexCoord2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2f.xml +func (gl *GL) TexCoord2f(s, t float32) { + C.gl1_5_glTexCoord2f(gl.funcs, C.GLfloat(s), C.GLfloat(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2dv.xml +func (gl *GL) TexCoord2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_5_glTexCoord2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2d.xml +func (gl *GL) TexCoord2d(s, t float64) { + C.gl1_5_glTexCoord2d(gl.funcs, C.GLdouble(s), C.GLdouble(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1sv.xml +func (gl *GL) TexCoord1sv(v []int16) { + C.gl1_5_glTexCoord1sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1s.xml +func (gl *GL) TexCoord1s(s int16) { + C.gl1_5_glTexCoord1s(gl.funcs, C.GLshort(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1iv.xml +func (gl *GL) TexCoord1iv(v []int32) { + C.gl1_5_glTexCoord1iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1i.xml +func (gl *GL) TexCoord1i(s int32) { + C.gl1_5_glTexCoord1i(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1fv.xml +func (gl *GL) TexCoord1fv(v []float32) { + C.gl1_5_glTexCoord1fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1f.xml +func (gl *GL) TexCoord1f(s float32) { + C.gl1_5_glTexCoord1f(gl.funcs, C.GLfloat(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1dv.xml +func (gl *GL) TexCoord1dv(v []float64) { + C.gl1_5_glTexCoord1dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1d.xml +func (gl *GL) TexCoord1d(s float64) { + C.gl1_5_glTexCoord1d(gl.funcs, C.GLdouble(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectsv.xml +func (gl *GL) Rectsv(v1, v2 []int16) { + C.gl1_5_glRectsv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v1[0])), (*C.GLshort)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRects.xml +func (gl *GL) Rects(x1, y1, x2, y2 int16) { + C.gl1_5_glRects(gl.funcs, C.GLshort(x1), C.GLshort(y1), C.GLshort(x2), C.GLshort(y2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectiv.xml +func (gl *GL) Rectiv(v1, v2 []int32) { + C.gl1_5_glRectiv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v1[0])), (*C.GLint)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRecti.xml +func (gl *GL) Recti(x1, y1, x2, y2 int32) { + C.gl1_5_glRecti(gl.funcs, C.GLint(x1), C.GLint(y1), C.GLint(x2), C.GLint(y2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectfv.xml +func (gl *GL) Rectfv(v1, v2 []float32) { + C.gl1_5_glRectfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v1[0])), (*C.GLfloat)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectf.xml +func (gl *GL) Rectf(x1, y1, x2, y2 float32) { + C.gl1_5_glRectf(gl.funcs, C.GLfloat(x1), C.GLfloat(y1), C.GLfloat(x2), C.GLfloat(y2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectdv.xml +func (gl *GL) Rectdv(v1, v2 []float64) { + C.gl1_5_glRectdv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v1[0])), (*C.GLdouble)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectd.xml +func (gl *GL) Rectd(x1, y1, x2, y2 float64) { + C.gl1_5_glRectd(gl.funcs, C.GLdouble(x1), C.GLdouble(y1), C.GLdouble(x2), C.GLdouble(y2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4sv.xml +func (gl *GL) RasterPos4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_5_glRasterPos4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4s.xml +func (gl *GL) RasterPos4s(x, y, z, w int16) { + C.gl1_5_glRasterPos4s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4iv.xml +func (gl *GL) RasterPos4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_5_glRasterPos4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4i.xml +func (gl *GL) RasterPos4i(x, y, z, w int) { + C.gl1_5_glRasterPos4i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4fv.xml +func (gl *GL) RasterPos4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_5_glRasterPos4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4f.xml +func (gl *GL) RasterPos4f(x, y, z, w float32) { + C.gl1_5_glRasterPos4f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4dv.xml +func (gl *GL) RasterPos4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_5_glRasterPos4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4d.xml +func (gl *GL) RasterPos4d(x, y, z, w float64) { + C.gl1_5_glRasterPos4d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3sv.xml +func (gl *GL) RasterPos3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_5_glRasterPos3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3s.xml +func (gl *GL) RasterPos3s(x, y, z int16) { + C.gl1_5_glRasterPos3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3iv.xml +func (gl *GL) RasterPos3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_5_glRasterPos3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3i.xml +func (gl *GL) RasterPos3i(x, y, z int) { + C.gl1_5_glRasterPos3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3fv.xml +func (gl *GL) RasterPos3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_5_glRasterPos3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3f.xml +func (gl *GL) RasterPos3f(x, y, z float32) { + C.gl1_5_glRasterPos3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3dv.xml +func (gl *GL) RasterPos3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_5_glRasterPos3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3d.xml +func (gl *GL) RasterPos3d(x, y, z float64) { + C.gl1_5_glRasterPos3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2sv.xml +func (gl *GL) RasterPos2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_5_glRasterPos2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2s.xml +func (gl *GL) RasterPos2s(x, y int16) { + C.gl1_5_glRasterPos2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2iv.xml +func (gl *GL) RasterPos2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_5_glRasterPos2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2i.xml +func (gl *GL) RasterPos2i(x, y int) { + C.gl1_5_glRasterPos2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2fv.xml +func (gl *GL) RasterPos2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_5_glRasterPos2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2f.xml +func (gl *GL) RasterPos2f(x, y float32) { + C.gl1_5_glRasterPos2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2dv.xml +func (gl *GL) RasterPos2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_5_glRasterPos2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2d.xml +func (gl *GL) RasterPos2d(x, y float64) { + C.gl1_5_glRasterPos2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3sv.xml +func (gl *GL) Normal3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_5_glNormal3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3s.xml +func (gl *GL) Normal3s(nx, ny, nz int16) { + C.gl1_5_glNormal3s(gl.funcs, C.GLshort(nx), C.GLshort(ny), C.GLshort(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3iv.xml +func (gl *GL) Normal3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_5_glNormal3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3i.xml +func (gl *GL) Normal3i(nx, ny, nz int32) { + C.gl1_5_glNormal3i(gl.funcs, C.GLint(nx), C.GLint(ny), C.GLint(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3fv.xml +func (gl *GL) Normal3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_5_glNormal3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3f.xml +func (gl *GL) Normal3f(nx, ny, nz float32) { + C.gl1_5_glNormal3f(gl.funcs, C.GLfloat(nx), C.GLfloat(ny), C.GLfloat(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3dv.xml +func (gl *GL) Normal3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_5_glNormal3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3d.xml +func (gl *GL) Normal3d(nx, ny, nz float64) { + C.gl1_5_glNormal3d(gl.funcs, C.GLdouble(nx), C.GLdouble(ny), C.GLdouble(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3bv.xml +func (gl *GL) Normal3bv(v []byte) { + C.gl1_5_glNormal3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3b.xml +func (gl *GL) Normal3b(nx, ny, nz byte) { + C.gl1_5_glNormal3b(gl.funcs, C.GLbyte(nx), C.GLbyte(ny), C.GLbyte(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexsv.xml +func (gl *GL) Indexsv(c []int16) { + C.gl1_5_glIndexsv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexs.xml +func (gl *GL) Indexs(c int16) { + C.gl1_5_glIndexs(gl.funcs, C.GLshort(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexiv.xml +func (gl *GL) Indexiv(c []int32) { + C.gl1_5_glIndexiv(gl.funcs, (*C.GLint)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexi.xml +func (gl *GL) Indexi(c int32) { + C.gl1_5_glIndexi(gl.funcs, C.GLint(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexfv.xml +func (gl *GL) Indexfv(c []float32) { + C.gl1_5_glIndexfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexf.xml +func (gl *GL) Indexf(c float32) { + C.gl1_5_glIndexf(gl.funcs, C.GLfloat(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexdv.xml +func (gl *GL) Indexdv(c []float64) { + C.gl1_5_glIndexdv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexd.xml +func (gl *GL) Indexd(c float64) { + C.gl1_5_glIndexd(gl.funcs, C.GLdouble(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEnd.xml +func (gl *GL) End() { + C.gl1_5_glEnd(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEdgeFlagv.xml +func (gl *GL) EdgeFlagv(flag []bool) { + C.gl1_5_glEdgeFlagv(gl.funcs, (*C.GLboolean)(unsafe.Pointer(&flag[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEdgeFlag.xml +func (gl *GL) EdgeFlag(flag bool) { + C.gl1_5_glEdgeFlag(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4usv.xml +func (gl *GL) Color4usv(v []uint16) { + C.gl1_5_glColor4usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4us.xml +func (gl *GL) Color4us(red, green, blue, alpha uint16) { + C.gl1_5_glColor4us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue), C.GLushort(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4uiv.xml +func (gl *GL) Color4uiv(v []uint32) { + C.gl1_5_glColor4uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4ui.xml +func (gl *GL) Color4ui(red, green, blue, alpha uint32) { + C.gl1_5_glColor4ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue), C.GLuint(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4ubv.xml +func (gl *GL) Color4ubv(v []uint8) { + C.gl1_5_glColor4ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4ub.xml +func (gl *GL) Color4ub(red, green, blue, alpha uint8) { + C.gl1_5_glColor4ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue), C.GLubyte(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4sv.xml +func (gl *GL) Color4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_5_glColor4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4s.xml +func (gl *GL) Color4s(red, green, blue, alpha int16) { + C.gl1_5_glColor4s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue), C.GLshort(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4iv.xml +func (gl *GL) Color4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_5_glColor4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4i.xml +func (gl *GL) Color4i(red, green, blue, alpha int32) { + C.gl1_5_glColor4i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue), C.GLint(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4fv.xml +func (gl *GL) Color4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_5_glColor4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4f.xml +func (gl *GL) Color4f(red, green, blue, alpha float32) { + C.gl1_5_glColor4f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4dv.xml +func (gl *GL) Color4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_5_glColor4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4d.xml +func (gl *GL) Color4d(red, green, blue, alpha float64) { + C.gl1_5_glColor4d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue), C.GLdouble(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4bv.xml +func (gl *GL) Color4bv(v []byte) { + C.gl1_5_glColor4bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4b.xml +func (gl *GL) Color4b(red, green, blue, alpha byte) { + C.gl1_5_glColor4b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue), C.GLbyte(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3usv.xml +func (gl *GL) Color3usv(v []uint16) { + C.gl1_5_glColor3usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3us.xml +func (gl *GL) Color3us(red, green, blue uint16) { + C.gl1_5_glColor3us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3uiv.xml +func (gl *GL) Color3uiv(v []uint32) { + C.gl1_5_glColor3uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3ui.xml +func (gl *GL) Color3ui(red, green, blue uint32) { + C.gl1_5_glColor3ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3ubv.xml +func (gl *GL) Color3ubv(v []uint8) { + C.gl1_5_glColor3ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3ub.xml +func (gl *GL) Color3ub(red, green, blue uint8) { + C.gl1_5_glColor3ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3sv.xml +func (gl *GL) Color3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_5_glColor3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3s.xml +func (gl *GL) Color3s(red, green, blue int16) { + C.gl1_5_glColor3s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3iv.xml +func (gl *GL) Color3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_5_glColor3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3i.xml +func (gl *GL) Color3i(red, green, blue int32) { + C.gl1_5_glColor3i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3fv.xml +func (gl *GL) Color3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_5_glColor3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3f.xml +func (gl *GL) Color3f(red, green, blue float32) { + C.gl1_5_glColor3f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3dv.xml +func (gl *GL) Color3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_5_glColor3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3d.xml +func (gl *GL) Color3d(red, green, blue float64) { + C.gl1_5_glColor3d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3bv.xml +func (gl *GL) Color3bv(v []byte) { + C.gl1_5_glColor3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3b.xml +func (gl *GL) Color3b(red, green, blue byte) { + C.gl1_5_glColor3b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBitmap.xml +func (gl *GL) Bitmap(width, height int, xorig, yorig, xmove, ymove float32, bitmap []uint8) { + C.gl1_5_glBitmap(gl.funcs, C.GLsizei(width), C.GLsizei(height), C.GLfloat(xorig), C.GLfloat(yorig), C.GLfloat(xmove), C.GLfloat(ymove), (*C.GLubyte)(unsafe.Pointer(&bitmap[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBegin.xml +func (gl *GL) Begin(mode glbase.Enum) { + C.gl1_5_glBegin(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glListBase.xml +func (gl *GL) ListBase(base uint32) { + C.gl1_5_glListBase(gl.funcs, C.GLuint(base)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGenLists.xml +func (gl *GL) GenLists(range_ int32) uint32 { + glresult := C.gl1_5_glGenLists(gl.funcs, C.GLsizei(range_)) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDeleteLists.xml +func (gl *GL) DeleteLists(list uint32, range_ int32) { + C.gl1_5_glDeleteLists(gl.funcs, C.GLuint(list), C.GLsizei(range_)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCallLists.xml +func (gl *GL) CallLists(n int, gltype glbase.Enum, lists interface{}) { + var lists_ptr unsafe.Pointer + var lists_v = reflect.ValueOf(lists) + if lists != nil && lists_v.Kind() != reflect.Slice { + panic("parameter lists must be a slice") + } + if lists != nil { + lists_ptr = unsafe.Pointer(lists_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glCallLists(gl.funcs, C.GLsizei(n), C.GLenum(gltype), lists_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCallList.xml +func (gl *GL) CallList(list uint32) { + C.gl1_5_glCallList(gl.funcs, C.GLuint(list)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEndList.xml +func (gl *GL) EndList() { + C.gl1_5_glEndList(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNewList.xml +func (gl *GL) NewList(list uint32, mode glbase.Enum) { + C.gl1_5_glNewList(gl.funcs, C.GLuint(list), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPushClientAttrib.xml +func (gl *GL) PushClientAttrib(mask glbase.Bitfield) { + C.gl1_5_glPushClientAttrib(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPopClientAttrib.xml +func (gl *GL) PopClientAttrib() { + C.gl1_5_glPopClientAttrib(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPrioritizeTextures.xml +func (gl *GL) PrioritizeTextures(n int, textures []glbase.Texture, priorities []float32) { + C.gl1_5_glPrioritizeTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0])), (*C.GLfloat)(unsafe.Pointer(&priorities[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glAreTexturesResident.xml +func (gl *GL) AreTexturesResident(n int, textures []glbase.Texture, residences []bool) bool { + glresult := C.gl1_5_glAreTexturesResident(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0])), (*C.GLboolean)(unsafe.Pointer(&residences[0]))) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexPointer.xml +func (gl *GL) VertexPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glVertexPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoordPointer.xml +func (gl *GL) TexCoordPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glTexCoordPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormalPointer.xml +func (gl *GL) NormalPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glNormalPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glInterleavedArrays.xml +func (gl *GL) InterleavedArrays(format glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glInterleavedArrays(gl.funcs, C.GLenum(format), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexPointer.xml +func (gl *GL) IndexPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glIndexPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEnableClientState.xml +func (gl *GL) EnableClientState(array glbase.Enum) { + C.gl1_5_glEnableClientState(gl.funcs, C.GLenum(array)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEdgeFlagPointer.xml +func (gl *GL) EdgeFlagPointer(stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glEdgeFlagPointer(gl.funcs, C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDisableClientState.xml +func (gl *GL) DisableClientState(array glbase.Enum) { + C.gl1_5_glDisableClientState(gl.funcs, C.GLenum(array)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorPointer.xml +func (gl *GL) ColorPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glColorPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glArrayElement.xml +func (gl *GL) ArrayElement(i int32) { + C.gl1_5_glArrayElement(gl.funcs, C.GLint(i)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glResetMinmax.xml +func (gl *GL) ResetMinmax(target glbase.Enum) { + C.gl1_5_glResetMinmax(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glResetHistogram.xml +func (gl *GL) ResetHistogram(target glbase.Enum) { + C.gl1_5_glResetHistogram(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMinmax.xml +func (gl *GL) Minmax(target, internalFormat glbase.Enum, sink bool) { + C.gl1_5_glMinmax(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), *(*C.GLboolean)(unsafe.Pointer(&sink))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glHistogram.xml +func (gl *GL) Histogram(target glbase.Enum, width int, internalFormat glbase.Enum, sink bool) { + C.gl1_5_glHistogram(gl.funcs, C.GLenum(target), C.GLsizei(width), C.GLenum(internalFormat), *(*C.GLboolean)(unsafe.Pointer(&sink))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMinmaxParameteriv.xml +func (gl *GL) GetMinmaxParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_5_glGetMinmaxParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMinmaxParameterfv.xml +func (gl *GL) GetMinmaxParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_5_glGetMinmaxParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMinmax.xml +func (gl *GL) GetMinmax(target glbase.Enum, reset bool, format, gltype glbase.Enum, values interface{}) { + var values_ptr unsafe.Pointer + var values_v = reflect.ValueOf(values) + if values != nil && values_v.Kind() != reflect.Slice { + panic("parameter values must be a slice") + } + if values != nil { + values_ptr = unsafe.Pointer(values_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glGetMinmax(gl.funcs, C.GLenum(target), *(*C.GLboolean)(unsafe.Pointer(&reset)), C.GLenum(format), C.GLenum(gltype), values_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetHistogramParameteriv.xml +func (gl *GL) GetHistogramParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_5_glGetHistogramParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetHistogramParameterfv.xml +func (gl *GL) GetHistogramParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_5_glGetHistogramParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetHistogram.xml +func (gl *GL) GetHistogram(target glbase.Enum, reset bool, format, gltype glbase.Enum, values interface{}) { + var values_ptr unsafe.Pointer + var values_v = reflect.ValueOf(values) + if values != nil && values_v.Kind() != reflect.Slice { + panic("parameter values must be a slice") + } + if values != nil { + values_ptr = unsafe.Pointer(values_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glGetHistogram(gl.funcs, C.GLenum(target), *(*C.GLboolean)(unsafe.Pointer(&reset)), C.GLenum(format), C.GLenum(gltype), values_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSeparableFilter2D.xml +func (gl *GL) SeparableFilter2D(target, internalFormat glbase.Enum, width, height int, format, gltype glbase.Enum, row, column interface{}) { + var row_ptr unsafe.Pointer + var row_v = reflect.ValueOf(row) + if row != nil && row_v.Kind() != reflect.Slice { + panic("parameter row must be a slice") + } + if row != nil { + row_ptr = unsafe.Pointer(row_v.Index(0).Addr().Pointer()) + } + var column_ptr unsafe.Pointer + var column_v = reflect.ValueOf(column) + if column != nil && column_v.Kind() != reflect.Slice { + panic("parameter column must be a slice") + } + if column != nil { + column_ptr = unsafe.Pointer(column_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glSeparableFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), row_ptr, column_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetSeparableFilter.xml +func (gl *GL) GetSeparableFilter(target, format, gltype glbase.Enum, row, column, span interface{}) { + var row_ptr unsafe.Pointer + var row_v = reflect.ValueOf(row) + if row != nil && row_v.Kind() != reflect.Slice { + panic("parameter row must be a slice") + } + if row != nil { + row_ptr = unsafe.Pointer(row_v.Index(0).Addr().Pointer()) + } + var column_ptr unsafe.Pointer + var column_v = reflect.ValueOf(column) + if column != nil && column_v.Kind() != reflect.Slice { + panic("parameter column must be a slice") + } + if column != nil { + column_ptr = unsafe.Pointer(column_v.Index(0).Addr().Pointer()) + } + var span_ptr unsafe.Pointer + var span_v = reflect.ValueOf(span) + if span != nil && span_v.Kind() != reflect.Slice { + panic("parameter span must be a slice") + } + if span != nil { + span_ptr = unsafe.Pointer(span_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glGetSeparableFilter(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), row_ptr, column_ptr, span_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetConvolutionParameteriv.xml +func (gl *GL) GetConvolutionParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_5_glGetConvolutionParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetConvolutionParameterfv.xml +func (gl *GL) GetConvolutionParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_5_glGetConvolutionParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetConvolutionFilter.xml +func (gl *GL) GetConvolutionFilter(target, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glGetConvolutionFilter(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyConvolutionFilter2D.xml +func (gl *GL) CopyConvolutionFilter2D(target, internalFormat glbase.Enum, x, y, width, height int) { + C.gl1_5_glCopyConvolutionFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyConvolutionFilter1D.xml +func (gl *GL) CopyConvolutionFilter1D(target, internalFormat glbase.Enum, x, y, width int) { + C.gl1_5_glCopyConvolutionFilter1D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionParameteriv.xml +func (gl *GL) ConvolutionParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_5_glConvolutionParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionParameteri.xml +func (gl *GL) ConvolutionParameteri(target, pname glbase.Enum, params int32) { + C.gl1_5_glConvolutionParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(params)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionParameterfv.xml +func (gl *GL) ConvolutionParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_5_glConvolutionParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionParameterf.xml +func (gl *GL) ConvolutionParameterf(target, pname glbase.Enum, params float32) { + C.gl1_5_glConvolutionParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(params)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionFilter2D.xml +func (gl *GL) ConvolutionFilter2D(target, internalFormat glbase.Enum, width, height int, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glConvolutionFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionFilter1D.xml +func (gl *GL) ConvolutionFilter1D(target, internalFormat glbase.Enum, width int, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glConvolutionFilter1D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyColorSubTable.xml +func (gl *GL) CopyColorSubTable(target glbase.Enum, start int32, x, y, width int) { + C.gl1_5_glCopyColorSubTable(gl.funcs, C.GLenum(target), C.GLsizei(start), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorSubTable.xml +func (gl *GL) ColorSubTable(target glbase.Enum, start int32, count int, format, gltype glbase.Enum, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glColorSubTable(gl.funcs, C.GLenum(target), C.GLsizei(start), C.GLsizei(count), C.GLenum(format), C.GLenum(gltype), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetColorTableParameteriv.xml +func (gl *GL) GetColorTableParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_5_glGetColorTableParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetColorTableParameterfv.xml +func (gl *GL) GetColorTableParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_5_glGetColorTableParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetColorTable.xml +func (gl *GL) GetColorTable(target, format, gltype glbase.Enum, table interface{}) { + var table_ptr unsafe.Pointer + var table_v = reflect.ValueOf(table) + if table != nil && table_v.Kind() != reflect.Slice { + panic("parameter table must be a slice") + } + if table != nil { + table_ptr = unsafe.Pointer(table_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glGetColorTable(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), table_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyColorTable.xml +func (gl *GL) CopyColorTable(target, internalFormat glbase.Enum, x, y, width int) { + C.gl1_5_glCopyColorTable(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorTableParameteriv.xml +func (gl *GL) ColorTableParameteriv(target, pname glbase.Enum, params []int32) { + C.gl1_5_glColorTableParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorTableParameterfv.xml +func (gl *GL) ColorTableParameterfv(target, pname glbase.Enum, params []float32) { + C.gl1_5_glColorTableParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorTable.xml +func (gl *GL) ColorTable(target, internalFormat glbase.Enum, width int, format, gltype glbase.Enum, table interface{}) { + var table_ptr unsafe.Pointer + var table_v = reflect.ValueOf(table) + if table != nil && table_v.Kind() != reflect.Slice { + panic("parameter table must be a slice") + } + if table != nil { + table_ptr = unsafe.Pointer(table_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glColorTable(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), table_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultTransposeMatrixd.xml +func (gl *GL) MultTransposeMatrixd(m []float64) { + C.gl1_5_glMultTransposeMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultTransposeMatrixf.xml +func (gl *GL) MultTransposeMatrixf(m []float32) { + C.gl1_5_glMultTransposeMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadTransposeMatrixd.xml +func (gl *GL) LoadTransposeMatrixd(m []float64) { + C.gl1_5_glLoadTransposeMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadTransposeMatrixf.xml +func (gl *GL) LoadTransposeMatrixf(m []float32) { + C.gl1_5_glLoadTransposeMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4sv.xml +func (gl *GL) MultiTexCoord4sv(target glbase.Enum, v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_5_glMultiTexCoord4sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4s.xml +func (gl *GL) MultiTexCoord4s(target glbase.Enum, s, t, r, q int16) { + C.gl1_5_glMultiTexCoord4s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t), C.GLshort(r), C.GLshort(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4iv.xml +func (gl *GL) MultiTexCoord4iv(target glbase.Enum, v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_5_glMultiTexCoord4iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4i.xml +func (gl *GL) MultiTexCoord4i(target glbase.Enum, s, t, r, q int32) { + C.gl1_5_glMultiTexCoord4i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t), C.GLint(r), C.GLint(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4fv.xml +func (gl *GL) MultiTexCoord4fv(target glbase.Enum, v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_5_glMultiTexCoord4fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4f.xml +func (gl *GL) MultiTexCoord4f(target glbase.Enum, s, t, r, q float32) { + C.gl1_5_glMultiTexCoord4f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t), C.GLfloat(r), C.GLfloat(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4dv.xml +func (gl *GL) MultiTexCoord4dv(target glbase.Enum, v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl1_5_glMultiTexCoord4dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4d.xml +func (gl *GL) MultiTexCoord4d(target glbase.Enum, s, t, r, q float64) { + C.gl1_5_glMultiTexCoord4d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t), C.GLdouble(r), C.GLdouble(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3sv.xml +func (gl *GL) MultiTexCoord3sv(target glbase.Enum, v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_5_glMultiTexCoord3sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3s.xml +func (gl *GL) MultiTexCoord3s(target glbase.Enum, s, t, r int16) { + C.gl1_5_glMultiTexCoord3s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t), C.GLshort(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3iv.xml +func (gl *GL) MultiTexCoord3iv(target glbase.Enum, v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_5_glMultiTexCoord3iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3i.xml +func (gl *GL) MultiTexCoord3i(target glbase.Enum, s, t, r int32) { + C.gl1_5_glMultiTexCoord3i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t), C.GLint(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3fv.xml +func (gl *GL) MultiTexCoord3fv(target glbase.Enum, v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_5_glMultiTexCoord3fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3f.xml +func (gl *GL) MultiTexCoord3f(target glbase.Enum, s, t, r float32) { + C.gl1_5_glMultiTexCoord3f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t), C.GLfloat(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3dv.xml +func (gl *GL) MultiTexCoord3dv(target glbase.Enum, v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_5_glMultiTexCoord3dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3d.xml +func (gl *GL) MultiTexCoord3d(target glbase.Enum, s, t, r float64) { + C.gl1_5_glMultiTexCoord3d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t), C.GLdouble(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2sv.xml +func (gl *GL) MultiTexCoord2sv(target glbase.Enum, v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_5_glMultiTexCoord2sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2s.xml +func (gl *GL) MultiTexCoord2s(target glbase.Enum, s, t int16) { + C.gl1_5_glMultiTexCoord2s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2iv.xml +func (gl *GL) MultiTexCoord2iv(target glbase.Enum, v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_5_glMultiTexCoord2iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2i.xml +func (gl *GL) MultiTexCoord2i(target glbase.Enum, s, t int32) { + C.gl1_5_glMultiTexCoord2i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2fv.xml +func (gl *GL) MultiTexCoord2fv(target glbase.Enum, v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_5_glMultiTexCoord2fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2f.xml +func (gl *GL) MultiTexCoord2f(target glbase.Enum, s, t float32) { + C.gl1_5_glMultiTexCoord2f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2dv.xml +func (gl *GL) MultiTexCoord2dv(target glbase.Enum, v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_5_glMultiTexCoord2dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2d.xml +func (gl *GL) MultiTexCoord2d(target glbase.Enum, s, t float64) { + C.gl1_5_glMultiTexCoord2d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1sv.xml +func (gl *GL) MultiTexCoord1sv(target glbase.Enum, v []int16) { + C.gl1_5_glMultiTexCoord1sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1s.xml +func (gl *GL) MultiTexCoord1s(target glbase.Enum, s int16) { + C.gl1_5_glMultiTexCoord1s(gl.funcs, C.GLenum(target), C.GLshort(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1iv.xml +func (gl *GL) MultiTexCoord1iv(target glbase.Enum, v []int32) { + C.gl1_5_glMultiTexCoord1iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1i.xml +func (gl *GL) MultiTexCoord1i(target glbase.Enum, s int32) { + C.gl1_5_glMultiTexCoord1i(gl.funcs, C.GLenum(target), C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1fv.xml +func (gl *GL) MultiTexCoord1fv(target glbase.Enum, v []float32) { + C.gl1_5_glMultiTexCoord1fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1f.xml +func (gl *GL) MultiTexCoord1f(target glbase.Enum, s float32) { + C.gl1_5_glMultiTexCoord1f(gl.funcs, C.GLenum(target), C.GLfloat(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1dv.xml +func (gl *GL) MultiTexCoord1dv(target glbase.Enum, v []float64) { + C.gl1_5_glMultiTexCoord1dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1d.xml +func (gl *GL) MultiTexCoord1d(target glbase.Enum, s float64) { + C.gl1_5_glMultiTexCoord1d(gl.funcs, C.GLenum(target), C.GLdouble(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClientActiveTexture.xml +func (gl *GL) ClientActiveTexture(texture glbase.Enum) { + C.gl1_5_glClientActiveTexture(gl.funcs, C.GLenum(texture)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos3sv.xml +func (gl *GL) WindowPos3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_5_glWindowPos3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos3s.xml +func (gl *GL) WindowPos3s(x, y, z int16) { + C.gl1_5_glWindowPos3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos3iv.xml +func (gl *GL) WindowPos3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_5_glWindowPos3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos3i.xml +func (gl *GL) WindowPos3i(x, y, z int) { + C.gl1_5_glWindowPos3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos3fv.xml +func (gl *GL) WindowPos3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_5_glWindowPos3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos3f.xml +func (gl *GL) WindowPos3f(x, y, z float32) { + C.gl1_5_glWindowPos3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos3dv.xml +func (gl *GL) WindowPos3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_5_glWindowPos3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos3d.xml +func (gl *GL) WindowPos3d(x, y, z float64) { + C.gl1_5_glWindowPos3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos2sv.xml +func (gl *GL) WindowPos2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_5_glWindowPos2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos2s.xml +func (gl *GL) WindowPos2s(x, y int16) { + C.gl1_5_glWindowPos2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos2iv.xml +func (gl *GL) WindowPos2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_5_glWindowPos2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos2i.xml +func (gl *GL) WindowPos2i(x, y int) { + C.gl1_5_glWindowPos2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos2fv.xml +func (gl *GL) WindowPos2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_5_glWindowPos2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos2f.xml +func (gl *GL) WindowPos2f(x, y float32) { + C.gl1_5_glWindowPos2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos2dv.xml +func (gl *GL) WindowPos2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl1_5_glWindowPos2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos2d.xml +func (gl *GL) WindowPos2d(x, y float64) { + C.gl1_5_glWindowPos2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColorPointer.xml +func (gl *GL) SecondaryColorPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glSecondaryColorPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3usv.xml +func (gl *GL) SecondaryColor3usv(v []uint16) { + C.gl1_5_glSecondaryColor3usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3us.xml +func (gl *GL) SecondaryColor3us(red, green, blue uint16) { + C.gl1_5_glSecondaryColor3us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3uiv.xml +func (gl *GL) SecondaryColor3uiv(v []uint32) { + C.gl1_5_glSecondaryColor3uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3ui.xml +func (gl *GL) SecondaryColor3ui(red, green, blue uint32) { + C.gl1_5_glSecondaryColor3ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3ubv.xml +func (gl *GL) SecondaryColor3ubv(v []uint8) { + C.gl1_5_glSecondaryColor3ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3ub.xml +func (gl *GL) SecondaryColor3ub(red, green, blue uint8) { + C.gl1_5_glSecondaryColor3ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3sv.xml +func (gl *GL) SecondaryColor3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_5_glSecondaryColor3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3s.xml +func (gl *GL) SecondaryColor3s(red, green, blue int16) { + C.gl1_5_glSecondaryColor3s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3iv.xml +func (gl *GL) SecondaryColor3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_5_glSecondaryColor3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3i.xml +func (gl *GL) SecondaryColor3i(red, green, blue int32) { + C.gl1_5_glSecondaryColor3i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3fv.xml +func (gl *GL) SecondaryColor3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_5_glSecondaryColor3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3f.xml +func (gl *GL) SecondaryColor3f(red, green, blue float32) { + C.gl1_5_glSecondaryColor3f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3dv.xml +func (gl *GL) SecondaryColor3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl1_5_glSecondaryColor3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3d.xml +func (gl *GL) SecondaryColor3d(red, green, blue float64) { + C.gl1_5_glSecondaryColor3d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3bv.xml +func (gl *GL) SecondaryColor3bv(v []byte) { + C.gl1_5_glSecondaryColor3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3b.xml +func (gl *GL) SecondaryColor3b(red, green, blue byte) { + C.gl1_5_glSecondaryColor3b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogCoordPointer.xml +func (gl *GL) FogCoordPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl1_5_glFogCoordPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogCoorddv.xml +func (gl *GL) FogCoorddv(coord []float64) { + C.gl1_5_glFogCoorddv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&coord[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogCoordd.xml +func (gl *GL) FogCoordd(coord float64) { + C.gl1_5_glFogCoordd(gl.funcs, C.GLdouble(coord)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogCoordfv.xml +func (gl *GL) FogCoordfv(coord []float32) { + C.gl1_5_glFogCoordfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&coord[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogCoordf.xml +func (gl *GL) FogCoordf(coord float32) { + C.gl1_5_glFogCoordf(gl.funcs, C.GLfloat(coord)) +} diff --git a/gl/2.0/funcs.cpp b/gl/2.0/funcs.cpp new file mode 100644 index 00000000..622f5904 --- /dev/null +++ b/gl/2.0/funcs.cpp @@ -0,0 +1,3444 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#include +#include + +#include "funcs.h" + +void *gl2_0_funcs() { + QOpenGLFunctions_2_0* funcs = QOpenGLContext::currentContext()->versionFunctions(); + if (!funcs) { + return 0; + } + funcs->initializeOpenGLFunctions(); + return funcs; +} + + +void gl2_0_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewport(x, y, width, height); +} + +void gl2_0_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRange(nearVal, farVal); +} + +GLboolean gl2_0_glIsEnabled(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabled(cap); +} + +void gl2_0_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameteriv(target, level, pname, params); +} + +void gl2_0_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameterfv(target, level, pname, params); +} + +void gl2_0_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameteriv(target, pname, params); +} + +void gl2_0_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterfv(target, pname, params); +} + +void gl2_0_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexImage(target, level, format, gltype, pixels); +} + +void gl2_0_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegerv(pname, params); +} + +void gl2_0_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFloatv(pname, params); +} + +GLenum gl2_0_glGetError(void *_glfuncs) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetError(); +} + +void gl2_0_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetDoublev(pname, params); +} + +void gl2_0_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleanv(pname, params); +} + +void gl2_0_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadPixels(x, y, width, height, format, gltype, pixels); +} + +void gl2_0_glReadBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadBuffer(mode); +} + +void gl2_0_glPixelStorei(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStorei(pname, param); +} + +void gl2_0_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStoref(pname, param); +} + +void gl2_0_glDepthFunc(void *_glfuncs, GLenum glfunc) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthFunc(glfunc); +} + +void gl2_0_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOp(fail, zfail, zpass); +} + +void gl2_0_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFunc(glfunc, ref, mask); +} + +void gl2_0_glLogicOp(void *_glfuncs, GLenum opcode) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLogicOp(opcode); +} + +void gl2_0_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFunc(sfactor, dfactor); +} + +void gl2_0_glFlush(void *_glfuncs) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlush(); +} + +void gl2_0_glFinish(void *_glfuncs) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFinish(); +} + +void gl2_0_glEnable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnable(cap); +} + +void gl2_0_glDisable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisable(cap); +} + +void gl2_0_glDepthMask(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthMask(flag); +} + +void gl2_0_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMask(red, green, blue, alpha); +} + +void gl2_0_glStencilMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMask(mask); +} + +void gl2_0_glClearDepth(void *_glfuncs, GLdouble depth) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearDepth(depth); +} + +void gl2_0_glClearStencil(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearStencil(s); +} + +void gl2_0_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearColor(red, green, blue, alpha); +} + +void gl2_0_glClear(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClear(mask); +} + +void gl2_0_glDrawBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffer(mode); +} + +void gl2_0_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage2D(target, level, internalFormat, width, height, border, format, gltype, pixels); +} + +void gl2_0_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage1D(target, level, internalFormat, width, border, format, gltype, pixels); +} + +void gl2_0_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteriv(target, pname, params); +} + +void gl2_0_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteri(target, pname, param); +} + +void gl2_0_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterfv(target, pname, params); +} + +void gl2_0_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterf(target, pname, param); +} + +void gl2_0_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissor(x, y, width, height); +} + +void gl2_0_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonMode(face, mode); +} + +void gl2_0_glPointSize(void *_glfuncs, GLfloat size) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointSize(size); +} + +void gl2_0_glLineWidth(void *_glfuncs, GLfloat width) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineWidth(width); +} + +void gl2_0_glHint(void *_glfuncs, GLenum target, GLenum mode) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glHint(target, mode); +} + +void gl2_0_glFrontFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrontFace(mode); +} + +void gl2_0_glCullFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCullFace(mode); +} + +void gl2_0_glIndexubv(void *_glfuncs, const GLubyte* c) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexubv(c); +} + +void gl2_0_glIndexub(void *_glfuncs, GLubyte c) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexub(c); +} + +GLboolean gl2_0_glIsTexture(void *_glfuncs, GLuint texture) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsTexture(texture); +} + +void gl2_0_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenTextures(n, textures); +} + +void gl2_0_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteTextures(n, textures); +} + +void gl2_0_glBindTexture(void *_glfuncs, GLenum target, GLuint texture) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindTexture(target, texture); +} + +void gl2_0_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, gltype, pixels); +} + +void gl2_0_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage1D(target, level, xoffset, width, format, gltype, pixels); +} + +void gl2_0_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); +} + +void gl2_0_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage1D(target, level, xoffset, x, y, width); +} + +void gl2_0_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage2D(target, level, internalFormat, x, y, width, height, border); +} + +void gl2_0_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage1D(target, level, internalFormat, x, y, width, border); +} + +void gl2_0_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonOffset(factor, units); +} + +void gl2_0_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElements(mode, count, gltype, indices); +} + +void gl2_0_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArrays(mode, first, count); +} + +void gl2_0_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); +} + +void gl2_0_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, gltype, pixels); +} + +void gl2_0_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage3D(target, level, internalFormat, width, height, depth, border, format, gltype, pixels); +} + +void gl2_0_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawRangeElements(mode, start, end, count, gltype, indices); +} + +void gl2_0_glBlendEquation(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquation(mode); +} + +void gl2_0_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendColor(red, green, blue, alpha); +} + +void gl2_0_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetCompressedTexImage(target, level, img); +} + +void gl2_0_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data); +} + +void gl2_0_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); +} + +void gl2_0_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); +} + +void gl2_0_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage1D(target, level, internalFormat, width, border, imageSize, data); +} + +void gl2_0_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data); +} + +void gl2_0_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage3D(target, level, internalFormat, width, height, depth, border, imageSize, data); +} + +void gl2_0_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSampleCoverage(value, invert); +} + +void gl2_0_glActiveTexture(void *_glfuncs, GLenum texture) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glActiveTexture(texture); +} + +void gl2_0_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteriv(pname, params); +} + +void gl2_0_glPointParameteri(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteri(pname, param); +} + +void gl2_0_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterfv(pname, params); +} + +void gl2_0_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterf(pname, param); +} + +void gl2_0_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiDrawArrays(mode, first, count, drawcount); +} + +void gl2_0_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); +} + +void gl2_0_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferParameteriv(target, pname, params); +} + +GLboolean gl2_0_glUnmapBuffer(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glUnmapBuffer(target); +} + +void gl2_0_glGetBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferSubData(target, offset, size, data); +} + +void gl2_0_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferSubData(target, offset, size, data); +} + +void gl2_0_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferData(target, size, data, usage); +} + +GLboolean gl2_0_glIsBuffer(void *_glfuncs, GLuint buffer) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsBuffer(buffer); +} + +void gl2_0_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenBuffers(n, buffers); +} + +void gl2_0_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteBuffers(n, buffers); +} + +void gl2_0_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBuffer(target, buffer); +} + +void gl2_0_glGetQueryObjectuiv(void *_glfuncs, GLuint id, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectuiv(id, pname, params); +} + +void gl2_0_glGetQueryObjectiv(void *_glfuncs, GLuint id, GLenum pname, GLint* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectiv(id, pname, params); +} + +void gl2_0_glGetQueryiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryiv(target, pname, params); +} + +void gl2_0_glEndQuery(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndQuery(target); +} + +void gl2_0_glBeginQuery(void *_glfuncs, GLenum target, GLuint id) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginQuery(target, id); +} + +GLboolean gl2_0_glIsQuery(void *_glfuncs, GLuint id) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsQuery(id); +} + +void gl2_0_glDeleteQueries(void *_glfuncs, GLsizei n, const GLuint* ids) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteQueries(n, ids); +} + +void gl2_0_glGenQueries(void *_glfuncs, GLsizei n, GLuint* ids) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenQueries(n, ids); +} + +void gl2_0_glVertexAttribPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLboolean normalized, GLsizei stride, const GLvoid* offset) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribPointer(index, size, gltype, normalized, stride, offset); +} + +void gl2_0_glValidateProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glValidateProgram(program); +} + +void gl2_0_glUniformMatrix4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4fv(location, count, transpose, value); +} + +void gl2_0_glUniformMatrix3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3fv(location, count, transpose, value); +} + +void gl2_0_glUniformMatrix2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2fv(location, count, transpose, value); +} + +void gl2_0_glUniform4iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4iv(location, count, value); +} + +void gl2_0_glUniform3iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3iv(location, count, value); +} + +void gl2_0_glUniform2iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2iv(location, count, value); +} + +void gl2_0_glUniform1iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1iv(location, count, value); +} + +void gl2_0_glUniform4fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4fv(location, count, value); +} + +void gl2_0_glUniform3fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3fv(location, count, value); +} + +void gl2_0_glUniform2fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2fv(location, count, value); +} + +void gl2_0_glUniform1fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1fv(location, count, value); +} + +void gl2_0_glUniform4i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4i(location, v0, v1, v2, v3); +} + +void gl2_0_glUniform3i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3i(location, v0, v1, v2); +} + +void gl2_0_glUniform2i(void *_glfuncs, GLint location, GLint v0, GLint v1) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2i(location, v0, v1); +} + +void gl2_0_glUniform1i(void *_glfuncs, GLint location, GLint v0) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1i(location, v0); +} + +void gl2_0_glUniform4f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4f(location, v0, v1, v2, v3); +} + +void gl2_0_glUniform3f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3f(location, v0, v1, v2); +} + +void gl2_0_glUniform2f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2f(location, v0, v1); +} + +void gl2_0_glUniform1f(void *_glfuncs, GLint location, GLfloat v0) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1f(location, v0); +} + +void gl2_0_glUseProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUseProgram(program); +} + +void gl2_0_glShaderSource(void *_glfuncs, GLuint shader, GLsizei count, const GLchar** source, const GLint* length) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShaderSource(shader, count, source, length); +} + +void gl2_0_glLinkProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLinkProgram(program); +} + +GLboolean gl2_0_glIsShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsShader(shader); +} + +GLboolean gl2_0_glIsProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsProgram(program); +} + +void gl2_0_glGetVertexAttribiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribiv(index, pname, params); +} + +void gl2_0_glGetVertexAttribfv(void *_glfuncs, GLuint index, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribfv(index, pname, params); +} + +void gl2_0_glGetVertexAttribdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribdv(index, pname, params); +} + +void gl2_0_glGetUniformiv(void *_glfuncs, GLuint program, GLint location, GLint* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformiv(program, location, params); +} + +void gl2_0_glGetUniformfv(void *_glfuncs, GLuint program, GLint location, GLfloat* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformfv(program, location, params); +} + +GLint gl2_0_glGetUniformLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetUniformLocation(program, name); +} + +void gl2_0_glGetShaderSource(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderSource(shader, bufSize, length, source); +} + +void gl2_0_glGetShaderInfoLog(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderInfoLog(shader, bufSize, length, infoLog); +} + +void gl2_0_glGetShaderiv(void *_glfuncs, GLuint shader, GLenum pname, GLint* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderiv(shader, pname, params); +} + +void gl2_0_glGetProgramInfoLog(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramInfoLog(program, bufSize, length, infoLog); +} + +void gl2_0_glGetProgramiv(void *_glfuncs, GLuint program, GLenum pname, GLint* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramiv(program, pname, params); +} + +GLint gl2_0_glGetAttribLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetAttribLocation(program, name); +} + +void gl2_0_glGetAttachedShaders(void *_glfuncs, GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetAttachedShaders(program, maxCount, count, obj); +} + +void gl2_0_glGetActiveUniform(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniform(program, index, bufSize, length, size, gltype, name); +} + +void gl2_0_glGetActiveAttrib(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveAttrib(program, index, bufSize, length, size, gltype, name); +} + +void gl2_0_glEnableVertexAttribArray(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnableVertexAttribArray(index); +} + +void gl2_0_glDisableVertexAttribArray(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisableVertexAttribArray(index); +} + +void gl2_0_glDetachShader(void *_glfuncs, GLuint program, GLuint shader) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDetachShader(program, shader); +} + +void gl2_0_glDeleteShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteShader(shader); +} + +void gl2_0_glDeleteProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteProgram(program); +} + +GLuint gl2_0_glCreateShader(void *_glfuncs, GLenum gltype) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCreateShader(gltype); +} + +GLuint gl2_0_glCreateProgram(void *_glfuncs) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCreateProgram(); +} + +void gl2_0_glCompileShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompileShader(shader); +} + +void gl2_0_glBindAttribLocation(void *_glfuncs, GLuint program, GLuint index, const GLchar* name) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindAttribLocation(program, index, name); +} + +void gl2_0_glAttachShader(void *_glfuncs, GLuint program, GLuint shader) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAttachShader(program, shader); +} + +void gl2_0_glStencilMaskSeparate(void *_glfuncs, GLenum face, GLuint mask) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMaskSeparate(face, mask); +} + +void gl2_0_glStencilFuncSeparate(void *_glfuncs, GLenum face, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFuncSeparate(face, glfunc, ref, mask); +} + +void gl2_0_glStencilOpSeparate(void *_glfuncs, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOpSeparate(face, sfail, dpfail, dppass); +} + +void gl2_0_glDrawBuffers(void *_glfuncs, GLsizei n, const GLenum* bufs) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffers(n, bufs); +} + +void gl2_0_glBlendEquationSeparate(void *_glfuncs, GLenum modeRGB, GLenum modeAlpha) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquationSeparate(modeRGB, modeAlpha); +} + +void gl2_0_glTranslatef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTranslatef(x, y, z); +} + +void gl2_0_glTranslated(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTranslated(x, y, z); +} + +void gl2_0_glScalef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScalef(x, y, z); +} + +void gl2_0_glScaled(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScaled(x, y, z); +} + +void gl2_0_glRotatef(void *_glfuncs, GLfloat angle, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRotatef(angle, x, y, z); +} + +void gl2_0_glRotated(void *_glfuncs, GLdouble angle, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRotated(angle, x, y, z); +} + +void gl2_0_glPushMatrix(void *_glfuncs) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushMatrix(); +} + +void gl2_0_glPopMatrix(void *_glfuncs) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopMatrix(); +} + +void gl2_0_glOrtho(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glOrtho(left, right, bottom, top, zNear, zFar); +} + +void gl2_0_glMultMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultMatrixd(m); +} + +void gl2_0_glMultMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultMatrixf(m); +} + +void gl2_0_glMatrixMode(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMatrixMode(mode); +} + +void gl2_0_glLoadMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadMatrixd(m); +} + +void gl2_0_glLoadMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadMatrixf(m); +} + +void gl2_0_glLoadIdentity(void *_glfuncs) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadIdentity(); +} + +void gl2_0_glFrustum(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrustum(left, right, bottom, top, zNear, zFar); +} + +GLboolean gl2_0_glIsList(void *_glfuncs, GLuint list) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsList(list); +} + +void gl2_0_glGetTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, GLint* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGeniv(coord, pname, params); +} + +void gl2_0_glGetTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGenfv(coord, pname, params); +} + +void gl2_0_glGetTexGendv(void *_glfuncs, GLenum coord, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGendv(coord, pname, params); +} + +void gl2_0_glGetTexEnviv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexEnviv(target, pname, params); +} + +void gl2_0_glGetTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexEnvfv(target, pname, params); +} + +void gl2_0_glGetPolygonStipple(void *_glfuncs, GLubyte* mask) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPolygonStipple(mask); +} + +void gl2_0_glGetPixelMapusv(void *_glfuncs, GLenum glmap, GLushort* values) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapusv(glmap, values); +} + +void gl2_0_glGetPixelMapuiv(void *_glfuncs, GLenum glmap, GLuint* values) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapuiv(glmap, values); +} + +void gl2_0_glGetPixelMapfv(void *_glfuncs, GLenum glmap, GLfloat* values) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapfv(glmap, values); +} + +void gl2_0_glGetMaterialiv(void *_glfuncs, GLenum face, GLenum pname, GLint* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMaterialiv(face, pname, params); +} + +void gl2_0_glGetMaterialfv(void *_glfuncs, GLenum face, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMaterialfv(face, pname, params); +} + +void gl2_0_glGetMapiv(void *_glfuncs, GLenum target, GLenum query, GLint* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapiv(target, query, v); +} + +void gl2_0_glGetMapfv(void *_glfuncs, GLenum target, GLenum query, GLfloat* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapfv(target, query, v); +} + +void gl2_0_glGetMapdv(void *_glfuncs, GLenum target, GLenum query, GLdouble* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapdv(target, query, v); +} + +void gl2_0_glGetLightiv(void *_glfuncs, GLenum light, GLenum pname, GLint* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetLightiv(light, pname, params); +} + +void gl2_0_glGetLightfv(void *_glfuncs, GLenum light, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetLightfv(light, pname, params); +} + +void gl2_0_glGetClipPlane(void *_glfuncs, GLenum plane, GLdouble* equation) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetClipPlane(plane, equation); +} + +void gl2_0_glDrawPixels(void *_glfuncs, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawPixels(width, height, format, gltype, pixels); +} + +void gl2_0_glCopyPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum gltype) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyPixels(x, y, width, height, gltype); +} + +void gl2_0_glPixelMapusv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLushort* values) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapusv(glmap, mapsize, values); +} + +void gl2_0_glPixelMapuiv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLuint* values) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapuiv(glmap, mapsize, values); +} + +void gl2_0_glPixelMapfv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLfloat* values) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapfv(glmap, mapsize, values); +} + +void gl2_0_glPixelTransferi(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelTransferi(pname, param); +} + +void gl2_0_glPixelTransferf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelTransferf(pname, param); +} + +void gl2_0_glPixelZoom(void *_glfuncs, GLfloat xfactor, GLfloat yfactor) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelZoom(xfactor, yfactor); +} + +void gl2_0_glAlphaFunc(void *_glfuncs, GLenum glfunc, GLfloat ref) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAlphaFunc(glfunc, ref); +} + +void gl2_0_glEvalPoint2(void *_glfuncs, GLint i, GLint j) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalPoint2(i, j); +} + +void gl2_0_glEvalMesh2(void *_glfuncs, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalMesh2(mode, i1, i2, j1, j2); +} + +void gl2_0_glEvalPoint1(void *_glfuncs, GLint i) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalPoint1(i); +} + +void gl2_0_glEvalMesh1(void *_glfuncs, GLenum mode, GLint i1, GLint i2) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalMesh1(mode, i1, i2); +} + +void gl2_0_glEvalCoord2fv(void *_glfuncs, const GLfloat* u) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2fv(u); +} + +void gl2_0_glEvalCoord2f(void *_glfuncs, GLfloat u, GLfloat v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2f(u, v); +} + +void gl2_0_glEvalCoord2dv(void *_glfuncs, const GLdouble* u) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2dv(u); +} + +void gl2_0_glEvalCoord2d(void *_glfuncs, GLdouble u, GLdouble v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2d(u, v); +} + +void gl2_0_glEvalCoord1fv(void *_glfuncs, const GLfloat* u) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1fv(u); +} + +void gl2_0_glEvalCoord1f(void *_glfuncs, GLfloat u) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1f(u); +} + +void gl2_0_glEvalCoord1dv(void *_glfuncs, const GLdouble* u) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1dv(u); +} + +void gl2_0_glEvalCoord1d(void *_glfuncs, GLdouble u) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1d(u); +} + +void gl2_0_glMapGrid2f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid2f(un, u1, u2, vn, v1, v2); +} + +void gl2_0_glMapGrid2d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid2d(un, u1, u2, vn, v1, v2); +} + +void gl2_0_glMapGrid1f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid1f(un, u1, u2); +} + +void gl2_0_glMapGrid1d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid1d(un, u1, u2); +} + +void gl2_0_glMap2f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); +} + +void gl2_0_glMap2d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); +} + +void gl2_0_glMap1f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap1f(target, u1, u2, stride, order, points); +} + +void gl2_0_glMap1d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap1d(target, u1, u2, stride, order, points); +} + +void gl2_0_glPushAttrib(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushAttrib(mask); +} + +void gl2_0_glPopAttrib(void *_glfuncs) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopAttrib(); +} + +void gl2_0_glAccum(void *_glfuncs, GLenum op, GLfloat value) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAccum(op, value); +} + +void gl2_0_glIndexMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexMask(mask); +} + +void gl2_0_glClearIndex(void *_glfuncs, GLfloat c) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearIndex(c); +} + +void gl2_0_glClearAccum(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearAccum(red, green, blue, alpha); +} + +void gl2_0_glPushName(void *_glfuncs, GLuint name) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushName(name); +} + +void gl2_0_glPopName(void *_glfuncs) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopName(); +} + +void gl2_0_glPassThrough(void *_glfuncs, GLfloat token) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPassThrough(token); +} + +void gl2_0_glLoadName(void *_glfuncs, GLuint name) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadName(name); +} + +void gl2_0_glInitNames(void *_glfuncs) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInitNames(); +} + +GLint gl2_0_glRenderMode(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glRenderMode(mode); +} + +void gl2_0_glSelectBuffer(void *_glfuncs, GLsizei size, GLuint* buffer) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSelectBuffer(size, buffer); +} + +void gl2_0_glFeedbackBuffer(void *_glfuncs, GLsizei size, GLenum gltype, GLfloat* buffer) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFeedbackBuffer(size, gltype, buffer); +} + +void gl2_0_glTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGeniv(coord, pname, params); +} + +void gl2_0_glTexGeni(void *_glfuncs, GLenum coord, GLenum pname, GLint param) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGeni(coord, pname, param); +} + +void gl2_0_glTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGenfv(coord, pname, params); +} + +void gl2_0_glTexGenf(void *_glfuncs, GLenum coord, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGenf(coord, pname, param); +} + +void gl2_0_glTexGendv(void *_glfuncs, GLenum coord, GLenum pname, const GLdouble* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGendv(coord, pname, params); +} + +void gl2_0_glTexGend(void *_glfuncs, GLenum coord, GLenum pname, GLdouble param) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGend(coord, pname, param); +} + +void gl2_0_glTexEnviv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnviv(target, pname, params); +} + +void gl2_0_glTexEnvi(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvi(target, pname, param); +} + +void gl2_0_glTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvfv(target, pname, params); +} + +void gl2_0_glTexEnvf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvf(target, pname, param); +} + +void gl2_0_glShadeModel(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShadeModel(mode); +} + +void gl2_0_glPolygonStipple(void *_glfuncs, const GLubyte* mask) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonStipple(mask); +} + +void gl2_0_glMaterialiv(void *_glfuncs, GLenum face, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialiv(face, pname, params); +} + +void gl2_0_glMateriali(void *_glfuncs, GLenum face, GLenum pname, GLint param) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMateriali(face, pname, param); +} + +void gl2_0_glMaterialfv(void *_glfuncs, GLenum face, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialfv(face, pname, params); +} + +void gl2_0_glMaterialf(void *_glfuncs, GLenum face, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialf(face, pname, param); +} + +void gl2_0_glLineStipple(void *_glfuncs, GLint factor, GLushort pattern) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineStipple(factor, pattern); +} + +void gl2_0_glLightModeliv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModeliv(pname, params); +} + +void gl2_0_glLightModeli(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModeli(pname, param); +} + +void gl2_0_glLightModelfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModelfv(pname, params); +} + +void gl2_0_glLightModelf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModelf(pname, param); +} + +void gl2_0_glLightiv(void *_glfuncs, GLenum light, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightiv(light, pname, params); +} + +void gl2_0_glLighti(void *_glfuncs, GLenum light, GLenum pname, GLint param) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLighti(light, pname, param); +} + +void gl2_0_glLightfv(void *_glfuncs, GLenum light, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightfv(light, pname, params); +} + +void gl2_0_glLightf(void *_glfuncs, GLenum light, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightf(light, pname, param); +} + +void gl2_0_glFogiv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogiv(pname, params); +} + +void gl2_0_glFogi(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogi(pname, param); +} + +void gl2_0_glFogfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogfv(pname, params); +} + +void gl2_0_glFogf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogf(pname, param); +} + +void gl2_0_glColorMaterial(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMaterial(face, mode); +} + +void gl2_0_glClipPlane(void *_glfuncs, GLenum plane, const GLdouble* equation) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClipPlane(plane, equation); +} + +void gl2_0_glVertex4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4sv(v); +} + +void gl2_0_glVertex4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4s(x, y, z, w); +} + +void gl2_0_glVertex4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4iv(v); +} + +void gl2_0_glVertex4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4i(x, y, z, w); +} + +void gl2_0_glVertex4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4fv(v); +} + +void gl2_0_glVertex4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4f(x, y, z, w); +} + +void gl2_0_glVertex4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4dv(v); +} + +void gl2_0_glVertex4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4d(x, y, z, w); +} + +void gl2_0_glVertex3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3sv(v); +} + +void gl2_0_glVertex3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3s(x, y, z); +} + +void gl2_0_glVertex3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3iv(v); +} + +void gl2_0_glVertex3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3i(x, y, z); +} + +void gl2_0_glVertex3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3fv(v); +} + +void gl2_0_glVertex3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3f(x, y, z); +} + +void gl2_0_glVertex3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3dv(v); +} + +void gl2_0_glVertex3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3d(x, y, z); +} + +void gl2_0_glVertex2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2sv(v); +} + +void gl2_0_glVertex2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2s(x, y); +} + +void gl2_0_glVertex2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2iv(v); +} + +void gl2_0_glVertex2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2i(x, y); +} + +void gl2_0_glVertex2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2fv(v); +} + +void gl2_0_glVertex2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2f(x, y); +} + +void gl2_0_glVertex2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2dv(v); +} + +void gl2_0_glVertex2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2d(x, y); +} + +void gl2_0_glTexCoord4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4sv(v); +} + +void gl2_0_glTexCoord4s(void *_glfuncs, GLshort s, GLshort t, GLshort r, GLshort q) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4s(s, t, r, q); +} + +void gl2_0_glTexCoord4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4iv(v); +} + +void gl2_0_glTexCoord4i(void *_glfuncs, GLint s, GLint t, GLint r, GLint q) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4i(s, t, r, q); +} + +void gl2_0_glTexCoord4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4fv(v); +} + +void gl2_0_glTexCoord4f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4f(s, t, r, q); +} + +void gl2_0_glTexCoord4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4dv(v); +} + +void gl2_0_glTexCoord4d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r, GLdouble q) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4d(s, t, r, q); +} + +void gl2_0_glTexCoord3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3sv(v); +} + +void gl2_0_glTexCoord3s(void *_glfuncs, GLshort s, GLshort t, GLshort r) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3s(s, t, r); +} + +void gl2_0_glTexCoord3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3iv(v); +} + +void gl2_0_glTexCoord3i(void *_glfuncs, GLint s, GLint t, GLint r) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3i(s, t, r); +} + +void gl2_0_glTexCoord3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3fv(v); +} + +void gl2_0_glTexCoord3f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3f(s, t, r); +} + +void gl2_0_glTexCoord3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3dv(v); +} + +void gl2_0_glTexCoord3d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3d(s, t, r); +} + +void gl2_0_glTexCoord2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2sv(v); +} + +void gl2_0_glTexCoord2s(void *_glfuncs, GLshort s, GLshort t) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2s(s, t); +} + +void gl2_0_glTexCoord2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2iv(v); +} + +void gl2_0_glTexCoord2i(void *_glfuncs, GLint s, GLint t) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2i(s, t); +} + +void gl2_0_glTexCoord2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2fv(v); +} + +void gl2_0_glTexCoord2f(void *_glfuncs, GLfloat s, GLfloat t) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2f(s, t); +} + +void gl2_0_glTexCoord2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2dv(v); +} + +void gl2_0_glTexCoord2d(void *_glfuncs, GLdouble s, GLdouble t) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2d(s, t); +} + +void gl2_0_glTexCoord1sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1sv(v); +} + +void gl2_0_glTexCoord1s(void *_glfuncs, GLshort s) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1s(s); +} + +void gl2_0_glTexCoord1iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1iv(v); +} + +void gl2_0_glTexCoord1i(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1i(s); +} + +void gl2_0_glTexCoord1fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1fv(v); +} + +void gl2_0_glTexCoord1f(void *_glfuncs, GLfloat s) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1f(s); +} + +void gl2_0_glTexCoord1dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1dv(v); +} + +void gl2_0_glTexCoord1d(void *_glfuncs, GLdouble s) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1d(s); +} + +void gl2_0_glRectsv(void *_glfuncs, const GLshort* v1, const GLshort* v2) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectsv(v1, v2); +} + +void gl2_0_glRects(void *_glfuncs, GLshort x1, GLshort y1, GLshort x2, GLshort y2) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRects(x1, y1, x2, y2); +} + +void gl2_0_glRectiv(void *_glfuncs, const GLint* v1, const GLint* v2) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectiv(v1, v2); +} + +void gl2_0_glRecti(void *_glfuncs, GLint x1, GLint y1, GLint x2, GLint y2) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRecti(x1, y1, x2, y2); +} + +void gl2_0_glRectfv(void *_glfuncs, const GLfloat* v1, const GLfloat* v2) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectfv(v1, v2); +} + +void gl2_0_glRectf(void *_glfuncs, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectf(x1, y1, x2, y2); +} + +void gl2_0_glRectdv(void *_glfuncs, const GLdouble* v1, const GLdouble* v2) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectdv(v1, v2); +} + +void gl2_0_glRectd(void *_glfuncs, GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectd(x1, y1, x2, y2); +} + +void gl2_0_glRasterPos4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4sv(v); +} + +void gl2_0_glRasterPos4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4s(x, y, z, w); +} + +void gl2_0_glRasterPos4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4iv(v); +} + +void gl2_0_glRasterPos4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4i(x, y, z, w); +} + +void gl2_0_glRasterPos4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4fv(v); +} + +void gl2_0_glRasterPos4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4f(x, y, z, w); +} + +void gl2_0_glRasterPos4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4dv(v); +} + +void gl2_0_glRasterPos4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4d(x, y, z, w); +} + +void gl2_0_glRasterPos3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3sv(v); +} + +void gl2_0_glRasterPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3s(x, y, z); +} + +void gl2_0_glRasterPos3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3iv(v); +} + +void gl2_0_glRasterPos3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3i(x, y, z); +} + +void gl2_0_glRasterPos3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3fv(v); +} + +void gl2_0_glRasterPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3f(x, y, z); +} + +void gl2_0_glRasterPos3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3dv(v); +} + +void gl2_0_glRasterPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3d(x, y, z); +} + +void gl2_0_glRasterPos2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2sv(v); +} + +void gl2_0_glRasterPos2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2s(x, y); +} + +void gl2_0_glRasterPos2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2iv(v); +} + +void gl2_0_glRasterPos2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2i(x, y); +} + +void gl2_0_glRasterPos2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2fv(v); +} + +void gl2_0_glRasterPos2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2f(x, y); +} + +void gl2_0_glRasterPos2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2dv(v); +} + +void gl2_0_glRasterPos2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2d(x, y); +} + +void gl2_0_glNormal3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3sv(v); +} + +void gl2_0_glNormal3s(void *_glfuncs, GLshort nx, GLshort ny, GLshort nz) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3s(nx, ny, nz); +} + +void gl2_0_glNormal3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3iv(v); +} + +void gl2_0_glNormal3i(void *_glfuncs, GLint nx, GLint ny, GLint nz) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3i(nx, ny, nz); +} + +void gl2_0_glNormal3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3fv(v); +} + +void gl2_0_glNormal3f(void *_glfuncs, GLfloat nx, GLfloat ny, GLfloat nz) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3f(nx, ny, nz); +} + +void gl2_0_glNormal3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3dv(v); +} + +void gl2_0_glNormal3d(void *_glfuncs, GLdouble nx, GLdouble ny, GLdouble nz) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3d(nx, ny, nz); +} + +void gl2_0_glNormal3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3bv(v); +} + +void gl2_0_glNormal3b(void *_glfuncs, GLbyte nx, GLbyte ny, GLbyte nz) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3b(nx, ny, nz); +} + +void gl2_0_glIndexsv(void *_glfuncs, const GLshort* c) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexsv(c); +} + +void gl2_0_glIndexs(void *_glfuncs, GLshort c) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexs(c); +} + +void gl2_0_glIndexiv(void *_glfuncs, const GLint* c) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexiv(c); +} + +void gl2_0_glIndexi(void *_glfuncs, GLint c) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexi(c); +} + +void gl2_0_glIndexfv(void *_glfuncs, const GLfloat* c) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexfv(c); +} + +void gl2_0_glIndexf(void *_glfuncs, GLfloat c) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexf(c); +} + +void gl2_0_glIndexdv(void *_glfuncs, const GLdouble* c) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexdv(c); +} + +void gl2_0_glIndexd(void *_glfuncs, GLdouble c) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexd(c); +} + +void gl2_0_glEnd(void *_glfuncs) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnd(); +} + +void gl2_0_glEdgeFlagv(void *_glfuncs, const GLboolean* flag) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlagv(flag); +} + +void gl2_0_glEdgeFlag(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlag(flag); +} + +void gl2_0_glColor4usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4usv(v); +} + +void gl2_0_glColor4us(void *_glfuncs, GLushort red, GLushort green, GLushort blue, GLushort alpha) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4us(red, green, blue, alpha); +} + +void gl2_0_glColor4uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4uiv(v); +} + +void gl2_0_glColor4ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue, GLuint alpha) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ui(red, green, blue, alpha); +} + +void gl2_0_glColor4ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ubv(v); +} + +void gl2_0_glColor4ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ub(red, green, blue, alpha); +} + +void gl2_0_glColor4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4sv(v); +} + +void gl2_0_glColor4s(void *_glfuncs, GLshort red, GLshort green, GLshort blue, GLshort alpha) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4s(red, green, blue, alpha); +} + +void gl2_0_glColor4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4iv(v); +} + +void gl2_0_glColor4i(void *_glfuncs, GLint red, GLint green, GLint blue, GLint alpha) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4i(red, green, blue, alpha); +} + +void gl2_0_glColor4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4fv(v); +} + +void gl2_0_glColor4f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4f(red, green, blue, alpha); +} + +void gl2_0_glColor4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4dv(v); +} + +void gl2_0_glColor4d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4d(red, green, blue, alpha); +} + +void gl2_0_glColor4bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4bv(v); +} + +void gl2_0_glColor4b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4b(red, green, blue, alpha); +} + +void gl2_0_glColor3usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3usv(v); +} + +void gl2_0_glColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3us(red, green, blue); +} + +void gl2_0_glColor3uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3uiv(v); +} + +void gl2_0_glColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ui(red, green, blue); +} + +void gl2_0_glColor3ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ubv(v); +} + +void gl2_0_glColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ub(red, green, blue); +} + +void gl2_0_glColor3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3sv(v); +} + +void gl2_0_glColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3s(red, green, blue); +} + +void gl2_0_glColor3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3iv(v); +} + +void gl2_0_glColor3i(void *_glfuncs, GLint red, GLint green, GLint blue) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3i(red, green, blue); +} + +void gl2_0_glColor3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3fv(v); +} + +void gl2_0_glColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3f(red, green, blue); +} + +void gl2_0_glColor3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3dv(v); +} + +void gl2_0_glColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3d(red, green, blue); +} + +void gl2_0_glColor3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3bv(v); +} + +void gl2_0_glColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3b(red, green, blue); +} + +void gl2_0_glBitmap(void *_glfuncs, GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBitmap(width, height, xorig, yorig, xmove, ymove, bitmap); +} + +void gl2_0_glBegin(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBegin(mode); +} + +void gl2_0_glListBase(void *_glfuncs, GLuint base) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glListBase(base); +} + +GLuint gl2_0_glGenLists(void *_glfuncs, GLsizei range_) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGenLists(range_); +} + +void gl2_0_glDeleteLists(void *_glfuncs, GLuint list, GLsizei range_) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteLists(list, range_); +} + +void gl2_0_glCallLists(void *_glfuncs, GLsizei n, GLenum gltype, const GLvoid* lists) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCallLists(n, gltype, lists); +} + +void gl2_0_glCallList(void *_glfuncs, GLuint list) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCallList(list); +} + +void gl2_0_glEndList(void *_glfuncs) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndList(); +} + +void gl2_0_glNewList(void *_glfuncs, GLuint list, GLenum mode) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNewList(list, mode); +} + +void gl2_0_glPushClientAttrib(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushClientAttrib(mask); +} + +void gl2_0_glPopClientAttrib(void *_glfuncs) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopClientAttrib(); +} + +void gl2_0_glPrioritizeTextures(void *_glfuncs, GLsizei n, const GLuint* textures, const GLfloat* priorities) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPrioritizeTextures(n, textures, priorities); +} + +GLboolean gl2_0_glAreTexturesResident(void *_glfuncs, GLsizei n, const GLuint* textures, GLboolean* residences) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glAreTexturesResident(n, textures, residences); +} + +void gl2_0_glVertexPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexPointer(size, gltype, stride, pointer); +} + +void gl2_0_glTexCoordPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordPointer(size, gltype, stride, pointer); +} + +void gl2_0_glNormalPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormalPointer(gltype, stride, pointer); +} + +void gl2_0_glInterleavedArrays(void *_glfuncs, GLenum format, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInterleavedArrays(format, stride, pointer); +} + +void gl2_0_glIndexPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexPointer(gltype, stride, pointer); +} + +void gl2_0_glEnableClientState(void *_glfuncs, GLenum array) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnableClientState(array); +} + +void gl2_0_glEdgeFlagPointer(void *_glfuncs, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlagPointer(stride, pointer); +} + +void gl2_0_glDisableClientState(void *_glfuncs, GLenum array) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisableClientState(array); +} + +void gl2_0_glColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorPointer(size, gltype, stride, pointer); +} + +void gl2_0_glArrayElement(void *_glfuncs, GLint i) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glArrayElement(i); +} + +void gl2_0_glResetMinmax(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glResetMinmax(target); +} + +void gl2_0_glResetHistogram(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glResetHistogram(target); +} + +void gl2_0_glMinmax(void *_glfuncs, GLenum target, GLenum internalFormat, GLboolean sink) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMinmax(target, internalFormat, sink); +} + +void gl2_0_glHistogram(void *_glfuncs, GLenum target, GLsizei width, GLenum internalFormat, GLboolean sink) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glHistogram(target, width, internalFormat, sink); +} + +void gl2_0_glGetMinmaxParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmaxParameteriv(target, pname, params); +} + +void gl2_0_glGetMinmaxParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmaxParameterfv(target, pname, params); +} + +void gl2_0_glGetMinmax(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmax(target, reset, format, gltype, values); +} + +void gl2_0_glGetHistogramParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogramParameteriv(target, pname, params); +} + +void gl2_0_glGetHistogramParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogramParameterfv(target, pname, params); +} + +void gl2_0_glGetHistogram(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogram(target, reset, format, gltype, values); +} + +void gl2_0_glSeparableFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* row, const GLvoid* column) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSeparableFilter2D(target, internalFormat, width, height, format, gltype, row, column); +} + +void gl2_0_glGetSeparableFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* row, GLvoid* column, GLvoid* span) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSeparableFilter(target, format, gltype, row, column, span); +} + +void gl2_0_glGetConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionParameteriv(target, pname, params); +} + +void gl2_0_glGetConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionParameterfv(target, pname, params); +} + +void gl2_0_glGetConvolutionFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* image) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionFilter(target, format, gltype, image); +} + +void gl2_0_glCopyConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyConvolutionFilter2D(target, internalFormat, x, y, width, height); +} + +void gl2_0_glCopyConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyConvolutionFilter1D(target, internalFormat, x, y, width); +} + +void gl2_0_glConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameteriv(target, pname, params); +} + +void gl2_0_glConvolutionParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameteri(target, pname, params); +} + +void gl2_0_glConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameterfv(target, pname, params); +} + +void gl2_0_glConvolutionParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameterf(target, pname, params); +} + +void gl2_0_glConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* image) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionFilter2D(target, internalFormat, width, height, format, gltype, image); +} + +void gl2_0_glConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* image) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionFilter1D(target, internalFormat, width, format, gltype, image); +} + +void gl2_0_glCopyColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyColorSubTable(target, start, x, y, width); +} + +void gl2_0_glColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum gltype, const GLvoid* data) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorSubTable(target, start, count, format, gltype, data); +} + +void gl2_0_glGetColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTableParameteriv(target, pname, params); +} + +void gl2_0_glGetColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTableParameterfv(target, pname, params); +} + +void gl2_0_glGetColorTable(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* table) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTable(target, format, gltype, table); +} + +void gl2_0_glCopyColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyColorTable(target, internalFormat, x, y, width); +} + +void gl2_0_glColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTableParameteriv(target, pname, params); +} + +void gl2_0_glColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTableParameterfv(target, pname, params); +} + +void gl2_0_glColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* table) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTable(target, internalFormat, width, format, gltype, table); +} + +void gl2_0_glMultTransposeMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultTransposeMatrixd(m); +} + +void gl2_0_glMultTransposeMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultTransposeMatrixf(m); +} + +void gl2_0_glLoadTransposeMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadTransposeMatrixd(m); +} + +void gl2_0_glLoadTransposeMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadTransposeMatrixf(m); +} + +void gl2_0_glMultiTexCoord4sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4sv(target, v); +} + +void gl2_0_glMultiTexCoord4s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r, GLshort q) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4s(target, s, t, r, q); +} + +void gl2_0_glMultiTexCoord4iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4iv(target, v); +} + +void gl2_0_glMultiTexCoord4i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r, GLint q) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4i(target, s, t, r, q); +} + +void gl2_0_glMultiTexCoord4fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4fv(target, v); +} + +void gl2_0_glMultiTexCoord4f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4f(target, s, t, r, q); +} + +void gl2_0_glMultiTexCoord4dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4dv(target, v); +} + +void gl2_0_glMultiTexCoord4d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4d(target, s, t, r, q); +} + +void gl2_0_glMultiTexCoord3sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3sv(target, v); +} + +void gl2_0_glMultiTexCoord3s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3s(target, s, t, r); +} + +void gl2_0_glMultiTexCoord3iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3iv(target, v); +} + +void gl2_0_glMultiTexCoord3i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3i(target, s, t, r); +} + +void gl2_0_glMultiTexCoord3fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3fv(target, v); +} + +void gl2_0_glMultiTexCoord3f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3f(target, s, t, r); +} + +void gl2_0_glMultiTexCoord3dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3dv(target, v); +} + +void gl2_0_glMultiTexCoord3d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3d(target, s, t, r); +} + +void gl2_0_glMultiTexCoord2sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2sv(target, v); +} + +void gl2_0_glMultiTexCoord2s(void *_glfuncs, GLenum target, GLshort s, GLshort t) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2s(target, s, t); +} + +void gl2_0_glMultiTexCoord2iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2iv(target, v); +} + +void gl2_0_glMultiTexCoord2i(void *_glfuncs, GLenum target, GLint s, GLint t) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2i(target, s, t); +} + +void gl2_0_glMultiTexCoord2fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2fv(target, v); +} + +void gl2_0_glMultiTexCoord2f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2f(target, s, t); +} + +void gl2_0_glMultiTexCoord2dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2dv(target, v); +} + +void gl2_0_glMultiTexCoord2d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2d(target, s, t); +} + +void gl2_0_glMultiTexCoord1sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1sv(target, v); +} + +void gl2_0_glMultiTexCoord1s(void *_glfuncs, GLenum target, GLshort s) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1s(target, s); +} + +void gl2_0_glMultiTexCoord1iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1iv(target, v); +} + +void gl2_0_glMultiTexCoord1i(void *_glfuncs, GLenum target, GLint s) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1i(target, s); +} + +void gl2_0_glMultiTexCoord1fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1fv(target, v); +} + +void gl2_0_glMultiTexCoord1f(void *_glfuncs, GLenum target, GLfloat s) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1f(target, s); +} + +void gl2_0_glMultiTexCoord1dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1dv(target, v); +} + +void gl2_0_glMultiTexCoord1d(void *_glfuncs, GLenum target, GLdouble s) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1d(target, s); +} + +void gl2_0_glClientActiveTexture(void *_glfuncs, GLenum texture) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClientActiveTexture(texture); +} + +void gl2_0_glWindowPos3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3sv(v); +} + +void gl2_0_glWindowPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3s(x, y, z); +} + +void gl2_0_glWindowPos3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3iv(v); +} + +void gl2_0_glWindowPos3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3i(x, y, z); +} + +void gl2_0_glWindowPos3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3fv(v); +} + +void gl2_0_glWindowPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3f(x, y, z); +} + +void gl2_0_glWindowPos3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3dv(v); +} + +void gl2_0_glWindowPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3d(x, y, z); +} + +void gl2_0_glWindowPos2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2sv(v); +} + +void gl2_0_glWindowPos2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2s(x, y); +} + +void gl2_0_glWindowPos2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2iv(v); +} + +void gl2_0_glWindowPos2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2i(x, y); +} + +void gl2_0_glWindowPos2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2fv(v); +} + +void gl2_0_glWindowPos2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2f(x, y); +} + +void gl2_0_glWindowPos2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2dv(v); +} + +void gl2_0_glWindowPos2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2d(x, y); +} + +void gl2_0_glSecondaryColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColorPointer(size, gltype, stride, pointer); +} + +void gl2_0_glSecondaryColor3usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3usv(v); +} + +void gl2_0_glSecondaryColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3us(red, green, blue); +} + +void gl2_0_glSecondaryColor3uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3uiv(v); +} + +void gl2_0_glSecondaryColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3ui(red, green, blue); +} + +void gl2_0_glSecondaryColor3ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3ubv(v); +} + +void gl2_0_glSecondaryColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3ub(red, green, blue); +} + +void gl2_0_glSecondaryColor3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3sv(v); +} + +void gl2_0_glSecondaryColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3s(red, green, blue); +} + +void gl2_0_glSecondaryColor3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3iv(v); +} + +void gl2_0_glSecondaryColor3i(void *_glfuncs, GLint red, GLint green, GLint blue) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3i(red, green, blue); +} + +void gl2_0_glSecondaryColor3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3fv(v); +} + +void gl2_0_glSecondaryColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3f(red, green, blue); +} + +void gl2_0_glSecondaryColor3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3dv(v); +} + +void gl2_0_glSecondaryColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3d(red, green, blue); +} + +void gl2_0_glSecondaryColor3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3bv(v); +} + +void gl2_0_glSecondaryColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3b(red, green, blue); +} + +void gl2_0_glFogCoordPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordPointer(gltype, stride, pointer); +} + +void gl2_0_glFogCoorddv(void *_glfuncs, const GLdouble* coord) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoorddv(coord); +} + +void gl2_0_glFogCoordd(void *_glfuncs, GLdouble coord) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordd(coord); +} + +void gl2_0_glFogCoordfv(void *_glfuncs, const GLfloat* coord) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordfv(coord); +} + +void gl2_0_glFogCoordf(void *_glfuncs, GLfloat coord) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordf(coord); +} + +void gl2_0_glVertexAttrib4usv(void *_glfuncs, GLuint index, const GLushort* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4usv(index, v); +} + +void gl2_0_glVertexAttrib4uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4uiv(index, v); +} + +void gl2_0_glVertexAttrib4ubv(void *_glfuncs, GLuint index, const GLubyte* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4ubv(index, v); +} + +void gl2_0_glVertexAttrib4sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4sv(index, v); +} + +void gl2_0_glVertexAttrib4s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4s(index, x, y, z, w); +} + +void gl2_0_glVertexAttrib4iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4iv(index, v); +} + +void gl2_0_glVertexAttrib4fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4fv(index, v); +} + +void gl2_0_glVertexAttrib4f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4f(index, x, y, z, w); +} + +void gl2_0_glVertexAttrib4dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4dv(index, v); +} + +void gl2_0_glVertexAttrib4d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4d(index, x, y, z, w); +} + +void gl2_0_glVertexAttrib4bv(void *_glfuncs, GLuint index, const GLbyte* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4bv(index, v); +} + +void gl2_0_glVertexAttrib4Nusv(void *_glfuncs, GLuint index, const GLushort* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nusv(index, v); +} + +void gl2_0_glVertexAttrib4Nuiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nuiv(index, v); +} + +void gl2_0_glVertexAttrib4Nubv(void *_glfuncs, GLuint index, const GLubyte* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nubv(index, v); +} + +void gl2_0_glVertexAttrib4Nub(void *_glfuncs, GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nub(index, x, y, z, w); +} + +void gl2_0_glVertexAttrib4Nsv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nsv(index, v); +} + +void gl2_0_glVertexAttrib4Niv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Niv(index, v); +} + +void gl2_0_glVertexAttrib4Nbv(void *_glfuncs, GLuint index, const GLbyte* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nbv(index, v); +} + +void gl2_0_glVertexAttrib3sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3sv(index, v); +} + +void gl2_0_glVertexAttrib3s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3s(index, x, y, z); +} + +void gl2_0_glVertexAttrib3fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3fv(index, v); +} + +void gl2_0_glVertexAttrib3f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3f(index, x, y, z); +} + +void gl2_0_glVertexAttrib3dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3dv(index, v); +} + +void gl2_0_glVertexAttrib3d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3d(index, x, y, z); +} + +void gl2_0_glVertexAttrib2sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2sv(index, v); +} + +void gl2_0_glVertexAttrib2s(void *_glfuncs, GLuint index, GLshort x, GLshort y) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2s(index, x, y); +} + +void gl2_0_glVertexAttrib2fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2fv(index, v); +} + +void gl2_0_glVertexAttrib2f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2f(index, x, y); +} + +void gl2_0_glVertexAttrib2dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2dv(index, v); +} + +void gl2_0_glVertexAttrib2d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2d(index, x, y); +} + +void gl2_0_glVertexAttrib1sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1sv(index, v); +} + +void gl2_0_glVertexAttrib1s(void *_glfuncs, GLuint index, GLshort x) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1s(index, x); +} + +void gl2_0_glVertexAttrib1fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1fv(index, v); +} + +void gl2_0_glVertexAttrib1f(void *_glfuncs, GLuint index, GLfloat x) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1f(index, x); +} + +void gl2_0_glVertexAttrib1dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1dv(index, v); +} + +void gl2_0_glVertexAttrib1d(void *_glfuncs, GLuint index, GLdouble x) +{ + QOpenGLFunctions_2_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1d(index, x); +} + diff --git a/gl/2.0/funcs.h b/gl/2.0/funcs.h new file mode 100644 index 00000000..ffa1a2a8 --- /dev/null +++ b/gl/2.0/funcs.h @@ -0,0 +1,613 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#ifndef __cplusplus +#include +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef char GLchar; +typedef signed char GLbyte; /* 1-byte signed */ +typedef short GLshort; /* 2-byte signed */ +typedef int GLint; /* 4-byte signed */ +typedef unsigned char GLubyte; /* 1-byte unsigned */ +typedef unsigned short GLushort; /* 2-byte unsigned */ +typedef unsigned int GLuint; /* 4-byte unsigned */ +typedef int GLsizei; /* 4-byte signed */ +typedef float GLfloat; /* single precision float */ +typedef float GLclampf; /* single precision float in [0,1] */ +typedef double GLdouble; /* double precision float */ +typedef double GLclampd; /* double precision float in [0,1] */ +typedef int64_t GLint64; +typedef uint64_t GLuint64; +typedef ptrdiff_t GLintptr; +typedef ptrdiff_t GLsizeiptr; +typedef ptrdiff_t GLintptrARB; +typedef ptrdiff_t GLsizeiptrARB; +typedef struct __GLsync *GLsync; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +void *gl2_0_funcs(); + +void gl2_0_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl2_0_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal); +GLboolean gl2_0_glIsEnabled(void *_glfuncs, GLenum cap); +void gl2_0_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params); +void gl2_0_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params); +void gl2_0_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl2_0_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl2_0_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels); +void gl2_0_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params); +void gl2_0_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params); +GLenum gl2_0_glGetError(void *_glfuncs); +void gl2_0_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params); +void gl2_0_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params); +void gl2_0_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels); +void gl2_0_glReadBuffer(void *_glfuncs, GLenum mode); +void gl2_0_glPixelStorei(void *_glfuncs, GLenum pname, GLint param); +void gl2_0_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param); +void gl2_0_glDepthFunc(void *_glfuncs, GLenum glfunc); +void gl2_0_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass); +void gl2_0_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask); +void gl2_0_glLogicOp(void *_glfuncs, GLenum opcode); +void gl2_0_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor); +void gl2_0_glFlush(void *_glfuncs); +void gl2_0_glFinish(void *_glfuncs); +void gl2_0_glEnable(void *_glfuncs, GLenum cap); +void gl2_0_glDisable(void *_glfuncs, GLenum cap); +void gl2_0_glDepthMask(void *_glfuncs, GLboolean flag); +void gl2_0_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +void gl2_0_glStencilMask(void *_glfuncs, GLuint mask); +void gl2_0_glClearDepth(void *_glfuncs, GLdouble depth); +void gl2_0_glClearStencil(void *_glfuncs, GLint s); +void gl2_0_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl2_0_glClear(void *_glfuncs, GLbitfield mask); +void gl2_0_glDrawBuffer(void *_glfuncs, GLenum mode); +void gl2_0_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl2_0_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl2_0_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl2_0_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl2_0_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl2_0_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl2_0_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl2_0_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode); +void gl2_0_glPointSize(void *_glfuncs, GLfloat size); +void gl2_0_glLineWidth(void *_glfuncs, GLfloat width); +void gl2_0_glHint(void *_glfuncs, GLenum target, GLenum mode); +void gl2_0_glFrontFace(void *_glfuncs, GLenum mode); +void gl2_0_glCullFace(void *_glfuncs, GLenum mode); +void gl2_0_glIndexubv(void *_glfuncs, const GLubyte* c); +void gl2_0_glIndexub(void *_glfuncs, GLubyte c); +GLboolean gl2_0_glIsTexture(void *_glfuncs, GLuint texture); +void gl2_0_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures); +void gl2_0_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures); +void gl2_0_glBindTexture(void *_glfuncs, GLenum target, GLuint texture); +void gl2_0_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl2_0_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl2_0_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl2_0_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +void gl2_0_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +void gl2_0_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border); +void gl2_0_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units); +void gl2_0_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl2_0_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count); +void gl2_0_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl2_0_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl2_0_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl2_0_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl2_0_glBlendEquation(void *_glfuncs, GLenum mode); +void gl2_0_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl2_0_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img); +void gl2_0_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl2_0_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl2_0_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl2_0_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data); +void gl2_0_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data); +void gl2_0_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data); +void gl2_0_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert); +void gl2_0_glActiveTexture(void *_glfuncs, GLenum texture); +void gl2_0_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params); +void gl2_0_glPointParameteri(void *_glfuncs, GLenum pname, GLint param); +void gl2_0_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl2_0_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param); +void gl2_0_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount); +void gl2_0_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +void gl2_0_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +GLboolean gl2_0_glUnmapBuffer(void *_glfuncs, GLenum target); +void gl2_0_glGetBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data); +void gl2_0_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data); +void gl2_0_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage); +GLboolean gl2_0_glIsBuffer(void *_glfuncs, GLuint buffer); +void gl2_0_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers); +void gl2_0_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers); +void gl2_0_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer); +void gl2_0_glGetQueryObjectuiv(void *_glfuncs, GLuint id, GLenum pname, GLuint* params); +void gl2_0_glGetQueryObjectiv(void *_glfuncs, GLuint id, GLenum pname, GLint* params); +void gl2_0_glGetQueryiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl2_0_glEndQuery(void *_glfuncs, GLenum target); +void gl2_0_glBeginQuery(void *_glfuncs, GLenum target, GLuint id); +GLboolean gl2_0_glIsQuery(void *_glfuncs, GLuint id); +void gl2_0_glDeleteQueries(void *_glfuncs, GLsizei n, const GLuint* ids); +void gl2_0_glGenQueries(void *_glfuncs, GLsizei n, GLuint* ids); +void gl2_0_glVertexAttribPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLboolean normalized, GLsizei stride, const GLvoid* offset); +void gl2_0_glValidateProgram(void *_glfuncs, GLuint program); +void gl2_0_glUniformMatrix4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl2_0_glUniformMatrix3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl2_0_glUniformMatrix2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl2_0_glUniform4iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl2_0_glUniform3iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl2_0_glUniform2iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl2_0_glUniform1iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl2_0_glUniform4fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl2_0_glUniform3fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl2_0_glUniform2fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl2_0_glUniform1fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl2_0_glUniform4i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +void gl2_0_glUniform3i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2); +void gl2_0_glUniform2i(void *_glfuncs, GLint location, GLint v0, GLint v1); +void gl2_0_glUniform1i(void *_glfuncs, GLint location, GLint v0); +void gl2_0_glUniform4f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +void gl2_0_glUniform3f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +void gl2_0_glUniform2f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1); +void gl2_0_glUniform1f(void *_glfuncs, GLint location, GLfloat v0); +void gl2_0_glUseProgram(void *_glfuncs, GLuint program); +void gl2_0_glShaderSource(void *_glfuncs, GLuint shader, GLsizei count, const GLchar** source, const GLint* length); +void gl2_0_glLinkProgram(void *_glfuncs, GLuint program); +GLboolean gl2_0_glIsShader(void *_glfuncs, GLuint shader); +GLboolean gl2_0_glIsProgram(void *_glfuncs, GLuint program); +void gl2_0_glGetVertexAttribiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params); +void gl2_0_glGetVertexAttribfv(void *_glfuncs, GLuint index, GLenum pname, GLfloat* params); +void gl2_0_glGetVertexAttribdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params); +void gl2_0_glGetUniformiv(void *_glfuncs, GLuint program, GLint location, GLint* params); +void gl2_0_glGetUniformfv(void *_glfuncs, GLuint program, GLint location, GLfloat* params); +GLint gl2_0_glGetUniformLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl2_0_glGetShaderSource(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source); +void gl2_0_glGetShaderInfoLog(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl2_0_glGetShaderiv(void *_glfuncs, GLuint shader, GLenum pname, GLint* params); +void gl2_0_glGetProgramInfoLog(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl2_0_glGetProgramiv(void *_glfuncs, GLuint program, GLenum pname, GLint* params); +GLint gl2_0_glGetAttribLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl2_0_glGetAttachedShaders(void *_glfuncs, GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj); +void gl2_0_glGetActiveUniform(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name); +void gl2_0_glGetActiveAttrib(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name); +void gl2_0_glEnableVertexAttribArray(void *_glfuncs, GLuint index); +void gl2_0_glDisableVertexAttribArray(void *_glfuncs, GLuint index); +void gl2_0_glDetachShader(void *_glfuncs, GLuint program, GLuint shader); +void gl2_0_glDeleteShader(void *_glfuncs, GLuint shader); +void gl2_0_glDeleteProgram(void *_glfuncs, GLuint program); +GLuint gl2_0_glCreateShader(void *_glfuncs, GLenum gltype); +GLuint gl2_0_glCreateProgram(void *_glfuncs); +void gl2_0_glCompileShader(void *_glfuncs, GLuint shader); +void gl2_0_glBindAttribLocation(void *_glfuncs, GLuint program, GLuint index, const GLchar* name); +void gl2_0_glAttachShader(void *_glfuncs, GLuint program, GLuint shader); +void gl2_0_glStencilMaskSeparate(void *_glfuncs, GLenum face, GLuint mask); +void gl2_0_glStencilFuncSeparate(void *_glfuncs, GLenum face, GLenum glfunc, GLint ref, GLuint mask); +void gl2_0_glStencilOpSeparate(void *_glfuncs, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +void gl2_0_glDrawBuffers(void *_glfuncs, GLsizei n, const GLenum* bufs); +void gl2_0_glBlendEquationSeparate(void *_glfuncs, GLenum modeRGB, GLenum modeAlpha); +void gl2_0_glTranslatef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl2_0_glTranslated(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl2_0_glScalef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl2_0_glScaled(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl2_0_glRotatef(void *_glfuncs, GLfloat angle, GLfloat x, GLfloat y, GLfloat z); +void gl2_0_glRotated(void *_glfuncs, GLdouble angle, GLdouble x, GLdouble y, GLdouble z); +void gl2_0_glPushMatrix(void *_glfuncs); +void gl2_0_glPopMatrix(void *_glfuncs); +void gl2_0_glOrtho(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +void gl2_0_glMultMatrixd(void *_glfuncs, const GLdouble* m); +void gl2_0_glMultMatrixf(void *_glfuncs, const GLfloat* m); +void gl2_0_glMatrixMode(void *_glfuncs, GLenum mode); +void gl2_0_glLoadMatrixd(void *_glfuncs, const GLdouble* m); +void gl2_0_glLoadMatrixf(void *_glfuncs, const GLfloat* m); +void gl2_0_glLoadIdentity(void *_glfuncs); +void gl2_0_glFrustum(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +GLboolean gl2_0_glIsList(void *_glfuncs, GLuint list); +void gl2_0_glGetTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, GLint* params); +void gl2_0_glGetTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, GLfloat* params); +void gl2_0_glGetTexGendv(void *_glfuncs, GLenum coord, GLenum pname, GLdouble* params); +void gl2_0_glGetTexEnviv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl2_0_glGetTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl2_0_glGetPolygonStipple(void *_glfuncs, GLubyte* mask); +void gl2_0_glGetPixelMapusv(void *_glfuncs, GLenum glmap, GLushort* values); +void gl2_0_glGetPixelMapuiv(void *_glfuncs, GLenum glmap, GLuint* values); +void gl2_0_glGetPixelMapfv(void *_glfuncs, GLenum glmap, GLfloat* values); +void gl2_0_glGetMaterialiv(void *_glfuncs, GLenum face, GLenum pname, GLint* params); +void gl2_0_glGetMaterialfv(void *_glfuncs, GLenum face, GLenum pname, GLfloat* params); +void gl2_0_glGetMapiv(void *_glfuncs, GLenum target, GLenum query, GLint* v); +void gl2_0_glGetMapfv(void *_glfuncs, GLenum target, GLenum query, GLfloat* v); +void gl2_0_glGetMapdv(void *_glfuncs, GLenum target, GLenum query, GLdouble* v); +void gl2_0_glGetLightiv(void *_glfuncs, GLenum light, GLenum pname, GLint* params); +void gl2_0_glGetLightfv(void *_glfuncs, GLenum light, GLenum pname, GLfloat* params); +void gl2_0_glGetClipPlane(void *_glfuncs, GLenum plane, GLdouble* equation); +void gl2_0_glDrawPixels(void *_glfuncs, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl2_0_glCopyPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum gltype); +void gl2_0_glPixelMapusv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLushort* values); +void gl2_0_glPixelMapuiv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLuint* values); +void gl2_0_glPixelMapfv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLfloat* values); +void gl2_0_glPixelTransferi(void *_glfuncs, GLenum pname, GLint param); +void gl2_0_glPixelTransferf(void *_glfuncs, GLenum pname, GLfloat param); +void gl2_0_glPixelZoom(void *_glfuncs, GLfloat xfactor, GLfloat yfactor); +void gl2_0_glAlphaFunc(void *_glfuncs, GLenum glfunc, GLfloat ref); +void gl2_0_glEvalPoint2(void *_glfuncs, GLint i, GLint j); +void gl2_0_glEvalMesh2(void *_glfuncs, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); +void gl2_0_glEvalPoint1(void *_glfuncs, GLint i); +void gl2_0_glEvalMesh1(void *_glfuncs, GLenum mode, GLint i1, GLint i2); +void gl2_0_glEvalCoord2fv(void *_glfuncs, const GLfloat* u); +void gl2_0_glEvalCoord2f(void *_glfuncs, GLfloat u, GLfloat v); +void gl2_0_glEvalCoord2dv(void *_glfuncs, const GLdouble* u); +void gl2_0_glEvalCoord2d(void *_glfuncs, GLdouble u, GLdouble v); +void gl2_0_glEvalCoord1fv(void *_glfuncs, const GLfloat* u); +void gl2_0_glEvalCoord1f(void *_glfuncs, GLfloat u); +void gl2_0_glEvalCoord1dv(void *_glfuncs, const GLdouble* u); +void gl2_0_glEvalCoord1d(void *_glfuncs, GLdouble u); +void gl2_0_glMapGrid2f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); +void gl2_0_glMapGrid2d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); +void gl2_0_glMapGrid1f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2); +void gl2_0_glMapGrid1d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2); +void gl2_0_glMap2f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points); +void gl2_0_glMap2d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points); +void gl2_0_glMap1f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points); +void gl2_0_glMap1d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points); +void gl2_0_glPushAttrib(void *_glfuncs, GLbitfield mask); +void gl2_0_glPopAttrib(void *_glfuncs); +void gl2_0_glAccum(void *_glfuncs, GLenum op, GLfloat value); +void gl2_0_glIndexMask(void *_glfuncs, GLuint mask); +void gl2_0_glClearIndex(void *_glfuncs, GLfloat c); +void gl2_0_glClearAccum(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl2_0_glPushName(void *_glfuncs, GLuint name); +void gl2_0_glPopName(void *_glfuncs); +void gl2_0_glPassThrough(void *_glfuncs, GLfloat token); +void gl2_0_glLoadName(void *_glfuncs, GLuint name); +void gl2_0_glInitNames(void *_glfuncs); +GLint gl2_0_glRenderMode(void *_glfuncs, GLenum mode); +void gl2_0_glSelectBuffer(void *_glfuncs, GLsizei size, GLuint* buffer); +void gl2_0_glFeedbackBuffer(void *_glfuncs, GLsizei size, GLenum gltype, GLfloat* buffer); +void gl2_0_glTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, const GLint* params); +void gl2_0_glTexGeni(void *_glfuncs, GLenum coord, GLenum pname, GLint param); +void gl2_0_glTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, const GLfloat* params); +void gl2_0_glTexGenf(void *_glfuncs, GLenum coord, GLenum pname, GLfloat param); +void gl2_0_glTexGendv(void *_glfuncs, GLenum coord, GLenum pname, const GLdouble* params); +void gl2_0_glTexGend(void *_glfuncs, GLenum coord, GLenum pname, GLdouble param); +void gl2_0_glTexEnviv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl2_0_glTexEnvi(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl2_0_glTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl2_0_glTexEnvf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl2_0_glShadeModel(void *_glfuncs, GLenum mode); +void gl2_0_glPolygonStipple(void *_glfuncs, const GLubyte* mask); +void gl2_0_glMaterialiv(void *_glfuncs, GLenum face, GLenum pname, const GLint* params); +void gl2_0_glMateriali(void *_glfuncs, GLenum face, GLenum pname, GLint param); +void gl2_0_glMaterialfv(void *_glfuncs, GLenum face, GLenum pname, const GLfloat* params); +void gl2_0_glMaterialf(void *_glfuncs, GLenum face, GLenum pname, GLfloat param); +void gl2_0_glLineStipple(void *_glfuncs, GLint factor, GLushort pattern); +void gl2_0_glLightModeliv(void *_glfuncs, GLenum pname, const GLint* params); +void gl2_0_glLightModeli(void *_glfuncs, GLenum pname, GLint param); +void gl2_0_glLightModelfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl2_0_glLightModelf(void *_glfuncs, GLenum pname, GLfloat param); +void gl2_0_glLightiv(void *_glfuncs, GLenum light, GLenum pname, const GLint* params); +void gl2_0_glLighti(void *_glfuncs, GLenum light, GLenum pname, GLint param); +void gl2_0_glLightfv(void *_glfuncs, GLenum light, GLenum pname, const GLfloat* params); +void gl2_0_glLightf(void *_glfuncs, GLenum light, GLenum pname, GLfloat param); +void gl2_0_glFogiv(void *_glfuncs, GLenum pname, const GLint* params); +void gl2_0_glFogi(void *_glfuncs, GLenum pname, GLint param); +void gl2_0_glFogfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl2_0_glFogf(void *_glfuncs, GLenum pname, GLfloat param); +void gl2_0_glColorMaterial(void *_glfuncs, GLenum face, GLenum mode); +void gl2_0_glClipPlane(void *_glfuncs, GLenum plane, const GLdouble* equation); +void gl2_0_glVertex4sv(void *_glfuncs, const GLshort* v); +void gl2_0_glVertex4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w); +void gl2_0_glVertex4iv(void *_glfuncs, const GLint* v); +void gl2_0_glVertex4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w); +void gl2_0_glVertex4fv(void *_glfuncs, const GLfloat* v); +void gl2_0_glVertex4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl2_0_glVertex4dv(void *_glfuncs, const GLdouble* v); +void gl2_0_glVertex4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl2_0_glVertex3sv(void *_glfuncs, const GLshort* v); +void gl2_0_glVertex3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl2_0_glVertex3iv(void *_glfuncs, const GLint* v); +void gl2_0_glVertex3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl2_0_glVertex3fv(void *_glfuncs, const GLfloat* v); +void gl2_0_glVertex3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl2_0_glVertex3dv(void *_glfuncs, const GLdouble* v); +void gl2_0_glVertex3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl2_0_glVertex2sv(void *_glfuncs, const GLshort* v); +void gl2_0_glVertex2s(void *_glfuncs, GLshort x, GLshort y); +void gl2_0_glVertex2iv(void *_glfuncs, const GLint* v); +void gl2_0_glVertex2i(void *_glfuncs, GLint x, GLint y); +void gl2_0_glVertex2fv(void *_glfuncs, const GLfloat* v); +void gl2_0_glVertex2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl2_0_glVertex2dv(void *_glfuncs, const GLdouble* v); +void gl2_0_glVertex2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl2_0_glTexCoord4sv(void *_glfuncs, const GLshort* v); +void gl2_0_glTexCoord4s(void *_glfuncs, GLshort s, GLshort t, GLshort r, GLshort q); +void gl2_0_glTexCoord4iv(void *_glfuncs, const GLint* v); +void gl2_0_glTexCoord4i(void *_glfuncs, GLint s, GLint t, GLint r, GLint q); +void gl2_0_glTexCoord4fv(void *_glfuncs, const GLfloat* v); +void gl2_0_glTexCoord4f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +void gl2_0_glTexCoord4dv(void *_glfuncs, const GLdouble* v); +void gl2_0_glTexCoord4d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +void gl2_0_glTexCoord3sv(void *_glfuncs, const GLshort* v); +void gl2_0_glTexCoord3s(void *_glfuncs, GLshort s, GLshort t, GLshort r); +void gl2_0_glTexCoord3iv(void *_glfuncs, const GLint* v); +void gl2_0_glTexCoord3i(void *_glfuncs, GLint s, GLint t, GLint r); +void gl2_0_glTexCoord3fv(void *_glfuncs, const GLfloat* v); +void gl2_0_glTexCoord3f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r); +void gl2_0_glTexCoord3dv(void *_glfuncs, const GLdouble* v); +void gl2_0_glTexCoord3d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r); +void gl2_0_glTexCoord2sv(void *_glfuncs, const GLshort* v); +void gl2_0_glTexCoord2s(void *_glfuncs, GLshort s, GLshort t); +void gl2_0_glTexCoord2iv(void *_glfuncs, const GLint* v); +void gl2_0_glTexCoord2i(void *_glfuncs, GLint s, GLint t); +void gl2_0_glTexCoord2fv(void *_glfuncs, const GLfloat* v); +void gl2_0_glTexCoord2f(void *_glfuncs, GLfloat s, GLfloat t); +void gl2_0_glTexCoord2dv(void *_glfuncs, const GLdouble* v); +void gl2_0_glTexCoord2d(void *_glfuncs, GLdouble s, GLdouble t); +void gl2_0_glTexCoord1sv(void *_glfuncs, const GLshort* v); +void gl2_0_glTexCoord1s(void *_glfuncs, GLshort s); +void gl2_0_glTexCoord1iv(void *_glfuncs, const GLint* v); +void gl2_0_glTexCoord1i(void *_glfuncs, GLint s); +void gl2_0_glTexCoord1fv(void *_glfuncs, const GLfloat* v); +void gl2_0_glTexCoord1f(void *_glfuncs, GLfloat s); +void gl2_0_glTexCoord1dv(void *_glfuncs, const GLdouble* v); +void gl2_0_glTexCoord1d(void *_glfuncs, GLdouble s); +void gl2_0_glRectsv(void *_glfuncs, const GLshort* v1, const GLshort* v2); +void gl2_0_glRects(void *_glfuncs, GLshort x1, GLshort y1, GLshort x2, GLshort y2); +void gl2_0_glRectiv(void *_glfuncs, const GLint* v1, const GLint* v2); +void gl2_0_glRecti(void *_glfuncs, GLint x1, GLint y1, GLint x2, GLint y2); +void gl2_0_glRectfv(void *_glfuncs, const GLfloat* v1, const GLfloat* v2); +void gl2_0_glRectf(void *_glfuncs, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); +void gl2_0_glRectdv(void *_glfuncs, const GLdouble* v1, const GLdouble* v2); +void gl2_0_glRectd(void *_glfuncs, GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); +void gl2_0_glRasterPos4sv(void *_glfuncs, const GLshort* v); +void gl2_0_glRasterPos4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w); +void gl2_0_glRasterPos4iv(void *_glfuncs, const GLint* v); +void gl2_0_glRasterPos4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w); +void gl2_0_glRasterPos4fv(void *_glfuncs, const GLfloat* v); +void gl2_0_glRasterPos4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl2_0_glRasterPos4dv(void *_glfuncs, const GLdouble* v); +void gl2_0_glRasterPos4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl2_0_glRasterPos3sv(void *_glfuncs, const GLshort* v); +void gl2_0_glRasterPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl2_0_glRasterPos3iv(void *_glfuncs, const GLint* v); +void gl2_0_glRasterPos3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl2_0_glRasterPos3fv(void *_glfuncs, const GLfloat* v); +void gl2_0_glRasterPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl2_0_glRasterPos3dv(void *_glfuncs, const GLdouble* v); +void gl2_0_glRasterPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl2_0_glRasterPos2sv(void *_glfuncs, const GLshort* v); +void gl2_0_glRasterPos2s(void *_glfuncs, GLshort x, GLshort y); +void gl2_0_glRasterPos2iv(void *_glfuncs, const GLint* v); +void gl2_0_glRasterPos2i(void *_glfuncs, GLint x, GLint y); +void gl2_0_glRasterPos2fv(void *_glfuncs, const GLfloat* v); +void gl2_0_glRasterPos2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl2_0_glRasterPos2dv(void *_glfuncs, const GLdouble* v); +void gl2_0_glRasterPos2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl2_0_glNormal3sv(void *_glfuncs, const GLshort* v); +void gl2_0_glNormal3s(void *_glfuncs, GLshort nx, GLshort ny, GLshort nz); +void gl2_0_glNormal3iv(void *_glfuncs, const GLint* v); +void gl2_0_glNormal3i(void *_glfuncs, GLint nx, GLint ny, GLint nz); +void gl2_0_glNormal3fv(void *_glfuncs, const GLfloat* v); +void gl2_0_glNormal3f(void *_glfuncs, GLfloat nx, GLfloat ny, GLfloat nz); +void gl2_0_glNormal3dv(void *_glfuncs, const GLdouble* v); +void gl2_0_glNormal3d(void *_glfuncs, GLdouble nx, GLdouble ny, GLdouble nz); +void gl2_0_glNormal3bv(void *_glfuncs, const GLbyte* v); +void gl2_0_glNormal3b(void *_glfuncs, GLbyte nx, GLbyte ny, GLbyte nz); +void gl2_0_glIndexsv(void *_glfuncs, const GLshort* c); +void gl2_0_glIndexs(void *_glfuncs, GLshort c); +void gl2_0_glIndexiv(void *_glfuncs, const GLint* c); +void gl2_0_glIndexi(void *_glfuncs, GLint c); +void gl2_0_glIndexfv(void *_glfuncs, const GLfloat* c); +void gl2_0_glIndexf(void *_glfuncs, GLfloat c); +void gl2_0_glIndexdv(void *_glfuncs, const GLdouble* c); +void gl2_0_glIndexd(void *_glfuncs, GLdouble c); +void gl2_0_glEnd(void *_glfuncs); +void gl2_0_glEdgeFlagv(void *_glfuncs, const GLboolean* flag); +void gl2_0_glEdgeFlag(void *_glfuncs, GLboolean flag); +void gl2_0_glColor4usv(void *_glfuncs, const GLushort* v); +void gl2_0_glColor4us(void *_glfuncs, GLushort red, GLushort green, GLushort blue, GLushort alpha); +void gl2_0_glColor4uiv(void *_glfuncs, const GLuint* v); +void gl2_0_glColor4ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue, GLuint alpha); +void gl2_0_glColor4ubv(void *_glfuncs, const GLubyte* v); +void gl2_0_glColor4ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); +void gl2_0_glColor4sv(void *_glfuncs, const GLshort* v); +void gl2_0_glColor4s(void *_glfuncs, GLshort red, GLshort green, GLshort blue, GLshort alpha); +void gl2_0_glColor4iv(void *_glfuncs, const GLint* v); +void gl2_0_glColor4i(void *_glfuncs, GLint red, GLint green, GLint blue, GLint alpha); +void gl2_0_glColor4fv(void *_glfuncs, const GLfloat* v); +void gl2_0_glColor4f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl2_0_glColor4dv(void *_glfuncs, const GLdouble* v); +void gl2_0_glColor4d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); +void gl2_0_glColor4bv(void *_glfuncs, const GLbyte* v); +void gl2_0_glColor4b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); +void gl2_0_glColor3usv(void *_glfuncs, const GLushort* v); +void gl2_0_glColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue); +void gl2_0_glColor3uiv(void *_glfuncs, const GLuint* v); +void gl2_0_glColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue); +void gl2_0_glColor3ubv(void *_glfuncs, const GLubyte* v); +void gl2_0_glColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue); +void gl2_0_glColor3sv(void *_glfuncs, const GLshort* v); +void gl2_0_glColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue); +void gl2_0_glColor3iv(void *_glfuncs, const GLint* v); +void gl2_0_glColor3i(void *_glfuncs, GLint red, GLint green, GLint blue); +void gl2_0_glColor3fv(void *_glfuncs, const GLfloat* v); +void gl2_0_glColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue); +void gl2_0_glColor3dv(void *_glfuncs, const GLdouble* v); +void gl2_0_glColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue); +void gl2_0_glColor3bv(void *_glfuncs, const GLbyte* v); +void gl2_0_glColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue); +void gl2_0_glBitmap(void *_glfuncs, GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap); +void gl2_0_glBegin(void *_glfuncs, GLenum mode); +void gl2_0_glListBase(void *_glfuncs, GLuint base); +GLuint gl2_0_glGenLists(void *_glfuncs, GLsizei range_); +void gl2_0_glDeleteLists(void *_glfuncs, GLuint list, GLsizei range_); +void gl2_0_glCallLists(void *_glfuncs, GLsizei n, GLenum gltype, const GLvoid* lists); +void gl2_0_glCallList(void *_glfuncs, GLuint list); +void gl2_0_glEndList(void *_glfuncs); +void gl2_0_glNewList(void *_glfuncs, GLuint list, GLenum mode); +void gl2_0_glPushClientAttrib(void *_glfuncs, GLbitfield mask); +void gl2_0_glPopClientAttrib(void *_glfuncs); +void gl2_0_glPrioritizeTextures(void *_glfuncs, GLsizei n, const GLuint* textures, const GLfloat* priorities); +GLboolean gl2_0_glAreTexturesResident(void *_glfuncs, GLsizei n, const GLuint* textures, GLboolean* residences); +void gl2_0_glVertexPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl2_0_glTexCoordPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl2_0_glNormalPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl2_0_glInterleavedArrays(void *_glfuncs, GLenum format, GLsizei stride, const GLvoid* pointer); +void gl2_0_glIndexPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl2_0_glEnableClientState(void *_glfuncs, GLenum array); +void gl2_0_glEdgeFlagPointer(void *_glfuncs, GLsizei stride, const GLvoid* pointer); +void gl2_0_glDisableClientState(void *_glfuncs, GLenum array); +void gl2_0_glColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl2_0_glArrayElement(void *_glfuncs, GLint i); +void gl2_0_glResetMinmax(void *_glfuncs, GLenum target); +void gl2_0_glResetHistogram(void *_glfuncs, GLenum target); +void gl2_0_glMinmax(void *_glfuncs, GLenum target, GLenum internalFormat, GLboolean sink); +void gl2_0_glHistogram(void *_glfuncs, GLenum target, GLsizei width, GLenum internalFormat, GLboolean sink); +void gl2_0_glGetMinmaxParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl2_0_glGetMinmaxParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl2_0_glGetMinmax(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values); +void gl2_0_glGetHistogramParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl2_0_glGetHistogramParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl2_0_glGetHistogram(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values); +void gl2_0_glSeparableFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* row, const GLvoid* column); +void gl2_0_glGetSeparableFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* row, GLvoid* column, GLvoid* span); +void gl2_0_glGetConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl2_0_glGetConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl2_0_glGetConvolutionFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* image); +void gl2_0_glCopyConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height); +void gl2_0_glCopyConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width); +void gl2_0_glConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl2_0_glConvolutionParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint params); +void gl2_0_glConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl2_0_glConvolutionParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat params); +void gl2_0_glConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* image); +void gl2_0_glConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* image); +void gl2_0_glCopyColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); +void gl2_0_glColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum gltype, const GLvoid* data); +void gl2_0_glGetColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl2_0_glGetColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl2_0_glGetColorTable(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* table); +void gl2_0_glCopyColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width); +void gl2_0_glColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl2_0_glColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl2_0_glColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* table); +void gl2_0_glMultTransposeMatrixd(void *_glfuncs, const GLdouble* m); +void gl2_0_glMultTransposeMatrixf(void *_glfuncs, const GLfloat* m); +void gl2_0_glLoadTransposeMatrixd(void *_glfuncs, const GLdouble* m); +void gl2_0_glLoadTransposeMatrixf(void *_glfuncs, const GLfloat* m); +void gl2_0_glMultiTexCoord4sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl2_0_glMultiTexCoord4s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); +void gl2_0_glMultiTexCoord4iv(void *_glfuncs, GLenum target, const GLint* v); +void gl2_0_glMultiTexCoord4i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r, GLint q); +void gl2_0_glMultiTexCoord4fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl2_0_glMultiTexCoord4f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +void gl2_0_glMultiTexCoord4dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl2_0_glMultiTexCoord4d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +void gl2_0_glMultiTexCoord3sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl2_0_glMultiTexCoord3s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r); +void gl2_0_glMultiTexCoord3iv(void *_glfuncs, GLenum target, const GLint* v); +void gl2_0_glMultiTexCoord3i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r); +void gl2_0_glMultiTexCoord3fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl2_0_glMultiTexCoord3f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r); +void gl2_0_glMultiTexCoord3dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl2_0_glMultiTexCoord3d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r); +void gl2_0_glMultiTexCoord2sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl2_0_glMultiTexCoord2s(void *_glfuncs, GLenum target, GLshort s, GLshort t); +void gl2_0_glMultiTexCoord2iv(void *_glfuncs, GLenum target, const GLint* v); +void gl2_0_glMultiTexCoord2i(void *_glfuncs, GLenum target, GLint s, GLint t); +void gl2_0_glMultiTexCoord2fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl2_0_glMultiTexCoord2f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t); +void gl2_0_glMultiTexCoord2dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl2_0_glMultiTexCoord2d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t); +void gl2_0_glMultiTexCoord1sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl2_0_glMultiTexCoord1s(void *_glfuncs, GLenum target, GLshort s); +void gl2_0_glMultiTexCoord1iv(void *_glfuncs, GLenum target, const GLint* v); +void gl2_0_glMultiTexCoord1i(void *_glfuncs, GLenum target, GLint s); +void gl2_0_glMultiTexCoord1fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl2_0_glMultiTexCoord1f(void *_glfuncs, GLenum target, GLfloat s); +void gl2_0_glMultiTexCoord1dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl2_0_glMultiTexCoord1d(void *_glfuncs, GLenum target, GLdouble s); +void gl2_0_glClientActiveTexture(void *_glfuncs, GLenum texture); +void gl2_0_glWindowPos3sv(void *_glfuncs, const GLshort* v); +void gl2_0_glWindowPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl2_0_glWindowPos3iv(void *_glfuncs, const GLint* v); +void gl2_0_glWindowPos3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl2_0_glWindowPos3fv(void *_glfuncs, const GLfloat* v); +void gl2_0_glWindowPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl2_0_glWindowPos3dv(void *_glfuncs, const GLdouble* v); +void gl2_0_glWindowPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl2_0_glWindowPos2sv(void *_glfuncs, const GLshort* v); +void gl2_0_glWindowPos2s(void *_glfuncs, GLshort x, GLshort y); +void gl2_0_glWindowPos2iv(void *_glfuncs, const GLint* v); +void gl2_0_glWindowPos2i(void *_glfuncs, GLint x, GLint y); +void gl2_0_glWindowPos2fv(void *_glfuncs, const GLfloat* v); +void gl2_0_glWindowPos2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl2_0_glWindowPos2dv(void *_glfuncs, const GLdouble* v); +void gl2_0_glWindowPos2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl2_0_glSecondaryColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl2_0_glSecondaryColor3usv(void *_glfuncs, const GLushort* v); +void gl2_0_glSecondaryColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue); +void gl2_0_glSecondaryColor3uiv(void *_glfuncs, const GLuint* v); +void gl2_0_glSecondaryColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue); +void gl2_0_glSecondaryColor3ubv(void *_glfuncs, const GLubyte* v); +void gl2_0_glSecondaryColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue); +void gl2_0_glSecondaryColor3sv(void *_glfuncs, const GLshort* v); +void gl2_0_glSecondaryColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue); +void gl2_0_glSecondaryColor3iv(void *_glfuncs, const GLint* v); +void gl2_0_glSecondaryColor3i(void *_glfuncs, GLint red, GLint green, GLint blue); +void gl2_0_glSecondaryColor3fv(void *_glfuncs, const GLfloat* v); +void gl2_0_glSecondaryColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue); +void gl2_0_glSecondaryColor3dv(void *_glfuncs, const GLdouble* v); +void gl2_0_glSecondaryColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue); +void gl2_0_glSecondaryColor3bv(void *_glfuncs, const GLbyte* v); +void gl2_0_glSecondaryColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue); +void gl2_0_glFogCoordPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl2_0_glFogCoorddv(void *_glfuncs, const GLdouble* coord); +void gl2_0_glFogCoordd(void *_glfuncs, GLdouble coord); +void gl2_0_glFogCoordfv(void *_glfuncs, const GLfloat* coord); +void gl2_0_glFogCoordf(void *_glfuncs, GLfloat coord); +void gl2_0_glVertexAttrib4usv(void *_glfuncs, GLuint index, const GLushort* v); +void gl2_0_glVertexAttrib4uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl2_0_glVertexAttrib4ubv(void *_glfuncs, GLuint index, const GLubyte* v); +void gl2_0_glVertexAttrib4sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl2_0_glVertexAttrib4s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +void gl2_0_glVertexAttrib4iv(void *_glfuncs, GLuint index, const GLint* v); +void gl2_0_glVertexAttrib4fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl2_0_glVertexAttrib4f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl2_0_glVertexAttrib4dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl2_0_glVertexAttrib4d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl2_0_glVertexAttrib4bv(void *_glfuncs, GLuint index, const GLbyte* v); +void gl2_0_glVertexAttrib4Nusv(void *_glfuncs, GLuint index, const GLushort* v); +void gl2_0_glVertexAttrib4Nuiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl2_0_glVertexAttrib4Nubv(void *_glfuncs, GLuint index, const GLubyte* v); +void gl2_0_glVertexAttrib4Nub(void *_glfuncs, GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +void gl2_0_glVertexAttrib4Nsv(void *_glfuncs, GLuint index, const GLshort* v); +void gl2_0_glVertexAttrib4Niv(void *_glfuncs, GLuint index, const GLint* v); +void gl2_0_glVertexAttrib4Nbv(void *_glfuncs, GLuint index, const GLbyte* v); +void gl2_0_glVertexAttrib3sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl2_0_glVertexAttrib3s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z); +void gl2_0_glVertexAttrib3fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl2_0_glVertexAttrib3f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z); +void gl2_0_glVertexAttrib3dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl2_0_glVertexAttrib3d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z); +void gl2_0_glVertexAttrib2sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl2_0_glVertexAttrib2s(void *_glfuncs, GLuint index, GLshort x, GLshort y); +void gl2_0_glVertexAttrib2fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl2_0_glVertexAttrib2f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y); +void gl2_0_glVertexAttrib2dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl2_0_glVertexAttrib2d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y); +void gl2_0_glVertexAttrib1sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl2_0_glVertexAttrib1s(void *_glfuncs, GLuint index, GLshort x); +void gl2_0_glVertexAttrib1fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl2_0_glVertexAttrib1f(void *_glfuncs, GLuint index, GLfloat x); +void gl2_0_glVertexAttrib1dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl2_0_glVertexAttrib1d(void *_glfuncs, GLuint index, GLdouble x); + + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/gl/2.0/gl.go b/gl/2.0/gl.go new file mode 100644 index 00000000..7bd1e1b5 --- /dev/null +++ b/gl/2.0/gl.go @@ -0,0 +1,6407 @@ +// ** file automatically generated by glgen -- do not edit manually ** + +package GL + +// #cgo CXXFLAGS: -std=c++0x -pedantic-errors -Wall -fno-strict-aliasing +// #cgo LDFLAGS: -lstdc++ +// #cgo pkg-config: Qt5Core Qt5OpenGL +// +// #include "funcs.h" +// +// void free(void*); +// +import "C" + +import ( + "fmt" + "reflect" + "unsafe" + + "gopkg.in/qml.v1/gl/glbase" +) + +// API returns a value that offers methods matching the OpenGL version 2.0 API. +// +// The returned API must not be used after the provided OpenGL context becomes invalid. +func API(context glbase.Contexter) *GL { + gl := &GL{} + gl.funcs = C.gl2_0_funcs() + if gl.funcs == nil { + panic(fmt.Errorf("OpenGL version 2.0 is not available")) + } + return gl +} + +// GL implements the OpenGL version 2.0 API. Values of this +// type must be created via the API function, and it must not be used after +// the associated OpenGL context becomes invalid. +type GL struct { + funcs unsafe.Pointer +} + +const ( + FALSE = 0 + TRUE = 1 + NONE = 0 + + BYTE = 0x1400 + UNSIGNED_BYTE = 0x1401 + SHORT = 0x1402 + UNSIGNED_SHORT = 0x1403 + INT = 0x1404 + UNSIGNED_INT = 0x1405 + FLOAT = 0x1406 + N2_BYTES = 0x1407 + N3_BYTES = 0x1408 + N4_BYTES = 0x1409 + DOUBLE = 0x140A + + ACCUM = 0x0100 + LOAD = 0x0101 + RETURN = 0x0102 + MULT = 0x0103 + ADD = 0x0104 + + ACCUM_BUFFER_BIT = 0x00000200 + ALL_ATTRIB_BITS = 0xFFFFFFFF + COLOR_BUFFER_BIT = 0x00004000 + CURRENT_BIT = 0x00000001 + DEPTH_BUFFER_BIT = 0x00000100 + ENABLE_BIT = 0x00002000 + EVAL_BIT = 0x00010000 + FOG_BIT = 0x00000080 + HINT_BIT = 0x00008000 + LIGHTING_BIT = 0x00000040 + LINE_BIT = 0x00000004 + LIST_BIT = 0x00020000 + MULTISAMPLE_BIT = 0x20000000 + PIXEL_MODE_BIT = 0x00000020 + POINT_BIT = 0x00000002 + POLYGON_BIT = 0x00000008 + POLYGON_STIPPLE_BIT = 0x00000010 + SCISSOR_BIT = 0x00080000 + STENCIL_BUFFER_BIT = 0x00000400 + TEXTURE_BIT = 0x00040000 + TRANSFORM_BIT = 0x00001000 + VIEWPORT_BIT = 0x00000800 + + ALWAYS = 0x0207 + EQUAL = 0x0202 + GEQUAL = 0x0206 + GREATER = 0x0204 + LEQUAL = 0x0203 + LESS = 0x0201 + NEVER = 0x0200 + NOTEQUAL = 0x0205 + + LOGIC_OP = 0x0BF1 + + DST_ALPHA = 0x0304 + ONE = 1 + ONE_MINUS_DST_ALPHA = 0x0305 + ONE_MINUS_SRC_ALPHA = 0x0303 + ONE_MINUS_SRC_COLOR = 0x0301 + SRC_ALPHA = 0x0302 + SRC_COLOR = 0x0300 + ZERO = 0 + + DST_COLOR = 0x0306 + ONE_MINUS_DST_COLOR = 0x0307 + SRC_ALPHA_SATURATE = 0x0308 + + CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF + CLIENT_PIXEL_STORE_BIT = 0x00000001 + CLIENT_VERTEX_ARRAY_BIT = 0x00000002 + + CLIP_PLANE0 = 0x3000 + CLIP_PLANE1 = 0x3001 + CLIP_PLANE2 = 0x3002 + CLIP_PLANE3 = 0x3003 + CLIP_PLANE4 = 0x3004 + CLIP_PLANE5 = 0x3005 + + BACK = 0x0405 + FRONT = 0x0404 + FRONT_AND_BACK = 0x0408 + + AMBIENT = 0x1200 + AMBIENT_AND_DIFFUSE = 0x1602 + DIFFUSE = 0x1201 + EMISSION = 0x1600 + SPECULAR = 0x1202 + + AUX0 = 0x0409 + AUX1 = 0x040A + AUX2 = 0x040B + AUX3 = 0x040C + BACK_LEFT = 0x0402 + BACK_RIGHT = 0x0403 + FRONT_LEFT = 0x0400 + FRONT_RIGHT = 0x0401 + LEFT = 0x0406 + RIGHT = 0x0407 + + ALPHA_TEST = 0x0BC0 + AUTO_NORMAL = 0x0D80 + BLEND = 0x0BE2 + COLOR_ARRAY = 0x8076 + COLOR_LOGIC_OP = 0x0BF2 + COLOR_MATERIAL = 0x0B57 + CULL_FACE = 0x0B44 + DEPTH_TEST = 0x0B71 + DITHER = 0x0BD0 + EDGE_FLAG_ARRAY = 0x8079 + FOG = 0x0B60 + INDEX_ARRAY = 0x8077 + INDEX_LOGIC_OP = 0x0BF1 + LIGHT0 = 0x4000 + LIGHT1 = 0x4001 + LIGHT2 = 0x4002 + LIGHT3 = 0x4003 + LIGHT4 = 0x4004 + LIGHT5 = 0x4005 + LIGHT6 = 0x4006 + LIGHT7 = 0x4007 + LIGHTING = 0x0B50 + LINE_SMOOTH = 0x0B20 + LINE_STIPPLE = 0x0B24 + MAP1_COLOR_4 = 0x0D90 + MAP1_INDEX = 0x0D91 + MAP1_NORMAL = 0x0D92 + MAP1_TEXTURE_COORD_1 = 0x0D93 + MAP1_TEXTURE_COORD_2 = 0x0D94 + MAP1_TEXTURE_COORD_3 = 0x0D95 + MAP1_TEXTURE_COORD_4 = 0x0D96 + MAP1_VERTEX_3 = 0x0D97 + MAP1_VERTEX_4 = 0x0D98 + MAP2_COLOR_4 = 0x0DB0 + MAP2_INDEX = 0x0DB1 + MAP2_NORMAL = 0x0DB2 + MAP2_TEXTURE_COORD_1 = 0x0DB3 + MAP2_TEXTURE_COORD_2 = 0x0DB4 + MAP2_TEXTURE_COORD_3 = 0x0DB5 + MAP2_TEXTURE_COORD_4 = 0x0DB6 + MAP2_VERTEX_3 = 0x0DB7 + MAP2_VERTEX_4 = 0x0DB8 + NORMALIZE = 0x0BA1 + NORMAL_ARRAY = 0x8075 + POINT_SMOOTH = 0x0B10 + POLYGON_OFFSET_FILL = 0x8037 + POLYGON_OFFSET_LINE = 0x2A02 + POLYGON_OFFSET_POINT = 0x2A01 + POLYGON_SMOOTH = 0x0B41 + POLYGON_STIPPLE = 0x0B42 + SCISSOR_TEST = 0x0C11 + STENCIL_TEST = 0x0B90 + TEXTURE_1D = 0x0DE0 + TEXTURE_2D = 0x0DE1 + TEXTURE_COORD_ARRAY = 0x8078 + TEXTURE_GEN_Q = 0x0C63 + TEXTURE_GEN_R = 0x0C62 + TEXTURE_GEN_S = 0x0C60 + TEXTURE_GEN_T = 0x0C61 + VERTEX_ARRAY = 0x8074 + + INVALID_ENUM = 0x0500 + INVALID_OPERATION = 0x0502 + INVALID_VALUE = 0x0501 + NO_ERROR = 0 + OUT_OF_MEMORY = 0x0505 + STACK_OVERFLOW = 0x0503 + STACK_UNDERFLOW = 0x0504 + + N2D = 0x0600 + N3D = 0x0601 + N3D_COLOR = 0x0602 + N3D_COLOR_TEXTURE = 0x0603 + N4D_COLOR_TEXTURE = 0x0604 + + BITMAP_TOKEN = 0x0704 + COPY_PIXEL_TOKEN = 0x0706 + DRAW_PIXEL_TOKEN = 0x0705 + LINE_RESET_TOKEN = 0x0707 + LINE_TOKEN = 0x0702 + PASS_THROUGH_TOKEN = 0x0700 + POINT_TOKEN = 0x0701 + POLYGON_TOKEN = 0x0703 + + EXP = 0x0800 + EXP2 = 0x0801 + LINEAR = 0x2601 + + FOG_COLOR = 0x0B66 + FOG_DENSITY = 0x0B62 + FOG_END = 0x0B64 + FOG_INDEX = 0x0B61 + FOG_MODE = 0x0B65 + FOG_START = 0x0B63 + + CCW = 0x0901 + CW = 0x0900 + + COEFF = 0x0A00 + DOMAIN = 0x0A02 + ORDER = 0x0A01 + + PIXEL_MAP_A_TO_A = 0x0C79 + PIXEL_MAP_B_TO_B = 0x0C78 + PIXEL_MAP_G_TO_G = 0x0C77 + PIXEL_MAP_I_TO_A = 0x0C75 + PIXEL_MAP_I_TO_B = 0x0C74 + PIXEL_MAP_I_TO_G = 0x0C73 + PIXEL_MAP_I_TO_I = 0x0C70 + PIXEL_MAP_I_TO_R = 0x0C72 + PIXEL_MAP_R_TO_R = 0x0C76 + PIXEL_MAP_S_TO_S = 0x0C71 + + ACCUM_ALPHA_BITS = 0x0D5B + ACCUM_BLUE_BITS = 0x0D5A + ACCUM_CLEAR_VALUE = 0x0B80 + ACCUM_GREEN_BITS = 0x0D59 + ACCUM_RED_BITS = 0x0D58 + ALIASED_LINE_WIDTH_RANGE = 0x846E + ALIASED_POINT_SIZE_RANGE = 0x846D + ALPHA_BIAS = 0x0D1D + ALPHA_BITS = 0x0D55 + ALPHA_SCALE = 0x0D1C + ALPHA_TEST_FUNC = 0x0BC1 + ALPHA_TEST_REF = 0x0BC2 + ATTRIB_STACK_DEPTH = 0x0BB0 + AUX_BUFFERS = 0x0C00 + BLEND_DST = 0x0BE0 + BLEND_SRC = 0x0BE1 + BLUE_BIAS = 0x0D1B + BLUE_BITS = 0x0D54 + BLUE_SCALE = 0x0D1A + CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1 + COLOR_ARRAY_SIZE = 0x8081 + COLOR_ARRAY_STRIDE = 0x8083 + COLOR_ARRAY_TYPE = 0x8082 + COLOR_CLEAR_VALUE = 0x0C22 + COLOR_MATERIAL_FACE = 0x0B55 + COLOR_MATERIAL_PARAMETER = 0x0B56 + COLOR_WRITEMASK = 0x0C23 + CULL_FACE_MODE = 0x0B45 + CURRENT_COLOR = 0x0B00 + CURRENT_INDEX = 0x0B01 + CURRENT_NORMAL = 0x0B02 + CURRENT_RASTER_COLOR = 0x0B04 + CURRENT_RASTER_DISTANCE = 0x0B09 + CURRENT_RASTER_INDEX = 0x0B05 + CURRENT_RASTER_POSITION = 0x0B07 + CURRENT_RASTER_POSITION_VALID = 0x0B08 + CURRENT_RASTER_TEXTURE_COORDS = 0x0B06 + CURRENT_TEXTURE_COORDS = 0x0B03 + DEPTH_BIAS = 0x0D1F + DEPTH_BITS = 0x0D56 + DEPTH_CLEAR_VALUE = 0x0B73 + DEPTH_FUNC = 0x0B74 + DEPTH_RANGE = 0x0B70 + DEPTH_SCALE = 0x0D1E + DEPTH_WRITEMASK = 0x0B72 + DOUBLEBUFFER = 0x0C32 + DRAW_BUFFER = 0x0C01 + EDGE_FLAG = 0x0B43 + EDGE_FLAG_ARRAY_STRIDE = 0x808C + FEEDBACK_BUFFER_SIZE = 0x0DF1 + FEEDBACK_BUFFER_TYPE = 0x0DF2 + FOG_HINT = 0x0C54 + FRONT_FACE = 0x0B46 + GREEN_BIAS = 0x0D19 + GREEN_BITS = 0x0D53 + GREEN_SCALE = 0x0D18 + INDEX_ARRAY_STRIDE = 0x8086 + INDEX_ARRAY_TYPE = 0x8085 + INDEX_BITS = 0x0D51 + INDEX_CLEAR_VALUE = 0x0C20 + INDEX_MODE = 0x0C30 + INDEX_OFFSET = 0x0D13 + INDEX_SHIFT = 0x0D12 + INDEX_WRITEMASK = 0x0C21 + LIGHT_MODEL_AMBIENT = 0x0B53 + LIGHT_MODEL_COLOR_CONTROL = 0x81F8 + LIGHT_MODEL_LOCAL_VIEWER = 0x0B51 + LIGHT_MODEL_TWO_SIDE = 0x0B52 + LINE_SMOOTH_HINT = 0x0C52 + LINE_STIPPLE_PATTERN = 0x0B25 + LINE_STIPPLE_REPEAT = 0x0B26 + LINE_WIDTH = 0x0B21 + LINE_WIDTH_GRANULARITY = 0x0B23 + LINE_WIDTH_RANGE = 0x0B22 + LIST_BASE = 0x0B32 + LIST_INDEX = 0x0B33 + LIST_MODE = 0x0B30 + LOGIC_OP_MODE = 0x0BF0 + MAP1_GRID_DOMAIN = 0x0DD0 + MAP1_GRID_SEGMENTS = 0x0DD1 + MAP2_GRID_DOMAIN = 0x0DD2 + MAP2_GRID_SEGMENTS = 0x0DD3 + MAP_COLOR = 0x0D10 + MAP_STENCIL = 0x0D11 + MATRIX_MODE = 0x0BA0 + MAX_ATTRIB_STACK_DEPTH = 0x0D35 + MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B + MAX_CLIP_PLANES = 0x0D32 + MAX_EVAL_ORDER = 0x0D30 + MAX_LIGHTS = 0x0D31 + MAX_LIST_NESTING = 0x0B31 + MAX_MODELVIEW_STACK_DEPTH = 0x0D36 + MAX_NAME_STACK_DEPTH = 0x0D37 + MAX_PIXEL_MAP_TABLE = 0x0D34 + MAX_PROJECTION_STACK_DEPTH = 0x0D38 + MAX_TEXTURE_SIZE = 0x0D33 + MAX_TEXTURE_STACK_DEPTH = 0x0D39 + MAX_VIEWPORT_DIMS = 0x0D3A + MODELVIEW_MATRIX = 0x0BA6 + MODELVIEW_STACK_DEPTH = 0x0BA3 + NAME_STACK_DEPTH = 0x0D70 + NORMAL_ARRAY_STRIDE = 0x807F + NORMAL_ARRAY_TYPE = 0x807E + PACK_ALIGNMENT = 0x0D05 + PACK_LSB_FIRST = 0x0D01 + PACK_ROW_LENGTH = 0x0D02 + PACK_SKIP_PIXELS = 0x0D04 + PACK_SKIP_ROWS = 0x0D03 + PACK_SWAP_BYTES = 0x0D00 + PERSPECTIVE_CORRECTION_HINT = 0x0C50 + PIXEL_MAP_A_TO_A_SIZE = 0x0CB9 + PIXEL_MAP_B_TO_B_SIZE = 0x0CB8 + PIXEL_MAP_G_TO_G_SIZE = 0x0CB7 + PIXEL_MAP_I_TO_A_SIZE = 0x0CB5 + PIXEL_MAP_I_TO_B_SIZE = 0x0CB4 + PIXEL_MAP_I_TO_G_SIZE = 0x0CB3 + PIXEL_MAP_I_TO_I_SIZE = 0x0CB0 + PIXEL_MAP_I_TO_R_SIZE = 0x0CB2 + PIXEL_MAP_R_TO_R_SIZE = 0x0CB6 + PIXEL_MAP_S_TO_S_SIZE = 0x0CB1 + POINT_SIZE = 0x0B11 + POINT_SIZE_GRANULARITY = 0x0B13 + POINT_SIZE_RANGE = 0x0B12 + POINT_SMOOTH_HINT = 0x0C51 + POLYGON_MODE = 0x0B40 + POLYGON_OFFSET_FACTOR = 0x8038 + POLYGON_OFFSET_UNITS = 0x2A00 + POLYGON_SMOOTH_HINT = 0x0C53 + PROJECTION_MATRIX = 0x0BA7 + PROJECTION_STACK_DEPTH = 0x0BA4 + READ_BUFFER = 0x0C02 + RED_BIAS = 0x0D15 + RED_BITS = 0x0D52 + RED_SCALE = 0x0D14 + RENDER_MODE = 0x0C40 + RGBA_MODE = 0x0C31 + SCISSOR_BOX = 0x0C10 + SELECTION_BUFFER_SIZE = 0x0DF4 + SHADE_MODEL = 0x0B54 + SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23 + SMOOTH_LINE_WIDTH_RANGE = 0x0B22 + SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13 + SMOOTH_POINT_SIZE_RANGE = 0x0B12 + STENCIL_BITS = 0x0D57 + STENCIL_CLEAR_VALUE = 0x0B91 + STENCIL_FAIL = 0x0B94 + STENCIL_FUNC = 0x0B92 + STENCIL_PASS_DEPTH_FAIL = 0x0B95 + STENCIL_PASS_DEPTH_PASS = 0x0B96 + STENCIL_REF = 0x0B97 + STENCIL_VALUE_MASK = 0x0B93 + STENCIL_WRITEMASK = 0x0B98 + STEREO = 0x0C33 + SUBPIXEL_BITS = 0x0D50 + TEXTURE_BINDING_1D = 0x8068 + TEXTURE_BINDING_2D = 0x8069 + TEXTURE_BINDING_3D = 0x806A + TEXTURE_COORD_ARRAY_SIZE = 0x8088 + TEXTURE_COORD_ARRAY_STRIDE = 0x808A + TEXTURE_COORD_ARRAY_TYPE = 0x8089 + TEXTURE_MATRIX = 0x0BA8 + TEXTURE_STACK_DEPTH = 0x0BA5 + UNPACK_ALIGNMENT = 0x0CF5 + UNPACK_LSB_FIRST = 0x0CF1 + UNPACK_ROW_LENGTH = 0x0CF2 + UNPACK_SKIP_PIXELS = 0x0CF4 + UNPACK_SKIP_ROWS = 0x0CF3 + UNPACK_SWAP_BYTES = 0x0CF0 + VERTEX_ARRAY_SIZE = 0x807A + VERTEX_ARRAY_STRIDE = 0x807C + VERTEX_ARRAY_TYPE = 0x807B + VIEWPORT = 0x0BA2 + ZOOM_X = 0x0D16 + ZOOM_Y = 0x0D17 + + COLOR_ARRAY_POINTER = 0x8090 + EDGE_FLAG_ARRAY_POINTER = 0x8093 + FEEDBACK_BUFFER_POINTER = 0x0DF0 + INDEX_ARRAY_POINTER = 0x8091 + NORMAL_ARRAY_POINTER = 0x808F + SELECTION_BUFFER_POINTER = 0x0DF3 + TEXTURE_COORD_ARRAY_POINTER = 0x8092 + VERTEX_ARRAY_POINTER = 0x808E + + TEXTURE_ALPHA_SIZE = 0x805F + TEXTURE_BLUE_SIZE = 0x805E + TEXTURE_BORDER = 0x1005 + TEXTURE_BORDER_COLOR = 0x1004 + TEXTURE_COMPONENTS = 0x1003 + TEXTURE_GREEN_SIZE = 0x805D + TEXTURE_HEIGHT = 0x1001 + TEXTURE_INTENSITY_SIZE = 0x8061 + TEXTURE_INTERNAL_FORMAT = 0x1003 + TEXTURE_LUMINANCE_SIZE = 0x8060 + TEXTURE_MAG_FILTER = 0x2800 + TEXTURE_MIN_FILTER = 0x2801 + TEXTURE_PRIORITY = 0x8066 + TEXTURE_RED_SIZE = 0x805C + TEXTURE_RESIDENT = 0x8067 + TEXTURE_WIDTH = 0x1000 + TEXTURE_WRAP_S = 0x2802 + TEXTURE_WRAP_T = 0x2803 + + DONT_CARE = 0x1100 + FASTEST = 0x1101 + NICEST = 0x1102 + + FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B + GENERATE_MIPMAP_HINT = 0x8192 + TEXTURE_COMPRESSION_HINT = 0x84EF + + C3F_V3F = 0x2A24 + C4F_N3F_V3F = 0x2A26 + C4UB_V2F = 0x2A22 + C4UB_V3F = 0x2A23 + N3F_V3F = 0x2A25 + T2F_C3F_V3F = 0x2A2A + T2F_C4F_N3F_V3F = 0x2A2C + T2F_C4UB_V3F = 0x2A29 + T2F_N3F_V3F = 0x2A2B + T2F_V3F = 0x2A27 + T4F_C4F_N3F_V4F = 0x2A2D + T4F_V4F = 0x2A28 + V2F = 0x2A20 + V3F = 0x2A21 + + MODULATE = 0x2100 + REPLACE = 0x1E01 + + SEPARATE_SPECULAR_COLOR = 0x81FA + SINGLE_COLOR = 0x81F9 + + CONSTANT_ATTENUATION = 0x1207 + LINEAR_ATTENUATION = 0x1208 + POSITION = 0x1203 + QUADRATIC_ATTENUATION = 0x1209 + SPOT_CUTOFF = 0x1206 + SPOT_DIRECTION = 0x1204 + SPOT_EXPONENT = 0x1205 + + COMPILE = 0x1300 + COMPILE_AND_EXECUTE = 0x1301 + + AND = 0x1501 + AND_INVERTED = 0x1504 + AND_REVERSE = 0x1502 + CLEAR = 0x1500 + COPY = 0x1503 + COPY_INVERTED = 0x150C + EQUIV = 0x1509 + INVERT = 0x150A + NAND = 0x150E + NOOP = 0x1505 + NOR = 0x1508 + OR = 0x1507 + OR_INVERTED = 0x150D + OR_REVERSE = 0x150B + SET = 0x150F + XOR = 0x1506 + + COLOR_INDEXES = 0x1603 + SHININESS = 0x1601 + + MODELVIEW = 0x1700 + PROJECTION = 0x1701 + TEXTURE = 0x1702 + + LINE = 0x1B01 + POINT = 0x1B00 + + FILL = 0x1B02 + + COLOR = 0x1800 + DEPTH = 0x1801 + STENCIL = 0x1802 + + ALPHA = 0x1906 + BLUE = 0x1905 + COLOR_INDEX = 0x1900 + DEPTH_COMPONENT = 0x1902 + GREEN = 0x1904 + LUMINANCE = 0x1909 + LUMINANCE_ALPHA = 0x190A + RED = 0x1903 + RGB = 0x1907 + RGBA = 0x1908 + STENCIL_INDEX = 0x1901 + + ALPHA12 = 0x803D + ALPHA16 = 0x803E + ALPHA4 = 0x803B + ALPHA8 = 0x803C + INTENSITY = 0x8049 + INTENSITY12 = 0x804C + INTENSITY16 = 0x804D + INTENSITY4 = 0x804A + INTENSITY8 = 0x804B + LUMINANCE12 = 0x8041 + LUMINANCE12_ALPHA12 = 0x8047 + LUMINANCE12_ALPHA4 = 0x8046 + LUMINANCE16 = 0x8042 + LUMINANCE16_ALPHA16 = 0x8048 + LUMINANCE4 = 0x803F + LUMINANCE4_ALPHA4 = 0x8043 + LUMINANCE6_ALPHA2 = 0x8044 + LUMINANCE8 = 0x8040 + LUMINANCE8_ALPHA8 = 0x8045 + R3_G3_B2 = 0x2A10 + RGB10 = 0x8052 + RGB10_A2 = 0x8059 + RGB12 = 0x8053 + RGB16 = 0x8054 + RGB4 = 0x804F + RGB5 = 0x8050 + RGB5_A1 = 0x8057 + RGB8 = 0x8051 + RGBA12 = 0x805A + RGBA16 = 0x805B + RGBA2 = 0x8055 + RGBA4 = 0x8056 + RGBA8 = 0x8058 + + PACK_IMAGE_HEIGHT = 0x806C + PACK_SKIP_IMAGES = 0x806B + UNPACK_IMAGE_HEIGHT = 0x806E + UNPACK_SKIP_IMAGES = 0x806D + + BITMAP = 0x1A00 + UNSIGNED_BYTE_3_3_2 = 0x8032 + UNSIGNED_INT_10_10_10_2 = 0x8036 + UNSIGNED_INT_8_8_8_8 = 0x8035 + UNSIGNED_SHORT_4_4_4_4 = 0x8033 + UNSIGNED_SHORT_5_5_5_1 = 0x8034 + + POINT_DISTANCE_ATTENUATION = 0x8129 + POINT_FADE_THRESHOLD_SIZE = 0x8128 + POINT_SIZE_MAX = 0x8127 + POINT_SIZE_MIN = 0x8126 + + LINES = 0x0001 + LINE_LOOP = 0x0002 + LINE_STRIP = 0x0003 + POINTS = 0x0000 + POLYGON = 0x0009 + QUADS = 0x0007 + QUAD_STRIP = 0x0008 + TRIANGLES = 0x0004 + TRIANGLE_FAN = 0x0006 + TRIANGLE_STRIP = 0x0005 + + FEEDBACK = 0x1C01 + RENDER = 0x1C00 + SELECT = 0x1C02 + + FLAT = 0x1D00 + SMOOTH = 0x1D01 + + DECR = 0x1E03 + INCR = 0x1E02 + KEEP = 0x1E00 + + EXTENSIONS = 0x1F03 + RENDERER = 0x1F01 + VENDOR = 0x1F00 + VERSION = 0x1F02 + + S = 0x2000 + T = 0x2001 + R = 0x2002 + Q = 0x2003 + + DECAL = 0x2101 + + TEXTURE_ENV_COLOR = 0x2201 + TEXTURE_ENV_MODE = 0x2200 + + TEXTURE_ENV = 0x2300 + + EYE_LINEAR = 0x2400 + OBJECT_LINEAR = 0x2401 + SPHERE_MAP = 0x2402 + + EYE_PLANE = 0x2502 + OBJECT_PLANE = 0x2501 + TEXTURE_GEN_MODE = 0x2500 + + NEAREST = 0x2600 + + LINEAR_MIPMAP_LINEAR = 0x2703 + LINEAR_MIPMAP_NEAREST = 0x2701 + NEAREST_MIPMAP_LINEAR = 0x2702 + NEAREST_MIPMAP_NEAREST = 0x2700 + + GENERATE_MIPMAP = 0x8191 + TEXTURE_WRAP_R = 0x8072 + + PROXY_TEXTURE_1D = 0x8063 + PROXY_TEXTURE_2D = 0x8064 + PROXY_TEXTURE_3D = 0x8070 + TEXTURE_3D = 0x806F + TEXTURE_BASE_LEVEL = 0x813C + TEXTURE_MAX_LEVEL = 0x813D + TEXTURE_MAX_LOD = 0x813B + TEXTURE_MIN_LOD = 0x813A + + CLAMP = 0x2900 + CLAMP_TO_BORDER = 0x812D + CLAMP_TO_EDGE = 0x812F + REPEAT = 0x2901 + + CONSTANT_COLOR = 0x8001 + ONE_MINUS_CONSTANT_COLOR = 0x8002 + CONSTANT_ALPHA = 0x8003 + ONE_MINUS_CONSTANT_ALPHA = 0x8004 + FUNC_ADD = 0x8006 + MIN = 0x8007 + MAX = 0x8008 + BLEND_EQUATION_RGB = 0x8009 + FUNC_SUBTRACT = 0x800A + FUNC_REVERSE_SUBTRACT = 0x800B + RESCALE_NORMAL = 0x803A + TEXTURE_DEPTH = 0x8071 + MAX_3D_TEXTURE_SIZE = 0x8073 + MULTISAMPLE = 0x809D + SAMPLE_ALPHA_TO_COVERAGE = 0x809E + SAMPLE_ALPHA_TO_ONE = 0x809F + SAMPLE_COVERAGE = 0x80A0 + SAMPLE_BUFFERS = 0x80A8 + SAMPLES = 0x80A9 + SAMPLE_COVERAGE_VALUE = 0x80AA + SAMPLE_COVERAGE_INVERT = 0x80AB + BLEND_DST_RGB = 0x80C8 + BLEND_SRC_RGB = 0x80C9 + BLEND_DST_ALPHA = 0x80CA + BLEND_SRC_ALPHA = 0x80CB + BGR = 0x80E0 + BGRA = 0x80E1 + MAX_ELEMENTS_VERTICES = 0x80E8 + MAX_ELEMENTS_INDICES = 0x80E9 + DEPTH_COMPONENT16 = 0x81A5 + DEPTH_COMPONENT24 = 0x81A6 + DEPTH_COMPONENT32 = 0x81A7 + UNSIGNED_BYTE_2_3_3_REV = 0x8362 + UNSIGNED_SHORT_5_6_5 = 0x8363 + UNSIGNED_SHORT_5_6_5_REV = 0x8364 + UNSIGNED_SHORT_4_4_4_4_REV = 0x8365 + UNSIGNED_SHORT_1_5_5_5_REV = 0x8366 + UNSIGNED_INT_8_8_8_8_REV = 0x8367 + UNSIGNED_INT_2_10_10_10_REV = 0x8368 + MIRRORED_REPEAT = 0x8370 + FOG_COORDINATE_SOURCE = 0x8450 + FOG_COORD_SRC = 0x8450 + FOG_COORDINATE = 0x8451 + FOG_COORD = 0x8451 + FRAGMENT_DEPTH = 0x8452 + CURRENT_FOG_COORDINATE = 0x8453 + CURRENT_FOG_COORD = 0x8453 + FOG_COORDINATE_ARRAY_TYPE = 0x8454 + FOG_COORD_ARRAY_TYPE = 0x8454 + FOG_COORDINATE_ARRAY_STRIDE = 0x8455 + FOG_COORD_ARRAY_STRIDE = 0x8455 + FOG_COORDINATE_ARRAY_POINTER = 0x8456 + FOG_COORD_ARRAY_POINTER = 0x8456 + FOG_COORDINATE_ARRAY = 0x8457 + FOG_COORD_ARRAY = 0x8457 + COLOR_SUM = 0x8458 + CURRENT_SECONDARY_COLOR = 0x8459 + SECONDARY_COLOR_ARRAY_SIZE = 0x845A + SECONDARY_COLOR_ARRAY_TYPE = 0x845B + SECONDARY_COLOR_ARRAY_STRIDE = 0x845C + SECONDARY_COLOR_ARRAY_POINTER = 0x845D + SECONDARY_COLOR_ARRAY = 0x845E + TEXTURE0 = 0x84C0 + TEXTURE1 = 0x84C1 + TEXTURE2 = 0x84C2 + TEXTURE3 = 0x84C3 + TEXTURE4 = 0x84C4 + TEXTURE5 = 0x84C5 + TEXTURE6 = 0x84C6 + TEXTURE7 = 0x84C7 + TEXTURE8 = 0x84C8 + TEXTURE9 = 0x84C9 + TEXTURE10 = 0x84CA + TEXTURE11 = 0x84CB + TEXTURE12 = 0x84CC + TEXTURE13 = 0x84CD + TEXTURE14 = 0x84CE + TEXTURE15 = 0x84CF + TEXTURE16 = 0x84D0 + TEXTURE17 = 0x84D1 + TEXTURE18 = 0x84D2 + TEXTURE19 = 0x84D3 + TEXTURE20 = 0x84D4 + TEXTURE21 = 0x84D5 + TEXTURE22 = 0x84D6 + TEXTURE23 = 0x84D7 + TEXTURE24 = 0x84D8 + TEXTURE25 = 0x84D9 + TEXTURE26 = 0x84DA + TEXTURE27 = 0x84DB + TEXTURE28 = 0x84DC + TEXTURE29 = 0x84DD + TEXTURE30 = 0x84DE + TEXTURE31 = 0x84DF + ACTIVE_TEXTURE = 0x84E0 + CLIENT_ACTIVE_TEXTURE = 0x84E1 + MAX_TEXTURE_UNITS = 0x84E2 + TRANSPOSE_MODELVIEW_MATRIX = 0x84E3 + TRANSPOSE_PROJECTION_MATRIX = 0x84E4 + TRANSPOSE_TEXTURE_MATRIX = 0x84E5 + TRANSPOSE_COLOR_MATRIX = 0x84E6 + SUBTRACT = 0x84E7 + COMPRESSED_ALPHA = 0x84E9 + COMPRESSED_LUMINANCE = 0x84EA + COMPRESSED_LUMINANCE_ALPHA = 0x84EB + COMPRESSED_INTENSITY = 0x84EC + COMPRESSED_RGB = 0x84ED + COMPRESSED_RGBA = 0x84EE + MAX_TEXTURE_LOD_BIAS = 0x84FD + TEXTURE_FILTER_CONTROL = 0x8500 + TEXTURE_LOD_BIAS = 0x8501 + INCR_WRAP = 0x8507 + DECR_WRAP = 0x8508 + NORMAL_MAP = 0x8511 + REFLECTION_MAP = 0x8512 + TEXTURE_CUBE_MAP = 0x8513 + TEXTURE_BINDING_CUBE_MAP = 0x8514 + TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515 + TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516 + TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517 + TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518 + TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519 + TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A + PROXY_TEXTURE_CUBE_MAP = 0x851B + MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C + COMBINE = 0x8570 + COMBINE_RGB = 0x8571 + COMBINE_ALPHA = 0x8572 + RGB_SCALE = 0x8573 + ADD_SIGNED = 0x8574 + INTERPOLATE = 0x8575 + CONSTANT = 0x8576 + PRIMARY_COLOR = 0x8577 + PREVIOUS = 0x8578 + SOURCE0_RGB = 0x8580 + SRC0_RGB = 0x8580 + SOURCE1_RGB = 0x8581 + SRC1_RGB = 0x8581 + SOURCE2_RGB = 0x8582 + SRC2_RGB = 0x8582 + SOURCE0_ALPHA = 0x8588 + SRC0_ALPHA = 0x8588 + SOURCE1_ALPHA = 0x8589 + SRC1_ALPHA = 0x8589 + SOURCE2_ALPHA = 0x858A + SRC2_ALPHA = 0x858A + OPERAND0_RGB = 0x8590 + OPERAND1_RGB = 0x8591 + OPERAND2_RGB = 0x8592 + OPERAND0_ALPHA = 0x8598 + OPERAND1_ALPHA = 0x8599 + OPERAND2_ALPHA = 0x859A + VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622 + VERTEX_ATTRIB_ARRAY_SIZE = 0x8623 + VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624 + VERTEX_ATTRIB_ARRAY_TYPE = 0x8625 + CURRENT_VERTEX_ATTRIB = 0x8626 + VERTEX_PROGRAM_POINT_SIZE = 0x8642 + VERTEX_PROGRAM_TWO_SIDE = 0x8643 + VERTEX_ATTRIB_ARRAY_POINTER = 0x8645 + TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0 + TEXTURE_COMPRESSED = 0x86A1 + NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2 + COMPRESSED_TEXTURE_FORMATS = 0x86A3 + DOT3_RGB = 0x86AE + DOT3_RGBA = 0x86AF + BUFFER_SIZE = 0x8764 + BUFFER_USAGE = 0x8765 + STENCIL_BACK_FUNC = 0x8800 + STENCIL_BACK_FAIL = 0x8801 + STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802 + STENCIL_BACK_PASS_DEPTH_PASS = 0x8803 + MAX_DRAW_BUFFERS = 0x8824 + DRAW_BUFFER0 = 0x8825 + DRAW_BUFFER1 = 0x8826 + DRAW_BUFFER2 = 0x8827 + DRAW_BUFFER3 = 0x8828 + DRAW_BUFFER4 = 0x8829 + DRAW_BUFFER5 = 0x882A + DRAW_BUFFER6 = 0x882B + DRAW_BUFFER7 = 0x882C + DRAW_BUFFER8 = 0x882D + DRAW_BUFFER9 = 0x882E + DRAW_BUFFER10 = 0x882F + DRAW_BUFFER11 = 0x8830 + DRAW_BUFFER12 = 0x8831 + DRAW_BUFFER13 = 0x8832 + DRAW_BUFFER14 = 0x8833 + DRAW_BUFFER15 = 0x8834 + BLEND_EQUATION_ALPHA = 0x883D + TEXTURE_DEPTH_SIZE = 0x884A + DEPTH_TEXTURE_MODE = 0x884B + TEXTURE_COMPARE_MODE = 0x884C + TEXTURE_COMPARE_FUNC = 0x884D + COMPARE_R_TO_TEXTURE = 0x884E + POINT_SPRITE = 0x8861 + COORD_REPLACE = 0x8862 + QUERY_COUNTER_BITS = 0x8864 + CURRENT_QUERY = 0x8865 + QUERY_RESULT = 0x8866 + QUERY_RESULT_AVAILABLE = 0x8867 + MAX_VERTEX_ATTRIBS = 0x8869 + VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A + MAX_TEXTURE_COORDS = 0x8871 + MAX_TEXTURE_IMAGE_UNITS = 0x8872 + ARRAY_BUFFER = 0x8892 + ELEMENT_ARRAY_BUFFER = 0x8893 + ARRAY_BUFFER_BINDING = 0x8894 + ELEMENT_ARRAY_BUFFER_BINDING = 0x8895 + VERTEX_ARRAY_BUFFER_BINDING = 0x8896 + NORMAL_ARRAY_BUFFER_BINDING = 0x8897 + COLOR_ARRAY_BUFFER_BINDING = 0x8898 + INDEX_ARRAY_BUFFER_BINDING = 0x8899 + TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A + EDGE_FLAG_ARRAY_BUFFER_BINDING = 0x889B + SECONDARY_COLOR_ARRAY_BUFFER_BINDING = 0x889C + FOG_COORDINATE_ARRAY_BUFFER_BINDING = 0x889D + FOG_COORD_ARRAY_BUFFER_BINDING = 0x889D + WEIGHT_ARRAY_BUFFER_BINDING = 0x889E + VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F + READ_ONLY = 0x88B8 + WRITE_ONLY = 0x88B9 + READ_WRITE = 0x88BA + BUFFER_ACCESS = 0x88BB + BUFFER_MAPPED = 0x88BC + BUFFER_MAP_POINTER = 0x88BD + STREAM_DRAW = 0x88E0 + STREAM_READ = 0x88E1 + STREAM_COPY = 0x88E2 + STATIC_DRAW = 0x88E4 + STATIC_READ = 0x88E5 + STATIC_COPY = 0x88E6 + DYNAMIC_DRAW = 0x88E8 + DYNAMIC_READ = 0x88E9 + DYNAMIC_COPY = 0x88EA + SAMPLES_PASSED = 0x8914 + FRAGMENT_SHADER = 0x8B30 + VERTEX_SHADER = 0x8B31 + MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49 + MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A + MAX_VARYING_FLOATS = 0x8B4B + MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C + MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D + SHADER_TYPE = 0x8B4F + FLOAT_VEC2 = 0x8B50 + FLOAT_VEC3 = 0x8B51 + FLOAT_VEC4 = 0x8B52 + INT_VEC2 = 0x8B53 + INT_VEC3 = 0x8B54 + INT_VEC4 = 0x8B55 + BOOL = 0x8B56 + BOOL_VEC2 = 0x8B57 + BOOL_VEC3 = 0x8B58 + BOOL_VEC4 = 0x8B59 + FLOAT_MAT2 = 0x8B5A + FLOAT_MAT3 = 0x8B5B + FLOAT_MAT4 = 0x8B5C + SAMPLER_1D = 0x8B5D + SAMPLER_2D = 0x8B5E + SAMPLER_3D = 0x8B5F + SAMPLER_CUBE = 0x8B60 + SAMPLER_1D_SHADOW = 0x8B61 + SAMPLER_2D_SHADOW = 0x8B62 + DELETE_STATUS = 0x8B80 + COMPILE_STATUS = 0x8B81 + LINK_STATUS = 0x8B82 + VALIDATE_STATUS = 0x8B83 + INFO_LOG_LENGTH = 0x8B84 + ATTACHED_SHADERS = 0x8B85 + ACTIVE_UNIFORMS = 0x8B86 + ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87 + SHADER_SOURCE_LENGTH = 0x8B88 + ACTIVE_ATTRIBUTES = 0x8B89 + ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A + SHADING_LANGUAGE_VERSION = 0x8B8C + CURRENT_PROGRAM = 0x8B8D + POINT_SPRITE_COORD_ORIGIN = 0x8CA0 + LOWER_LEFT = 0x8CA1 + UPPER_LEFT = 0x8CA2 + STENCIL_BACK_REF = 0x8CA3 + STENCIL_BACK_VALUE_MASK = 0x8CA4 + STENCIL_BACK_WRITEMASK = 0x8CA5 +) + +// https://www.opengl.org/sdk/docs/man2/xhtml/glViewport.xml +func (gl *GL) Viewport(x, y, width, height int) { + C.gl2_0_glViewport(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// DepthRange specifies the mapping of depth values from normalized device +// coordinates to window coordinates. +// +// Parameter nearVal specifies the mapping of the near clipping plane to window +// coordinates (defaults to 0), while farVal specifies the mapping of the far +// clipping plane to window coordinates (defaults to 1). +// +// After clipping and division by w, depth coordinates range from -1 to 1, +// corresponding to the near and far clipping planes. DepthRange specifies a +// linear mapping of the normalized depth coordinates in this range to window +// depth coordinates. Regardless of the actual depth buffer implementation, +// window coordinate depth values are treated as though they range from 0 through 1 +// (like color components). Thus, the values accepted by DepthRange are both +// clamped to this range before they are accepted. +// +// The default setting of (0, 1) maps the near plane to 0 and the far plane to 1. +// With this mapping, the depth buffer range is fully utilized. +// +// It is not necessary that nearVal be less than farVal. Reverse mappings such as +// nearVal 1, and farVal 0 are acceptable. +// +// GL.INVALID_OPERATION is generated if DepthRange is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) DepthRange(nearVal, farVal float64) { + C.gl2_0_glDepthRange(gl.funcs, C.GLdouble(nearVal), C.GLdouble(farVal)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsEnabled.xml +func (gl *GL) IsEnabled(cap glbase.Enum) bool { + glresult := C.gl2_0_glIsEnabled(gl.funcs, C.GLenum(cap)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexLevelParameteriv.xml +func (gl *GL) GetTexLevelParameteriv(target glbase.Enum, level int, pname glbase.Enum, params []int32) { + C.gl2_0_glGetTexLevelParameteriv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexLevelParameterfv.xml +func (gl *GL) GetTexLevelParameterfv(target glbase.Enum, level int, pname glbase.Enum, params []float32) { + C.gl2_0_glGetTexLevelParameterfv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexParameteriv.xml +func (gl *GL) GetTexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl2_0_glGetTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexParameterfv.xml +func (gl *GL) GetTexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl2_0_glGetTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexImage.xml +func (gl *GL) GetTexImage(target glbase.Enum, level int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glGetTexImage(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetIntegerv.xml +func (gl *GL) GetIntegerv(pname glbase.Enum, params []int32) { + C.gl2_0_glGetIntegerv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetFloatv.xml +func (gl *GL) GetFloatv(pname glbase.Enum, params []float32) { + C.gl2_0_glGetFloatv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetError.xml +func (gl *GL) GetError() glbase.Enum { + glresult := C.gl2_0_glGetError(gl.funcs) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetDoublev.xml +func (gl *GL) GetDoublev(pname glbase.Enum, params []float64) { + C.gl2_0_glGetDoublev(gl.funcs, C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetBooleanv.xml +func (gl *GL) GetBooleanv(pname glbase.Enum, params []bool) { + C.gl2_0_glGetBooleanv(gl.funcs, C.GLenum(pname), (*C.GLboolean)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glReadPixels.xml +func (gl *GL) ReadPixels(x, y, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glReadPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glReadBuffer.xml +func (gl *GL) ReadBuffer(mode glbase.Enum) { + C.gl2_0_glReadBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelStorei.xml +func (gl *GL) PixelStorei(pname glbase.Enum, param int32) { + C.gl2_0_glPixelStorei(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelStoref.xml +func (gl *GL) PixelStoref(pname glbase.Enum, param float32) { + C.gl2_0_glPixelStoref(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDepthFunc.xml +func (gl *GL) DepthFunc(glfunc glbase.Enum) { + C.gl2_0_glDepthFunc(gl.funcs, C.GLenum(glfunc)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilOp.xml +func (gl *GL) StencilOp(fail, zfail, zpass glbase.Enum) { + C.gl2_0_glStencilOp(gl.funcs, C.GLenum(fail), C.GLenum(zfail), C.GLenum(zpass)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilFunc.xml +func (gl *GL) StencilFunc(glfunc glbase.Enum, ref int32, mask uint32) { + C.gl2_0_glStencilFunc(gl.funcs, C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLogicOp.xml +func (gl *GL) LogicOp(opcode glbase.Enum) { + C.gl2_0_glLogicOp(gl.funcs, C.GLenum(opcode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBlendFunc.xml +func (gl *GL) BlendFunc(sfactor, dfactor glbase.Enum) { + C.gl2_0_glBlendFunc(gl.funcs, C.GLenum(sfactor), C.GLenum(dfactor)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFlush.xml +func (gl *GL) Flush() { + C.gl2_0_glFlush(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFinish.xml +func (gl *GL) Finish() { + C.gl2_0_glFinish(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEnable.xml +func (gl *GL) Enable(cap glbase.Enum) { + C.gl2_0_glEnable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDisable.xml +func (gl *GL) Disable(cap glbase.Enum) { + C.gl2_0_glDisable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDepthMask.xml +func (gl *GL) DepthMask(flag bool) { + C.gl2_0_glDepthMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorMask.xml +func (gl *GL) ColorMask(red, green, blue, alpha bool) { + C.gl2_0_glColorMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&red)), *(*C.GLboolean)(unsafe.Pointer(&green)), *(*C.GLboolean)(unsafe.Pointer(&blue)), *(*C.GLboolean)(unsafe.Pointer(&alpha))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilMask.xml +func (gl *GL) StencilMask(mask uint32) { + C.gl2_0_glStencilMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearDepth.xml +func (gl *GL) ClearDepth(depth float64) { + C.gl2_0_glClearDepth(gl.funcs, C.GLdouble(depth)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearStencil.xml +func (gl *GL) ClearStencil(s int32) { + C.gl2_0_glClearStencil(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearColor.xml +func (gl *GL) ClearColor(red, green, blue, alpha float32) { + C.gl2_0_glClearColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClear.xml +func (gl *GL) Clear(mask glbase.Bitfield) { + C.gl2_0_glClear(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawBuffer.xml +func (gl *GL) DrawBuffer(mode glbase.Enum) { + C.gl2_0_glDrawBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexImage2D.xml +func (gl *GL) TexImage2D(target glbase.Enum, level int, internalFormat int32, width, height, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexImage1D.xml +func (gl *GL) TexImage1D(target glbase.Enum, level int, internalFormat int32, width, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameteriv.xml +func (gl *GL) TexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl2_0_glTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameteri.xml +func (gl *GL) TexParameteri(target, pname glbase.Enum, param int32) { + C.gl2_0_glTexParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameterfv.xml +func (gl *GL) TexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl2_0_glTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameterf.xml +func (gl *GL) TexParameterf(target, pname glbase.Enum, param float32) { + C.gl2_0_glTexParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glScissor.xml +func (gl *GL) Scissor(x, y, width, height int) { + C.gl2_0_glScissor(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPolygonMode.xml +func (gl *GL) PolygonMode(face, mode glbase.Enum) { + C.gl2_0_glPolygonMode(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPointSize.xml +func (gl *GL) PointSize(size float32) { + C.gl2_0_glPointSize(gl.funcs, C.GLfloat(size)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLineWidth.xml +func (gl *GL) LineWidth(width float32) { + C.gl2_0_glLineWidth(gl.funcs, C.GLfloat(width)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glHint.xml +func (gl *GL) Hint(target, mode glbase.Enum) { + C.gl2_0_glHint(gl.funcs, C.GLenum(target), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFrontFace.xml +func (gl *GL) FrontFace(mode glbase.Enum) { + C.gl2_0_glFrontFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCullFace.xml +func (gl *GL) CullFace(mode glbase.Enum) { + C.gl2_0_glCullFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexubv.xml +func (gl *GL) Indexubv(c []uint8) { + C.gl2_0_glIndexubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexub.xml +func (gl *GL) Indexub(c uint8) { + C.gl2_0_glIndexub(gl.funcs, C.GLubyte(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsTexture.xml +func (gl *GL) IsTexture(texture glbase.Texture) bool { + glresult := C.gl2_0_glIsTexture(gl.funcs, C.GLuint(texture)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenTextures returns n texture names in textures. There is no guarantee +// that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenTextures. +// +// The generated textures have no dimensionality; they assume the +// dimensionality of the texture target to which they are first bound (see +// BindTexture). +// +// Texture names returned by a call to GenTextures are not returned by +// subsequent calls, unless they are first deleted with DeleteTextures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenTextures is available in GL version 2.0 or greater. +func (gl *GL) GenTextures(n int) []glbase.Texture { + if n == 0 { + return nil + } + textures := make([]glbase.Texture, n) + C.gl2_0_glGenTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) + return textures +} + +// DeleteTextures deletes the textures objects whose names are stored +// in the textures slice. After a texture is deleted, it has no contents or +// dimensionality, and its name is free for reuse (for example by +// GenTextures). If a texture that is currently bound is deleted, the binding +// reverts to 0 (the default texture). +// +// DeleteTextures silently ignores 0's and names that do not correspond to +// existing textures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteTextures is available in GL version 2.0 or greater. +func (gl *GL) DeleteTextures(textures []glbase.Texture) { + n := len(textures) + if n == 0 { + return + } + C.gl2_0_glDeleteTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBindTexture.xml +func (gl *GL) BindTexture(target glbase.Enum, texture glbase.Texture) { + C.gl2_0_glBindTexture(gl.funcs, C.GLenum(target), C.GLuint(texture)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexSubImage2D.xml +func (gl *GL) TexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexSubImage1D.xml +func (gl *GL) TexSubImage1D(target glbase.Enum, level, xoffset, width int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexSubImage2D.xml +func (gl *GL) CopyTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, x, y, width, height int) { + C.gl2_0_glCopyTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexSubImage1D.xml +func (gl *GL) CopyTexSubImage1D(target glbase.Enum, level, xoffset, x, y, width int) { + C.gl2_0_glCopyTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexImage2D.xml +func (gl *GL) CopyTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, height, border int) { + C.gl2_0_glCopyTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexImage1D.xml +func (gl *GL) CopyTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, border int) { + C.gl2_0_glCopyTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPolygonOffset.xml +func (gl *GL) PolygonOffset(factor, units float32) { + C.gl2_0_glPolygonOffset(gl.funcs, C.GLfloat(factor), C.GLfloat(units)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawElements.xml +func (gl *GL) DrawElements(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glDrawElements(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawArrays.xml +func (gl *GL) DrawArrays(mode glbase.Enum, first, count int) { + C.gl2_0_glDrawArrays(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexSubImage3D.xml +func (gl *GL) CopyTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, x, y, width, height int) { + C.gl2_0_glCopyTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexSubImage3D.xml +func (gl *GL) TexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexImage3D.xml +func (gl *GL) TexImage3D(target glbase.Enum, level int, internalFormat int32, width, height int, depth int32, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawRangeElements.xml +func (gl *GL) DrawRangeElements(mode glbase.Enum, start, end uint32, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glDrawRangeElements(gl.funcs, C.GLenum(mode), C.GLuint(start), C.GLuint(end), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBlendEquation.xml +func (gl *GL) BlendEquation(mode glbase.Enum) { + C.gl2_0_glBlendEquation(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBlendColor.xml +func (gl *GL) BlendColor(red, green, blue, alpha float32) { + C.gl2_0_glBlendColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetCompressedTexImage.xml +func (gl *GL) GetCompressedTexImage(target glbase.Enum, level int, img interface{}) { + var img_ptr unsafe.Pointer + var img_v = reflect.ValueOf(img) + if img != nil && img_v.Kind() != reflect.Slice { + panic("parameter img must be a slice") + } + if img != nil { + img_ptr = unsafe.Pointer(img_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glGetCompressedTexImage(gl.funcs, C.GLenum(target), C.GLint(level), img_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCompressedTexSubImage1D.xml +func (gl *GL) CompressedTexSubImage1D(target glbase.Enum, level, xoffset, width int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glCompressedTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCompressedTexSubImage2D.xml +func (gl *GL) CompressedTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glCompressedTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCompressedTexSubImage3D.xml +func (gl *GL) CompressedTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glCompressedTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCompressedTexImage1D.xml +func (gl *GL) CompressedTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, width, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glCompressedTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCompressedTexImage2D.xml +func (gl *GL) CompressedTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glCompressedTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCompressedTexImage3D.xml +func (gl *GL) CompressedTexImage3D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height int, depth int32, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glCompressedTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSampleCoverage.xml +func (gl *GL) SampleCoverage(value float32, invert bool) { + C.gl2_0_glSampleCoverage(gl.funcs, C.GLfloat(value), *(*C.GLboolean)(unsafe.Pointer(&invert))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glActiveTexture.xml +func (gl *GL) ActiveTexture(texture glbase.Enum) { + C.gl2_0_glActiveTexture(gl.funcs, C.GLenum(texture)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPointParameteriv.xml +func (gl *GL) PointParameteriv(pname glbase.Enum, params []int32) { + C.gl2_0_glPointParameteriv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPointParameteri.xml +func (gl *GL) PointParameteri(pname glbase.Enum, param int32) { + C.gl2_0_glPointParameteri(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPointParameterfv.xml +func (gl *GL) PointParameterfv(pname glbase.Enum, params []float32) { + C.gl2_0_glPointParameterfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPointParameterf.xml +func (gl *GL) PointParameterf(pname glbase.Enum, param float32) { + C.gl2_0_glPointParameterf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiDrawArrays.xml +func (gl *GL) MultiDrawArrays(mode glbase.Enum, first, count []int, drawcount int32) { + C.gl2_0_glMultiDrawArrays(gl.funcs, C.GLenum(mode), (*C.GLint)(unsafe.Pointer(&first[0])), (*C.GLsizei)(unsafe.Pointer(&count[0])), C.GLsizei(drawcount)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBlendFuncSeparate.xml +func (gl *GL) BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha glbase.Enum) { + C.gl2_0_glBlendFuncSeparate(gl.funcs, C.GLenum(sfactorRGB), C.GLenum(dfactorRGB), C.GLenum(sfactorAlpha), C.GLenum(dfactorAlpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetBufferParameteriv.xml +func (gl *GL) GetBufferParameteriv(target, pname glbase.Enum, params []int32) { + C.gl2_0_glGetBufferParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glUnmapBuffer.xml +func (gl *GL) UnmapBuffer(target glbase.Enum) bool { + glresult := C.gl2_0_glUnmapBuffer(gl.funcs, C.GLenum(target)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetBufferSubData.xml +func (gl *GL) GetBufferSubData(target glbase.Enum, offset, size int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glGetBufferSubData(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(size), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBufferSubData.xml +func (gl *GL) BufferSubData(target glbase.Enum, offset, size int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glBufferSubData(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(size), data_ptr) +} + +// BufferData creates a new data store for the buffer object currently +// bound to target. Any pre-existing data store is deleted. The new data +// store is created with the specified size in bytes and usage. If data is +// not nil, it must be a slice that is used to initialize the data store. +// In that case the size parameter is ignored and the store size will match +// the slice data size. +// +// In its initial state, the new data store is not mapped, it has a NULL +// mapped pointer, and its mapped access is GL.READ_WRITE. +// +// The target constant must be one of GL.ARRAY_BUFFER, GL.COPY_READ_BUFFER, +// GL.COPY_WRITE_BUFFER, GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER, +// GL.PIXEL_UNPACK_BUFFER, GL.TEXTURE_BUFFER, GL.TRANSFORM_FEEDBACK_BUFFER, +// or GL.UNIFORM_BUFFER. +// +// The usage parameter is a hint to the GL implementation as to how a buffer +// object's data store will be accessed. This enables the GL implementation +// to make more intelligent decisions that may significantly impact buffer +// object performance. It does not, however, constrain the actual usage of +// the data store. usage can be broken down into two parts: first, the +// frequency of access (modification and usage), and second, the nature of +// that access. +// +// A usage frequency of STREAM and nature of DRAW is specified via the +// constant GL.STREAM_DRAW, for example. +// +// The usage frequency of access may be one of: +// +// STREAM +// The data store contents will be modified once and used at most a few times. +// +// STATIC +// The data store contents will be modified once and used many times. +// +// DYNAMIC +// The data store contents will be modified repeatedly and used many times. +// +// The usage nature of access may be one of: +// +// DRAW +// The data store contents are modified by the application, and used as +// the source for GL drawing and image specification commands. +// +// READ +// The data store contents are modified by reading data from the GL, +// and used to return that data when queried by the application. +// +// COPY +// The data store contents are modified by reading data from the GL, +// and used as the source for GL drawing and image specification +// commands. +// +// Clients must align data elements consistent with the requirements of the +// client platform, with an additional base-level requirement that an offset +// within a buffer to a datum comprising N bytes be a multiple of N. +// +// Error GL.INVALID_ENUM is generated if target is not one of the accepted +// buffer targets. GL.INVALID_ENUM is generated if usage is not +// GL.STREAM_DRAW, GL.STREAM_READ, GL.STREAM_COPY, GL.STATIC_DRAW, +// GL.STATIC_READ, GL.STATIC_COPY, GL.DYNAMIC_DRAW, GL.DYNAMIC_READ, or +// GL.DYNAMIC_COPY. GL.INVALID_VALUE is generated if size is negative. +// GL.INVALID_OPERATION is generated if the reserved buffer object name 0 is +// bound to target. GL.OUT_OF_MEMORY is generated if the GL is unable to +// create a data store with the specified size. +func (gl *GL) BufferData(target glbase.Enum, size int, data interface{}, usage glbase.Enum) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + if data != nil { + size = int(data_v.Type().Size()) * data_v.Len() + } + C.gl2_0_glBufferData(gl.funcs, C.GLenum(target), C.GLsizeiptr(size), data_ptr, C.GLenum(usage)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsBuffer.xml +func (gl *GL) IsBuffer(buffer glbase.Buffer) bool { + glresult := C.gl2_0_glIsBuffer(gl.funcs, C.GLuint(buffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenBuffers returns n buffer object names. There is no guarantee that +// the names form a contiguous set of integers; however, it is guaranteed +// that none of the returned names was in use immediately before the call to +// GenBuffers. +// +// Buffer object names returned by a call to GenBuffers are not returned by +// subsequent calls, unless they are first deleted with DeleteBuffers. +// +// No buffer objects are associated with the returned buffer object names +// until they are first bound by calling BindBuffer. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if GenBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// GenBuffers is available in GL version 1.5 or greater. +func (gl *GL) GenBuffers(n int) []glbase.Buffer { + if n == 0 { + return nil + } + buffers := make([]glbase.Buffer, n) + C.gl2_0_glGenBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) + return buffers +} + +// DeleteBuffers deletes the buffer objects whose names are stored in the +// buffers slice. +// +// After a buffer object is deleted, it has no contents, and its name is free +// for reuse (for example by GenBuffers). If a buffer object that is +// currently bound is deleted, the binding reverts to 0 (the absence of any +// buffer object, which reverts to client memory usage). +// +// DeleteBuffers silently ignores 0's and names that do not correspond to +// existing buffer objects. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if DeleteBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// DeleteBuffers is available in GL version 1.5 or greater. +func (gl *GL) DeleteBuffers(buffers []glbase.Buffer) { + n := len(buffers) + if n == 0 { + return + } + C.gl2_0_glDeleteBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) +} + +// BindBuffer creates or puts in use a named buffer object. +// Calling BindBuffer with target set to GL.ARRAY_BUFFER, +// GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER or GL.PIXEL_UNPACK_BUFFER +// and buffer set to the name of the new buffer object binds the buffer +// object name to the target. When a buffer object is bound to a target, the +// previous binding for that target is automatically broken. +// +// Buffer object names are unsigned integers. The value zero is reserved, but +// there is no default buffer object for each buffer object target. Instead, +// buffer set to zero effectively unbinds any buffer object previously bound, +// and restores client memory usage for that buffer object target. Buffer +// object names and the corresponding buffer object contents are local to the +// shared display-list space (see XCreateContext) of the current GL rendering +// context; two rendering contexts share buffer object names only if they +// also share display lists. +// +// GenBuffers may be called to generate a set of new buffer object names. +// +// The state of a buffer object immediately after it is first bound is an +// unmapped zero-sized memory buffer with GL.READ_WRITE access and +// GL.STATIC_DRAW usage. +// +// While a non-zero buffer object name is bound, GL operations on the target +// to which it is bound affect the bound buffer object, and queries of the +// target to which it is bound return state from the bound buffer object. +// While buffer object name zero is bound, as in the initial state, attempts +// to modify or query state on the target to which it is bound generates an +// GL.INVALID_OPERATION error. +// +// When vertex array pointer state is changed, for example by a call to +// NormalPointer, the current buffer object binding (GL.ARRAY_BUFFER_BINDING) +// is copied into the corresponding client state for the vertex array type +// being changed, for example GL.NORMAL_ARRAY_BUFFER_BINDING. While a +// non-zero buffer object is bound to the GL.ARRAY_BUFFER target, the vertex +// array pointer parameter that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.ELEMENT_ARRAY_BUFFER +// target, the indices parameter of DrawElements, DrawRangeElements, or +// MultiDrawElements that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_PACK_BUFFER +// target, the following commands are affected: GetCompressedTexImage, +// GetConvolutionFilter, GetHistogram, GetMinmax, GetPixelMap, +// GetPolygonStipple, GetSeparableFilter, GetTexImage, and ReadPixels. The +// pointer parameter that is traditionally interpreted as a pointer to +// client-side memory where the pixels are to be packed is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_UNPACK_BUFFER +// target, the following commands are affected: Bitmap, ColorSubTable, +// ColorTable, CompressedTexImage1D, CompressedTexImage2D, +// CompressedTexImage3D, CompressedTexSubImage1D, CompressedTexSubImage2D, +// CompressedTexSubImage3D, ConvolutionFilter1D, ConvolutionFilter2D, +// DrawPixels, PixelMap, PolygonStipple, SeparableFilter2D, TexImage1D, +// TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, and TexSubImage3D. +// The pointer parameter that is traditionally interpreted as a pointer to +// client-side memory from which the pixels are to be unpacked is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// A buffer object binding created with BindBuffer remains active until a +// different buffer object name is bound to the same target, or until the +// bound buffer object is deleted with DeleteBuffers. +// +// Once created, a named buffer object may be re-bound to any target as often +// as needed. However, the GL implementation may make choices about how to +// optimize the storage of a buffer object based on its initial binding +// target. +// +// Error GL.INVALID_ENUM is generated if target is not one of the allowable +// values. GL.INVALID_OPERATION is generated if BindBuffer is executed +// between the execution of Begin and the corresponding execution of End. +// +// BindBuffer is available in GL version 1.5 or greater. +func (gl *GL) BindBuffer(target glbase.Enum, buffer glbase.Buffer) { + C.gl2_0_glBindBuffer(gl.funcs, C.GLenum(target), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetQueryObjectuiv.xml +func (gl *GL) GetQueryObjectuiv(id uint32, pname glbase.Enum, params []uint32) { + C.gl2_0_glGetQueryObjectuiv(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetQueryObjectiv.xml +func (gl *GL) GetQueryObjectiv(id uint32, pname glbase.Enum, params []int32) { + C.gl2_0_glGetQueryObjectiv(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetQueryiv.xml +func (gl *GL) GetQueryiv(target, pname glbase.Enum, params []int32) { + C.gl2_0_glGetQueryiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEndQuery.xml +func (gl *GL) EndQuery(target glbase.Enum) { + C.gl2_0_glEndQuery(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBeginQuery.xml +func (gl *GL) BeginQuery(target glbase.Enum, id uint32) { + C.gl2_0_glBeginQuery(gl.funcs, C.GLenum(target), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsQuery.xml +func (gl *GL) IsQuery(id uint32) bool { + glresult := C.gl2_0_glIsQuery(gl.funcs, C.GLuint(id)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDeleteQueries.xml +func (gl *GL) DeleteQueries(n int, ids []uint32) { + C.gl2_0_glDeleteQueries(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGenQueries.xml +func (gl *GL) GenQueries(n int, ids []uint32) { + C.gl2_0_glGenQueries(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// VertexAttribPointer specifies the location and data format of the array +// of generic vertex attributes at index to use when rendering. size +// specifies the number of components per attribute and must be 1, 2, 3, or +// 4. type specifies the data type of each component, and stride specifies +// the byte stride from one attribute to the next, allowing vertices and +// attributes to be packed into a single array or stored in separate arrays. +// normalized indicates whether the values stored in an integer format are +// to be mapped to the range [-1,1] (for signed values) or [0,1] +// (for unsigned values) when they are accessed and converted to floating +// point; otherwise, values will be converted to floats directly without +// normalization. offset is a byte offset into the buffer object's data +// store, which must be bound to the GL.ARRAY_BUFFER target with BindBuffer. +// +// The buffer object binding (GL.ARRAY_BUFFER_BINDING) is saved as +// generic vertex attribute array client-side state +// (GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING) for the provided index. +// +// To enable and disable a generic vertex attribute array, call +// EnableVertexAttribArray and DisableVertexAttribArray with index. If +// enabled, the generic vertex attribute array is used when DrawArrays or +// DrawElements is called. Each generic vertex attribute array is initially +// disabled. +// +// VertexAttribPointer is typically implemented on the client side. +// +// Error GL.INVALID_ENUM is generated if type is not an accepted value. +// GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_VALUE is generated if size is not 1, 2, +// 3, or 4. GL.INVALID_VALUE is generated if stride is negative. +func (gl *GL) VertexAttribPointer(index glbase.Attrib, size int, gltype glbase.Enum, normalized bool, stride int, offset uintptr) { + offset_ptr := unsafe.Pointer(offset) + C.gl2_0_glVertexAttribPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLsizei(stride), offset_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glValidateProgram.xml +func (gl *GL) ValidateProgram(program glbase.Program) { + C.gl2_0_glValidateProgram(gl.funcs, C.GLuint(program)) +} + +// UniformMatrix4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*4) != 0 { + panic("invalid value length for UniformMatrix4fv") + } + count := len(value) / (4 * 4) + C.gl2_0_glUniformMatrix4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*3) != 0 { + panic("invalid value length for UniformMatrix3fv") + } + count := len(value) / (3 * 3) + C.gl2_0_glUniformMatrix3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*2) != 0 { + panic("invalid value length for UniformMatrix2fv") + } + count := len(value) / (2 * 2) + C.gl2_0_glUniformMatrix2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform4iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4iv") + } + count := len(value) / 4 + C.gl2_0_glUniform4iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform3iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3iv") + } + count := len(value) / 3 + C.gl2_0_glUniform3iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform2iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2iv") + } + count := len(value) / 2 + C.gl2_0_glUniform2iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform1iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl2_0_glUniform1iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4fv") + } + count := len(value) / 4 + C.gl2_0_glUniform4fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3fv") + } + count := len(value) / 3 + C.gl2_0_glUniform3fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2fv") + } + count := len(value) / 2 + C.gl2_0_glUniform2fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform1fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl2_0_glUniform1fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform4i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4i(location glbase.Uniform, v0, v1, v2, v3 int32) { + C.gl2_0_glUniform4i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2), C.GLint(v3)) +} + +// Uniform3i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3i(location glbase.Uniform, v0, v1, v2 int32) { + C.gl2_0_glUniform3i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2)) +} + +// Uniform2i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2i(location glbase.Uniform, v0, v1 int32) { + C.gl2_0_glUniform2i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1)) +} + +// Uniform1i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1i(location glbase.Uniform, v0 int32) { + C.gl2_0_glUniform1i(gl.funcs, C.GLint(location), C.GLint(v0)) +} + +// Uniform4f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4f(location glbase.Uniform, v0, v1, v2, v3 float32) { + C.gl2_0_glUniform4f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2), C.GLfloat(v3)) +} + +// Uniform3f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3f(location glbase.Uniform, v0, v1, v2 float32) { + C.gl2_0_glUniform3f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2)) +} + +// Uniform2f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2f(location glbase.Uniform, v0, v1 float32) { + C.gl2_0_glUniform2f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1)) +} + +// Uniform1f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1f(location glbase.Uniform, v0 float32) { + C.gl2_0_glUniform1f(gl.funcs, C.GLint(location), C.GLfloat(v0)) +} + +// UseProgram installs the program object specified by program as part of +// current rendering state. One or more executables are created in a program +// object by successfully attaching shader objects to it with AttachShader, +// successfully compiling the shader objects with CompileShader, and +// successfully linking the program object with LinkProgram. +// +// A program object will contain an executable that will run on the vertex +// processor if it contains one or more shader objects of type +// GL.VERTEX_SHADER that have been successfully compiled and linked. +// Similarly, a program object will contain an executable that will run on +// the fragment processor if it contains one or more shader objects of type +// GL.FRAGMENT_SHADER that have been successfully compiled and linked. +// +// Successfully installing an executable on a programmable processor will +// cause the corresponding fixed functionality of OpenGL to be disabled. +// Specifically, if an executable is installed on the vertex processor, the +// OpenGL fixed functionality will be disabled as follows. +// +// - The modelview matrix is not applied to vertex coordinates. +// +// - The projection matrix is not applied to vertex coordinates. +// +// - The texture matrices are not applied to texture coordinates. +// +// - Normals are not transformed to eye coordinates. +// +// - Normals are not rescaled or normalized. +// +// - Normalization of GL.AUTO_NORMAL evaluated normals is not performed. +// +// - Texture coordinates are not generated automatically. +// +// - Per-vertex lighting is not performed. +// +// - Color material computations are not performed. +// +// - Color index lighting is not performed. +// +// - This list also applies when setting the current raster position. +// +// The executable that is installed on the vertex processor is expected to +// implement any or all of the desired functionality from the preceding list. +// Similarly, if an executable is installed on the fragment processor, the +// OpenGL fixed functionality will be disabled as follows. +// +// - Texture environment and texture functions are not applied. +// +// - Texture application is not applied. +// +// - Color sum is not applied. +// +// - Fog is not applied. +// +// Again, the fragment shader that is installed is expected to implement any +// or all of the desired functionality from the preceding list. +// +// While a program object is in use, applications are free to modify attached +// shader objects, compile attached shader objects, attach additional shader +// objects, and detach or delete shader objects. None of these operations +// will affect the executables that are part of the current state. However, +// relinking the program object that is currently in use will install the +// program object as part of the current rendering state if the link +// operation was successful (see LinkProgram). If the program object +// currently in use is relinked unsuccessfully, its link status will be set +// to GL.FALSE, but the executables and associated state will remain part of +// the current state until a subsequent call to UseProgram removes it from +// use. After it is removed from use, it cannot be made part of current state +// until it has been successfully relinked. +// +// If program contains shader objects of type GL.VERTEX_SHADER but it does +// not contain shader objects of type GL.FRAGMENT_SHADER, an executable will +// be installed on the vertex processor, but fixed functionality will be used +// for fragment processing. Similarly, if program contains shader objects of +// type GL.FRAGMENT_SHADER but it does not contain shader objects of type +// GL.VERTEX_SHADER, an executable will be installed on the fragment +// processor, but fixed functionality will be used for vertex processing. If +// program is 0, the programmable processors will be disabled, and fixed +// functionality will be used for both vertex and fragment processing. +// +// While a program object is in use, the state that controls the disabled +// fixed functionality may also be updated using the normal OpenGL calls. +// +// Like display lists and texture objects, the name space for program objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// Applications are responsible for providing the synchronization across API +// calls when objects are accessed from different execution threads. +// +// Error GL.INVALID_VALUE is generated if program is neither 0 nor a value +// generated by OpenGL. GL.INVALID_OPERATION is generated if program is not +// a program object. GL.INVALID_OPERATION is generated if program could not +// be made part of current state. GL.INVALID_OPERATION is generated if +// UseProgram is executed between the execution of Begin and the +// corresponding execution of End. +// +// UseProgram is available in GL version 2.0 or greater. +func (gl *GL) UseProgram(program glbase.Program) { + C.gl2_0_glUseProgram(gl.funcs, C.GLuint(program)) +} + +// ShaderSource sets the source code in shader to the provided source code. Any source +// code previously stored in the shader object is completely replaced. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_VALUE is generated if count is less than 0. +// GL.INVALID_OPERATION is generated if ShaderSource is executed between the +// execution of Begin and the corresponding execution of End. +// +// ShaderSource is available in GL version 2.0 or greater. +func (gl *GL) ShaderSource(shader glbase.Shader, source ...string) { + count := len(source) + length := make([]int32, count) + source_c := make([]unsafe.Pointer, count) + for i, src := range source { + length[i] = int32(len(src)) + if len(src) > 0 { + source_c[i] = *(*unsafe.Pointer)(unsafe.Pointer(&src)) + } else { + source_c[i] = unsafe.Pointer(uintptr(0)) + } + } + C.gl2_0_glShaderSource(gl.funcs, C.GLuint(shader), C.GLsizei(count), (**C.GLchar)(unsafe.Pointer(&source_c[0])), (*C.GLint)(unsafe.Pointer(&length[0]))) +} + +// LinkProgram links the program object specified by program. If any shader +// objects of type GL.VERTEX_SHADER are attached to program, they will be +// used to create an executable that will run on the programmable vertex +// processor. If any shader objects of type GL.FRAGMENT_SHADER are attached +// to program, they will be used to create an executable that will run on the +// programmable fragment processor. +// +// The status of the link operation will be stored as part of the program +// object's state. This value will be set to GL.TRUE if the program object +// was linked without errors and is ready for use, and GL.FALSE otherwise. It +// can be queried by calling GetProgramiv with arguments program and +// GL.LINK_STATUS. +// +// As a result of a successful link operation, all active user-defined +// uniform variables belonging to program will be initialized to 0, and each +// of the program object's active uniform variables will be assigned a +// location that can be queried by calling GetUniformLocation. Also, any +// active user-defined attribute variables that have not been bound to a +// generic vertex attribute index will be bound to one at this time. +// +// Linking of a program object can fail for a number of reasons as specified +// in the OpenGL Shading Language Specification. The following lists some of +// the conditions that will cause a link error. +// +// - The number of active attribute variables supported by the +// implementation has been exceeded. +// +// - The storage limit for uniform variables has been exceeded. +// +// - The number of active uniform variables supported by the implementation +// has been exceeded. +// +// - The main function is missing for the vertex shader or the fragment +// shader. +// +// - A varying variable actually used in the fragment shader is not +// declared in the same way (or is not declared at all) in the vertex +// shader. +// +// - A reference to a function or variable name is unresolved. +// +// - A shared global is declared with two different types or two different +// initial values. +// +// - One or more of the attached shader objects has not been successfully +// compiled. +// +// - Binding a generic attribute matrix caused some rows of the matrix to +// fall outside the allowed maximum of GL.MAX_VERTEX_ATTRIBS. +// +// - Not enough contiguous vertex attribute slots could be found to bind +// attribute matrices. +// +// When a program object has been successfully linked, the program object can +// be made part of current state by calling UseProgram. Whether or not the +// link operation was successful, the program object's information log will +// be overwritten. The information log can be retrieved by calling +// GetProgramInfoLog. +// +// LinkProgram will also install the generated executables as part of the +// current rendering state if the link operation was successful and the +// specified program object is already currently in use as a result of a +// previous call to UseProgram. If the program object currently in use is +// relinked unsuccessfully, its link status will be set to GL.FALSE , but the +// executables and associated state will remain part of the current state +// until a subsequent call to UseProgram removes it from use. After it is +// removed from use, it cannot be made part of current state until it has +// been successfully relinked. +// +// If program contains shader objects of type GL.VERTEX_SHADER but does not +// contain shader objects of type GL.FRAGMENT_SHADER, the vertex shader will +// be linked against the implicit interface for fixed functionality fragment +// processing. Similarly, if program contains shader objects of type +// GL.FRAGMENT_SHADER but it does not contain shader objects of type +// GL.VERTEX_SHADER, the fragment shader will be linked against the implicit +// interface for fixed functionality vertex processing. +// +// The program object's information log is updated and the program is +// generated at the time of the link operation. After the link operation, +// applications are free to modify attached shader objects, compile attached +// shader objects, detach shader objects, delete shader objects, and attach +// additional shader objects. None of these operations affects the +// information log or the program that is part of the program object. +// +// If the link operation is unsuccessful, any information about a previous +// link operation on program is lost (a failed link does not restore the +// old state of program). Certain information can still be retrieved +// from program even after an unsuccessful link operation. See for instance +// GetActiveAttrib and GetActiveUniform. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if LinkProgram is executed +// between the execution of Begin and the corresponding execution of End. +// +// LinkProgram is available in GL version 2.0 or greater. +func (gl *GL) LinkProgram(program glbase.Program) { + C.gl2_0_glLinkProgram(gl.funcs, C.GLuint(program)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsShader.xml +func (gl *GL) IsShader(shader glbase.Shader) bool { + glresult := C.gl2_0_glIsShader(gl.funcs, C.GLuint(shader)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsProgram.xml +func (gl *GL) IsProgram(program glbase.Program) bool { + glresult := C.gl2_0_glIsProgram(gl.funcs, C.GLuint(program)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GetVertexAttribiv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribiv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribiv(index glbase.Attrib, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl2_0_glGetVertexAttribiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetVertexAttribfv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribfv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribfv(index glbase.Attrib, pname glbase.Enum, params []float32) { + var params_c [4]float32 + C.gl2_0_glGetVertexAttribfv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetVertexAttribdv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribdv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribdv(index glbase.Attrib, pname glbase.Enum, params []float64) { + var params_c [4]float64 + C.gl2_0_glGetVertexAttribdv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformiv returns in params the value of the specified uniform +// variable. The type of the uniform variable specified by location +// determines the number of values returned. If the uniform variable is +// defined in the shader as a boolean, int, or float, a single value will be +// returned. If it is defined as a vec2, ivec2, or bvec2, two values will be +// returned. If it is defined as a vec3, ivec3, or bvec3, three values will +// be returned, and so on. To query values stored in uniform variables +// declared as arrays, call GetUniformiv for each element of the array. To +// query values stored in uniform variables declared as structures, call +// GetUniformiv for each field in the structure. The values for uniform +// variables declared as a matrix will be returned in column major order. +// +// The locations assigned to uniform variables are not known until the +// program object is linked. After linking has occurred, the command +// GetUniformLocation can be used to obtain the location of a uniform +// variable. This location value can then be passed to GetUniformiv in order +// to query the current value of the uniform variable. After a program object +// has been linked successfully, the index values for uniform variables +// remain fixed until the next link command occurs. The uniform variable +// values can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if program has not been +// successfully linked. GL.INVALID_OPERATION is generated if location does +// not correspond to a valid uniform variable location for the specified +// program object. GL.INVALID_OPERATION is generated if GetUniformiv is +// executed between the execution of Begin and the corresponding execution of +// End. +// +// GetUniformiv is available in GL version 2.0 or greater. +func (gl *GL) GetUniformiv(program glbase.Program, location glbase.Uniform, params []int32) { + var params_c [4]int32 + C.gl2_0_glGetUniformiv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformfv returns in params the value of the specified uniform +// variable. The type of the uniform variable specified by location +// determines the number of values returned. If the uniform variable is +// defined in the shader as a boolean, int, or float, a single value will be +// returned. If it is defined as a vec2, ivec2, or bvec2, two values will be +// returned. If it is defined as a vec3, ivec3, or bvec3, three values will +// be returned, and so on. To query values stored in uniform variables +// declared as arrays, call GetUniformfv for each element of the array. To +// query values stored in uniform variables declared as structures, call +// GetUniformfv for each field in the structure. The values for uniform +// variables declared as a matrix will be returned in column major order. +// +// The locations assigned to uniform variables are not known until the +// program object is linked. After linking has occurred, the command +// GetUniformLocation can be used to obtain the location of a uniform +// variable. This location value can then be passed to GetUniformfv in order +// to query the current value of the uniform variable. After a program object +// has been linked successfully, the index values for uniform variables +// remain fixed until the next link command occurs. The uniform variable +// values can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if program has not been +// successfully linked. GL.INVALID_OPERATION is generated if location does +// not correspond to a valid uniform variable location for the specified +// program object. GL.INVALID_OPERATION is generated if GetUniformfv is +// executed between the execution of Begin and the corresponding execution of +// End. +// +// GetUniformfv is available in GL version 2.0 or greater. +func (gl *GL) GetUniformfv(program glbase.Program, location glbase.Uniform, params []float32) { + var params_c [4]float32 + C.gl2_0_glGetUniformfv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLfloat)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformLocation returns an integer that represents the location of a +// specific uniform variable within a program object. name must be an active +// uniform variable name in program that is not a structure, an array of +// structures, or a subcomponent of a vector or a matrix. This function +// returns -1 if name does not correspond to an active uniform variable in +// program or if name starts with the reserved prefix "gl_". +// +// Uniform variables that are structures or arrays of structures may be +// queried by calling GetUniformLocation for each field within the +// structure. The array element operator "[]" and the structure field +// operator "." may be used in name in order to select elements within an +// array or fields within a structure. The result of using these operators is +// not allowed to be another structure, an array of structures, or a +// subcomponent of a vector or a matrix. Except if the last part of name +// indicates a uniform variable array, the location of the first element of +// an array can be retrieved by using the name of the array, or by using the +// name appended by "[0]". +// +// The actual locations assigned to uniform variables are not known until the +// program object is linked successfully. After linking has occurred, the +// command GetUniformLocation can be used to obtain the location of a +// uniform variable. This location value can then be passed to Uniform to +// set the value of the uniform variable or to GetUniform in order to query +// the current value of the uniform variable. After a program object has been +// linked successfully, the index values for uniform variables remain fixed +// until the next link command occurs. Uniform variable locations and values +// can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program object. +// GL.INVALID_OPERATION is generated if program has not been successfully +// linked. GL.INVALID_OPERATION is generated if GetUniformLocation is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetUniformLocation is available in GL version 2.0 or greater. +func (gl *GL) GetUniformLocation(program glbase.Program, name string) glbase.Uniform { + name_cstr := C.CString(name) + glresult := C.gl2_0_glGetUniformLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) + return glbase.Uniform(glresult) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetShaderSource.xml +func (gl *GL) GetShaderSource(shader glbase.Shader, bufSize int32, length []int32, source []byte) { + C.gl2_0_glGetShaderSource(gl.funcs, C.GLuint(shader), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&source[0]))) +} + +// GetShaderInfoLog returns the information log for the specified shader +// object. The information log for a shader object is modified when the +// shader is compiled. +// +// The information log for a shader object is a string that may contain +// diagnostic messages, warning messages, and other information about the +// last compile operation. When a shader object is created, its information +// log will be a string of length 0, and the size of the current log can be +// obtained by calling GetShaderiv with the value GL.INFO_LOG_LENGTH. +// +// The information log for a shader object is the OpenGL implementer's +// primary mechanism for conveying information about the compilation process. +// Therefore, the information log can be helpful to application developers +// during the development process, even when compilation is successful. +// Application developers should not expect different OpenGL implementations +// to produce identical information logs. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_VALUE is generated if maxLength is less than 0. +// GL.INVALID_OPERATION is generated if GetShaderInfoLog is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetShaderInfoLog is available in GL version 2.0 or greater. +func (gl *GL) GetShaderInfoLog(shader glbase.Shader) []byte { + var params [1]int32 + var length int32 + gl.GetShaderiv(shader, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + C.gl2_0_glGetShaderInfoLog(gl.funcs, C.GLuint(shader), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length)), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) + return infoLog +} + +// GetShaderiv GetShader returns in params the value of a parameter for a specific +// shader object. The following parameters are defined: +// +// GL.SHADER_TYPE +// params returns GL.VERTEX_SHADER if shader is a vertex shader object, +// and GL.FRAGMENT_SHADER if shader is a fragment shader object. +// +// GL.DELETE_STATUS +// params returns GL.TRUE if shader is currently flagged for deletion, +// and GL.FALSE otherwise. +// +// GL.COMPILE_STATUS +// params returns GL.TRUE if the last compile operation on shader was +// successful, and GL.FALSE otherwise. +// +// GL.INFO_LOG_LENGTH +// params returns the number of characters in the information log for +// shader including the null termination character (the size of the +// character buffer required to store the information log). If shader has +// no information log, a value of 0 is returned. +// +// GL.SHADER_SOURCE_LENGTH +// params returns the length of the concatenation of the source strings +// that make up the shader source for the shader, including the null +// termination character. (the size of the character buffer +// required to store the shader source). If no source code exists, 0 is +// returned. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader does not refer to a +// shader object. GL.INVALID_ENUM is generated if pname is not an accepted +// value. GL.INVALID_OPERATION is generated if GetShader is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetShaderiv is available in GL version 2.0 or greater. +func (gl *GL) GetShaderiv(shader glbase.Shader, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl2_0_glGetShaderiv(gl.funcs, C.GLuint(shader), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetProgramInfoLog returns the information log for the specified program +// object. The information log for a program object is modified when the +// program object is linked or validated. +// +// The information log for a program object is either an empty string, or a +// string containing information about the last link operation, or a string +// containing information about the last validation operation. It may contain +// diagnostic messages, warning messages, and other information. When a +// program object is created, its information log will be a string of length +// 0, and the size of the current log can be obtained by calling GetProgramiv +// with the value GL.INFO_LOG_LENGTH. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated +// by OpenGL. GL.INVALID_OPERATION is generated if program is not a +// program object. +func (gl *GL) GetProgramInfoLog(program glbase.Program) []byte { + var params [1]int32 + var length int32 + gl.GetProgramiv(program, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + C.gl2_0_glGetProgramInfoLog(gl.funcs, C.GLuint(program), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length)), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) + return infoLog +} + +// GetProgramiv returns in params the value of a parameter for a specific +// program object. The following parameters are defined: +// +// GL.DELETE_STATUS +// params returns GL.TRUE if program is currently flagged for deletion, +// and GL.FALSE otherwise. +// +// GL.LINK_STATUS +// params returns GL.TRUE if the last link operation on program was +// successful, and GL.FALSE otherwise. +// +// GL.VALIDATE_STATUS +// params returns GL.TRUE or if the last validation operation on +// program was successful, and GL.FALSE otherwise. +// +// GL.INFO_LOG_LENGTH +// params returns the number of characters in the information log for +// program including the null termination character (the size of +// the character buffer required to store the information log). If +// program has no information log, a value of 0 is returned. +// +// GL.ATTACHED_SHADERS +// params returns the number of shader objects attached to program. +// +// GL.ACTIVE_ATTRIBUTES +// params returns the number of active attribute variables for program. +// +// GL.ACTIVE_ATTRIBUTE_MAX_LENGTH +// params returns the length of the longest active attribute name for +// program, including the null termination character (the size of +// the character buffer required to store the longest attribute name). +// If no active attributes exist, 0 is returned. +// +// GL.ACTIVE_UNIFORMS +// params returns the number of active uniform variables for program. +// +// GL.ACTIVE_UNIFORM_MAX_LENGTH +// params returns the length of the longest active uniform variable +// name for program, including the null termination character (i.e., +// the size of the character buffer required to store the longest +// uniform variable name). If no active uniform variables exist, 0 is +// returned. +// +// GL.TRANSFORM_FEEDBACK_BUFFER_MODE +// params returns a symbolic constant indicating the buffer mode used +// when transform feedback is active. This may be GL.SEPARATE_ATTRIBS +// or GL.INTERLEAVED_ATTRIBS. +// +// GL.TRANSFORM_FEEDBACK_VARYINGS +// params returns the number of varying variables to capture in transform +// feedback mode for the program. +// +// GL.TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH +// params returns the length of the longest variable name to be used for +// transform feedback, including the null-terminator. +// +// GL.GEOMETRY_VERTICES_OUT +// params returns the maximum number of vertices that the geometry shader in +// program will output. +// +// GL.GEOMETRY_INPUT_TYPE +// params returns a symbolic constant indicating the primitive type accepted +// as input to the geometry shader contained in program. +// +// GL.GEOMETRY_OUTPUT_TYPE +// params returns a symbolic constant indicating the primitive type that will +// be output by the geometry shader contained in program. +// +// GL.ACTIVE_UNIFORM_BLOCKS and GL.ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH are +// available only if the GL version 3.1 or greater. +// +// GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE and +// GL.GEOMETRY_OUTPUT_TYPE are accepted only if the GL version is 3.2 or +// greater. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program does not refer to a +// program object. GL.INVALID_OPERATION is generated if pname is +// GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE, or +// GL.GEOMETRY_OUTPUT_TYPE, and program does not contain a geometry shader. +// GL.INVALID_ENUM is generated if pname is not an accepted value. +func (gl *GL) GetProgramiv(program glbase.Program, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl2_0_glGetProgramiv(gl.funcs, C.GLuint(program), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetAttribLocation queries the previously linked program object specified +// by program for the attribute variable specified by name and returns the +// index of the generic vertex attribute that is bound to that attribute +// variable. If name is a matrix attribute variable, the index of the first +// column of the matrix is returned. If the named attribute variable is not +// an active attribute in the specified program object or if name starts with +// the reserved prefix "gl_", a value of -1 is returned. +// +// The association between an attribute variable name and a generic attribute +// index can be specified at any time by calling BindAttribLocation. +// Attribute bindings do not go into effect until LinkProgram is called. +// After a program object has been linked successfully, the index values for +// attribute variables remain fixed until the next link command occurs. The +// attribute values can only be queried after a link if the link was +// successful. GetAttribLocation returns the binding that actually went +// into effect the last time LinkProgram was called for the specified +// program object. Attribute bindings that have been specified since the last +// link operation are not returned by GetAttribLocation. +// +// Error GL_INVALID_OPERATION is generated if program is not a value +// generated by OpenGL. GL_INVALID_OPERATION is generated if program is not +// a program object. GL_INVALID_OPERATION is generated if program has not +// been successfully linked. GL_INVALID_OPERATION is generated if +// GetAttribLocation is executed between the execution of Begin and the +// corresponding execution of End. +// +// GetAttribLocation is available in GL version 2.0 or greater. +func (gl *GL) GetAttribLocation(program glbase.Program, name string) glbase.Attrib { + name_cstr := C.CString(name) + glresult := C.gl2_0_glGetAttribLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) + return glbase.Attrib(glresult) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetAttachedShaders.xml +func (gl *GL) GetAttachedShaders(program glbase.Program, maxCount int32, count []int, obj []uint32) { + C.gl2_0_glGetAttachedShaders(gl.funcs, C.GLuint(program), C.GLsizei(maxCount), (*C.GLsizei)(unsafe.Pointer(&count[0])), (*C.GLuint)(unsafe.Pointer(&obj[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetActiveUniform.xml +func (gl *GL) GetActiveUniform(program glbase.Program, index uint32, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl2_0_glGetActiveUniform(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetActiveAttrib.xml +func (gl *GL) GetActiveAttrib(program glbase.Program, index glbase.Attrib, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl2_0_glGetActiveAttrib(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEnableVertexAttribArray.xml +func (gl *GL) EnableVertexAttribArray(index glbase.Attrib) { + C.gl2_0_glEnableVertexAttribArray(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDisableVertexAttribArray.xml +func (gl *GL) DisableVertexAttribArray(index glbase.Attrib) { + C.gl2_0_glDisableVertexAttribArray(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDetachShader.xml +func (gl *GL) DetachShader(program glbase.Program, shader glbase.Shader) { + C.gl2_0_glDetachShader(gl.funcs, C.GLuint(program), C.GLuint(shader)) +} + +// DeleteShader frees the memory and invalidates the name associated with +// the shader object specified by shader. This command effectively undoes the +// effects of a call to CreateShader. +// +// If a shader object to be deleted is attached to a program object, it will +// be flagged for deletion, but it will not be deleted until it is no longer +// attached to any program object, for any rendering context (it must +// be detached from wherever it was attached before it will be deleted). A +// value of 0 for shader will be silently ignored. +// +// To determine whether an object has been flagged for deletion, call +// GetShader with arguments shader and GL.DELETE_STATUS. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. +// +// DeleteShader is available in GL version 2.0 or greater. +func (gl *GL) DeleteShader(shader glbase.Shader) { + C.gl2_0_glDeleteShader(gl.funcs, C.GLuint(shader)) +} + +// DeleteProgram frees the memory and invalidates the name associated with +// the program object specified by program. This command effectively undoes +// the effects of a call to CreateProgram. +// +// If a program object is in use as part of current rendering state, it will +// be flagged for deletion, but it will not be deleted until it is no longer +// part of current state for any rendering context. If a program object to be +// deleted has shader objects attached to it, those shader objects will be +// automatically detached but not deleted unless they have already been +// flagged for deletion by a previous call to DeleteShader. A value of 0 +// for program will be silently ignored. +// +// To determine whether a program object has been flagged for deletion, call +// GetProgram with arguments program and GL.DELETE_STATUS. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. +// +// DeleteProgram is available in GL version 2.0 or greater. +func (gl *GL) DeleteProgram(program glbase.Program) { + C.gl2_0_glDeleteProgram(gl.funcs, C.GLuint(program)) +} + +// CreateShader creates an empty shader object and returns a non-zero value +// by which it can be referenced. A shader object is used to maintain the +// source code strings that define a shader. shaderType indicates the type of +// shader to be created. +// +// Two types of shaders are supported. A shader of type GL.VERTEX_SHADER is a +// shader that is intended to run on the programmable vertex processor and +// replace the fixed functionality vertex processing in OpenGL. A shader of +// type GL.FRAGMENT_SHADER is a shader that is intended to run on the +// programmable fragment processor and replace the fixed functionality +// fragment processing in OpenGL. +// +// When created, a shader object's GL.SHADER_TYPE parameter is set to either +// GL.VERTEX_SHADER or GL.FRAGMENT_SHADER, depending on the value of +// shaderType. +// +// Like display lists and texture objects, the name space for shader objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// This function returns 0 if an error occurs creating the shader object. +// +// Error GL.INVALID_ENUM is generated if shaderType is not an accepted value. +// GL.INVALID_OPERATION is generated if CreateShader is executed between the +// execution of Begin and the corresponding execution of End. +// +// CreateShader is available in GL version 2.0 or greater. +func (gl *GL) CreateShader(gltype glbase.Enum) glbase.Shader { + glresult := C.gl2_0_glCreateShader(gl.funcs, C.GLenum(gltype)) + return glbase.Shader(glresult) +} + +// CreateProgram creates an empty program object and returns a non-zero +// value by which it can be referenced. A program object is an object to +// which shader objects can be attached. This provides a mechanism to specify +// the shader objects that will be linked to create a program. It also +// provides a means for checking the compatibility of the shaders that will +// be used to create a program (for instance, checking the compatibility +// between a vertex shader and a fragment shader). When no longer needed as +// part of a program object, shader objects can be detached. +// +// One or more executables are created in a program object by successfully +// attaching shader objects to it with AttachShader, successfully compiling +// the shader objects with CompileShader, and successfully linking the +// program object with LinkProgram. These executables are made part of +// current state when UseProgram is called. Program objects can be deleted +// by calling DeleteProgram. The memory associated with the program object +// will be deleted when it is no longer part of current rendering state for +// any context. +// +// Like display lists and texture objects, the name space for program objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// Applications are responsible for providing the synchronization across API +// calls when objects are accessed from different execution threads. +// +// This function returns 0 if an error occurs creating the program object. +// +// Error GL.INVALID_OPERATION is generated if CreateProgram is executed +// between the execution of Begin and the corresponding execution of End. +// +// CreateProgram is available in GL version 2.0 or greater. +func (gl *GL) CreateProgram() glbase.Program { + glresult := C.gl2_0_glCreateProgram(gl.funcs) + return glbase.Program(glresult) +} + +// CompileShader compiles the source code strings that have been stored in +// the shader object specified by shader. +// +// The compilation status will be stored as part of the shader object's +// state. This value will be set to GL.TRUE if the shader was compiled without +// errors and is ready for use, and GL.FALSE otherwise. It can be queried by +// calling GetShaderiv with arguments shader and GL.COMPILE_STATUS. +// +// Compilation of a shader can fail for a number of reasons as specified by +// the OpenGL Shading Language Specification. Whether or not the compilation +// was successful, information about the compilation can be obtained from the +// shader object's information log by calling GetShaderInfoLog. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_OPERATION is generated if CompileShader is executed +// between the execution of Begin and the corresponding execution of End. +// +// CompileShader is available in GL version 2.0 or greater. +func (gl *GL) CompileShader(shader glbase.Shader) { + C.gl2_0_glCompileShader(gl.funcs, C.GLuint(shader)) +} + +// BindAttribLocation associates a user-defined attribute variable in the program +// object specified by program with a generic vertex attribute index. The name +// parameter specifies the name of the vertex shader attribute variable to +// which index is to be bound. When program is made part of the current state, +// values provided via the generic vertex attribute index will modify the +// value of the user-defined attribute variable specified by name. +// +// If name refers to a matrix attribute variable, index refers to the first +// column of the matrix. Other matrix columns are then automatically bound to +// locations index+1 for a matrix of type mat2; index+1 and index+2 for a +// matrix of type mat3; and index+1, index+2, and index+3 for a matrix of +// type mat4. +// +// This command makes it possible for vertex shaders to use descriptive names +// for attribute variables rather than generic variables that are numbered +// from 0 to GL.MAX_VERTEX_ATTRIBS-1. The values sent to each generic +// attribute index are part of current state, just like standard vertex +// attributes such as color, normal, and vertex position. If a different +// program object is made current by calling UseProgram, the generic vertex +// attributes are tracked in such a way that the same values will be observed +// by attributes in the new program object that are also bound to index. +// +// Attribute variable name-to-generic attribute index bindings for a program +// object can be explicitly assigned at any time by calling +// BindAttribLocation. Attribute bindings do not go into effect until +// LinkProgram is called. After a program object has been linked +// successfully, the index values for generic attributes remain fixed (and +// their values can be queried) until the next link command occurs. +// +// Applications are not allowed to bind any of the standard OpenGL vertex +// attributes using this command, as they are bound automatically when +// needed. Any attribute binding that occurs after the program object has +// been linked will not take effect until the next time the program object is +// linked. +// +// If name was bound previously, that information is lost. Thus you cannot +// bind one user-defined attribute variable to multiple indices, but you can +// bind multiple user-defined attribute variables to the same index. +// +// Applications are allowed to bind more than one user-defined attribute +// variable to the same generic vertex attribute index. This is called +// aliasing, and it is allowed only if just one of the aliased attributes is +// active in the executable program, or if no path through the shader +// consumes more than one attribute of a set of attributes aliased to the +// same location. The compiler and linker are allowed to assume that no +// aliasing is done and are free to employ optimizations that work only in +// the absence of aliasing. OpenGL implementations are not required to do +// error checking to detect aliasing. Because there is no way to bind +// standard attributes, it is not possible to alias generic attributes with +// conventional ones (except for generic attribute 0). +// +// BindAttribLocation can be called before any vertex shader objects are +// bound to the specified program object. It is also permissible to bind a +// generic attribute index to an attribute variable name that is never used +// in a vertex shader. +// +// Active attributes that are not explicitly bound will be bound by the +// linker when LinkProgram is called. The locations assigned can be queried +// by calling GetAttribLocation. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. +// GL.INVALID_OPERATION is generated if name starts with the reserved prefix "gl_". +// GL.INVALID_VALUE is generated if program is not a value generated by OpenGL. +// GL.INVALID_OPERATION is generated if program is not a program object. +// GL.INVALID_OPERATION is generated if BindAttribLocation is executed +// between the execution of Begin and the corresponding execution of End. +// +// BindAttribLocation is available in GL version 2.0 or greater. +func (gl *GL) BindAttribLocation(program glbase.Program, index glbase.Attrib, name string) { + name_cstr := C.CString(name) + C.gl2_0_glBindAttribLocation(gl.funcs, C.GLuint(program), C.GLuint(index), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) +} + +// AttachShader attaches a shader object to a program object. +// +// In order to create an executable, there must be a way to specify the list +// of things that will be linked together. Program objects provide this +// mechanism. Shaders that are to be linked together in a program object must +// first be attached to that program object. This indicates that shader will +// be included in link operations that will be performed on program. +// +// All operations that can be performed on a shader object are valid whether +// or not the shader object is attached to a program object. It is +// permissible to attach a shader object to a program object before source +// code has been loaded into the shader object or before the shader object +// has been compiled. It is permissible to attach multiple shader objects of +// the same type because each may contain a portion of the complete shader. +// It is also permissible to attach a shader object to more than one program +// object. If a shader object is deleted while it is attached to a program +// object, it will be flagged for deletion, and deletion will not occur until +// DetachShader is called to detach it from all program objects to which it +// is attached. +// +// Error GL.INVALID_VALUE is generated if either program or shader is not a +// value generated by OpenGL. GL.INVALID_OPERATION is generated if program +// is not a program object. GL.INVALID_OPERATION is generated if shader is +// not a shader object. GL.INVALID_OPERATION is generated if shader is +// already attached to program. GL.INVALID_OPERATION is generated if +// AttachShader is executed between the execution of Begin and the +// corresponding execution of End. +// +// AttachShader is available in GL version 2.0 or greater. +func (gl *GL) AttachShader(program glbase.Program, shader glbase.Shader) { + C.gl2_0_glAttachShader(gl.funcs, C.GLuint(program), C.GLuint(shader)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilMaskSeparate.xml +func (gl *GL) StencilMaskSeparate(face glbase.Enum, mask uint32) { + C.gl2_0_glStencilMaskSeparate(gl.funcs, C.GLenum(face), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilFuncSeparate.xml +func (gl *GL) StencilFuncSeparate(face, glfunc glbase.Enum, ref int32, mask uint32) { + C.gl2_0_glStencilFuncSeparate(gl.funcs, C.GLenum(face), C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilOpSeparate.xml +func (gl *GL) StencilOpSeparate(face, sfail, dpfail, dppass glbase.Enum) { + C.gl2_0_glStencilOpSeparate(gl.funcs, C.GLenum(face), C.GLenum(sfail), C.GLenum(dpfail), C.GLenum(dppass)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawBuffers.xml +func (gl *GL) DrawBuffers(n int, bufs []glbase.Enum) { + C.gl2_0_glDrawBuffers(gl.funcs, C.GLsizei(n), (*C.GLenum)(unsafe.Pointer(&bufs[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBlendEquationSeparate.xml +func (gl *GL) BlendEquationSeparate(modeRGB, modeAlpha glbase.Enum) { + C.gl2_0_glBlendEquationSeparate(gl.funcs, C.GLenum(modeRGB), C.GLenum(modeAlpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTranslatef.xml +func (gl *GL) Translatef(x, y, z float32) { + C.gl2_0_glTranslatef(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTranslated.xml +func (gl *GL) Translated(x, y, z float64) { + C.gl2_0_glTranslated(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glScalef.xml +func (gl *GL) Scalef(x, y, z float32) { + C.gl2_0_glScalef(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glScaled.xml +func (gl *GL) Scaled(x, y, z float64) { + C.gl2_0_glScaled(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRotatef.xml +func (gl *GL) Rotatef(angle, x, y, z float32) { + C.gl2_0_glRotatef(gl.funcs, C.GLfloat(angle), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRotated.xml +func (gl *GL) Rotated(angle, x, y, z float64) { + C.gl2_0_glRotated(gl.funcs, C.GLdouble(angle), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPushMatrix.xml +func (gl *GL) PushMatrix() { + C.gl2_0_glPushMatrix(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPopMatrix.xml +func (gl *GL) PopMatrix() { + C.gl2_0_glPopMatrix(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glOrtho.xml +func (gl *GL) Ortho(left, right, bottom, top, zNear, zFar float64) { + C.gl2_0_glOrtho(gl.funcs, C.GLdouble(left), C.GLdouble(right), C.GLdouble(bottom), C.GLdouble(top), C.GLdouble(zNear), C.GLdouble(zFar)) +} + +// MultMatrixd multiplies the current matrix with the provided matrix. +// +// The m parameter must hold 16 consecutive elements of a 4x4 column-major matrix. +// +// The current matrix is determined by the current matrix mode (see +// MatrixMode). It is either the projection matrix, modelview matrix, or the +// texture matrix. +// +// For example, if the current matrix is C and the coordinates to be transformed +// are v = (v[0], v[1], v[2], v[3]), then the current transformation is C × v, or +// +// c[0] c[4] c[8] c[12] v[0] +// c[1] c[5] c[9] c[13] v[1] +// c[2] c[6] c[10] c[14] X v[2] +// c[3] c[7] c[11] c[15] v[3] +// +// Calling MultMatrix with an argument of m = m[0], m[1], ..., m[15] +// replaces the current transformation with (C X M) x v, or +// +// c[0] c[4] c[8] c[12] m[0] m[4] m[8] m[12] v[0] +// c[1] c[5] c[9] c[13] m[1] m[5] m[9] m[13] v[1] +// c[2] c[6] c[10] c[14] X m[2] m[6] m[10] m[14] X v[2] +// c[3] c[7] c[11] c[15] m[3] m[7] m[11] m[15] v[3] +// +// Where 'X' denotes matrix multiplication, and v is represented as a 4x1 matrix. +// +// While the elements of the matrix may be specified with single or double +// precision, the GL may store or operate on these values in less-than-single +// precision. +// +// In many computer languages, 4×4 arrays are represented in row-major +// order. The transformations just described represent these matrices in +// column-major order. The order of the multiplication is important. For +// example, if the current transformation is a rotation, and MultMatrix is +// called with a translation matrix, the translation is done directly on the +// coordinates to be transformed, while the rotation is done on the results +// of that translation. +// +// GL.INVALID_OPERATION is generated if MultMatrix is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) MultMatrixd(m []float64) { + if len(m) != 16 { + panic("parameter m must have length 16 for the 4x4 matrix") + } + C.gl2_0_glMultMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// MultMatrixf multiplies the current matrix with the provided matrix. +// +// The m parameter must hold 16 consecutive elements of a 4x4 column-major matrix. +// +// The current matrix is determined by the current matrix mode (see +// MatrixMode). It is either the projection matrix, modelview matrix, or the +// texture matrix. +// +// For example, if the current matrix is C and the coordinates to be transformed +// are v = (v[0], v[1], v[2], v[3]), then the current transformation is C × v, or +// +// c[0] c[4] c[8] c[12] v[0] +// c[1] c[5] c[9] c[13] v[1] +// c[2] c[6] c[10] c[14] X v[2] +// c[3] c[7] c[11] c[15] v[3] +// +// Calling MultMatrix with an argument of m = m[0], m[1], ..., m[15] +// replaces the current transformation with (C X M) x v, or +// +// c[0] c[4] c[8] c[12] m[0] m[4] m[8] m[12] v[0] +// c[1] c[5] c[9] c[13] m[1] m[5] m[9] m[13] v[1] +// c[2] c[6] c[10] c[14] X m[2] m[6] m[10] m[14] X v[2] +// c[3] c[7] c[11] c[15] m[3] m[7] m[11] m[15] v[3] +// +// Where 'X' denotes matrix multiplication, and v is represented as a 4x1 matrix. +// +// While the elements of the matrix may be specified with single or double +// precision, the GL may store or operate on these values in less-than-single +// precision. +// +// In many computer languages, 4×4 arrays are represented in row-major +// order. The transformations just described represent these matrices in +// column-major order. The order of the multiplication is important. For +// example, if the current transformation is a rotation, and MultMatrix is +// called with a translation matrix, the translation is done directly on the +// coordinates to be transformed, while the rotation is done on the results +// of that translation. +// +// GL.INVALID_OPERATION is generated if MultMatrix is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) MultMatrixf(m []float32) { + if len(m) != 16 { + panic("parameter m must have length 16 for the 4x4 matrix") + } + C.gl2_0_glMultMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMatrixMode.xml +func (gl *GL) MatrixMode(mode glbase.Enum) { + C.gl2_0_glMatrixMode(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadMatrixd.xml +func (gl *GL) LoadMatrixd(m []float64) { + C.gl2_0_glLoadMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadMatrixf.xml +func (gl *GL) LoadMatrixf(m []float32) { + C.gl2_0_glLoadMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadIdentity.xml +func (gl *GL) LoadIdentity() { + C.gl2_0_glLoadIdentity(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFrustum.xml +func (gl *GL) Frustum(left, right, bottom, top, zNear, zFar float64) { + C.gl2_0_glFrustum(gl.funcs, C.GLdouble(left), C.GLdouble(right), C.GLdouble(bottom), C.GLdouble(top), C.GLdouble(zNear), C.GLdouble(zFar)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsList.xml +func (gl *GL) IsList(list uint32) bool { + glresult := C.gl2_0_glIsList(gl.funcs, C.GLuint(list)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexGeniv.xml +func (gl *GL) GetTexGeniv(coord, pname glbase.Enum, params []int32) { + C.gl2_0_glGetTexGeniv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexGenfv.xml +func (gl *GL) GetTexGenfv(coord, pname glbase.Enum, params []float32) { + C.gl2_0_glGetTexGenfv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexGendv.xml +func (gl *GL) GetTexGendv(coord, pname glbase.Enum, params []float64) { + C.gl2_0_glGetTexGendv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexEnviv.xml +func (gl *GL) GetTexEnviv(target, pname glbase.Enum, params []int32) { + C.gl2_0_glGetTexEnviv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexEnvfv.xml +func (gl *GL) GetTexEnvfv(target, pname glbase.Enum, params []float32) { + C.gl2_0_glGetTexEnvfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetPolygonStipple.xml +func (gl *GL) GetPolygonStipple(mask []uint8) { + C.gl2_0_glGetPolygonStipple(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&mask[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetPixelMapusv.xml +func (gl *GL) GetPixelMapusv(glmap glbase.Enum, values []uint16) { + C.gl2_0_glGetPixelMapusv(gl.funcs, C.GLenum(glmap), (*C.GLushort)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetPixelMapuiv.xml +func (gl *GL) GetPixelMapuiv(glmap glbase.Enum, values []uint32) { + C.gl2_0_glGetPixelMapuiv(gl.funcs, C.GLenum(glmap), (*C.GLuint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetPixelMapfv.xml +func (gl *GL) GetPixelMapfv(glmap glbase.Enum, values []float32) { + C.gl2_0_glGetPixelMapfv(gl.funcs, C.GLenum(glmap), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMaterialiv.xml +func (gl *GL) GetMaterialiv(face, pname glbase.Enum, params []int32) { + C.gl2_0_glGetMaterialiv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMaterialfv.xml +func (gl *GL) GetMaterialfv(face, pname glbase.Enum, params []float32) { + C.gl2_0_glGetMaterialfv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMapiv.xml +func (gl *GL) GetMapiv(target, query glbase.Enum, v []int32) { + C.gl2_0_glGetMapiv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMapfv.xml +func (gl *GL) GetMapfv(target, query glbase.Enum, v []float32) { + C.gl2_0_glGetMapfv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMapdv.xml +func (gl *GL) GetMapdv(target, query glbase.Enum, v []float64) { + C.gl2_0_glGetMapdv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetLightiv.xml +func (gl *GL) GetLightiv(light, pname glbase.Enum, params []int32) { + C.gl2_0_glGetLightiv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetLightfv.xml +func (gl *GL) GetLightfv(light, pname glbase.Enum, params []float32) { + C.gl2_0_glGetLightfv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetClipPlane.xml +func (gl *GL) GetClipPlane(plane glbase.Enum, equation []float64) { + C.gl2_0_glGetClipPlane(gl.funcs, C.GLenum(plane), (*C.GLdouble)(unsafe.Pointer(&equation[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawPixels.xml +func (gl *GL) DrawPixels(width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glDrawPixels(gl.funcs, C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyPixels.xml +func (gl *GL) CopyPixels(x, y, width, height int, gltype glbase.Enum) { + C.gl2_0_glCopyPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(gltype)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelMapusv.xml +func (gl *GL) PixelMapusv(glmap glbase.Enum, mapsize int32, values []uint16) { + C.gl2_0_glPixelMapusv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLushort)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelMapuiv.xml +func (gl *GL) PixelMapuiv(glmap glbase.Enum, mapsize int32, values []uint32) { + C.gl2_0_glPixelMapuiv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLuint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelMapfv.xml +func (gl *GL) PixelMapfv(glmap glbase.Enum, mapsize int32, values []float32) { + C.gl2_0_glPixelMapfv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelTransferi.xml +func (gl *GL) PixelTransferi(pname glbase.Enum, param int32) { + C.gl2_0_glPixelTransferi(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelTransferf.xml +func (gl *GL) PixelTransferf(pname glbase.Enum, param float32) { + C.gl2_0_glPixelTransferf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelZoom.xml +func (gl *GL) PixelZoom(xfactor, yfactor float32) { + C.gl2_0_glPixelZoom(gl.funcs, C.GLfloat(xfactor), C.GLfloat(yfactor)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glAlphaFunc.xml +func (gl *GL) AlphaFunc(glfunc glbase.Enum, ref float32) { + C.gl2_0_glAlphaFunc(gl.funcs, C.GLenum(glfunc), C.GLfloat(ref)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalPoint2.xml +func (gl *GL) EvalPoint2(i, j int32) { + C.gl2_0_glEvalPoint2(gl.funcs, C.GLint(i), C.GLint(j)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalMesh2.xml +func (gl *GL) EvalMesh2(mode glbase.Enum, i1, i2, j1, j2 int32) { + C.gl2_0_glEvalMesh2(gl.funcs, C.GLenum(mode), C.GLint(i1), C.GLint(i2), C.GLint(j1), C.GLint(j2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalPoint1.xml +func (gl *GL) EvalPoint1(i int32) { + C.gl2_0_glEvalPoint1(gl.funcs, C.GLint(i)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalMesh1.xml +func (gl *GL) EvalMesh1(mode glbase.Enum, i1, i2 int32) { + C.gl2_0_glEvalMesh1(gl.funcs, C.GLenum(mode), C.GLint(i1), C.GLint(i2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord2fv.xml +func (gl *GL) EvalCoord2fv(u []float32) { + if len(u) != 2 { + panic("parameter u has incorrect length") + } + C.gl2_0_glEvalCoord2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord2f.xml +func (gl *GL) EvalCoord2f(u, v float32) { + C.gl2_0_glEvalCoord2f(gl.funcs, C.GLfloat(u), C.GLfloat(v)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord2dv.xml +func (gl *GL) EvalCoord2dv(u []float64) { + if len(u) != 2 { + panic("parameter u has incorrect length") + } + C.gl2_0_glEvalCoord2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord2d.xml +func (gl *GL) EvalCoord2d(u, v float64) { + C.gl2_0_glEvalCoord2d(gl.funcs, C.GLdouble(u), C.GLdouble(v)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord1fv.xml +func (gl *GL) EvalCoord1fv(u []float32) { + C.gl2_0_glEvalCoord1fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord1f.xml +func (gl *GL) EvalCoord1f(u float32) { + C.gl2_0_glEvalCoord1f(gl.funcs, C.GLfloat(u)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord1dv.xml +func (gl *GL) EvalCoord1dv(u []float64) { + C.gl2_0_glEvalCoord1dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord1d.xml +func (gl *GL) EvalCoord1d(u float64) { + C.gl2_0_glEvalCoord1d(gl.funcs, C.GLdouble(u)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMapGrid2f.xml +func (gl *GL) MapGrid2f(un int32, u1, u2 float32, vn int32, v1, v2 float32) { + C.gl2_0_glMapGrid2f(gl.funcs, C.GLint(un), C.GLfloat(u1), C.GLfloat(u2), C.GLint(vn), C.GLfloat(v1), C.GLfloat(v2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMapGrid2d.xml +func (gl *GL) MapGrid2d(un int32, u1, u2 float64, vn int32, v1, v2 float64) { + C.gl2_0_glMapGrid2d(gl.funcs, C.GLint(un), C.GLdouble(u1), C.GLdouble(u2), C.GLint(vn), C.GLdouble(v1), C.GLdouble(v2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMapGrid1f.xml +func (gl *GL) MapGrid1f(un int32, u1, u2 float32) { + C.gl2_0_glMapGrid1f(gl.funcs, C.GLint(un), C.GLfloat(u1), C.GLfloat(u2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMapGrid1d.xml +func (gl *GL) MapGrid1d(un int32, u1, u2 float64) { + C.gl2_0_glMapGrid1d(gl.funcs, C.GLint(un), C.GLdouble(u1), C.GLdouble(u2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMap2f.xml +func (gl *GL) Map2f(target glbase.Enum, u1, u2 float32, ustride, uorder int32, v1, v2 float32, vstride, vorder int32, points []float32) { + C.gl2_0_glMap2f(gl.funcs, C.GLenum(target), C.GLfloat(u1), C.GLfloat(u2), C.GLint(ustride), C.GLint(uorder), C.GLfloat(v1), C.GLfloat(v2), C.GLint(vstride), C.GLint(vorder), (*C.GLfloat)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMap2d.xml +func (gl *GL) Map2d(target glbase.Enum, u1, u2 float64, ustride, uorder int32, v1, v2 float64, vstride, vorder int32, points []float64) { + C.gl2_0_glMap2d(gl.funcs, C.GLenum(target), C.GLdouble(u1), C.GLdouble(u2), C.GLint(ustride), C.GLint(uorder), C.GLdouble(v1), C.GLdouble(v2), C.GLint(vstride), C.GLint(vorder), (*C.GLdouble)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMap1f.xml +func (gl *GL) Map1f(target glbase.Enum, u1, u2 float32, stride, order int, points []float32) { + C.gl2_0_glMap1f(gl.funcs, C.GLenum(target), C.GLfloat(u1), C.GLfloat(u2), C.GLint(stride), C.GLint(order), (*C.GLfloat)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMap1d.xml +func (gl *GL) Map1d(target glbase.Enum, u1, u2 float64, stride, order int, points []float64) { + C.gl2_0_glMap1d(gl.funcs, C.GLenum(target), C.GLdouble(u1), C.GLdouble(u2), C.GLint(stride), C.GLint(order), (*C.GLdouble)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPushAttrib.xml +func (gl *GL) PushAttrib(mask glbase.Bitfield) { + C.gl2_0_glPushAttrib(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPopAttrib.xml +func (gl *GL) PopAttrib() { + C.gl2_0_glPopAttrib(gl.funcs) +} + +// Accum executes an operation on the accumulation buffer. +// +// Parameter op defines the accumulation buffer operation (GL.ACCUM, GL.LOAD, +// GL.ADD, GL.MULT, or GL.RETURN) and specifies how the value parameter is +// used. +// +// The accumulation buffer is an extended-range color buffer. Images are not +// rendered into it. Rather, images rendered into one of the color buffers +// are added to the contents of the accumulation buffer after rendering. +// Effects such as antialiasing (of points, lines, and polygons), motion +// blur, and depth of field can be created by accumulating images generated +// with different transformation matrices. +// +// Each pixel in the accumulation buffer consists of red, green, blue, and +// alpha values. The number of bits per component in the accumulation buffer +// depends on the implementation. You can examine this number by calling +// GetIntegerv four times, with arguments GL.ACCUM_RED_BITS, +// GL.ACCUM_GREEN_BITS, GL.ACCUM_BLUE_BITS, and GL.ACCUM_ALPHA_BITS. +// Regardless of the number of bits per component, the range of values stored +// by each component is (-1, 1). The accumulation buffer pixels are mapped +// one-to-one with frame buffer pixels. +// +// All accumulation buffer operations are limited to the area of the current +// scissor box and applied identically to the red, green, blue, and alpha +// components of each pixel. If a Accum operation results in a value outside +// the range (-1, 1), the contents of an accumulation buffer pixel component +// are undefined. +// +// The operations are as follows: +// +// GL.ACCUM +// Obtains R, G, B, and A values from the buffer currently selected for +// reading (see ReadBuffer). Each component value is divided by 2 n - +// 1 , where n is the number of bits allocated to each color component +// in the currently selected buffer. The result is a floating-point +// value in the range 0 1 , which is multiplied by value and added to +// the corresponding pixel component in the accumulation buffer, +// thereby updating the accumulation buffer. +// +// GL.LOAD +// Similar to GL.ACCUM, except that the current value in the +// accumulation buffer is not used in the calculation of the new value. +// That is, the R, G, B, and A values from the currently selected +// buffer are divided by 2 n - 1 , multiplied by value, and then stored +// in the corresponding accumulation buffer cell, overwriting the +// current value. +// +// GL.ADD +// Adds value to each R, G, B, and A in the accumulation buffer. +// +// GL.MULT +// Multiplies each R, G, B, and A in the accumulation buffer by value +// and returns the scaled component to its corresponding accumulation +// buffer location. +// +// GL.RETURN +// Transfers accumulation buffer values to the color buffer or buffers +// currently selected for writing. Each R, G, B, and A component is +// multiplied by value, then multiplied by 2 n - 1 , clamped to the +// range 0 2 n - 1 , and stored in the corresponding display buffer +// cell. The only fragment operations that are applied to this transfer +// are pixel ownership, scissor, dithering, and color writemasks. +// +// To clear the accumulation buffer, call ClearAccum with R, G, B, and A +// values to set it to, then call Clear with the accumulation buffer +// enabled. +// +// Error GL.INVALID_ENUM is generated if op is not an accepted value. +// GL.INVALID_OPERATION is generated if there is no accumulation buffer. +// GL.INVALID_OPERATION is generated if Accum is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) Accum(op glbase.Enum, value float32) { + C.gl2_0_glAccum(gl.funcs, C.GLenum(op), C.GLfloat(value)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexMask.xml +func (gl *GL) IndexMask(mask uint32) { + C.gl2_0_glIndexMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearIndex.xml +func (gl *GL) ClearIndex(c float32) { + C.gl2_0_glClearIndex(gl.funcs, C.GLfloat(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearAccum.xml +func (gl *GL) ClearAccum(red, green, blue, alpha float32) { + C.gl2_0_glClearAccum(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPushName.xml +func (gl *GL) PushName(name uint32) { + C.gl2_0_glPushName(gl.funcs, C.GLuint(name)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPopName.xml +func (gl *GL) PopName() { + C.gl2_0_glPopName(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPassThrough.xml +func (gl *GL) PassThrough(token float32) { + C.gl2_0_glPassThrough(gl.funcs, C.GLfloat(token)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadName.xml +func (gl *GL) LoadName(name uint32) { + C.gl2_0_glLoadName(gl.funcs, C.GLuint(name)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glInitNames.xml +func (gl *GL) InitNames() { + C.gl2_0_glInitNames(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRenderMode.xml +func (gl *GL) RenderMode(mode glbase.Enum) int32 { + glresult := C.gl2_0_glRenderMode(gl.funcs, C.GLenum(mode)) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSelectBuffer.xml +func (gl *GL) SelectBuffer(size int, buffer []glbase.Buffer) { + C.gl2_0_glSelectBuffer(gl.funcs, C.GLsizei(size), (*C.GLuint)(unsafe.Pointer(&buffer[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFeedbackBuffer.xml +func (gl *GL) FeedbackBuffer(size int, gltype glbase.Enum, buffer []float32) { + C.gl2_0_glFeedbackBuffer(gl.funcs, C.GLsizei(size), C.GLenum(gltype), (*C.GLfloat)(unsafe.Pointer(&buffer[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGeniv.xml +func (gl *GL) TexGeniv(coord, pname glbase.Enum, params []int32) { + C.gl2_0_glTexGeniv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGeni.xml +func (gl *GL) TexGeni(coord, pname glbase.Enum, param int32) { + C.gl2_0_glTexGeni(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGenfv.xml +func (gl *GL) TexGenfv(coord, pname glbase.Enum, params []float32) { + C.gl2_0_glTexGenfv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGenf.xml +func (gl *GL) TexGenf(coord, pname glbase.Enum, param float32) { + C.gl2_0_glTexGenf(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGendv.xml +func (gl *GL) TexGendv(coord, pname glbase.Enum, params []float64) { + C.gl2_0_glTexGendv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGend.xml +func (gl *GL) TexGend(coord, pname glbase.Enum, param float64) { + C.gl2_0_glTexGend(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLdouble(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnviv.xml +func (gl *GL) TexEnviv(target, pname glbase.Enum, params []int32) { + C.gl2_0_glTexEnviv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnvi.xml +func (gl *GL) TexEnvi(target, pname glbase.Enum, param int32) { + C.gl2_0_glTexEnvi(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnvfv.xml +func (gl *GL) TexEnvfv(target, pname glbase.Enum, params []float32) { + C.gl2_0_glTexEnvfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnvf.xml +func (gl *GL) TexEnvf(target, pname glbase.Enum, param float32) { + C.gl2_0_glTexEnvf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glShadeModel.xml +func (gl *GL) ShadeModel(mode glbase.Enum) { + C.gl2_0_glShadeModel(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPolygonStipple.xml +func (gl *GL) PolygonStipple(mask []uint8) { + C.gl2_0_glPolygonStipple(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&mask[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMaterialiv.xml +func (gl *GL) Materialiv(face, pname glbase.Enum, params []int32) { + C.gl2_0_glMaterialiv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMateriali.xml +func (gl *GL) Materiali(face, pname glbase.Enum, param int32) { + C.gl2_0_glMateriali(gl.funcs, C.GLenum(face), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMaterialfv.xml +func (gl *GL) Materialfv(face, pname glbase.Enum, params []float32) { + C.gl2_0_glMaterialfv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMaterialf.xml +func (gl *GL) Materialf(face, pname glbase.Enum, param float32) { + C.gl2_0_glMaterialf(gl.funcs, C.GLenum(face), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLineStipple.xml +func (gl *GL) LineStipple(factor int32, pattern uint16) { + C.gl2_0_glLineStipple(gl.funcs, C.GLint(factor), C.GLushort(pattern)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightModeliv.xml +func (gl *GL) LightModeliv(pname glbase.Enum, params []int32) { + C.gl2_0_glLightModeliv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightModeli.xml +func (gl *GL) LightModeli(pname glbase.Enum, param int32) { + C.gl2_0_glLightModeli(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightModelfv.xml +func (gl *GL) LightModelfv(pname glbase.Enum, params []float32) { + C.gl2_0_glLightModelfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightModelf.xml +func (gl *GL) LightModelf(pname glbase.Enum, param float32) { + C.gl2_0_glLightModelf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightiv.xml +func (gl *GL) Lightiv(light, pname glbase.Enum, params []int32) { + C.gl2_0_glLightiv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLighti.xml +func (gl *GL) Lighti(light, pname glbase.Enum, param int32) { + C.gl2_0_glLighti(gl.funcs, C.GLenum(light), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightfv.xml +func (gl *GL) Lightfv(light, pname glbase.Enum, params []float32) { + C.gl2_0_glLightfv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightf.xml +func (gl *GL) Lightf(light, pname glbase.Enum, param float32) { + C.gl2_0_glLightf(gl.funcs, C.GLenum(light), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogiv.xml +func (gl *GL) Fogiv(pname glbase.Enum, params []int32) { + C.gl2_0_glFogiv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogi.xml +func (gl *GL) Fogi(pname glbase.Enum, param int32) { + C.gl2_0_glFogi(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogfv.xml +func (gl *GL) Fogfv(pname glbase.Enum, params []float32) { + C.gl2_0_glFogfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogf.xml +func (gl *GL) Fogf(pname glbase.Enum, param float32) { + C.gl2_0_glFogf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorMaterial.xml +func (gl *GL) ColorMaterial(face, mode glbase.Enum) { + C.gl2_0_glColorMaterial(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClipPlane.xml +func (gl *GL) ClipPlane(plane glbase.Enum, equation []float64) { + C.gl2_0_glClipPlane(gl.funcs, C.GLenum(plane), (*C.GLdouble)(unsafe.Pointer(&equation[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4sv.xml +func (gl *GL) Vertex4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_0_glVertex4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4s.xml +func (gl *GL) Vertex4s(x, y, z, w int16) { + C.gl2_0_glVertex4s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4iv.xml +func (gl *GL) Vertex4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_0_glVertex4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4i.xml +func (gl *GL) Vertex4i(x, y, z, w int) { + C.gl2_0_glVertex4i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4fv.xml +func (gl *GL) Vertex4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_0_glVertex4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4f.xml +func (gl *GL) Vertex4f(x, y, z, w float32) { + C.gl2_0_glVertex4f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4dv.xml +func (gl *GL) Vertex4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_0_glVertex4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4d.xml +func (gl *GL) Vertex4d(x, y, z, w float64) { + C.gl2_0_glVertex4d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3sv.xml +func (gl *GL) Vertex3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_0_glVertex3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3s.xml +func (gl *GL) Vertex3s(x, y, z int16) { + C.gl2_0_glVertex3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3iv.xml +func (gl *GL) Vertex3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_0_glVertex3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3i.xml +func (gl *GL) Vertex3i(x, y, z int) { + C.gl2_0_glVertex3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3fv.xml +func (gl *GL) Vertex3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_0_glVertex3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3f.xml +func (gl *GL) Vertex3f(x, y, z float32) { + C.gl2_0_glVertex3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3dv.xml +func (gl *GL) Vertex3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_0_glVertex3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3d.xml +func (gl *GL) Vertex3d(x, y, z float64) { + C.gl2_0_glVertex3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2sv.xml +func (gl *GL) Vertex2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_0_glVertex2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2s.xml +func (gl *GL) Vertex2s(x, y int16) { + C.gl2_0_glVertex2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2iv.xml +func (gl *GL) Vertex2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_0_glVertex2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2i.xml +func (gl *GL) Vertex2i(x, y int) { + C.gl2_0_glVertex2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2fv.xml +func (gl *GL) Vertex2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_0_glVertex2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2f.xml +func (gl *GL) Vertex2f(x, y float32) { + C.gl2_0_glVertex2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2dv.xml +func (gl *GL) Vertex2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_0_glVertex2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2d.xml +func (gl *GL) Vertex2d(x, y float64) { + C.gl2_0_glVertex2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4sv.xml +func (gl *GL) TexCoord4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_0_glTexCoord4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4s.xml +func (gl *GL) TexCoord4s(s, t, r, q int16) { + C.gl2_0_glTexCoord4s(gl.funcs, C.GLshort(s), C.GLshort(t), C.GLshort(r), C.GLshort(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4iv.xml +func (gl *GL) TexCoord4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_0_glTexCoord4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4i.xml +func (gl *GL) TexCoord4i(s, t, r, q int32) { + C.gl2_0_glTexCoord4i(gl.funcs, C.GLint(s), C.GLint(t), C.GLint(r), C.GLint(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4fv.xml +func (gl *GL) TexCoord4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_0_glTexCoord4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4f.xml +func (gl *GL) TexCoord4f(s, t, r, q float32) { + C.gl2_0_glTexCoord4f(gl.funcs, C.GLfloat(s), C.GLfloat(t), C.GLfloat(r), C.GLfloat(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4dv.xml +func (gl *GL) TexCoord4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_0_glTexCoord4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4d.xml +func (gl *GL) TexCoord4d(s, t, r, q float64) { + C.gl2_0_glTexCoord4d(gl.funcs, C.GLdouble(s), C.GLdouble(t), C.GLdouble(r), C.GLdouble(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3sv.xml +func (gl *GL) TexCoord3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_0_glTexCoord3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3s.xml +func (gl *GL) TexCoord3s(s, t, r int16) { + C.gl2_0_glTexCoord3s(gl.funcs, C.GLshort(s), C.GLshort(t), C.GLshort(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3iv.xml +func (gl *GL) TexCoord3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_0_glTexCoord3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3i.xml +func (gl *GL) TexCoord3i(s, t, r int32) { + C.gl2_0_glTexCoord3i(gl.funcs, C.GLint(s), C.GLint(t), C.GLint(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3fv.xml +func (gl *GL) TexCoord3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_0_glTexCoord3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3f.xml +func (gl *GL) TexCoord3f(s, t, r float32) { + C.gl2_0_glTexCoord3f(gl.funcs, C.GLfloat(s), C.GLfloat(t), C.GLfloat(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3dv.xml +func (gl *GL) TexCoord3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_0_glTexCoord3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3d.xml +func (gl *GL) TexCoord3d(s, t, r float64) { + C.gl2_0_glTexCoord3d(gl.funcs, C.GLdouble(s), C.GLdouble(t), C.GLdouble(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2sv.xml +func (gl *GL) TexCoord2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_0_glTexCoord2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2s.xml +func (gl *GL) TexCoord2s(s, t int16) { + C.gl2_0_glTexCoord2s(gl.funcs, C.GLshort(s), C.GLshort(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2iv.xml +func (gl *GL) TexCoord2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_0_glTexCoord2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2i.xml +func (gl *GL) TexCoord2i(s, t int32) { + C.gl2_0_glTexCoord2i(gl.funcs, C.GLint(s), C.GLint(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2fv.xml +func (gl *GL) TexCoord2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_0_glTexCoord2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2f.xml +func (gl *GL) TexCoord2f(s, t float32) { + C.gl2_0_glTexCoord2f(gl.funcs, C.GLfloat(s), C.GLfloat(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2dv.xml +func (gl *GL) TexCoord2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_0_glTexCoord2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2d.xml +func (gl *GL) TexCoord2d(s, t float64) { + C.gl2_0_glTexCoord2d(gl.funcs, C.GLdouble(s), C.GLdouble(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1sv.xml +func (gl *GL) TexCoord1sv(v []int16) { + C.gl2_0_glTexCoord1sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1s.xml +func (gl *GL) TexCoord1s(s int16) { + C.gl2_0_glTexCoord1s(gl.funcs, C.GLshort(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1iv.xml +func (gl *GL) TexCoord1iv(v []int32) { + C.gl2_0_glTexCoord1iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1i.xml +func (gl *GL) TexCoord1i(s int32) { + C.gl2_0_glTexCoord1i(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1fv.xml +func (gl *GL) TexCoord1fv(v []float32) { + C.gl2_0_glTexCoord1fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1f.xml +func (gl *GL) TexCoord1f(s float32) { + C.gl2_0_glTexCoord1f(gl.funcs, C.GLfloat(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1dv.xml +func (gl *GL) TexCoord1dv(v []float64) { + C.gl2_0_glTexCoord1dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1d.xml +func (gl *GL) TexCoord1d(s float64) { + C.gl2_0_glTexCoord1d(gl.funcs, C.GLdouble(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectsv.xml +func (gl *GL) Rectsv(v1, v2 []int16) { + C.gl2_0_glRectsv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v1[0])), (*C.GLshort)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRects.xml +func (gl *GL) Rects(x1, y1, x2, y2 int16) { + C.gl2_0_glRects(gl.funcs, C.GLshort(x1), C.GLshort(y1), C.GLshort(x2), C.GLshort(y2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectiv.xml +func (gl *GL) Rectiv(v1, v2 []int32) { + C.gl2_0_glRectiv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v1[0])), (*C.GLint)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRecti.xml +func (gl *GL) Recti(x1, y1, x2, y2 int32) { + C.gl2_0_glRecti(gl.funcs, C.GLint(x1), C.GLint(y1), C.GLint(x2), C.GLint(y2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectfv.xml +func (gl *GL) Rectfv(v1, v2 []float32) { + C.gl2_0_glRectfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v1[0])), (*C.GLfloat)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectf.xml +func (gl *GL) Rectf(x1, y1, x2, y2 float32) { + C.gl2_0_glRectf(gl.funcs, C.GLfloat(x1), C.GLfloat(y1), C.GLfloat(x2), C.GLfloat(y2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectdv.xml +func (gl *GL) Rectdv(v1, v2 []float64) { + C.gl2_0_glRectdv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v1[0])), (*C.GLdouble)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectd.xml +func (gl *GL) Rectd(x1, y1, x2, y2 float64) { + C.gl2_0_glRectd(gl.funcs, C.GLdouble(x1), C.GLdouble(y1), C.GLdouble(x2), C.GLdouble(y2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4sv.xml +func (gl *GL) RasterPos4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_0_glRasterPos4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4s.xml +func (gl *GL) RasterPos4s(x, y, z, w int16) { + C.gl2_0_glRasterPos4s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4iv.xml +func (gl *GL) RasterPos4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_0_glRasterPos4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4i.xml +func (gl *GL) RasterPos4i(x, y, z, w int) { + C.gl2_0_glRasterPos4i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4fv.xml +func (gl *GL) RasterPos4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_0_glRasterPos4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4f.xml +func (gl *GL) RasterPos4f(x, y, z, w float32) { + C.gl2_0_glRasterPos4f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4dv.xml +func (gl *GL) RasterPos4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_0_glRasterPos4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4d.xml +func (gl *GL) RasterPos4d(x, y, z, w float64) { + C.gl2_0_glRasterPos4d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3sv.xml +func (gl *GL) RasterPos3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_0_glRasterPos3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3s.xml +func (gl *GL) RasterPos3s(x, y, z int16) { + C.gl2_0_glRasterPos3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3iv.xml +func (gl *GL) RasterPos3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_0_glRasterPos3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3i.xml +func (gl *GL) RasterPos3i(x, y, z int) { + C.gl2_0_glRasterPos3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3fv.xml +func (gl *GL) RasterPos3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_0_glRasterPos3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3f.xml +func (gl *GL) RasterPos3f(x, y, z float32) { + C.gl2_0_glRasterPos3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3dv.xml +func (gl *GL) RasterPos3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_0_glRasterPos3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3d.xml +func (gl *GL) RasterPos3d(x, y, z float64) { + C.gl2_0_glRasterPos3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2sv.xml +func (gl *GL) RasterPos2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_0_glRasterPos2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2s.xml +func (gl *GL) RasterPos2s(x, y int16) { + C.gl2_0_glRasterPos2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2iv.xml +func (gl *GL) RasterPos2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_0_glRasterPos2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2i.xml +func (gl *GL) RasterPos2i(x, y int) { + C.gl2_0_glRasterPos2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2fv.xml +func (gl *GL) RasterPos2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_0_glRasterPos2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2f.xml +func (gl *GL) RasterPos2f(x, y float32) { + C.gl2_0_glRasterPos2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2dv.xml +func (gl *GL) RasterPos2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_0_glRasterPos2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2d.xml +func (gl *GL) RasterPos2d(x, y float64) { + C.gl2_0_glRasterPos2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3sv.xml +func (gl *GL) Normal3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_0_glNormal3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3s.xml +func (gl *GL) Normal3s(nx, ny, nz int16) { + C.gl2_0_glNormal3s(gl.funcs, C.GLshort(nx), C.GLshort(ny), C.GLshort(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3iv.xml +func (gl *GL) Normal3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_0_glNormal3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3i.xml +func (gl *GL) Normal3i(nx, ny, nz int32) { + C.gl2_0_glNormal3i(gl.funcs, C.GLint(nx), C.GLint(ny), C.GLint(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3fv.xml +func (gl *GL) Normal3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_0_glNormal3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3f.xml +func (gl *GL) Normal3f(nx, ny, nz float32) { + C.gl2_0_glNormal3f(gl.funcs, C.GLfloat(nx), C.GLfloat(ny), C.GLfloat(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3dv.xml +func (gl *GL) Normal3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_0_glNormal3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3d.xml +func (gl *GL) Normal3d(nx, ny, nz float64) { + C.gl2_0_glNormal3d(gl.funcs, C.GLdouble(nx), C.GLdouble(ny), C.GLdouble(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3bv.xml +func (gl *GL) Normal3bv(v []byte) { + C.gl2_0_glNormal3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3b.xml +func (gl *GL) Normal3b(nx, ny, nz byte) { + C.gl2_0_glNormal3b(gl.funcs, C.GLbyte(nx), C.GLbyte(ny), C.GLbyte(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexsv.xml +func (gl *GL) Indexsv(c []int16) { + C.gl2_0_glIndexsv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexs.xml +func (gl *GL) Indexs(c int16) { + C.gl2_0_glIndexs(gl.funcs, C.GLshort(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexiv.xml +func (gl *GL) Indexiv(c []int32) { + C.gl2_0_glIndexiv(gl.funcs, (*C.GLint)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexi.xml +func (gl *GL) Indexi(c int32) { + C.gl2_0_glIndexi(gl.funcs, C.GLint(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexfv.xml +func (gl *GL) Indexfv(c []float32) { + C.gl2_0_glIndexfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexf.xml +func (gl *GL) Indexf(c float32) { + C.gl2_0_glIndexf(gl.funcs, C.GLfloat(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexdv.xml +func (gl *GL) Indexdv(c []float64) { + C.gl2_0_glIndexdv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexd.xml +func (gl *GL) Indexd(c float64) { + C.gl2_0_glIndexd(gl.funcs, C.GLdouble(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEnd.xml +func (gl *GL) End() { + C.gl2_0_glEnd(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEdgeFlagv.xml +func (gl *GL) EdgeFlagv(flag []bool) { + C.gl2_0_glEdgeFlagv(gl.funcs, (*C.GLboolean)(unsafe.Pointer(&flag[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEdgeFlag.xml +func (gl *GL) EdgeFlag(flag bool) { + C.gl2_0_glEdgeFlag(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4usv.xml +func (gl *GL) Color4usv(v []uint16) { + C.gl2_0_glColor4usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4us.xml +func (gl *GL) Color4us(red, green, blue, alpha uint16) { + C.gl2_0_glColor4us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue), C.GLushort(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4uiv.xml +func (gl *GL) Color4uiv(v []uint32) { + C.gl2_0_glColor4uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4ui.xml +func (gl *GL) Color4ui(red, green, blue, alpha uint32) { + C.gl2_0_glColor4ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue), C.GLuint(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4ubv.xml +func (gl *GL) Color4ubv(v []uint8) { + C.gl2_0_glColor4ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4ub.xml +func (gl *GL) Color4ub(red, green, blue, alpha uint8) { + C.gl2_0_glColor4ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue), C.GLubyte(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4sv.xml +func (gl *GL) Color4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_0_glColor4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4s.xml +func (gl *GL) Color4s(red, green, blue, alpha int16) { + C.gl2_0_glColor4s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue), C.GLshort(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4iv.xml +func (gl *GL) Color4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_0_glColor4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4i.xml +func (gl *GL) Color4i(red, green, blue, alpha int32) { + C.gl2_0_glColor4i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue), C.GLint(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4fv.xml +func (gl *GL) Color4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_0_glColor4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4f.xml +func (gl *GL) Color4f(red, green, blue, alpha float32) { + C.gl2_0_glColor4f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4dv.xml +func (gl *GL) Color4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_0_glColor4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4d.xml +func (gl *GL) Color4d(red, green, blue, alpha float64) { + C.gl2_0_glColor4d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue), C.GLdouble(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4bv.xml +func (gl *GL) Color4bv(v []byte) { + C.gl2_0_glColor4bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4b.xml +func (gl *GL) Color4b(red, green, blue, alpha byte) { + C.gl2_0_glColor4b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue), C.GLbyte(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3usv.xml +func (gl *GL) Color3usv(v []uint16) { + C.gl2_0_glColor3usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3us.xml +func (gl *GL) Color3us(red, green, blue uint16) { + C.gl2_0_glColor3us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3uiv.xml +func (gl *GL) Color3uiv(v []uint32) { + C.gl2_0_glColor3uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3ui.xml +func (gl *GL) Color3ui(red, green, blue uint32) { + C.gl2_0_glColor3ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3ubv.xml +func (gl *GL) Color3ubv(v []uint8) { + C.gl2_0_glColor3ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3ub.xml +func (gl *GL) Color3ub(red, green, blue uint8) { + C.gl2_0_glColor3ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3sv.xml +func (gl *GL) Color3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_0_glColor3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3s.xml +func (gl *GL) Color3s(red, green, blue int16) { + C.gl2_0_glColor3s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3iv.xml +func (gl *GL) Color3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_0_glColor3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3i.xml +func (gl *GL) Color3i(red, green, blue int32) { + C.gl2_0_glColor3i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3fv.xml +func (gl *GL) Color3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_0_glColor3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3f.xml +func (gl *GL) Color3f(red, green, blue float32) { + C.gl2_0_glColor3f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3dv.xml +func (gl *GL) Color3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_0_glColor3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3d.xml +func (gl *GL) Color3d(red, green, blue float64) { + C.gl2_0_glColor3d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3bv.xml +func (gl *GL) Color3bv(v []byte) { + C.gl2_0_glColor3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3b.xml +func (gl *GL) Color3b(red, green, blue byte) { + C.gl2_0_glColor3b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBitmap.xml +func (gl *GL) Bitmap(width, height int, xorig, yorig, xmove, ymove float32, bitmap []uint8) { + C.gl2_0_glBitmap(gl.funcs, C.GLsizei(width), C.GLsizei(height), C.GLfloat(xorig), C.GLfloat(yorig), C.GLfloat(xmove), C.GLfloat(ymove), (*C.GLubyte)(unsafe.Pointer(&bitmap[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBegin.xml +func (gl *GL) Begin(mode glbase.Enum) { + C.gl2_0_glBegin(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glListBase.xml +func (gl *GL) ListBase(base uint32) { + C.gl2_0_glListBase(gl.funcs, C.GLuint(base)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGenLists.xml +func (gl *GL) GenLists(range_ int32) uint32 { + glresult := C.gl2_0_glGenLists(gl.funcs, C.GLsizei(range_)) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDeleteLists.xml +func (gl *GL) DeleteLists(list uint32, range_ int32) { + C.gl2_0_glDeleteLists(gl.funcs, C.GLuint(list), C.GLsizei(range_)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCallLists.xml +func (gl *GL) CallLists(n int, gltype glbase.Enum, lists interface{}) { + var lists_ptr unsafe.Pointer + var lists_v = reflect.ValueOf(lists) + if lists != nil && lists_v.Kind() != reflect.Slice { + panic("parameter lists must be a slice") + } + if lists != nil { + lists_ptr = unsafe.Pointer(lists_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glCallLists(gl.funcs, C.GLsizei(n), C.GLenum(gltype), lists_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCallList.xml +func (gl *GL) CallList(list uint32) { + C.gl2_0_glCallList(gl.funcs, C.GLuint(list)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEndList.xml +func (gl *GL) EndList() { + C.gl2_0_glEndList(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNewList.xml +func (gl *GL) NewList(list uint32, mode glbase.Enum) { + C.gl2_0_glNewList(gl.funcs, C.GLuint(list), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPushClientAttrib.xml +func (gl *GL) PushClientAttrib(mask glbase.Bitfield) { + C.gl2_0_glPushClientAttrib(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPopClientAttrib.xml +func (gl *GL) PopClientAttrib() { + C.gl2_0_glPopClientAttrib(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPrioritizeTextures.xml +func (gl *GL) PrioritizeTextures(n int, textures []glbase.Texture, priorities []float32) { + C.gl2_0_glPrioritizeTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0])), (*C.GLfloat)(unsafe.Pointer(&priorities[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glAreTexturesResident.xml +func (gl *GL) AreTexturesResident(n int, textures []glbase.Texture, residences []bool) bool { + glresult := C.gl2_0_glAreTexturesResident(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0])), (*C.GLboolean)(unsafe.Pointer(&residences[0]))) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexPointer.xml +func (gl *GL) VertexPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glVertexPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoordPointer.xml +func (gl *GL) TexCoordPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glTexCoordPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormalPointer.xml +func (gl *GL) NormalPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glNormalPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glInterleavedArrays.xml +func (gl *GL) InterleavedArrays(format glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glInterleavedArrays(gl.funcs, C.GLenum(format), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexPointer.xml +func (gl *GL) IndexPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glIndexPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEnableClientState.xml +func (gl *GL) EnableClientState(array glbase.Enum) { + C.gl2_0_glEnableClientState(gl.funcs, C.GLenum(array)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEdgeFlagPointer.xml +func (gl *GL) EdgeFlagPointer(stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glEdgeFlagPointer(gl.funcs, C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDisableClientState.xml +func (gl *GL) DisableClientState(array glbase.Enum) { + C.gl2_0_glDisableClientState(gl.funcs, C.GLenum(array)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorPointer.xml +func (gl *GL) ColorPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glColorPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glArrayElement.xml +func (gl *GL) ArrayElement(i int32) { + C.gl2_0_glArrayElement(gl.funcs, C.GLint(i)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glResetMinmax.xml +func (gl *GL) ResetMinmax(target glbase.Enum) { + C.gl2_0_glResetMinmax(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glResetHistogram.xml +func (gl *GL) ResetHistogram(target glbase.Enum) { + C.gl2_0_glResetHistogram(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMinmax.xml +func (gl *GL) Minmax(target, internalFormat glbase.Enum, sink bool) { + C.gl2_0_glMinmax(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), *(*C.GLboolean)(unsafe.Pointer(&sink))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glHistogram.xml +func (gl *GL) Histogram(target glbase.Enum, width int, internalFormat glbase.Enum, sink bool) { + C.gl2_0_glHistogram(gl.funcs, C.GLenum(target), C.GLsizei(width), C.GLenum(internalFormat), *(*C.GLboolean)(unsafe.Pointer(&sink))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMinmaxParameteriv.xml +func (gl *GL) GetMinmaxParameteriv(target, pname glbase.Enum, params []int32) { + C.gl2_0_glGetMinmaxParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMinmaxParameterfv.xml +func (gl *GL) GetMinmaxParameterfv(target, pname glbase.Enum, params []float32) { + C.gl2_0_glGetMinmaxParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMinmax.xml +func (gl *GL) GetMinmax(target glbase.Enum, reset bool, format, gltype glbase.Enum, values interface{}) { + var values_ptr unsafe.Pointer + var values_v = reflect.ValueOf(values) + if values != nil && values_v.Kind() != reflect.Slice { + panic("parameter values must be a slice") + } + if values != nil { + values_ptr = unsafe.Pointer(values_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glGetMinmax(gl.funcs, C.GLenum(target), *(*C.GLboolean)(unsafe.Pointer(&reset)), C.GLenum(format), C.GLenum(gltype), values_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetHistogramParameteriv.xml +func (gl *GL) GetHistogramParameteriv(target, pname glbase.Enum, params []int32) { + C.gl2_0_glGetHistogramParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetHistogramParameterfv.xml +func (gl *GL) GetHistogramParameterfv(target, pname glbase.Enum, params []float32) { + C.gl2_0_glGetHistogramParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetHistogram.xml +func (gl *GL) GetHistogram(target glbase.Enum, reset bool, format, gltype glbase.Enum, values interface{}) { + var values_ptr unsafe.Pointer + var values_v = reflect.ValueOf(values) + if values != nil && values_v.Kind() != reflect.Slice { + panic("parameter values must be a slice") + } + if values != nil { + values_ptr = unsafe.Pointer(values_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glGetHistogram(gl.funcs, C.GLenum(target), *(*C.GLboolean)(unsafe.Pointer(&reset)), C.GLenum(format), C.GLenum(gltype), values_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSeparableFilter2D.xml +func (gl *GL) SeparableFilter2D(target, internalFormat glbase.Enum, width, height int, format, gltype glbase.Enum, row, column interface{}) { + var row_ptr unsafe.Pointer + var row_v = reflect.ValueOf(row) + if row != nil && row_v.Kind() != reflect.Slice { + panic("parameter row must be a slice") + } + if row != nil { + row_ptr = unsafe.Pointer(row_v.Index(0).Addr().Pointer()) + } + var column_ptr unsafe.Pointer + var column_v = reflect.ValueOf(column) + if column != nil && column_v.Kind() != reflect.Slice { + panic("parameter column must be a slice") + } + if column != nil { + column_ptr = unsafe.Pointer(column_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glSeparableFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), row_ptr, column_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetSeparableFilter.xml +func (gl *GL) GetSeparableFilter(target, format, gltype glbase.Enum, row, column, span interface{}) { + var row_ptr unsafe.Pointer + var row_v = reflect.ValueOf(row) + if row != nil && row_v.Kind() != reflect.Slice { + panic("parameter row must be a slice") + } + if row != nil { + row_ptr = unsafe.Pointer(row_v.Index(0).Addr().Pointer()) + } + var column_ptr unsafe.Pointer + var column_v = reflect.ValueOf(column) + if column != nil && column_v.Kind() != reflect.Slice { + panic("parameter column must be a slice") + } + if column != nil { + column_ptr = unsafe.Pointer(column_v.Index(0).Addr().Pointer()) + } + var span_ptr unsafe.Pointer + var span_v = reflect.ValueOf(span) + if span != nil && span_v.Kind() != reflect.Slice { + panic("parameter span must be a slice") + } + if span != nil { + span_ptr = unsafe.Pointer(span_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glGetSeparableFilter(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), row_ptr, column_ptr, span_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetConvolutionParameteriv.xml +func (gl *GL) GetConvolutionParameteriv(target, pname glbase.Enum, params []int32) { + C.gl2_0_glGetConvolutionParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetConvolutionParameterfv.xml +func (gl *GL) GetConvolutionParameterfv(target, pname glbase.Enum, params []float32) { + C.gl2_0_glGetConvolutionParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetConvolutionFilter.xml +func (gl *GL) GetConvolutionFilter(target, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glGetConvolutionFilter(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyConvolutionFilter2D.xml +func (gl *GL) CopyConvolutionFilter2D(target, internalFormat glbase.Enum, x, y, width, height int) { + C.gl2_0_glCopyConvolutionFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyConvolutionFilter1D.xml +func (gl *GL) CopyConvolutionFilter1D(target, internalFormat glbase.Enum, x, y, width int) { + C.gl2_0_glCopyConvolutionFilter1D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionParameteriv.xml +func (gl *GL) ConvolutionParameteriv(target, pname glbase.Enum, params []int32) { + C.gl2_0_glConvolutionParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionParameteri.xml +func (gl *GL) ConvolutionParameteri(target, pname glbase.Enum, params int32) { + C.gl2_0_glConvolutionParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(params)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionParameterfv.xml +func (gl *GL) ConvolutionParameterfv(target, pname glbase.Enum, params []float32) { + C.gl2_0_glConvolutionParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionParameterf.xml +func (gl *GL) ConvolutionParameterf(target, pname glbase.Enum, params float32) { + C.gl2_0_glConvolutionParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(params)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionFilter2D.xml +func (gl *GL) ConvolutionFilter2D(target, internalFormat glbase.Enum, width, height int, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glConvolutionFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionFilter1D.xml +func (gl *GL) ConvolutionFilter1D(target, internalFormat glbase.Enum, width int, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glConvolutionFilter1D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyColorSubTable.xml +func (gl *GL) CopyColorSubTable(target glbase.Enum, start int32, x, y, width int) { + C.gl2_0_glCopyColorSubTable(gl.funcs, C.GLenum(target), C.GLsizei(start), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorSubTable.xml +func (gl *GL) ColorSubTable(target glbase.Enum, start int32, count int, format, gltype glbase.Enum, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glColorSubTable(gl.funcs, C.GLenum(target), C.GLsizei(start), C.GLsizei(count), C.GLenum(format), C.GLenum(gltype), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetColorTableParameteriv.xml +func (gl *GL) GetColorTableParameteriv(target, pname glbase.Enum, params []int32) { + C.gl2_0_glGetColorTableParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetColorTableParameterfv.xml +func (gl *GL) GetColorTableParameterfv(target, pname glbase.Enum, params []float32) { + C.gl2_0_glGetColorTableParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetColorTable.xml +func (gl *GL) GetColorTable(target, format, gltype glbase.Enum, table interface{}) { + var table_ptr unsafe.Pointer + var table_v = reflect.ValueOf(table) + if table != nil && table_v.Kind() != reflect.Slice { + panic("parameter table must be a slice") + } + if table != nil { + table_ptr = unsafe.Pointer(table_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glGetColorTable(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), table_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyColorTable.xml +func (gl *GL) CopyColorTable(target, internalFormat glbase.Enum, x, y, width int) { + C.gl2_0_glCopyColorTable(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorTableParameteriv.xml +func (gl *GL) ColorTableParameteriv(target, pname glbase.Enum, params []int32) { + C.gl2_0_glColorTableParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorTableParameterfv.xml +func (gl *GL) ColorTableParameterfv(target, pname glbase.Enum, params []float32) { + C.gl2_0_glColorTableParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorTable.xml +func (gl *GL) ColorTable(target, internalFormat glbase.Enum, width int, format, gltype glbase.Enum, table interface{}) { + var table_ptr unsafe.Pointer + var table_v = reflect.ValueOf(table) + if table != nil && table_v.Kind() != reflect.Slice { + panic("parameter table must be a slice") + } + if table != nil { + table_ptr = unsafe.Pointer(table_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glColorTable(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), table_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultTransposeMatrixd.xml +func (gl *GL) MultTransposeMatrixd(m []float64) { + C.gl2_0_glMultTransposeMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultTransposeMatrixf.xml +func (gl *GL) MultTransposeMatrixf(m []float32) { + C.gl2_0_glMultTransposeMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadTransposeMatrixd.xml +func (gl *GL) LoadTransposeMatrixd(m []float64) { + C.gl2_0_glLoadTransposeMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadTransposeMatrixf.xml +func (gl *GL) LoadTransposeMatrixf(m []float32) { + C.gl2_0_glLoadTransposeMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4sv.xml +func (gl *GL) MultiTexCoord4sv(target glbase.Enum, v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_0_glMultiTexCoord4sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4s.xml +func (gl *GL) MultiTexCoord4s(target glbase.Enum, s, t, r, q int16) { + C.gl2_0_glMultiTexCoord4s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t), C.GLshort(r), C.GLshort(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4iv.xml +func (gl *GL) MultiTexCoord4iv(target glbase.Enum, v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_0_glMultiTexCoord4iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4i.xml +func (gl *GL) MultiTexCoord4i(target glbase.Enum, s, t, r, q int32) { + C.gl2_0_glMultiTexCoord4i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t), C.GLint(r), C.GLint(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4fv.xml +func (gl *GL) MultiTexCoord4fv(target glbase.Enum, v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_0_glMultiTexCoord4fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4f.xml +func (gl *GL) MultiTexCoord4f(target glbase.Enum, s, t, r, q float32) { + C.gl2_0_glMultiTexCoord4f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t), C.GLfloat(r), C.GLfloat(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4dv.xml +func (gl *GL) MultiTexCoord4dv(target glbase.Enum, v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_0_glMultiTexCoord4dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4d.xml +func (gl *GL) MultiTexCoord4d(target glbase.Enum, s, t, r, q float64) { + C.gl2_0_glMultiTexCoord4d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t), C.GLdouble(r), C.GLdouble(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3sv.xml +func (gl *GL) MultiTexCoord3sv(target glbase.Enum, v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_0_glMultiTexCoord3sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3s.xml +func (gl *GL) MultiTexCoord3s(target glbase.Enum, s, t, r int16) { + C.gl2_0_glMultiTexCoord3s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t), C.GLshort(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3iv.xml +func (gl *GL) MultiTexCoord3iv(target glbase.Enum, v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_0_glMultiTexCoord3iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3i.xml +func (gl *GL) MultiTexCoord3i(target glbase.Enum, s, t, r int32) { + C.gl2_0_glMultiTexCoord3i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t), C.GLint(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3fv.xml +func (gl *GL) MultiTexCoord3fv(target glbase.Enum, v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_0_glMultiTexCoord3fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3f.xml +func (gl *GL) MultiTexCoord3f(target glbase.Enum, s, t, r float32) { + C.gl2_0_glMultiTexCoord3f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t), C.GLfloat(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3dv.xml +func (gl *GL) MultiTexCoord3dv(target glbase.Enum, v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_0_glMultiTexCoord3dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3d.xml +func (gl *GL) MultiTexCoord3d(target glbase.Enum, s, t, r float64) { + C.gl2_0_glMultiTexCoord3d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t), C.GLdouble(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2sv.xml +func (gl *GL) MultiTexCoord2sv(target glbase.Enum, v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_0_glMultiTexCoord2sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2s.xml +func (gl *GL) MultiTexCoord2s(target glbase.Enum, s, t int16) { + C.gl2_0_glMultiTexCoord2s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2iv.xml +func (gl *GL) MultiTexCoord2iv(target glbase.Enum, v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_0_glMultiTexCoord2iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2i.xml +func (gl *GL) MultiTexCoord2i(target glbase.Enum, s, t int32) { + C.gl2_0_glMultiTexCoord2i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2fv.xml +func (gl *GL) MultiTexCoord2fv(target glbase.Enum, v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_0_glMultiTexCoord2fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2f.xml +func (gl *GL) MultiTexCoord2f(target glbase.Enum, s, t float32) { + C.gl2_0_glMultiTexCoord2f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2dv.xml +func (gl *GL) MultiTexCoord2dv(target glbase.Enum, v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_0_glMultiTexCoord2dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2d.xml +func (gl *GL) MultiTexCoord2d(target glbase.Enum, s, t float64) { + C.gl2_0_glMultiTexCoord2d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1sv.xml +func (gl *GL) MultiTexCoord1sv(target glbase.Enum, v []int16) { + C.gl2_0_glMultiTexCoord1sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1s.xml +func (gl *GL) MultiTexCoord1s(target glbase.Enum, s int16) { + C.gl2_0_glMultiTexCoord1s(gl.funcs, C.GLenum(target), C.GLshort(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1iv.xml +func (gl *GL) MultiTexCoord1iv(target glbase.Enum, v []int32) { + C.gl2_0_glMultiTexCoord1iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1i.xml +func (gl *GL) MultiTexCoord1i(target glbase.Enum, s int32) { + C.gl2_0_glMultiTexCoord1i(gl.funcs, C.GLenum(target), C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1fv.xml +func (gl *GL) MultiTexCoord1fv(target glbase.Enum, v []float32) { + C.gl2_0_glMultiTexCoord1fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1f.xml +func (gl *GL) MultiTexCoord1f(target glbase.Enum, s float32) { + C.gl2_0_glMultiTexCoord1f(gl.funcs, C.GLenum(target), C.GLfloat(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1dv.xml +func (gl *GL) MultiTexCoord1dv(target glbase.Enum, v []float64) { + C.gl2_0_glMultiTexCoord1dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1d.xml +func (gl *GL) MultiTexCoord1d(target glbase.Enum, s float64) { + C.gl2_0_glMultiTexCoord1d(gl.funcs, C.GLenum(target), C.GLdouble(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClientActiveTexture.xml +func (gl *GL) ClientActiveTexture(texture glbase.Enum) { + C.gl2_0_glClientActiveTexture(gl.funcs, C.GLenum(texture)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos3sv.xml +func (gl *GL) WindowPos3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_0_glWindowPos3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos3s.xml +func (gl *GL) WindowPos3s(x, y, z int16) { + C.gl2_0_glWindowPos3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos3iv.xml +func (gl *GL) WindowPos3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_0_glWindowPos3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos3i.xml +func (gl *GL) WindowPos3i(x, y, z int) { + C.gl2_0_glWindowPos3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos3fv.xml +func (gl *GL) WindowPos3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_0_glWindowPos3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos3f.xml +func (gl *GL) WindowPos3f(x, y, z float32) { + C.gl2_0_glWindowPos3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos3dv.xml +func (gl *GL) WindowPos3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_0_glWindowPos3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos3d.xml +func (gl *GL) WindowPos3d(x, y, z float64) { + C.gl2_0_glWindowPos3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos2sv.xml +func (gl *GL) WindowPos2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_0_glWindowPos2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos2s.xml +func (gl *GL) WindowPos2s(x, y int16) { + C.gl2_0_glWindowPos2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos2iv.xml +func (gl *GL) WindowPos2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_0_glWindowPos2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos2i.xml +func (gl *GL) WindowPos2i(x, y int) { + C.gl2_0_glWindowPos2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos2fv.xml +func (gl *GL) WindowPos2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_0_glWindowPos2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos2f.xml +func (gl *GL) WindowPos2f(x, y float32) { + C.gl2_0_glWindowPos2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos2dv.xml +func (gl *GL) WindowPos2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_0_glWindowPos2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos2d.xml +func (gl *GL) WindowPos2d(x, y float64) { + C.gl2_0_glWindowPos2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColorPointer.xml +func (gl *GL) SecondaryColorPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glSecondaryColorPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3usv.xml +func (gl *GL) SecondaryColor3usv(v []uint16) { + C.gl2_0_glSecondaryColor3usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3us.xml +func (gl *GL) SecondaryColor3us(red, green, blue uint16) { + C.gl2_0_glSecondaryColor3us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3uiv.xml +func (gl *GL) SecondaryColor3uiv(v []uint32) { + C.gl2_0_glSecondaryColor3uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3ui.xml +func (gl *GL) SecondaryColor3ui(red, green, blue uint32) { + C.gl2_0_glSecondaryColor3ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3ubv.xml +func (gl *GL) SecondaryColor3ubv(v []uint8) { + C.gl2_0_glSecondaryColor3ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3ub.xml +func (gl *GL) SecondaryColor3ub(red, green, blue uint8) { + C.gl2_0_glSecondaryColor3ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3sv.xml +func (gl *GL) SecondaryColor3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_0_glSecondaryColor3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3s.xml +func (gl *GL) SecondaryColor3s(red, green, blue int16) { + C.gl2_0_glSecondaryColor3s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3iv.xml +func (gl *GL) SecondaryColor3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_0_glSecondaryColor3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3i.xml +func (gl *GL) SecondaryColor3i(red, green, blue int32) { + C.gl2_0_glSecondaryColor3i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3fv.xml +func (gl *GL) SecondaryColor3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_0_glSecondaryColor3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3f.xml +func (gl *GL) SecondaryColor3f(red, green, blue float32) { + C.gl2_0_glSecondaryColor3f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3dv.xml +func (gl *GL) SecondaryColor3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_0_glSecondaryColor3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3d.xml +func (gl *GL) SecondaryColor3d(red, green, blue float64) { + C.gl2_0_glSecondaryColor3d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3bv.xml +func (gl *GL) SecondaryColor3bv(v []byte) { + C.gl2_0_glSecondaryColor3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3b.xml +func (gl *GL) SecondaryColor3b(red, green, blue byte) { + C.gl2_0_glSecondaryColor3b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogCoordPointer.xml +func (gl *GL) FogCoordPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl2_0_glFogCoordPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogCoorddv.xml +func (gl *GL) FogCoorddv(coord []float64) { + C.gl2_0_glFogCoorddv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&coord[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogCoordd.xml +func (gl *GL) FogCoordd(coord float64) { + C.gl2_0_glFogCoordd(gl.funcs, C.GLdouble(coord)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogCoordfv.xml +func (gl *GL) FogCoordfv(coord []float32) { + C.gl2_0_glFogCoordfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&coord[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogCoordf.xml +func (gl *GL) FogCoordf(coord float32) { + C.gl2_0_glFogCoordf(gl.funcs, C.GLfloat(coord)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4usv.xml +func (gl *GL) VertexAttrib4usv(index glbase.Attrib, v []uint16) { + C.gl2_0_glVertexAttrib4usv(gl.funcs, C.GLuint(index), (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4uiv.xml +func (gl *GL) VertexAttrib4uiv(index glbase.Attrib, v []uint32) { + C.gl2_0_glVertexAttrib4uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4ubv.xml +func (gl *GL) VertexAttrib4ubv(index glbase.Attrib, v []uint8) { + C.gl2_0_glVertexAttrib4ubv(gl.funcs, C.GLuint(index), (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4sv.xml +func (gl *GL) VertexAttrib4sv(index glbase.Attrib, v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_0_glVertexAttrib4sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4s.xml +func (gl *GL) VertexAttrib4s(index glbase.Attrib, x, y, z, w int16) { + C.gl2_0_glVertexAttrib4s(gl.funcs, C.GLuint(index), C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4iv.xml +func (gl *GL) VertexAttrib4iv(index glbase.Attrib, v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_0_glVertexAttrib4iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4fv.xml +func (gl *GL) VertexAttrib4fv(index glbase.Attrib, v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_0_glVertexAttrib4fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4f.xml +func (gl *GL) VertexAttrib4f(index glbase.Attrib, x, y, z, w float32) { + C.gl2_0_glVertexAttrib4f(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4dv.xml +func (gl *GL) VertexAttrib4dv(index glbase.Attrib, v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_0_glVertexAttrib4dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4d.xml +func (gl *GL) VertexAttrib4d(index glbase.Attrib, x, y, z, w float64) { + C.gl2_0_glVertexAttrib4d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4bv.xml +func (gl *GL) VertexAttrib4bv(index glbase.Attrib, v []byte) { + C.gl2_0_glVertexAttrib4bv(gl.funcs, C.GLuint(index), (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4Nusv.xml +func (gl *GL) VertexAttrib4Nusv(index glbase.Attrib, v []uint16) { + C.gl2_0_glVertexAttrib4Nusv(gl.funcs, C.GLuint(index), (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4Nuiv.xml +func (gl *GL) VertexAttrib4Nuiv(index glbase.Attrib, v []uint32) { + C.gl2_0_glVertexAttrib4Nuiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4Nubv.xml +func (gl *GL) VertexAttrib4Nubv(index glbase.Attrib, v []uint8) { + C.gl2_0_glVertexAttrib4Nubv(gl.funcs, C.GLuint(index), (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4Nub.xml +func (gl *GL) VertexAttrib4Nub(index glbase.Attrib, x, y, z, w uint8) { + C.gl2_0_glVertexAttrib4Nub(gl.funcs, C.GLuint(index), C.GLubyte(x), C.GLubyte(y), C.GLubyte(z), C.GLubyte(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4Nsv.xml +func (gl *GL) VertexAttrib4Nsv(index glbase.Attrib, v []int16) { + C.gl2_0_glVertexAttrib4Nsv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4Niv.xml +func (gl *GL) VertexAttrib4Niv(index glbase.Attrib, v []int32) { + C.gl2_0_glVertexAttrib4Niv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4Nbv.xml +func (gl *GL) VertexAttrib4Nbv(index glbase.Attrib, v []byte) { + C.gl2_0_glVertexAttrib4Nbv(gl.funcs, C.GLuint(index), (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib3sv.xml +func (gl *GL) VertexAttrib3sv(index glbase.Attrib, v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_0_glVertexAttrib3sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib3s.xml +func (gl *GL) VertexAttrib3s(index glbase.Attrib, x, y, z int16) { + C.gl2_0_glVertexAttrib3s(gl.funcs, C.GLuint(index), C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib3fv.xml +func (gl *GL) VertexAttrib3fv(index glbase.Attrib, v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_0_glVertexAttrib3fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib3f.xml +func (gl *GL) VertexAttrib3f(index glbase.Attrib, x, y, z float32) { + C.gl2_0_glVertexAttrib3f(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib3dv.xml +func (gl *GL) VertexAttrib3dv(index glbase.Attrib, v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_0_glVertexAttrib3dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib3d.xml +func (gl *GL) VertexAttrib3d(index glbase.Attrib, x, y, z float64) { + C.gl2_0_glVertexAttrib3d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib2sv.xml +func (gl *GL) VertexAttrib2sv(index glbase.Attrib, v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_0_glVertexAttrib2sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib2s.xml +func (gl *GL) VertexAttrib2s(index glbase.Attrib, x, y int16) { + C.gl2_0_glVertexAttrib2s(gl.funcs, C.GLuint(index), C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib2fv.xml +func (gl *GL) VertexAttrib2fv(index glbase.Attrib, v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_0_glVertexAttrib2fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib2f.xml +func (gl *GL) VertexAttrib2f(index glbase.Attrib, x, y float32) { + C.gl2_0_glVertexAttrib2f(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib2dv.xml +func (gl *GL) VertexAttrib2dv(index glbase.Attrib, v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_0_glVertexAttrib2dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib2d.xml +func (gl *GL) VertexAttrib2d(index glbase.Attrib, x, y float64) { + C.gl2_0_glVertexAttrib2d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib1sv.xml +func (gl *GL) VertexAttrib1sv(index glbase.Attrib, v []int16) { + C.gl2_0_glVertexAttrib1sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib1s.xml +func (gl *GL) VertexAttrib1s(index glbase.Attrib, x int16) { + C.gl2_0_glVertexAttrib1s(gl.funcs, C.GLuint(index), C.GLshort(x)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib1fv.xml +func (gl *GL) VertexAttrib1fv(index glbase.Attrib, v []float32) { + C.gl2_0_glVertexAttrib1fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib1f.xml +func (gl *GL) VertexAttrib1f(index glbase.Attrib, x float32) { + C.gl2_0_glVertexAttrib1f(gl.funcs, C.GLuint(index), C.GLfloat(x)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib1dv.xml +func (gl *GL) VertexAttrib1dv(index glbase.Attrib, v []float64) { + C.gl2_0_glVertexAttrib1dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib1d.xml +func (gl *GL) VertexAttrib1d(index glbase.Attrib, x float64) { + C.gl2_0_glVertexAttrib1d(gl.funcs, C.GLuint(index), C.GLdouble(x)) +} diff --git a/gl/2.1/funcs.cpp b/gl/2.1/funcs.cpp new file mode 100644 index 00000000..6235d6e8 --- /dev/null +++ b/gl/2.1/funcs.cpp @@ -0,0 +1,3480 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#include +#include + +#include "funcs.h" + +void *gl2_1_funcs() { + QOpenGLFunctions_2_1* funcs = QOpenGLContext::currentContext()->versionFunctions(); + if (!funcs) { + return 0; + } + funcs->initializeOpenGLFunctions(); + return funcs; +} + + +void gl2_1_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewport(x, y, width, height); +} + +void gl2_1_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRange(nearVal, farVal); +} + +GLboolean gl2_1_glIsEnabled(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabled(cap); +} + +void gl2_1_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameteriv(target, level, pname, params); +} + +void gl2_1_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameterfv(target, level, pname, params); +} + +void gl2_1_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameteriv(target, pname, params); +} + +void gl2_1_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterfv(target, pname, params); +} + +void gl2_1_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexImage(target, level, format, gltype, pixels); +} + +void gl2_1_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegerv(pname, params); +} + +void gl2_1_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFloatv(pname, params); +} + +GLenum gl2_1_glGetError(void *_glfuncs) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetError(); +} + +void gl2_1_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetDoublev(pname, params); +} + +void gl2_1_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleanv(pname, params); +} + +void gl2_1_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadPixels(x, y, width, height, format, gltype, pixels); +} + +void gl2_1_glReadBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadBuffer(mode); +} + +void gl2_1_glPixelStorei(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStorei(pname, param); +} + +void gl2_1_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStoref(pname, param); +} + +void gl2_1_glDepthFunc(void *_glfuncs, GLenum glfunc) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthFunc(glfunc); +} + +void gl2_1_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOp(fail, zfail, zpass); +} + +void gl2_1_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFunc(glfunc, ref, mask); +} + +void gl2_1_glLogicOp(void *_glfuncs, GLenum opcode) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLogicOp(opcode); +} + +void gl2_1_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFunc(sfactor, dfactor); +} + +void gl2_1_glFlush(void *_glfuncs) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlush(); +} + +void gl2_1_glFinish(void *_glfuncs) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFinish(); +} + +void gl2_1_glEnable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnable(cap); +} + +void gl2_1_glDisable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisable(cap); +} + +void gl2_1_glDepthMask(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthMask(flag); +} + +void gl2_1_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMask(red, green, blue, alpha); +} + +void gl2_1_glStencilMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMask(mask); +} + +void gl2_1_glClearDepth(void *_glfuncs, GLdouble depth) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearDepth(depth); +} + +void gl2_1_glClearStencil(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearStencil(s); +} + +void gl2_1_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearColor(red, green, blue, alpha); +} + +void gl2_1_glClear(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClear(mask); +} + +void gl2_1_glDrawBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffer(mode); +} + +void gl2_1_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage2D(target, level, internalFormat, width, height, border, format, gltype, pixels); +} + +void gl2_1_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage1D(target, level, internalFormat, width, border, format, gltype, pixels); +} + +void gl2_1_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteriv(target, pname, params); +} + +void gl2_1_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteri(target, pname, param); +} + +void gl2_1_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterfv(target, pname, params); +} + +void gl2_1_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterf(target, pname, param); +} + +void gl2_1_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissor(x, y, width, height); +} + +void gl2_1_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonMode(face, mode); +} + +void gl2_1_glPointSize(void *_glfuncs, GLfloat size) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointSize(size); +} + +void gl2_1_glLineWidth(void *_glfuncs, GLfloat width) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineWidth(width); +} + +void gl2_1_glHint(void *_glfuncs, GLenum target, GLenum mode) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glHint(target, mode); +} + +void gl2_1_glFrontFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrontFace(mode); +} + +void gl2_1_glCullFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCullFace(mode); +} + +void gl2_1_glIndexubv(void *_glfuncs, const GLubyte* c) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexubv(c); +} + +void gl2_1_glIndexub(void *_glfuncs, GLubyte c) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexub(c); +} + +GLboolean gl2_1_glIsTexture(void *_glfuncs, GLuint texture) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsTexture(texture); +} + +void gl2_1_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenTextures(n, textures); +} + +void gl2_1_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteTextures(n, textures); +} + +void gl2_1_glBindTexture(void *_glfuncs, GLenum target, GLuint texture) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindTexture(target, texture); +} + +void gl2_1_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, gltype, pixels); +} + +void gl2_1_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage1D(target, level, xoffset, width, format, gltype, pixels); +} + +void gl2_1_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); +} + +void gl2_1_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage1D(target, level, xoffset, x, y, width); +} + +void gl2_1_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage2D(target, level, internalFormat, x, y, width, height, border); +} + +void gl2_1_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage1D(target, level, internalFormat, x, y, width, border); +} + +void gl2_1_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonOffset(factor, units); +} + +void gl2_1_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElements(mode, count, gltype, indices); +} + +void gl2_1_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArrays(mode, first, count); +} + +void gl2_1_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); +} + +void gl2_1_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, gltype, pixels); +} + +void gl2_1_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage3D(target, level, internalFormat, width, height, depth, border, format, gltype, pixels); +} + +void gl2_1_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawRangeElements(mode, start, end, count, gltype, indices); +} + +void gl2_1_glBlendEquation(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquation(mode); +} + +void gl2_1_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendColor(red, green, blue, alpha); +} + +void gl2_1_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetCompressedTexImage(target, level, img); +} + +void gl2_1_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data); +} + +void gl2_1_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); +} + +void gl2_1_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); +} + +void gl2_1_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage1D(target, level, internalFormat, width, border, imageSize, data); +} + +void gl2_1_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data); +} + +void gl2_1_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage3D(target, level, internalFormat, width, height, depth, border, imageSize, data); +} + +void gl2_1_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSampleCoverage(value, invert); +} + +void gl2_1_glActiveTexture(void *_glfuncs, GLenum texture) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glActiveTexture(texture); +} + +void gl2_1_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteriv(pname, params); +} + +void gl2_1_glPointParameteri(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteri(pname, param); +} + +void gl2_1_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterfv(pname, params); +} + +void gl2_1_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterf(pname, param); +} + +void gl2_1_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiDrawArrays(mode, first, count, drawcount); +} + +void gl2_1_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); +} + +void gl2_1_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferParameteriv(target, pname, params); +} + +GLboolean gl2_1_glUnmapBuffer(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glUnmapBuffer(target); +} + +void gl2_1_glGetBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferSubData(target, offset, size, data); +} + +void gl2_1_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferSubData(target, offset, size, data); +} + +void gl2_1_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferData(target, size, data, usage); +} + +GLboolean gl2_1_glIsBuffer(void *_glfuncs, GLuint buffer) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsBuffer(buffer); +} + +void gl2_1_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenBuffers(n, buffers); +} + +void gl2_1_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteBuffers(n, buffers); +} + +void gl2_1_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBuffer(target, buffer); +} + +void gl2_1_glGetQueryObjectuiv(void *_glfuncs, GLuint id, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectuiv(id, pname, params); +} + +void gl2_1_glGetQueryObjectiv(void *_glfuncs, GLuint id, GLenum pname, GLint* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectiv(id, pname, params); +} + +void gl2_1_glGetQueryiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryiv(target, pname, params); +} + +void gl2_1_glEndQuery(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndQuery(target); +} + +void gl2_1_glBeginQuery(void *_glfuncs, GLenum target, GLuint id) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginQuery(target, id); +} + +GLboolean gl2_1_glIsQuery(void *_glfuncs, GLuint id) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsQuery(id); +} + +void gl2_1_glDeleteQueries(void *_glfuncs, GLsizei n, const GLuint* ids) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteQueries(n, ids); +} + +void gl2_1_glGenQueries(void *_glfuncs, GLsizei n, GLuint* ids) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenQueries(n, ids); +} + +void gl2_1_glVertexAttribPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLboolean normalized, GLsizei stride, const GLvoid* offset) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribPointer(index, size, gltype, normalized, stride, offset); +} + +void gl2_1_glValidateProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glValidateProgram(program); +} + +void gl2_1_glUniformMatrix4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4fv(location, count, transpose, value); +} + +void gl2_1_glUniformMatrix3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3fv(location, count, transpose, value); +} + +void gl2_1_glUniformMatrix2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2fv(location, count, transpose, value); +} + +void gl2_1_glUniform4iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4iv(location, count, value); +} + +void gl2_1_glUniform3iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3iv(location, count, value); +} + +void gl2_1_glUniform2iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2iv(location, count, value); +} + +void gl2_1_glUniform1iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1iv(location, count, value); +} + +void gl2_1_glUniform4fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4fv(location, count, value); +} + +void gl2_1_glUniform3fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3fv(location, count, value); +} + +void gl2_1_glUniform2fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2fv(location, count, value); +} + +void gl2_1_glUniform1fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1fv(location, count, value); +} + +void gl2_1_glUniform4i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4i(location, v0, v1, v2, v3); +} + +void gl2_1_glUniform3i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3i(location, v0, v1, v2); +} + +void gl2_1_glUniform2i(void *_glfuncs, GLint location, GLint v0, GLint v1) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2i(location, v0, v1); +} + +void gl2_1_glUniform1i(void *_glfuncs, GLint location, GLint v0) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1i(location, v0); +} + +void gl2_1_glUniform4f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4f(location, v0, v1, v2, v3); +} + +void gl2_1_glUniform3f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3f(location, v0, v1, v2); +} + +void gl2_1_glUniform2f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2f(location, v0, v1); +} + +void gl2_1_glUniform1f(void *_glfuncs, GLint location, GLfloat v0) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1f(location, v0); +} + +void gl2_1_glUseProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUseProgram(program); +} + +void gl2_1_glShaderSource(void *_glfuncs, GLuint shader, GLsizei count, const GLchar** source, const GLint* length) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShaderSource(shader, count, source, length); +} + +void gl2_1_glLinkProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLinkProgram(program); +} + +GLboolean gl2_1_glIsShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsShader(shader); +} + +GLboolean gl2_1_glIsProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsProgram(program); +} + +void gl2_1_glGetVertexAttribiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribiv(index, pname, params); +} + +void gl2_1_glGetVertexAttribfv(void *_glfuncs, GLuint index, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribfv(index, pname, params); +} + +void gl2_1_glGetVertexAttribdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribdv(index, pname, params); +} + +void gl2_1_glGetUniformiv(void *_glfuncs, GLuint program, GLint location, GLint* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformiv(program, location, params); +} + +void gl2_1_glGetUniformfv(void *_glfuncs, GLuint program, GLint location, GLfloat* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformfv(program, location, params); +} + +GLint gl2_1_glGetUniformLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetUniformLocation(program, name); +} + +void gl2_1_glGetShaderSource(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderSource(shader, bufSize, length, source); +} + +void gl2_1_glGetShaderInfoLog(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderInfoLog(shader, bufSize, length, infoLog); +} + +void gl2_1_glGetShaderiv(void *_glfuncs, GLuint shader, GLenum pname, GLint* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderiv(shader, pname, params); +} + +void gl2_1_glGetProgramInfoLog(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramInfoLog(program, bufSize, length, infoLog); +} + +void gl2_1_glGetProgramiv(void *_glfuncs, GLuint program, GLenum pname, GLint* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramiv(program, pname, params); +} + +GLint gl2_1_glGetAttribLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetAttribLocation(program, name); +} + +void gl2_1_glGetAttachedShaders(void *_glfuncs, GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetAttachedShaders(program, maxCount, count, obj); +} + +void gl2_1_glGetActiveUniform(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniform(program, index, bufSize, length, size, gltype, name); +} + +void gl2_1_glGetActiveAttrib(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveAttrib(program, index, bufSize, length, size, gltype, name); +} + +void gl2_1_glEnableVertexAttribArray(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnableVertexAttribArray(index); +} + +void gl2_1_glDisableVertexAttribArray(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisableVertexAttribArray(index); +} + +void gl2_1_glDetachShader(void *_glfuncs, GLuint program, GLuint shader) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDetachShader(program, shader); +} + +void gl2_1_glDeleteShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteShader(shader); +} + +void gl2_1_glDeleteProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteProgram(program); +} + +GLuint gl2_1_glCreateShader(void *_glfuncs, GLenum gltype) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCreateShader(gltype); +} + +GLuint gl2_1_glCreateProgram(void *_glfuncs) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCreateProgram(); +} + +void gl2_1_glCompileShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompileShader(shader); +} + +void gl2_1_glBindAttribLocation(void *_glfuncs, GLuint program, GLuint index, const GLchar* name) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindAttribLocation(program, index, name); +} + +void gl2_1_glAttachShader(void *_glfuncs, GLuint program, GLuint shader) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAttachShader(program, shader); +} + +void gl2_1_glStencilMaskSeparate(void *_glfuncs, GLenum face, GLuint mask) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMaskSeparate(face, mask); +} + +void gl2_1_glStencilFuncSeparate(void *_glfuncs, GLenum face, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFuncSeparate(face, glfunc, ref, mask); +} + +void gl2_1_glStencilOpSeparate(void *_glfuncs, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOpSeparate(face, sfail, dpfail, dppass); +} + +void gl2_1_glDrawBuffers(void *_glfuncs, GLsizei n, const GLenum* bufs) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffers(n, bufs); +} + +void gl2_1_glBlendEquationSeparate(void *_glfuncs, GLenum modeRGB, GLenum modeAlpha) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquationSeparate(modeRGB, modeAlpha); +} + +void gl2_1_glUniformMatrix4x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x3fv(location, count, transpose, value); +} + +void gl2_1_glUniformMatrix3x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x4fv(location, count, transpose, value); +} + +void gl2_1_glUniformMatrix4x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x2fv(location, count, transpose, value); +} + +void gl2_1_glUniformMatrix2x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x4fv(location, count, transpose, value); +} + +void gl2_1_glUniformMatrix3x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x2fv(location, count, transpose, value); +} + +void gl2_1_glUniformMatrix2x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x3fv(location, count, transpose, value); +} + +void gl2_1_glTranslatef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTranslatef(x, y, z); +} + +void gl2_1_glTranslated(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTranslated(x, y, z); +} + +void gl2_1_glScalef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScalef(x, y, z); +} + +void gl2_1_glScaled(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScaled(x, y, z); +} + +void gl2_1_glRotatef(void *_glfuncs, GLfloat angle, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRotatef(angle, x, y, z); +} + +void gl2_1_glRotated(void *_glfuncs, GLdouble angle, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRotated(angle, x, y, z); +} + +void gl2_1_glPushMatrix(void *_glfuncs) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushMatrix(); +} + +void gl2_1_glPopMatrix(void *_glfuncs) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopMatrix(); +} + +void gl2_1_glOrtho(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glOrtho(left, right, bottom, top, zNear, zFar); +} + +void gl2_1_glMultMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultMatrixd(m); +} + +void gl2_1_glMultMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultMatrixf(m); +} + +void gl2_1_glMatrixMode(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMatrixMode(mode); +} + +void gl2_1_glLoadMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadMatrixd(m); +} + +void gl2_1_glLoadMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadMatrixf(m); +} + +void gl2_1_glLoadIdentity(void *_glfuncs) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadIdentity(); +} + +void gl2_1_glFrustum(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrustum(left, right, bottom, top, zNear, zFar); +} + +GLboolean gl2_1_glIsList(void *_glfuncs, GLuint list) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsList(list); +} + +void gl2_1_glGetTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, GLint* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGeniv(coord, pname, params); +} + +void gl2_1_glGetTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGenfv(coord, pname, params); +} + +void gl2_1_glGetTexGendv(void *_glfuncs, GLenum coord, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGendv(coord, pname, params); +} + +void gl2_1_glGetTexEnviv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexEnviv(target, pname, params); +} + +void gl2_1_glGetTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexEnvfv(target, pname, params); +} + +void gl2_1_glGetPolygonStipple(void *_glfuncs, GLubyte* mask) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPolygonStipple(mask); +} + +void gl2_1_glGetPixelMapusv(void *_glfuncs, GLenum glmap, GLushort* values) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapusv(glmap, values); +} + +void gl2_1_glGetPixelMapuiv(void *_glfuncs, GLenum glmap, GLuint* values) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapuiv(glmap, values); +} + +void gl2_1_glGetPixelMapfv(void *_glfuncs, GLenum glmap, GLfloat* values) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapfv(glmap, values); +} + +void gl2_1_glGetMaterialiv(void *_glfuncs, GLenum face, GLenum pname, GLint* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMaterialiv(face, pname, params); +} + +void gl2_1_glGetMaterialfv(void *_glfuncs, GLenum face, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMaterialfv(face, pname, params); +} + +void gl2_1_glGetMapiv(void *_glfuncs, GLenum target, GLenum query, GLint* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapiv(target, query, v); +} + +void gl2_1_glGetMapfv(void *_glfuncs, GLenum target, GLenum query, GLfloat* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapfv(target, query, v); +} + +void gl2_1_glGetMapdv(void *_glfuncs, GLenum target, GLenum query, GLdouble* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapdv(target, query, v); +} + +void gl2_1_glGetLightiv(void *_glfuncs, GLenum light, GLenum pname, GLint* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetLightiv(light, pname, params); +} + +void gl2_1_glGetLightfv(void *_glfuncs, GLenum light, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetLightfv(light, pname, params); +} + +void gl2_1_glGetClipPlane(void *_glfuncs, GLenum plane, GLdouble* equation) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetClipPlane(plane, equation); +} + +void gl2_1_glDrawPixels(void *_glfuncs, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawPixels(width, height, format, gltype, pixels); +} + +void gl2_1_glCopyPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum gltype) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyPixels(x, y, width, height, gltype); +} + +void gl2_1_glPixelMapusv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLushort* values) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapusv(glmap, mapsize, values); +} + +void gl2_1_glPixelMapuiv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLuint* values) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapuiv(glmap, mapsize, values); +} + +void gl2_1_glPixelMapfv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLfloat* values) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapfv(glmap, mapsize, values); +} + +void gl2_1_glPixelTransferi(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelTransferi(pname, param); +} + +void gl2_1_glPixelTransferf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelTransferf(pname, param); +} + +void gl2_1_glPixelZoom(void *_glfuncs, GLfloat xfactor, GLfloat yfactor) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelZoom(xfactor, yfactor); +} + +void gl2_1_glAlphaFunc(void *_glfuncs, GLenum glfunc, GLfloat ref) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAlphaFunc(glfunc, ref); +} + +void gl2_1_glEvalPoint2(void *_glfuncs, GLint i, GLint j) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalPoint2(i, j); +} + +void gl2_1_glEvalMesh2(void *_glfuncs, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalMesh2(mode, i1, i2, j1, j2); +} + +void gl2_1_glEvalPoint1(void *_glfuncs, GLint i) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalPoint1(i); +} + +void gl2_1_glEvalMesh1(void *_glfuncs, GLenum mode, GLint i1, GLint i2) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalMesh1(mode, i1, i2); +} + +void gl2_1_glEvalCoord2fv(void *_glfuncs, const GLfloat* u) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2fv(u); +} + +void gl2_1_glEvalCoord2f(void *_glfuncs, GLfloat u, GLfloat v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2f(u, v); +} + +void gl2_1_glEvalCoord2dv(void *_glfuncs, const GLdouble* u) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2dv(u); +} + +void gl2_1_glEvalCoord2d(void *_glfuncs, GLdouble u, GLdouble v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2d(u, v); +} + +void gl2_1_glEvalCoord1fv(void *_glfuncs, const GLfloat* u) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1fv(u); +} + +void gl2_1_glEvalCoord1f(void *_glfuncs, GLfloat u) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1f(u); +} + +void gl2_1_glEvalCoord1dv(void *_glfuncs, const GLdouble* u) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1dv(u); +} + +void gl2_1_glEvalCoord1d(void *_glfuncs, GLdouble u) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1d(u); +} + +void gl2_1_glMapGrid2f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid2f(un, u1, u2, vn, v1, v2); +} + +void gl2_1_glMapGrid2d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid2d(un, u1, u2, vn, v1, v2); +} + +void gl2_1_glMapGrid1f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid1f(un, u1, u2); +} + +void gl2_1_glMapGrid1d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid1d(un, u1, u2); +} + +void gl2_1_glMap2f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); +} + +void gl2_1_glMap2d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); +} + +void gl2_1_glMap1f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap1f(target, u1, u2, stride, order, points); +} + +void gl2_1_glMap1d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap1d(target, u1, u2, stride, order, points); +} + +void gl2_1_glPushAttrib(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushAttrib(mask); +} + +void gl2_1_glPopAttrib(void *_glfuncs) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopAttrib(); +} + +void gl2_1_glAccum(void *_glfuncs, GLenum op, GLfloat value) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAccum(op, value); +} + +void gl2_1_glIndexMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexMask(mask); +} + +void gl2_1_glClearIndex(void *_glfuncs, GLfloat c) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearIndex(c); +} + +void gl2_1_glClearAccum(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearAccum(red, green, blue, alpha); +} + +void gl2_1_glPushName(void *_glfuncs, GLuint name) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushName(name); +} + +void gl2_1_glPopName(void *_glfuncs) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopName(); +} + +void gl2_1_glPassThrough(void *_glfuncs, GLfloat token) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPassThrough(token); +} + +void gl2_1_glLoadName(void *_glfuncs, GLuint name) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadName(name); +} + +void gl2_1_glInitNames(void *_glfuncs) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInitNames(); +} + +GLint gl2_1_glRenderMode(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glRenderMode(mode); +} + +void gl2_1_glSelectBuffer(void *_glfuncs, GLsizei size, GLuint* buffer) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSelectBuffer(size, buffer); +} + +void gl2_1_glFeedbackBuffer(void *_glfuncs, GLsizei size, GLenum gltype, GLfloat* buffer) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFeedbackBuffer(size, gltype, buffer); +} + +void gl2_1_glTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGeniv(coord, pname, params); +} + +void gl2_1_glTexGeni(void *_glfuncs, GLenum coord, GLenum pname, GLint param) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGeni(coord, pname, param); +} + +void gl2_1_glTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGenfv(coord, pname, params); +} + +void gl2_1_glTexGenf(void *_glfuncs, GLenum coord, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGenf(coord, pname, param); +} + +void gl2_1_glTexGendv(void *_glfuncs, GLenum coord, GLenum pname, const GLdouble* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGendv(coord, pname, params); +} + +void gl2_1_glTexGend(void *_glfuncs, GLenum coord, GLenum pname, GLdouble param) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGend(coord, pname, param); +} + +void gl2_1_glTexEnviv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnviv(target, pname, params); +} + +void gl2_1_glTexEnvi(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvi(target, pname, param); +} + +void gl2_1_glTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvfv(target, pname, params); +} + +void gl2_1_glTexEnvf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvf(target, pname, param); +} + +void gl2_1_glShadeModel(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShadeModel(mode); +} + +void gl2_1_glPolygonStipple(void *_glfuncs, const GLubyte* mask) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonStipple(mask); +} + +void gl2_1_glMaterialiv(void *_glfuncs, GLenum face, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialiv(face, pname, params); +} + +void gl2_1_glMateriali(void *_glfuncs, GLenum face, GLenum pname, GLint param) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMateriali(face, pname, param); +} + +void gl2_1_glMaterialfv(void *_glfuncs, GLenum face, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialfv(face, pname, params); +} + +void gl2_1_glMaterialf(void *_glfuncs, GLenum face, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialf(face, pname, param); +} + +void gl2_1_glLineStipple(void *_glfuncs, GLint factor, GLushort pattern) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineStipple(factor, pattern); +} + +void gl2_1_glLightModeliv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModeliv(pname, params); +} + +void gl2_1_glLightModeli(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModeli(pname, param); +} + +void gl2_1_glLightModelfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModelfv(pname, params); +} + +void gl2_1_glLightModelf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModelf(pname, param); +} + +void gl2_1_glLightiv(void *_glfuncs, GLenum light, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightiv(light, pname, params); +} + +void gl2_1_glLighti(void *_glfuncs, GLenum light, GLenum pname, GLint param) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLighti(light, pname, param); +} + +void gl2_1_glLightfv(void *_glfuncs, GLenum light, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightfv(light, pname, params); +} + +void gl2_1_glLightf(void *_glfuncs, GLenum light, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightf(light, pname, param); +} + +void gl2_1_glFogiv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogiv(pname, params); +} + +void gl2_1_glFogi(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogi(pname, param); +} + +void gl2_1_glFogfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogfv(pname, params); +} + +void gl2_1_glFogf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogf(pname, param); +} + +void gl2_1_glColorMaterial(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMaterial(face, mode); +} + +void gl2_1_glClipPlane(void *_glfuncs, GLenum plane, const GLdouble* equation) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClipPlane(plane, equation); +} + +void gl2_1_glVertex4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4sv(v); +} + +void gl2_1_glVertex4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4s(x, y, z, w); +} + +void gl2_1_glVertex4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4iv(v); +} + +void gl2_1_glVertex4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4i(x, y, z, w); +} + +void gl2_1_glVertex4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4fv(v); +} + +void gl2_1_glVertex4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4f(x, y, z, w); +} + +void gl2_1_glVertex4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4dv(v); +} + +void gl2_1_glVertex4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4d(x, y, z, w); +} + +void gl2_1_glVertex3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3sv(v); +} + +void gl2_1_glVertex3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3s(x, y, z); +} + +void gl2_1_glVertex3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3iv(v); +} + +void gl2_1_glVertex3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3i(x, y, z); +} + +void gl2_1_glVertex3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3fv(v); +} + +void gl2_1_glVertex3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3f(x, y, z); +} + +void gl2_1_glVertex3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3dv(v); +} + +void gl2_1_glVertex3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3d(x, y, z); +} + +void gl2_1_glVertex2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2sv(v); +} + +void gl2_1_glVertex2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2s(x, y); +} + +void gl2_1_glVertex2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2iv(v); +} + +void gl2_1_glVertex2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2i(x, y); +} + +void gl2_1_glVertex2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2fv(v); +} + +void gl2_1_glVertex2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2f(x, y); +} + +void gl2_1_glVertex2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2dv(v); +} + +void gl2_1_glVertex2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2d(x, y); +} + +void gl2_1_glTexCoord4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4sv(v); +} + +void gl2_1_glTexCoord4s(void *_glfuncs, GLshort s, GLshort t, GLshort r, GLshort q) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4s(s, t, r, q); +} + +void gl2_1_glTexCoord4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4iv(v); +} + +void gl2_1_glTexCoord4i(void *_glfuncs, GLint s, GLint t, GLint r, GLint q) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4i(s, t, r, q); +} + +void gl2_1_glTexCoord4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4fv(v); +} + +void gl2_1_glTexCoord4f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4f(s, t, r, q); +} + +void gl2_1_glTexCoord4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4dv(v); +} + +void gl2_1_glTexCoord4d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r, GLdouble q) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4d(s, t, r, q); +} + +void gl2_1_glTexCoord3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3sv(v); +} + +void gl2_1_glTexCoord3s(void *_glfuncs, GLshort s, GLshort t, GLshort r) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3s(s, t, r); +} + +void gl2_1_glTexCoord3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3iv(v); +} + +void gl2_1_glTexCoord3i(void *_glfuncs, GLint s, GLint t, GLint r) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3i(s, t, r); +} + +void gl2_1_glTexCoord3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3fv(v); +} + +void gl2_1_glTexCoord3f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3f(s, t, r); +} + +void gl2_1_glTexCoord3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3dv(v); +} + +void gl2_1_glTexCoord3d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3d(s, t, r); +} + +void gl2_1_glTexCoord2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2sv(v); +} + +void gl2_1_glTexCoord2s(void *_glfuncs, GLshort s, GLshort t) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2s(s, t); +} + +void gl2_1_glTexCoord2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2iv(v); +} + +void gl2_1_glTexCoord2i(void *_glfuncs, GLint s, GLint t) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2i(s, t); +} + +void gl2_1_glTexCoord2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2fv(v); +} + +void gl2_1_glTexCoord2f(void *_glfuncs, GLfloat s, GLfloat t) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2f(s, t); +} + +void gl2_1_glTexCoord2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2dv(v); +} + +void gl2_1_glTexCoord2d(void *_glfuncs, GLdouble s, GLdouble t) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2d(s, t); +} + +void gl2_1_glTexCoord1sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1sv(v); +} + +void gl2_1_glTexCoord1s(void *_glfuncs, GLshort s) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1s(s); +} + +void gl2_1_glTexCoord1iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1iv(v); +} + +void gl2_1_glTexCoord1i(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1i(s); +} + +void gl2_1_glTexCoord1fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1fv(v); +} + +void gl2_1_glTexCoord1f(void *_glfuncs, GLfloat s) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1f(s); +} + +void gl2_1_glTexCoord1dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1dv(v); +} + +void gl2_1_glTexCoord1d(void *_glfuncs, GLdouble s) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1d(s); +} + +void gl2_1_glRectsv(void *_glfuncs, const GLshort* v1, const GLshort* v2) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectsv(v1, v2); +} + +void gl2_1_glRects(void *_glfuncs, GLshort x1, GLshort y1, GLshort x2, GLshort y2) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRects(x1, y1, x2, y2); +} + +void gl2_1_glRectiv(void *_glfuncs, const GLint* v1, const GLint* v2) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectiv(v1, v2); +} + +void gl2_1_glRecti(void *_glfuncs, GLint x1, GLint y1, GLint x2, GLint y2) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRecti(x1, y1, x2, y2); +} + +void gl2_1_glRectfv(void *_glfuncs, const GLfloat* v1, const GLfloat* v2) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectfv(v1, v2); +} + +void gl2_1_glRectf(void *_glfuncs, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectf(x1, y1, x2, y2); +} + +void gl2_1_glRectdv(void *_glfuncs, const GLdouble* v1, const GLdouble* v2) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectdv(v1, v2); +} + +void gl2_1_glRectd(void *_glfuncs, GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectd(x1, y1, x2, y2); +} + +void gl2_1_glRasterPos4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4sv(v); +} + +void gl2_1_glRasterPos4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4s(x, y, z, w); +} + +void gl2_1_glRasterPos4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4iv(v); +} + +void gl2_1_glRasterPos4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4i(x, y, z, w); +} + +void gl2_1_glRasterPos4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4fv(v); +} + +void gl2_1_glRasterPos4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4f(x, y, z, w); +} + +void gl2_1_glRasterPos4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4dv(v); +} + +void gl2_1_glRasterPos4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4d(x, y, z, w); +} + +void gl2_1_glRasterPos3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3sv(v); +} + +void gl2_1_glRasterPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3s(x, y, z); +} + +void gl2_1_glRasterPos3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3iv(v); +} + +void gl2_1_glRasterPos3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3i(x, y, z); +} + +void gl2_1_glRasterPos3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3fv(v); +} + +void gl2_1_glRasterPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3f(x, y, z); +} + +void gl2_1_glRasterPos3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3dv(v); +} + +void gl2_1_glRasterPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3d(x, y, z); +} + +void gl2_1_glRasterPos2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2sv(v); +} + +void gl2_1_glRasterPos2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2s(x, y); +} + +void gl2_1_glRasterPos2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2iv(v); +} + +void gl2_1_glRasterPos2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2i(x, y); +} + +void gl2_1_glRasterPos2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2fv(v); +} + +void gl2_1_glRasterPos2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2f(x, y); +} + +void gl2_1_glRasterPos2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2dv(v); +} + +void gl2_1_glRasterPos2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2d(x, y); +} + +void gl2_1_glNormal3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3sv(v); +} + +void gl2_1_glNormal3s(void *_glfuncs, GLshort nx, GLshort ny, GLshort nz) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3s(nx, ny, nz); +} + +void gl2_1_glNormal3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3iv(v); +} + +void gl2_1_glNormal3i(void *_glfuncs, GLint nx, GLint ny, GLint nz) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3i(nx, ny, nz); +} + +void gl2_1_glNormal3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3fv(v); +} + +void gl2_1_glNormal3f(void *_glfuncs, GLfloat nx, GLfloat ny, GLfloat nz) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3f(nx, ny, nz); +} + +void gl2_1_glNormal3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3dv(v); +} + +void gl2_1_glNormal3d(void *_glfuncs, GLdouble nx, GLdouble ny, GLdouble nz) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3d(nx, ny, nz); +} + +void gl2_1_glNormal3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3bv(v); +} + +void gl2_1_glNormal3b(void *_glfuncs, GLbyte nx, GLbyte ny, GLbyte nz) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3b(nx, ny, nz); +} + +void gl2_1_glIndexsv(void *_glfuncs, const GLshort* c) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexsv(c); +} + +void gl2_1_glIndexs(void *_glfuncs, GLshort c) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexs(c); +} + +void gl2_1_glIndexiv(void *_glfuncs, const GLint* c) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexiv(c); +} + +void gl2_1_glIndexi(void *_glfuncs, GLint c) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexi(c); +} + +void gl2_1_glIndexfv(void *_glfuncs, const GLfloat* c) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexfv(c); +} + +void gl2_1_glIndexf(void *_glfuncs, GLfloat c) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexf(c); +} + +void gl2_1_glIndexdv(void *_glfuncs, const GLdouble* c) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexdv(c); +} + +void gl2_1_glIndexd(void *_glfuncs, GLdouble c) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexd(c); +} + +void gl2_1_glEnd(void *_glfuncs) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnd(); +} + +void gl2_1_glEdgeFlagv(void *_glfuncs, const GLboolean* flag) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlagv(flag); +} + +void gl2_1_glEdgeFlag(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlag(flag); +} + +void gl2_1_glColor4usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4usv(v); +} + +void gl2_1_glColor4us(void *_glfuncs, GLushort red, GLushort green, GLushort blue, GLushort alpha) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4us(red, green, blue, alpha); +} + +void gl2_1_glColor4uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4uiv(v); +} + +void gl2_1_glColor4ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue, GLuint alpha) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ui(red, green, blue, alpha); +} + +void gl2_1_glColor4ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ubv(v); +} + +void gl2_1_glColor4ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ub(red, green, blue, alpha); +} + +void gl2_1_glColor4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4sv(v); +} + +void gl2_1_glColor4s(void *_glfuncs, GLshort red, GLshort green, GLshort blue, GLshort alpha) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4s(red, green, blue, alpha); +} + +void gl2_1_glColor4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4iv(v); +} + +void gl2_1_glColor4i(void *_glfuncs, GLint red, GLint green, GLint blue, GLint alpha) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4i(red, green, blue, alpha); +} + +void gl2_1_glColor4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4fv(v); +} + +void gl2_1_glColor4f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4f(red, green, blue, alpha); +} + +void gl2_1_glColor4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4dv(v); +} + +void gl2_1_glColor4d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4d(red, green, blue, alpha); +} + +void gl2_1_glColor4bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4bv(v); +} + +void gl2_1_glColor4b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4b(red, green, blue, alpha); +} + +void gl2_1_glColor3usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3usv(v); +} + +void gl2_1_glColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3us(red, green, blue); +} + +void gl2_1_glColor3uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3uiv(v); +} + +void gl2_1_glColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ui(red, green, blue); +} + +void gl2_1_glColor3ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ubv(v); +} + +void gl2_1_glColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ub(red, green, blue); +} + +void gl2_1_glColor3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3sv(v); +} + +void gl2_1_glColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3s(red, green, blue); +} + +void gl2_1_glColor3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3iv(v); +} + +void gl2_1_glColor3i(void *_glfuncs, GLint red, GLint green, GLint blue) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3i(red, green, blue); +} + +void gl2_1_glColor3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3fv(v); +} + +void gl2_1_glColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3f(red, green, blue); +} + +void gl2_1_glColor3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3dv(v); +} + +void gl2_1_glColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3d(red, green, blue); +} + +void gl2_1_glColor3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3bv(v); +} + +void gl2_1_glColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3b(red, green, blue); +} + +void gl2_1_glBitmap(void *_glfuncs, GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBitmap(width, height, xorig, yorig, xmove, ymove, bitmap); +} + +void gl2_1_glBegin(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBegin(mode); +} + +void gl2_1_glListBase(void *_glfuncs, GLuint base) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glListBase(base); +} + +GLuint gl2_1_glGenLists(void *_glfuncs, GLsizei range_) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGenLists(range_); +} + +void gl2_1_glDeleteLists(void *_glfuncs, GLuint list, GLsizei range_) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteLists(list, range_); +} + +void gl2_1_glCallLists(void *_glfuncs, GLsizei n, GLenum gltype, const GLvoid* lists) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCallLists(n, gltype, lists); +} + +void gl2_1_glCallList(void *_glfuncs, GLuint list) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCallList(list); +} + +void gl2_1_glEndList(void *_glfuncs) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndList(); +} + +void gl2_1_glNewList(void *_glfuncs, GLuint list, GLenum mode) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNewList(list, mode); +} + +void gl2_1_glPushClientAttrib(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushClientAttrib(mask); +} + +void gl2_1_glPopClientAttrib(void *_glfuncs) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopClientAttrib(); +} + +void gl2_1_glPrioritizeTextures(void *_glfuncs, GLsizei n, const GLuint* textures, const GLfloat* priorities) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPrioritizeTextures(n, textures, priorities); +} + +GLboolean gl2_1_glAreTexturesResident(void *_glfuncs, GLsizei n, const GLuint* textures, GLboolean* residences) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glAreTexturesResident(n, textures, residences); +} + +void gl2_1_glVertexPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexPointer(size, gltype, stride, pointer); +} + +void gl2_1_glTexCoordPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordPointer(size, gltype, stride, pointer); +} + +void gl2_1_glNormalPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormalPointer(gltype, stride, pointer); +} + +void gl2_1_glInterleavedArrays(void *_glfuncs, GLenum format, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInterleavedArrays(format, stride, pointer); +} + +void gl2_1_glIndexPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexPointer(gltype, stride, pointer); +} + +void gl2_1_glEnableClientState(void *_glfuncs, GLenum array) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnableClientState(array); +} + +void gl2_1_glEdgeFlagPointer(void *_glfuncs, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlagPointer(stride, pointer); +} + +void gl2_1_glDisableClientState(void *_glfuncs, GLenum array) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisableClientState(array); +} + +void gl2_1_glColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorPointer(size, gltype, stride, pointer); +} + +void gl2_1_glArrayElement(void *_glfuncs, GLint i) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glArrayElement(i); +} + +void gl2_1_glResetMinmax(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glResetMinmax(target); +} + +void gl2_1_glResetHistogram(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glResetHistogram(target); +} + +void gl2_1_glMinmax(void *_glfuncs, GLenum target, GLenum internalFormat, GLboolean sink) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMinmax(target, internalFormat, sink); +} + +void gl2_1_glHistogram(void *_glfuncs, GLenum target, GLsizei width, GLenum internalFormat, GLboolean sink) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glHistogram(target, width, internalFormat, sink); +} + +void gl2_1_glGetMinmaxParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmaxParameteriv(target, pname, params); +} + +void gl2_1_glGetMinmaxParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmaxParameterfv(target, pname, params); +} + +void gl2_1_glGetMinmax(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmax(target, reset, format, gltype, values); +} + +void gl2_1_glGetHistogramParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogramParameteriv(target, pname, params); +} + +void gl2_1_glGetHistogramParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogramParameterfv(target, pname, params); +} + +void gl2_1_glGetHistogram(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogram(target, reset, format, gltype, values); +} + +void gl2_1_glSeparableFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* row, const GLvoid* column) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSeparableFilter2D(target, internalFormat, width, height, format, gltype, row, column); +} + +void gl2_1_glGetSeparableFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* row, GLvoid* column, GLvoid* span) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSeparableFilter(target, format, gltype, row, column, span); +} + +void gl2_1_glGetConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionParameteriv(target, pname, params); +} + +void gl2_1_glGetConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionParameterfv(target, pname, params); +} + +void gl2_1_glGetConvolutionFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* image) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionFilter(target, format, gltype, image); +} + +void gl2_1_glCopyConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyConvolutionFilter2D(target, internalFormat, x, y, width, height); +} + +void gl2_1_glCopyConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyConvolutionFilter1D(target, internalFormat, x, y, width); +} + +void gl2_1_glConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameteriv(target, pname, params); +} + +void gl2_1_glConvolutionParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameteri(target, pname, params); +} + +void gl2_1_glConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameterfv(target, pname, params); +} + +void gl2_1_glConvolutionParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameterf(target, pname, params); +} + +void gl2_1_glConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* image) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionFilter2D(target, internalFormat, width, height, format, gltype, image); +} + +void gl2_1_glConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* image) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionFilter1D(target, internalFormat, width, format, gltype, image); +} + +void gl2_1_glCopyColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyColorSubTable(target, start, x, y, width); +} + +void gl2_1_glColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum gltype, const GLvoid* data) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorSubTable(target, start, count, format, gltype, data); +} + +void gl2_1_glGetColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTableParameteriv(target, pname, params); +} + +void gl2_1_glGetColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTableParameterfv(target, pname, params); +} + +void gl2_1_glGetColorTable(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* table) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTable(target, format, gltype, table); +} + +void gl2_1_glCopyColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyColorTable(target, internalFormat, x, y, width); +} + +void gl2_1_glColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTableParameteriv(target, pname, params); +} + +void gl2_1_glColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTableParameterfv(target, pname, params); +} + +void gl2_1_glColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* table) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTable(target, internalFormat, width, format, gltype, table); +} + +void gl2_1_glMultTransposeMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultTransposeMatrixd(m); +} + +void gl2_1_glMultTransposeMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultTransposeMatrixf(m); +} + +void gl2_1_glLoadTransposeMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadTransposeMatrixd(m); +} + +void gl2_1_glLoadTransposeMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadTransposeMatrixf(m); +} + +void gl2_1_glMultiTexCoord4sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4sv(target, v); +} + +void gl2_1_glMultiTexCoord4s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r, GLshort q) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4s(target, s, t, r, q); +} + +void gl2_1_glMultiTexCoord4iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4iv(target, v); +} + +void gl2_1_glMultiTexCoord4i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r, GLint q) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4i(target, s, t, r, q); +} + +void gl2_1_glMultiTexCoord4fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4fv(target, v); +} + +void gl2_1_glMultiTexCoord4f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4f(target, s, t, r, q); +} + +void gl2_1_glMultiTexCoord4dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4dv(target, v); +} + +void gl2_1_glMultiTexCoord4d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4d(target, s, t, r, q); +} + +void gl2_1_glMultiTexCoord3sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3sv(target, v); +} + +void gl2_1_glMultiTexCoord3s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3s(target, s, t, r); +} + +void gl2_1_glMultiTexCoord3iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3iv(target, v); +} + +void gl2_1_glMultiTexCoord3i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3i(target, s, t, r); +} + +void gl2_1_glMultiTexCoord3fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3fv(target, v); +} + +void gl2_1_glMultiTexCoord3f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3f(target, s, t, r); +} + +void gl2_1_glMultiTexCoord3dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3dv(target, v); +} + +void gl2_1_glMultiTexCoord3d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3d(target, s, t, r); +} + +void gl2_1_glMultiTexCoord2sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2sv(target, v); +} + +void gl2_1_glMultiTexCoord2s(void *_glfuncs, GLenum target, GLshort s, GLshort t) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2s(target, s, t); +} + +void gl2_1_glMultiTexCoord2iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2iv(target, v); +} + +void gl2_1_glMultiTexCoord2i(void *_glfuncs, GLenum target, GLint s, GLint t) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2i(target, s, t); +} + +void gl2_1_glMultiTexCoord2fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2fv(target, v); +} + +void gl2_1_glMultiTexCoord2f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2f(target, s, t); +} + +void gl2_1_glMultiTexCoord2dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2dv(target, v); +} + +void gl2_1_glMultiTexCoord2d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2d(target, s, t); +} + +void gl2_1_glMultiTexCoord1sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1sv(target, v); +} + +void gl2_1_glMultiTexCoord1s(void *_glfuncs, GLenum target, GLshort s) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1s(target, s); +} + +void gl2_1_glMultiTexCoord1iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1iv(target, v); +} + +void gl2_1_glMultiTexCoord1i(void *_glfuncs, GLenum target, GLint s) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1i(target, s); +} + +void gl2_1_glMultiTexCoord1fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1fv(target, v); +} + +void gl2_1_glMultiTexCoord1f(void *_glfuncs, GLenum target, GLfloat s) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1f(target, s); +} + +void gl2_1_glMultiTexCoord1dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1dv(target, v); +} + +void gl2_1_glMultiTexCoord1d(void *_glfuncs, GLenum target, GLdouble s) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1d(target, s); +} + +void gl2_1_glClientActiveTexture(void *_glfuncs, GLenum texture) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClientActiveTexture(texture); +} + +void gl2_1_glWindowPos3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3sv(v); +} + +void gl2_1_glWindowPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3s(x, y, z); +} + +void gl2_1_glWindowPos3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3iv(v); +} + +void gl2_1_glWindowPos3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3i(x, y, z); +} + +void gl2_1_glWindowPos3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3fv(v); +} + +void gl2_1_glWindowPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3f(x, y, z); +} + +void gl2_1_glWindowPos3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3dv(v); +} + +void gl2_1_glWindowPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3d(x, y, z); +} + +void gl2_1_glWindowPos2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2sv(v); +} + +void gl2_1_glWindowPos2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2s(x, y); +} + +void gl2_1_glWindowPos2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2iv(v); +} + +void gl2_1_glWindowPos2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2i(x, y); +} + +void gl2_1_glWindowPos2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2fv(v); +} + +void gl2_1_glWindowPos2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2f(x, y); +} + +void gl2_1_glWindowPos2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2dv(v); +} + +void gl2_1_glWindowPos2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2d(x, y); +} + +void gl2_1_glSecondaryColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColorPointer(size, gltype, stride, pointer); +} + +void gl2_1_glSecondaryColor3usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3usv(v); +} + +void gl2_1_glSecondaryColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3us(red, green, blue); +} + +void gl2_1_glSecondaryColor3uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3uiv(v); +} + +void gl2_1_glSecondaryColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3ui(red, green, blue); +} + +void gl2_1_glSecondaryColor3ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3ubv(v); +} + +void gl2_1_glSecondaryColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3ub(red, green, blue); +} + +void gl2_1_glSecondaryColor3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3sv(v); +} + +void gl2_1_glSecondaryColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3s(red, green, blue); +} + +void gl2_1_glSecondaryColor3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3iv(v); +} + +void gl2_1_glSecondaryColor3i(void *_glfuncs, GLint red, GLint green, GLint blue) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3i(red, green, blue); +} + +void gl2_1_glSecondaryColor3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3fv(v); +} + +void gl2_1_glSecondaryColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3f(red, green, blue); +} + +void gl2_1_glSecondaryColor3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3dv(v); +} + +void gl2_1_glSecondaryColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3d(red, green, blue); +} + +void gl2_1_glSecondaryColor3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3bv(v); +} + +void gl2_1_glSecondaryColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3b(red, green, blue); +} + +void gl2_1_glFogCoordPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordPointer(gltype, stride, pointer); +} + +void gl2_1_glFogCoorddv(void *_glfuncs, const GLdouble* coord) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoorddv(coord); +} + +void gl2_1_glFogCoordd(void *_glfuncs, GLdouble coord) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordd(coord); +} + +void gl2_1_glFogCoordfv(void *_glfuncs, const GLfloat* coord) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordfv(coord); +} + +void gl2_1_glFogCoordf(void *_glfuncs, GLfloat coord) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordf(coord); +} + +void gl2_1_glVertexAttrib4usv(void *_glfuncs, GLuint index, const GLushort* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4usv(index, v); +} + +void gl2_1_glVertexAttrib4uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4uiv(index, v); +} + +void gl2_1_glVertexAttrib4ubv(void *_glfuncs, GLuint index, const GLubyte* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4ubv(index, v); +} + +void gl2_1_glVertexAttrib4sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4sv(index, v); +} + +void gl2_1_glVertexAttrib4s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4s(index, x, y, z, w); +} + +void gl2_1_glVertexAttrib4iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4iv(index, v); +} + +void gl2_1_glVertexAttrib4fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4fv(index, v); +} + +void gl2_1_glVertexAttrib4f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4f(index, x, y, z, w); +} + +void gl2_1_glVertexAttrib4dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4dv(index, v); +} + +void gl2_1_glVertexAttrib4d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4d(index, x, y, z, w); +} + +void gl2_1_glVertexAttrib4bv(void *_glfuncs, GLuint index, const GLbyte* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4bv(index, v); +} + +void gl2_1_glVertexAttrib4Nusv(void *_glfuncs, GLuint index, const GLushort* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nusv(index, v); +} + +void gl2_1_glVertexAttrib4Nuiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nuiv(index, v); +} + +void gl2_1_glVertexAttrib4Nubv(void *_glfuncs, GLuint index, const GLubyte* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nubv(index, v); +} + +void gl2_1_glVertexAttrib4Nub(void *_glfuncs, GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nub(index, x, y, z, w); +} + +void gl2_1_glVertexAttrib4Nsv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nsv(index, v); +} + +void gl2_1_glVertexAttrib4Niv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Niv(index, v); +} + +void gl2_1_glVertexAttrib4Nbv(void *_glfuncs, GLuint index, const GLbyte* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nbv(index, v); +} + +void gl2_1_glVertexAttrib3sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3sv(index, v); +} + +void gl2_1_glVertexAttrib3s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3s(index, x, y, z); +} + +void gl2_1_glVertexAttrib3fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3fv(index, v); +} + +void gl2_1_glVertexAttrib3f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3f(index, x, y, z); +} + +void gl2_1_glVertexAttrib3dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3dv(index, v); +} + +void gl2_1_glVertexAttrib3d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3d(index, x, y, z); +} + +void gl2_1_glVertexAttrib2sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2sv(index, v); +} + +void gl2_1_glVertexAttrib2s(void *_glfuncs, GLuint index, GLshort x, GLshort y) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2s(index, x, y); +} + +void gl2_1_glVertexAttrib2fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2fv(index, v); +} + +void gl2_1_glVertexAttrib2f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2f(index, x, y); +} + +void gl2_1_glVertexAttrib2dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2dv(index, v); +} + +void gl2_1_glVertexAttrib2d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2d(index, x, y); +} + +void gl2_1_glVertexAttrib1sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1sv(index, v); +} + +void gl2_1_glVertexAttrib1s(void *_glfuncs, GLuint index, GLshort x) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1s(index, x); +} + +void gl2_1_glVertexAttrib1fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1fv(index, v); +} + +void gl2_1_glVertexAttrib1f(void *_glfuncs, GLuint index, GLfloat x) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1f(index, x); +} + +void gl2_1_glVertexAttrib1dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1dv(index, v); +} + +void gl2_1_glVertexAttrib1d(void *_glfuncs, GLuint index, GLdouble x) +{ + QOpenGLFunctions_2_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1d(index, x); +} + diff --git a/gl/2.1/funcs.h b/gl/2.1/funcs.h new file mode 100644 index 00000000..39978450 --- /dev/null +++ b/gl/2.1/funcs.h @@ -0,0 +1,619 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#ifndef __cplusplus +#include +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef char GLchar; +typedef signed char GLbyte; /* 1-byte signed */ +typedef short GLshort; /* 2-byte signed */ +typedef int GLint; /* 4-byte signed */ +typedef unsigned char GLubyte; /* 1-byte unsigned */ +typedef unsigned short GLushort; /* 2-byte unsigned */ +typedef unsigned int GLuint; /* 4-byte unsigned */ +typedef int GLsizei; /* 4-byte signed */ +typedef float GLfloat; /* single precision float */ +typedef float GLclampf; /* single precision float in [0,1] */ +typedef double GLdouble; /* double precision float */ +typedef double GLclampd; /* double precision float in [0,1] */ +typedef int64_t GLint64; +typedef uint64_t GLuint64; +typedef ptrdiff_t GLintptr; +typedef ptrdiff_t GLsizeiptr; +typedef ptrdiff_t GLintptrARB; +typedef ptrdiff_t GLsizeiptrARB; +typedef struct __GLsync *GLsync; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +void *gl2_1_funcs(); + +void gl2_1_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl2_1_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal); +GLboolean gl2_1_glIsEnabled(void *_glfuncs, GLenum cap); +void gl2_1_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params); +void gl2_1_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params); +void gl2_1_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl2_1_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl2_1_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels); +void gl2_1_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params); +void gl2_1_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params); +GLenum gl2_1_glGetError(void *_glfuncs); +void gl2_1_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params); +void gl2_1_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params); +void gl2_1_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels); +void gl2_1_glReadBuffer(void *_glfuncs, GLenum mode); +void gl2_1_glPixelStorei(void *_glfuncs, GLenum pname, GLint param); +void gl2_1_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param); +void gl2_1_glDepthFunc(void *_glfuncs, GLenum glfunc); +void gl2_1_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass); +void gl2_1_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask); +void gl2_1_glLogicOp(void *_glfuncs, GLenum opcode); +void gl2_1_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor); +void gl2_1_glFlush(void *_glfuncs); +void gl2_1_glFinish(void *_glfuncs); +void gl2_1_glEnable(void *_glfuncs, GLenum cap); +void gl2_1_glDisable(void *_glfuncs, GLenum cap); +void gl2_1_glDepthMask(void *_glfuncs, GLboolean flag); +void gl2_1_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +void gl2_1_glStencilMask(void *_glfuncs, GLuint mask); +void gl2_1_glClearDepth(void *_glfuncs, GLdouble depth); +void gl2_1_glClearStencil(void *_glfuncs, GLint s); +void gl2_1_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl2_1_glClear(void *_glfuncs, GLbitfield mask); +void gl2_1_glDrawBuffer(void *_glfuncs, GLenum mode); +void gl2_1_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl2_1_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl2_1_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl2_1_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl2_1_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl2_1_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl2_1_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl2_1_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode); +void gl2_1_glPointSize(void *_glfuncs, GLfloat size); +void gl2_1_glLineWidth(void *_glfuncs, GLfloat width); +void gl2_1_glHint(void *_glfuncs, GLenum target, GLenum mode); +void gl2_1_glFrontFace(void *_glfuncs, GLenum mode); +void gl2_1_glCullFace(void *_glfuncs, GLenum mode); +void gl2_1_glIndexubv(void *_glfuncs, const GLubyte* c); +void gl2_1_glIndexub(void *_glfuncs, GLubyte c); +GLboolean gl2_1_glIsTexture(void *_glfuncs, GLuint texture); +void gl2_1_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures); +void gl2_1_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures); +void gl2_1_glBindTexture(void *_glfuncs, GLenum target, GLuint texture); +void gl2_1_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl2_1_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl2_1_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl2_1_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +void gl2_1_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +void gl2_1_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border); +void gl2_1_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units); +void gl2_1_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl2_1_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count); +void gl2_1_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl2_1_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl2_1_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl2_1_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl2_1_glBlendEquation(void *_glfuncs, GLenum mode); +void gl2_1_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl2_1_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img); +void gl2_1_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl2_1_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl2_1_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl2_1_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data); +void gl2_1_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data); +void gl2_1_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data); +void gl2_1_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert); +void gl2_1_glActiveTexture(void *_glfuncs, GLenum texture); +void gl2_1_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params); +void gl2_1_glPointParameteri(void *_glfuncs, GLenum pname, GLint param); +void gl2_1_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl2_1_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param); +void gl2_1_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount); +void gl2_1_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +void gl2_1_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +GLboolean gl2_1_glUnmapBuffer(void *_glfuncs, GLenum target); +void gl2_1_glGetBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data); +void gl2_1_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data); +void gl2_1_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage); +GLboolean gl2_1_glIsBuffer(void *_glfuncs, GLuint buffer); +void gl2_1_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers); +void gl2_1_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers); +void gl2_1_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer); +void gl2_1_glGetQueryObjectuiv(void *_glfuncs, GLuint id, GLenum pname, GLuint* params); +void gl2_1_glGetQueryObjectiv(void *_glfuncs, GLuint id, GLenum pname, GLint* params); +void gl2_1_glGetQueryiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl2_1_glEndQuery(void *_glfuncs, GLenum target); +void gl2_1_glBeginQuery(void *_glfuncs, GLenum target, GLuint id); +GLboolean gl2_1_glIsQuery(void *_glfuncs, GLuint id); +void gl2_1_glDeleteQueries(void *_glfuncs, GLsizei n, const GLuint* ids); +void gl2_1_glGenQueries(void *_glfuncs, GLsizei n, GLuint* ids); +void gl2_1_glVertexAttribPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLboolean normalized, GLsizei stride, const GLvoid* offset); +void gl2_1_glValidateProgram(void *_glfuncs, GLuint program); +void gl2_1_glUniformMatrix4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl2_1_glUniformMatrix3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl2_1_glUniformMatrix2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl2_1_glUniform4iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl2_1_glUniform3iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl2_1_glUniform2iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl2_1_glUniform1iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl2_1_glUniform4fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl2_1_glUniform3fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl2_1_glUniform2fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl2_1_glUniform1fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl2_1_glUniform4i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +void gl2_1_glUniform3i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2); +void gl2_1_glUniform2i(void *_glfuncs, GLint location, GLint v0, GLint v1); +void gl2_1_glUniform1i(void *_glfuncs, GLint location, GLint v0); +void gl2_1_glUniform4f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +void gl2_1_glUniform3f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +void gl2_1_glUniform2f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1); +void gl2_1_glUniform1f(void *_glfuncs, GLint location, GLfloat v0); +void gl2_1_glUseProgram(void *_glfuncs, GLuint program); +void gl2_1_glShaderSource(void *_glfuncs, GLuint shader, GLsizei count, const GLchar** source, const GLint* length); +void gl2_1_glLinkProgram(void *_glfuncs, GLuint program); +GLboolean gl2_1_glIsShader(void *_glfuncs, GLuint shader); +GLboolean gl2_1_glIsProgram(void *_glfuncs, GLuint program); +void gl2_1_glGetVertexAttribiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params); +void gl2_1_glGetVertexAttribfv(void *_glfuncs, GLuint index, GLenum pname, GLfloat* params); +void gl2_1_glGetVertexAttribdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params); +void gl2_1_glGetUniformiv(void *_glfuncs, GLuint program, GLint location, GLint* params); +void gl2_1_glGetUniformfv(void *_glfuncs, GLuint program, GLint location, GLfloat* params); +GLint gl2_1_glGetUniformLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl2_1_glGetShaderSource(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source); +void gl2_1_glGetShaderInfoLog(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl2_1_glGetShaderiv(void *_glfuncs, GLuint shader, GLenum pname, GLint* params); +void gl2_1_glGetProgramInfoLog(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl2_1_glGetProgramiv(void *_glfuncs, GLuint program, GLenum pname, GLint* params); +GLint gl2_1_glGetAttribLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl2_1_glGetAttachedShaders(void *_glfuncs, GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj); +void gl2_1_glGetActiveUniform(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name); +void gl2_1_glGetActiveAttrib(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name); +void gl2_1_glEnableVertexAttribArray(void *_glfuncs, GLuint index); +void gl2_1_glDisableVertexAttribArray(void *_glfuncs, GLuint index); +void gl2_1_glDetachShader(void *_glfuncs, GLuint program, GLuint shader); +void gl2_1_glDeleteShader(void *_glfuncs, GLuint shader); +void gl2_1_glDeleteProgram(void *_glfuncs, GLuint program); +GLuint gl2_1_glCreateShader(void *_glfuncs, GLenum gltype); +GLuint gl2_1_glCreateProgram(void *_glfuncs); +void gl2_1_glCompileShader(void *_glfuncs, GLuint shader); +void gl2_1_glBindAttribLocation(void *_glfuncs, GLuint program, GLuint index, const GLchar* name); +void gl2_1_glAttachShader(void *_glfuncs, GLuint program, GLuint shader); +void gl2_1_glStencilMaskSeparate(void *_glfuncs, GLenum face, GLuint mask); +void gl2_1_glStencilFuncSeparate(void *_glfuncs, GLenum face, GLenum glfunc, GLint ref, GLuint mask); +void gl2_1_glStencilOpSeparate(void *_glfuncs, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +void gl2_1_glDrawBuffers(void *_glfuncs, GLsizei n, const GLenum* bufs); +void gl2_1_glBlendEquationSeparate(void *_glfuncs, GLenum modeRGB, GLenum modeAlpha); +void gl2_1_glUniformMatrix4x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl2_1_glUniformMatrix3x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl2_1_glUniformMatrix4x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl2_1_glUniformMatrix2x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl2_1_glUniformMatrix3x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl2_1_glUniformMatrix2x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl2_1_glTranslatef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl2_1_glTranslated(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl2_1_glScalef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl2_1_glScaled(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl2_1_glRotatef(void *_glfuncs, GLfloat angle, GLfloat x, GLfloat y, GLfloat z); +void gl2_1_glRotated(void *_glfuncs, GLdouble angle, GLdouble x, GLdouble y, GLdouble z); +void gl2_1_glPushMatrix(void *_glfuncs); +void gl2_1_glPopMatrix(void *_glfuncs); +void gl2_1_glOrtho(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +void gl2_1_glMultMatrixd(void *_glfuncs, const GLdouble* m); +void gl2_1_glMultMatrixf(void *_glfuncs, const GLfloat* m); +void gl2_1_glMatrixMode(void *_glfuncs, GLenum mode); +void gl2_1_glLoadMatrixd(void *_glfuncs, const GLdouble* m); +void gl2_1_glLoadMatrixf(void *_glfuncs, const GLfloat* m); +void gl2_1_glLoadIdentity(void *_glfuncs); +void gl2_1_glFrustum(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +GLboolean gl2_1_glIsList(void *_glfuncs, GLuint list); +void gl2_1_glGetTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, GLint* params); +void gl2_1_glGetTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, GLfloat* params); +void gl2_1_glGetTexGendv(void *_glfuncs, GLenum coord, GLenum pname, GLdouble* params); +void gl2_1_glGetTexEnviv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl2_1_glGetTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl2_1_glGetPolygonStipple(void *_glfuncs, GLubyte* mask); +void gl2_1_glGetPixelMapusv(void *_glfuncs, GLenum glmap, GLushort* values); +void gl2_1_glGetPixelMapuiv(void *_glfuncs, GLenum glmap, GLuint* values); +void gl2_1_glGetPixelMapfv(void *_glfuncs, GLenum glmap, GLfloat* values); +void gl2_1_glGetMaterialiv(void *_glfuncs, GLenum face, GLenum pname, GLint* params); +void gl2_1_glGetMaterialfv(void *_glfuncs, GLenum face, GLenum pname, GLfloat* params); +void gl2_1_glGetMapiv(void *_glfuncs, GLenum target, GLenum query, GLint* v); +void gl2_1_glGetMapfv(void *_glfuncs, GLenum target, GLenum query, GLfloat* v); +void gl2_1_glGetMapdv(void *_glfuncs, GLenum target, GLenum query, GLdouble* v); +void gl2_1_glGetLightiv(void *_glfuncs, GLenum light, GLenum pname, GLint* params); +void gl2_1_glGetLightfv(void *_glfuncs, GLenum light, GLenum pname, GLfloat* params); +void gl2_1_glGetClipPlane(void *_glfuncs, GLenum plane, GLdouble* equation); +void gl2_1_glDrawPixels(void *_glfuncs, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl2_1_glCopyPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum gltype); +void gl2_1_glPixelMapusv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLushort* values); +void gl2_1_glPixelMapuiv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLuint* values); +void gl2_1_glPixelMapfv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLfloat* values); +void gl2_1_glPixelTransferi(void *_glfuncs, GLenum pname, GLint param); +void gl2_1_glPixelTransferf(void *_glfuncs, GLenum pname, GLfloat param); +void gl2_1_glPixelZoom(void *_glfuncs, GLfloat xfactor, GLfloat yfactor); +void gl2_1_glAlphaFunc(void *_glfuncs, GLenum glfunc, GLfloat ref); +void gl2_1_glEvalPoint2(void *_glfuncs, GLint i, GLint j); +void gl2_1_glEvalMesh2(void *_glfuncs, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); +void gl2_1_glEvalPoint1(void *_glfuncs, GLint i); +void gl2_1_glEvalMesh1(void *_glfuncs, GLenum mode, GLint i1, GLint i2); +void gl2_1_glEvalCoord2fv(void *_glfuncs, const GLfloat* u); +void gl2_1_glEvalCoord2f(void *_glfuncs, GLfloat u, GLfloat v); +void gl2_1_glEvalCoord2dv(void *_glfuncs, const GLdouble* u); +void gl2_1_glEvalCoord2d(void *_glfuncs, GLdouble u, GLdouble v); +void gl2_1_glEvalCoord1fv(void *_glfuncs, const GLfloat* u); +void gl2_1_glEvalCoord1f(void *_glfuncs, GLfloat u); +void gl2_1_glEvalCoord1dv(void *_glfuncs, const GLdouble* u); +void gl2_1_glEvalCoord1d(void *_glfuncs, GLdouble u); +void gl2_1_glMapGrid2f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); +void gl2_1_glMapGrid2d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); +void gl2_1_glMapGrid1f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2); +void gl2_1_glMapGrid1d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2); +void gl2_1_glMap2f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points); +void gl2_1_glMap2d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points); +void gl2_1_glMap1f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points); +void gl2_1_glMap1d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points); +void gl2_1_glPushAttrib(void *_glfuncs, GLbitfield mask); +void gl2_1_glPopAttrib(void *_glfuncs); +void gl2_1_glAccum(void *_glfuncs, GLenum op, GLfloat value); +void gl2_1_glIndexMask(void *_glfuncs, GLuint mask); +void gl2_1_glClearIndex(void *_glfuncs, GLfloat c); +void gl2_1_glClearAccum(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl2_1_glPushName(void *_glfuncs, GLuint name); +void gl2_1_glPopName(void *_glfuncs); +void gl2_1_glPassThrough(void *_glfuncs, GLfloat token); +void gl2_1_glLoadName(void *_glfuncs, GLuint name); +void gl2_1_glInitNames(void *_glfuncs); +GLint gl2_1_glRenderMode(void *_glfuncs, GLenum mode); +void gl2_1_glSelectBuffer(void *_glfuncs, GLsizei size, GLuint* buffer); +void gl2_1_glFeedbackBuffer(void *_glfuncs, GLsizei size, GLenum gltype, GLfloat* buffer); +void gl2_1_glTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, const GLint* params); +void gl2_1_glTexGeni(void *_glfuncs, GLenum coord, GLenum pname, GLint param); +void gl2_1_glTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, const GLfloat* params); +void gl2_1_glTexGenf(void *_glfuncs, GLenum coord, GLenum pname, GLfloat param); +void gl2_1_glTexGendv(void *_glfuncs, GLenum coord, GLenum pname, const GLdouble* params); +void gl2_1_glTexGend(void *_glfuncs, GLenum coord, GLenum pname, GLdouble param); +void gl2_1_glTexEnviv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl2_1_glTexEnvi(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl2_1_glTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl2_1_glTexEnvf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl2_1_glShadeModel(void *_glfuncs, GLenum mode); +void gl2_1_glPolygonStipple(void *_glfuncs, const GLubyte* mask); +void gl2_1_glMaterialiv(void *_glfuncs, GLenum face, GLenum pname, const GLint* params); +void gl2_1_glMateriali(void *_glfuncs, GLenum face, GLenum pname, GLint param); +void gl2_1_glMaterialfv(void *_glfuncs, GLenum face, GLenum pname, const GLfloat* params); +void gl2_1_glMaterialf(void *_glfuncs, GLenum face, GLenum pname, GLfloat param); +void gl2_1_glLineStipple(void *_glfuncs, GLint factor, GLushort pattern); +void gl2_1_glLightModeliv(void *_glfuncs, GLenum pname, const GLint* params); +void gl2_1_glLightModeli(void *_glfuncs, GLenum pname, GLint param); +void gl2_1_glLightModelfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl2_1_glLightModelf(void *_glfuncs, GLenum pname, GLfloat param); +void gl2_1_glLightiv(void *_glfuncs, GLenum light, GLenum pname, const GLint* params); +void gl2_1_glLighti(void *_glfuncs, GLenum light, GLenum pname, GLint param); +void gl2_1_glLightfv(void *_glfuncs, GLenum light, GLenum pname, const GLfloat* params); +void gl2_1_glLightf(void *_glfuncs, GLenum light, GLenum pname, GLfloat param); +void gl2_1_glFogiv(void *_glfuncs, GLenum pname, const GLint* params); +void gl2_1_glFogi(void *_glfuncs, GLenum pname, GLint param); +void gl2_1_glFogfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl2_1_glFogf(void *_glfuncs, GLenum pname, GLfloat param); +void gl2_1_glColorMaterial(void *_glfuncs, GLenum face, GLenum mode); +void gl2_1_glClipPlane(void *_glfuncs, GLenum plane, const GLdouble* equation); +void gl2_1_glVertex4sv(void *_glfuncs, const GLshort* v); +void gl2_1_glVertex4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w); +void gl2_1_glVertex4iv(void *_glfuncs, const GLint* v); +void gl2_1_glVertex4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w); +void gl2_1_glVertex4fv(void *_glfuncs, const GLfloat* v); +void gl2_1_glVertex4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl2_1_glVertex4dv(void *_glfuncs, const GLdouble* v); +void gl2_1_glVertex4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl2_1_glVertex3sv(void *_glfuncs, const GLshort* v); +void gl2_1_glVertex3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl2_1_glVertex3iv(void *_glfuncs, const GLint* v); +void gl2_1_glVertex3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl2_1_glVertex3fv(void *_glfuncs, const GLfloat* v); +void gl2_1_glVertex3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl2_1_glVertex3dv(void *_glfuncs, const GLdouble* v); +void gl2_1_glVertex3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl2_1_glVertex2sv(void *_glfuncs, const GLshort* v); +void gl2_1_glVertex2s(void *_glfuncs, GLshort x, GLshort y); +void gl2_1_glVertex2iv(void *_glfuncs, const GLint* v); +void gl2_1_glVertex2i(void *_glfuncs, GLint x, GLint y); +void gl2_1_glVertex2fv(void *_glfuncs, const GLfloat* v); +void gl2_1_glVertex2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl2_1_glVertex2dv(void *_glfuncs, const GLdouble* v); +void gl2_1_glVertex2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl2_1_glTexCoord4sv(void *_glfuncs, const GLshort* v); +void gl2_1_glTexCoord4s(void *_glfuncs, GLshort s, GLshort t, GLshort r, GLshort q); +void gl2_1_glTexCoord4iv(void *_glfuncs, const GLint* v); +void gl2_1_glTexCoord4i(void *_glfuncs, GLint s, GLint t, GLint r, GLint q); +void gl2_1_glTexCoord4fv(void *_glfuncs, const GLfloat* v); +void gl2_1_glTexCoord4f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +void gl2_1_glTexCoord4dv(void *_glfuncs, const GLdouble* v); +void gl2_1_glTexCoord4d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +void gl2_1_glTexCoord3sv(void *_glfuncs, const GLshort* v); +void gl2_1_glTexCoord3s(void *_glfuncs, GLshort s, GLshort t, GLshort r); +void gl2_1_glTexCoord3iv(void *_glfuncs, const GLint* v); +void gl2_1_glTexCoord3i(void *_glfuncs, GLint s, GLint t, GLint r); +void gl2_1_glTexCoord3fv(void *_glfuncs, const GLfloat* v); +void gl2_1_glTexCoord3f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r); +void gl2_1_glTexCoord3dv(void *_glfuncs, const GLdouble* v); +void gl2_1_glTexCoord3d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r); +void gl2_1_glTexCoord2sv(void *_glfuncs, const GLshort* v); +void gl2_1_glTexCoord2s(void *_glfuncs, GLshort s, GLshort t); +void gl2_1_glTexCoord2iv(void *_glfuncs, const GLint* v); +void gl2_1_glTexCoord2i(void *_glfuncs, GLint s, GLint t); +void gl2_1_glTexCoord2fv(void *_glfuncs, const GLfloat* v); +void gl2_1_glTexCoord2f(void *_glfuncs, GLfloat s, GLfloat t); +void gl2_1_glTexCoord2dv(void *_glfuncs, const GLdouble* v); +void gl2_1_glTexCoord2d(void *_glfuncs, GLdouble s, GLdouble t); +void gl2_1_glTexCoord1sv(void *_glfuncs, const GLshort* v); +void gl2_1_glTexCoord1s(void *_glfuncs, GLshort s); +void gl2_1_glTexCoord1iv(void *_glfuncs, const GLint* v); +void gl2_1_glTexCoord1i(void *_glfuncs, GLint s); +void gl2_1_glTexCoord1fv(void *_glfuncs, const GLfloat* v); +void gl2_1_glTexCoord1f(void *_glfuncs, GLfloat s); +void gl2_1_glTexCoord1dv(void *_glfuncs, const GLdouble* v); +void gl2_1_glTexCoord1d(void *_glfuncs, GLdouble s); +void gl2_1_glRectsv(void *_glfuncs, const GLshort* v1, const GLshort* v2); +void gl2_1_glRects(void *_glfuncs, GLshort x1, GLshort y1, GLshort x2, GLshort y2); +void gl2_1_glRectiv(void *_glfuncs, const GLint* v1, const GLint* v2); +void gl2_1_glRecti(void *_glfuncs, GLint x1, GLint y1, GLint x2, GLint y2); +void gl2_1_glRectfv(void *_glfuncs, const GLfloat* v1, const GLfloat* v2); +void gl2_1_glRectf(void *_glfuncs, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); +void gl2_1_glRectdv(void *_glfuncs, const GLdouble* v1, const GLdouble* v2); +void gl2_1_glRectd(void *_glfuncs, GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); +void gl2_1_glRasterPos4sv(void *_glfuncs, const GLshort* v); +void gl2_1_glRasterPos4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w); +void gl2_1_glRasterPos4iv(void *_glfuncs, const GLint* v); +void gl2_1_glRasterPos4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w); +void gl2_1_glRasterPos4fv(void *_glfuncs, const GLfloat* v); +void gl2_1_glRasterPos4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl2_1_glRasterPos4dv(void *_glfuncs, const GLdouble* v); +void gl2_1_glRasterPos4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl2_1_glRasterPos3sv(void *_glfuncs, const GLshort* v); +void gl2_1_glRasterPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl2_1_glRasterPos3iv(void *_glfuncs, const GLint* v); +void gl2_1_glRasterPos3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl2_1_glRasterPos3fv(void *_glfuncs, const GLfloat* v); +void gl2_1_glRasterPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl2_1_glRasterPos3dv(void *_glfuncs, const GLdouble* v); +void gl2_1_glRasterPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl2_1_glRasterPos2sv(void *_glfuncs, const GLshort* v); +void gl2_1_glRasterPos2s(void *_glfuncs, GLshort x, GLshort y); +void gl2_1_glRasterPos2iv(void *_glfuncs, const GLint* v); +void gl2_1_glRasterPos2i(void *_glfuncs, GLint x, GLint y); +void gl2_1_glRasterPos2fv(void *_glfuncs, const GLfloat* v); +void gl2_1_glRasterPos2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl2_1_glRasterPos2dv(void *_glfuncs, const GLdouble* v); +void gl2_1_glRasterPos2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl2_1_glNormal3sv(void *_glfuncs, const GLshort* v); +void gl2_1_glNormal3s(void *_glfuncs, GLshort nx, GLshort ny, GLshort nz); +void gl2_1_glNormal3iv(void *_glfuncs, const GLint* v); +void gl2_1_glNormal3i(void *_glfuncs, GLint nx, GLint ny, GLint nz); +void gl2_1_glNormal3fv(void *_glfuncs, const GLfloat* v); +void gl2_1_glNormal3f(void *_glfuncs, GLfloat nx, GLfloat ny, GLfloat nz); +void gl2_1_glNormal3dv(void *_glfuncs, const GLdouble* v); +void gl2_1_glNormal3d(void *_glfuncs, GLdouble nx, GLdouble ny, GLdouble nz); +void gl2_1_glNormal3bv(void *_glfuncs, const GLbyte* v); +void gl2_1_glNormal3b(void *_glfuncs, GLbyte nx, GLbyte ny, GLbyte nz); +void gl2_1_glIndexsv(void *_glfuncs, const GLshort* c); +void gl2_1_glIndexs(void *_glfuncs, GLshort c); +void gl2_1_glIndexiv(void *_glfuncs, const GLint* c); +void gl2_1_glIndexi(void *_glfuncs, GLint c); +void gl2_1_glIndexfv(void *_glfuncs, const GLfloat* c); +void gl2_1_glIndexf(void *_glfuncs, GLfloat c); +void gl2_1_glIndexdv(void *_glfuncs, const GLdouble* c); +void gl2_1_glIndexd(void *_glfuncs, GLdouble c); +void gl2_1_glEnd(void *_glfuncs); +void gl2_1_glEdgeFlagv(void *_glfuncs, const GLboolean* flag); +void gl2_1_glEdgeFlag(void *_glfuncs, GLboolean flag); +void gl2_1_glColor4usv(void *_glfuncs, const GLushort* v); +void gl2_1_glColor4us(void *_glfuncs, GLushort red, GLushort green, GLushort blue, GLushort alpha); +void gl2_1_glColor4uiv(void *_glfuncs, const GLuint* v); +void gl2_1_glColor4ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue, GLuint alpha); +void gl2_1_glColor4ubv(void *_glfuncs, const GLubyte* v); +void gl2_1_glColor4ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); +void gl2_1_glColor4sv(void *_glfuncs, const GLshort* v); +void gl2_1_glColor4s(void *_glfuncs, GLshort red, GLshort green, GLshort blue, GLshort alpha); +void gl2_1_glColor4iv(void *_glfuncs, const GLint* v); +void gl2_1_glColor4i(void *_glfuncs, GLint red, GLint green, GLint blue, GLint alpha); +void gl2_1_glColor4fv(void *_glfuncs, const GLfloat* v); +void gl2_1_glColor4f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl2_1_glColor4dv(void *_glfuncs, const GLdouble* v); +void gl2_1_glColor4d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); +void gl2_1_glColor4bv(void *_glfuncs, const GLbyte* v); +void gl2_1_glColor4b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); +void gl2_1_glColor3usv(void *_glfuncs, const GLushort* v); +void gl2_1_glColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue); +void gl2_1_glColor3uiv(void *_glfuncs, const GLuint* v); +void gl2_1_glColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue); +void gl2_1_glColor3ubv(void *_glfuncs, const GLubyte* v); +void gl2_1_glColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue); +void gl2_1_glColor3sv(void *_glfuncs, const GLshort* v); +void gl2_1_glColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue); +void gl2_1_glColor3iv(void *_glfuncs, const GLint* v); +void gl2_1_glColor3i(void *_glfuncs, GLint red, GLint green, GLint blue); +void gl2_1_glColor3fv(void *_glfuncs, const GLfloat* v); +void gl2_1_glColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue); +void gl2_1_glColor3dv(void *_glfuncs, const GLdouble* v); +void gl2_1_glColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue); +void gl2_1_glColor3bv(void *_glfuncs, const GLbyte* v); +void gl2_1_glColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue); +void gl2_1_glBitmap(void *_glfuncs, GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap); +void gl2_1_glBegin(void *_glfuncs, GLenum mode); +void gl2_1_glListBase(void *_glfuncs, GLuint base); +GLuint gl2_1_glGenLists(void *_glfuncs, GLsizei range_); +void gl2_1_glDeleteLists(void *_glfuncs, GLuint list, GLsizei range_); +void gl2_1_glCallLists(void *_glfuncs, GLsizei n, GLenum gltype, const GLvoid* lists); +void gl2_1_glCallList(void *_glfuncs, GLuint list); +void gl2_1_glEndList(void *_glfuncs); +void gl2_1_glNewList(void *_glfuncs, GLuint list, GLenum mode); +void gl2_1_glPushClientAttrib(void *_glfuncs, GLbitfield mask); +void gl2_1_glPopClientAttrib(void *_glfuncs); +void gl2_1_glPrioritizeTextures(void *_glfuncs, GLsizei n, const GLuint* textures, const GLfloat* priorities); +GLboolean gl2_1_glAreTexturesResident(void *_glfuncs, GLsizei n, const GLuint* textures, GLboolean* residences); +void gl2_1_glVertexPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl2_1_glTexCoordPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl2_1_glNormalPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl2_1_glInterleavedArrays(void *_glfuncs, GLenum format, GLsizei stride, const GLvoid* pointer); +void gl2_1_glIndexPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl2_1_glEnableClientState(void *_glfuncs, GLenum array); +void gl2_1_glEdgeFlagPointer(void *_glfuncs, GLsizei stride, const GLvoid* pointer); +void gl2_1_glDisableClientState(void *_glfuncs, GLenum array); +void gl2_1_glColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl2_1_glArrayElement(void *_glfuncs, GLint i); +void gl2_1_glResetMinmax(void *_glfuncs, GLenum target); +void gl2_1_glResetHistogram(void *_glfuncs, GLenum target); +void gl2_1_glMinmax(void *_glfuncs, GLenum target, GLenum internalFormat, GLboolean sink); +void gl2_1_glHistogram(void *_glfuncs, GLenum target, GLsizei width, GLenum internalFormat, GLboolean sink); +void gl2_1_glGetMinmaxParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl2_1_glGetMinmaxParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl2_1_glGetMinmax(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values); +void gl2_1_glGetHistogramParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl2_1_glGetHistogramParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl2_1_glGetHistogram(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values); +void gl2_1_glSeparableFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* row, const GLvoid* column); +void gl2_1_glGetSeparableFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* row, GLvoid* column, GLvoid* span); +void gl2_1_glGetConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl2_1_glGetConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl2_1_glGetConvolutionFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* image); +void gl2_1_glCopyConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height); +void gl2_1_glCopyConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width); +void gl2_1_glConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl2_1_glConvolutionParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint params); +void gl2_1_glConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl2_1_glConvolutionParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat params); +void gl2_1_glConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* image); +void gl2_1_glConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* image); +void gl2_1_glCopyColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); +void gl2_1_glColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum gltype, const GLvoid* data); +void gl2_1_glGetColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl2_1_glGetColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl2_1_glGetColorTable(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* table); +void gl2_1_glCopyColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width); +void gl2_1_glColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl2_1_glColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl2_1_glColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* table); +void gl2_1_glMultTransposeMatrixd(void *_glfuncs, const GLdouble* m); +void gl2_1_glMultTransposeMatrixf(void *_glfuncs, const GLfloat* m); +void gl2_1_glLoadTransposeMatrixd(void *_glfuncs, const GLdouble* m); +void gl2_1_glLoadTransposeMatrixf(void *_glfuncs, const GLfloat* m); +void gl2_1_glMultiTexCoord4sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl2_1_glMultiTexCoord4s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); +void gl2_1_glMultiTexCoord4iv(void *_glfuncs, GLenum target, const GLint* v); +void gl2_1_glMultiTexCoord4i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r, GLint q); +void gl2_1_glMultiTexCoord4fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl2_1_glMultiTexCoord4f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +void gl2_1_glMultiTexCoord4dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl2_1_glMultiTexCoord4d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +void gl2_1_glMultiTexCoord3sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl2_1_glMultiTexCoord3s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r); +void gl2_1_glMultiTexCoord3iv(void *_glfuncs, GLenum target, const GLint* v); +void gl2_1_glMultiTexCoord3i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r); +void gl2_1_glMultiTexCoord3fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl2_1_glMultiTexCoord3f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r); +void gl2_1_glMultiTexCoord3dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl2_1_glMultiTexCoord3d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r); +void gl2_1_glMultiTexCoord2sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl2_1_glMultiTexCoord2s(void *_glfuncs, GLenum target, GLshort s, GLshort t); +void gl2_1_glMultiTexCoord2iv(void *_glfuncs, GLenum target, const GLint* v); +void gl2_1_glMultiTexCoord2i(void *_glfuncs, GLenum target, GLint s, GLint t); +void gl2_1_glMultiTexCoord2fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl2_1_glMultiTexCoord2f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t); +void gl2_1_glMultiTexCoord2dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl2_1_glMultiTexCoord2d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t); +void gl2_1_glMultiTexCoord1sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl2_1_glMultiTexCoord1s(void *_glfuncs, GLenum target, GLshort s); +void gl2_1_glMultiTexCoord1iv(void *_glfuncs, GLenum target, const GLint* v); +void gl2_1_glMultiTexCoord1i(void *_glfuncs, GLenum target, GLint s); +void gl2_1_glMultiTexCoord1fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl2_1_glMultiTexCoord1f(void *_glfuncs, GLenum target, GLfloat s); +void gl2_1_glMultiTexCoord1dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl2_1_glMultiTexCoord1d(void *_glfuncs, GLenum target, GLdouble s); +void gl2_1_glClientActiveTexture(void *_glfuncs, GLenum texture); +void gl2_1_glWindowPos3sv(void *_glfuncs, const GLshort* v); +void gl2_1_glWindowPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl2_1_glWindowPos3iv(void *_glfuncs, const GLint* v); +void gl2_1_glWindowPos3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl2_1_glWindowPos3fv(void *_glfuncs, const GLfloat* v); +void gl2_1_glWindowPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl2_1_glWindowPos3dv(void *_glfuncs, const GLdouble* v); +void gl2_1_glWindowPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl2_1_glWindowPos2sv(void *_glfuncs, const GLshort* v); +void gl2_1_glWindowPos2s(void *_glfuncs, GLshort x, GLshort y); +void gl2_1_glWindowPos2iv(void *_glfuncs, const GLint* v); +void gl2_1_glWindowPos2i(void *_glfuncs, GLint x, GLint y); +void gl2_1_glWindowPos2fv(void *_glfuncs, const GLfloat* v); +void gl2_1_glWindowPos2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl2_1_glWindowPos2dv(void *_glfuncs, const GLdouble* v); +void gl2_1_glWindowPos2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl2_1_glSecondaryColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl2_1_glSecondaryColor3usv(void *_glfuncs, const GLushort* v); +void gl2_1_glSecondaryColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue); +void gl2_1_glSecondaryColor3uiv(void *_glfuncs, const GLuint* v); +void gl2_1_glSecondaryColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue); +void gl2_1_glSecondaryColor3ubv(void *_glfuncs, const GLubyte* v); +void gl2_1_glSecondaryColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue); +void gl2_1_glSecondaryColor3sv(void *_glfuncs, const GLshort* v); +void gl2_1_glSecondaryColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue); +void gl2_1_glSecondaryColor3iv(void *_glfuncs, const GLint* v); +void gl2_1_glSecondaryColor3i(void *_glfuncs, GLint red, GLint green, GLint blue); +void gl2_1_glSecondaryColor3fv(void *_glfuncs, const GLfloat* v); +void gl2_1_glSecondaryColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue); +void gl2_1_glSecondaryColor3dv(void *_glfuncs, const GLdouble* v); +void gl2_1_glSecondaryColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue); +void gl2_1_glSecondaryColor3bv(void *_glfuncs, const GLbyte* v); +void gl2_1_glSecondaryColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue); +void gl2_1_glFogCoordPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl2_1_glFogCoorddv(void *_glfuncs, const GLdouble* coord); +void gl2_1_glFogCoordd(void *_glfuncs, GLdouble coord); +void gl2_1_glFogCoordfv(void *_glfuncs, const GLfloat* coord); +void gl2_1_glFogCoordf(void *_glfuncs, GLfloat coord); +void gl2_1_glVertexAttrib4usv(void *_glfuncs, GLuint index, const GLushort* v); +void gl2_1_glVertexAttrib4uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl2_1_glVertexAttrib4ubv(void *_glfuncs, GLuint index, const GLubyte* v); +void gl2_1_glVertexAttrib4sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl2_1_glVertexAttrib4s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +void gl2_1_glVertexAttrib4iv(void *_glfuncs, GLuint index, const GLint* v); +void gl2_1_glVertexAttrib4fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl2_1_glVertexAttrib4f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl2_1_glVertexAttrib4dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl2_1_glVertexAttrib4d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl2_1_glVertexAttrib4bv(void *_glfuncs, GLuint index, const GLbyte* v); +void gl2_1_glVertexAttrib4Nusv(void *_glfuncs, GLuint index, const GLushort* v); +void gl2_1_glVertexAttrib4Nuiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl2_1_glVertexAttrib4Nubv(void *_glfuncs, GLuint index, const GLubyte* v); +void gl2_1_glVertexAttrib4Nub(void *_glfuncs, GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +void gl2_1_glVertexAttrib4Nsv(void *_glfuncs, GLuint index, const GLshort* v); +void gl2_1_glVertexAttrib4Niv(void *_glfuncs, GLuint index, const GLint* v); +void gl2_1_glVertexAttrib4Nbv(void *_glfuncs, GLuint index, const GLbyte* v); +void gl2_1_glVertexAttrib3sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl2_1_glVertexAttrib3s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z); +void gl2_1_glVertexAttrib3fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl2_1_glVertexAttrib3f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z); +void gl2_1_glVertexAttrib3dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl2_1_glVertexAttrib3d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z); +void gl2_1_glVertexAttrib2sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl2_1_glVertexAttrib2s(void *_glfuncs, GLuint index, GLshort x, GLshort y); +void gl2_1_glVertexAttrib2fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl2_1_glVertexAttrib2f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y); +void gl2_1_glVertexAttrib2dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl2_1_glVertexAttrib2d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y); +void gl2_1_glVertexAttrib1sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl2_1_glVertexAttrib1s(void *_glfuncs, GLuint index, GLshort x); +void gl2_1_glVertexAttrib1fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl2_1_glVertexAttrib1f(void *_glfuncs, GLuint index, GLfloat x); +void gl2_1_glVertexAttrib1dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl2_1_glVertexAttrib1d(void *_glfuncs, GLuint index, GLdouble x); + + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/gl/2.1/gl.go b/gl/2.1/gl.go new file mode 100644 index 00000000..718d258a --- /dev/null +++ b/gl/2.1/gl.go @@ -0,0 +1,6652 @@ +// ** file automatically generated by glgen -- do not edit manually ** + +package GL + +// #cgo CXXFLAGS: -std=c++0x -pedantic-errors -Wall -fno-strict-aliasing +// #cgo LDFLAGS: -lstdc++ +// #cgo pkg-config: Qt5Core Qt5OpenGL +// +// #include "funcs.h" +// +// void free(void*); +// +import "C" + +import ( + "fmt" + "reflect" + "unsafe" + + "gopkg.in/qml.v1/gl/glbase" +) + +// API returns a value that offers methods matching the OpenGL version 2.1 API. +// +// The returned API must not be used after the provided OpenGL context becomes invalid. +func API(context glbase.Contexter) *GL { + gl := &GL{} + gl.funcs = C.gl2_1_funcs() + if gl.funcs == nil { + panic(fmt.Errorf("OpenGL version 2.1 is not available")) + } + return gl +} + +// GL implements the OpenGL version 2.1 API. Values of this +// type must be created via the API function, and it must not be used after +// the associated OpenGL context becomes invalid. +type GL struct { + funcs unsafe.Pointer +} + +const ( + FALSE = 0 + TRUE = 1 + NONE = 0 + + BYTE = 0x1400 + UNSIGNED_BYTE = 0x1401 + SHORT = 0x1402 + UNSIGNED_SHORT = 0x1403 + INT = 0x1404 + UNSIGNED_INT = 0x1405 + FLOAT = 0x1406 + N2_BYTES = 0x1407 + N3_BYTES = 0x1408 + N4_BYTES = 0x1409 + DOUBLE = 0x140A + + ACCUM = 0x0100 + LOAD = 0x0101 + RETURN = 0x0102 + MULT = 0x0103 + ADD = 0x0104 + + ACCUM_BUFFER_BIT = 0x00000200 + ALL_ATTRIB_BITS = 0xFFFFFFFF + COLOR_BUFFER_BIT = 0x00004000 + CURRENT_BIT = 0x00000001 + DEPTH_BUFFER_BIT = 0x00000100 + ENABLE_BIT = 0x00002000 + EVAL_BIT = 0x00010000 + FOG_BIT = 0x00000080 + HINT_BIT = 0x00008000 + LIGHTING_BIT = 0x00000040 + LINE_BIT = 0x00000004 + LIST_BIT = 0x00020000 + MULTISAMPLE_BIT = 0x20000000 + PIXEL_MODE_BIT = 0x00000020 + POINT_BIT = 0x00000002 + POLYGON_BIT = 0x00000008 + POLYGON_STIPPLE_BIT = 0x00000010 + SCISSOR_BIT = 0x00080000 + STENCIL_BUFFER_BIT = 0x00000400 + TEXTURE_BIT = 0x00040000 + TRANSFORM_BIT = 0x00001000 + VIEWPORT_BIT = 0x00000800 + + ALWAYS = 0x0207 + EQUAL = 0x0202 + GEQUAL = 0x0206 + GREATER = 0x0204 + LEQUAL = 0x0203 + LESS = 0x0201 + NEVER = 0x0200 + NOTEQUAL = 0x0205 + + LOGIC_OP = 0x0BF1 + + DST_ALPHA = 0x0304 + ONE = 1 + ONE_MINUS_DST_ALPHA = 0x0305 + ONE_MINUS_SRC_ALPHA = 0x0303 + ONE_MINUS_SRC_COLOR = 0x0301 + SRC_ALPHA = 0x0302 + SRC_COLOR = 0x0300 + ZERO = 0 + + DST_COLOR = 0x0306 + ONE_MINUS_DST_COLOR = 0x0307 + SRC_ALPHA_SATURATE = 0x0308 + + CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF + CLIENT_PIXEL_STORE_BIT = 0x00000001 + CLIENT_VERTEX_ARRAY_BIT = 0x00000002 + + CLIP_PLANE0 = 0x3000 + CLIP_PLANE1 = 0x3001 + CLIP_PLANE2 = 0x3002 + CLIP_PLANE3 = 0x3003 + CLIP_PLANE4 = 0x3004 + CLIP_PLANE5 = 0x3005 + + BACK = 0x0405 + FRONT = 0x0404 + FRONT_AND_BACK = 0x0408 + + AMBIENT = 0x1200 + AMBIENT_AND_DIFFUSE = 0x1602 + DIFFUSE = 0x1201 + EMISSION = 0x1600 + SPECULAR = 0x1202 + + AUX0 = 0x0409 + AUX1 = 0x040A + AUX2 = 0x040B + AUX3 = 0x040C + BACK_LEFT = 0x0402 + BACK_RIGHT = 0x0403 + FRONT_LEFT = 0x0400 + FRONT_RIGHT = 0x0401 + LEFT = 0x0406 + RIGHT = 0x0407 + + ALPHA_TEST = 0x0BC0 + AUTO_NORMAL = 0x0D80 + BLEND = 0x0BE2 + COLOR_ARRAY = 0x8076 + COLOR_LOGIC_OP = 0x0BF2 + COLOR_MATERIAL = 0x0B57 + CULL_FACE = 0x0B44 + DEPTH_TEST = 0x0B71 + DITHER = 0x0BD0 + EDGE_FLAG_ARRAY = 0x8079 + FOG = 0x0B60 + INDEX_ARRAY = 0x8077 + INDEX_LOGIC_OP = 0x0BF1 + LIGHT0 = 0x4000 + LIGHT1 = 0x4001 + LIGHT2 = 0x4002 + LIGHT3 = 0x4003 + LIGHT4 = 0x4004 + LIGHT5 = 0x4005 + LIGHT6 = 0x4006 + LIGHT7 = 0x4007 + LIGHTING = 0x0B50 + LINE_SMOOTH = 0x0B20 + LINE_STIPPLE = 0x0B24 + MAP1_COLOR_4 = 0x0D90 + MAP1_INDEX = 0x0D91 + MAP1_NORMAL = 0x0D92 + MAP1_TEXTURE_COORD_1 = 0x0D93 + MAP1_TEXTURE_COORD_2 = 0x0D94 + MAP1_TEXTURE_COORD_3 = 0x0D95 + MAP1_TEXTURE_COORD_4 = 0x0D96 + MAP1_VERTEX_3 = 0x0D97 + MAP1_VERTEX_4 = 0x0D98 + MAP2_COLOR_4 = 0x0DB0 + MAP2_INDEX = 0x0DB1 + MAP2_NORMAL = 0x0DB2 + MAP2_TEXTURE_COORD_1 = 0x0DB3 + MAP2_TEXTURE_COORD_2 = 0x0DB4 + MAP2_TEXTURE_COORD_3 = 0x0DB5 + MAP2_TEXTURE_COORD_4 = 0x0DB6 + MAP2_VERTEX_3 = 0x0DB7 + MAP2_VERTEX_4 = 0x0DB8 + NORMALIZE = 0x0BA1 + NORMAL_ARRAY = 0x8075 + POINT_SMOOTH = 0x0B10 + POLYGON_OFFSET_FILL = 0x8037 + POLYGON_OFFSET_LINE = 0x2A02 + POLYGON_OFFSET_POINT = 0x2A01 + POLYGON_SMOOTH = 0x0B41 + POLYGON_STIPPLE = 0x0B42 + SCISSOR_TEST = 0x0C11 + STENCIL_TEST = 0x0B90 + TEXTURE_1D = 0x0DE0 + TEXTURE_2D = 0x0DE1 + TEXTURE_COORD_ARRAY = 0x8078 + TEXTURE_GEN_Q = 0x0C63 + TEXTURE_GEN_R = 0x0C62 + TEXTURE_GEN_S = 0x0C60 + TEXTURE_GEN_T = 0x0C61 + VERTEX_ARRAY = 0x8074 + + INVALID_ENUM = 0x0500 + INVALID_OPERATION = 0x0502 + INVALID_VALUE = 0x0501 + NO_ERROR = 0 + OUT_OF_MEMORY = 0x0505 + STACK_OVERFLOW = 0x0503 + STACK_UNDERFLOW = 0x0504 + + N2D = 0x0600 + N3D = 0x0601 + N3D_COLOR = 0x0602 + N3D_COLOR_TEXTURE = 0x0603 + N4D_COLOR_TEXTURE = 0x0604 + + BITMAP_TOKEN = 0x0704 + COPY_PIXEL_TOKEN = 0x0706 + DRAW_PIXEL_TOKEN = 0x0705 + LINE_RESET_TOKEN = 0x0707 + LINE_TOKEN = 0x0702 + PASS_THROUGH_TOKEN = 0x0700 + POINT_TOKEN = 0x0701 + POLYGON_TOKEN = 0x0703 + + EXP = 0x0800 + EXP2 = 0x0801 + LINEAR = 0x2601 + + FOG_COLOR = 0x0B66 + FOG_DENSITY = 0x0B62 + FOG_END = 0x0B64 + FOG_INDEX = 0x0B61 + FOG_MODE = 0x0B65 + FOG_START = 0x0B63 + + CCW = 0x0901 + CW = 0x0900 + + COEFF = 0x0A00 + DOMAIN = 0x0A02 + ORDER = 0x0A01 + + PIXEL_MAP_A_TO_A = 0x0C79 + PIXEL_MAP_B_TO_B = 0x0C78 + PIXEL_MAP_G_TO_G = 0x0C77 + PIXEL_MAP_I_TO_A = 0x0C75 + PIXEL_MAP_I_TO_B = 0x0C74 + PIXEL_MAP_I_TO_G = 0x0C73 + PIXEL_MAP_I_TO_I = 0x0C70 + PIXEL_MAP_I_TO_R = 0x0C72 + PIXEL_MAP_R_TO_R = 0x0C76 + PIXEL_MAP_S_TO_S = 0x0C71 + + ACCUM_ALPHA_BITS = 0x0D5B + ACCUM_BLUE_BITS = 0x0D5A + ACCUM_CLEAR_VALUE = 0x0B80 + ACCUM_GREEN_BITS = 0x0D59 + ACCUM_RED_BITS = 0x0D58 + ALIASED_LINE_WIDTH_RANGE = 0x846E + ALIASED_POINT_SIZE_RANGE = 0x846D + ALPHA_BIAS = 0x0D1D + ALPHA_BITS = 0x0D55 + ALPHA_SCALE = 0x0D1C + ALPHA_TEST_FUNC = 0x0BC1 + ALPHA_TEST_REF = 0x0BC2 + ATTRIB_STACK_DEPTH = 0x0BB0 + AUX_BUFFERS = 0x0C00 + BLEND_DST = 0x0BE0 + BLEND_SRC = 0x0BE1 + BLUE_BIAS = 0x0D1B + BLUE_BITS = 0x0D54 + BLUE_SCALE = 0x0D1A + CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1 + COLOR_ARRAY_SIZE = 0x8081 + COLOR_ARRAY_STRIDE = 0x8083 + COLOR_ARRAY_TYPE = 0x8082 + COLOR_CLEAR_VALUE = 0x0C22 + COLOR_MATERIAL_FACE = 0x0B55 + COLOR_MATERIAL_PARAMETER = 0x0B56 + COLOR_WRITEMASK = 0x0C23 + CULL_FACE_MODE = 0x0B45 + CURRENT_COLOR = 0x0B00 + CURRENT_INDEX = 0x0B01 + CURRENT_NORMAL = 0x0B02 + CURRENT_RASTER_COLOR = 0x0B04 + CURRENT_RASTER_DISTANCE = 0x0B09 + CURRENT_RASTER_INDEX = 0x0B05 + CURRENT_RASTER_POSITION = 0x0B07 + CURRENT_RASTER_POSITION_VALID = 0x0B08 + CURRENT_RASTER_TEXTURE_COORDS = 0x0B06 + CURRENT_TEXTURE_COORDS = 0x0B03 + DEPTH_BIAS = 0x0D1F + DEPTH_BITS = 0x0D56 + DEPTH_CLEAR_VALUE = 0x0B73 + DEPTH_FUNC = 0x0B74 + DEPTH_RANGE = 0x0B70 + DEPTH_SCALE = 0x0D1E + DEPTH_WRITEMASK = 0x0B72 + DOUBLEBUFFER = 0x0C32 + DRAW_BUFFER = 0x0C01 + EDGE_FLAG = 0x0B43 + EDGE_FLAG_ARRAY_STRIDE = 0x808C + FEEDBACK_BUFFER_SIZE = 0x0DF1 + FEEDBACK_BUFFER_TYPE = 0x0DF2 + FOG_HINT = 0x0C54 + FRONT_FACE = 0x0B46 + GREEN_BIAS = 0x0D19 + GREEN_BITS = 0x0D53 + GREEN_SCALE = 0x0D18 + INDEX_ARRAY_STRIDE = 0x8086 + INDEX_ARRAY_TYPE = 0x8085 + INDEX_BITS = 0x0D51 + INDEX_CLEAR_VALUE = 0x0C20 + INDEX_MODE = 0x0C30 + INDEX_OFFSET = 0x0D13 + INDEX_SHIFT = 0x0D12 + INDEX_WRITEMASK = 0x0C21 + LIGHT_MODEL_AMBIENT = 0x0B53 + LIGHT_MODEL_COLOR_CONTROL = 0x81F8 + LIGHT_MODEL_LOCAL_VIEWER = 0x0B51 + LIGHT_MODEL_TWO_SIDE = 0x0B52 + LINE_SMOOTH_HINT = 0x0C52 + LINE_STIPPLE_PATTERN = 0x0B25 + LINE_STIPPLE_REPEAT = 0x0B26 + LINE_WIDTH = 0x0B21 + LINE_WIDTH_GRANULARITY = 0x0B23 + LINE_WIDTH_RANGE = 0x0B22 + LIST_BASE = 0x0B32 + LIST_INDEX = 0x0B33 + LIST_MODE = 0x0B30 + LOGIC_OP_MODE = 0x0BF0 + MAP1_GRID_DOMAIN = 0x0DD0 + MAP1_GRID_SEGMENTS = 0x0DD1 + MAP2_GRID_DOMAIN = 0x0DD2 + MAP2_GRID_SEGMENTS = 0x0DD3 + MAP_COLOR = 0x0D10 + MAP_STENCIL = 0x0D11 + MATRIX_MODE = 0x0BA0 + MAX_ATTRIB_STACK_DEPTH = 0x0D35 + MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B + MAX_CLIP_PLANES = 0x0D32 + MAX_EVAL_ORDER = 0x0D30 + MAX_LIGHTS = 0x0D31 + MAX_LIST_NESTING = 0x0B31 + MAX_MODELVIEW_STACK_DEPTH = 0x0D36 + MAX_NAME_STACK_DEPTH = 0x0D37 + MAX_PIXEL_MAP_TABLE = 0x0D34 + MAX_PROJECTION_STACK_DEPTH = 0x0D38 + MAX_TEXTURE_SIZE = 0x0D33 + MAX_TEXTURE_STACK_DEPTH = 0x0D39 + MAX_VIEWPORT_DIMS = 0x0D3A + MODELVIEW_MATRIX = 0x0BA6 + MODELVIEW_STACK_DEPTH = 0x0BA3 + NAME_STACK_DEPTH = 0x0D70 + NORMAL_ARRAY_STRIDE = 0x807F + NORMAL_ARRAY_TYPE = 0x807E + PACK_ALIGNMENT = 0x0D05 + PACK_LSB_FIRST = 0x0D01 + PACK_ROW_LENGTH = 0x0D02 + PACK_SKIP_PIXELS = 0x0D04 + PACK_SKIP_ROWS = 0x0D03 + PACK_SWAP_BYTES = 0x0D00 + PERSPECTIVE_CORRECTION_HINT = 0x0C50 + PIXEL_MAP_A_TO_A_SIZE = 0x0CB9 + PIXEL_MAP_B_TO_B_SIZE = 0x0CB8 + PIXEL_MAP_G_TO_G_SIZE = 0x0CB7 + PIXEL_MAP_I_TO_A_SIZE = 0x0CB5 + PIXEL_MAP_I_TO_B_SIZE = 0x0CB4 + PIXEL_MAP_I_TO_G_SIZE = 0x0CB3 + PIXEL_MAP_I_TO_I_SIZE = 0x0CB0 + PIXEL_MAP_I_TO_R_SIZE = 0x0CB2 + PIXEL_MAP_R_TO_R_SIZE = 0x0CB6 + PIXEL_MAP_S_TO_S_SIZE = 0x0CB1 + POINT_SIZE = 0x0B11 + POINT_SIZE_GRANULARITY = 0x0B13 + POINT_SIZE_RANGE = 0x0B12 + POINT_SMOOTH_HINT = 0x0C51 + POLYGON_MODE = 0x0B40 + POLYGON_OFFSET_FACTOR = 0x8038 + POLYGON_OFFSET_UNITS = 0x2A00 + POLYGON_SMOOTH_HINT = 0x0C53 + PROJECTION_MATRIX = 0x0BA7 + PROJECTION_STACK_DEPTH = 0x0BA4 + READ_BUFFER = 0x0C02 + RED_BIAS = 0x0D15 + RED_BITS = 0x0D52 + RED_SCALE = 0x0D14 + RENDER_MODE = 0x0C40 + RGBA_MODE = 0x0C31 + SCISSOR_BOX = 0x0C10 + SELECTION_BUFFER_SIZE = 0x0DF4 + SHADE_MODEL = 0x0B54 + SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23 + SMOOTH_LINE_WIDTH_RANGE = 0x0B22 + SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13 + SMOOTH_POINT_SIZE_RANGE = 0x0B12 + STENCIL_BITS = 0x0D57 + STENCIL_CLEAR_VALUE = 0x0B91 + STENCIL_FAIL = 0x0B94 + STENCIL_FUNC = 0x0B92 + STENCIL_PASS_DEPTH_FAIL = 0x0B95 + STENCIL_PASS_DEPTH_PASS = 0x0B96 + STENCIL_REF = 0x0B97 + STENCIL_VALUE_MASK = 0x0B93 + STENCIL_WRITEMASK = 0x0B98 + STEREO = 0x0C33 + SUBPIXEL_BITS = 0x0D50 + TEXTURE_BINDING_1D = 0x8068 + TEXTURE_BINDING_2D = 0x8069 + TEXTURE_BINDING_3D = 0x806A + TEXTURE_COORD_ARRAY_SIZE = 0x8088 + TEXTURE_COORD_ARRAY_STRIDE = 0x808A + TEXTURE_COORD_ARRAY_TYPE = 0x8089 + TEXTURE_MATRIX = 0x0BA8 + TEXTURE_STACK_DEPTH = 0x0BA5 + UNPACK_ALIGNMENT = 0x0CF5 + UNPACK_LSB_FIRST = 0x0CF1 + UNPACK_ROW_LENGTH = 0x0CF2 + UNPACK_SKIP_PIXELS = 0x0CF4 + UNPACK_SKIP_ROWS = 0x0CF3 + UNPACK_SWAP_BYTES = 0x0CF0 + VERTEX_ARRAY_SIZE = 0x807A + VERTEX_ARRAY_STRIDE = 0x807C + VERTEX_ARRAY_TYPE = 0x807B + VIEWPORT = 0x0BA2 + ZOOM_X = 0x0D16 + ZOOM_Y = 0x0D17 + + COLOR_ARRAY_POINTER = 0x8090 + EDGE_FLAG_ARRAY_POINTER = 0x8093 + FEEDBACK_BUFFER_POINTER = 0x0DF0 + INDEX_ARRAY_POINTER = 0x8091 + NORMAL_ARRAY_POINTER = 0x808F + SELECTION_BUFFER_POINTER = 0x0DF3 + TEXTURE_COORD_ARRAY_POINTER = 0x8092 + VERTEX_ARRAY_POINTER = 0x808E + + TEXTURE_ALPHA_SIZE = 0x805F + TEXTURE_BLUE_SIZE = 0x805E + TEXTURE_BORDER = 0x1005 + TEXTURE_BORDER_COLOR = 0x1004 + TEXTURE_COMPONENTS = 0x1003 + TEXTURE_GREEN_SIZE = 0x805D + TEXTURE_HEIGHT = 0x1001 + TEXTURE_INTENSITY_SIZE = 0x8061 + TEXTURE_INTERNAL_FORMAT = 0x1003 + TEXTURE_LUMINANCE_SIZE = 0x8060 + TEXTURE_MAG_FILTER = 0x2800 + TEXTURE_MIN_FILTER = 0x2801 + TEXTURE_PRIORITY = 0x8066 + TEXTURE_RED_SIZE = 0x805C + TEXTURE_RESIDENT = 0x8067 + TEXTURE_WIDTH = 0x1000 + TEXTURE_WRAP_S = 0x2802 + TEXTURE_WRAP_T = 0x2803 + + DONT_CARE = 0x1100 + FASTEST = 0x1101 + NICEST = 0x1102 + + FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B + GENERATE_MIPMAP_HINT = 0x8192 + TEXTURE_COMPRESSION_HINT = 0x84EF + + C3F_V3F = 0x2A24 + C4F_N3F_V3F = 0x2A26 + C4UB_V2F = 0x2A22 + C4UB_V3F = 0x2A23 + N3F_V3F = 0x2A25 + T2F_C3F_V3F = 0x2A2A + T2F_C4F_N3F_V3F = 0x2A2C + T2F_C4UB_V3F = 0x2A29 + T2F_N3F_V3F = 0x2A2B + T2F_V3F = 0x2A27 + T4F_C4F_N3F_V4F = 0x2A2D + T4F_V4F = 0x2A28 + V2F = 0x2A20 + V3F = 0x2A21 + + MODULATE = 0x2100 + REPLACE = 0x1E01 + + SEPARATE_SPECULAR_COLOR = 0x81FA + SINGLE_COLOR = 0x81F9 + + CONSTANT_ATTENUATION = 0x1207 + LINEAR_ATTENUATION = 0x1208 + POSITION = 0x1203 + QUADRATIC_ATTENUATION = 0x1209 + SPOT_CUTOFF = 0x1206 + SPOT_DIRECTION = 0x1204 + SPOT_EXPONENT = 0x1205 + + COMPILE = 0x1300 + COMPILE_AND_EXECUTE = 0x1301 + + AND = 0x1501 + AND_INVERTED = 0x1504 + AND_REVERSE = 0x1502 + CLEAR = 0x1500 + COPY = 0x1503 + COPY_INVERTED = 0x150C + EQUIV = 0x1509 + INVERT = 0x150A + NAND = 0x150E + NOOP = 0x1505 + NOR = 0x1508 + OR = 0x1507 + OR_INVERTED = 0x150D + OR_REVERSE = 0x150B + SET = 0x150F + XOR = 0x1506 + + COLOR_INDEXES = 0x1603 + SHININESS = 0x1601 + + MODELVIEW = 0x1700 + PROJECTION = 0x1701 + TEXTURE = 0x1702 + + LINE = 0x1B01 + POINT = 0x1B00 + + FILL = 0x1B02 + + COLOR = 0x1800 + DEPTH = 0x1801 + STENCIL = 0x1802 + + ALPHA = 0x1906 + BLUE = 0x1905 + COLOR_INDEX = 0x1900 + DEPTH_COMPONENT = 0x1902 + GREEN = 0x1904 + LUMINANCE = 0x1909 + LUMINANCE_ALPHA = 0x190A + RED = 0x1903 + RGB = 0x1907 + RGBA = 0x1908 + STENCIL_INDEX = 0x1901 + + ALPHA12 = 0x803D + ALPHA16 = 0x803E + ALPHA4 = 0x803B + ALPHA8 = 0x803C + INTENSITY = 0x8049 + INTENSITY12 = 0x804C + INTENSITY16 = 0x804D + INTENSITY4 = 0x804A + INTENSITY8 = 0x804B + LUMINANCE12 = 0x8041 + LUMINANCE12_ALPHA12 = 0x8047 + LUMINANCE12_ALPHA4 = 0x8046 + LUMINANCE16 = 0x8042 + LUMINANCE16_ALPHA16 = 0x8048 + LUMINANCE4 = 0x803F + LUMINANCE4_ALPHA4 = 0x8043 + LUMINANCE6_ALPHA2 = 0x8044 + LUMINANCE8 = 0x8040 + LUMINANCE8_ALPHA8 = 0x8045 + R3_G3_B2 = 0x2A10 + RGB10 = 0x8052 + RGB10_A2 = 0x8059 + RGB12 = 0x8053 + RGB16 = 0x8054 + RGB4 = 0x804F + RGB5 = 0x8050 + RGB5_A1 = 0x8057 + RGB8 = 0x8051 + RGBA12 = 0x805A + RGBA16 = 0x805B + RGBA2 = 0x8055 + RGBA4 = 0x8056 + RGBA8 = 0x8058 + + PACK_IMAGE_HEIGHT = 0x806C + PACK_SKIP_IMAGES = 0x806B + UNPACK_IMAGE_HEIGHT = 0x806E + UNPACK_SKIP_IMAGES = 0x806D + + BITMAP = 0x1A00 + UNSIGNED_BYTE_3_3_2 = 0x8032 + UNSIGNED_INT_10_10_10_2 = 0x8036 + UNSIGNED_INT_8_8_8_8 = 0x8035 + UNSIGNED_SHORT_4_4_4_4 = 0x8033 + UNSIGNED_SHORT_5_5_5_1 = 0x8034 + + POINT_DISTANCE_ATTENUATION = 0x8129 + POINT_FADE_THRESHOLD_SIZE = 0x8128 + POINT_SIZE_MAX = 0x8127 + POINT_SIZE_MIN = 0x8126 + + LINES = 0x0001 + LINE_LOOP = 0x0002 + LINE_STRIP = 0x0003 + POINTS = 0x0000 + POLYGON = 0x0009 + QUADS = 0x0007 + QUAD_STRIP = 0x0008 + TRIANGLES = 0x0004 + TRIANGLE_FAN = 0x0006 + TRIANGLE_STRIP = 0x0005 + + FEEDBACK = 0x1C01 + RENDER = 0x1C00 + SELECT = 0x1C02 + + FLAT = 0x1D00 + SMOOTH = 0x1D01 + + DECR = 0x1E03 + INCR = 0x1E02 + KEEP = 0x1E00 + + EXTENSIONS = 0x1F03 + RENDERER = 0x1F01 + VENDOR = 0x1F00 + VERSION = 0x1F02 + + S = 0x2000 + T = 0x2001 + R = 0x2002 + Q = 0x2003 + + DECAL = 0x2101 + + TEXTURE_ENV_COLOR = 0x2201 + TEXTURE_ENV_MODE = 0x2200 + + TEXTURE_ENV = 0x2300 + + EYE_LINEAR = 0x2400 + OBJECT_LINEAR = 0x2401 + SPHERE_MAP = 0x2402 + + EYE_PLANE = 0x2502 + OBJECT_PLANE = 0x2501 + TEXTURE_GEN_MODE = 0x2500 + + NEAREST = 0x2600 + + LINEAR_MIPMAP_LINEAR = 0x2703 + LINEAR_MIPMAP_NEAREST = 0x2701 + NEAREST_MIPMAP_LINEAR = 0x2702 + NEAREST_MIPMAP_NEAREST = 0x2700 + + GENERATE_MIPMAP = 0x8191 + TEXTURE_WRAP_R = 0x8072 + + PROXY_TEXTURE_1D = 0x8063 + PROXY_TEXTURE_2D = 0x8064 + PROXY_TEXTURE_3D = 0x8070 + TEXTURE_3D = 0x806F + TEXTURE_BASE_LEVEL = 0x813C + TEXTURE_MAX_LEVEL = 0x813D + TEXTURE_MAX_LOD = 0x813B + TEXTURE_MIN_LOD = 0x813A + + CLAMP = 0x2900 + CLAMP_TO_BORDER = 0x812D + CLAMP_TO_EDGE = 0x812F + REPEAT = 0x2901 + + CONSTANT_COLOR = 0x8001 + ONE_MINUS_CONSTANT_COLOR = 0x8002 + CONSTANT_ALPHA = 0x8003 + ONE_MINUS_CONSTANT_ALPHA = 0x8004 + FUNC_ADD = 0x8006 + MIN = 0x8007 + MAX = 0x8008 + BLEND_EQUATION_RGB = 0x8009 + FUNC_SUBTRACT = 0x800A + FUNC_REVERSE_SUBTRACT = 0x800B + RESCALE_NORMAL = 0x803A + TEXTURE_DEPTH = 0x8071 + MAX_3D_TEXTURE_SIZE = 0x8073 + MULTISAMPLE = 0x809D + SAMPLE_ALPHA_TO_COVERAGE = 0x809E + SAMPLE_ALPHA_TO_ONE = 0x809F + SAMPLE_COVERAGE = 0x80A0 + SAMPLE_BUFFERS = 0x80A8 + SAMPLES = 0x80A9 + SAMPLE_COVERAGE_VALUE = 0x80AA + SAMPLE_COVERAGE_INVERT = 0x80AB + BLEND_DST_RGB = 0x80C8 + BLEND_SRC_RGB = 0x80C9 + BLEND_DST_ALPHA = 0x80CA + BLEND_SRC_ALPHA = 0x80CB + BGR = 0x80E0 + BGRA = 0x80E1 + MAX_ELEMENTS_VERTICES = 0x80E8 + MAX_ELEMENTS_INDICES = 0x80E9 + DEPTH_COMPONENT16 = 0x81A5 + DEPTH_COMPONENT24 = 0x81A6 + DEPTH_COMPONENT32 = 0x81A7 + UNSIGNED_BYTE_2_3_3_REV = 0x8362 + UNSIGNED_SHORT_5_6_5 = 0x8363 + UNSIGNED_SHORT_5_6_5_REV = 0x8364 + UNSIGNED_SHORT_4_4_4_4_REV = 0x8365 + UNSIGNED_SHORT_1_5_5_5_REV = 0x8366 + UNSIGNED_INT_8_8_8_8_REV = 0x8367 + UNSIGNED_INT_2_10_10_10_REV = 0x8368 + MIRRORED_REPEAT = 0x8370 + FOG_COORDINATE_SOURCE = 0x8450 + FOG_COORD_SRC = 0x8450 + FOG_COORDINATE = 0x8451 + FOG_COORD = 0x8451 + FRAGMENT_DEPTH = 0x8452 + CURRENT_FOG_COORDINATE = 0x8453 + CURRENT_FOG_COORD = 0x8453 + FOG_COORDINATE_ARRAY_TYPE = 0x8454 + FOG_COORD_ARRAY_TYPE = 0x8454 + FOG_COORDINATE_ARRAY_STRIDE = 0x8455 + FOG_COORD_ARRAY_STRIDE = 0x8455 + FOG_COORDINATE_ARRAY_POINTER = 0x8456 + FOG_COORD_ARRAY_POINTER = 0x8456 + FOG_COORDINATE_ARRAY = 0x8457 + FOG_COORD_ARRAY = 0x8457 + COLOR_SUM = 0x8458 + CURRENT_SECONDARY_COLOR = 0x8459 + SECONDARY_COLOR_ARRAY_SIZE = 0x845A + SECONDARY_COLOR_ARRAY_TYPE = 0x845B + SECONDARY_COLOR_ARRAY_STRIDE = 0x845C + SECONDARY_COLOR_ARRAY_POINTER = 0x845D + SECONDARY_COLOR_ARRAY = 0x845E + CURRENT_RASTER_SECONDARY_COLOR = 0x845F + TEXTURE0 = 0x84C0 + TEXTURE1 = 0x84C1 + TEXTURE2 = 0x84C2 + TEXTURE3 = 0x84C3 + TEXTURE4 = 0x84C4 + TEXTURE5 = 0x84C5 + TEXTURE6 = 0x84C6 + TEXTURE7 = 0x84C7 + TEXTURE8 = 0x84C8 + TEXTURE9 = 0x84C9 + TEXTURE10 = 0x84CA + TEXTURE11 = 0x84CB + TEXTURE12 = 0x84CC + TEXTURE13 = 0x84CD + TEXTURE14 = 0x84CE + TEXTURE15 = 0x84CF + TEXTURE16 = 0x84D0 + TEXTURE17 = 0x84D1 + TEXTURE18 = 0x84D2 + TEXTURE19 = 0x84D3 + TEXTURE20 = 0x84D4 + TEXTURE21 = 0x84D5 + TEXTURE22 = 0x84D6 + TEXTURE23 = 0x84D7 + TEXTURE24 = 0x84D8 + TEXTURE25 = 0x84D9 + TEXTURE26 = 0x84DA + TEXTURE27 = 0x84DB + TEXTURE28 = 0x84DC + TEXTURE29 = 0x84DD + TEXTURE30 = 0x84DE + TEXTURE31 = 0x84DF + ACTIVE_TEXTURE = 0x84E0 + CLIENT_ACTIVE_TEXTURE = 0x84E1 + MAX_TEXTURE_UNITS = 0x84E2 + TRANSPOSE_MODELVIEW_MATRIX = 0x84E3 + TRANSPOSE_PROJECTION_MATRIX = 0x84E4 + TRANSPOSE_TEXTURE_MATRIX = 0x84E5 + TRANSPOSE_COLOR_MATRIX = 0x84E6 + SUBTRACT = 0x84E7 + COMPRESSED_ALPHA = 0x84E9 + COMPRESSED_LUMINANCE = 0x84EA + COMPRESSED_LUMINANCE_ALPHA = 0x84EB + COMPRESSED_INTENSITY = 0x84EC + COMPRESSED_RGB = 0x84ED + COMPRESSED_RGBA = 0x84EE + MAX_TEXTURE_LOD_BIAS = 0x84FD + TEXTURE_FILTER_CONTROL = 0x8500 + TEXTURE_LOD_BIAS = 0x8501 + INCR_WRAP = 0x8507 + DECR_WRAP = 0x8508 + NORMAL_MAP = 0x8511 + REFLECTION_MAP = 0x8512 + TEXTURE_CUBE_MAP = 0x8513 + TEXTURE_BINDING_CUBE_MAP = 0x8514 + TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515 + TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516 + TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517 + TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518 + TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519 + TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A + PROXY_TEXTURE_CUBE_MAP = 0x851B + MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C + COMBINE = 0x8570 + COMBINE_RGB = 0x8571 + COMBINE_ALPHA = 0x8572 + RGB_SCALE = 0x8573 + ADD_SIGNED = 0x8574 + INTERPOLATE = 0x8575 + CONSTANT = 0x8576 + PRIMARY_COLOR = 0x8577 + PREVIOUS = 0x8578 + SOURCE0_RGB = 0x8580 + SRC0_RGB = 0x8580 + SOURCE1_RGB = 0x8581 + SRC1_RGB = 0x8581 + SOURCE2_RGB = 0x8582 + SRC2_RGB = 0x8582 + SOURCE0_ALPHA = 0x8588 + SRC0_ALPHA = 0x8588 + SOURCE1_ALPHA = 0x8589 + SRC1_ALPHA = 0x8589 + SOURCE2_ALPHA = 0x858A + SRC2_ALPHA = 0x858A + OPERAND0_RGB = 0x8590 + OPERAND1_RGB = 0x8591 + OPERAND2_RGB = 0x8592 + OPERAND0_ALPHA = 0x8598 + OPERAND1_ALPHA = 0x8599 + OPERAND2_ALPHA = 0x859A + VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622 + VERTEX_ATTRIB_ARRAY_SIZE = 0x8623 + VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624 + VERTEX_ATTRIB_ARRAY_TYPE = 0x8625 + CURRENT_VERTEX_ATTRIB = 0x8626 + VERTEX_PROGRAM_POINT_SIZE = 0x8642 + VERTEX_PROGRAM_TWO_SIDE = 0x8643 + VERTEX_ATTRIB_ARRAY_POINTER = 0x8645 + TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0 + TEXTURE_COMPRESSED = 0x86A1 + NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2 + COMPRESSED_TEXTURE_FORMATS = 0x86A3 + DOT3_RGB = 0x86AE + DOT3_RGBA = 0x86AF + BUFFER_SIZE = 0x8764 + BUFFER_USAGE = 0x8765 + STENCIL_BACK_FUNC = 0x8800 + STENCIL_BACK_FAIL = 0x8801 + STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802 + STENCIL_BACK_PASS_DEPTH_PASS = 0x8803 + MAX_DRAW_BUFFERS = 0x8824 + DRAW_BUFFER0 = 0x8825 + DRAW_BUFFER1 = 0x8826 + DRAW_BUFFER2 = 0x8827 + DRAW_BUFFER3 = 0x8828 + DRAW_BUFFER4 = 0x8829 + DRAW_BUFFER5 = 0x882A + DRAW_BUFFER6 = 0x882B + DRAW_BUFFER7 = 0x882C + DRAW_BUFFER8 = 0x882D + DRAW_BUFFER9 = 0x882E + DRAW_BUFFER10 = 0x882F + DRAW_BUFFER11 = 0x8830 + DRAW_BUFFER12 = 0x8831 + DRAW_BUFFER13 = 0x8832 + DRAW_BUFFER14 = 0x8833 + DRAW_BUFFER15 = 0x8834 + BLEND_EQUATION_ALPHA = 0x883D + TEXTURE_DEPTH_SIZE = 0x884A + DEPTH_TEXTURE_MODE = 0x884B + TEXTURE_COMPARE_MODE = 0x884C + TEXTURE_COMPARE_FUNC = 0x884D + COMPARE_R_TO_TEXTURE = 0x884E + POINT_SPRITE = 0x8861 + COORD_REPLACE = 0x8862 + QUERY_COUNTER_BITS = 0x8864 + CURRENT_QUERY = 0x8865 + QUERY_RESULT = 0x8866 + QUERY_RESULT_AVAILABLE = 0x8867 + MAX_VERTEX_ATTRIBS = 0x8869 + VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A + MAX_TEXTURE_COORDS = 0x8871 + MAX_TEXTURE_IMAGE_UNITS = 0x8872 + ARRAY_BUFFER = 0x8892 + ELEMENT_ARRAY_BUFFER = 0x8893 + ARRAY_BUFFER_BINDING = 0x8894 + ELEMENT_ARRAY_BUFFER_BINDING = 0x8895 + VERTEX_ARRAY_BUFFER_BINDING = 0x8896 + NORMAL_ARRAY_BUFFER_BINDING = 0x8897 + COLOR_ARRAY_BUFFER_BINDING = 0x8898 + INDEX_ARRAY_BUFFER_BINDING = 0x8899 + TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A + EDGE_FLAG_ARRAY_BUFFER_BINDING = 0x889B + SECONDARY_COLOR_ARRAY_BUFFER_BINDING = 0x889C + FOG_COORDINATE_ARRAY_BUFFER_BINDING = 0x889D + FOG_COORD_ARRAY_BUFFER_BINDING = 0x889D + WEIGHT_ARRAY_BUFFER_BINDING = 0x889E + VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F + READ_ONLY = 0x88B8 + WRITE_ONLY = 0x88B9 + READ_WRITE = 0x88BA + BUFFER_ACCESS = 0x88BB + BUFFER_MAPPED = 0x88BC + BUFFER_MAP_POINTER = 0x88BD + STREAM_DRAW = 0x88E0 + STREAM_READ = 0x88E1 + STREAM_COPY = 0x88E2 + STATIC_DRAW = 0x88E4 + STATIC_READ = 0x88E5 + STATIC_COPY = 0x88E6 + DYNAMIC_DRAW = 0x88E8 + DYNAMIC_READ = 0x88E9 + DYNAMIC_COPY = 0x88EA + PIXEL_PACK_BUFFER = 0x88EB + PIXEL_UNPACK_BUFFER = 0x88EC + PIXEL_PACK_BUFFER_BINDING = 0x88ED + PIXEL_UNPACK_BUFFER_BINDING = 0x88EF + SAMPLES_PASSED = 0x8914 + FRAGMENT_SHADER = 0x8B30 + VERTEX_SHADER = 0x8B31 + MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49 + MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A + MAX_VARYING_FLOATS = 0x8B4B + MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C + MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D + SHADER_TYPE = 0x8B4F + FLOAT_VEC2 = 0x8B50 + FLOAT_VEC3 = 0x8B51 + FLOAT_VEC4 = 0x8B52 + INT_VEC2 = 0x8B53 + INT_VEC3 = 0x8B54 + INT_VEC4 = 0x8B55 + BOOL = 0x8B56 + BOOL_VEC2 = 0x8B57 + BOOL_VEC3 = 0x8B58 + BOOL_VEC4 = 0x8B59 + FLOAT_MAT2 = 0x8B5A + FLOAT_MAT3 = 0x8B5B + FLOAT_MAT4 = 0x8B5C + SAMPLER_1D = 0x8B5D + SAMPLER_2D = 0x8B5E + SAMPLER_3D = 0x8B5F + SAMPLER_CUBE = 0x8B60 + SAMPLER_1D_SHADOW = 0x8B61 + SAMPLER_2D_SHADOW = 0x8B62 + FLOAT_MAT2x3 = 0x8B65 + FLOAT_MAT2x4 = 0x8B66 + FLOAT_MAT3x2 = 0x8B67 + FLOAT_MAT3x4 = 0x8B68 + FLOAT_MAT4x2 = 0x8B69 + FLOAT_MAT4x3 = 0x8B6A + DELETE_STATUS = 0x8B80 + COMPILE_STATUS = 0x8B81 + LINK_STATUS = 0x8B82 + VALIDATE_STATUS = 0x8B83 + INFO_LOG_LENGTH = 0x8B84 + ATTACHED_SHADERS = 0x8B85 + ACTIVE_UNIFORMS = 0x8B86 + ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87 + SHADER_SOURCE_LENGTH = 0x8B88 + ACTIVE_ATTRIBUTES = 0x8B89 + ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A + SHADING_LANGUAGE_VERSION = 0x8B8C + CURRENT_PROGRAM = 0x8B8D + SRGB = 0x8C40 + SRGB8 = 0x8C41 + SRGB_ALPHA = 0x8C42 + SRGB8_ALPHA8 = 0x8C43 + SLUMINANCE_ALPHA = 0x8C44 + SLUMINANCE8_ALPHA8 = 0x8C45 + SLUMINANCE = 0x8C46 + SLUMINANCE8 = 0x8C47 + COMPRESSED_SRGB = 0x8C48 + COMPRESSED_SRGB_ALPHA = 0x8C49 + COMPRESSED_SLUMINANCE = 0x8C4A + COMPRESSED_SLUMINANCE_ALPHA = 0x8C4B + POINT_SPRITE_COORD_ORIGIN = 0x8CA0 + LOWER_LEFT = 0x8CA1 + UPPER_LEFT = 0x8CA2 + STENCIL_BACK_REF = 0x8CA3 + STENCIL_BACK_VALUE_MASK = 0x8CA4 + STENCIL_BACK_WRITEMASK = 0x8CA5 +) + +// https://www.opengl.org/sdk/docs/man2/xhtml/glViewport.xml +func (gl *GL) Viewport(x, y, width, height int) { + C.gl2_1_glViewport(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// DepthRange specifies the mapping of depth values from normalized device +// coordinates to window coordinates. +// +// Parameter nearVal specifies the mapping of the near clipping plane to window +// coordinates (defaults to 0), while farVal specifies the mapping of the far +// clipping plane to window coordinates (defaults to 1). +// +// After clipping and division by w, depth coordinates range from -1 to 1, +// corresponding to the near and far clipping planes. DepthRange specifies a +// linear mapping of the normalized depth coordinates in this range to window +// depth coordinates. Regardless of the actual depth buffer implementation, +// window coordinate depth values are treated as though they range from 0 through 1 +// (like color components). Thus, the values accepted by DepthRange are both +// clamped to this range before they are accepted. +// +// The default setting of (0, 1) maps the near plane to 0 and the far plane to 1. +// With this mapping, the depth buffer range is fully utilized. +// +// It is not necessary that nearVal be less than farVal. Reverse mappings such as +// nearVal 1, and farVal 0 are acceptable. +// +// GL.INVALID_OPERATION is generated if DepthRange is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) DepthRange(nearVal, farVal float64) { + C.gl2_1_glDepthRange(gl.funcs, C.GLdouble(nearVal), C.GLdouble(farVal)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsEnabled.xml +func (gl *GL) IsEnabled(cap glbase.Enum) bool { + glresult := C.gl2_1_glIsEnabled(gl.funcs, C.GLenum(cap)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexLevelParameteriv.xml +func (gl *GL) GetTexLevelParameteriv(target glbase.Enum, level int, pname glbase.Enum, params []int32) { + C.gl2_1_glGetTexLevelParameteriv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexLevelParameterfv.xml +func (gl *GL) GetTexLevelParameterfv(target glbase.Enum, level int, pname glbase.Enum, params []float32) { + C.gl2_1_glGetTexLevelParameterfv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexParameteriv.xml +func (gl *GL) GetTexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl2_1_glGetTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexParameterfv.xml +func (gl *GL) GetTexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl2_1_glGetTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexImage.xml +func (gl *GL) GetTexImage(target glbase.Enum, level int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glGetTexImage(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetIntegerv.xml +func (gl *GL) GetIntegerv(pname glbase.Enum, params []int32) { + C.gl2_1_glGetIntegerv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetFloatv.xml +func (gl *GL) GetFloatv(pname glbase.Enum, params []float32) { + C.gl2_1_glGetFloatv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetError.xml +func (gl *GL) GetError() glbase.Enum { + glresult := C.gl2_1_glGetError(gl.funcs) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetDoublev.xml +func (gl *GL) GetDoublev(pname glbase.Enum, params []float64) { + C.gl2_1_glGetDoublev(gl.funcs, C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetBooleanv.xml +func (gl *GL) GetBooleanv(pname glbase.Enum, params []bool) { + C.gl2_1_glGetBooleanv(gl.funcs, C.GLenum(pname), (*C.GLboolean)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glReadPixels.xml +func (gl *GL) ReadPixels(x, y, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glReadPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glReadBuffer.xml +func (gl *GL) ReadBuffer(mode glbase.Enum) { + C.gl2_1_glReadBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelStorei.xml +func (gl *GL) PixelStorei(pname glbase.Enum, param int32) { + C.gl2_1_glPixelStorei(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelStoref.xml +func (gl *GL) PixelStoref(pname glbase.Enum, param float32) { + C.gl2_1_glPixelStoref(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDepthFunc.xml +func (gl *GL) DepthFunc(glfunc glbase.Enum) { + C.gl2_1_glDepthFunc(gl.funcs, C.GLenum(glfunc)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilOp.xml +func (gl *GL) StencilOp(fail, zfail, zpass glbase.Enum) { + C.gl2_1_glStencilOp(gl.funcs, C.GLenum(fail), C.GLenum(zfail), C.GLenum(zpass)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilFunc.xml +func (gl *GL) StencilFunc(glfunc glbase.Enum, ref int32, mask uint32) { + C.gl2_1_glStencilFunc(gl.funcs, C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLogicOp.xml +func (gl *GL) LogicOp(opcode glbase.Enum) { + C.gl2_1_glLogicOp(gl.funcs, C.GLenum(opcode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBlendFunc.xml +func (gl *GL) BlendFunc(sfactor, dfactor glbase.Enum) { + C.gl2_1_glBlendFunc(gl.funcs, C.GLenum(sfactor), C.GLenum(dfactor)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFlush.xml +func (gl *GL) Flush() { + C.gl2_1_glFlush(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFinish.xml +func (gl *GL) Finish() { + C.gl2_1_glFinish(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEnable.xml +func (gl *GL) Enable(cap glbase.Enum) { + C.gl2_1_glEnable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDisable.xml +func (gl *GL) Disable(cap glbase.Enum) { + C.gl2_1_glDisable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDepthMask.xml +func (gl *GL) DepthMask(flag bool) { + C.gl2_1_glDepthMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorMask.xml +func (gl *GL) ColorMask(red, green, blue, alpha bool) { + C.gl2_1_glColorMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&red)), *(*C.GLboolean)(unsafe.Pointer(&green)), *(*C.GLboolean)(unsafe.Pointer(&blue)), *(*C.GLboolean)(unsafe.Pointer(&alpha))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilMask.xml +func (gl *GL) StencilMask(mask uint32) { + C.gl2_1_glStencilMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearDepth.xml +func (gl *GL) ClearDepth(depth float64) { + C.gl2_1_glClearDepth(gl.funcs, C.GLdouble(depth)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearStencil.xml +func (gl *GL) ClearStencil(s int32) { + C.gl2_1_glClearStencil(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearColor.xml +func (gl *GL) ClearColor(red, green, blue, alpha float32) { + C.gl2_1_glClearColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClear.xml +func (gl *GL) Clear(mask glbase.Bitfield) { + C.gl2_1_glClear(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawBuffer.xml +func (gl *GL) DrawBuffer(mode glbase.Enum) { + C.gl2_1_glDrawBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexImage2D.xml +func (gl *GL) TexImage2D(target glbase.Enum, level int, internalFormat int32, width, height, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexImage1D.xml +func (gl *GL) TexImage1D(target glbase.Enum, level int, internalFormat int32, width, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameteriv.xml +func (gl *GL) TexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl2_1_glTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameteri.xml +func (gl *GL) TexParameteri(target, pname glbase.Enum, param int32) { + C.gl2_1_glTexParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameterfv.xml +func (gl *GL) TexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl2_1_glTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameterf.xml +func (gl *GL) TexParameterf(target, pname glbase.Enum, param float32) { + C.gl2_1_glTexParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glScissor.xml +func (gl *GL) Scissor(x, y, width, height int) { + C.gl2_1_glScissor(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPolygonMode.xml +func (gl *GL) PolygonMode(face, mode glbase.Enum) { + C.gl2_1_glPolygonMode(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPointSize.xml +func (gl *GL) PointSize(size float32) { + C.gl2_1_glPointSize(gl.funcs, C.GLfloat(size)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLineWidth.xml +func (gl *GL) LineWidth(width float32) { + C.gl2_1_glLineWidth(gl.funcs, C.GLfloat(width)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glHint.xml +func (gl *GL) Hint(target, mode glbase.Enum) { + C.gl2_1_glHint(gl.funcs, C.GLenum(target), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFrontFace.xml +func (gl *GL) FrontFace(mode glbase.Enum) { + C.gl2_1_glFrontFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCullFace.xml +func (gl *GL) CullFace(mode glbase.Enum) { + C.gl2_1_glCullFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexubv.xml +func (gl *GL) Indexubv(c []uint8) { + C.gl2_1_glIndexubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexub.xml +func (gl *GL) Indexub(c uint8) { + C.gl2_1_glIndexub(gl.funcs, C.GLubyte(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsTexture.xml +func (gl *GL) IsTexture(texture glbase.Texture) bool { + glresult := C.gl2_1_glIsTexture(gl.funcs, C.GLuint(texture)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenTextures returns n texture names in textures. There is no guarantee +// that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenTextures. +// +// The generated textures have no dimensionality; they assume the +// dimensionality of the texture target to which they are first bound (see +// BindTexture). +// +// Texture names returned by a call to GenTextures are not returned by +// subsequent calls, unless they are first deleted with DeleteTextures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenTextures is available in GL version 2.0 or greater. +func (gl *GL) GenTextures(n int) []glbase.Texture { + if n == 0 { + return nil + } + textures := make([]glbase.Texture, n) + C.gl2_1_glGenTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) + return textures +} + +// DeleteTextures deletes the textures objects whose names are stored +// in the textures slice. After a texture is deleted, it has no contents or +// dimensionality, and its name is free for reuse (for example by +// GenTextures). If a texture that is currently bound is deleted, the binding +// reverts to 0 (the default texture). +// +// DeleteTextures silently ignores 0's and names that do not correspond to +// existing textures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteTextures is available in GL version 2.0 or greater. +func (gl *GL) DeleteTextures(textures []glbase.Texture) { + n := len(textures) + if n == 0 { + return + } + C.gl2_1_glDeleteTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBindTexture.xml +func (gl *GL) BindTexture(target glbase.Enum, texture glbase.Texture) { + C.gl2_1_glBindTexture(gl.funcs, C.GLenum(target), C.GLuint(texture)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexSubImage2D.xml +func (gl *GL) TexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexSubImage1D.xml +func (gl *GL) TexSubImage1D(target glbase.Enum, level, xoffset, width int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexSubImage2D.xml +func (gl *GL) CopyTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, x, y, width, height int) { + C.gl2_1_glCopyTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexSubImage1D.xml +func (gl *GL) CopyTexSubImage1D(target glbase.Enum, level, xoffset, x, y, width int) { + C.gl2_1_glCopyTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexImage2D.xml +func (gl *GL) CopyTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, height, border int) { + C.gl2_1_glCopyTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexImage1D.xml +func (gl *GL) CopyTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, border int) { + C.gl2_1_glCopyTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPolygonOffset.xml +func (gl *GL) PolygonOffset(factor, units float32) { + C.gl2_1_glPolygonOffset(gl.funcs, C.GLfloat(factor), C.GLfloat(units)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawElements.xml +func (gl *GL) DrawElements(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glDrawElements(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawArrays.xml +func (gl *GL) DrawArrays(mode glbase.Enum, first, count int) { + C.gl2_1_glDrawArrays(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexSubImage3D.xml +func (gl *GL) CopyTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, x, y, width, height int) { + C.gl2_1_glCopyTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexSubImage3D.xml +func (gl *GL) TexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexImage3D.xml +func (gl *GL) TexImage3D(target glbase.Enum, level int, internalFormat int32, width, height int, depth int32, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawRangeElements.xml +func (gl *GL) DrawRangeElements(mode glbase.Enum, start, end uint32, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glDrawRangeElements(gl.funcs, C.GLenum(mode), C.GLuint(start), C.GLuint(end), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBlendEquation.xml +func (gl *GL) BlendEquation(mode glbase.Enum) { + C.gl2_1_glBlendEquation(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBlendColor.xml +func (gl *GL) BlendColor(red, green, blue, alpha float32) { + C.gl2_1_glBlendColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetCompressedTexImage.xml +func (gl *GL) GetCompressedTexImage(target glbase.Enum, level int, img interface{}) { + var img_ptr unsafe.Pointer + var img_v = reflect.ValueOf(img) + if img != nil && img_v.Kind() != reflect.Slice { + panic("parameter img must be a slice") + } + if img != nil { + img_ptr = unsafe.Pointer(img_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glGetCompressedTexImage(gl.funcs, C.GLenum(target), C.GLint(level), img_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCompressedTexSubImage1D.xml +func (gl *GL) CompressedTexSubImage1D(target glbase.Enum, level, xoffset, width int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glCompressedTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCompressedTexSubImage2D.xml +func (gl *GL) CompressedTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glCompressedTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCompressedTexSubImage3D.xml +func (gl *GL) CompressedTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glCompressedTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCompressedTexImage1D.xml +func (gl *GL) CompressedTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, width, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glCompressedTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCompressedTexImage2D.xml +func (gl *GL) CompressedTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glCompressedTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCompressedTexImage3D.xml +func (gl *GL) CompressedTexImage3D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height int, depth int32, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glCompressedTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSampleCoverage.xml +func (gl *GL) SampleCoverage(value float32, invert bool) { + C.gl2_1_glSampleCoverage(gl.funcs, C.GLfloat(value), *(*C.GLboolean)(unsafe.Pointer(&invert))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glActiveTexture.xml +func (gl *GL) ActiveTexture(texture glbase.Enum) { + C.gl2_1_glActiveTexture(gl.funcs, C.GLenum(texture)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPointParameteriv.xml +func (gl *GL) PointParameteriv(pname glbase.Enum, params []int32) { + C.gl2_1_glPointParameteriv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPointParameteri.xml +func (gl *GL) PointParameteri(pname glbase.Enum, param int32) { + C.gl2_1_glPointParameteri(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPointParameterfv.xml +func (gl *GL) PointParameterfv(pname glbase.Enum, params []float32) { + C.gl2_1_glPointParameterfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPointParameterf.xml +func (gl *GL) PointParameterf(pname glbase.Enum, param float32) { + C.gl2_1_glPointParameterf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiDrawArrays.xml +func (gl *GL) MultiDrawArrays(mode glbase.Enum, first, count []int, drawcount int32) { + C.gl2_1_glMultiDrawArrays(gl.funcs, C.GLenum(mode), (*C.GLint)(unsafe.Pointer(&first[0])), (*C.GLsizei)(unsafe.Pointer(&count[0])), C.GLsizei(drawcount)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBlendFuncSeparate.xml +func (gl *GL) BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha glbase.Enum) { + C.gl2_1_glBlendFuncSeparate(gl.funcs, C.GLenum(sfactorRGB), C.GLenum(dfactorRGB), C.GLenum(sfactorAlpha), C.GLenum(dfactorAlpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetBufferParameteriv.xml +func (gl *GL) GetBufferParameteriv(target, pname glbase.Enum, params []int32) { + C.gl2_1_glGetBufferParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glUnmapBuffer.xml +func (gl *GL) UnmapBuffer(target glbase.Enum) bool { + glresult := C.gl2_1_glUnmapBuffer(gl.funcs, C.GLenum(target)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetBufferSubData.xml +func (gl *GL) GetBufferSubData(target glbase.Enum, offset, size int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glGetBufferSubData(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(size), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBufferSubData.xml +func (gl *GL) BufferSubData(target glbase.Enum, offset, size int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glBufferSubData(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(size), data_ptr) +} + +// BufferData creates a new data store for the buffer object currently +// bound to target. Any pre-existing data store is deleted. The new data +// store is created with the specified size in bytes and usage. If data is +// not nil, it must be a slice that is used to initialize the data store. +// In that case the size parameter is ignored and the store size will match +// the slice data size. +// +// In its initial state, the new data store is not mapped, it has a NULL +// mapped pointer, and its mapped access is GL.READ_WRITE. +// +// The target constant must be one of GL.ARRAY_BUFFER, GL.COPY_READ_BUFFER, +// GL.COPY_WRITE_BUFFER, GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER, +// GL.PIXEL_UNPACK_BUFFER, GL.TEXTURE_BUFFER, GL.TRANSFORM_FEEDBACK_BUFFER, +// or GL.UNIFORM_BUFFER. +// +// The usage parameter is a hint to the GL implementation as to how a buffer +// object's data store will be accessed. This enables the GL implementation +// to make more intelligent decisions that may significantly impact buffer +// object performance. It does not, however, constrain the actual usage of +// the data store. usage can be broken down into two parts: first, the +// frequency of access (modification and usage), and second, the nature of +// that access. +// +// A usage frequency of STREAM and nature of DRAW is specified via the +// constant GL.STREAM_DRAW, for example. +// +// The usage frequency of access may be one of: +// +// STREAM +// The data store contents will be modified once and used at most a few times. +// +// STATIC +// The data store contents will be modified once and used many times. +// +// DYNAMIC +// The data store contents will be modified repeatedly and used many times. +// +// The usage nature of access may be one of: +// +// DRAW +// The data store contents are modified by the application, and used as +// the source for GL drawing and image specification commands. +// +// READ +// The data store contents are modified by reading data from the GL, +// and used to return that data when queried by the application. +// +// COPY +// The data store contents are modified by reading data from the GL, +// and used as the source for GL drawing and image specification +// commands. +// +// Clients must align data elements consistent with the requirements of the +// client platform, with an additional base-level requirement that an offset +// within a buffer to a datum comprising N bytes be a multiple of N. +// +// Error GL.INVALID_ENUM is generated if target is not one of the accepted +// buffer targets. GL.INVALID_ENUM is generated if usage is not +// GL.STREAM_DRAW, GL.STREAM_READ, GL.STREAM_COPY, GL.STATIC_DRAW, +// GL.STATIC_READ, GL.STATIC_COPY, GL.DYNAMIC_DRAW, GL.DYNAMIC_READ, or +// GL.DYNAMIC_COPY. GL.INVALID_VALUE is generated if size is negative. +// GL.INVALID_OPERATION is generated if the reserved buffer object name 0 is +// bound to target. GL.OUT_OF_MEMORY is generated if the GL is unable to +// create a data store with the specified size. +func (gl *GL) BufferData(target glbase.Enum, size int, data interface{}, usage glbase.Enum) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + if data != nil { + size = int(data_v.Type().Size()) * data_v.Len() + } + C.gl2_1_glBufferData(gl.funcs, C.GLenum(target), C.GLsizeiptr(size), data_ptr, C.GLenum(usage)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsBuffer.xml +func (gl *GL) IsBuffer(buffer glbase.Buffer) bool { + glresult := C.gl2_1_glIsBuffer(gl.funcs, C.GLuint(buffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenBuffers returns n buffer object names. There is no guarantee that +// the names form a contiguous set of integers; however, it is guaranteed +// that none of the returned names was in use immediately before the call to +// GenBuffers. +// +// Buffer object names returned by a call to GenBuffers are not returned by +// subsequent calls, unless they are first deleted with DeleteBuffers. +// +// No buffer objects are associated with the returned buffer object names +// until they are first bound by calling BindBuffer. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if GenBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// GenBuffers is available in GL version 1.5 or greater. +func (gl *GL) GenBuffers(n int) []glbase.Buffer { + if n == 0 { + return nil + } + buffers := make([]glbase.Buffer, n) + C.gl2_1_glGenBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) + return buffers +} + +// DeleteBuffers deletes the buffer objects whose names are stored in the +// buffers slice. +// +// After a buffer object is deleted, it has no contents, and its name is free +// for reuse (for example by GenBuffers). If a buffer object that is +// currently bound is deleted, the binding reverts to 0 (the absence of any +// buffer object, which reverts to client memory usage). +// +// DeleteBuffers silently ignores 0's and names that do not correspond to +// existing buffer objects. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if DeleteBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// DeleteBuffers is available in GL version 1.5 or greater. +func (gl *GL) DeleteBuffers(buffers []glbase.Buffer) { + n := len(buffers) + if n == 0 { + return + } + C.gl2_1_glDeleteBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) +} + +// BindBuffer creates or puts in use a named buffer object. +// Calling BindBuffer with target set to GL.ARRAY_BUFFER, +// GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER or GL.PIXEL_UNPACK_BUFFER +// and buffer set to the name of the new buffer object binds the buffer +// object name to the target. When a buffer object is bound to a target, the +// previous binding for that target is automatically broken. +// +// Buffer object names are unsigned integers. The value zero is reserved, but +// there is no default buffer object for each buffer object target. Instead, +// buffer set to zero effectively unbinds any buffer object previously bound, +// and restores client memory usage for that buffer object target. Buffer +// object names and the corresponding buffer object contents are local to the +// shared display-list space (see XCreateContext) of the current GL rendering +// context; two rendering contexts share buffer object names only if they +// also share display lists. +// +// GenBuffers may be called to generate a set of new buffer object names. +// +// The state of a buffer object immediately after it is first bound is an +// unmapped zero-sized memory buffer with GL.READ_WRITE access and +// GL.STATIC_DRAW usage. +// +// While a non-zero buffer object name is bound, GL operations on the target +// to which it is bound affect the bound buffer object, and queries of the +// target to which it is bound return state from the bound buffer object. +// While buffer object name zero is bound, as in the initial state, attempts +// to modify or query state on the target to which it is bound generates an +// GL.INVALID_OPERATION error. +// +// When vertex array pointer state is changed, for example by a call to +// NormalPointer, the current buffer object binding (GL.ARRAY_BUFFER_BINDING) +// is copied into the corresponding client state for the vertex array type +// being changed, for example GL.NORMAL_ARRAY_BUFFER_BINDING. While a +// non-zero buffer object is bound to the GL.ARRAY_BUFFER target, the vertex +// array pointer parameter that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.ELEMENT_ARRAY_BUFFER +// target, the indices parameter of DrawElements, DrawRangeElements, or +// MultiDrawElements that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_PACK_BUFFER +// target, the following commands are affected: GetCompressedTexImage, +// GetConvolutionFilter, GetHistogram, GetMinmax, GetPixelMap, +// GetPolygonStipple, GetSeparableFilter, GetTexImage, and ReadPixels. The +// pointer parameter that is traditionally interpreted as a pointer to +// client-side memory where the pixels are to be packed is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_UNPACK_BUFFER +// target, the following commands are affected: Bitmap, ColorSubTable, +// ColorTable, CompressedTexImage1D, CompressedTexImage2D, +// CompressedTexImage3D, CompressedTexSubImage1D, CompressedTexSubImage2D, +// CompressedTexSubImage3D, ConvolutionFilter1D, ConvolutionFilter2D, +// DrawPixels, PixelMap, PolygonStipple, SeparableFilter2D, TexImage1D, +// TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, and TexSubImage3D. +// The pointer parameter that is traditionally interpreted as a pointer to +// client-side memory from which the pixels are to be unpacked is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// A buffer object binding created with BindBuffer remains active until a +// different buffer object name is bound to the same target, or until the +// bound buffer object is deleted with DeleteBuffers. +// +// Once created, a named buffer object may be re-bound to any target as often +// as needed. However, the GL implementation may make choices about how to +// optimize the storage of a buffer object based on its initial binding +// target. +// +// Error GL.INVALID_ENUM is generated if target is not one of the allowable +// values. GL.INVALID_OPERATION is generated if BindBuffer is executed +// between the execution of Begin and the corresponding execution of End. +// +// BindBuffer is available in GL version 1.5 or greater. +func (gl *GL) BindBuffer(target glbase.Enum, buffer glbase.Buffer) { + C.gl2_1_glBindBuffer(gl.funcs, C.GLenum(target), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetQueryObjectuiv.xml +func (gl *GL) GetQueryObjectuiv(id uint32, pname glbase.Enum, params []uint32) { + C.gl2_1_glGetQueryObjectuiv(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetQueryObjectiv.xml +func (gl *GL) GetQueryObjectiv(id uint32, pname glbase.Enum, params []int32) { + C.gl2_1_glGetQueryObjectiv(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetQueryiv.xml +func (gl *GL) GetQueryiv(target, pname glbase.Enum, params []int32) { + C.gl2_1_glGetQueryiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEndQuery.xml +func (gl *GL) EndQuery(target glbase.Enum) { + C.gl2_1_glEndQuery(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBeginQuery.xml +func (gl *GL) BeginQuery(target glbase.Enum, id uint32) { + C.gl2_1_glBeginQuery(gl.funcs, C.GLenum(target), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsQuery.xml +func (gl *GL) IsQuery(id uint32) bool { + glresult := C.gl2_1_glIsQuery(gl.funcs, C.GLuint(id)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDeleteQueries.xml +func (gl *GL) DeleteQueries(n int, ids []uint32) { + C.gl2_1_glDeleteQueries(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGenQueries.xml +func (gl *GL) GenQueries(n int, ids []uint32) { + C.gl2_1_glGenQueries(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// VertexAttribPointer specifies the location and data format of the array +// of generic vertex attributes at index to use when rendering. size +// specifies the number of components per attribute and must be 1, 2, 3, or +// 4. type specifies the data type of each component, and stride specifies +// the byte stride from one attribute to the next, allowing vertices and +// attributes to be packed into a single array or stored in separate arrays. +// normalized indicates whether the values stored in an integer format are +// to be mapped to the range [-1,1] (for signed values) or [0,1] +// (for unsigned values) when they are accessed and converted to floating +// point; otherwise, values will be converted to floats directly without +// normalization. offset is a byte offset into the buffer object's data +// store, which must be bound to the GL.ARRAY_BUFFER target with BindBuffer. +// +// The buffer object binding (GL.ARRAY_BUFFER_BINDING) is saved as +// generic vertex attribute array client-side state +// (GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING) for the provided index. +// +// To enable and disable a generic vertex attribute array, call +// EnableVertexAttribArray and DisableVertexAttribArray with index. If +// enabled, the generic vertex attribute array is used when DrawArrays or +// DrawElements is called. Each generic vertex attribute array is initially +// disabled. +// +// VertexAttribPointer is typically implemented on the client side. +// +// Error GL.INVALID_ENUM is generated if type is not an accepted value. +// GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_VALUE is generated if size is not 1, 2, +// 3, or 4. GL.INVALID_VALUE is generated if stride is negative. +func (gl *GL) VertexAttribPointer(index glbase.Attrib, size int, gltype glbase.Enum, normalized bool, stride int, offset uintptr) { + offset_ptr := unsafe.Pointer(offset) + C.gl2_1_glVertexAttribPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLsizei(stride), offset_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glValidateProgram.xml +func (gl *GL) ValidateProgram(program glbase.Program) { + C.gl2_1_glValidateProgram(gl.funcs, C.GLuint(program)) +} + +// UniformMatrix4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*4) != 0 { + panic("invalid value length for UniformMatrix4fv") + } + count := len(value) / (4 * 4) + C.gl2_1_glUniformMatrix4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*3) != 0 { + panic("invalid value length for UniformMatrix3fv") + } + count := len(value) / (3 * 3) + C.gl2_1_glUniformMatrix3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*2) != 0 { + panic("invalid value length for UniformMatrix2fv") + } + count := len(value) / (2 * 2) + C.gl2_1_glUniformMatrix2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform4iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4iv") + } + count := len(value) / 4 + C.gl2_1_glUniform4iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform3iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3iv") + } + count := len(value) / 3 + C.gl2_1_glUniform3iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform2iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2iv") + } + count := len(value) / 2 + C.gl2_1_glUniform2iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform1iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl2_1_glUniform1iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4fv") + } + count := len(value) / 4 + C.gl2_1_glUniform4fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3fv") + } + count := len(value) / 3 + C.gl2_1_glUniform3fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2fv") + } + count := len(value) / 2 + C.gl2_1_glUniform2fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform1fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl2_1_glUniform1fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform4i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4i(location glbase.Uniform, v0, v1, v2, v3 int32) { + C.gl2_1_glUniform4i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2), C.GLint(v3)) +} + +// Uniform3i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3i(location glbase.Uniform, v0, v1, v2 int32) { + C.gl2_1_glUniform3i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2)) +} + +// Uniform2i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2i(location glbase.Uniform, v0, v1 int32) { + C.gl2_1_glUniform2i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1)) +} + +// Uniform1i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1i(location glbase.Uniform, v0 int32) { + C.gl2_1_glUniform1i(gl.funcs, C.GLint(location), C.GLint(v0)) +} + +// Uniform4f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4f(location glbase.Uniform, v0, v1, v2, v3 float32) { + C.gl2_1_glUniform4f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2), C.GLfloat(v3)) +} + +// Uniform3f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3f(location glbase.Uniform, v0, v1, v2 float32) { + C.gl2_1_glUniform3f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2)) +} + +// Uniform2f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2f(location glbase.Uniform, v0, v1 float32) { + C.gl2_1_glUniform2f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1)) +} + +// Uniform1f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1f(location glbase.Uniform, v0 float32) { + C.gl2_1_glUniform1f(gl.funcs, C.GLint(location), C.GLfloat(v0)) +} + +// UseProgram installs the program object specified by program as part of +// current rendering state. One or more executables are created in a program +// object by successfully attaching shader objects to it with AttachShader, +// successfully compiling the shader objects with CompileShader, and +// successfully linking the program object with LinkProgram. +// +// A program object will contain an executable that will run on the vertex +// processor if it contains one or more shader objects of type +// GL.VERTEX_SHADER that have been successfully compiled and linked. +// Similarly, a program object will contain an executable that will run on +// the fragment processor if it contains one or more shader objects of type +// GL.FRAGMENT_SHADER that have been successfully compiled and linked. +// +// Successfully installing an executable on a programmable processor will +// cause the corresponding fixed functionality of OpenGL to be disabled. +// Specifically, if an executable is installed on the vertex processor, the +// OpenGL fixed functionality will be disabled as follows. +// +// - The modelview matrix is not applied to vertex coordinates. +// +// - The projection matrix is not applied to vertex coordinates. +// +// - The texture matrices are not applied to texture coordinates. +// +// - Normals are not transformed to eye coordinates. +// +// - Normals are not rescaled or normalized. +// +// - Normalization of GL.AUTO_NORMAL evaluated normals is not performed. +// +// - Texture coordinates are not generated automatically. +// +// - Per-vertex lighting is not performed. +// +// - Color material computations are not performed. +// +// - Color index lighting is not performed. +// +// - This list also applies when setting the current raster position. +// +// The executable that is installed on the vertex processor is expected to +// implement any or all of the desired functionality from the preceding list. +// Similarly, if an executable is installed on the fragment processor, the +// OpenGL fixed functionality will be disabled as follows. +// +// - Texture environment and texture functions are not applied. +// +// - Texture application is not applied. +// +// - Color sum is not applied. +// +// - Fog is not applied. +// +// Again, the fragment shader that is installed is expected to implement any +// or all of the desired functionality from the preceding list. +// +// While a program object is in use, applications are free to modify attached +// shader objects, compile attached shader objects, attach additional shader +// objects, and detach or delete shader objects. None of these operations +// will affect the executables that are part of the current state. However, +// relinking the program object that is currently in use will install the +// program object as part of the current rendering state if the link +// operation was successful (see LinkProgram). If the program object +// currently in use is relinked unsuccessfully, its link status will be set +// to GL.FALSE, but the executables and associated state will remain part of +// the current state until a subsequent call to UseProgram removes it from +// use. After it is removed from use, it cannot be made part of current state +// until it has been successfully relinked. +// +// If program contains shader objects of type GL.VERTEX_SHADER but it does +// not contain shader objects of type GL.FRAGMENT_SHADER, an executable will +// be installed on the vertex processor, but fixed functionality will be used +// for fragment processing. Similarly, if program contains shader objects of +// type GL.FRAGMENT_SHADER but it does not contain shader objects of type +// GL.VERTEX_SHADER, an executable will be installed on the fragment +// processor, but fixed functionality will be used for vertex processing. If +// program is 0, the programmable processors will be disabled, and fixed +// functionality will be used for both vertex and fragment processing. +// +// While a program object is in use, the state that controls the disabled +// fixed functionality may also be updated using the normal OpenGL calls. +// +// Like display lists and texture objects, the name space for program objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// Applications are responsible for providing the synchronization across API +// calls when objects are accessed from different execution threads. +// +// Error GL.INVALID_VALUE is generated if program is neither 0 nor a value +// generated by OpenGL. GL.INVALID_OPERATION is generated if program is not +// a program object. GL.INVALID_OPERATION is generated if program could not +// be made part of current state. GL.INVALID_OPERATION is generated if +// UseProgram is executed between the execution of Begin and the +// corresponding execution of End. +// +// UseProgram is available in GL version 2.0 or greater. +func (gl *GL) UseProgram(program glbase.Program) { + C.gl2_1_glUseProgram(gl.funcs, C.GLuint(program)) +} + +// ShaderSource sets the source code in shader to the provided source code. Any source +// code previously stored in the shader object is completely replaced. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_VALUE is generated if count is less than 0. +// GL.INVALID_OPERATION is generated if ShaderSource is executed between the +// execution of Begin and the corresponding execution of End. +// +// ShaderSource is available in GL version 2.0 or greater. +func (gl *GL) ShaderSource(shader glbase.Shader, source ...string) { + count := len(source) + length := make([]int32, count) + source_c := make([]unsafe.Pointer, count) + for i, src := range source { + length[i] = int32(len(src)) + if len(src) > 0 { + source_c[i] = *(*unsafe.Pointer)(unsafe.Pointer(&src)) + } else { + source_c[i] = unsafe.Pointer(uintptr(0)) + } + } + C.gl2_1_glShaderSource(gl.funcs, C.GLuint(shader), C.GLsizei(count), (**C.GLchar)(unsafe.Pointer(&source_c[0])), (*C.GLint)(unsafe.Pointer(&length[0]))) +} + +// LinkProgram links the program object specified by program. If any shader +// objects of type GL.VERTEX_SHADER are attached to program, they will be +// used to create an executable that will run on the programmable vertex +// processor. If any shader objects of type GL.FRAGMENT_SHADER are attached +// to program, they will be used to create an executable that will run on the +// programmable fragment processor. +// +// The status of the link operation will be stored as part of the program +// object's state. This value will be set to GL.TRUE if the program object +// was linked without errors and is ready for use, and GL.FALSE otherwise. It +// can be queried by calling GetProgramiv with arguments program and +// GL.LINK_STATUS. +// +// As a result of a successful link operation, all active user-defined +// uniform variables belonging to program will be initialized to 0, and each +// of the program object's active uniform variables will be assigned a +// location that can be queried by calling GetUniformLocation. Also, any +// active user-defined attribute variables that have not been bound to a +// generic vertex attribute index will be bound to one at this time. +// +// Linking of a program object can fail for a number of reasons as specified +// in the OpenGL Shading Language Specification. The following lists some of +// the conditions that will cause a link error. +// +// - The number of active attribute variables supported by the +// implementation has been exceeded. +// +// - The storage limit for uniform variables has been exceeded. +// +// - The number of active uniform variables supported by the implementation +// has been exceeded. +// +// - The main function is missing for the vertex shader or the fragment +// shader. +// +// - A varying variable actually used in the fragment shader is not +// declared in the same way (or is not declared at all) in the vertex +// shader. +// +// - A reference to a function or variable name is unresolved. +// +// - A shared global is declared with two different types or two different +// initial values. +// +// - One or more of the attached shader objects has not been successfully +// compiled. +// +// - Binding a generic attribute matrix caused some rows of the matrix to +// fall outside the allowed maximum of GL.MAX_VERTEX_ATTRIBS. +// +// - Not enough contiguous vertex attribute slots could be found to bind +// attribute matrices. +// +// When a program object has been successfully linked, the program object can +// be made part of current state by calling UseProgram. Whether or not the +// link operation was successful, the program object's information log will +// be overwritten. The information log can be retrieved by calling +// GetProgramInfoLog. +// +// LinkProgram will also install the generated executables as part of the +// current rendering state if the link operation was successful and the +// specified program object is already currently in use as a result of a +// previous call to UseProgram. If the program object currently in use is +// relinked unsuccessfully, its link status will be set to GL.FALSE , but the +// executables and associated state will remain part of the current state +// until a subsequent call to UseProgram removes it from use. After it is +// removed from use, it cannot be made part of current state until it has +// been successfully relinked. +// +// If program contains shader objects of type GL.VERTEX_SHADER but does not +// contain shader objects of type GL.FRAGMENT_SHADER, the vertex shader will +// be linked against the implicit interface for fixed functionality fragment +// processing. Similarly, if program contains shader objects of type +// GL.FRAGMENT_SHADER but it does not contain shader objects of type +// GL.VERTEX_SHADER, the fragment shader will be linked against the implicit +// interface for fixed functionality vertex processing. +// +// The program object's information log is updated and the program is +// generated at the time of the link operation. After the link operation, +// applications are free to modify attached shader objects, compile attached +// shader objects, detach shader objects, delete shader objects, and attach +// additional shader objects. None of these operations affects the +// information log or the program that is part of the program object. +// +// If the link operation is unsuccessful, any information about a previous +// link operation on program is lost (a failed link does not restore the +// old state of program). Certain information can still be retrieved +// from program even after an unsuccessful link operation. See for instance +// GetActiveAttrib and GetActiveUniform. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if LinkProgram is executed +// between the execution of Begin and the corresponding execution of End. +// +// LinkProgram is available in GL version 2.0 or greater. +func (gl *GL) LinkProgram(program glbase.Program) { + C.gl2_1_glLinkProgram(gl.funcs, C.GLuint(program)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsShader.xml +func (gl *GL) IsShader(shader glbase.Shader) bool { + glresult := C.gl2_1_glIsShader(gl.funcs, C.GLuint(shader)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsProgram.xml +func (gl *GL) IsProgram(program glbase.Program) bool { + glresult := C.gl2_1_glIsProgram(gl.funcs, C.GLuint(program)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GetVertexAttribiv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribiv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribiv(index glbase.Attrib, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl2_1_glGetVertexAttribiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetVertexAttribfv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribfv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribfv(index glbase.Attrib, pname glbase.Enum, params []float32) { + var params_c [4]float32 + C.gl2_1_glGetVertexAttribfv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetVertexAttribdv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribdv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribdv(index glbase.Attrib, pname glbase.Enum, params []float64) { + var params_c [4]float64 + C.gl2_1_glGetVertexAttribdv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformiv returns in params the value of the specified uniform +// variable. The type of the uniform variable specified by location +// determines the number of values returned. If the uniform variable is +// defined in the shader as a boolean, int, or float, a single value will be +// returned. If it is defined as a vec2, ivec2, or bvec2, two values will be +// returned. If it is defined as a vec3, ivec3, or bvec3, three values will +// be returned, and so on. To query values stored in uniform variables +// declared as arrays, call GetUniformiv for each element of the array. To +// query values stored in uniform variables declared as structures, call +// GetUniformiv for each field in the structure. The values for uniform +// variables declared as a matrix will be returned in column major order. +// +// The locations assigned to uniform variables are not known until the +// program object is linked. After linking has occurred, the command +// GetUniformLocation can be used to obtain the location of a uniform +// variable. This location value can then be passed to GetUniformiv in order +// to query the current value of the uniform variable. After a program object +// has been linked successfully, the index values for uniform variables +// remain fixed until the next link command occurs. The uniform variable +// values can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if program has not been +// successfully linked. GL.INVALID_OPERATION is generated if location does +// not correspond to a valid uniform variable location for the specified +// program object. GL.INVALID_OPERATION is generated if GetUniformiv is +// executed between the execution of Begin and the corresponding execution of +// End. +// +// GetUniformiv is available in GL version 2.0 or greater. +func (gl *GL) GetUniformiv(program glbase.Program, location glbase.Uniform, params []int32) { + var params_c [4]int32 + C.gl2_1_glGetUniformiv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformfv returns in params the value of the specified uniform +// variable. The type of the uniform variable specified by location +// determines the number of values returned. If the uniform variable is +// defined in the shader as a boolean, int, or float, a single value will be +// returned. If it is defined as a vec2, ivec2, or bvec2, two values will be +// returned. If it is defined as a vec3, ivec3, or bvec3, three values will +// be returned, and so on. To query values stored in uniform variables +// declared as arrays, call GetUniformfv for each element of the array. To +// query values stored in uniform variables declared as structures, call +// GetUniformfv for each field in the structure. The values for uniform +// variables declared as a matrix will be returned in column major order. +// +// The locations assigned to uniform variables are not known until the +// program object is linked. After linking has occurred, the command +// GetUniformLocation can be used to obtain the location of a uniform +// variable. This location value can then be passed to GetUniformfv in order +// to query the current value of the uniform variable. After a program object +// has been linked successfully, the index values for uniform variables +// remain fixed until the next link command occurs. The uniform variable +// values can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if program has not been +// successfully linked. GL.INVALID_OPERATION is generated if location does +// not correspond to a valid uniform variable location for the specified +// program object. GL.INVALID_OPERATION is generated if GetUniformfv is +// executed between the execution of Begin and the corresponding execution of +// End. +// +// GetUniformfv is available in GL version 2.0 or greater. +func (gl *GL) GetUniformfv(program glbase.Program, location glbase.Uniform, params []float32) { + var params_c [4]float32 + C.gl2_1_glGetUniformfv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLfloat)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformLocation returns an integer that represents the location of a +// specific uniform variable within a program object. name must be an active +// uniform variable name in program that is not a structure, an array of +// structures, or a subcomponent of a vector or a matrix. This function +// returns -1 if name does not correspond to an active uniform variable in +// program or if name starts with the reserved prefix "gl_". +// +// Uniform variables that are structures or arrays of structures may be +// queried by calling GetUniformLocation for each field within the +// structure. The array element operator "[]" and the structure field +// operator "." may be used in name in order to select elements within an +// array or fields within a structure. The result of using these operators is +// not allowed to be another structure, an array of structures, or a +// subcomponent of a vector or a matrix. Except if the last part of name +// indicates a uniform variable array, the location of the first element of +// an array can be retrieved by using the name of the array, or by using the +// name appended by "[0]". +// +// The actual locations assigned to uniform variables are not known until the +// program object is linked successfully. After linking has occurred, the +// command GetUniformLocation can be used to obtain the location of a +// uniform variable. This location value can then be passed to Uniform to +// set the value of the uniform variable or to GetUniform in order to query +// the current value of the uniform variable. After a program object has been +// linked successfully, the index values for uniform variables remain fixed +// until the next link command occurs. Uniform variable locations and values +// can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program object. +// GL.INVALID_OPERATION is generated if program has not been successfully +// linked. GL.INVALID_OPERATION is generated if GetUniformLocation is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetUniformLocation is available in GL version 2.0 or greater. +func (gl *GL) GetUniformLocation(program glbase.Program, name string) glbase.Uniform { + name_cstr := C.CString(name) + glresult := C.gl2_1_glGetUniformLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) + return glbase.Uniform(glresult) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetShaderSource.xml +func (gl *GL) GetShaderSource(shader glbase.Shader, bufSize int32, length []int32, source []byte) { + C.gl2_1_glGetShaderSource(gl.funcs, C.GLuint(shader), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&source[0]))) +} + +// GetShaderInfoLog returns the information log for the specified shader +// object. The information log for a shader object is modified when the +// shader is compiled. +// +// The information log for a shader object is a string that may contain +// diagnostic messages, warning messages, and other information about the +// last compile operation. When a shader object is created, its information +// log will be a string of length 0, and the size of the current log can be +// obtained by calling GetShaderiv with the value GL.INFO_LOG_LENGTH. +// +// The information log for a shader object is the OpenGL implementer's +// primary mechanism for conveying information about the compilation process. +// Therefore, the information log can be helpful to application developers +// during the development process, even when compilation is successful. +// Application developers should not expect different OpenGL implementations +// to produce identical information logs. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_VALUE is generated if maxLength is less than 0. +// GL.INVALID_OPERATION is generated if GetShaderInfoLog is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetShaderInfoLog is available in GL version 2.0 or greater. +func (gl *GL) GetShaderInfoLog(shader glbase.Shader) []byte { + var params [1]int32 + var length int32 + gl.GetShaderiv(shader, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + C.gl2_1_glGetShaderInfoLog(gl.funcs, C.GLuint(shader), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length)), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) + return infoLog +} + +// GetShaderiv GetShader returns in params the value of a parameter for a specific +// shader object. The following parameters are defined: +// +// GL.SHADER_TYPE +// params returns GL.VERTEX_SHADER if shader is a vertex shader object, +// and GL.FRAGMENT_SHADER if shader is a fragment shader object. +// +// GL.DELETE_STATUS +// params returns GL.TRUE if shader is currently flagged for deletion, +// and GL.FALSE otherwise. +// +// GL.COMPILE_STATUS +// params returns GL.TRUE if the last compile operation on shader was +// successful, and GL.FALSE otherwise. +// +// GL.INFO_LOG_LENGTH +// params returns the number of characters in the information log for +// shader including the null termination character (the size of the +// character buffer required to store the information log). If shader has +// no information log, a value of 0 is returned. +// +// GL.SHADER_SOURCE_LENGTH +// params returns the length of the concatenation of the source strings +// that make up the shader source for the shader, including the null +// termination character. (the size of the character buffer +// required to store the shader source). If no source code exists, 0 is +// returned. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader does not refer to a +// shader object. GL.INVALID_ENUM is generated if pname is not an accepted +// value. GL.INVALID_OPERATION is generated if GetShader is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetShaderiv is available in GL version 2.0 or greater. +func (gl *GL) GetShaderiv(shader glbase.Shader, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl2_1_glGetShaderiv(gl.funcs, C.GLuint(shader), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetProgramInfoLog returns the information log for the specified program +// object. The information log for a program object is modified when the +// program object is linked or validated. +// +// The information log for a program object is either an empty string, or a +// string containing information about the last link operation, or a string +// containing information about the last validation operation. It may contain +// diagnostic messages, warning messages, and other information. When a +// program object is created, its information log will be a string of length +// 0, and the size of the current log can be obtained by calling GetProgramiv +// with the value GL.INFO_LOG_LENGTH. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated +// by OpenGL. GL.INVALID_OPERATION is generated if program is not a +// program object. +func (gl *GL) GetProgramInfoLog(program glbase.Program) []byte { + var params [1]int32 + var length int32 + gl.GetProgramiv(program, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + C.gl2_1_glGetProgramInfoLog(gl.funcs, C.GLuint(program), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length)), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) + return infoLog +} + +// GetProgramiv returns in params the value of a parameter for a specific +// program object. The following parameters are defined: +// +// GL.DELETE_STATUS +// params returns GL.TRUE if program is currently flagged for deletion, +// and GL.FALSE otherwise. +// +// GL.LINK_STATUS +// params returns GL.TRUE if the last link operation on program was +// successful, and GL.FALSE otherwise. +// +// GL.VALIDATE_STATUS +// params returns GL.TRUE or if the last validation operation on +// program was successful, and GL.FALSE otherwise. +// +// GL.INFO_LOG_LENGTH +// params returns the number of characters in the information log for +// program including the null termination character (the size of +// the character buffer required to store the information log). If +// program has no information log, a value of 0 is returned. +// +// GL.ATTACHED_SHADERS +// params returns the number of shader objects attached to program. +// +// GL.ACTIVE_ATTRIBUTES +// params returns the number of active attribute variables for program. +// +// GL.ACTIVE_ATTRIBUTE_MAX_LENGTH +// params returns the length of the longest active attribute name for +// program, including the null termination character (the size of +// the character buffer required to store the longest attribute name). +// If no active attributes exist, 0 is returned. +// +// GL.ACTIVE_UNIFORMS +// params returns the number of active uniform variables for program. +// +// GL.ACTIVE_UNIFORM_MAX_LENGTH +// params returns the length of the longest active uniform variable +// name for program, including the null termination character (i.e., +// the size of the character buffer required to store the longest +// uniform variable name). If no active uniform variables exist, 0 is +// returned. +// +// GL.TRANSFORM_FEEDBACK_BUFFER_MODE +// params returns a symbolic constant indicating the buffer mode used +// when transform feedback is active. This may be GL.SEPARATE_ATTRIBS +// or GL.INTERLEAVED_ATTRIBS. +// +// GL.TRANSFORM_FEEDBACK_VARYINGS +// params returns the number of varying variables to capture in transform +// feedback mode for the program. +// +// GL.TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH +// params returns the length of the longest variable name to be used for +// transform feedback, including the null-terminator. +// +// GL.GEOMETRY_VERTICES_OUT +// params returns the maximum number of vertices that the geometry shader in +// program will output. +// +// GL.GEOMETRY_INPUT_TYPE +// params returns a symbolic constant indicating the primitive type accepted +// as input to the geometry shader contained in program. +// +// GL.GEOMETRY_OUTPUT_TYPE +// params returns a symbolic constant indicating the primitive type that will +// be output by the geometry shader contained in program. +// +// GL.ACTIVE_UNIFORM_BLOCKS and GL.ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH are +// available only if the GL version 3.1 or greater. +// +// GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE and +// GL.GEOMETRY_OUTPUT_TYPE are accepted only if the GL version is 3.2 or +// greater. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program does not refer to a +// program object. GL.INVALID_OPERATION is generated if pname is +// GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE, or +// GL.GEOMETRY_OUTPUT_TYPE, and program does not contain a geometry shader. +// GL.INVALID_ENUM is generated if pname is not an accepted value. +func (gl *GL) GetProgramiv(program glbase.Program, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl2_1_glGetProgramiv(gl.funcs, C.GLuint(program), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetAttribLocation queries the previously linked program object specified +// by program for the attribute variable specified by name and returns the +// index of the generic vertex attribute that is bound to that attribute +// variable. If name is a matrix attribute variable, the index of the first +// column of the matrix is returned. If the named attribute variable is not +// an active attribute in the specified program object or if name starts with +// the reserved prefix "gl_", a value of -1 is returned. +// +// The association between an attribute variable name and a generic attribute +// index can be specified at any time by calling BindAttribLocation. +// Attribute bindings do not go into effect until LinkProgram is called. +// After a program object has been linked successfully, the index values for +// attribute variables remain fixed until the next link command occurs. The +// attribute values can only be queried after a link if the link was +// successful. GetAttribLocation returns the binding that actually went +// into effect the last time LinkProgram was called for the specified +// program object. Attribute bindings that have been specified since the last +// link operation are not returned by GetAttribLocation. +// +// Error GL_INVALID_OPERATION is generated if program is not a value +// generated by OpenGL. GL_INVALID_OPERATION is generated if program is not +// a program object. GL_INVALID_OPERATION is generated if program has not +// been successfully linked. GL_INVALID_OPERATION is generated if +// GetAttribLocation is executed between the execution of Begin and the +// corresponding execution of End. +// +// GetAttribLocation is available in GL version 2.0 or greater. +func (gl *GL) GetAttribLocation(program glbase.Program, name string) glbase.Attrib { + name_cstr := C.CString(name) + glresult := C.gl2_1_glGetAttribLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) + return glbase.Attrib(glresult) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetAttachedShaders.xml +func (gl *GL) GetAttachedShaders(program glbase.Program, maxCount int32, count []int, obj []uint32) { + C.gl2_1_glGetAttachedShaders(gl.funcs, C.GLuint(program), C.GLsizei(maxCount), (*C.GLsizei)(unsafe.Pointer(&count[0])), (*C.GLuint)(unsafe.Pointer(&obj[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetActiveUniform.xml +func (gl *GL) GetActiveUniform(program glbase.Program, index uint32, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl2_1_glGetActiveUniform(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetActiveAttrib.xml +func (gl *GL) GetActiveAttrib(program glbase.Program, index glbase.Attrib, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl2_1_glGetActiveAttrib(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEnableVertexAttribArray.xml +func (gl *GL) EnableVertexAttribArray(index glbase.Attrib) { + C.gl2_1_glEnableVertexAttribArray(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDisableVertexAttribArray.xml +func (gl *GL) DisableVertexAttribArray(index glbase.Attrib) { + C.gl2_1_glDisableVertexAttribArray(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDetachShader.xml +func (gl *GL) DetachShader(program glbase.Program, shader glbase.Shader) { + C.gl2_1_glDetachShader(gl.funcs, C.GLuint(program), C.GLuint(shader)) +} + +// DeleteShader frees the memory and invalidates the name associated with +// the shader object specified by shader. This command effectively undoes the +// effects of a call to CreateShader. +// +// If a shader object to be deleted is attached to a program object, it will +// be flagged for deletion, but it will not be deleted until it is no longer +// attached to any program object, for any rendering context (it must +// be detached from wherever it was attached before it will be deleted). A +// value of 0 for shader will be silently ignored. +// +// To determine whether an object has been flagged for deletion, call +// GetShader with arguments shader and GL.DELETE_STATUS. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. +// +// DeleteShader is available in GL version 2.0 or greater. +func (gl *GL) DeleteShader(shader glbase.Shader) { + C.gl2_1_glDeleteShader(gl.funcs, C.GLuint(shader)) +} + +// DeleteProgram frees the memory and invalidates the name associated with +// the program object specified by program. This command effectively undoes +// the effects of a call to CreateProgram. +// +// If a program object is in use as part of current rendering state, it will +// be flagged for deletion, but it will not be deleted until it is no longer +// part of current state for any rendering context. If a program object to be +// deleted has shader objects attached to it, those shader objects will be +// automatically detached but not deleted unless they have already been +// flagged for deletion by a previous call to DeleteShader. A value of 0 +// for program will be silently ignored. +// +// To determine whether a program object has been flagged for deletion, call +// GetProgram with arguments program and GL.DELETE_STATUS. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. +// +// DeleteProgram is available in GL version 2.0 or greater. +func (gl *GL) DeleteProgram(program glbase.Program) { + C.gl2_1_glDeleteProgram(gl.funcs, C.GLuint(program)) +} + +// CreateShader creates an empty shader object and returns a non-zero value +// by which it can be referenced. A shader object is used to maintain the +// source code strings that define a shader. shaderType indicates the type of +// shader to be created. +// +// Two types of shaders are supported. A shader of type GL.VERTEX_SHADER is a +// shader that is intended to run on the programmable vertex processor and +// replace the fixed functionality vertex processing in OpenGL. A shader of +// type GL.FRAGMENT_SHADER is a shader that is intended to run on the +// programmable fragment processor and replace the fixed functionality +// fragment processing in OpenGL. +// +// When created, a shader object's GL.SHADER_TYPE parameter is set to either +// GL.VERTEX_SHADER or GL.FRAGMENT_SHADER, depending on the value of +// shaderType. +// +// Like display lists and texture objects, the name space for shader objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// This function returns 0 if an error occurs creating the shader object. +// +// Error GL.INVALID_ENUM is generated if shaderType is not an accepted value. +// GL.INVALID_OPERATION is generated if CreateShader is executed between the +// execution of Begin and the corresponding execution of End. +// +// CreateShader is available in GL version 2.0 or greater. +func (gl *GL) CreateShader(gltype glbase.Enum) glbase.Shader { + glresult := C.gl2_1_glCreateShader(gl.funcs, C.GLenum(gltype)) + return glbase.Shader(glresult) +} + +// CreateProgram creates an empty program object and returns a non-zero +// value by which it can be referenced. A program object is an object to +// which shader objects can be attached. This provides a mechanism to specify +// the shader objects that will be linked to create a program. It also +// provides a means for checking the compatibility of the shaders that will +// be used to create a program (for instance, checking the compatibility +// between a vertex shader and a fragment shader). When no longer needed as +// part of a program object, shader objects can be detached. +// +// One or more executables are created in a program object by successfully +// attaching shader objects to it with AttachShader, successfully compiling +// the shader objects with CompileShader, and successfully linking the +// program object with LinkProgram. These executables are made part of +// current state when UseProgram is called. Program objects can be deleted +// by calling DeleteProgram. The memory associated with the program object +// will be deleted when it is no longer part of current rendering state for +// any context. +// +// Like display lists and texture objects, the name space for program objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// Applications are responsible for providing the synchronization across API +// calls when objects are accessed from different execution threads. +// +// This function returns 0 if an error occurs creating the program object. +// +// Error GL.INVALID_OPERATION is generated if CreateProgram is executed +// between the execution of Begin and the corresponding execution of End. +// +// CreateProgram is available in GL version 2.0 or greater. +func (gl *GL) CreateProgram() glbase.Program { + glresult := C.gl2_1_glCreateProgram(gl.funcs) + return glbase.Program(glresult) +} + +// CompileShader compiles the source code strings that have been stored in +// the shader object specified by shader. +// +// The compilation status will be stored as part of the shader object's +// state. This value will be set to GL.TRUE if the shader was compiled without +// errors and is ready for use, and GL.FALSE otherwise. It can be queried by +// calling GetShaderiv with arguments shader and GL.COMPILE_STATUS. +// +// Compilation of a shader can fail for a number of reasons as specified by +// the OpenGL Shading Language Specification. Whether or not the compilation +// was successful, information about the compilation can be obtained from the +// shader object's information log by calling GetShaderInfoLog. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_OPERATION is generated if CompileShader is executed +// between the execution of Begin and the corresponding execution of End. +// +// CompileShader is available in GL version 2.0 or greater. +func (gl *GL) CompileShader(shader glbase.Shader) { + C.gl2_1_glCompileShader(gl.funcs, C.GLuint(shader)) +} + +// BindAttribLocation associates a user-defined attribute variable in the program +// object specified by program with a generic vertex attribute index. The name +// parameter specifies the name of the vertex shader attribute variable to +// which index is to be bound. When program is made part of the current state, +// values provided via the generic vertex attribute index will modify the +// value of the user-defined attribute variable specified by name. +// +// If name refers to a matrix attribute variable, index refers to the first +// column of the matrix. Other matrix columns are then automatically bound to +// locations index+1 for a matrix of type mat2; index+1 and index+2 for a +// matrix of type mat3; and index+1, index+2, and index+3 for a matrix of +// type mat4. +// +// This command makes it possible for vertex shaders to use descriptive names +// for attribute variables rather than generic variables that are numbered +// from 0 to GL.MAX_VERTEX_ATTRIBS-1. The values sent to each generic +// attribute index are part of current state, just like standard vertex +// attributes such as color, normal, and vertex position. If a different +// program object is made current by calling UseProgram, the generic vertex +// attributes are tracked in such a way that the same values will be observed +// by attributes in the new program object that are also bound to index. +// +// Attribute variable name-to-generic attribute index bindings for a program +// object can be explicitly assigned at any time by calling +// BindAttribLocation. Attribute bindings do not go into effect until +// LinkProgram is called. After a program object has been linked +// successfully, the index values for generic attributes remain fixed (and +// their values can be queried) until the next link command occurs. +// +// Applications are not allowed to bind any of the standard OpenGL vertex +// attributes using this command, as they are bound automatically when +// needed. Any attribute binding that occurs after the program object has +// been linked will not take effect until the next time the program object is +// linked. +// +// If name was bound previously, that information is lost. Thus you cannot +// bind one user-defined attribute variable to multiple indices, but you can +// bind multiple user-defined attribute variables to the same index. +// +// Applications are allowed to bind more than one user-defined attribute +// variable to the same generic vertex attribute index. This is called +// aliasing, and it is allowed only if just one of the aliased attributes is +// active in the executable program, or if no path through the shader +// consumes more than one attribute of a set of attributes aliased to the +// same location. The compiler and linker are allowed to assume that no +// aliasing is done and are free to employ optimizations that work only in +// the absence of aliasing. OpenGL implementations are not required to do +// error checking to detect aliasing. Because there is no way to bind +// standard attributes, it is not possible to alias generic attributes with +// conventional ones (except for generic attribute 0). +// +// BindAttribLocation can be called before any vertex shader objects are +// bound to the specified program object. It is also permissible to bind a +// generic attribute index to an attribute variable name that is never used +// in a vertex shader. +// +// Active attributes that are not explicitly bound will be bound by the +// linker when LinkProgram is called. The locations assigned can be queried +// by calling GetAttribLocation. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. +// GL.INVALID_OPERATION is generated if name starts with the reserved prefix "gl_". +// GL.INVALID_VALUE is generated if program is not a value generated by OpenGL. +// GL.INVALID_OPERATION is generated if program is not a program object. +// GL.INVALID_OPERATION is generated if BindAttribLocation is executed +// between the execution of Begin and the corresponding execution of End. +// +// BindAttribLocation is available in GL version 2.0 or greater. +func (gl *GL) BindAttribLocation(program glbase.Program, index glbase.Attrib, name string) { + name_cstr := C.CString(name) + C.gl2_1_glBindAttribLocation(gl.funcs, C.GLuint(program), C.GLuint(index), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) +} + +// AttachShader attaches a shader object to a program object. +// +// In order to create an executable, there must be a way to specify the list +// of things that will be linked together. Program objects provide this +// mechanism. Shaders that are to be linked together in a program object must +// first be attached to that program object. This indicates that shader will +// be included in link operations that will be performed on program. +// +// All operations that can be performed on a shader object are valid whether +// or not the shader object is attached to a program object. It is +// permissible to attach a shader object to a program object before source +// code has been loaded into the shader object or before the shader object +// has been compiled. It is permissible to attach multiple shader objects of +// the same type because each may contain a portion of the complete shader. +// It is also permissible to attach a shader object to more than one program +// object. If a shader object is deleted while it is attached to a program +// object, it will be flagged for deletion, and deletion will not occur until +// DetachShader is called to detach it from all program objects to which it +// is attached. +// +// Error GL.INVALID_VALUE is generated if either program or shader is not a +// value generated by OpenGL. GL.INVALID_OPERATION is generated if program +// is not a program object. GL.INVALID_OPERATION is generated if shader is +// not a shader object. GL.INVALID_OPERATION is generated if shader is +// already attached to program. GL.INVALID_OPERATION is generated if +// AttachShader is executed between the execution of Begin and the +// corresponding execution of End. +// +// AttachShader is available in GL version 2.0 or greater. +func (gl *GL) AttachShader(program glbase.Program, shader glbase.Shader) { + C.gl2_1_glAttachShader(gl.funcs, C.GLuint(program), C.GLuint(shader)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilMaskSeparate.xml +func (gl *GL) StencilMaskSeparate(face glbase.Enum, mask uint32) { + C.gl2_1_glStencilMaskSeparate(gl.funcs, C.GLenum(face), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilFuncSeparate.xml +func (gl *GL) StencilFuncSeparate(face, glfunc glbase.Enum, ref int32, mask uint32) { + C.gl2_1_glStencilFuncSeparate(gl.funcs, C.GLenum(face), C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilOpSeparate.xml +func (gl *GL) StencilOpSeparate(face, sfail, dpfail, dppass glbase.Enum) { + C.gl2_1_glStencilOpSeparate(gl.funcs, C.GLenum(face), C.GLenum(sfail), C.GLenum(dpfail), C.GLenum(dppass)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawBuffers.xml +func (gl *GL) DrawBuffers(n int, bufs []glbase.Enum) { + C.gl2_1_glDrawBuffers(gl.funcs, C.GLsizei(n), (*C.GLenum)(unsafe.Pointer(&bufs[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBlendEquationSeparate.xml +func (gl *GL) BlendEquationSeparate(modeRGB, modeAlpha glbase.Enum) { + C.gl2_1_glBlendEquationSeparate(gl.funcs, C.GLenum(modeRGB), C.GLenum(modeAlpha)) +} + +// UniformMatrix4x3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4x3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4x3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*3) != 0 { + panic("invalid value length for UniformMatrix4x3fv") + } + count := len(value) / (4 * 3) + C.gl2_1_glUniformMatrix4x3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3x4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3x4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3x4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*4) != 0 { + panic("invalid value length for UniformMatrix3x4fv") + } + count := len(value) / (3 * 4) + C.gl2_1_glUniformMatrix3x4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix4x2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4x2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4x2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*2) != 0 { + panic("invalid value length for UniformMatrix4x2fv") + } + count := len(value) / (4 * 2) + C.gl2_1_glUniformMatrix4x2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2x4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2x4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2x4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*4) != 0 { + panic("invalid value length for UniformMatrix2x4fv") + } + count := len(value) / (2 * 4) + C.gl2_1_glUniformMatrix2x4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3x2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3x2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3x2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*2) != 0 { + panic("invalid value length for UniformMatrix3x2fv") + } + count := len(value) / (3 * 2) + C.gl2_1_glUniformMatrix3x2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2x3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2x3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2x3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*3) != 0 { + panic("invalid value length for UniformMatrix2x3fv") + } + count := len(value) / (2 * 3) + C.gl2_1_glUniformMatrix2x3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTranslatef.xml +func (gl *GL) Translatef(x, y, z float32) { + C.gl2_1_glTranslatef(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTranslated.xml +func (gl *GL) Translated(x, y, z float64) { + C.gl2_1_glTranslated(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glScalef.xml +func (gl *GL) Scalef(x, y, z float32) { + C.gl2_1_glScalef(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glScaled.xml +func (gl *GL) Scaled(x, y, z float64) { + C.gl2_1_glScaled(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRotatef.xml +func (gl *GL) Rotatef(angle, x, y, z float32) { + C.gl2_1_glRotatef(gl.funcs, C.GLfloat(angle), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRotated.xml +func (gl *GL) Rotated(angle, x, y, z float64) { + C.gl2_1_glRotated(gl.funcs, C.GLdouble(angle), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPushMatrix.xml +func (gl *GL) PushMatrix() { + C.gl2_1_glPushMatrix(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPopMatrix.xml +func (gl *GL) PopMatrix() { + C.gl2_1_glPopMatrix(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glOrtho.xml +func (gl *GL) Ortho(left, right, bottom, top, zNear, zFar float64) { + C.gl2_1_glOrtho(gl.funcs, C.GLdouble(left), C.GLdouble(right), C.GLdouble(bottom), C.GLdouble(top), C.GLdouble(zNear), C.GLdouble(zFar)) +} + +// MultMatrixd multiplies the current matrix with the provided matrix. +// +// The m parameter must hold 16 consecutive elements of a 4x4 column-major matrix. +// +// The current matrix is determined by the current matrix mode (see +// MatrixMode). It is either the projection matrix, modelview matrix, or the +// texture matrix. +// +// For example, if the current matrix is C and the coordinates to be transformed +// are v = (v[0], v[1], v[2], v[3]), then the current transformation is C × v, or +// +// c[0] c[4] c[8] c[12] v[0] +// c[1] c[5] c[9] c[13] v[1] +// c[2] c[6] c[10] c[14] X v[2] +// c[3] c[7] c[11] c[15] v[3] +// +// Calling MultMatrix with an argument of m = m[0], m[1], ..., m[15] +// replaces the current transformation with (C X M) x v, or +// +// c[0] c[4] c[8] c[12] m[0] m[4] m[8] m[12] v[0] +// c[1] c[5] c[9] c[13] m[1] m[5] m[9] m[13] v[1] +// c[2] c[6] c[10] c[14] X m[2] m[6] m[10] m[14] X v[2] +// c[3] c[7] c[11] c[15] m[3] m[7] m[11] m[15] v[3] +// +// Where 'X' denotes matrix multiplication, and v is represented as a 4x1 matrix. +// +// While the elements of the matrix may be specified with single or double +// precision, the GL may store or operate on these values in less-than-single +// precision. +// +// In many computer languages, 4×4 arrays are represented in row-major +// order. The transformations just described represent these matrices in +// column-major order. The order of the multiplication is important. For +// example, if the current transformation is a rotation, and MultMatrix is +// called with a translation matrix, the translation is done directly on the +// coordinates to be transformed, while the rotation is done on the results +// of that translation. +// +// GL.INVALID_OPERATION is generated if MultMatrix is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) MultMatrixd(m []float64) { + if len(m) != 16 { + panic("parameter m must have length 16 for the 4x4 matrix") + } + C.gl2_1_glMultMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// MultMatrixf multiplies the current matrix with the provided matrix. +// +// The m parameter must hold 16 consecutive elements of a 4x4 column-major matrix. +// +// The current matrix is determined by the current matrix mode (see +// MatrixMode). It is either the projection matrix, modelview matrix, or the +// texture matrix. +// +// For example, if the current matrix is C and the coordinates to be transformed +// are v = (v[0], v[1], v[2], v[3]), then the current transformation is C × v, or +// +// c[0] c[4] c[8] c[12] v[0] +// c[1] c[5] c[9] c[13] v[1] +// c[2] c[6] c[10] c[14] X v[2] +// c[3] c[7] c[11] c[15] v[3] +// +// Calling MultMatrix with an argument of m = m[0], m[1], ..., m[15] +// replaces the current transformation with (C X M) x v, or +// +// c[0] c[4] c[8] c[12] m[0] m[4] m[8] m[12] v[0] +// c[1] c[5] c[9] c[13] m[1] m[5] m[9] m[13] v[1] +// c[2] c[6] c[10] c[14] X m[2] m[6] m[10] m[14] X v[2] +// c[3] c[7] c[11] c[15] m[3] m[7] m[11] m[15] v[3] +// +// Where 'X' denotes matrix multiplication, and v is represented as a 4x1 matrix. +// +// While the elements of the matrix may be specified with single or double +// precision, the GL may store or operate on these values in less-than-single +// precision. +// +// In many computer languages, 4×4 arrays are represented in row-major +// order. The transformations just described represent these matrices in +// column-major order. The order of the multiplication is important. For +// example, if the current transformation is a rotation, and MultMatrix is +// called with a translation matrix, the translation is done directly on the +// coordinates to be transformed, while the rotation is done on the results +// of that translation. +// +// GL.INVALID_OPERATION is generated if MultMatrix is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) MultMatrixf(m []float32) { + if len(m) != 16 { + panic("parameter m must have length 16 for the 4x4 matrix") + } + C.gl2_1_glMultMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMatrixMode.xml +func (gl *GL) MatrixMode(mode glbase.Enum) { + C.gl2_1_glMatrixMode(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadMatrixd.xml +func (gl *GL) LoadMatrixd(m []float64) { + C.gl2_1_glLoadMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadMatrixf.xml +func (gl *GL) LoadMatrixf(m []float32) { + C.gl2_1_glLoadMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadIdentity.xml +func (gl *GL) LoadIdentity() { + C.gl2_1_glLoadIdentity(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFrustum.xml +func (gl *GL) Frustum(left, right, bottom, top, zNear, zFar float64) { + C.gl2_1_glFrustum(gl.funcs, C.GLdouble(left), C.GLdouble(right), C.GLdouble(bottom), C.GLdouble(top), C.GLdouble(zNear), C.GLdouble(zFar)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsList.xml +func (gl *GL) IsList(list uint32) bool { + glresult := C.gl2_1_glIsList(gl.funcs, C.GLuint(list)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexGeniv.xml +func (gl *GL) GetTexGeniv(coord, pname glbase.Enum, params []int32) { + C.gl2_1_glGetTexGeniv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexGenfv.xml +func (gl *GL) GetTexGenfv(coord, pname glbase.Enum, params []float32) { + C.gl2_1_glGetTexGenfv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexGendv.xml +func (gl *GL) GetTexGendv(coord, pname glbase.Enum, params []float64) { + C.gl2_1_glGetTexGendv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexEnviv.xml +func (gl *GL) GetTexEnviv(target, pname glbase.Enum, params []int32) { + C.gl2_1_glGetTexEnviv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexEnvfv.xml +func (gl *GL) GetTexEnvfv(target, pname glbase.Enum, params []float32) { + C.gl2_1_glGetTexEnvfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetPolygonStipple.xml +func (gl *GL) GetPolygonStipple(mask []uint8) { + C.gl2_1_glGetPolygonStipple(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&mask[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetPixelMapusv.xml +func (gl *GL) GetPixelMapusv(glmap glbase.Enum, values []uint16) { + C.gl2_1_glGetPixelMapusv(gl.funcs, C.GLenum(glmap), (*C.GLushort)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetPixelMapuiv.xml +func (gl *GL) GetPixelMapuiv(glmap glbase.Enum, values []uint32) { + C.gl2_1_glGetPixelMapuiv(gl.funcs, C.GLenum(glmap), (*C.GLuint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetPixelMapfv.xml +func (gl *GL) GetPixelMapfv(glmap glbase.Enum, values []float32) { + C.gl2_1_glGetPixelMapfv(gl.funcs, C.GLenum(glmap), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMaterialiv.xml +func (gl *GL) GetMaterialiv(face, pname glbase.Enum, params []int32) { + C.gl2_1_glGetMaterialiv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMaterialfv.xml +func (gl *GL) GetMaterialfv(face, pname glbase.Enum, params []float32) { + C.gl2_1_glGetMaterialfv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMapiv.xml +func (gl *GL) GetMapiv(target, query glbase.Enum, v []int32) { + C.gl2_1_glGetMapiv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMapfv.xml +func (gl *GL) GetMapfv(target, query glbase.Enum, v []float32) { + C.gl2_1_glGetMapfv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMapdv.xml +func (gl *GL) GetMapdv(target, query glbase.Enum, v []float64) { + C.gl2_1_glGetMapdv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetLightiv.xml +func (gl *GL) GetLightiv(light, pname glbase.Enum, params []int32) { + C.gl2_1_glGetLightiv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetLightfv.xml +func (gl *GL) GetLightfv(light, pname glbase.Enum, params []float32) { + C.gl2_1_glGetLightfv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetClipPlane.xml +func (gl *GL) GetClipPlane(plane glbase.Enum, equation []float64) { + C.gl2_1_glGetClipPlane(gl.funcs, C.GLenum(plane), (*C.GLdouble)(unsafe.Pointer(&equation[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawPixels.xml +func (gl *GL) DrawPixels(width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glDrawPixels(gl.funcs, C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyPixels.xml +func (gl *GL) CopyPixels(x, y, width, height int, gltype glbase.Enum) { + C.gl2_1_glCopyPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(gltype)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelMapusv.xml +func (gl *GL) PixelMapusv(glmap glbase.Enum, mapsize int32, values []uint16) { + C.gl2_1_glPixelMapusv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLushort)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelMapuiv.xml +func (gl *GL) PixelMapuiv(glmap glbase.Enum, mapsize int32, values []uint32) { + C.gl2_1_glPixelMapuiv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLuint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelMapfv.xml +func (gl *GL) PixelMapfv(glmap glbase.Enum, mapsize int32, values []float32) { + C.gl2_1_glPixelMapfv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelTransferi.xml +func (gl *GL) PixelTransferi(pname glbase.Enum, param int32) { + C.gl2_1_glPixelTransferi(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelTransferf.xml +func (gl *GL) PixelTransferf(pname glbase.Enum, param float32) { + C.gl2_1_glPixelTransferf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelZoom.xml +func (gl *GL) PixelZoom(xfactor, yfactor float32) { + C.gl2_1_glPixelZoom(gl.funcs, C.GLfloat(xfactor), C.GLfloat(yfactor)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glAlphaFunc.xml +func (gl *GL) AlphaFunc(glfunc glbase.Enum, ref float32) { + C.gl2_1_glAlphaFunc(gl.funcs, C.GLenum(glfunc), C.GLfloat(ref)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalPoint2.xml +func (gl *GL) EvalPoint2(i, j int32) { + C.gl2_1_glEvalPoint2(gl.funcs, C.GLint(i), C.GLint(j)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalMesh2.xml +func (gl *GL) EvalMesh2(mode glbase.Enum, i1, i2, j1, j2 int32) { + C.gl2_1_glEvalMesh2(gl.funcs, C.GLenum(mode), C.GLint(i1), C.GLint(i2), C.GLint(j1), C.GLint(j2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalPoint1.xml +func (gl *GL) EvalPoint1(i int32) { + C.gl2_1_glEvalPoint1(gl.funcs, C.GLint(i)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalMesh1.xml +func (gl *GL) EvalMesh1(mode glbase.Enum, i1, i2 int32) { + C.gl2_1_glEvalMesh1(gl.funcs, C.GLenum(mode), C.GLint(i1), C.GLint(i2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord2fv.xml +func (gl *GL) EvalCoord2fv(u []float32) { + if len(u) != 2 { + panic("parameter u has incorrect length") + } + C.gl2_1_glEvalCoord2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord2f.xml +func (gl *GL) EvalCoord2f(u, v float32) { + C.gl2_1_glEvalCoord2f(gl.funcs, C.GLfloat(u), C.GLfloat(v)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord2dv.xml +func (gl *GL) EvalCoord2dv(u []float64) { + if len(u) != 2 { + panic("parameter u has incorrect length") + } + C.gl2_1_glEvalCoord2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord2d.xml +func (gl *GL) EvalCoord2d(u, v float64) { + C.gl2_1_glEvalCoord2d(gl.funcs, C.GLdouble(u), C.GLdouble(v)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord1fv.xml +func (gl *GL) EvalCoord1fv(u []float32) { + C.gl2_1_glEvalCoord1fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord1f.xml +func (gl *GL) EvalCoord1f(u float32) { + C.gl2_1_glEvalCoord1f(gl.funcs, C.GLfloat(u)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord1dv.xml +func (gl *GL) EvalCoord1dv(u []float64) { + C.gl2_1_glEvalCoord1dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEvalCoord1d.xml +func (gl *GL) EvalCoord1d(u float64) { + C.gl2_1_glEvalCoord1d(gl.funcs, C.GLdouble(u)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMapGrid2f.xml +func (gl *GL) MapGrid2f(un int32, u1, u2 float32, vn int32, v1, v2 float32) { + C.gl2_1_glMapGrid2f(gl.funcs, C.GLint(un), C.GLfloat(u1), C.GLfloat(u2), C.GLint(vn), C.GLfloat(v1), C.GLfloat(v2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMapGrid2d.xml +func (gl *GL) MapGrid2d(un int32, u1, u2 float64, vn int32, v1, v2 float64) { + C.gl2_1_glMapGrid2d(gl.funcs, C.GLint(un), C.GLdouble(u1), C.GLdouble(u2), C.GLint(vn), C.GLdouble(v1), C.GLdouble(v2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMapGrid1f.xml +func (gl *GL) MapGrid1f(un int32, u1, u2 float32) { + C.gl2_1_glMapGrid1f(gl.funcs, C.GLint(un), C.GLfloat(u1), C.GLfloat(u2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMapGrid1d.xml +func (gl *GL) MapGrid1d(un int32, u1, u2 float64) { + C.gl2_1_glMapGrid1d(gl.funcs, C.GLint(un), C.GLdouble(u1), C.GLdouble(u2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMap2f.xml +func (gl *GL) Map2f(target glbase.Enum, u1, u2 float32, ustride, uorder int32, v1, v2 float32, vstride, vorder int32, points []float32) { + C.gl2_1_glMap2f(gl.funcs, C.GLenum(target), C.GLfloat(u1), C.GLfloat(u2), C.GLint(ustride), C.GLint(uorder), C.GLfloat(v1), C.GLfloat(v2), C.GLint(vstride), C.GLint(vorder), (*C.GLfloat)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMap2d.xml +func (gl *GL) Map2d(target glbase.Enum, u1, u2 float64, ustride, uorder int32, v1, v2 float64, vstride, vorder int32, points []float64) { + C.gl2_1_glMap2d(gl.funcs, C.GLenum(target), C.GLdouble(u1), C.GLdouble(u2), C.GLint(ustride), C.GLint(uorder), C.GLdouble(v1), C.GLdouble(v2), C.GLint(vstride), C.GLint(vorder), (*C.GLdouble)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMap1f.xml +func (gl *GL) Map1f(target glbase.Enum, u1, u2 float32, stride, order int, points []float32) { + C.gl2_1_glMap1f(gl.funcs, C.GLenum(target), C.GLfloat(u1), C.GLfloat(u2), C.GLint(stride), C.GLint(order), (*C.GLfloat)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMap1d.xml +func (gl *GL) Map1d(target glbase.Enum, u1, u2 float64, stride, order int, points []float64) { + C.gl2_1_glMap1d(gl.funcs, C.GLenum(target), C.GLdouble(u1), C.GLdouble(u2), C.GLint(stride), C.GLint(order), (*C.GLdouble)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPushAttrib.xml +func (gl *GL) PushAttrib(mask glbase.Bitfield) { + C.gl2_1_glPushAttrib(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPopAttrib.xml +func (gl *GL) PopAttrib() { + C.gl2_1_glPopAttrib(gl.funcs) +} + +// Accum executes an operation on the accumulation buffer. +// +// Parameter op defines the accumulation buffer operation (GL.ACCUM, GL.LOAD, +// GL.ADD, GL.MULT, or GL.RETURN) and specifies how the value parameter is +// used. +// +// The accumulation buffer is an extended-range color buffer. Images are not +// rendered into it. Rather, images rendered into one of the color buffers +// are added to the contents of the accumulation buffer after rendering. +// Effects such as antialiasing (of points, lines, and polygons), motion +// blur, and depth of field can be created by accumulating images generated +// with different transformation matrices. +// +// Each pixel in the accumulation buffer consists of red, green, blue, and +// alpha values. The number of bits per component in the accumulation buffer +// depends on the implementation. You can examine this number by calling +// GetIntegerv four times, with arguments GL.ACCUM_RED_BITS, +// GL.ACCUM_GREEN_BITS, GL.ACCUM_BLUE_BITS, and GL.ACCUM_ALPHA_BITS. +// Regardless of the number of bits per component, the range of values stored +// by each component is (-1, 1). The accumulation buffer pixels are mapped +// one-to-one with frame buffer pixels. +// +// All accumulation buffer operations are limited to the area of the current +// scissor box and applied identically to the red, green, blue, and alpha +// components of each pixel. If a Accum operation results in a value outside +// the range (-1, 1), the contents of an accumulation buffer pixel component +// are undefined. +// +// The operations are as follows: +// +// GL.ACCUM +// Obtains R, G, B, and A values from the buffer currently selected for +// reading (see ReadBuffer). Each component value is divided by 2 n - +// 1 , where n is the number of bits allocated to each color component +// in the currently selected buffer. The result is a floating-point +// value in the range 0 1 , which is multiplied by value and added to +// the corresponding pixel component in the accumulation buffer, +// thereby updating the accumulation buffer. +// +// GL.LOAD +// Similar to GL.ACCUM, except that the current value in the +// accumulation buffer is not used in the calculation of the new value. +// That is, the R, G, B, and A values from the currently selected +// buffer are divided by 2 n - 1 , multiplied by value, and then stored +// in the corresponding accumulation buffer cell, overwriting the +// current value. +// +// GL.ADD +// Adds value to each R, G, B, and A in the accumulation buffer. +// +// GL.MULT +// Multiplies each R, G, B, and A in the accumulation buffer by value +// and returns the scaled component to its corresponding accumulation +// buffer location. +// +// GL.RETURN +// Transfers accumulation buffer values to the color buffer or buffers +// currently selected for writing. Each R, G, B, and A component is +// multiplied by value, then multiplied by 2 n - 1 , clamped to the +// range 0 2 n - 1 , and stored in the corresponding display buffer +// cell. The only fragment operations that are applied to this transfer +// are pixel ownership, scissor, dithering, and color writemasks. +// +// To clear the accumulation buffer, call ClearAccum with R, G, B, and A +// values to set it to, then call Clear with the accumulation buffer +// enabled. +// +// Error GL.INVALID_ENUM is generated if op is not an accepted value. +// GL.INVALID_OPERATION is generated if there is no accumulation buffer. +// GL.INVALID_OPERATION is generated if Accum is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) Accum(op glbase.Enum, value float32) { + C.gl2_1_glAccum(gl.funcs, C.GLenum(op), C.GLfloat(value)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexMask.xml +func (gl *GL) IndexMask(mask uint32) { + C.gl2_1_glIndexMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearIndex.xml +func (gl *GL) ClearIndex(c float32) { + C.gl2_1_glClearIndex(gl.funcs, C.GLfloat(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearAccum.xml +func (gl *GL) ClearAccum(red, green, blue, alpha float32) { + C.gl2_1_glClearAccum(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPushName.xml +func (gl *GL) PushName(name uint32) { + C.gl2_1_glPushName(gl.funcs, C.GLuint(name)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPopName.xml +func (gl *GL) PopName() { + C.gl2_1_glPopName(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPassThrough.xml +func (gl *GL) PassThrough(token float32) { + C.gl2_1_glPassThrough(gl.funcs, C.GLfloat(token)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadName.xml +func (gl *GL) LoadName(name uint32) { + C.gl2_1_glLoadName(gl.funcs, C.GLuint(name)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glInitNames.xml +func (gl *GL) InitNames() { + C.gl2_1_glInitNames(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRenderMode.xml +func (gl *GL) RenderMode(mode glbase.Enum) int32 { + glresult := C.gl2_1_glRenderMode(gl.funcs, C.GLenum(mode)) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSelectBuffer.xml +func (gl *GL) SelectBuffer(size int, buffer []glbase.Buffer) { + C.gl2_1_glSelectBuffer(gl.funcs, C.GLsizei(size), (*C.GLuint)(unsafe.Pointer(&buffer[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFeedbackBuffer.xml +func (gl *GL) FeedbackBuffer(size int, gltype glbase.Enum, buffer []float32) { + C.gl2_1_glFeedbackBuffer(gl.funcs, C.GLsizei(size), C.GLenum(gltype), (*C.GLfloat)(unsafe.Pointer(&buffer[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGeniv.xml +func (gl *GL) TexGeniv(coord, pname glbase.Enum, params []int32) { + C.gl2_1_glTexGeniv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGeni.xml +func (gl *GL) TexGeni(coord, pname glbase.Enum, param int32) { + C.gl2_1_glTexGeni(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGenfv.xml +func (gl *GL) TexGenfv(coord, pname glbase.Enum, params []float32) { + C.gl2_1_glTexGenfv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGenf.xml +func (gl *GL) TexGenf(coord, pname glbase.Enum, param float32) { + C.gl2_1_glTexGenf(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGendv.xml +func (gl *GL) TexGendv(coord, pname glbase.Enum, params []float64) { + C.gl2_1_glTexGendv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexGend.xml +func (gl *GL) TexGend(coord, pname glbase.Enum, param float64) { + C.gl2_1_glTexGend(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLdouble(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnviv.xml +func (gl *GL) TexEnviv(target, pname glbase.Enum, params []int32) { + C.gl2_1_glTexEnviv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnvi.xml +func (gl *GL) TexEnvi(target, pname glbase.Enum, param int32) { + C.gl2_1_glTexEnvi(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnvfv.xml +func (gl *GL) TexEnvfv(target, pname glbase.Enum, params []float32) { + C.gl2_1_glTexEnvfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnvf.xml +func (gl *GL) TexEnvf(target, pname glbase.Enum, param float32) { + C.gl2_1_glTexEnvf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glShadeModel.xml +func (gl *GL) ShadeModel(mode glbase.Enum) { + C.gl2_1_glShadeModel(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPolygonStipple.xml +func (gl *GL) PolygonStipple(mask []uint8) { + C.gl2_1_glPolygonStipple(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&mask[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMaterialiv.xml +func (gl *GL) Materialiv(face, pname glbase.Enum, params []int32) { + C.gl2_1_glMaterialiv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMateriali.xml +func (gl *GL) Materiali(face, pname glbase.Enum, param int32) { + C.gl2_1_glMateriali(gl.funcs, C.GLenum(face), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMaterialfv.xml +func (gl *GL) Materialfv(face, pname glbase.Enum, params []float32) { + C.gl2_1_glMaterialfv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMaterialf.xml +func (gl *GL) Materialf(face, pname glbase.Enum, param float32) { + C.gl2_1_glMaterialf(gl.funcs, C.GLenum(face), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLineStipple.xml +func (gl *GL) LineStipple(factor int32, pattern uint16) { + C.gl2_1_glLineStipple(gl.funcs, C.GLint(factor), C.GLushort(pattern)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightModeliv.xml +func (gl *GL) LightModeliv(pname glbase.Enum, params []int32) { + C.gl2_1_glLightModeliv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightModeli.xml +func (gl *GL) LightModeli(pname glbase.Enum, param int32) { + C.gl2_1_glLightModeli(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightModelfv.xml +func (gl *GL) LightModelfv(pname glbase.Enum, params []float32) { + C.gl2_1_glLightModelfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightModelf.xml +func (gl *GL) LightModelf(pname glbase.Enum, param float32) { + C.gl2_1_glLightModelf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightiv.xml +func (gl *GL) Lightiv(light, pname glbase.Enum, params []int32) { + C.gl2_1_glLightiv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLighti.xml +func (gl *GL) Lighti(light, pname glbase.Enum, param int32) { + C.gl2_1_glLighti(gl.funcs, C.GLenum(light), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightfv.xml +func (gl *GL) Lightfv(light, pname glbase.Enum, params []float32) { + C.gl2_1_glLightfv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLightf.xml +func (gl *GL) Lightf(light, pname glbase.Enum, param float32) { + C.gl2_1_glLightf(gl.funcs, C.GLenum(light), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogiv.xml +func (gl *GL) Fogiv(pname glbase.Enum, params []int32) { + C.gl2_1_glFogiv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogi.xml +func (gl *GL) Fogi(pname glbase.Enum, param int32) { + C.gl2_1_glFogi(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogfv.xml +func (gl *GL) Fogfv(pname glbase.Enum, params []float32) { + C.gl2_1_glFogfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogf.xml +func (gl *GL) Fogf(pname glbase.Enum, param float32) { + C.gl2_1_glFogf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorMaterial.xml +func (gl *GL) ColorMaterial(face, mode glbase.Enum) { + C.gl2_1_glColorMaterial(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClipPlane.xml +func (gl *GL) ClipPlane(plane glbase.Enum, equation []float64) { + C.gl2_1_glClipPlane(gl.funcs, C.GLenum(plane), (*C.GLdouble)(unsafe.Pointer(&equation[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4sv.xml +func (gl *GL) Vertex4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_1_glVertex4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4s.xml +func (gl *GL) Vertex4s(x, y, z, w int16) { + C.gl2_1_glVertex4s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4iv.xml +func (gl *GL) Vertex4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_1_glVertex4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4i.xml +func (gl *GL) Vertex4i(x, y, z, w int) { + C.gl2_1_glVertex4i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4fv.xml +func (gl *GL) Vertex4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_1_glVertex4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4f.xml +func (gl *GL) Vertex4f(x, y, z, w float32) { + C.gl2_1_glVertex4f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4dv.xml +func (gl *GL) Vertex4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_1_glVertex4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex4d.xml +func (gl *GL) Vertex4d(x, y, z, w float64) { + C.gl2_1_glVertex4d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3sv.xml +func (gl *GL) Vertex3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_1_glVertex3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3s.xml +func (gl *GL) Vertex3s(x, y, z int16) { + C.gl2_1_glVertex3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3iv.xml +func (gl *GL) Vertex3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_1_glVertex3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3i.xml +func (gl *GL) Vertex3i(x, y, z int) { + C.gl2_1_glVertex3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3fv.xml +func (gl *GL) Vertex3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_1_glVertex3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3f.xml +func (gl *GL) Vertex3f(x, y, z float32) { + C.gl2_1_glVertex3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3dv.xml +func (gl *GL) Vertex3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_1_glVertex3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex3d.xml +func (gl *GL) Vertex3d(x, y, z float64) { + C.gl2_1_glVertex3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2sv.xml +func (gl *GL) Vertex2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_1_glVertex2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2s.xml +func (gl *GL) Vertex2s(x, y int16) { + C.gl2_1_glVertex2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2iv.xml +func (gl *GL) Vertex2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_1_glVertex2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2i.xml +func (gl *GL) Vertex2i(x, y int) { + C.gl2_1_glVertex2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2fv.xml +func (gl *GL) Vertex2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_1_glVertex2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2f.xml +func (gl *GL) Vertex2f(x, y float32) { + C.gl2_1_glVertex2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2dv.xml +func (gl *GL) Vertex2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_1_glVertex2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertex2d.xml +func (gl *GL) Vertex2d(x, y float64) { + C.gl2_1_glVertex2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4sv.xml +func (gl *GL) TexCoord4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_1_glTexCoord4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4s.xml +func (gl *GL) TexCoord4s(s, t, r, q int16) { + C.gl2_1_glTexCoord4s(gl.funcs, C.GLshort(s), C.GLshort(t), C.GLshort(r), C.GLshort(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4iv.xml +func (gl *GL) TexCoord4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_1_glTexCoord4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4i.xml +func (gl *GL) TexCoord4i(s, t, r, q int32) { + C.gl2_1_glTexCoord4i(gl.funcs, C.GLint(s), C.GLint(t), C.GLint(r), C.GLint(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4fv.xml +func (gl *GL) TexCoord4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_1_glTexCoord4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4f.xml +func (gl *GL) TexCoord4f(s, t, r, q float32) { + C.gl2_1_glTexCoord4f(gl.funcs, C.GLfloat(s), C.GLfloat(t), C.GLfloat(r), C.GLfloat(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4dv.xml +func (gl *GL) TexCoord4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_1_glTexCoord4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord4d.xml +func (gl *GL) TexCoord4d(s, t, r, q float64) { + C.gl2_1_glTexCoord4d(gl.funcs, C.GLdouble(s), C.GLdouble(t), C.GLdouble(r), C.GLdouble(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3sv.xml +func (gl *GL) TexCoord3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_1_glTexCoord3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3s.xml +func (gl *GL) TexCoord3s(s, t, r int16) { + C.gl2_1_glTexCoord3s(gl.funcs, C.GLshort(s), C.GLshort(t), C.GLshort(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3iv.xml +func (gl *GL) TexCoord3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_1_glTexCoord3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3i.xml +func (gl *GL) TexCoord3i(s, t, r int32) { + C.gl2_1_glTexCoord3i(gl.funcs, C.GLint(s), C.GLint(t), C.GLint(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3fv.xml +func (gl *GL) TexCoord3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_1_glTexCoord3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3f.xml +func (gl *GL) TexCoord3f(s, t, r float32) { + C.gl2_1_glTexCoord3f(gl.funcs, C.GLfloat(s), C.GLfloat(t), C.GLfloat(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3dv.xml +func (gl *GL) TexCoord3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_1_glTexCoord3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord3d.xml +func (gl *GL) TexCoord3d(s, t, r float64) { + C.gl2_1_glTexCoord3d(gl.funcs, C.GLdouble(s), C.GLdouble(t), C.GLdouble(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2sv.xml +func (gl *GL) TexCoord2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_1_glTexCoord2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2s.xml +func (gl *GL) TexCoord2s(s, t int16) { + C.gl2_1_glTexCoord2s(gl.funcs, C.GLshort(s), C.GLshort(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2iv.xml +func (gl *GL) TexCoord2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_1_glTexCoord2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2i.xml +func (gl *GL) TexCoord2i(s, t int32) { + C.gl2_1_glTexCoord2i(gl.funcs, C.GLint(s), C.GLint(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2fv.xml +func (gl *GL) TexCoord2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_1_glTexCoord2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2f.xml +func (gl *GL) TexCoord2f(s, t float32) { + C.gl2_1_glTexCoord2f(gl.funcs, C.GLfloat(s), C.GLfloat(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2dv.xml +func (gl *GL) TexCoord2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_1_glTexCoord2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord2d.xml +func (gl *GL) TexCoord2d(s, t float64) { + C.gl2_1_glTexCoord2d(gl.funcs, C.GLdouble(s), C.GLdouble(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1sv.xml +func (gl *GL) TexCoord1sv(v []int16) { + C.gl2_1_glTexCoord1sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1s.xml +func (gl *GL) TexCoord1s(s int16) { + C.gl2_1_glTexCoord1s(gl.funcs, C.GLshort(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1iv.xml +func (gl *GL) TexCoord1iv(v []int32) { + C.gl2_1_glTexCoord1iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1i.xml +func (gl *GL) TexCoord1i(s int32) { + C.gl2_1_glTexCoord1i(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1fv.xml +func (gl *GL) TexCoord1fv(v []float32) { + C.gl2_1_glTexCoord1fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1f.xml +func (gl *GL) TexCoord1f(s float32) { + C.gl2_1_glTexCoord1f(gl.funcs, C.GLfloat(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1dv.xml +func (gl *GL) TexCoord1dv(v []float64) { + C.gl2_1_glTexCoord1dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoord1d.xml +func (gl *GL) TexCoord1d(s float64) { + C.gl2_1_glTexCoord1d(gl.funcs, C.GLdouble(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectsv.xml +func (gl *GL) Rectsv(v1, v2 []int16) { + C.gl2_1_glRectsv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v1[0])), (*C.GLshort)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRects.xml +func (gl *GL) Rects(x1, y1, x2, y2 int16) { + C.gl2_1_glRects(gl.funcs, C.GLshort(x1), C.GLshort(y1), C.GLshort(x2), C.GLshort(y2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectiv.xml +func (gl *GL) Rectiv(v1, v2 []int32) { + C.gl2_1_glRectiv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v1[0])), (*C.GLint)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRecti.xml +func (gl *GL) Recti(x1, y1, x2, y2 int32) { + C.gl2_1_glRecti(gl.funcs, C.GLint(x1), C.GLint(y1), C.GLint(x2), C.GLint(y2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectfv.xml +func (gl *GL) Rectfv(v1, v2 []float32) { + C.gl2_1_glRectfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v1[0])), (*C.GLfloat)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectf.xml +func (gl *GL) Rectf(x1, y1, x2, y2 float32) { + C.gl2_1_glRectf(gl.funcs, C.GLfloat(x1), C.GLfloat(y1), C.GLfloat(x2), C.GLfloat(y2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectdv.xml +func (gl *GL) Rectdv(v1, v2 []float64) { + C.gl2_1_glRectdv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v1[0])), (*C.GLdouble)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRectd.xml +func (gl *GL) Rectd(x1, y1, x2, y2 float64) { + C.gl2_1_glRectd(gl.funcs, C.GLdouble(x1), C.GLdouble(y1), C.GLdouble(x2), C.GLdouble(y2)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4sv.xml +func (gl *GL) RasterPos4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_1_glRasterPos4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4s.xml +func (gl *GL) RasterPos4s(x, y, z, w int16) { + C.gl2_1_glRasterPos4s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4iv.xml +func (gl *GL) RasterPos4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_1_glRasterPos4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4i.xml +func (gl *GL) RasterPos4i(x, y, z, w int) { + C.gl2_1_glRasterPos4i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4fv.xml +func (gl *GL) RasterPos4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_1_glRasterPos4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4f.xml +func (gl *GL) RasterPos4f(x, y, z, w float32) { + C.gl2_1_glRasterPos4f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4dv.xml +func (gl *GL) RasterPos4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_1_glRasterPos4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos4d.xml +func (gl *GL) RasterPos4d(x, y, z, w float64) { + C.gl2_1_glRasterPos4d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3sv.xml +func (gl *GL) RasterPos3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_1_glRasterPos3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3s.xml +func (gl *GL) RasterPos3s(x, y, z int16) { + C.gl2_1_glRasterPos3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3iv.xml +func (gl *GL) RasterPos3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_1_glRasterPos3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3i.xml +func (gl *GL) RasterPos3i(x, y, z int) { + C.gl2_1_glRasterPos3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3fv.xml +func (gl *GL) RasterPos3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_1_glRasterPos3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3f.xml +func (gl *GL) RasterPos3f(x, y, z float32) { + C.gl2_1_glRasterPos3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3dv.xml +func (gl *GL) RasterPos3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_1_glRasterPos3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos3d.xml +func (gl *GL) RasterPos3d(x, y, z float64) { + C.gl2_1_glRasterPos3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2sv.xml +func (gl *GL) RasterPos2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_1_glRasterPos2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2s.xml +func (gl *GL) RasterPos2s(x, y int16) { + C.gl2_1_glRasterPos2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2iv.xml +func (gl *GL) RasterPos2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_1_glRasterPos2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2i.xml +func (gl *GL) RasterPos2i(x, y int) { + C.gl2_1_glRasterPos2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2fv.xml +func (gl *GL) RasterPos2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_1_glRasterPos2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2f.xml +func (gl *GL) RasterPos2f(x, y float32) { + C.gl2_1_glRasterPos2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2dv.xml +func (gl *GL) RasterPos2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_1_glRasterPos2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRasterPos2d.xml +func (gl *GL) RasterPos2d(x, y float64) { + C.gl2_1_glRasterPos2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3sv.xml +func (gl *GL) Normal3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_1_glNormal3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3s.xml +func (gl *GL) Normal3s(nx, ny, nz int16) { + C.gl2_1_glNormal3s(gl.funcs, C.GLshort(nx), C.GLshort(ny), C.GLshort(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3iv.xml +func (gl *GL) Normal3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_1_glNormal3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3i.xml +func (gl *GL) Normal3i(nx, ny, nz int32) { + C.gl2_1_glNormal3i(gl.funcs, C.GLint(nx), C.GLint(ny), C.GLint(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3fv.xml +func (gl *GL) Normal3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_1_glNormal3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3f.xml +func (gl *GL) Normal3f(nx, ny, nz float32) { + C.gl2_1_glNormal3f(gl.funcs, C.GLfloat(nx), C.GLfloat(ny), C.GLfloat(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3dv.xml +func (gl *GL) Normal3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_1_glNormal3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3d.xml +func (gl *GL) Normal3d(nx, ny, nz float64) { + C.gl2_1_glNormal3d(gl.funcs, C.GLdouble(nx), C.GLdouble(ny), C.GLdouble(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3bv.xml +func (gl *GL) Normal3bv(v []byte) { + C.gl2_1_glNormal3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormal3b.xml +func (gl *GL) Normal3b(nx, ny, nz byte) { + C.gl2_1_glNormal3b(gl.funcs, C.GLbyte(nx), C.GLbyte(ny), C.GLbyte(nz)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexsv.xml +func (gl *GL) Indexsv(c []int16) { + C.gl2_1_glIndexsv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexs.xml +func (gl *GL) Indexs(c int16) { + C.gl2_1_glIndexs(gl.funcs, C.GLshort(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexiv.xml +func (gl *GL) Indexiv(c []int32) { + C.gl2_1_glIndexiv(gl.funcs, (*C.GLint)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexi.xml +func (gl *GL) Indexi(c int32) { + C.gl2_1_glIndexi(gl.funcs, C.GLint(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexfv.xml +func (gl *GL) Indexfv(c []float32) { + C.gl2_1_glIndexfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexf.xml +func (gl *GL) Indexf(c float32) { + C.gl2_1_glIndexf(gl.funcs, C.GLfloat(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexdv.xml +func (gl *GL) Indexdv(c []float64) { + C.gl2_1_glIndexdv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexd.xml +func (gl *GL) Indexd(c float64) { + C.gl2_1_glIndexd(gl.funcs, C.GLdouble(c)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEnd.xml +func (gl *GL) End() { + C.gl2_1_glEnd(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEdgeFlagv.xml +func (gl *GL) EdgeFlagv(flag []bool) { + C.gl2_1_glEdgeFlagv(gl.funcs, (*C.GLboolean)(unsafe.Pointer(&flag[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEdgeFlag.xml +func (gl *GL) EdgeFlag(flag bool) { + C.gl2_1_glEdgeFlag(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4usv.xml +func (gl *GL) Color4usv(v []uint16) { + C.gl2_1_glColor4usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4us.xml +func (gl *GL) Color4us(red, green, blue, alpha uint16) { + C.gl2_1_glColor4us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue), C.GLushort(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4uiv.xml +func (gl *GL) Color4uiv(v []uint32) { + C.gl2_1_glColor4uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4ui.xml +func (gl *GL) Color4ui(red, green, blue, alpha uint32) { + C.gl2_1_glColor4ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue), C.GLuint(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4ubv.xml +func (gl *GL) Color4ubv(v []uint8) { + C.gl2_1_glColor4ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4ub.xml +func (gl *GL) Color4ub(red, green, blue, alpha uint8) { + C.gl2_1_glColor4ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue), C.GLubyte(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4sv.xml +func (gl *GL) Color4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_1_glColor4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4s.xml +func (gl *GL) Color4s(red, green, blue, alpha int16) { + C.gl2_1_glColor4s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue), C.GLshort(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4iv.xml +func (gl *GL) Color4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_1_glColor4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4i.xml +func (gl *GL) Color4i(red, green, blue, alpha int32) { + C.gl2_1_glColor4i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue), C.GLint(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4fv.xml +func (gl *GL) Color4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_1_glColor4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4f.xml +func (gl *GL) Color4f(red, green, blue, alpha float32) { + C.gl2_1_glColor4f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4dv.xml +func (gl *GL) Color4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_1_glColor4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4d.xml +func (gl *GL) Color4d(red, green, blue, alpha float64) { + C.gl2_1_glColor4d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue), C.GLdouble(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4bv.xml +func (gl *GL) Color4bv(v []byte) { + C.gl2_1_glColor4bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor4b.xml +func (gl *GL) Color4b(red, green, blue, alpha byte) { + C.gl2_1_glColor4b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue), C.GLbyte(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3usv.xml +func (gl *GL) Color3usv(v []uint16) { + C.gl2_1_glColor3usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3us.xml +func (gl *GL) Color3us(red, green, blue uint16) { + C.gl2_1_glColor3us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3uiv.xml +func (gl *GL) Color3uiv(v []uint32) { + C.gl2_1_glColor3uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3ui.xml +func (gl *GL) Color3ui(red, green, blue uint32) { + C.gl2_1_glColor3ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3ubv.xml +func (gl *GL) Color3ubv(v []uint8) { + C.gl2_1_glColor3ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3ub.xml +func (gl *GL) Color3ub(red, green, blue uint8) { + C.gl2_1_glColor3ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3sv.xml +func (gl *GL) Color3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_1_glColor3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3s.xml +func (gl *GL) Color3s(red, green, blue int16) { + C.gl2_1_glColor3s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3iv.xml +func (gl *GL) Color3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_1_glColor3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3i.xml +func (gl *GL) Color3i(red, green, blue int32) { + C.gl2_1_glColor3i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3fv.xml +func (gl *GL) Color3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_1_glColor3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3f.xml +func (gl *GL) Color3f(red, green, blue float32) { + C.gl2_1_glColor3f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3dv.xml +func (gl *GL) Color3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_1_glColor3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3d.xml +func (gl *GL) Color3d(red, green, blue float64) { + C.gl2_1_glColor3d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3bv.xml +func (gl *GL) Color3bv(v []byte) { + C.gl2_1_glColor3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColor3b.xml +func (gl *GL) Color3b(red, green, blue byte) { + C.gl2_1_glColor3b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBitmap.xml +func (gl *GL) Bitmap(width, height int, xorig, yorig, xmove, ymove float32, bitmap []uint8) { + C.gl2_1_glBitmap(gl.funcs, C.GLsizei(width), C.GLsizei(height), C.GLfloat(xorig), C.GLfloat(yorig), C.GLfloat(xmove), C.GLfloat(ymove), (*C.GLubyte)(unsafe.Pointer(&bitmap[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBegin.xml +func (gl *GL) Begin(mode glbase.Enum) { + C.gl2_1_glBegin(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glListBase.xml +func (gl *GL) ListBase(base uint32) { + C.gl2_1_glListBase(gl.funcs, C.GLuint(base)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGenLists.xml +func (gl *GL) GenLists(range_ int32) uint32 { + glresult := C.gl2_1_glGenLists(gl.funcs, C.GLsizei(range_)) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDeleteLists.xml +func (gl *GL) DeleteLists(list uint32, range_ int32) { + C.gl2_1_glDeleteLists(gl.funcs, C.GLuint(list), C.GLsizei(range_)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCallLists.xml +func (gl *GL) CallLists(n int, gltype glbase.Enum, lists interface{}) { + var lists_ptr unsafe.Pointer + var lists_v = reflect.ValueOf(lists) + if lists != nil && lists_v.Kind() != reflect.Slice { + panic("parameter lists must be a slice") + } + if lists != nil { + lists_ptr = unsafe.Pointer(lists_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glCallLists(gl.funcs, C.GLsizei(n), C.GLenum(gltype), lists_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCallList.xml +func (gl *GL) CallList(list uint32) { + C.gl2_1_glCallList(gl.funcs, C.GLuint(list)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEndList.xml +func (gl *GL) EndList() { + C.gl2_1_glEndList(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNewList.xml +func (gl *GL) NewList(list uint32, mode glbase.Enum) { + C.gl2_1_glNewList(gl.funcs, C.GLuint(list), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPushClientAttrib.xml +func (gl *GL) PushClientAttrib(mask glbase.Bitfield) { + C.gl2_1_glPushClientAttrib(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPopClientAttrib.xml +func (gl *GL) PopClientAttrib() { + C.gl2_1_glPopClientAttrib(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPrioritizeTextures.xml +func (gl *GL) PrioritizeTextures(n int, textures []glbase.Texture, priorities []float32) { + C.gl2_1_glPrioritizeTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0])), (*C.GLfloat)(unsafe.Pointer(&priorities[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glAreTexturesResident.xml +func (gl *GL) AreTexturesResident(n int, textures []glbase.Texture, residences []bool) bool { + glresult := C.gl2_1_glAreTexturesResident(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0])), (*C.GLboolean)(unsafe.Pointer(&residences[0]))) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexPointer.xml +func (gl *GL) VertexPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glVertexPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexCoordPointer.xml +func (gl *GL) TexCoordPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glTexCoordPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glNormalPointer.xml +func (gl *GL) NormalPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glNormalPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glInterleavedArrays.xml +func (gl *GL) InterleavedArrays(format glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glInterleavedArrays(gl.funcs, C.GLenum(format), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIndexPointer.xml +func (gl *GL) IndexPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glIndexPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEnableClientState.xml +func (gl *GL) EnableClientState(array glbase.Enum) { + C.gl2_1_glEnableClientState(gl.funcs, C.GLenum(array)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEdgeFlagPointer.xml +func (gl *GL) EdgeFlagPointer(stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glEdgeFlagPointer(gl.funcs, C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDisableClientState.xml +func (gl *GL) DisableClientState(array glbase.Enum) { + C.gl2_1_glDisableClientState(gl.funcs, C.GLenum(array)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorPointer.xml +func (gl *GL) ColorPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glColorPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glArrayElement.xml +func (gl *GL) ArrayElement(i int32) { + C.gl2_1_glArrayElement(gl.funcs, C.GLint(i)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glResetMinmax.xml +func (gl *GL) ResetMinmax(target glbase.Enum) { + C.gl2_1_glResetMinmax(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glResetHistogram.xml +func (gl *GL) ResetHistogram(target glbase.Enum) { + C.gl2_1_glResetHistogram(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMinmax.xml +func (gl *GL) Minmax(target, internalFormat glbase.Enum, sink bool) { + C.gl2_1_glMinmax(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), *(*C.GLboolean)(unsafe.Pointer(&sink))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glHistogram.xml +func (gl *GL) Histogram(target glbase.Enum, width int, internalFormat glbase.Enum, sink bool) { + C.gl2_1_glHistogram(gl.funcs, C.GLenum(target), C.GLsizei(width), C.GLenum(internalFormat), *(*C.GLboolean)(unsafe.Pointer(&sink))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMinmaxParameteriv.xml +func (gl *GL) GetMinmaxParameteriv(target, pname glbase.Enum, params []int32) { + C.gl2_1_glGetMinmaxParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMinmaxParameterfv.xml +func (gl *GL) GetMinmaxParameterfv(target, pname glbase.Enum, params []float32) { + C.gl2_1_glGetMinmaxParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetMinmax.xml +func (gl *GL) GetMinmax(target glbase.Enum, reset bool, format, gltype glbase.Enum, values interface{}) { + var values_ptr unsafe.Pointer + var values_v = reflect.ValueOf(values) + if values != nil && values_v.Kind() != reflect.Slice { + panic("parameter values must be a slice") + } + if values != nil { + values_ptr = unsafe.Pointer(values_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glGetMinmax(gl.funcs, C.GLenum(target), *(*C.GLboolean)(unsafe.Pointer(&reset)), C.GLenum(format), C.GLenum(gltype), values_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetHistogramParameteriv.xml +func (gl *GL) GetHistogramParameteriv(target, pname glbase.Enum, params []int32) { + C.gl2_1_glGetHistogramParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetHistogramParameterfv.xml +func (gl *GL) GetHistogramParameterfv(target, pname glbase.Enum, params []float32) { + C.gl2_1_glGetHistogramParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetHistogram.xml +func (gl *GL) GetHistogram(target glbase.Enum, reset bool, format, gltype glbase.Enum, values interface{}) { + var values_ptr unsafe.Pointer + var values_v = reflect.ValueOf(values) + if values != nil && values_v.Kind() != reflect.Slice { + panic("parameter values must be a slice") + } + if values != nil { + values_ptr = unsafe.Pointer(values_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glGetHistogram(gl.funcs, C.GLenum(target), *(*C.GLboolean)(unsafe.Pointer(&reset)), C.GLenum(format), C.GLenum(gltype), values_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSeparableFilter2D.xml +func (gl *GL) SeparableFilter2D(target, internalFormat glbase.Enum, width, height int, format, gltype glbase.Enum, row, column interface{}) { + var row_ptr unsafe.Pointer + var row_v = reflect.ValueOf(row) + if row != nil && row_v.Kind() != reflect.Slice { + panic("parameter row must be a slice") + } + if row != nil { + row_ptr = unsafe.Pointer(row_v.Index(0).Addr().Pointer()) + } + var column_ptr unsafe.Pointer + var column_v = reflect.ValueOf(column) + if column != nil && column_v.Kind() != reflect.Slice { + panic("parameter column must be a slice") + } + if column != nil { + column_ptr = unsafe.Pointer(column_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glSeparableFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), row_ptr, column_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetSeparableFilter.xml +func (gl *GL) GetSeparableFilter(target, format, gltype glbase.Enum, row, column, span interface{}) { + var row_ptr unsafe.Pointer + var row_v = reflect.ValueOf(row) + if row != nil && row_v.Kind() != reflect.Slice { + panic("parameter row must be a slice") + } + if row != nil { + row_ptr = unsafe.Pointer(row_v.Index(0).Addr().Pointer()) + } + var column_ptr unsafe.Pointer + var column_v = reflect.ValueOf(column) + if column != nil && column_v.Kind() != reflect.Slice { + panic("parameter column must be a slice") + } + if column != nil { + column_ptr = unsafe.Pointer(column_v.Index(0).Addr().Pointer()) + } + var span_ptr unsafe.Pointer + var span_v = reflect.ValueOf(span) + if span != nil && span_v.Kind() != reflect.Slice { + panic("parameter span must be a slice") + } + if span != nil { + span_ptr = unsafe.Pointer(span_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glGetSeparableFilter(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), row_ptr, column_ptr, span_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetConvolutionParameteriv.xml +func (gl *GL) GetConvolutionParameteriv(target, pname glbase.Enum, params []int32) { + C.gl2_1_glGetConvolutionParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetConvolutionParameterfv.xml +func (gl *GL) GetConvolutionParameterfv(target, pname glbase.Enum, params []float32) { + C.gl2_1_glGetConvolutionParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetConvolutionFilter.xml +func (gl *GL) GetConvolutionFilter(target, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glGetConvolutionFilter(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyConvolutionFilter2D.xml +func (gl *GL) CopyConvolutionFilter2D(target, internalFormat glbase.Enum, x, y, width, height int) { + C.gl2_1_glCopyConvolutionFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyConvolutionFilter1D.xml +func (gl *GL) CopyConvolutionFilter1D(target, internalFormat glbase.Enum, x, y, width int) { + C.gl2_1_glCopyConvolutionFilter1D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionParameteriv.xml +func (gl *GL) ConvolutionParameteriv(target, pname glbase.Enum, params []int32) { + C.gl2_1_glConvolutionParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionParameteri.xml +func (gl *GL) ConvolutionParameteri(target, pname glbase.Enum, params int32) { + C.gl2_1_glConvolutionParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(params)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionParameterfv.xml +func (gl *GL) ConvolutionParameterfv(target, pname glbase.Enum, params []float32) { + C.gl2_1_glConvolutionParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionParameterf.xml +func (gl *GL) ConvolutionParameterf(target, pname glbase.Enum, params float32) { + C.gl2_1_glConvolutionParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(params)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionFilter2D.xml +func (gl *GL) ConvolutionFilter2D(target, internalFormat glbase.Enum, width, height int, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glConvolutionFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glConvolutionFilter1D.xml +func (gl *GL) ConvolutionFilter1D(target, internalFormat glbase.Enum, width int, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glConvolutionFilter1D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyColorSubTable.xml +func (gl *GL) CopyColorSubTable(target glbase.Enum, start int32, x, y, width int) { + C.gl2_1_glCopyColorSubTable(gl.funcs, C.GLenum(target), C.GLsizei(start), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorSubTable.xml +func (gl *GL) ColorSubTable(target glbase.Enum, start int32, count int, format, gltype glbase.Enum, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glColorSubTable(gl.funcs, C.GLenum(target), C.GLsizei(start), C.GLsizei(count), C.GLenum(format), C.GLenum(gltype), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetColorTableParameteriv.xml +func (gl *GL) GetColorTableParameteriv(target, pname glbase.Enum, params []int32) { + C.gl2_1_glGetColorTableParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetColorTableParameterfv.xml +func (gl *GL) GetColorTableParameterfv(target, pname glbase.Enum, params []float32) { + C.gl2_1_glGetColorTableParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetColorTable.xml +func (gl *GL) GetColorTable(target, format, gltype glbase.Enum, table interface{}) { + var table_ptr unsafe.Pointer + var table_v = reflect.ValueOf(table) + if table != nil && table_v.Kind() != reflect.Slice { + panic("parameter table must be a slice") + } + if table != nil { + table_ptr = unsafe.Pointer(table_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glGetColorTable(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), table_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyColorTable.xml +func (gl *GL) CopyColorTable(target, internalFormat glbase.Enum, x, y, width int) { + C.gl2_1_glCopyColorTable(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorTableParameteriv.xml +func (gl *GL) ColorTableParameteriv(target, pname glbase.Enum, params []int32) { + C.gl2_1_glColorTableParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorTableParameterfv.xml +func (gl *GL) ColorTableParameterfv(target, pname glbase.Enum, params []float32) { + C.gl2_1_glColorTableParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorTable.xml +func (gl *GL) ColorTable(target, internalFormat glbase.Enum, width int, format, gltype glbase.Enum, table interface{}) { + var table_ptr unsafe.Pointer + var table_v = reflect.ValueOf(table) + if table != nil && table_v.Kind() != reflect.Slice { + panic("parameter table must be a slice") + } + if table != nil { + table_ptr = unsafe.Pointer(table_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glColorTable(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), table_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultTransposeMatrixd.xml +func (gl *GL) MultTransposeMatrixd(m []float64) { + C.gl2_1_glMultTransposeMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultTransposeMatrixf.xml +func (gl *GL) MultTransposeMatrixf(m []float32) { + C.gl2_1_glMultTransposeMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadTransposeMatrixd.xml +func (gl *GL) LoadTransposeMatrixd(m []float64) { + C.gl2_1_glLoadTransposeMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLoadTransposeMatrixf.xml +func (gl *GL) LoadTransposeMatrixf(m []float32) { + C.gl2_1_glLoadTransposeMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4sv.xml +func (gl *GL) MultiTexCoord4sv(target glbase.Enum, v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_1_glMultiTexCoord4sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4s.xml +func (gl *GL) MultiTexCoord4s(target glbase.Enum, s, t, r, q int16) { + C.gl2_1_glMultiTexCoord4s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t), C.GLshort(r), C.GLshort(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4iv.xml +func (gl *GL) MultiTexCoord4iv(target glbase.Enum, v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_1_glMultiTexCoord4iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4i.xml +func (gl *GL) MultiTexCoord4i(target glbase.Enum, s, t, r, q int32) { + C.gl2_1_glMultiTexCoord4i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t), C.GLint(r), C.GLint(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4fv.xml +func (gl *GL) MultiTexCoord4fv(target glbase.Enum, v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_1_glMultiTexCoord4fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4f.xml +func (gl *GL) MultiTexCoord4f(target glbase.Enum, s, t, r, q float32) { + C.gl2_1_glMultiTexCoord4f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t), C.GLfloat(r), C.GLfloat(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4dv.xml +func (gl *GL) MultiTexCoord4dv(target glbase.Enum, v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_1_glMultiTexCoord4dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord4d.xml +func (gl *GL) MultiTexCoord4d(target glbase.Enum, s, t, r, q float64) { + C.gl2_1_glMultiTexCoord4d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t), C.GLdouble(r), C.GLdouble(q)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3sv.xml +func (gl *GL) MultiTexCoord3sv(target glbase.Enum, v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_1_glMultiTexCoord3sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3s.xml +func (gl *GL) MultiTexCoord3s(target glbase.Enum, s, t, r int16) { + C.gl2_1_glMultiTexCoord3s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t), C.GLshort(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3iv.xml +func (gl *GL) MultiTexCoord3iv(target glbase.Enum, v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_1_glMultiTexCoord3iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3i.xml +func (gl *GL) MultiTexCoord3i(target glbase.Enum, s, t, r int32) { + C.gl2_1_glMultiTexCoord3i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t), C.GLint(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3fv.xml +func (gl *GL) MultiTexCoord3fv(target glbase.Enum, v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_1_glMultiTexCoord3fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3f.xml +func (gl *GL) MultiTexCoord3f(target glbase.Enum, s, t, r float32) { + C.gl2_1_glMultiTexCoord3f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t), C.GLfloat(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3dv.xml +func (gl *GL) MultiTexCoord3dv(target glbase.Enum, v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_1_glMultiTexCoord3dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord3d.xml +func (gl *GL) MultiTexCoord3d(target glbase.Enum, s, t, r float64) { + C.gl2_1_glMultiTexCoord3d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t), C.GLdouble(r)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2sv.xml +func (gl *GL) MultiTexCoord2sv(target glbase.Enum, v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_1_glMultiTexCoord2sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2s.xml +func (gl *GL) MultiTexCoord2s(target glbase.Enum, s, t int16) { + C.gl2_1_glMultiTexCoord2s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2iv.xml +func (gl *GL) MultiTexCoord2iv(target glbase.Enum, v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_1_glMultiTexCoord2iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2i.xml +func (gl *GL) MultiTexCoord2i(target glbase.Enum, s, t int32) { + C.gl2_1_glMultiTexCoord2i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2fv.xml +func (gl *GL) MultiTexCoord2fv(target glbase.Enum, v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_1_glMultiTexCoord2fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2f.xml +func (gl *GL) MultiTexCoord2f(target glbase.Enum, s, t float32) { + C.gl2_1_glMultiTexCoord2f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2dv.xml +func (gl *GL) MultiTexCoord2dv(target glbase.Enum, v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_1_glMultiTexCoord2dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord2d.xml +func (gl *GL) MultiTexCoord2d(target glbase.Enum, s, t float64) { + C.gl2_1_glMultiTexCoord2d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1sv.xml +func (gl *GL) MultiTexCoord1sv(target glbase.Enum, v []int16) { + C.gl2_1_glMultiTexCoord1sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1s.xml +func (gl *GL) MultiTexCoord1s(target glbase.Enum, s int16) { + C.gl2_1_glMultiTexCoord1s(gl.funcs, C.GLenum(target), C.GLshort(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1iv.xml +func (gl *GL) MultiTexCoord1iv(target glbase.Enum, v []int32) { + C.gl2_1_glMultiTexCoord1iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1i.xml +func (gl *GL) MultiTexCoord1i(target glbase.Enum, s int32) { + C.gl2_1_glMultiTexCoord1i(gl.funcs, C.GLenum(target), C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1fv.xml +func (gl *GL) MultiTexCoord1fv(target glbase.Enum, v []float32) { + C.gl2_1_glMultiTexCoord1fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1f.xml +func (gl *GL) MultiTexCoord1f(target glbase.Enum, s float32) { + C.gl2_1_glMultiTexCoord1f(gl.funcs, C.GLenum(target), C.GLfloat(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1dv.xml +func (gl *GL) MultiTexCoord1dv(target glbase.Enum, v []float64) { + C.gl2_1_glMultiTexCoord1dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glMultiTexCoord1d.xml +func (gl *GL) MultiTexCoord1d(target glbase.Enum, s float64) { + C.gl2_1_glMultiTexCoord1d(gl.funcs, C.GLenum(target), C.GLdouble(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClientActiveTexture.xml +func (gl *GL) ClientActiveTexture(texture glbase.Enum) { + C.gl2_1_glClientActiveTexture(gl.funcs, C.GLenum(texture)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos3sv.xml +func (gl *GL) WindowPos3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_1_glWindowPos3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos3s.xml +func (gl *GL) WindowPos3s(x, y, z int16) { + C.gl2_1_glWindowPos3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos3iv.xml +func (gl *GL) WindowPos3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_1_glWindowPos3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos3i.xml +func (gl *GL) WindowPos3i(x, y, z int) { + C.gl2_1_glWindowPos3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos3fv.xml +func (gl *GL) WindowPos3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_1_glWindowPos3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos3f.xml +func (gl *GL) WindowPos3f(x, y, z float32) { + C.gl2_1_glWindowPos3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos3dv.xml +func (gl *GL) WindowPos3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_1_glWindowPos3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos3d.xml +func (gl *GL) WindowPos3d(x, y, z float64) { + C.gl2_1_glWindowPos3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos2sv.xml +func (gl *GL) WindowPos2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_1_glWindowPos2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos2s.xml +func (gl *GL) WindowPos2s(x, y int16) { + C.gl2_1_glWindowPos2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos2iv.xml +func (gl *GL) WindowPos2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_1_glWindowPos2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos2i.xml +func (gl *GL) WindowPos2i(x, y int) { + C.gl2_1_glWindowPos2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos2fv.xml +func (gl *GL) WindowPos2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_1_glWindowPos2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos2f.xml +func (gl *GL) WindowPos2f(x, y float32) { + C.gl2_1_glWindowPos2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos2dv.xml +func (gl *GL) WindowPos2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_1_glWindowPos2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glWindowPos2d.xml +func (gl *GL) WindowPos2d(x, y float64) { + C.gl2_1_glWindowPos2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColorPointer.xml +func (gl *GL) SecondaryColorPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glSecondaryColorPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3usv.xml +func (gl *GL) SecondaryColor3usv(v []uint16) { + C.gl2_1_glSecondaryColor3usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3us.xml +func (gl *GL) SecondaryColor3us(red, green, blue uint16) { + C.gl2_1_glSecondaryColor3us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3uiv.xml +func (gl *GL) SecondaryColor3uiv(v []uint32) { + C.gl2_1_glSecondaryColor3uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3ui.xml +func (gl *GL) SecondaryColor3ui(red, green, blue uint32) { + C.gl2_1_glSecondaryColor3ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3ubv.xml +func (gl *GL) SecondaryColor3ubv(v []uint8) { + C.gl2_1_glSecondaryColor3ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3ub.xml +func (gl *GL) SecondaryColor3ub(red, green, blue uint8) { + C.gl2_1_glSecondaryColor3ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3sv.xml +func (gl *GL) SecondaryColor3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_1_glSecondaryColor3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3s.xml +func (gl *GL) SecondaryColor3s(red, green, blue int16) { + C.gl2_1_glSecondaryColor3s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3iv.xml +func (gl *GL) SecondaryColor3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_1_glSecondaryColor3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3i.xml +func (gl *GL) SecondaryColor3i(red, green, blue int32) { + C.gl2_1_glSecondaryColor3i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3fv.xml +func (gl *GL) SecondaryColor3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_1_glSecondaryColor3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3f.xml +func (gl *GL) SecondaryColor3f(red, green, blue float32) { + C.gl2_1_glSecondaryColor3f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3dv.xml +func (gl *GL) SecondaryColor3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_1_glSecondaryColor3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3d.xml +func (gl *GL) SecondaryColor3d(red, green, blue float64) { + C.gl2_1_glSecondaryColor3d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3bv.xml +func (gl *GL) SecondaryColor3bv(v []byte) { + C.gl2_1_glSecondaryColor3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSecondaryColor3b.xml +func (gl *GL) SecondaryColor3b(red, green, blue byte) { + C.gl2_1_glSecondaryColor3b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogCoordPointer.xml +func (gl *GL) FogCoordPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl2_1_glFogCoordPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogCoorddv.xml +func (gl *GL) FogCoorddv(coord []float64) { + C.gl2_1_glFogCoorddv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&coord[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogCoordd.xml +func (gl *GL) FogCoordd(coord float64) { + C.gl2_1_glFogCoordd(gl.funcs, C.GLdouble(coord)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogCoordfv.xml +func (gl *GL) FogCoordfv(coord []float32) { + C.gl2_1_glFogCoordfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&coord[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFogCoordf.xml +func (gl *GL) FogCoordf(coord float32) { + C.gl2_1_glFogCoordf(gl.funcs, C.GLfloat(coord)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4usv.xml +func (gl *GL) VertexAttrib4usv(index glbase.Attrib, v []uint16) { + C.gl2_1_glVertexAttrib4usv(gl.funcs, C.GLuint(index), (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4uiv.xml +func (gl *GL) VertexAttrib4uiv(index glbase.Attrib, v []uint32) { + C.gl2_1_glVertexAttrib4uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4ubv.xml +func (gl *GL) VertexAttrib4ubv(index glbase.Attrib, v []uint8) { + C.gl2_1_glVertexAttrib4ubv(gl.funcs, C.GLuint(index), (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4sv.xml +func (gl *GL) VertexAttrib4sv(index glbase.Attrib, v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_1_glVertexAttrib4sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4s.xml +func (gl *GL) VertexAttrib4s(index glbase.Attrib, x, y, z, w int16) { + C.gl2_1_glVertexAttrib4s(gl.funcs, C.GLuint(index), C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4iv.xml +func (gl *GL) VertexAttrib4iv(index glbase.Attrib, v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_1_glVertexAttrib4iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4fv.xml +func (gl *GL) VertexAttrib4fv(index glbase.Attrib, v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_1_glVertexAttrib4fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4f.xml +func (gl *GL) VertexAttrib4f(index glbase.Attrib, x, y, z, w float32) { + C.gl2_1_glVertexAttrib4f(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4dv.xml +func (gl *GL) VertexAttrib4dv(index glbase.Attrib, v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl2_1_glVertexAttrib4dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4d.xml +func (gl *GL) VertexAttrib4d(index glbase.Attrib, x, y, z, w float64) { + C.gl2_1_glVertexAttrib4d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4bv.xml +func (gl *GL) VertexAttrib4bv(index glbase.Attrib, v []byte) { + C.gl2_1_glVertexAttrib4bv(gl.funcs, C.GLuint(index), (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4Nusv.xml +func (gl *GL) VertexAttrib4Nusv(index glbase.Attrib, v []uint16) { + C.gl2_1_glVertexAttrib4Nusv(gl.funcs, C.GLuint(index), (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4Nuiv.xml +func (gl *GL) VertexAttrib4Nuiv(index glbase.Attrib, v []uint32) { + C.gl2_1_glVertexAttrib4Nuiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4Nubv.xml +func (gl *GL) VertexAttrib4Nubv(index glbase.Attrib, v []uint8) { + C.gl2_1_glVertexAttrib4Nubv(gl.funcs, C.GLuint(index), (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4Nub.xml +func (gl *GL) VertexAttrib4Nub(index glbase.Attrib, x, y, z, w uint8) { + C.gl2_1_glVertexAttrib4Nub(gl.funcs, C.GLuint(index), C.GLubyte(x), C.GLubyte(y), C.GLubyte(z), C.GLubyte(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4Nsv.xml +func (gl *GL) VertexAttrib4Nsv(index glbase.Attrib, v []int16) { + C.gl2_1_glVertexAttrib4Nsv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4Niv.xml +func (gl *GL) VertexAttrib4Niv(index glbase.Attrib, v []int32) { + C.gl2_1_glVertexAttrib4Niv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4Nbv.xml +func (gl *GL) VertexAttrib4Nbv(index glbase.Attrib, v []byte) { + C.gl2_1_glVertexAttrib4Nbv(gl.funcs, C.GLuint(index), (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib3sv.xml +func (gl *GL) VertexAttrib3sv(index glbase.Attrib, v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_1_glVertexAttrib3sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib3s.xml +func (gl *GL) VertexAttrib3s(index glbase.Attrib, x, y, z int16) { + C.gl2_1_glVertexAttrib3s(gl.funcs, C.GLuint(index), C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib3fv.xml +func (gl *GL) VertexAttrib3fv(index glbase.Attrib, v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_1_glVertexAttrib3fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib3f.xml +func (gl *GL) VertexAttrib3f(index glbase.Attrib, x, y, z float32) { + C.gl2_1_glVertexAttrib3f(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib3dv.xml +func (gl *GL) VertexAttrib3dv(index glbase.Attrib, v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl2_1_glVertexAttrib3dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib3d.xml +func (gl *GL) VertexAttrib3d(index glbase.Attrib, x, y, z float64) { + C.gl2_1_glVertexAttrib3d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib2sv.xml +func (gl *GL) VertexAttrib2sv(index glbase.Attrib, v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_1_glVertexAttrib2sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib2s.xml +func (gl *GL) VertexAttrib2s(index glbase.Attrib, x, y int16) { + C.gl2_1_glVertexAttrib2s(gl.funcs, C.GLuint(index), C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib2fv.xml +func (gl *GL) VertexAttrib2fv(index glbase.Attrib, v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_1_glVertexAttrib2fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib2f.xml +func (gl *GL) VertexAttrib2f(index glbase.Attrib, x, y float32) { + C.gl2_1_glVertexAttrib2f(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib2dv.xml +func (gl *GL) VertexAttrib2dv(index glbase.Attrib, v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl2_1_glVertexAttrib2dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib2d.xml +func (gl *GL) VertexAttrib2d(index glbase.Attrib, x, y float64) { + C.gl2_1_glVertexAttrib2d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib1sv.xml +func (gl *GL) VertexAttrib1sv(index glbase.Attrib, v []int16) { + C.gl2_1_glVertexAttrib1sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib1s.xml +func (gl *GL) VertexAttrib1s(index glbase.Attrib, x int16) { + C.gl2_1_glVertexAttrib1s(gl.funcs, C.GLuint(index), C.GLshort(x)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib1fv.xml +func (gl *GL) VertexAttrib1fv(index glbase.Attrib, v []float32) { + C.gl2_1_glVertexAttrib1fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib1f.xml +func (gl *GL) VertexAttrib1f(index glbase.Attrib, x float32) { + C.gl2_1_glVertexAttrib1f(gl.funcs, C.GLuint(index), C.GLfloat(x)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib1dv.xml +func (gl *GL) VertexAttrib1dv(index glbase.Attrib, v []float64) { + C.gl2_1_glVertexAttrib1dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib1d.xml +func (gl *GL) VertexAttrib1d(index glbase.Attrib, x float64) { + C.gl2_1_glVertexAttrib1d(gl.funcs, C.GLuint(index), C.GLdouble(x)) +} diff --git a/gl/3.0/funcs.cpp b/gl/3.0/funcs.cpp new file mode 100644 index 00000000..8d4262f9 --- /dev/null +++ b/gl/3.0/funcs.cpp @@ -0,0 +1,3966 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#include +#include + +#include "funcs.h" + +void *gl3_0_funcs() { + QOpenGLFunctions_3_0* funcs = QOpenGLContext::currentContext()->versionFunctions(); + if (!funcs) { + return 0; + } + funcs->initializeOpenGLFunctions(); + return funcs; +} + + +void gl3_0_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewport(x, y, width, height); +} + +void gl3_0_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRange(nearVal, farVal); +} + +GLboolean gl3_0_glIsEnabled(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabled(cap); +} + +void gl3_0_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameteriv(target, level, pname, params); +} + +void gl3_0_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameterfv(target, level, pname, params); +} + +void gl3_0_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameteriv(target, pname, params); +} + +void gl3_0_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterfv(target, pname, params); +} + +void gl3_0_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexImage(target, level, format, gltype, pixels); +} + +void gl3_0_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegerv(pname, params); +} + +void gl3_0_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFloatv(pname, params); +} + +GLenum gl3_0_glGetError(void *_glfuncs) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetError(); +} + +void gl3_0_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetDoublev(pname, params); +} + +void gl3_0_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleanv(pname, params); +} + +void gl3_0_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadPixels(x, y, width, height, format, gltype, pixels); +} + +void gl3_0_glReadBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadBuffer(mode); +} + +void gl3_0_glPixelStorei(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStorei(pname, param); +} + +void gl3_0_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStoref(pname, param); +} + +void gl3_0_glDepthFunc(void *_glfuncs, GLenum glfunc) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthFunc(glfunc); +} + +void gl3_0_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOp(fail, zfail, zpass); +} + +void gl3_0_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFunc(glfunc, ref, mask); +} + +void gl3_0_glLogicOp(void *_glfuncs, GLenum opcode) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLogicOp(opcode); +} + +void gl3_0_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFunc(sfactor, dfactor); +} + +void gl3_0_glFlush(void *_glfuncs) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlush(); +} + +void gl3_0_glFinish(void *_glfuncs) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFinish(); +} + +void gl3_0_glEnable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnable(cap); +} + +void gl3_0_glDisable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisable(cap); +} + +void gl3_0_glDepthMask(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthMask(flag); +} + +void gl3_0_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMask(red, green, blue, alpha); +} + +void gl3_0_glStencilMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMask(mask); +} + +void gl3_0_glClearDepth(void *_glfuncs, GLdouble depth) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearDepth(depth); +} + +void gl3_0_glClearStencil(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearStencil(s); +} + +void gl3_0_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearColor(red, green, blue, alpha); +} + +void gl3_0_glClear(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClear(mask); +} + +void gl3_0_glDrawBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffer(mode); +} + +void gl3_0_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage2D(target, level, internalFormat, width, height, border, format, gltype, pixels); +} + +void gl3_0_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage1D(target, level, internalFormat, width, border, format, gltype, pixels); +} + +void gl3_0_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteriv(target, pname, params); +} + +void gl3_0_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteri(target, pname, param); +} + +void gl3_0_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterfv(target, pname, params); +} + +void gl3_0_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterf(target, pname, param); +} + +void gl3_0_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissor(x, y, width, height); +} + +void gl3_0_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonMode(face, mode); +} + +void gl3_0_glPointSize(void *_glfuncs, GLfloat size) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointSize(size); +} + +void gl3_0_glLineWidth(void *_glfuncs, GLfloat width) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineWidth(width); +} + +void gl3_0_glHint(void *_glfuncs, GLenum target, GLenum mode) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glHint(target, mode); +} + +void gl3_0_glFrontFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrontFace(mode); +} + +void gl3_0_glCullFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCullFace(mode); +} + +void gl3_0_glIndexubv(void *_glfuncs, const GLubyte* c) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexubv(c); +} + +void gl3_0_glIndexub(void *_glfuncs, GLubyte c) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexub(c); +} + +GLboolean gl3_0_glIsTexture(void *_glfuncs, GLuint texture) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsTexture(texture); +} + +void gl3_0_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenTextures(n, textures); +} + +void gl3_0_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteTextures(n, textures); +} + +void gl3_0_glBindTexture(void *_glfuncs, GLenum target, GLuint texture) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindTexture(target, texture); +} + +void gl3_0_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, gltype, pixels); +} + +void gl3_0_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage1D(target, level, xoffset, width, format, gltype, pixels); +} + +void gl3_0_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); +} + +void gl3_0_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage1D(target, level, xoffset, x, y, width); +} + +void gl3_0_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage2D(target, level, internalFormat, x, y, width, height, border); +} + +void gl3_0_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage1D(target, level, internalFormat, x, y, width, border); +} + +void gl3_0_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonOffset(factor, units); +} + +void gl3_0_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElements(mode, count, gltype, indices); +} + +void gl3_0_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArrays(mode, first, count); +} + +void gl3_0_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); +} + +void gl3_0_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, gltype, pixels); +} + +void gl3_0_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage3D(target, level, internalFormat, width, height, depth, border, format, gltype, pixels); +} + +void gl3_0_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawRangeElements(mode, start, end, count, gltype, indices); +} + +void gl3_0_glBlendEquation(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquation(mode); +} + +void gl3_0_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendColor(red, green, blue, alpha); +} + +void gl3_0_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetCompressedTexImage(target, level, img); +} + +void gl3_0_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data); +} + +void gl3_0_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); +} + +void gl3_0_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); +} + +void gl3_0_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage1D(target, level, internalFormat, width, border, imageSize, data); +} + +void gl3_0_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data); +} + +void gl3_0_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage3D(target, level, internalFormat, width, height, depth, border, imageSize, data); +} + +void gl3_0_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSampleCoverage(value, invert); +} + +void gl3_0_glActiveTexture(void *_glfuncs, GLenum texture) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glActiveTexture(texture); +} + +void gl3_0_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteriv(pname, params); +} + +void gl3_0_glPointParameteri(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteri(pname, param); +} + +void gl3_0_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterfv(pname, params); +} + +void gl3_0_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterf(pname, param); +} + +void gl3_0_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiDrawArrays(mode, first, count, drawcount); +} + +void gl3_0_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); +} + +void gl3_0_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferParameteriv(target, pname, params); +} + +GLboolean gl3_0_glUnmapBuffer(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glUnmapBuffer(target); +} + +void gl3_0_glGetBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferSubData(target, offset, size, data); +} + +void gl3_0_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferSubData(target, offset, size, data); +} + +void gl3_0_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferData(target, size, data, usage); +} + +GLboolean gl3_0_glIsBuffer(void *_glfuncs, GLuint buffer) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsBuffer(buffer); +} + +void gl3_0_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenBuffers(n, buffers); +} + +void gl3_0_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteBuffers(n, buffers); +} + +void gl3_0_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBuffer(target, buffer); +} + +void gl3_0_glGetQueryObjectuiv(void *_glfuncs, GLuint id, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectuiv(id, pname, params); +} + +void gl3_0_glGetQueryObjectiv(void *_glfuncs, GLuint id, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectiv(id, pname, params); +} + +void gl3_0_glGetQueryiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryiv(target, pname, params); +} + +void gl3_0_glEndQuery(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndQuery(target); +} + +void gl3_0_glBeginQuery(void *_glfuncs, GLenum target, GLuint id) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginQuery(target, id); +} + +GLboolean gl3_0_glIsQuery(void *_glfuncs, GLuint id) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsQuery(id); +} + +void gl3_0_glDeleteQueries(void *_glfuncs, GLsizei n, const GLuint* ids) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteQueries(n, ids); +} + +void gl3_0_glGenQueries(void *_glfuncs, GLsizei n, GLuint* ids) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenQueries(n, ids); +} + +void gl3_0_glVertexAttribPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLboolean normalized, GLsizei stride, const GLvoid* offset) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribPointer(index, size, gltype, normalized, stride, offset); +} + +void gl3_0_glValidateProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glValidateProgram(program); +} + +void gl3_0_glUniformMatrix4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4fv(location, count, transpose, value); +} + +void gl3_0_glUniformMatrix3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3fv(location, count, transpose, value); +} + +void gl3_0_glUniformMatrix2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2fv(location, count, transpose, value); +} + +void gl3_0_glUniform4iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4iv(location, count, value); +} + +void gl3_0_glUniform3iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3iv(location, count, value); +} + +void gl3_0_glUniform2iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2iv(location, count, value); +} + +void gl3_0_glUniform1iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1iv(location, count, value); +} + +void gl3_0_glUniform4fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4fv(location, count, value); +} + +void gl3_0_glUniform3fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3fv(location, count, value); +} + +void gl3_0_glUniform2fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2fv(location, count, value); +} + +void gl3_0_glUniform1fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1fv(location, count, value); +} + +void gl3_0_glUniform4i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4i(location, v0, v1, v2, v3); +} + +void gl3_0_glUniform3i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3i(location, v0, v1, v2); +} + +void gl3_0_glUniform2i(void *_glfuncs, GLint location, GLint v0, GLint v1) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2i(location, v0, v1); +} + +void gl3_0_glUniform1i(void *_glfuncs, GLint location, GLint v0) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1i(location, v0); +} + +void gl3_0_glUniform4f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4f(location, v0, v1, v2, v3); +} + +void gl3_0_glUniform3f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3f(location, v0, v1, v2); +} + +void gl3_0_glUniform2f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2f(location, v0, v1); +} + +void gl3_0_glUniform1f(void *_glfuncs, GLint location, GLfloat v0) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1f(location, v0); +} + +void gl3_0_glUseProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUseProgram(program); +} + +void gl3_0_glShaderSource(void *_glfuncs, GLuint shader, GLsizei count, const GLchar** source, const GLint* length) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShaderSource(shader, count, source, length); +} + +void gl3_0_glLinkProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLinkProgram(program); +} + +GLboolean gl3_0_glIsShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsShader(shader); +} + +GLboolean gl3_0_glIsProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsProgram(program); +} + +void gl3_0_glGetVertexAttribiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribiv(index, pname, params); +} + +void gl3_0_glGetVertexAttribfv(void *_glfuncs, GLuint index, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribfv(index, pname, params); +} + +void gl3_0_glGetVertexAttribdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribdv(index, pname, params); +} + +void gl3_0_glGetUniformiv(void *_glfuncs, GLuint program, GLint location, GLint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformiv(program, location, params); +} + +void gl3_0_glGetUniformfv(void *_glfuncs, GLuint program, GLint location, GLfloat* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformfv(program, location, params); +} + +GLint gl3_0_glGetUniformLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetUniformLocation(program, name); +} + +void gl3_0_glGetShaderSource(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderSource(shader, bufSize, length, source); +} + +void gl3_0_glGetShaderInfoLog(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderInfoLog(shader, bufSize, length, infoLog); +} + +void gl3_0_glGetShaderiv(void *_glfuncs, GLuint shader, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderiv(shader, pname, params); +} + +void gl3_0_glGetProgramInfoLog(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramInfoLog(program, bufSize, length, infoLog); +} + +void gl3_0_glGetProgramiv(void *_glfuncs, GLuint program, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramiv(program, pname, params); +} + +GLint gl3_0_glGetAttribLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetAttribLocation(program, name); +} + +void gl3_0_glGetAttachedShaders(void *_glfuncs, GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetAttachedShaders(program, maxCount, count, obj); +} + +void gl3_0_glGetActiveUniform(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniform(program, index, bufSize, length, size, gltype, name); +} + +void gl3_0_glGetActiveAttrib(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveAttrib(program, index, bufSize, length, size, gltype, name); +} + +void gl3_0_glEnableVertexAttribArray(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnableVertexAttribArray(index); +} + +void gl3_0_glDisableVertexAttribArray(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisableVertexAttribArray(index); +} + +void gl3_0_glDetachShader(void *_glfuncs, GLuint program, GLuint shader) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDetachShader(program, shader); +} + +void gl3_0_glDeleteShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteShader(shader); +} + +void gl3_0_glDeleteProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteProgram(program); +} + +GLuint gl3_0_glCreateShader(void *_glfuncs, GLenum gltype) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCreateShader(gltype); +} + +GLuint gl3_0_glCreateProgram(void *_glfuncs) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCreateProgram(); +} + +void gl3_0_glCompileShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompileShader(shader); +} + +void gl3_0_glBindAttribLocation(void *_glfuncs, GLuint program, GLuint index, const GLchar* name) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindAttribLocation(program, index, name); +} + +void gl3_0_glAttachShader(void *_glfuncs, GLuint program, GLuint shader) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAttachShader(program, shader); +} + +void gl3_0_glStencilMaskSeparate(void *_glfuncs, GLenum face, GLuint mask) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMaskSeparate(face, mask); +} + +void gl3_0_glStencilFuncSeparate(void *_glfuncs, GLenum face, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFuncSeparate(face, glfunc, ref, mask); +} + +void gl3_0_glStencilOpSeparate(void *_glfuncs, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOpSeparate(face, sfail, dpfail, dppass); +} + +void gl3_0_glDrawBuffers(void *_glfuncs, GLsizei n, const GLenum* bufs) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffers(n, bufs); +} + +void gl3_0_glBlendEquationSeparate(void *_glfuncs, GLenum modeRGB, GLenum modeAlpha) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquationSeparate(modeRGB, modeAlpha); +} + +void gl3_0_glUniformMatrix4x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x3fv(location, count, transpose, value); +} + +void gl3_0_glUniformMatrix3x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x4fv(location, count, transpose, value); +} + +void gl3_0_glUniformMatrix4x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x2fv(location, count, transpose, value); +} + +void gl3_0_glUniformMatrix2x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x4fv(location, count, transpose, value); +} + +void gl3_0_glUniformMatrix3x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x2fv(location, count, transpose, value); +} + +void gl3_0_glUniformMatrix2x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x3fv(location, count, transpose, value); +} + +GLboolean gl3_0_glIsVertexArray(void *_glfuncs, GLuint array) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsVertexArray(array); +} + +void gl3_0_glGenVertexArrays(void *_glfuncs, GLsizei n, GLuint* arrays) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenVertexArrays(n, arrays); +} + +void gl3_0_glDeleteVertexArrays(void *_glfuncs, GLsizei n, const GLuint* arrays) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteVertexArrays(n, arrays); +} + +void gl3_0_glBindVertexArray(void *_glfuncs, GLuint array) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindVertexArray(array); +} + +void gl3_0_glFlushMappedBufferRange(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr length) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlushMappedBufferRange(target, offset, length); +} + +void gl3_0_glFramebufferTextureLayer(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTextureLayer(target, attachment, texture, level, layer); +} + +void gl3_0_glRenderbufferStorageMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRenderbufferStorageMultisample(target, samples, internalFormat, width, height); +} + +void gl3_0_glBlitFramebuffer(void *_glfuncs, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); +} + +void gl3_0_glGenerateMipmap(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenerateMipmap(target); +} + +void gl3_0_glGetFramebufferAttachmentParameteriv(void *_glfuncs, GLenum target, GLenum attachment, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFramebufferAttachmentParameteriv(target, attachment, pname, params); +} + +void gl3_0_glFramebufferRenderbuffer(void *_glfuncs, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer); +} + +void gl3_0_glFramebufferTexture3D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset); +} + +void gl3_0_glFramebufferTexture2D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture2D(target, attachment, textarget, texture, level); +} + +void gl3_0_glFramebufferTexture1D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture1D(target, attachment, textarget, texture, level); +} + +GLenum gl3_0_glCheckFramebufferStatus(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCheckFramebufferStatus(target); +} + +void gl3_0_glGenFramebuffers(void *_glfuncs, GLsizei n, GLuint* framebuffers) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenFramebuffers(n, framebuffers); +} + +void gl3_0_glDeleteFramebuffers(void *_glfuncs, GLsizei n, const GLuint* framebuffers) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteFramebuffers(n, framebuffers); +} + +void gl3_0_glBindFramebuffer(void *_glfuncs, GLenum target, GLuint framebuffer) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFramebuffer(target, framebuffer); +} + +GLboolean gl3_0_glIsFramebuffer(void *_glfuncs, GLuint framebuffer) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsFramebuffer(framebuffer); +} + +void gl3_0_glGetRenderbufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetRenderbufferParameteriv(target, pname, params); +} + +void gl3_0_glRenderbufferStorage(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRenderbufferStorage(target, internalFormat, width, height); +} + +void gl3_0_glGenRenderbuffers(void *_glfuncs, GLsizei n, GLuint* renderbuffers) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenRenderbuffers(n, renderbuffers); +} + +void gl3_0_glDeleteRenderbuffers(void *_glfuncs, GLsizei n, const GLuint* renderbuffers) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteRenderbuffers(n, renderbuffers); +} + +void gl3_0_glBindRenderbuffer(void *_glfuncs, GLenum target, GLuint renderbuffer) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindRenderbuffer(target, renderbuffer); +} + +GLboolean gl3_0_glIsRenderbuffer(void *_glfuncs, GLuint renderbuffer) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsRenderbuffer(renderbuffer); +} + +void gl3_0_glClearBufferfi(void *_glfuncs, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferfi(buffer, drawbuffer, depth, stencil); +} + +void gl3_0_glClearBufferfv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLfloat* value) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferfv(buffer, drawbuffer, value); +} + +void gl3_0_glClearBufferuiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLuint* value) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferuiv(buffer, drawbuffer, value); +} + +void gl3_0_glClearBufferiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLint* value) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferiv(buffer, drawbuffer, value); +} + +void gl3_0_glGetTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterIuiv(target, pname, params); +} + +void gl3_0_glGetTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterIiv(target, pname, params); +} + +void gl3_0_glTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, const GLuint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterIuiv(target, pname, params); +} + +void gl3_0_glTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterIiv(target, pname, params); +} + +void gl3_0_glUniform4uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4uiv(location, count, value); +} + +void gl3_0_glUniform3uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3uiv(location, count, value); +} + +void gl3_0_glUniform2uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2uiv(location, count, value); +} + +void gl3_0_glUniform1uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1uiv(location, count, value); +} + +void gl3_0_glUniform4ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4ui(location, v0, v1, v2, v3); +} + +void gl3_0_glUniform3ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3ui(location, v0, v1, v2); +} + +void gl3_0_glUniform2ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2ui(location, v0, v1); +} + +void gl3_0_glUniform1ui(void *_glfuncs, GLint location, GLuint v0) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1ui(location, v0); +} + +GLint gl3_0_glGetFragDataLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetFragDataLocation(program, name); +} + +void gl3_0_glBindFragDataLocation(void *_glfuncs, GLuint program, GLuint color, const GLchar* name) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFragDataLocation(program, color, name); +} + +void gl3_0_glGetUniformuiv(void *_glfuncs, GLuint program, GLint location, GLuint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformuiv(program, location, params); +} + +void gl3_0_glGetVertexAttribIuiv(void *_glfuncs, GLuint index, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribIuiv(index, pname, params); +} + +void gl3_0_glGetVertexAttribIiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribIiv(index, pname, params); +} + +void gl3_0_glVertexAttribIPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribIPointer(index, size, gltype, stride, pointer); +} + +void gl3_0_glEndConditionalRender(void *_glfuncs) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndConditionalRender(); +} + +void gl3_0_glBeginConditionalRender(void *_glfuncs, GLuint id, GLenum mode) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginConditionalRender(id, mode); +} + +void gl3_0_glClampColor(void *_glfuncs, GLenum target, GLenum clamp) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClampColor(target, clamp); +} + +void gl3_0_glGetTransformFeedbackVarying(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTransformFeedbackVarying(program, index, bufSize, length, size, gltype, name); +} + +void gl3_0_glBindBufferBase(void *_glfuncs, GLenum target, GLuint index, GLuint buffer) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBufferBase(target, index, buffer); +} + +void gl3_0_glBindBufferRange(void *_glfuncs, GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBufferRange(target, index, buffer, offset, size); +} + +void gl3_0_glEndTransformFeedback(void *_glfuncs) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndTransformFeedback(); +} + +void gl3_0_glBeginTransformFeedback(void *_glfuncs, GLenum primitiveMode) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginTransformFeedback(primitiveMode); +} + +GLboolean gl3_0_glIsEnabledi(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabledi(target, index); +} + +void gl3_0_glDisablei(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisablei(target, index); +} + +void gl3_0_glEnablei(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnablei(target, index); +} + +void gl3_0_glGetIntegeri_v(void *_glfuncs, GLenum target, GLuint index, GLint* data) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegeri_v(target, index, data); +} + +void gl3_0_glGetBooleani_v(void *_glfuncs, GLenum target, GLuint index, GLboolean* data) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleani_v(target, index, data); +} + +void gl3_0_glColorMaski(void *_glfuncs, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMaski(index, r, g, b, a); +} + +void gl3_0_glTranslatef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTranslatef(x, y, z); +} + +void gl3_0_glTranslated(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTranslated(x, y, z); +} + +void gl3_0_glScalef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScalef(x, y, z); +} + +void gl3_0_glScaled(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScaled(x, y, z); +} + +void gl3_0_glRotatef(void *_glfuncs, GLfloat angle, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRotatef(angle, x, y, z); +} + +void gl3_0_glRotated(void *_glfuncs, GLdouble angle, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRotated(angle, x, y, z); +} + +void gl3_0_glPushMatrix(void *_glfuncs) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushMatrix(); +} + +void gl3_0_glPopMatrix(void *_glfuncs) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopMatrix(); +} + +void gl3_0_glOrtho(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glOrtho(left, right, bottom, top, zNear, zFar); +} + +void gl3_0_glMultMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultMatrixd(m); +} + +void gl3_0_glMultMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultMatrixf(m); +} + +void gl3_0_glMatrixMode(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMatrixMode(mode); +} + +void gl3_0_glLoadMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadMatrixd(m); +} + +void gl3_0_glLoadMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadMatrixf(m); +} + +void gl3_0_glLoadIdentity(void *_glfuncs) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadIdentity(); +} + +void gl3_0_glFrustum(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrustum(left, right, bottom, top, zNear, zFar); +} + +GLboolean gl3_0_glIsList(void *_glfuncs, GLuint list) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsList(list); +} + +void gl3_0_glGetTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGeniv(coord, pname, params); +} + +void gl3_0_glGetTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGenfv(coord, pname, params); +} + +void gl3_0_glGetTexGendv(void *_glfuncs, GLenum coord, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGendv(coord, pname, params); +} + +void gl3_0_glGetTexEnviv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexEnviv(target, pname, params); +} + +void gl3_0_glGetTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexEnvfv(target, pname, params); +} + +void gl3_0_glGetPolygonStipple(void *_glfuncs, GLubyte* mask) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPolygonStipple(mask); +} + +void gl3_0_glGetPixelMapusv(void *_glfuncs, GLenum glmap, GLushort* values) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapusv(glmap, values); +} + +void gl3_0_glGetPixelMapuiv(void *_glfuncs, GLenum glmap, GLuint* values) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapuiv(glmap, values); +} + +void gl3_0_glGetPixelMapfv(void *_glfuncs, GLenum glmap, GLfloat* values) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapfv(glmap, values); +} + +void gl3_0_glGetMaterialiv(void *_glfuncs, GLenum face, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMaterialiv(face, pname, params); +} + +void gl3_0_glGetMaterialfv(void *_glfuncs, GLenum face, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMaterialfv(face, pname, params); +} + +void gl3_0_glGetMapiv(void *_glfuncs, GLenum target, GLenum query, GLint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapiv(target, query, v); +} + +void gl3_0_glGetMapfv(void *_glfuncs, GLenum target, GLenum query, GLfloat* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapfv(target, query, v); +} + +void gl3_0_glGetMapdv(void *_glfuncs, GLenum target, GLenum query, GLdouble* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapdv(target, query, v); +} + +void gl3_0_glGetLightiv(void *_glfuncs, GLenum light, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetLightiv(light, pname, params); +} + +void gl3_0_glGetLightfv(void *_glfuncs, GLenum light, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetLightfv(light, pname, params); +} + +void gl3_0_glGetClipPlane(void *_glfuncs, GLenum plane, GLdouble* equation) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetClipPlane(plane, equation); +} + +void gl3_0_glDrawPixels(void *_glfuncs, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawPixels(width, height, format, gltype, pixels); +} + +void gl3_0_glCopyPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum gltype) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyPixels(x, y, width, height, gltype); +} + +void gl3_0_glPixelMapusv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLushort* values) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapusv(glmap, mapsize, values); +} + +void gl3_0_glPixelMapuiv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLuint* values) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapuiv(glmap, mapsize, values); +} + +void gl3_0_glPixelMapfv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLfloat* values) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapfv(glmap, mapsize, values); +} + +void gl3_0_glPixelTransferi(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelTransferi(pname, param); +} + +void gl3_0_glPixelTransferf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelTransferf(pname, param); +} + +void gl3_0_glPixelZoom(void *_glfuncs, GLfloat xfactor, GLfloat yfactor) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelZoom(xfactor, yfactor); +} + +void gl3_0_glAlphaFunc(void *_glfuncs, GLenum glfunc, GLfloat ref) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAlphaFunc(glfunc, ref); +} + +void gl3_0_glEvalPoint2(void *_glfuncs, GLint i, GLint j) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalPoint2(i, j); +} + +void gl3_0_glEvalMesh2(void *_glfuncs, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalMesh2(mode, i1, i2, j1, j2); +} + +void gl3_0_glEvalPoint1(void *_glfuncs, GLint i) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalPoint1(i); +} + +void gl3_0_glEvalMesh1(void *_glfuncs, GLenum mode, GLint i1, GLint i2) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalMesh1(mode, i1, i2); +} + +void gl3_0_glEvalCoord2fv(void *_glfuncs, const GLfloat* u) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2fv(u); +} + +void gl3_0_glEvalCoord2f(void *_glfuncs, GLfloat u, GLfloat v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2f(u, v); +} + +void gl3_0_glEvalCoord2dv(void *_glfuncs, const GLdouble* u) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2dv(u); +} + +void gl3_0_glEvalCoord2d(void *_glfuncs, GLdouble u, GLdouble v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2d(u, v); +} + +void gl3_0_glEvalCoord1fv(void *_glfuncs, const GLfloat* u) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1fv(u); +} + +void gl3_0_glEvalCoord1f(void *_glfuncs, GLfloat u) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1f(u); +} + +void gl3_0_glEvalCoord1dv(void *_glfuncs, const GLdouble* u) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1dv(u); +} + +void gl3_0_glEvalCoord1d(void *_glfuncs, GLdouble u) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1d(u); +} + +void gl3_0_glMapGrid2f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid2f(un, u1, u2, vn, v1, v2); +} + +void gl3_0_glMapGrid2d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid2d(un, u1, u2, vn, v1, v2); +} + +void gl3_0_glMapGrid1f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid1f(un, u1, u2); +} + +void gl3_0_glMapGrid1d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid1d(un, u1, u2); +} + +void gl3_0_glMap2f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); +} + +void gl3_0_glMap2d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); +} + +void gl3_0_glMap1f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap1f(target, u1, u2, stride, order, points); +} + +void gl3_0_glMap1d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap1d(target, u1, u2, stride, order, points); +} + +void gl3_0_glPushAttrib(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushAttrib(mask); +} + +void gl3_0_glPopAttrib(void *_glfuncs) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopAttrib(); +} + +void gl3_0_glAccum(void *_glfuncs, GLenum op, GLfloat value) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAccum(op, value); +} + +void gl3_0_glIndexMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexMask(mask); +} + +void gl3_0_glClearIndex(void *_glfuncs, GLfloat c) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearIndex(c); +} + +void gl3_0_glClearAccum(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearAccum(red, green, blue, alpha); +} + +void gl3_0_glPushName(void *_glfuncs, GLuint name) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushName(name); +} + +void gl3_0_glPopName(void *_glfuncs) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopName(); +} + +void gl3_0_glPassThrough(void *_glfuncs, GLfloat token) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPassThrough(token); +} + +void gl3_0_glLoadName(void *_glfuncs, GLuint name) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadName(name); +} + +void gl3_0_glInitNames(void *_glfuncs) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInitNames(); +} + +GLint gl3_0_glRenderMode(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glRenderMode(mode); +} + +void gl3_0_glSelectBuffer(void *_glfuncs, GLsizei size, GLuint* buffer) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSelectBuffer(size, buffer); +} + +void gl3_0_glFeedbackBuffer(void *_glfuncs, GLsizei size, GLenum gltype, GLfloat* buffer) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFeedbackBuffer(size, gltype, buffer); +} + +void gl3_0_glTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGeniv(coord, pname, params); +} + +void gl3_0_glTexGeni(void *_glfuncs, GLenum coord, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGeni(coord, pname, param); +} + +void gl3_0_glTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGenfv(coord, pname, params); +} + +void gl3_0_glTexGenf(void *_glfuncs, GLenum coord, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGenf(coord, pname, param); +} + +void gl3_0_glTexGendv(void *_glfuncs, GLenum coord, GLenum pname, const GLdouble* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGendv(coord, pname, params); +} + +void gl3_0_glTexGend(void *_glfuncs, GLenum coord, GLenum pname, GLdouble param) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGend(coord, pname, param); +} + +void gl3_0_glTexEnviv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnviv(target, pname, params); +} + +void gl3_0_glTexEnvi(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvi(target, pname, param); +} + +void gl3_0_glTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvfv(target, pname, params); +} + +void gl3_0_glTexEnvf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvf(target, pname, param); +} + +void gl3_0_glShadeModel(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShadeModel(mode); +} + +void gl3_0_glPolygonStipple(void *_glfuncs, const GLubyte* mask) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonStipple(mask); +} + +void gl3_0_glMaterialiv(void *_glfuncs, GLenum face, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialiv(face, pname, params); +} + +void gl3_0_glMateriali(void *_glfuncs, GLenum face, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMateriali(face, pname, param); +} + +void gl3_0_glMaterialfv(void *_glfuncs, GLenum face, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialfv(face, pname, params); +} + +void gl3_0_glMaterialf(void *_glfuncs, GLenum face, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialf(face, pname, param); +} + +void gl3_0_glLineStipple(void *_glfuncs, GLint factor, GLushort pattern) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineStipple(factor, pattern); +} + +void gl3_0_glLightModeliv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModeliv(pname, params); +} + +void gl3_0_glLightModeli(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModeli(pname, param); +} + +void gl3_0_glLightModelfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModelfv(pname, params); +} + +void gl3_0_glLightModelf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModelf(pname, param); +} + +void gl3_0_glLightiv(void *_glfuncs, GLenum light, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightiv(light, pname, params); +} + +void gl3_0_glLighti(void *_glfuncs, GLenum light, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLighti(light, pname, param); +} + +void gl3_0_glLightfv(void *_glfuncs, GLenum light, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightfv(light, pname, params); +} + +void gl3_0_glLightf(void *_glfuncs, GLenum light, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightf(light, pname, param); +} + +void gl3_0_glFogiv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogiv(pname, params); +} + +void gl3_0_glFogi(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogi(pname, param); +} + +void gl3_0_glFogfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogfv(pname, params); +} + +void gl3_0_glFogf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogf(pname, param); +} + +void gl3_0_glColorMaterial(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMaterial(face, mode); +} + +void gl3_0_glClipPlane(void *_glfuncs, GLenum plane, const GLdouble* equation) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClipPlane(plane, equation); +} + +void gl3_0_glVertex4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4sv(v); +} + +void gl3_0_glVertex4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4s(x, y, z, w); +} + +void gl3_0_glVertex4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4iv(v); +} + +void gl3_0_glVertex4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4i(x, y, z, w); +} + +void gl3_0_glVertex4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4fv(v); +} + +void gl3_0_glVertex4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4f(x, y, z, w); +} + +void gl3_0_glVertex4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4dv(v); +} + +void gl3_0_glVertex4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4d(x, y, z, w); +} + +void gl3_0_glVertex3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3sv(v); +} + +void gl3_0_glVertex3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3s(x, y, z); +} + +void gl3_0_glVertex3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3iv(v); +} + +void gl3_0_glVertex3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3i(x, y, z); +} + +void gl3_0_glVertex3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3fv(v); +} + +void gl3_0_glVertex3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3f(x, y, z); +} + +void gl3_0_glVertex3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3dv(v); +} + +void gl3_0_glVertex3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3d(x, y, z); +} + +void gl3_0_glVertex2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2sv(v); +} + +void gl3_0_glVertex2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2s(x, y); +} + +void gl3_0_glVertex2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2iv(v); +} + +void gl3_0_glVertex2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2i(x, y); +} + +void gl3_0_glVertex2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2fv(v); +} + +void gl3_0_glVertex2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2f(x, y); +} + +void gl3_0_glVertex2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2dv(v); +} + +void gl3_0_glVertex2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2d(x, y); +} + +void gl3_0_glTexCoord4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4sv(v); +} + +void gl3_0_glTexCoord4s(void *_glfuncs, GLshort s, GLshort t, GLshort r, GLshort q) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4s(s, t, r, q); +} + +void gl3_0_glTexCoord4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4iv(v); +} + +void gl3_0_glTexCoord4i(void *_glfuncs, GLint s, GLint t, GLint r, GLint q) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4i(s, t, r, q); +} + +void gl3_0_glTexCoord4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4fv(v); +} + +void gl3_0_glTexCoord4f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4f(s, t, r, q); +} + +void gl3_0_glTexCoord4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4dv(v); +} + +void gl3_0_glTexCoord4d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r, GLdouble q) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4d(s, t, r, q); +} + +void gl3_0_glTexCoord3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3sv(v); +} + +void gl3_0_glTexCoord3s(void *_glfuncs, GLshort s, GLshort t, GLshort r) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3s(s, t, r); +} + +void gl3_0_glTexCoord3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3iv(v); +} + +void gl3_0_glTexCoord3i(void *_glfuncs, GLint s, GLint t, GLint r) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3i(s, t, r); +} + +void gl3_0_glTexCoord3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3fv(v); +} + +void gl3_0_glTexCoord3f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3f(s, t, r); +} + +void gl3_0_glTexCoord3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3dv(v); +} + +void gl3_0_glTexCoord3d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3d(s, t, r); +} + +void gl3_0_glTexCoord2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2sv(v); +} + +void gl3_0_glTexCoord2s(void *_glfuncs, GLshort s, GLshort t) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2s(s, t); +} + +void gl3_0_glTexCoord2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2iv(v); +} + +void gl3_0_glTexCoord2i(void *_glfuncs, GLint s, GLint t) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2i(s, t); +} + +void gl3_0_glTexCoord2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2fv(v); +} + +void gl3_0_glTexCoord2f(void *_glfuncs, GLfloat s, GLfloat t) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2f(s, t); +} + +void gl3_0_glTexCoord2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2dv(v); +} + +void gl3_0_glTexCoord2d(void *_glfuncs, GLdouble s, GLdouble t) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2d(s, t); +} + +void gl3_0_glTexCoord1sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1sv(v); +} + +void gl3_0_glTexCoord1s(void *_glfuncs, GLshort s) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1s(s); +} + +void gl3_0_glTexCoord1iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1iv(v); +} + +void gl3_0_glTexCoord1i(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1i(s); +} + +void gl3_0_glTexCoord1fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1fv(v); +} + +void gl3_0_glTexCoord1f(void *_glfuncs, GLfloat s) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1f(s); +} + +void gl3_0_glTexCoord1dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1dv(v); +} + +void gl3_0_glTexCoord1d(void *_glfuncs, GLdouble s) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1d(s); +} + +void gl3_0_glRectsv(void *_glfuncs, const GLshort* v1, const GLshort* v2) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectsv(v1, v2); +} + +void gl3_0_glRects(void *_glfuncs, GLshort x1, GLshort y1, GLshort x2, GLshort y2) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRects(x1, y1, x2, y2); +} + +void gl3_0_glRectiv(void *_glfuncs, const GLint* v1, const GLint* v2) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectiv(v1, v2); +} + +void gl3_0_glRecti(void *_glfuncs, GLint x1, GLint y1, GLint x2, GLint y2) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRecti(x1, y1, x2, y2); +} + +void gl3_0_glRectfv(void *_glfuncs, const GLfloat* v1, const GLfloat* v2) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectfv(v1, v2); +} + +void gl3_0_glRectf(void *_glfuncs, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectf(x1, y1, x2, y2); +} + +void gl3_0_glRectdv(void *_glfuncs, const GLdouble* v1, const GLdouble* v2) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectdv(v1, v2); +} + +void gl3_0_glRectd(void *_glfuncs, GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectd(x1, y1, x2, y2); +} + +void gl3_0_glRasterPos4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4sv(v); +} + +void gl3_0_glRasterPos4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4s(x, y, z, w); +} + +void gl3_0_glRasterPos4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4iv(v); +} + +void gl3_0_glRasterPos4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4i(x, y, z, w); +} + +void gl3_0_glRasterPos4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4fv(v); +} + +void gl3_0_glRasterPos4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4f(x, y, z, w); +} + +void gl3_0_glRasterPos4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4dv(v); +} + +void gl3_0_glRasterPos4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4d(x, y, z, w); +} + +void gl3_0_glRasterPos3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3sv(v); +} + +void gl3_0_glRasterPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3s(x, y, z); +} + +void gl3_0_glRasterPos3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3iv(v); +} + +void gl3_0_glRasterPos3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3i(x, y, z); +} + +void gl3_0_glRasterPos3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3fv(v); +} + +void gl3_0_glRasterPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3f(x, y, z); +} + +void gl3_0_glRasterPos3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3dv(v); +} + +void gl3_0_glRasterPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3d(x, y, z); +} + +void gl3_0_glRasterPos2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2sv(v); +} + +void gl3_0_glRasterPos2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2s(x, y); +} + +void gl3_0_glRasterPos2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2iv(v); +} + +void gl3_0_glRasterPos2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2i(x, y); +} + +void gl3_0_glRasterPos2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2fv(v); +} + +void gl3_0_glRasterPos2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2f(x, y); +} + +void gl3_0_glRasterPos2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2dv(v); +} + +void gl3_0_glRasterPos2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2d(x, y); +} + +void gl3_0_glNormal3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3sv(v); +} + +void gl3_0_glNormal3s(void *_glfuncs, GLshort nx, GLshort ny, GLshort nz) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3s(nx, ny, nz); +} + +void gl3_0_glNormal3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3iv(v); +} + +void gl3_0_glNormal3i(void *_glfuncs, GLint nx, GLint ny, GLint nz) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3i(nx, ny, nz); +} + +void gl3_0_glNormal3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3fv(v); +} + +void gl3_0_glNormal3f(void *_glfuncs, GLfloat nx, GLfloat ny, GLfloat nz) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3f(nx, ny, nz); +} + +void gl3_0_glNormal3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3dv(v); +} + +void gl3_0_glNormal3d(void *_glfuncs, GLdouble nx, GLdouble ny, GLdouble nz) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3d(nx, ny, nz); +} + +void gl3_0_glNormal3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3bv(v); +} + +void gl3_0_glNormal3b(void *_glfuncs, GLbyte nx, GLbyte ny, GLbyte nz) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3b(nx, ny, nz); +} + +void gl3_0_glIndexsv(void *_glfuncs, const GLshort* c) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexsv(c); +} + +void gl3_0_glIndexs(void *_glfuncs, GLshort c) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexs(c); +} + +void gl3_0_glIndexiv(void *_glfuncs, const GLint* c) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexiv(c); +} + +void gl3_0_glIndexi(void *_glfuncs, GLint c) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexi(c); +} + +void gl3_0_glIndexfv(void *_glfuncs, const GLfloat* c) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexfv(c); +} + +void gl3_0_glIndexf(void *_glfuncs, GLfloat c) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexf(c); +} + +void gl3_0_glIndexdv(void *_glfuncs, const GLdouble* c) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexdv(c); +} + +void gl3_0_glIndexd(void *_glfuncs, GLdouble c) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexd(c); +} + +void gl3_0_glEnd(void *_glfuncs) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnd(); +} + +void gl3_0_glEdgeFlagv(void *_glfuncs, const GLboolean* flag) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlagv(flag); +} + +void gl3_0_glEdgeFlag(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlag(flag); +} + +void gl3_0_glColor4usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4usv(v); +} + +void gl3_0_glColor4us(void *_glfuncs, GLushort red, GLushort green, GLushort blue, GLushort alpha) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4us(red, green, blue, alpha); +} + +void gl3_0_glColor4uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4uiv(v); +} + +void gl3_0_glColor4ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue, GLuint alpha) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ui(red, green, blue, alpha); +} + +void gl3_0_glColor4ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ubv(v); +} + +void gl3_0_glColor4ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ub(red, green, blue, alpha); +} + +void gl3_0_glColor4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4sv(v); +} + +void gl3_0_glColor4s(void *_glfuncs, GLshort red, GLshort green, GLshort blue, GLshort alpha) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4s(red, green, blue, alpha); +} + +void gl3_0_glColor4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4iv(v); +} + +void gl3_0_glColor4i(void *_glfuncs, GLint red, GLint green, GLint blue, GLint alpha) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4i(red, green, blue, alpha); +} + +void gl3_0_glColor4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4fv(v); +} + +void gl3_0_glColor4f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4f(red, green, blue, alpha); +} + +void gl3_0_glColor4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4dv(v); +} + +void gl3_0_glColor4d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4d(red, green, blue, alpha); +} + +void gl3_0_glColor4bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4bv(v); +} + +void gl3_0_glColor4b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4b(red, green, blue, alpha); +} + +void gl3_0_glColor3usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3usv(v); +} + +void gl3_0_glColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3us(red, green, blue); +} + +void gl3_0_glColor3uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3uiv(v); +} + +void gl3_0_glColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ui(red, green, blue); +} + +void gl3_0_glColor3ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ubv(v); +} + +void gl3_0_glColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ub(red, green, blue); +} + +void gl3_0_glColor3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3sv(v); +} + +void gl3_0_glColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3s(red, green, blue); +} + +void gl3_0_glColor3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3iv(v); +} + +void gl3_0_glColor3i(void *_glfuncs, GLint red, GLint green, GLint blue) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3i(red, green, blue); +} + +void gl3_0_glColor3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3fv(v); +} + +void gl3_0_glColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3f(red, green, blue); +} + +void gl3_0_glColor3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3dv(v); +} + +void gl3_0_glColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3d(red, green, blue); +} + +void gl3_0_glColor3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3bv(v); +} + +void gl3_0_glColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3b(red, green, blue); +} + +void gl3_0_glBitmap(void *_glfuncs, GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBitmap(width, height, xorig, yorig, xmove, ymove, bitmap); +} + +void gl3_0_glBegin(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBegin(mode); +} + +void gl3_0_glListBase(void *_glfuncs, GLuint base) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glListBase(base); +} + +GLuint gl3_0_glGenLists(void *_glfuncs, GLsizei range_) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGenLists(range_); +} + +void gl3_0_glDeleteLists(void *_glfuncs, GLuint list, GLsizei range_) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteLists(list, range_); +} + +void gl3_0_glCallLists(void *_glfuncs, GLsizei n, GLenum gltype, const GLvoid* lists) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCallLists(n, gltype, lists); +} + +void gl3_0_glCallList(void *_glfuncs, GLuint list) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCallList(list); +} + +void gl3_0_glEndList(void *_glfuncs) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndList(); +} + +void gl3_0_glNewList(void *_glfuncs, GLuint list, GLenum mode) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNewList(list, mode); +} + +void gl3_0_glPushClientAttrib(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushClientAttrib(mask); +} + +void gl3_0_glPopClientAttrib(void *_glfuncs) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopClientAttrib(); +} + +void gl3_0_glPrioritizeTextures(void *_glfuncs, GLsizei n, const GLuint* textures, const GLfloat* priorities) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPrioritizeTextures(n, textures, priorities); +} + +GLboolean gl3_0_glAreTexturesResident(void *_glfuncs, GLsizei n, const GLuint* textures, GLboolean* residences) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glAreTexturesResident(n, textures, residences); +} + +void gl3_0_glVertexPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexPointer(size, gltype, stride, pointer); +} + +void gl3_0_glTexCoordPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordPointer(size, gltype, stride, pointer); +} + +void gl3_0_glNormalPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormalPointer(gltype, stride, pointer); +} + +void gl3_0_glInterleavedArrays(void *_glfuncs, GLenum format, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInterleavedArrays(format, stride, pointer); +} + +void gl3_0_glIndexPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexPointer(gltype, stride, pointer); +} + +void gl3_0_glEnableClientState(void *_glfuncs, GLenum array) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnableClientState(array); +} + +void gl3_0_glEdgeFlagPointer(void *_glfuncs, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlagPointer(stride, pointer); +} + +void gl3_0_glDisableClientState(void *_glfuncs, GLenum array) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisableClientState(array); +} + +void gl3_0_glColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorPointer(size, gltype, stride, pointer); +} + +void gl3_0_glArrayElement(void *_glfuncs, GLint i) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glArrayElement(i); +} + +void gl3_0_glResetMinmax(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glResetMinmax(target); +} + +void gl3_0_glResetHistogram(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glResetHistogram(target); +} + +void gl3_0_glMinmax(void *_glfuncs, GLenum target, GLenum internalFormat, GLboolean sink) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMinmax(target, internalFormat, sink); +} + +void gl3_0_glHistogram(void *_glfuncs, GLenum target, GLsizei width, GLenum internalFormat, GLboolean sink) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glHistogram(target, width, internalFormat, sink); +} + +void gl3_0_glGetMinmaxParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmaxParameteriv(target, pname, params); +} + +void gl3_0_glGetMinmaxParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmaxParameterfv(target, pname, params); +} + +void gl3_0_glGetMinmax(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmax(target, reset, format, gltype, values); +} + +void gl3_0_glGetHistogramParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogramParameteriv(target, pname, params); +} + +void gl3_0_glGetHistogramParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogramParameterfv(target, pname, params); +} + +void gl3_0_glGetHistogram(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogram(target, reset, format, gltype, values); +} + +void gl3_0_glSeparableFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* row, const GLvoid* column) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSeparableFilter2D(target, internalFormat, width, height, format, gltype, row, column); +} + +void gl3_0_glGetSeparableFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* row, GLvoid* column, GLvoid* span) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSeparableFilter(target, format, gltype, row, column, span); +} + +void gl3_0_glGetConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionParameteriv(target, pname, params); +} + +void gl3_0_glGetConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionParameterfv(target, pname, params); +} + +void gl3_0_glGetConvolutionFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* image) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionFilter(target, format, gltype, image); +} + +void gl3_0_glCopyConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyConvolutionFilter2D(target, internalFormat, x, y, width, height); +} + +void gl3_0_glCopyConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyConvolutionFilter1D(target, internalFormat, x, y, width); +} + +void gl3_0_glConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameteriv(target, pname, params); +} + +void gl3_0_glConvolutionParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameteri(target, pname, params); +} + +void gl3_0_glConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameterfv(target, pname, params); +} + +void gl3_0_glConvolutionParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameterf(target, pname, params); +} + +void gl3_0_glConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* image) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionFilter2D(target, internalFormat, width, height, format, gltype, image); +} + +void gl3_0_glConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* image) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionFilter1D(target, internalFormat, width, format, gltype, image); +} + +void gl3_0_glCopyColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyColorSubTable(target, start, x, y, width); +} + +void gl3_0_glColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum gltype, const GLvoid* data) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorSubTable(target, start, count, format, gltype, data); +} + +void gl3_0_glGetColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTableParameteriv(target, pname, params); +} + +void gl3_0_glGetColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTableParameterfv(target, pname, params); +} + +void gl3_0_glGetColorTable(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* table) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTable(target, format, gltype, table); +} + +void gl3_0_glCopyColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyColorTable(target, internalFormat, x, y, width); +} + +void gl3_0_glColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTableParameteriv(target, pname, params); +} + +void gl3_0_glColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTableParameterfv(target, pname, params); +} + +void gl3_0_glColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* table) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTable(target, internalFormat, width, format, gltype, table); +} + +void gl3_0_glMultTransposeMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultTransposeMatrixd(m); +} + +void gl3_0_glMultTransposeMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultTransposeMatrixf(m); +} + +void gl3_0_glLoadTransposeMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadTransposeMatrixd(m); +} + +void gl3_0_glLoadTransposeMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadTransposeMatrixf(m); +} + +void gl3_0_glMultiTexCoord4sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4sv(target, v); +} + +void gl3_0_glMultiTexCoord4s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r, GLshort q) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4s(target, s, t, r, q); +} + +void gl3_0_glMultiTexCoord4iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4iv(target, v); +} + +void gl3_0_glMultiTexCoord4i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r, GLint q) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4i(target, s, t, r, q); +} + +void gl3_0_glMultiTexCoord4fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4fv(target, v); +} + +void gl3_0_glMultiTexCoord4f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4f(target, s, t, r, q); +} + +void gl3_0_glMultiTexCoord4dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4dv(target, v); +} + +void gl3_0_glMultiTexCoord4d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4d(target, s, t, r, q); +} + +void gl3_0_glMultiTexCoord3sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3sv(target, v); +} + +void gl3_0_glMultiTexCoord3s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3s(target, s, t, r); +} + +void gl3_0_glMultiTexCoord3iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3iv(target, v); +} + +void gl3_0_glMultiTexCoord3i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3i(target, s, t, r); +} + +void gl3_0_glMultiTexCoord3fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3fv(target, v); +} + +void gl3_0_glMultiTexCoord3f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3f(target, s, t, r); +} + +void gl3_0_glMultiTexCoord3dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3dv(target, v); +} + +void gl3_0_glMultiTexCoord3d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3d(target, s, t, r); +} + +void gl3_0_glMultiTexCoord2sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2sv(target, v); +} + +void gl3_0_glMultiTexCoord2s(void *_glfuncs, GLenum target, GLshort s, GLshort t) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2s(target, s, t); +} + +void gl3_0_glMultiTexCoord2iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2iv(target, v); +} + +void gl3_0_glMultiTexCoord2i(void *_glfuncs, GLenum target, GLint s, GLint t) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2i(target, s, t); +} + +void gl3_0_glMultiTexCoord2fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2fv(target, v); +} + +void gl3_0_glMultiTexCoord2f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2f(target, s, t); +} + +void gl3_0_glMultiTexCoord2dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2dv(target, v); +} + +void gl3_0_glMultiTexCoord2d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2d(target, s, t); +} + +void gl3_0_glMultiTexCoord1sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1sv(target, v); +} + +void gl3_0_glMultiTexCoord1s(void *_glfuncs, GLenum target, GLshort s) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1s(target, s); +} + +void gl3_0_glMultiTexCoord1iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1iv(target, v); +} + +void gl3_0_glMultiTexCoord1i(void *_glfuncs, GLenum target, GLint s) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1i(target, s); +} + +void gl3_0_glMultiTexCoord1fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1fv(target, v); +} + +void gl3_0_glMultiTexCoord1f(void *_glfuncs, GLenum target, GLfloat s) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1f(target, s); +} + +void gl3_0_glMultiTexCoord1dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1dv(target, v); +} + +void gl3_0_glMultiTexCoord1d(void *_glfuncs, GLenum target, GLdouble s) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1d(target, s); +} + +void gl3_0_glClientActiveTexture(void *_glfuncs, GLenum texture) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClientActiveTexture(texture); +} + +void gl3_0_glWindowPos3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3sv(v); +} + +void gl3_0_glWindowPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3s(x, y, z); +} + +void gl3_0_glWindowPos3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3iv(v); +} + +void gl3_0_glWindowPos3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3i(x, y, z); +} + +void gl3_0_glWindowPos3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3fv(v); +} + +void gl3_0_glWindowPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3f(x, y, z); +} + +void gl3_0_glWindowPos3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3dv(v); +} + +void gl3_0_glWindowPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3d(x, y, z); +} + +void gl3_0_glWindowPos2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2sv(v); +} + +void gl3_0_glWindowPos2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2s(x, y); +} + +void gl3_0_glWindowPos2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2iv(v); +} + +void gl3_0_glWindowPos2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2i(x, y); +} + +void gl3_0_glWindowPos2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2fv(v); +} + +void gl3_0_glWindowPos2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2f(x, y); +} + +void gl3_0_glWindowPos2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2dv(v); +} + +void gl3_0_glWindowPos2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2d(x, y); +} + +void gl3_0_glSecondaryColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColorPointer(size, gltype, stride, pointer); +} + +void gl3_0_glSecondaryColor3usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3usv(v); +} + +void gl3_0_glSecondaryColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3us(red, green, blue); +} + +void gl3_0_glSecondaryColor3uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3uiv(v); +} + +void gl3_0_glSecondaryColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3ui(red, green, blue); +} + +void gl3_0_glSecondaryColor3ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3ubv(v); +} + +void gl3_0_glSecondaryColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3ub(red, green, blue); +} + +void gl3_0_glSecondaryColor3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3sv(v); +} + +void gl3_0_glSecondaryColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3s(red, green, blue); +} + +void gl3_0_glSecondaryColor3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3iv(v); +} + +void gl3_0_glSecondaryColor3i(void *_glfuncs, GLint red, GLint green, GLint blue) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3i(red, green, blue); +} + +void gl3_0_glSecondaryColor3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3fv(v); +} + +void gl3_0_glSecondaryColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3f(red, green, blue); +} + +void gl3_0_glSecondaryColor3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3dv(v); +} + +void gl3_0_glSecondaryColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3d(red, green, blue); +} + +void gl3_0_glSecondaryColor3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3bv(v); +} + +void gl3_0_glSecondaryColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3b(red, green, blue); +} + +void gl3_0_glFogCoordPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordPointer(gltype, stride, pointer); +} + +void gl3_0_glFogCoorddv(void *_glfuncs, const GLdouble* coord) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoorddv(coord); +} + +void gl3_0_glFogCoordd(void *_glfuncs, GLdouble coord) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordd(coord); +} + +void gl3_0_glFogCoordfv(void *_glfuncs, const GLfloat* coord) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordfv(coord); +} + +void gl3_0_glFogCoordf(void *_glfuncs, GLfloat coord) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordf(coord); +} + +void gl3_0_glVertexAttrib4usv(void *_glfuncs, GLuint index, const GLushort* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4usv(index, v); +} + +void gl3_0_glVertexAttrib4uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4uiv(index, v); +} + +void gl3_0_glVertexAttrib4ubv(void *_glfuncs, GLuint index, const GLubyte* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4ubv(index, v); +} + +void gl3_0_glVertexAttrib4sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4sv(index, v); +} + +void gl3_0_glVertexAttrib4s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4s(index, x, y, z, w); +} + +void gl3_0_glVertexAttrib4iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4iv(index, v); +} + +void gl3_0_glVertexAttrib4fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4fv(index, v); +} + +void gl3_0_glVertexAttrib4f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4f(index, x, y, z, w); +} + +void gl3_0_glVertexAttrib4dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4dv(index, v); +} + +void gl3_0_glVertexAttrib4d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4d(index, x, y, z, w); +} + +void gl3_0_glVertexAttrib4bv(void *_glfuncs, GLuint index, const GLbyte* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4bv(index, v); +} + +void gl3_0_glVertexAttrib4Nusv(void *_glfuncs, GLuint index, const GLushort* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nusv(index, v); +} + +void gl3_0_glVertexAttrib4Nuiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nuiv(index, v); +} + +void gl3_0_glVertexAttrib4Nubv(void *_glfuncs, GLuint index, const GLubyte* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nubv(index, v); +} + +void gl3_0_glVertexAttrib4Nub(void *_glfuncs, GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nub(index, x, y, z, w); +} + +void gl3_0_glVertexAttrib4Nsv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nsv(index, v); +} + +void gl3_0_glVertexAttrib4Niv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Niv(index, v); +} + +void gl3_0_glVertexAttrib4Nbv(void *_glfuncs, GLuint index, const GLbyte* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nbv(index, v); +} + +void gl3_0_glVertexAttrib3sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3sv(index, v); +} + +void gl3_0_glVertexAttrib3s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3s(index, x, y, z); +} + +void gl3_0_glVertexAttrib3fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3fv(index, v); +} + +void gl3_0_glVertexAttrib3f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3f(index, x, y, z); +} + +void gl3_0_glVertexAttrib3dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3dv(index, v); +} + +void gl3_0_glVertexAttrib3d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3d(index, x, y, z); +} + +void gl3_0_glVertexAttrib2sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2sv(index, v); +} + +void gl3_0_glVertexAttrib2s(void *_glfuncs, GLuint index, GLshort x, GLshort y) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2s(index, x, y); +} + +void gl3_0_glVertexAttrib2fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2fv(index, v); +} + +void gl3_0_glVertexAttrib2f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2f(index, x, y); +} + +void gl3_0_glVertexAttrib2dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2dv(index, v); +} + +void gl3_0_glVertexAttrib2d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2d(index, x, y); +} + +void gl3_0_glVertexAttrib1sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1sv(index, v); +} + +void gl3_0_glVertexAttrib1s(void *_glfuncs, GLuint index, GLshort x) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1s(index, x); +} + +void gl3_0_glVertexAttrib1fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1fv(index, v); +} + +void gl3_0_glVertexAttrib1f(void *_glfuncs, GLuint index, GLfloat x) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1f(index, x); +} + +void gl3_0_glVertexAttrib1dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1dv(index, v); +} + +void gl3_0_glVertexAttrib1d(void *_glfuncs, GLuint index, GLdouble x) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1d(index, x); +} + +void gl3_0_glVertexAttribI4usv(void *_glfuncs, GLuint index, const GLushort* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4usv(index, v); +} + +void gl3_0_glVertexAttribI4ubv(void *_glfuncs, GLuint index, const GLubyte* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4ubv(index, v); +} + +void gl3_0_glVertexAttribI4sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4sv(index, v); +} + +void gl3_0_glVertexAttribI4bv(void *_glfuncs, GLuint index, const GLbyte* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4bv(index, v); +} + +void gl3_0_glVertexAttribI4uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4uiv(index, v); +} + +void gl3_0_glVertexAttribI3uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI3uiv(index, v); +} + +void gl3_0_glVertexAttribI2uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI2uiv(index, v); +} + +void gl3_0_glVertexAttribI1uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI1uiv(index, v); +} + +void gl3_0_glVertexAttribI4iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4iv(index, v); +} + +void gl3_0_glVertexAttribI3iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI3iv(index, v); +} + +void gl3_0_glVertexAttribI2iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI2iv(index, v); +} + +void gl3_0_glVertexAttribI1iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI1iv(index, v); +} + +void gl3_0_glVertexAttribI4ui(void *_glfuncs, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4ui(index, x, y, z, w); +} + +void gl3_0_glVertexAttribI3ui(void *_glfuncs, GLuint index, GLuint x, GLuint y, GLuint z) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI3ui(index, x, y, z); +} + +void gl3_0_glVertexAttribI2ui(void *_glfuncs, GLuint index, GLuint x, GLuint y) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI2ui(index, x, y); +} + +void gl3_0_glVertexAttribI1ui(void *_glfuncs, GLuint index, GLuint x) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI1ui(index, x); +} + +void gl3_0_glVertexAttribI4i(void *_glfuncs, GLuint index, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4i(index, x, y, z, w); +} + +void gl3_0_glVertexAttribI3i(void *_glfuncs, GLuint index, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI3i(index, x, y, z); +} + +void gl3_0_glVertexAttribI2i(void *_glfuncs, GLuint index, GLint x, GLint y) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI2i(index, x, y); +} + +void gl3_0_glVertexAttribI1i(void *_glfuncs, GLuint index, GLint x) +{ + QOpenGLFunctions_3_0* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI1i(index, x); +} + diff --git a/gl/3.0/funcs.h b/gl/3.0/funcs.h new file mode 100644 index 00000000..81db33a9 --- /dev/null +++ b/gl/3.0/funcs.h @@ -0,0 +1,700 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#ifndef __cplusplus +#include +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef char GLchar; +typedef signed char GLbyte; /* 1-byte signed */ +typedef short GLshort; /* 2-byte signed */ +typedef int GLint; /* 4-byte signed */ +typedef unsigned char GLubyte; /* 1-byte unsigned */ +typedef unsigned short GLushort; /* 2-byte unsigned */ +typedef unsigned int GLuint; /* 4-byte unsigned */ +typedef int GLsizei; /* 4-byte signed */ +typedef float GLfloat; /* single precision float */ +typedef float GLclampf; /* single precision float in [0,1] */ +typedef double GLdouble; /* double precision float */ +typedef double GLclampd; /* double precision float in [0,1] */ +typedef int64_t GLint64; +typedef uint64_t GLuint64; +typedef ptrdiff_t GLintptr; +typedef ptrdiff_t GLsizeiptr; +typedef ptrdiff_t GLintptrARB; +typedef ptrdiff_t GLsizeiptrARB; +typedef struct __GLsync *GLsync; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +void *gl3_0_funcs(); + +void gl3_0_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl3_0_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal); +GLboolean gl3_0_glIsEnabled(void *_glfuncs, GLenum cap); +void gl3_0_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params); +void gl3_0_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params); +void gl3_0_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_0_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl3_0_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels); +void gl3_0_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params); +void gl3_0_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params); +GLenum gl3_0_glGetError(void *_glfuncs); +void gl3_0_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params); +void gl3_0_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params); +void gl3_0_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels); +void gl3_0_glReadBuffer(void *_glfuncs, GLenum mode); +void gl3_0_glPixelStorei(void *_glfuncs, GLenum pname, GLint param); +void gl3_0_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param); +void gl3_0_glDepthFunc(void *_glfuncs, GLenum glfunc); +void gl3_0_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass); +void gl3_0_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask); +void gl3_0_glLogicOp(void *_glfuncs, GLenum opcode); +void gl3_0_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor); +void gl3_0_glFlush(void *_glfuncs); +void gl3_0_glFinish(void *_glfuncs); +void gl3_0_glEnable(void *_glfuncs, GLenum cap); +void gl3_0_glDisable(void *_glfuncs, GLenum cap); +void gl3_0_glDepthMask(void *_glfuncs, GLboolean flag); +void gl3_0_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +void gl3_0_glStencilMask(void *_glfuncs, GLuint mask); +void gl3_0_glClearDepth(void *_glfuncs, GLdouble depth); +void gl3_0_glClearStencil(void *_glfuncs, GLint s); +void gl3_0_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl3_0_glClear(void *_glfuncs, GLbitfield mask); +void gl3_0_glDrawBuffer(void *_glfuncs, GLenum mode); +void gl3_0_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_0_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_0_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl3_0_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl3_0_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl3_0_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl3_0_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl3_0_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode); +void gl3_0_glPointSize(void *_glfuncs, GLfloat size); +void gl3_0_glLineWidth(void *_glfuncs, GLfloat width); +void gl3_0_glHint(void *_glfuncs, GLenum target, GLenum mode); +void gl3_0_glFrontFace(void *_glfuncs, GLenum mode); +void gl3_0_glCullFace(void *_glfuncs, GLenum mode); +void gl3_0_glIndexubv(void *_glfuncs, const GLubyte* c); +void gl3_0_glIndexub(void *_glfuncs, GLubyte c); +GLboolean gl3_0_glIsTexture(void *_glfuncs, GLuint texture); +void gl3_0_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures); +void gl3_0_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures); +void gl3_0_glBindTexture(void *_glfuncs, GLenum target, GLuint texture); +void gl3_0_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_0_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_0_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl3_0_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +void gl3_0_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +void gl3_0_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border); +void gl3_0_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units); +void gl3_0_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl3_0_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count); +void gl3_0_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl3_0_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_0_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_0_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl3_0_glBlendEquation(void *_glfuncs, GLenum mode); +void gl3_0_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl3_0_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img); +void gl3_0_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl3_0_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl3_0_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl3_0_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data); +void gl3_0_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data); +void gl3_0_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data); +void gl3_0_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert); +void gl3_0_glActiveTexture(void *_glfuncs, GLenum texture); +void gl3_0_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params); +void gl3_0_glPointParameteri(void *_glfuncs, GLenum pname, GLint param); +void gl3_0_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl3_0_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param); +void gl3_0_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount); +void gl3_0_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +void gl3_0_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +GLboolean gl3_0_glUnmapBuffer(void *_glfuncs, GLenum target); +void gl3_0_glGetBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data); +void gl3_0_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data); +void gl3_0_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage); +GLboolean gl3_0_glIsBuffer(void *_glfuncs, GLuint buffer); +void gl3_0_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers); +void gl3_0_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers); +void gl3_0_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer); +void gl3_0_glGetQueryObjectuiv(void *_glfuncs, GLuint id, GLenum pname, GLuint* params); +void gl3_0_glGetQueryObjectiv(void *_glfuncs, GLuint id, GLenum pname, GLint* params); +void gl3_0_glGetQueryiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_0_glEndQuery(void *_glfuncs, GLenum target); +void gl3_0_glBeginQuery(void *_glfuncs, GLenum target, GLuint id); +GLboolean gl3_0_glIsQuery(void *_glfuncs, GLuint id); +void gl3_0_glDeleteQueries(void *_glfuncs, GLsizei n, const GLuint* ids); +void gl3_0_glGenQueries(void *_glfuncs, GLsizei n, GLuint* ids); +void gl3_0_glVertexAttribPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLboolean normalized, GLsizei stride, const GLvoid* offset); +void gl3_0_glValidateProgram(void *_glfuncs, GLuint program); +void gl3_0_glUniformMatrix4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_0_glUniformMatrix3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_0_glUniformMatrix2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_0_glUniform4iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl3_0_glUniform3iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl3_0_glUniform2iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl3_0_glUniform1iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl3_0_glUniform4fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl3_0_glUniform3fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl3_0_glUniform2fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl3_0_glUniform1fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl3_0_glUniform4i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +void gl3_0_glUniform3i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2); +void gl3_0_glUniform2i(void *_glfuncs, GLint location, GLint v0, GLint v1); +void gl3_0_glUniform1i(void *_glfuncs, GLint location, GLint v0); +void gl3_0_glUniform4f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +void gl3_0_glUniform3f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +void gl3_0_glUniform2f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1); +void gl3_0_glUniform1f(void *_glfuncs, GLint location, GLfloat v0); +void gl3_0_glUseProgram(void *_glfuncs, GLuint program); +void gl3_0_glShaderSource(void *_glfuncs, GLuint shader, GLsizei count, const GLchar** source, const GLint* length); +void gl3_0_glLinkProgram(void *_glfuncs, GLuint program); +GLboolean gl3_0_glIsShader(void *_glfuncs, GLuint shader); +GLboolean gl3_0_glIsProgram(void *_glfuncs, GLuint program); +void gl3_0_glGetVertexAttribiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params); +void gl3_0_glGetVertexAttribfv(void *_glfuncs, GLuint index, GLenum pname, GLfloat* params); +void gl3_0_glGetVertexAttribdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params); +void gl3_0_glGetUniformiv(void *_glfuncs, GLuint program, GLint location, GLint* params); +void gl3_0_glGetUniformfv(void *_glfuncs, GLuint program, GLint location, GLfloat* params); +GLint gl3_0_glGetUniformLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl3_0_glGetShaderSource(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source); +void gl3_0_glGetShaderInfoLog(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl3_0_glGetShaderiv(void *_glfuncs, GLuint shader, GLenum pname, GLint* params); +void gl3_0_glGetProgramInfoLog(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl3_0_glGetProgramiv(void *_glfuncs, GLuint program, GLenum pname, GLint* params); +GLint gl3_0_glGetAttribLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl3_0_glGetAttachedShaders(void *_glfuncs, GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj); +void gl3_0_glGetActiveUniform(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name); +void gl3_0_glGetActiveAttrib(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name); +void gl3_0_glEnableVertexAttribArray(void *_glfuncs, GLuint index); +void gl3_0_glDisableVertexAttribArray(void *_glfuncs, GLuint index); +void gl3_0_glDetachShader(void *_glfuncs, GLuint program, GLuint shader); +void gl3_0_glDeleteShader(void *_glfuncs, GLuint shader); +void gl3_0_glDeleteProgram(void *_glfuncs, GLuint program); +GLuint gl3_0_glCreateShader(void *_glfuncs, GLenum gltype); +GLuint gl3_0_glCreateProgram(void *_glfuncs); +void gl3_0_glCompileShader(void *_glfuncs, GLuint shader); +void gl3_0_glBindAttribLocation(void *_glfuncs, GLuint program, GLuint index, const GLchar* name); +void gl3_0_glAttachShader(void *_glfuncs, GLuint program, GLuint shader); +void gl3_0_glStencilMaskSeparate(void *_glfuncs, GLenum face, GLuint mask); +void gl3_0_glStencilFuncSeparate(void *_glfuncs, GLenum face, GLenum glfunc, GLint ref, GLuint mask); +void gl3_0_glStencilOpSeparate(void *_glfuncs, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +void gl3_0_glDrawBuffers(void *_glfuncs, GLsizei n, const GLenum* bufs); +void gl3_0_glBlendEquationSeparate(void *_glfuncs, GLenum modeRGB, GLenum modeAlpha); +void gl3_0_glUniformMatrix4x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_0_glUniformMatrix3x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_0_glUniformMatrix4x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_0_glUniformMatrix2x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_0_glUniformMatrix3x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_0_glUniformMatrix2x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +GLboolean gl3_0_glIsVertexArray(void *_glfuncs, GLuint array); +void gl3_0_glGenVertexArrays(void *_glfuncs, GLsizei n, GLuint* arrays); +void gl3_0_glDeleteVertexArrays(void *_glfuncs, GLsizei n, const GLuint* arrays); +void gl3_0_glBindVertexArray(void *_glfuncs, GLuint array); +void gl3_0_glFlushMappedBufferRange(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr length); +void gl3_0_glFramebufferTextureLayer(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +void gl3_0_glRenderbufferStorageMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height); +void gl3_0_glBlitFramebuffer(void *_glfuncs, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +void gl3_0_glGenerateMipmap(void *_glfuncs, GLenum target); +void gl3_0_glGetFramebufferAttachmentParameteriv(void *_glfuncs, GLenum target, GLenum attachment, GLenum pname, GLint* params); +void gl3_0_glFramebufferRenderbuffer(void *_glfuncs, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +void gl3_0_glFramebufferTexture3D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +void gl3_0_glFramebufferTexture2D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +void gl3_0_glFramebufferTexture1D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLenum gl3_0_glCheckFramebufferStatus(void *_glfuncs, GLenum target); +void gl3_0_glGenFramebuffers(void *_glfuncs, GLsizei n, GLuint* framebuffers); +void gl3_0_glDeleteFramebuffers(void *_glfuncs, GLsizei n, const GLuint* framebuffers); +void gl3_0_glBindFramebuffer(void *_glfuncs, GLenum target, GLuint framebuffer); +GLboolean gl3_0_glIsFramebuffer(void *_glfuncs, GLuint framebuffer); +void gl3_0_glGetRenderbufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_0_glRenderbufferStorage(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height); +void gl3_0_glGenRenderbuffers(void *_glfuncs, GLsizei n, GLuint* renderbuffers); +void gl3_0_glDeleteRenderbuffers(void *_glfuncs, GLsizei n, const GLuint* renderbuffers); +void gl3_0_glBindRenderbuffer(void *_glfuncs, GLenum target, GLuint renderbuffer); +GLboolean gl3_0_glIsRenderbuffer(void *_glfuncs, GLuint renderbuffer); +void gl3_0_glClearBufferfi(void *_glfuncs, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); +void gl3_0_glClearBufferfv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLfloat* value); +void gl3_0_glClearBufferuiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLuint* value); +void gl3_0_glClearBufferiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLint* value); +void gl3_0_glGetTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, GLuint* params); +void gl3_0_glGetTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_0_glTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, const GLuint* params); +void gl3_0_glTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl3_0_glUniform4uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl3_0_glUniform3uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl3_0_glUniform2uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl3_0_glUniform1uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl3_0_glUniform4ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +void gl3_0_glUniform3ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2); +void gl3_0_glUniform2ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1); +void gl3_0_glUniform1ui(void *_glfuncs, GLint location, GLuint v0); +GLint gl3_0_glGetFragDataLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl3_0_glBindFragDataLocation(void *_glfuncs, GLuint program, GLuint color, const GLchar* name); +void gl3_0_glGetUniformuiv(void *_glfuncs, GLuint program, GLint location, GLuint* params); +void gl3_0_glGetVertexAttribIuiv(void *_glfuncs, GLuint index, GLenum pname, GLuint* params); +void gl3_0_glGetVertexAttribIiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params); +void gl3_0_glVertexAttribIPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl3_0_glEndConditionalRender(void *_glfuncs); +void gl3_0_glBeginConditionalRender(void *_glfuncs, GLuint id, GLenum mode); +void gl3_0_glClampColor(void *_glfuncs, GLenum target, GLenum clamp); +void gl3_0_glGetTransformFeedbackVarying(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* gltype, GLchar* name); +void gl3_0_glBindBufferBase(void *_glfuncs, GLenum target, GLuint index, GLuint buffer); +void gl3_0_glBindBufferRange(void *_glfuncs, GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +void gl3_0_glEndTransformFeedback(void *_glfuncs); +void gl3_0_glBeginTransformFeedback(void *_glfuncs, GLenum primitiveMode); +GLboolean gl3_0_glIsEnabledi(void *_glfuncs, GLenum target, GLuint index); +void gl3_0_glDisablei(void *_glfuncs, GLenum target, GLuint index); +void gl3_0_glEnablei(void *_glfuncs, GLenum target, GLuint index); +void gl3_0_glGetIntegeri_v(void *_glfuncs, GLenum target, GLuint index, GLint* data); +void gl3_0_glGetBooleani_v(void *_glfuncs, GLenum target, GLuint index, GLboolean* data); +void gl3_0_glColorMaski(void *_glfuncs, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +void gl3_0_glTranslatef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl3_0_glTranslated(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl3_0_glScalef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl3_0_glScaled(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl3_0_glRotatef(void *_glfuncs, GLfloat angle, GLfloat x, GLfloat y, GLfloat z); +void gl3_0_glRotated(void *_glfuncs, GLdouble angle, GLdouble x, GLdouble y, GLdouble z); +void gl3_0_glPushMatrix(void *_glfuncs); +void gl3_0_glPopMatrix(void *_glfuncs); +void gl3_0_glOrtho(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +void gl3_0_glMultMatrixd(void *_glfuncs, const GLdouble* m); +void gl3_0_glMultMatrixf(void *_glfuncs, const GLfloat* m); +void gl3_0_glMatrixMode(void *_glfuncs, GLenum mode); +void gl3_0_glLoadMatrixd(void *_glfuncs, const GLdouble* m); +void gl3_0_glLoadMatrixf(void *_glfuncs, const GLfloat* m); +void gl3_0_glLoadIdentity(void *_glfuncs); +void gl3_0_glFrustum(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +GLboolean gl3_0_glIsList(void *_glfuncs, GLuint list); +void gl3_0_glGetTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, GLint* params); +void gl3_0_glGetTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, GLfloat* params); +void gl3_0_glGetTexGendv(void *_glfuncs, GLenum coord, GLenum pname, GLdouble* params); +void gl3_0_glGetTexEnviv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_0_glGetTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl3_0_glGetPolygonStipple(void *_glfuncs, GLubyte* mask); +void gl3_0_glGetPixelMapusv(void *_glfuncs, GLenum glmap, GLushort* values); +void gl3_0_glGetPixelMapuiv(void *_glfuncs, GLenum glmap, GLuint* values); +void gl3_0_glGetPixelMapfv(void *_glfuncs, GLenum glmap, GLfloat* values); +void gl3_0_glGetMaterialiv(void *_glfuncs, GLenum face, GLenum pname, GLint* params); +void gl3_0_glGetMaterialfv(void *_glfuncs, GLenum face, GLenum pname, GLfloat* params); +void gl3_0_glGetMapiv(void *_glfuncs, GLenum target, GLenum query, GLint* v); +void gl3_0_glGetMapfv(void *_glfuncs, GLenum target, GLenum query, GLfloat* v); +void gl3_0_glGetMapdv(void *_glfuncs, GLenum target, GLenum query, GLdouble* v); +void gl3_0_glGetLightiv(void *_glfuncs, GLenum light, GLenum pname, GLint* params); +void gl3_0_glGetLightfv(void *_glfuncs, GLenum light, GLenum pname, GLfloat* params); +void gl3_0_glGetClipPlane(void *_glfuncs, GLenum plane, GLdouble* equation); +void gl3_0_glDrawPixels(void *_glfuncs, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_0_glCopyPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum gltype); +void gl3_0_glPixelMapusv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLushort* values); +void gl3_0_glPixelMapuiv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLuint* values); +void gl3_0_glPixelMapfv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLfloat* values); +void gl3_0_glPixelTransferi(void *_glfuncs, GLenum pname, GLint param); +void gl3_0_glPixelTransferf(void *_glfuncs, GLenum pname, GLfloat param); +void gl3_0_glPixelZoom(void *_glfuncs, GLfloat xfactor, GLfloat yfactor); +void gl3_0_glAlphaFunc(void *_glfuncs, GLenum glfunc, GLfloat ref); +void gl3_0_glEvalPoint2(void *_glfuncs, GLint i, GLint j); +void gl3_0_glEvalMesh2(void *_glfuncs, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); +void gl3_0_glEvalPoint1(void *_glfuncs, GLint i); +void gl3_0_glEvalMesh1(void *_glfuncs, GLenum mode, GLint i1, GLint i2); +void gl3_0_glEvalCoord2fv(void *_glfuncs, const GLfloat* u); +void gl3_0_glEvalCoord2f(void *_glfuncs, GLfloat u, GLfloat v); +void gl3_0_glEvalCoord2dv(void *_glfuncs, const GLdouble* u); +void gl3_0_glEvalCoord2d(void *_glfuncs, GLdouble u, GLdouble v); +void gl3_0_glEvalCoord1fv(void *_glfuncs, const GLfloat* u); +void gl3_0_glEvalCoord1f(void *_glfuncs, GLfloat u); +void gl3_0_glEvalCoord1dv(void *_glfuncs, const GLdouble* u); +void gl3_0_glEvalCoord1d(void *_glfuncs, GLdouble u); +void gl3_0_glMapGrid2f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); +void gl3_0_glMapGrid2d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); +void gl3_0_glMapGrid1f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2); +void gl3_0_glMapGrid1d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2); +void gl3_0_glMap2f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points); +void gl3_0_glMap2d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points); +void gl3_0_glMap1f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points); +void gl3_0_glMap1d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points); +void gl3_0_glPushAttrib(void *_glfuncs, GLbitfield mask); +void gl3_0_glPopAttrib(void *_glfuncs); +void gl3_0_glAccum(void *_glfuncs, GLenum op, GLfloat value); +void gl3_0_glIndexMask(void *_glfuncs, GLuint mask); +void gl3_0_glClearIndex(void *_glfuncs, GLfloat c); +void gl3_0_glClearAccum(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl3_0_glPushName(void *_glfuncs, GLuint name); +void gl3_0_glPopName(void *_glfuncs); +void gl3_0_glPassThrough(void *_glfuncs, GLfloat token); +void gl3_0_glLoadName(void *_glfuncs, GLuint name); +void gl3_0_glInitNames(void *_glfuncs); +GLint gl3_0_glRenderMode(void *_glfuncs, GLenum mode); +void gl3_0_glSelectBuffer(void *_glfuncs, GLsizei size, GLuint* buffer); +void gl3_0_glFeedbackBuffer(void *_glfuncs, GLsizei size, GLenum gltype, GLfloat* buffer); +void gl3_0_glTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, const GLint* params); +void gl3_0_glTexGeni(void *_glfuncs, GLenum coord, GLenum pname, GLint param); +void gl3_0_glTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, const GLfloat* params); +void gl3_0_glTexGenf(void *_glfuncs, GLenum coord, GLenum pname, GLfloat param); +void gl3_0_glTexGendv(void *_glfuncs, GLenum coord, GLenum pname, const GLdouble* params); +void gl3_0_glTexGend(void *_glfuncs, GLenum coord, GLenum pname, GLdouble param); +void gl3_0_glTexEnviv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl3_0_glTexEnvi(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl3_0_glTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl3_0_glTexEnvf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl3_0_glShadeModel(void *_glfuncs, GLenum mode); +void gl3_0_glPolygonStipple(void *_glfuncs, const GLubyte* mask); +void gl3_0_glMaterialiv(void *_glfuncs, GLenum face, GLenum pname, const GLint* params); +void gl3_0_glMateriali(void *_glfuncs, GLenum face, GLenum pname, GLint param); +void gl3_0_glMaterialfv(void *_glfuncs, GLenum face, GLenum pname, const GLfloat* params); +void gl3_0_glMaterialf(void *_glfuncs, GLenum face, GLenum pname, GLfloat param); +void gl3_0_glLineStipple(void *_glfuncs, GLint factor, GLushort pattern); +void gl3_0_glLightModeliv(void *_glfuncs, GLenum pname, const GLint* params); +void gl3_0_glLightModeli(void *_glfuncs, GLenum pname, GLint param); +void gl3_0_glLightModelfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl3_0_glLightModelf(void *_glfuncs, GLenum pname, GLfloat param); +void gl3_0_glLightiv(void *_glfuncs, GLenum light, GLenum pname, const GLint* params); +void gl3_0_glLighti(void *_glfuncs, GLenum light, GLenum pname, GLint param); +void gl3_0_glLightfv(void *_glfuncs, GLenum light, GLenum pname, const GLfloat* params); +void gl3_0_glLightf(void *_glfuncs, GLenum light, GLenum pname, GLfloat param); +void gl3_0_glFogiv(void *_glfuncs, GLenum pname, const GLint* params); +void gl3_0_glFogi(void *_glfuncs, GLenum pname, GLint param); +void gl3_0_glFogfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl3_0_glFogf(void *_glfuncs, GLenum pname, GLfloat param); +void gl3_0_glColorMaterial(void *_glfuncs, GLenum face, GLenum mode); +void gl3_0_glClipPlane(void *_glfuncs, GLenum plane, const GLdouble* equation); +void gl3_0_glVertex4sv(void *_glfuncs, const GLshort* v); +void gl3_0_glVertex4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w); +void gl3_0_glVertex4iv(void *_glfuncs, const GLint* v); +void gl3_0_glVertex4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w); +void gl3_0_glVertex4fv(void *_glfuncs, const GLfloat* v); +void gl3_0_glVertex4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl3_0_glVertex4dv(void *_glfuncs, const GLdouble* v); +void gl3_0_glVertex4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl3_0_glVertex3sv(void *_glfuncs, const GLshort* v); +void gl3_0_glVertex3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl3_0_glVertex3iv(void *_glfuncs, const GLint* v); +void gl3_0_glVertex3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl3_0_glVertex3fv(void *_glfuncs, const GLfloat* v); +void gl3_0_glVertex3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl3_0_glVertex3dv(void *_glfuncs, const GLdouble* v); +void gl3_0_glVertex3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl3_0_glVertex2sv(void *_glfuncs, const GLshort* v); +void gl3_0_glVertex2s(void *_glfuncs, GLshort x, GLshort y); +void gl3_0_glVertex2iv(void *_glfuncs, const GLint* v); +void gl3_0_glVertex2i(void *_glfuncs, GLint x, GLint y); +void gl3_0_glVertex2fv(void *_glfuncs, const GLfloat* v); +void gl3_0_glVertex2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl3_0_glVertex2dv(void *_glfuncs, const GLdouble* v); +void gl3_0_glVertex2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl3_0_glTexCoord4sv(void *_glfuncs, const GLshort* v); +void gl3_0_glTexCoord4s(void *_glfuncs, GLshort s, GLshort t, GLshort r, GLshort q); +void gl3_0_glTexCoord4iv(void *_glfuncs, const GLint* v); +void gl3_0_glTexCoord4i(void *_glfuncs, GLint s, GLint t, GLint r, GLint q); +void gl3_0_glTexCoord4fv(void *_glfuncs, const GLfloat* v); +void gl3_0_glTexCoord4f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +void gl3_0_glTexCoord4dv(void *_glfuncs, const GLdouble* v); +void gl3_0_glTexCoord4d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +void gl3_0_glTexCoord3sv(void *_glfuncs, const GLshort* v); +void gl3_0_glTexCoord3s(void *_glfuncs, GLshort s, GLshort t, GLshort r); +void gl3_0_glTexCoord3iv(void *_glfuncs, const GLint* v); +void gl3_0_glTexCoord3i(void *_glfuncs, GLint s, GLint t, GLint r); +void gl3_0_glTexCoord3fv(void *_glfuncs, const GLfloat* v); +void gl3_0_glTexCoord3f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r); +void gl3_0_glTexCoord3dv(void *_glfuncs, const GLdouble* v); +void gl3_0_glTexCoord3d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r); +void gl3_0_glTexCoord2sv(void *_glfuncs, const GLshort* v); +void gl3_0_glTexCoord2s(void *_glfuncs, GLshort s, GLshort t); +void gl3_0_glTexCoord2iv(void *_glfuncs, const GLint* v); +void gl3_0_glTexCoord2i(void *_glfuncs, GLint s, GLint t); +void gl3_0_glTexCoord2fv(void *_glfuncs, const GLfloat* v); +void gl3_0_glTexCoord2f(void *_glfuncs, GLfloat s, GLfloat t); +void gl3_0_glTexCoord2dv(void *_glfuncs, const GLdouble* v); +void gl3_0_glTexCoord2d(void *_glfuncs, GLdouble s, GLdouble t); +void gl3_0_glTexCoord1sv(void *_glfuncs, const GLshort* v); +void gl3_0_glTexCoord1s(void *_glfuncs, GLshort s); +void gl3_0_glTexCoord1iv(void *_glfuncs, const GLint* v); +void gl3_0_glTexCoord1i(void *_glfuncs, GLint s); +void gl3_0_glTexCoord1fv(void *_glfuncs, const GLfloat* v); +void gl3_0_glTexCoord1f(void *_glfuncs, GLfloat s); +void gl3_0_glTexCoord1dv(void *_glfuncs, const GLdouble* v); +void gl3_0_glTexCoord1d(void *_glfuncs, GLdouble s); +void gl3_0_glRectsv(void *_glfuncs, const GLshort* v1, const GLshort* v2); +void gl3_0_glRects(void *_glfuncs, GLshort x1, GLshort y1, GLshort x2, GLshort y2); +void gl3_0_glRectiv(void *_glfuncs, const GLint* v1, const GLint* v2); +void gl3_0_glRecti(void *_glfuncs, GLint x1, GLint y1, GLint x2, GLint y2); +void gl3_0_glRectfv(void *_glfuncs, const GLfloat* v1, const GLfloat* v2); +void gl3_0_glRectf(void *_glfuncs, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); +void gl3_0_glRectdv(void *_glfuncs, const GLdouble* v1, const GLdouble* v2); +void gl3_0_glRectd(void *_glfuncs, GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); +void gl3_0_glRasterPos4sv(void *_glfuncs, const GLshort* v); +void gl3_0_glRasterPos4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w); +void gl3_0_glRasterPos4iv(void *_glfuncs, const GLint* v); +void gl3_0_glRasterPos4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w); +void gl3_0_glRasterPos4fv(void *_glfuncs, const GLfloat* v); +void gl3_0_glRasterPos4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl3_0_glRasterPos4dv(void *_glfuncs, const GLdouble* v); +void gl3_0_glRasterPos4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl3_0_glRasterPos3sv(void *_glfuncs, const GLshort* v); +void gl3_0_glRasterPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl3_0_glRasterPos3iv(void *_glfuncs, const GLint* v); +void gl3_0_glRasterPos3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl3_0_glRasterPos3fv(void *_glfuncs, const GLfloat* v); +void gl3_0_glRasterPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl3_0_glRasterPos3dv(void *_glfuncs, const GLdouble* v); +void gl3_0_glRasterPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl3_0_glRasterPos2sv(void *_glfuncs, const GLshort* v); +void gl3_0_glRasterPos2s(void *_glfuncs, GLshort x, GLshort y); +void gl3_0_glRasterPos2iv(void *_glfuncs, const GLint* v); +void gl3_0_glRasterPos2i(void *_glfuncs, GLint x, GLint y); +void gl3_0_glRasterPos2fv(void *_glfuncs, const GLfloat* v); +void gl3_0_glRasterPos2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl3_0_glRasterPos2dv(void *_glfuncs, const GLdouble* v); +void gl3_0_glRasterPos2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl3_0_glNormal3sv(void *_glfuncs, const GLshort* v); +void gl3_0_glNormal3s(void *_glfuncs, GLshort nx, GLshort ny, GLshort nz); +void gl3_0_glNormal3iv(void *_glfuncs, const GLint* v); +void gl3_0_glNormal3i(void *_glfuncs, GLint nx, GLint ny, GLint nz); +void gl3_0_glNormal3fv(void *_glfuncs, const GLfloat* v); +void gl3_0_glNormal3f(void *_glfuncs, GLfloat nx, GLfloat ny, GLfloat nz); +void gl3_0_glNormal3dv(void *_glfuncs, const GLdouble* v); +void gl3_0_glNormal3d(void *_glfuncs, GLdouble nx, GLdouble ny, GLdouble nz); +void gl3_0_glNormal3bv(void *_glfuncs, const GLbyte* v); +void gl3_0_glNormal3b(void *_glfuncs, GLbyte nx, GLbyte ny, GLbyte nz); +void gl3_0_glIndexsv(void *_glfuncs, const GLshort* c); +void gl3_0_glIndexs(void *_glfuncs, GLshort c); +void gl3_0_glIndexiv(void *_glfuncs, const GLint* c); +void gl3_0_glIndexi(void *_glfuncs, GLint c); +void gl3_0_glIndexfv(void *_glfuncs, const GLfloat* c); +void gl3_0_glIndexf(void *_glfuncs, GLfloat c); +void gl3_0_glIndexdv(void *_glfuncs, const GLdouble* c); +void gl3_0_glIndexd(void *_glfuncs, GLdouble c); +void gl3_0_glEnd(void *_glfuncs); +void gl3_0_glEdgeFlagv(void *_glfuncs, const GLboolean* flag); +void gl3_0_glEdgeFlag(void *_glfuncs, GLboolean flag); +void gl3_0_glColor4usv(void *_glfuncs, const GLushort* v); +void gl3_0_glColor4us(void *_glfuncs, GLushort red, GLushort green, GLushort blue, GLushort alpha); +void gl3_0_glColor4uiv(void *_glfuncs, const GLuint* v); +void gl3_0_glColor4ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue, GLuint alpha); +void gl3_0_glColor4ubv(void *_glfuncs, const GLubyte* v); +void gl3_0_glColor4ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); +void gl3_0_glColor4sv(void *_glfuncs, const GLshort* v); +void gl3_0_glColor4s(void *_glfuncs, GLshort red, GLshort green, GLshort blue, GLshort alpha); +void gl3_0_glColor4iv(void *_glfuncs, const GLint* v); +void gl3_0_glColor4i(void *_glfuncs, GLint red, GLint green, GLint blue, GLint alpha); +void gl3_0_glColor4fv(void *_glfuncs, const GLfloat* v); +void gl3_0_glColor4f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl3_0_glColor4dv(void *_glfuncs, const GLdouble* v); +void gl3_0_glColor4d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); +void gl3_0_glColor4bv(void *_glfuncs, const GLbyte* v); +void gl3_0_glColor4b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); +void gl3_0_glColor3usv(void *_glfuncs, const GLushort* v); +void gl3_0_glColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue); +void gl3_0_glColor3uiv(void *_glfuncs, const GLuint* v); +void gl3_0_glColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue); +void gl3_0_glColor3ubv(void *_glfuncs, const GLubyte* v); +void gl3_0_glColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue); +void gl3_0_glColor3sv(void *_glfuncs, const GLshort* v); +void gl3_0_glColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue); +void gl3_0_glColor3iv(void *_glfuncs, const GLint* v); +void gl3_0_glColor3i(void *_glfuncs, GLint red, GLint green, GLint blue); +void gl3_0_glColor3fv(void *_glfuncs, const GLfloat* v); +void gl3_0_glColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue); +void gl3_0_glColor3dv(void *_glfuncs, const GLdouble* v); +void gl3_0_glColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue); +void gl3_0_glColor3bv(void *_glfuncs, const GLbyte* v); +void gl3_0_glColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue); +void gl3_0_glBitmap(void *_glfuncs, GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap); +void gl3_0_glBegin(void *_glfuncs, GLenum mode); +void gl3_0_glListBase(void *_glfuncs, GLuint base); +GLuint gl3_0_glGenLists(void *_glfuncs, GLsizei range_); +void gl3_0_glDeleteLists(void *_glfuncs, GLuint list, GLsizei range_); +void gl3_0_glCallLists(void *_glfuncs, GLsizei n, GLenum gltype, const GLvoid* lists); +void gl3_0_glCallList(void *_glfuncs, GLuint list); +void gl3_0_glEndList(void *_glfuncs); +void gl3_0_glNewList(void *_glfuncs, GLuint list, GLenum mode); +void gl3_0_glPushClientAttrib(void *_glfuncs, GLbitfield mask); +void gl3_0_glPopClientAttrib(void *_glfuncs); +void gl3_0_glPrioritizeTextures(void *_glfuncs, GLsizei n, const GLuint* textures, const GLfloat* priorities); +GLboolean gl3_0_glAreTexturesResident(void *_glfuncs, GLsizei n, const GLuint* textures, GLboolean* residences); +void gl3_0_glVertexPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl3_0_glTexCoordPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl3_0_glNormalPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl3_0_glInterleavedArrays(void *_glfuncs, GLenum format, GLsizei stride, const GLvoid* pointer); +void gl3_0_glIndexPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl3_0_glEnableClientState(void *_glfuncs, GLenum array); +void gl3_0_glEdgeFlagPointer(void *_glfuncs, GLsizei stride, const GLvoid* pointer); +void gl3_0_glDisableClientState(void *_glfuncs, GLenum array); +void gl3_0_glColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl3_0_glArrayElement(void *_glfuncs, GLint i); +void gl3_0_glResetMinmax(void *_glfuncs, GLenum target); +void gl3_0_glResetHistogram(void *_glfuncs, GLenum target); +void gl3_0_glMinmax(void *_glfuncs, GLenum target, GLenum internalFormat, GLboolean sink); +void gl3_0_glHistogram(void *_glfuncs, GLenum target, GLsizei width, GLenum internalFormat, GLboolean sink); +void gl3_0_glGetMinmaxParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_0_glGetMinmaxParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl3_0_glGetMinmax(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values); +void gl3_0_glGetHistogramParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_0_glGetHistogramParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl3_0_glGetHistogram(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values); +void gl3_0_glSeparableFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* row, const GLvoid* column); +void gl3_0_glGetSeparableFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* row, GLvoid* column, GLvoid* span); +void gl3_0_glGetConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_0_glGetConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl3_0_glGetConvolutionFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* image); +void gl3_0_glCopyConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height); +void gl3_0_glCopyConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width); +void gl3_0_glConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl3_0_glConvolutionParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint params); +void gl3_0_glConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl3_0_glConvolutionParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat params); +void gl3_0_glConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* image); +void gl3_0_glConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* image); +void gl3_0_glCopyColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); +void gl3_0_glColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum gltype, const GLvoid* data); +void gl3_0_glGetColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_0_glGetColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl3_0_glGetColorTable(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* table); +void gl3_0_glCopyColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width); +void gl3_0_glColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl3_0_glColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl3_0_glColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* table); +void gl3_0_glMultTransposeMatrixd(void *_glfuncs, const GLdouble* m); +void gl3_0_glMultTransposeMatrixf(void *_glfuncs, const GLfloat* m); +void gl3_0_glLoadTransposeMatrixd(void *_glfuncs, const GLdouble* m); +void gl3_0_glLoadTransposeMatrixf(void *_glfuncs, const GLfloat* m); +void gl3_0_glMultiTexCoord4sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl3_0_glMultiTexCoord4s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); +void gl3_0_glMultiTexCoord4iv(void *_glfuncs, GLenum target, const GLint* v); +void gl3_0_glMultiTexCoord4i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r, GLint q); +void gl3_0_glMultiTexCoord4fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl3_0_glMultiTexCoord4f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +void gl3_0_glMultiTexCoord4dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl3_0_glMultiTexCoord4d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +void gl3_0_glMultiTexCoord3sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl3_0_glMultiTexCoord3s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r); +void gl3_0_glMultiTexCoord3iv(void *_glfuncs, GLenum target, const GLint* v); +void gl3_0_glMultiTexCoord3i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r); +void gl3_0_glMultiTexCoord3fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl3_0_glMultiTexCoord3f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r); +void gl3_0_glMultiTexCoord3dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl3_0_glMultiTexCoord3d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r); +void gl3_0_glMultiTexCoord2sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl3_0_glMultiTexCoord2s(void *_glfuncs, GLenum target, GLshort s, GLshort t); +void gl3_0_glMultiTexCoord2iv(void *_glfuncs, GLenum target, const GLint* v); +void gl3_0_glMultiTexCoord2i(void *_glfuncs, GLenum target, GLint s, GLint t); +void gl3_0_glMultiTexCoord2fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl3_0_glMultiTexCoord2f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t); +void gl3_0_glMultiTexCoord2dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl3_0_glMultiTexCoord2d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t); +void gl3_0_glMultiTexCoord1sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl3_0_glMultiTexCoord1s(void *_glfuncs, GLenum target, GLshort s); +void gl3_0_glMultiTexCoord1iv(void *_glfuncs, GLenum target, const GLint* v); +void gl3_0_glMultiTexCoord1i(void *_glfuncs, GLenum target, GLint s); +void gl3_0_glMultiTexCoord1fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl3_0_glMultiTexCoord1f(void *_glfuncs, GLenum target, GLfloat s); +void gl3_0_glMultiTexCoord1dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl3_0_glMultiTexCoord1d(void *_glfuncs, GLenum target, GLdouble s); +void gl3_0_glClientActiveTexture(void *_glfuncs, GLenum texture); +void gl3_0_glWindowPos3sv(void *_glfuncs, const GLshort* v); +void gl3_0_glWindowPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl3_0_glWindowPos3iv(void *_glfuncs, const GLint* v); +void gl3_0_glWindowPos3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl3_0_glWindowPos3fv(void *_glfuncs, const GLfloat* v); +void gl3_0_glWindowPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl3_0_glWindowPos3dv(void *_glfuncs, const GLdouble* v); +void gl3_0_glWindowPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl3_0_glWindowPos2sv(void *_glfuncs, const GLshort* v); +void gl3_0_glWindowPos2s(void *_glfuncs, GLshort x, GLshort y); +void gl3_0_glWindowPos2iv(void *_glfuncs, const GLint* v); +void gl3_0_glWindowPos2i(void *_glfuncs, GLint x, GLint y); +void gl3_0_glWindowPos2fv(void *_glfuncs, const GLfloat* v); +void gl3_0_glWindowPos2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl3_0_glWindowPos2dv(void *_glfuncs, const GLdouble* v); +void gl3_0_glWindowPos2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl3_0_glSecondaryColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl3_0_glSecondaryColor3usv(void *_glfuncs, const GLushort* v); +void gl3_0_glSecondaryColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue); +void gl3_0_glSecondaryColor3uiv(void *_glfuncs, const GLuint* v); +void gl3_0_glSecondaryColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue); +void gl3_0_glSecondaryColor3ubv(void *_glfuncs, const GLubyte* v); +void gl3_0_glSecondaryColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue); +void gl3_0_glSecondaryColor3sv(void *_glfuncs, const GLshort* v); +void gl3_0_glSecondaryColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue); +void gl3_0_glSecondaryColor3iv(void *_glfuncs, const GLint* v); +void gl3_0_glSecondaryColor3i(void *_glfuncs, GLint red, GLint green, GLint blue); +void gl3_0_glSecondaryColor3fv(void *_glfuncs, const GLfloat* v); +void gl3_0_glSecondaryColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue); +void gl3_0_glSecondaryColor3dv(void *_glfuncs, const GLdouble* v); +void gl3_0_glSecondaryColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue); +void gl3_0_glSecondaryColor3bv(void *_glfuncs, const GLbyte* v); +void gl3_0_glSecondaryColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue); +void gl3_0_glFogCoordPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl3_0_glFogCoorddv(void *_glfuncs, const GLdouble* coord); +void gl3_0_glFogCoordd(void *_glfuncs, GLdouble coord); +void gl3_0_glFogCoordfv(void *_glfuncs, const GLfloat* coord); +void gl3_0_glFogCoordf(void *_glfuncs, GLfloat coord); +void gl3_0_glVertexAttrib4usv(void *_glfuncs, GLuint index, const GLushort* v); +void gl3_0_glVertexAttrib4uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl3_0_glVertexAttrib4ubv(void *_glfuncs, GLuint index, const GLubyte* v); +void gl3_0_glVertexAttrib4sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl3_0_glVertexAttrib4s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +void gl3_0_glVertexAttrib4iv(void *_glfuncs, GLuint index, const GLint* v); +void gl3_0_glVertexAttrib4fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl3_0_glVertexAttrib4f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl3_0_glVertexAttrib4dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl3_0_glVertexAttrib4d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl3_0_glVertexAttrib4bv(void *_glfuncs, GLuint index, const GLbyte* v); +void gl3_0_glVertexAttrib4Nusv(void *_glfuncs, GLuint index, const GLushort* v); +void gl3_0_glVertexAttrib4Nuiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl3_0_glVertexAttrib4Nubv(void *_glfuncs, GLuint index, const GLubyte* v); +void gl3_0_glVertexAttrib4Nub(void *_glfuncs, GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +void gl3_0_glVertexAttrib4Nsv(void *_glfuncs, GLuint index, const GLshort* v); +void gl3_0_glVertexAttrib4Niv(void *_glfuncs, GLuint index, const GLint* v); +void gl3_0_glVertexAttrib4Nbv(void *_glfuncs, GLuint index, const GLbyte* v); +void gl3_0_glVertexAttrib3sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl3_0_glVertexAttrib3s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z); +void gl3_0_glVertexAttrib3fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl3_0_glVertexAttrib3f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z); +void gl3_0_glVertexAttrib3dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl3_0_glVertexAttrib3d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z); +void gl3_0_glVertexAttrib2sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl3_0_glVertexAttrib2s(void *_glfuncs, GLuint index, GLshort x, GLshort y); +void gl3_0_glVertexAttrib2fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl3_0_glVertexAttrib2f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y); +void gl3_0_glVertexAttrib2dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl3_0_glVertexAttrib2d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y); +void gl3_0_glVertexAttrib1sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl3_0_glVertexAttrib1s(void *_glfuncs, GLuint index, GLshort x); +void gl3_0_glVertexAttrib1fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl3_0_glVertexAttrib1f(void *_glfuncs, GLuint index, GLfloat x); +void gl3_0_glVertexAttrib1dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl3_0_glVertexAttrib1d(void *_glfuncs, GLuint index, GLdouble x); +void gl3_0_glVertexAttribI4usv(void *_glfuncs, GLuint index, const GLushort* v); +void gl3_0_glVertexAttribI4ubv(void *_glfuncs, GLuint index, const GLubyte* v); +void gl3_0_glVertexAttribI4sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl3_0_glVertexAttribI4bv(void *_glfuncs, GLuint index, const GLbyte* v); +void gl3_0_glVertexAttribI4uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl3_0_glVertexAttribI3uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl3_0_glVertexAttribI2uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl3_0_glVertexAttribI1uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl3_0_glVertexAttribI4iv(void *_glfuncs, GLuint index, const GLint* v); +void gl3_0_glVertexAttribI3iv(void *_glfuncs, GLuint index, const GLint* v); +void gl3_0_glVertexAttribI2iv(void *_glfuncs, GLuint index, const GLint* v); +void gl3_0_glVertexAttribI1iv(void *_glfuncs, GLuint index, const GLint* v); +void gl3_0_glVertexAttribI4ui(void *_glfuncs, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +void gl3_0_glVertexAttribI3ui(void *_glfuncs, GLuint index, GLuint x, GLuint y, GLuint z); +void gl3_0_glVertexAttribI2ui(void *_glfuncs, GLuint index, GLuint x, GLuint y); +void gl3_0_glVertexAttribI1ui(void *_glfuncs, GLuint index, GLuint x); +void gl3_0_glVertexAttribI4i(void *_glfuncs, GLuint index, GLint x, GLint y, GLint z, GLint w); +void gl3_0_glVertexAttribI3i(void *_glfuncs, GLuint index, GLint x, GLint y, GLint z); +void gl3_0_glVertexAttribI2i(void *_glfuncs, GLuint index, GLint x, GLint y); +void gl3_0_glVertexAttribI1i(void *_glfuncs, GLuint index, GLint x); + + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/gl/3.0/gl.go b/gl/3.0/gl.go new file mode 100644 index 00000000..a8509aec --- /dev/null +++ b/gl/3.0/gl.go @@ -0,0 +1,7663 @@ +// ** file automatically generated by glgen -- do not edit manually ** + +package GL + +// #cgo CXXFLAGS: -std=c++0x -pedantic-errors -Wall -fno-strict-aliasing +// #cgo LDFLAGS: -lstdc++ +// #cgo pkg-config: Qt5Core Qt5OpenGL +// +// #include "funcs.h" +// +// void free(void*); +// +import "C" + +import ( + "fmt" + "reflect" + "unsafe" + + "gopkg.in/qml.v1/gl/glbase" +) + +// API returns a value that offers methods matching the OpenGL version 3.0 API. +// +// The returned API must not be used after the provided OpenGL context becomes invalid. +func API(context glbase.Contexter) *GL { + gl := &GL{} + gl.funcs = C.gl3_0_funcs() + if gl.funcs == nil { + panic(fmt.Errorf("OpenGL version 3.0 is not available")) + } + return gl +} + +// GL implements the OpenGL version 3.0 API. Values of this +// type must be created via the API function, and it must not be used after +// the associated OpenGL context becomes invalid. +type GL struct { + funcs unsafe.Pointer +} + +const ( + FALSE = 0 + TRUE = 1 + NONE = 0 + + BYTE = 0x1400 + UNSIGNED_BYTE = 0x1401 + SHORT = 0x1402 + UNSIGNED_SHORT = 0x1403 + INT = 0x1404 + UNSIGNED_INT = 0x1405 + FLOAT = 0x1406 + N2_BYTES = 0x1407 + N3_BYTES = 0x1408 + N4_BYTES = 0x1409 + DOUBLE = 0x140A + HALF_FLOAT = 0x140B + + ACCUM = 0x0100 + LOAD = 0x0101 + RETURN = 0x0102 + MULT = 0x0103 + ADD = 0x0104 + + ACCUM_BUFFER_BIT = 0x00000200 + ALL_ATTRIB_BITS = 0xFFFFFFFF + COLOR_BUFFER_BIT = 0x00004000 + CURRENT_BIT = 0x00000001 + DEPTH_BUFFER_BIT = 0x00000100 + ENABLE_BIT = 0x00002000 + EVAL_BIT = 0x00010000 + FOG_BIT = 0x00000080 + HINT_BIT = 0x00008000 + LIGHTING_BIT = 0x00000040 + LINE_BIT = 0x00000004 + LIST_BIT = 0x00020000 + MULTISAMPLE_BIT = 0x20000000 + PIXEL_MODE_BIT = 0x00000020 + POINT_BIT = 0x00000002 + POLYGON_BIT = 0x00000008 + POLYGON_STIPPLE_BIT = 0x00000010 + SCISSOR_BIT = 0x00080000 + STENCIL_BUFFER_BIT = 0x00000400 + TEXTURE_BIT = 0x00040000 + TRANSFORM_BIT = 0x00001000 + VIEWPORT_BIT = 0x00000800 + + ALWAYS = 0x0207 + EQUAL = 0x0202 + GEQUAL = 0x0206 + GREATER = 0x0204 + LEQUAL = 0x0203 + LESS = 0x0201 + NEVER = 0x0200 + NOTEQUAL = 0x0205 + + LOGIC_OP = 0x0BF1 + + DST_ALPHA = 0x0304 + ONE = 1 + ONE_MINUS_DST_ALPHA = 0x0305 + ONE_MINUS_SRC_ALPHA = 0x0303 + ONE_MINUS_SRC_COLOR = 0x0301 + SRC_ALPHA = 0x0302 + SRC_COLOR = 0x0300 + ZERO = 0 + + DST_COLOR = 0x0306 + ONE_MINUS_DST_COLOR = 0x0307 + SRC_ALPHA_SATURATE = 0x0308 + + CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF + CLIENT_PIXEL_STORE_BIT = 0x00000001 + CLIENT_VERTEX_ARRAY_BIT = 0x00000002 + + CLIP_DISTANCE0 = 0x3000 + CLIP_DISTANCE1 = 0x3001 + CLIP_DISTANCE2 = 0x3002 + CLIP_DISTANCE3 = 0x3003 + CLIP_DISTANCE4 = 0x3004 + CLIP_DISTANCE5 = 0x3005 + CLIP_DISTANCE6 = 0x3006 + CLIP_DISTANCE7 = 0x3007 + CLIP_PLANE0 = 0x3000 + CLIP_PLANE1 = 0x3001 + CLIP_PLANE2 = 0x3002 + CLIP_PLANE3 = 0x3003 + CLIP_PLANE4 = 0x3004 + CLIP_PLANE5 = 0x3005 + + BACK = 0x0405 + FRONT = 0x0404 + FRONT_AND_BACK = 0x0408 + + AMBIENT = 0x1200 + AMBIENT_AND_DIFFUSE = 0x1602 + DIFFUSE = 0x1201 + EMISSION = 0x1600 + SPECULAR = 0x1202 + + CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x00000001 + + AUX0 = 0x0409 + AUX1 = 0x040A + AUX2 = 0x040B + AUX3 = 0x040C + BACK_LEFT = 0x0402 + BACK_RIGHT = 0x0403 + FRONT_LEFT = 0x0400 + FRONT_RIGHT = 0x0401 + LEFT = 0x0406 + RIGHT = 0x0407 + + ALPHA_TEST = 0x0BC0 + AUTO_NORMAL = 0x0D80 + BLEND = 0x0BE2 + COLOR_ARRAY = 0x8076 + COLOR_LOGIC_OP = 0x0BF2 + COLOR_MATERIAL = 0x0B57 + CULL_FACE = 0x0B44 + DEPTH_TEST = 0x0B71 + DITHER = 0x0BD0 + EDGE_FLAG_ARRAY = 0x8079 + FOG = 0x0B60 + INDEX_ARRAY = 0x8077 + INDEX_LOGIC_OP = 0x0BF1 + LIGHT0 = 0x4000 + LIGHT1 = 0x4001 + LIGHT2 = 0x4002 + LIGHT3 = 0x4003 + LIGHT4 = 0x4004 + LIGHT5 = 0x4005 + LIGHT6 = 0x4006 + LIGHT7 = 0x4007 + LIGHTING = 0x0B50 + LINE_SMOOTH = 0x0B20 + LINE_STIPPLE = 0x0B24 + MAP1_COLOR_4 = 0x0D90 + MAP1_INDEX = 0x0D91 + MAP1_NORMAL = 0x0D92 + MAP1_TEXTURE_COORD_1 = 0x0D93 + MAP1_TEXTURE_COORD_2 = 0x0D94 + MAP1_TEXTURE_COORD_3 = 0x0D95 + MAP1_TEXTURE_COORD_4 = 0x0D96 + MAP1_VERTEX_3 = 0x0D97 + MAP1_VERTEX_4 = 0x0D98 + MAP2_COLOR_4 = 0x0DB0 + MAP2_INDEX = 0x0DB1 + MAP2_NORMAL = 0x0DB2 + MAP2_TEXTURE_COORD_1 = 0x0DB3 + MAP2_TEXTURE_COORD_2 = 0x0DB4 + MAP2_TEXTURE_COORD_3 = 0x0DB5 + MAP2_TEXTURE_COORD_4 = 0x0DB6 + MAP2_VERTEX_3 = 0x0DB7 + MAP2_VERTEX_4 = 0x0DB8 + NORMALIZE = 0x0BA1 + NORMAL_ARRAY = 0x8075 + POINT_SMOOTH = 0x0B10 + POLYGON_OFFSET_FILL = 0x8037 + POLYGON_OFFSET_LINE = 0x2A02 + POLYGON_OFFSET_POINT = 0x2A01 + POLYGON_SMOOTH = 0x0B41 + POLYGON_STIPPLE = 0x0B42 + SCISSOR_TEST = 0x0C11 + STENCIL_TEST = 0x0B90 + TEXTURE_1D = 0x0DE0 + TEXTURE_2D = 0x0DE1 + TEXTURE_COORD_ARRAY = 0x8078 + TEXTURE_GEN_Q = 0x0C63 + TEXTURE_GEN_R = 0x0C62 + TEXTURE_GEN_S = 0x0C60 + TEXTURE_GEN_T = 0x0C61 + VERTEX_ARRAY = 0x8074 + + INVALID_ENUM = 0x0500 + INVALID_FRAMEBUFFER_OPERATION = 0x0506 + INVALID_OPERATION = 0x0502 + INVALID_VALUE = 0x0501 + NO_ERROR = 0 + OUT_OF_MEMORY = 0x0505 + STACK_OVERFLOW = 0x0503 + STACK_UNDERFLOW = 0x0504 + + N2D = 0x0600 + N3D = 0x0601 + N3D_COLOR = 0x0602 + N3D_COLOR_TEXTURE = 0x0603 + N4D_COLOR_TEXTURE = 0x0604 + + BITMAP_TOKEN = 0x0704 + COPY_PIXEL_TOKEN = 0x0706 + DRAW_PIXEL_TOKEN = 0x0705 + LINE_RESET_TOKEN = 0x0707 + LINE_TOKEN = 0x0702 + PASS_THROUGH_TOKEN = 0x0700 + POINT_TOKEN = 0x0701 + POLYGON_TOKEN = 0x0703 + + EXP = 0x0800 + EXP2 = 0x0801 + LINEAR = 0x2601 + + FOG_COLOR = 0x0B66 + FOG_DENSITY = 0x0B62 + FOG_END = 0x0B64 + FOG_INDEX = 0x0B61 + FOG_MODE = 0x0B65 + FOG_START = 0x0B63 + + CCW = 0x0901 + CW = 0x0900 + + COEFF = 0x0A00 + DOMAIN = 0x0A02 + ORDER = 0x0A01 + + PIXEL_MAP_A_TO_A = 0x0C79 + PIXEL_MAP_B_TO_B = 0x0C78 + PIXEL_MAP_G_TO_G = 0x0C77 + PIXEL_MAP_I_TO_A = 0x0C75 + PIXEL_MAP_I_TO_B = 0x0C74 + PIXEL_MAP_I_TO_G = 0x0C73 + PIXEL_MAP_I_TO_I = 0x0C70 + PIXEL_MAP_I_TO_R = 0x0C72 + PIXEL_MAP_R_TO_R = 0x0C76 + PIXEL_MAP_S_TO_S = 0x0C71 + + ACCUM_ALPHA_BITS = 0x0D5B + ACCUM_BLUE_BITS = 0x0D5A + ACCUM_CLEAR_VALUE = 0x0B80 + ACCUM_GREEN_BITS = 0x0D59 + ACCUM_RED_BITS = 0x0D58 + ALIASED_LINE_WIDTH_RANGE = 0x846E + ALIASED_POINT_SIZE_RANGE = 0x846D + ALPHA_BIAS = 0x0D1D + ALPHA_BITS = 0x0D55 + ALPHA_SCALE = 0x0D1C + ALPHA_TEST_FUNC = 0x0BC1 + ALPHA_TEST_REF = 0x0BC2 + ATTRIB_STACK_DEPTH = 0x0BB0 + AUX_BUFFERS = 0x0C00 + BLEND_DST = 0x0BE0 + BLEND_SRC = 0x0BE1 + BLUE_BIAS = 0x0D1B + BLUE_BITS = 0x0D54 + BLUE_SCALE = 0x0D1A + CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1 + COLOR_ARRAY_SIZE = 0x8081 + COLOR_ARRAY_STRIDE = 0x8083 + COLOR_ARRAY_TYPE = 0x8082 + COLOR_CLEAR_VALUE = 0x0C22 + COLOR_MATERIAL_FACE = 0x0B55 + COLOR_MATERIAL_PARAMETER = 0x0B56 + COLOR_WRITEMASK = 0x0C23 + CULL_FACE_MODE = 0x0B45 + CURRENT_COLOR = 0x0B00 + CURRENT_INDEX = 0x0B01 + CURRENT_NORMAL = 0x0B02 + CURRENT_RASTER_COLOR = 0x0B04 + CURRENT_RASTER_DISTANCE = 0x0B09 + CURRENT_RASTER_INDEX = 0x0B05 + CURRENT_RASTER_POSITION = 0x0B07 + CURRENT_RASTER_POSITION_VALID = 0x0B08 + CURRENT_RASTER_TEXTURE_COORDS = 0x0B06 + CURRENT_TEXTURE_COORDS = 0x0B03 + DEPTH_BIAS = 0x0D1F + DEPTH_BITS = 0x0D56 + DEPTH_CLEAR_VALUE = 0x0B73 + DEPTH_FUNC = 0x0B74 + DEPTH_RANGE = 0x0B70 + DEPTH_SCALE = 0x0D1E + DEPTH_WRITEMASK = 0x0B72 + DOUBLEBUFFER = 0x0C32 + DRAW_BUFFER = 0x0C01 + EDGE_FLAG = 0x0B43 + EDGE_FLAG_ARRAY_STRIDE = 0x808C + FEEDBACK_BUFFER_SIZE = 0x0DF1 + FEEDBACK_BUFFER_TYPE = 0x0DF2 + FOG_HINT = 0x0C54 + FRONT_FACE = 0x0B46 + GREEN_BIAS = 0x0D19 + GREEN_BITS = 0x0D53 + GREEN_SCALE = 0x0D18 + INDEX_ARRAY_STRIDE = 0x8086 + INDEX_ARRAY_TYPE = 0x8085 + INDEX_BITS = 0x0D51 + INDEX_CLEAR_VALUE = 0x0C20 + INDEX_MODE = 0x0C30 + INDEX_OFFSET = 0x0D13 + INDEX_SHIFT = 0x0D12 + INDEX_WRITEMASK = 0x0C21 + LIGHT_MODEL_AMBIENT = 0x0B53 + LIGHT_MODEL_COLOR_CONTROL = 0x81F8 + LIGHT_MODEL_LOCAL_VIEWER = 0x0B51 + LIGHT_MODEL_TWO_SIDE = 0x0B52 + LINE_SMOOTH_HINT = 0x0C52 + LINE_STIPPLE_PATTERN = 0x0B25 + LINE_STIPPLE_REPEAT = 0x0B26 + LINE_WIDTH = 0x0B21 + LINE_WIDTH_GRANULARITY = 0x0B23 + LINE_WIDTH_RANGE = 0x0B22 + LIST_BASE = 0x0B32 + LIST_INDEX = 0x0B33 + LIST_MODE = 0x0B30 + LOGIC_OP_MODE = 0x0BF0 + MAP1_GRID_DOMAIN = 0x0DD0 + MAP1_GRID_SEGMENTS = 0x0DD1 + MAP2_GRID_DOMAIN = 0x0DD2 + MAP2_GRID_SEGMENTS = 0x0DD3 + MAP_COLOR = 0x0D10 + MAP_STENCIL = 0x0D11 + MATRIX_MODE = 0x0BA0 + MAX_ATTRIB_STACK_DEPTH = 0x0D35 + MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B + MAX_CLIP_DISTANCES = 0x0D32 + MAX_CLIP_PLANES = 0x0D32 + MAX_EVAL_ORDER = 0x0D30 + MAX_LIGHTS = 0x0D31 + MAX_LIST_NESTING = 0x0B31 + MAX_MODELVIEW_STACK_DEPTH = 0x0D36 + MAX_NAME_STACK_DEPTH = 0x0D37 + MAX_PIXEL_MAP_TABLE = 0x0D34 + MAX_PROJECTION_STACK_DEPTH = 0x0D38 + MAX_TEXTURE_SIZE = 0x0D33 + MAX_TEXTURE_STACK_DEPTH = 0x0D39 + MAX_VIEWPORT_DIMS = 0x0D3A + MODELVIEW_MATRIX = 0x0BA6 + MODELVIEW_STACK_DEPTH = 0x0BA3 + NAME_STACK_DEPTH = 0x0D70 + NORMAL_ARRAY_STRIDE = 0x807F + NORMAL_ARRAY_TYPE = 0x807E + PACK_ALIGNMENT = 0x0D05 + PACK_LSB_FIRST = 0x0D01 + PACK_ROW_LENGTH = 0x0D02 + PACK_SKIP_PIXELS = 0x0D04 + PACK_SKIP_ROWS = 0x0D03 + PACK_SWAP_BYTES = 0x0D00 + PERSPECTIVE_CORRECTION_HINT = 0x0C50 + PIXEL_MAP_A_TO_A_SIZE = 0x0CB9 + PIXEL_MAP_B_TO_B_SIZE = 0x0CB8 + PIXEL_MAP_G_TO_G_SIZE = 0x0CB7 + PIXEL_MAP_I_TO_A_SIZE = 0x0CB5 + PIXEL_MAP_I_TO_B_SIZE = 0x0CB4 + PIXEL_MAP_I_TO_G_SIZE = 0x0CB3 + PIXEL_MAP_I_TO_I_SIZE = 0x0CB0 + PIXEL_MAP_I_TO_R_SIZE = 0x0CB2 + PIXEL_MAP_R_TO_R_SIZE = 0x0CB6 + PIXEL_MAP_S_TO_S_SIZE = 0x0CB1 + POINT_SIZE = 0x0B11 + POINT_SIZE_GRANULARITY = 0x0B13 + POINT_SIZE_RANGE = 0x0B12 + POINT_SMOOTH_HINT = 0x0C51 + POLYGON_MODE = 0x0B40 + POLYGON_OFFSET_FACTOR = 0x8038 + POLYGON_OFFSET_UNITS = 0x2A00 + POLYGON_SMOOTH_HINT = 0x0C53 + PROJECTION_MATRIX = 0x0BA7 + PROJECTION_STACK_DEPTH = 0x0BA4 + READ_BUFFER = 0x0C02 + RED_BIAS = 0x0D15 + RED_BITS = 0x0D52 + RED_SCALE = 0x0D14 + RENDER_MODE = 0x0C40 + RGBA_MODE = 0x0C31 + SCISSOR_BOX = 0x0C10 + SELECTION_BUFFER_SIZE = 0x0DF4 + SHADE_MODEL = 0x0B54 + SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23 + SMOOTH_LINE_WIDTH_RANGE = 0x0B22 + SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13 + SMOOTH_POINT_SIZE_RANGE = 0x0B12 + STENCIL_BITS = 0x0D57 + STENCIL_CLEAR_VALUE = 0x0B91 + STENCIL_FAIL = 0x0B94 + STENCIL_FUNC = 0x0B92 + STENCIL_PASS_DEPTH_FAIL = 0x0B95 + STENCIL_PASS_DEPTH_PASS = 0x0B96 + STENCIL_REF = 0x0B97 + STENCIL_VALUE_MASK = 0x0B93 + STENCIL_WRITEMASK = 0x0B98 + STEREO = 0x0C33 + SUBPIXEL_BITS = 0x0D50 + TEXTURE_BINDING_1D = 0x8068 + TEXTURE_BINDING_2D = 0x8069 + TEXTURE_BINDING_3D = 0x806A + TEXTURE_COORD_ARRAY_SIZE = 0x8088 + TEXTURE_COORD_ARRAY_STRIDE = 0x808A + TEXTURE_COORD_ARRAY_TYPE = 0x8089 + TEXTURE_MATRIX = 0x0BA8 + TEXTURE_STACK_DEPTH = 0x0BA5 + UNPACK_ALIGNMENT = 0x0CF5 + UNPACK_LSB_FIRST = 0x0CF1 + UNPACK_ROW_LENGTH = 0x0CF2 + UNPACK_SKIP_PIXELS = 0x0CF4 + UNPACK_SKIP_ROWS = 0x0CF3 + UNPACK_SWAP_BYTES = 0x0CF0 + VERTEX_ARRAY_SIZE = 0x807A + VERTEX_ARRAY_STRIDE = 0x807C + VERTEX_ARRAY_TYPE = 0x807B + VIEWPORT = 0x0BA2 + ZOOM_X = 0x0D16 + ZOOM_Y = 0x0D17 + + COLOR_ARRAY_POINTER = 0x8090 + EDGE_FLAG_ARRAY_POINTER = 0x8093 + FEEDBACK_BUFFER_POINTER = 0x0DF0 + INDEX_ARRAY_POINTER = 0x8091 + NORMAL_ARRAY_POINTER = 0x808F + SELECTION_BUFFER_POINTER = 0x0DF3 + TEXTURE_COORD_ARRAY_POINTER = 0x8092 + VERTEX_ARRAY_POINTER = 0x808E + + TEXTURE_ALPHA_SIZE = 0x805F + TEXTURE_BLUE_SIZE = 0x805E + TEXTURE_BORDER = 0x1005 + TEXTURE_BORDER_COLOR = 0x1004 + TEXTURE_COMPONENTS = 0x1003 + TEXTURE_GREEN_SIZE = 0x805D + TEXTURE_HEIGHT = 0x1001 + TEXTURE_INTENSITY_SIZE = 0x8061 + TEXTURE_INTERNAL_FORMAT = 0x1003 + TEXTURE_LUMINANCE_SIZE = 0x8060 + TEXTURE_MAG_FILTER = 0x2800 + TEXTURE_MIN_FILTER = 0x2801 + TEXTURE_PRIORITY = 0x8066 + TEXTURE_RED_SIZE = 0x805C + TEXTURE_RESIDENT = 0x8067 + TEXTURE_WIDTH = 0x1000 + TEXTURE_WRAP_S = 0x2802 + TEXTURE_WRAP_T = 0x2803 + + DONT_CARE = 0x1100 + FASTEST = 0x1101 + NICEST = 0x1102 + + FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B + GENERATE_MIPMAP_HINT = 0x8192 + TEXTURE_COMPRESSION_HINT = 0x84EF + + C3F_V3F = 0x2A24 + C4F_N3F_V3F = 0x2A26 + C4UB_V2F = 0x2A22 + C4UB_V3F = 0x2A23 + N3F_V3F = 0x2A25 + T2F_C3F_V3F = 0x2A2A + T2F_C4F_N3F_V3F = 0x2A2C + T2F_C4UB_V3F = 0x2A29 + T2F_N3F_V3F = 0x2A2B + T2F_V3F = 0x2A27 + T4F_C4F_N3F_V4F = 0x2A2D + T4F_V4F = 0x2A28 + V2F = 0x2A20 + V3F = 0x2A21 + + MODULATE = 0x2100 + REPLACE = 0x1E01 + + SEPARATE_SPECULAR_COLOR = 0x81FA + SINGLE_COLOR = 0x81F9 + + CONSTANT_ATTENUATION = 0x1207 + LINEAR_ATTENUATION = 0x1208 + POSITION = 0x1203 + QUADRATIC_ATTENUATION = 0x1209 + SPOT_CUTOFF = 0x1206 + SPOT_DIRECTION = 0x1204 + SPOT_EXPONENT = 0x1205 + + COMPILE = 0x1300 + COMPILE_AND_EXECUTE = 0x1301 + + AND = 0x1501 + AND_INVERTED = 0x1504 + AND_REVERSE = 0x1502 + CLEAR = 0x1500 + COPY = 0x1503 + COPY_INVERTED = 0x150C + EQUIV = 0x1509 + INVERT = 0x150A + NAND = 0x150E + NOOP = 0x1505 + NOR = 0x1508 + OR = 0x1507 + OR_INVERTED = 0x150D + OR_REVERSE = 0x150B + SET = 0x150F + XOR = 0x1506 + + MAP_FLUSH_EXPLICIT_BIT = 0x0010 + MAP_INVALIDATE_BUFFER_BIT = 0x0008 + MAP_INVALIDATE_RANGE_BIT = 0x0004 + MAP_READ_BIT = 0x0001 + MAP_UNSYNCHRONIZED_BIT = 0x0020 + MAP_WRITE_BIT = 0x0002 + + COLOR_INDEXES = 0x1603 + SHININESS = 0x1601 + + MODELVIEW = 0x1700 + PROJECTION = 0x1701 + TEXTURE = 0x1702 + + LINE = 0x1B01 + POINT = 0x1B00 + + FILL = 0x1B02 + + COLOR = 0x1800 + DEPTH = 0x1801 + STENCIL = 0x1802 + + ALPHA = 0x1906 + BLUE = 0x1905 + COLOR_INDEX = 0x1900 + DEPTH_COMPONENT = 0x1902 + GREEN = 0x1904 + LUMINANCE = 0x1909 + LUMINANCE_ALPHA = 0x190A + RED = 0x1903 + RGB = 0x1907 + RGBA = 0x1908 + STENCIL_INDEX = 0x1901 + + ALPHA12 = 0x803D + ALPHA16 = 0x803E + ALPHA4 = 0x803B + ALPHA8 = 0x803C + INTENSITY = 0x8049 + INTENSITY12 = 0x804C + INTENSITY16 = 0x804D + INTENSITY4 = 0x804A + INTENSITY8 = 0x804B + LUMINANCE12 = 0x8041 + LUMINANCE12_ALPHA12 = 0x8047 + LUMINANCE12_ALPHA4 = 0x8046 + LUMINANCE16 = 0x8042 + LUMINANCE16_ALPHA16 = 0x8048 + LUMINANCE4 = 0x803F + LUMINANCE4_ALPHA4 = 0x8043 + LUMINANCE6_ALPHA2 = 0x8044 + LUMINANCE8 = 0x8040 + LUMINANCE8_ALPHA8 = 0x8045 + R3_G3_B2 = 0x2A10 + RGB10 = 0x8052 + RGB10_A2 = 0x8059 + RGB12 = 0x8053 + RGB16 = 0x8054 + RGB4 = 0x804F + RGB5 = 0x8050 + RGB5_A1 = 0x8057 + RGB8 = 0x8051 + RGBA12 = 0x805A + RGBA16 = 0x805B + RGBA2 = 0x8055 + RGBA4 = 0x8056 + RGBA8 = 0x8058 + + PACK_IMAGE_HEIGHT = 0x806C + PACK_SKIP_IMAGES = 0x806B + UNPACK_IMAGE_HEIGHT = 0x806E + UNPACK_SKIP_IMAGES = 0x806D + + BITMAP = 0x1A00 + UNSIGNED_BYTE_3_3_2 = 0x8032 + UNSIGNED_INT_10_10_10_2 = 0x8036 + UNSIGNED_INT_8_8_8_8 = 0x8035 + UNSIGNED_SHORT_4_4_4_4 = 0x8033 + UNSIGNED_SHORT_5_5_5_1 = 0x8034 + + POINT_DISTANCE_ATTENUATION = 0x8129 + POINT_FADE_THRESHOLD_SIZE = 0x8128 + POINT_SIZE_MAX = 0x8127 + POINT_SIZE_MIN = 0x8126 + + LINES = 0x0001 + LINE_LOOP = 0x0002 + LINE_STRIP = 0x0003 + POINTS = 0x0000 + POLYGON = 0x0009 + QUADS = 0x0007 + QUAD_STRIP = 0x0008 + TRIANGLES = 0x0004 + TRIANGLE_FAN = 0x0006 + TRIANGLE_STRIP = 0x0005 + + FEEDBACK = 0x1C01 + RENDER = 0x1C00 + SELECT = 0x1C02 + + FLAT = 0x1D00 + SMOOTH = 0x1D01 + + DECR = 0x1E03 + INCR = 0x1E02 + KEEP = 0x1E00 + + EXTENSIONS = 0x1F03 + RENDERER = 0x1F01 + VENDOR = 0x1F00 + VERSION = 0x1F02 + + S = 0x2000 + T = 0x2001 + R = 0x2002 + Q = 0x2003 + + DECAL = 0x2101 + + TEXTURE_ENV_COLOR = 0x2201 + TEXTURE_ENV_MODE = 0x2200 + + TEXTURE_ENV = 0x2300 + + EYE_LINEAR = 0x2400 + OBJECT_LINEAR = 0x2401 + SPHERE_MAP = 0x2402 + + EYE_PLANE = 0x2502 + OBJECT_PLANE = 0x2501 + TEXTURE_GEN_MODE = 0x2500 + + NEAREST = 0x2600 + + LINEAR_MIPMAP_LINEAR = 0x2703 + LINEAR_MIPMAP_NEAREST = 0x2701 + NEAREST_MIPMAP_LINEAR = 0x2702 + NEAREST_MIPMAP_NEAREST = 0x2700 + + GENERATE_MIPMAP = 0x8191 + TEXTURE_WRAP_R = 0x8072 + + PROXY_TEXTURE_1D = 0x8063 + PROXY_TEXTURE_2D = 0x8064 + PROXY_TEXTURE_3D = 0x8070 + TEXTURE_3D = 0x806F + TEXTURE_BASE_LEVEL = 0x813C + TEXTURE_MAX_LEVEL = 0x813D + TEXTURE_MAX_LOD = 0x813B + TEXTURE_MIN_LOD = 0x813A + + CLAMP = 0x2900 + CLAMP_TO_BORDER = 0x812D + CLAMP_TO_EDGE = 0x812F + REPEAT = 0x2901 + + CONSTANT_COLOR = 0x8001 + ONE_MINUS_CONSTANT_COLOR = 0x8002 + CONSTANT_ALPHA = 0x8003 + ONE_MINUS_CONSTANT_ALPHA = 0x8004 + FUNC_ADD = 0x8006 + MIN = 0x8007 + MAX = 0x8008 + BLEND_EQUATION_RGB = 0x8009 + FUNC_SUBTRACT = 0x800A + FUNC_REVERSE_SUBTRACT = 0x800B + RESCALE_NORMAL = 0x803A + TEXTURE_DEPTH = 0x8071 + MAX_3D_TEXTURE_SIZE = 0x8073 + MULTISAMPLE = 0x809D + SAMPLE_ALPHA_TO_COVERAGE = 0x809E + SAMPLE_ALPHA_TO_ONE = 0x809F + SAMPLE_COVERAGE = 0x80A0 + SAMPLE_BUFFERS = 0x80A8 + SAMPLES = 0x80A9 + SAMPLE_COVERAGE_VALUE = 0x80AA + SAMPLE_COVERAGE_INVERT = 0x80AB + BLEND_DST_RGB = 0x80C8 + BLEND_SRC_RGB = 0x80C9 + BLEND_DST_ALPHA = 0x80CA + BLEND_SRC_ALPHA = 0x80CB + BGR = 0x80E0 + BGRA = 0x80E1 + MAX_ELEMENTS_VERTICES = 0x80E8 + MAX_ELEMENTS_INDICES = 0x80E9 + DEPTH_COMPONENT16 = 0x81A5 + DEPTH_COMPONENT24 = 0x81A6 + DEPTH_COMPONENT32 = 0x81A7 + FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210 + FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211 + FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212 + FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213 + FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214 + FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215 + FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216 + FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217 + FRAMEBUFFER_DEFAULT = 0x8218 + FRAMEBUFFER_UNDEFINED = 0x8219 + DEPTH_STENCIL_ATTACHMENT = 0x821A + MAJOR_VERSION = 0x821B + MINOR_VERSION = 0x821C + NUM_EXTENSIONS = 0x821D + CONTEXT_FLAGS = 0x821E + COMPRESSED_RED = 0x8225 + COMPRESSED_RG = 0x8226 + RG = 0x8227 + RG_INTEGER = 0x8228 + R8 = 0x8229 + R16 = 0x822A + RG8 = 0x822B + RG16 = 0x822C + R16F = 0x822D + R32F = 0x822E + RG16F = 0x822F + RG32F = 0x8230 + R8I = 0x8231 + R8UI = 0x8232 + R16I = 0x8233 + R16UI = 0x8234 + R32I = 0x8235 + R32UI = 0x8236 + RG8I = 0x8237 + RG8UI = 0x8238 + RG16I = 0x8239 + RG16UI = 0x823A + RG32I = 0x823B + RG32UI = 0x823C + UNSIGNED_BYTE_2_3_3_REV = 0x8362 + UNSIGNED_SHORT_5_6_5 = 0x8363 + UNSIGNED_SHORT_5_6_5_REV = 0x8364 + UNSIGNED_SHORT_4_4_4_4_REV = 0x8365 + UNSIGNED_SHORT_1_5_5_5_REV = 0x8366 + UNSIGNED_INT_8_8_8_8_REV = 0x8367 + UNSIGNED_INT_2_10_10_10_REV = 0x8368 + MIRRORED_REPEAT = 0x8370 + FOG_COORDINATE_SOURCE = 0x8450 + FOG_COORD_SRC = 0x8450 + FOG_COORDINATE = 0x8451 + FOG_COORD = 0x8451 + FRAGMENT_DEPTH = 0x8452 + CURRENT_FOG_COORDINATE = 0x8453 + CURRENT_FOG_COORD = 0x8453 + FOG_COORDINATE_ARRAY_TYPE = 0x8454 + FOG_COORD_ARRAY_TYPE = 0x8454 + FOG_COORDINATE_ARRAY_STRIDE = 0x8455 + FOG_COORD_ARRAY_STRIDE = 0x8455 + FOG_COORDINATE_ARRAY_POINTER = 0x8456 + FOG_COORD_ARRAY_POINTER = 0x8456 + FOG_COORDINATE_ARRAY = 0x8457 + FOG_COORD_ARRAY = 0x8457 + COLOR_SUM = 0x8458 + CURRENT_SECONDARY_COLOR = 0x8459 + SECONDARY_COLOR_ARRAY_SIZE = 0x845A + SECONDARY_COLOR_ARRAY_TYPE = 0x845B + SECONDARY_COLOR_ARRAY_STRIDE = 0x845C + SECONDARY_COLOR_ARRAY_POINTER = 0x845D + SECONDARY_COLOR_ARRAY = 0x845E + CURRENT_RASTER_SECONDARY_COLOR = 0x845F + TEXTURE0 = 0x84C0 + TEXTURE1 = 0x84C1 + TEXTURE2 = 0x84C2 + TEXTURE3 = 0x84C3 + TEXTURE4 = 0x84C4 + TEXTURE5 = 0x84C5 + TEXTURE6 = 0x84C6 + TEXTURE7 = 0x84C7 + TEXTURE8 = 0x84C8 + TEXTURE9 = 0x84C9 + TEXTURE10 = 0x84CA + TEXTURE11 = 0x84CB + TEXTURE12 = 0x84CC + TEXTURE13 = 0x84CD + TEXTURE14 = 0x84CE + TEXTURE15 = 0x84CF + TEXTURE16 = 0x84D0 + TEXTURE17 = 0x84D1 + TEXTURE18 = 0x84D2 + TEXTURE19 = 0x84D3 + TEXTURE20 = 0x84D4 + TEXTURE21 = 0x84D5 + TEXTURE22 = 0x84D6 + TEXTURE23 = 0x84D7 + TEXTURE24 = 0x84D8 + TEXTURE25 = 0x84D9 + TEXTURE26 = 0x84DA + TEXTURE27 = 0x84DB + TEXTURE28 = 0x84DC + TEXTURE29 = 0x84DD + TEXTURE30 = 0x84DE + TEXTURE31 = 0x84DF + ACTIVE_TEXTURE = 0x84E0 + CLIENT_ACTIVE_TEXTURE = 0x84E1 + MAX_TEXTURE_UNITS = 0x84E2 + TRANSPOSE_MODELVIEW_MATRIX = 0x84E3 + TRANSPOSE_PROJECTION_MATRIX = 0x84E4 + TRANSPOSE_TEXTURE_MATRIX = 0x84E5 + TRANSPOSE_COLOR_MATRIX = 0x84E6 + SUBTRACT = 0x84E7 + MAX_RENDERBUFFER_SIZE = 0x84E8 + COMPRESSED_ALPHA = 0x84E9 + COMPRESSED_LUMINANCE = 0x84EA + COMPRESSED_LUMINANCE_ALPHA = 0x84EB + COMPRESSED_INTENSITY = 0x84EC + COMPRESSED_RGB = 0x84ED + COMPRESSED_RGBA = 0x84EE + DEPTH_STENCIL = 0x84F9 + UNSIGNED_INT_24_8 = 0x84FA + MAX_TEXTURE_LOD_BIAS = 0x84FD + TEXTURE_FILTER_CONTROL = 0x8500 + TEXTURE_LOD_BIAS = 0x8501 + INCR_WRAP = 0x8507 + DECR_WRAP = 0x8508 + NORMAL_MAP = 0x8511 + REFLECTION_MAP = 0x8512 + TEXTURE_CUBE_MAP = 0x8513 + TEXTURE_BINDING_CUBE_MAP = 0x8514 + TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515 + TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516 + TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517 + TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518 + TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519 + TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A + PROXY_TEXTURE_CUBE_MAP = 0x851B + MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C + COMBINE = 0x8570 + COMBINE_RGB = 0x8571 + COMBINE_ALPHA = 0x8572 + RGB_SCALE = 0x8573 + ADD_SIGNED = 0x8574 + INTERPOLATE = 0x8575 + CONSTANT = 0x8576 + PRIMARY_COLOR = 0x8577 + PREVIOUS = 0x8578 + SOURCE0_RGB = 0x8580 + SRC0_RGB = 0x8580 + SOURCE1_RGB = 0x8581 + SRC1_RGB = 0x8581 + SOURCE2_RGB = 0x8582 + SRC2_RGB = 0x8582 + SOURCE0_ALPHA = 0x8588 + SRC0_ALPHA = 0x8588 + SOURCE1_ALPHA = 0x8589 + SRC1_ALPHA = 0x8589 + SOURCE2_ALPHA = 0x858A + SRC2_ALPHA = 0x858A + OPERAND0_RGB = 0x8590 + OPERAND1_RGB = 0x8591 + OPERAND2_RGB = 0x8592 + OPERAND0_ALPHA = 0x8598 + OPERAND1_ALPHA = 0x8599 + OPERAND2_ALPHA = 0x859A + VERTEX_ARRAY_BINDING = 0x85B5 + VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622 + VERTEX_ATTRIB_ARRAY_SIZE = 0x8623 + VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624 + VERTEX_ATTRIB_ARRAY_TYPE = 0x8625 + CURRENT_VERTEX_ATTRIB = 0x8626 + VERTEX_PROGRAM_POINT_SIZE = 0x8642 + VERTEX_PROGRAM_TWO_SIDE = 0x8643 + VERTEX_ATTRIB_ARRAY_POINTER = 0x8645 + TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0 + TEXTURE_COMPRESSED = 0x86A1 + NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2 + COMPRESSED_TEXTURE_FORMATS = 0x86A3 + DOT3_RGB = 0x86AE + DOT3_RGBA = 0x86AF + BUFFER_SIZE = 0x8764 + BUFFER_USAGE = 0x8765 + STENCIL_BACK_FUNC = 0x8800 + STENCIL_BACK_FAIL = 0x8801 + STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802 + STENCIL_BACK_PASS_DEPTH_PASS = 0x8803 + RGBA32F = 0x8814 + RGB32F = 0x8815 + RGBA16F = 0x881A + RGB16F = 0x881B + MAX_DRAW_BUFFERS = 0x8824 + DRAW_BUFFER0 = 0x8825 + DRAW_BUFFER1 = 0x8826 + DRAW_BUFFER2 = 0x8827 + DRAW_BUFFER3 = 0x8828 + DRAW_BUFFER4 = 0x8829 + DRAW_BUFFER5 = 0x882A + DRAW_BUFFER6 = 0x882B + DRAW_BUFFER7 = 0x882C + DRAW_BUFFER8 = 0x882D + DRAW_BUFFER9 = 0x882E + DRAW_BUFFER10 = 0x882F + DRAW_BUFFER11 = 0x8830 + DRAW_BUFFER12 = 0x8831 + DRAW_BUFFER13 = 0x8832 + DRAW_BUFFER14 = 0x8833 + DRAW_BUFFER15 = 0x8834 + BLEND_EQUATION_ALPHA = 0x883D + TEXTURE_DEPTH_SIZE = 0x884A + DEPTH_TEXTURE_MODE = 0x884B + TEXTURE_COMPARE_MODE = 0x884C + TEXTURE_COMPARE_FUNC = 0x884D + COMPARE_R_TO_TEXTURE = 0x884E + COMPARE_REF_TO_TEXTURE = 0x884E + POINT_SPRITE = 0x8861 + COORD_REPLACE = 0x8862 + QUERY_COUNTER_BITS = 0x8864 + CURRENT_QUERY = 0x8865 + QUERY_RESULT = 0x8866 + QUERY_RESULT_AVAILABLE = 0x8867 + MAX_VERTEX_ATTRIBS = 0x8869 + VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A + MAX_TEXTURE_COORDS = 0x8871 + MAX_TEXTURE_IMAGE_UNITS = 0x8872 + ARRAY_BUFFER = 0x8892 + ELEMENT_ARRAY_BUFFER = 0x8893 + ARRAY_BUFFER_BINDING = 0x8894 + ELEMENT_ARRAY_BUFFER_BINDING = 0x8895 + VERTEX_ARRAY_BUFFER_BINDING = 0x8896 + NORMAL_ARRAY_BUFFER_BINDING = 0x8897 + COLOR_ARRAY_BUFFER_BINDING = 0x8898 + INDEX_ARRAY_BUFFER_BINDING = 0x8899 + TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A + EDGE_FLAG_ARRAY_BUFFER_BINDING = 0x889B + SECONDARY_COLOR_ARRAY_BUFFER_BINDING = 0x889C + FOG_COORDINATE_ARRAY_BUFFER_BINDING = 0x889D + FOG_COORD_ARRAY_BUFFER_BINDING = 0x889D + WEIGHT_ARRAY_BUFFER_BINDING = 0x889E + VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F + READ_ONLY = 0x88B8 + WRITE_ONLY = 0x88B9 + READ_WRITE = 0x88BA + BUFFER_ACCESS = 0x88BB + BUFFER_MAPPED = 0x88BC + BUFFER_MAP_POINTER = 0x88BD + STREAM_DRAW = 0x88E0 + STREAM_READ = 0x88E1 + STREAM_COPY = 0x88E2 + STATIC_DRAW = 0x88E4 + STATIC_READ = 0x88E5 + STATIC_COPY = 0x88E6 + DYNAMIC_DRAW = 0x88E8 + DYNAMIC_READ = 0x88E9 + DYNAMIC_COPY = 0x88EA + PIXEL_PACK_BUFFER = 0x88EB + PIXEL_UNPACK_BUFFER = 0x88EC + PIXEL_PACK_BUFFER_BINDING = 0x88ED + PIXEL_UNPACK_BUFFER_BINDING = 0x88EF + DEPTH24_STENCIL8 = 0x88F0 + TEXTURE_STENCIL_SIZE = 0x88F1 + VERTEX_ATTRIB_ARRAY_INTEGER = 0x88FD + MAX_ARRAY_TEXTURE_LAYERS = 0x88FF + MIN_PROGRAM_TEXEL_OFFSET = 0x8904 + MAX_PROGRAM_TEXEL_OFFSET = 0x8905 + SAMPLES_PASSED = 0x8914 + CLAMP_VERTEX_COLOR = 0x891A + CLAMP_FRAGMENT_COLOR = 0x891B + CLAMP_READ_COLOR = 0x891C + FIXED_ONLY = 0x891D + FRAGMENT_SHADER = 0x8B30 + VERTEX_SHADER = 0x8B31 + MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49 + MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A + MAX_VARYING_FLOATS = 0x8B4B + MAX_VARYING_COMPONENTS = 0x8B4B + MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C + MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D + SHADER_TYPE = 0x8B4F + FLOAT_VEC2 = 0x8B50 + FLOAT_VEC3 = 0x8B51 + FLOAT_VEC4 = 0x8B52 + INT_VEC2 = 0x8B53 + INT_VEC3 = 0x8B54 + INT_VEC4 = 0x8B55 + BOOL = 0x8B56 + BOOL_VEC2 = 0x8B57 + BOOL_VEC3 = 0x8B58 + BOOL_VEC4 = 0x8B59 + FLOAT_MAT2 = 0x8B5A + FLOAT_MAT3 = 0x8B5B + FLOAT_MAT4 = 0x8B5C + SAMPLER_1D = 0x8B5D + SAMPLER_2D = 0x8B5E + SAMPLER_3D = 0x8B5F + SAMPLER_CUBE = 0x8B60 + SAMPLER_1D_SHADOW = 0x8B61 + SAMPLER_2D_SHADOW = 0x8B62 + FLOAT_MAT2x3 = 0x8B65 + FLOAT_MAT2x4 = 0x8B66 + FLOAT_MAT3x2 = 0x8B67 + FLOAT_MAT3x4 = 0x8B68 + FLOAT_MAT4x2 = 0x8B69 + FLOAT_MAT4x3 = 0x8B6A + DELETE_STATUS = 0x8B80 + COMPILE_STATUS = 0x8B81 + LINK_STATUS = 0x8B82 + VALIDATE_STATUS = 0x8B83 + INFO_LOG_LENGTH = 0x8B84 + ATTACHED_SHADERS = 0x8B85 + ACTIVE_UNIFORMS = 0x8B86 + ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87 + SHADER_SOURCE_LENGTH = 0x8B88 + ACTIVE_ATTRIBUTES = 0x8B89 + ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A + SHADING_LANGUAGE_VERSION = 0x8B8C + CURRENT_PROGRAM = 0x8B8D + TEXTURE_RED_TYPE = 0x8C10 + TEXTURE_GREEN_TYPE = 0x8C11 + TEXTURE_BLUE_TYPE = 0x8C12 + TEXTURE_ALPHA_TYPE = 0x8C13 + TEXTURE_DEPTH_TYPE = 0x8C16 + UNSIGNED_NORMALIZED = 0x8C17 + TEXTURE_1D_ARRAY = 0x8C18 + PROXY_TEXTURE_1D_ARRAY = 0x8C19 + TEXTURE_2D_ARRAY = 0x8C1A + PROXY_TEXTURE_2D_ARRAY = 0x8C1B + TEXTURE_BINDING_1D_ARRAY = 0x8C1C + TEXTURE_BINDING_2D_ARRAY = 0x8C1D + R11F_G11F_B10F = 0x8C3A + UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B + RGB9_E5 = 0x8C3D + UNSIGNED_INT_5_9_9_9_REV = 0x8C3E + TEXTURE_SHARED_SIZE = 0x8C3F + SRGB = 0x8C40 + SRGB8 = 0x8C41 + SRGB_ALPHA = 0x8C42 + SRGB8_ALPHA8 = 0x8C43 + SLUMINANCE_ALPHA = 0x8C44 + SLUMINANCE8_ALPHA8 = 0x8C45 + SLUMINANCE = 0x8C46 + SLUMINANCE8 = 0x8C47 + COMPRESSED_SRGB = 0x8C48 + COMPRESSED_SRGB_ALPHA = 0x8C49 + COMPRESSED_SLUMINANCE = 0x8C4A + COMPRESSED_SLUMINANCE_ALPHA = 0x8C4B + TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76 + TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F + MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80 + TRANSFORM_FEEDBACK_VARYINGS = 0x8C83 + TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84 + TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85 + PRIMITIVES_GENERATED = 0x8C87 + TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88 + RASTERIZER_DISCARD = 0x8C89 + MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A + MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B + INTERLEAVED_ATTRIBS = 0x8C8C + SEPARATE_ATTRIBS = 0x8C8D + TRANSFORM_FEEDBACK_BUFFER = 0x8C8E + TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F + POINT_SPRITE_COORD_ORIGIN = 0x8CA0 + LOWER_LEFT = 0x8CA1 + UPPER_LEFT = 0x8CA2 + STENCIL_BACK_REF = 0x8CA3 + STENCIL_BACK_VALUE_MASK = 0x8CA4 + STENCIL_BACK_WRITEMASK = 0x8CA5 + DRAW_FRAMEBUFFER_BINDING = 0x8CA6 + FRAMEBUFFER_BINDING = 0x8CA6 + RENDERBUFFER_BINDING = 0x8CA7 + READ_FRAMEBUFFER = 0x8CA8 + DRAW_FRAMEBUFFER = 0x8CA9 + READ_FRAMEBUFFER_BINDING = 0x8CAA + RENDERBUFFER_SAMPLES = 0x8CAB + DEPTH_COMPONENT32F = 0x8CAC + DEPTH32F_STENCIL8 = 0x8CAD + FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0 + FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1 + FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2 + FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3 + FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4 + FRAMEBUFFER_COMPLETE = 0x8CD5 + FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6 + FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7 + FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB + FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC + FRAMEBUFFER_UNSUPPORTED = 0x8CDD + MAX_COLOR_ATTACHMENTS = 0x8CDF + COLOR_ATTACHMENT0 = 0x8CE0 + COLOR_ATTACHMENT1 = 0x8CE1 + COLOR_ATTACHMENT2 = 0x8CE2 + COLOR_ATTACHMENT3 = 0x8CE3 + COLOR_ATTACHMENT4 = 0x8CE4 + COLOR_ATTACHMENT5 = 0x8CE5 + COLOR_ATTACHMENT6 = 0x8CE6 + COLOR_ATTACHMENT7 = 0x8CE7 + COLOR_ATTACHMENT8 = 0x8CE8 + COLOR_ATTACHMENT9 = 0x8CE9 + COLOR_ATTACHMENT10 = 0x8CEA + COLOR_ATTACHMENT11 = 0x8CEB + COLOR_ATTACHMENT12 = 0x8CEC + COLOR_ATTACHMENT13 = 0x8CED + COLOR_ATTACHMENT14 = 0x8CEE + COLOR_ATTACHMENT15 = 0x8CEF + DEPTH_ATTACHMENT = 0x8D00 + STENCIL_ATTACHMENT = 0x8D20 + FRAMEBUFFER = 0x8D40 + RENDERBUFFER = 0x8D41 + RENDERBUFFER_WIDTH = 0x8D42 + RENDERBUFFER_HEIGHT = 0x8D43 + RENDERBUFFER_INTERNAL_FORMAT = 0x8D44 + STENCIL_INDEX1 = 0x8D46 + STENCIL_INDEX4 = 0x8D47 + STENCIL_INDEX8 = 0x8D48 + STENCIL_INDEX16 = 0x8D49 + RENDERBUFFER_RED_SIZE = 0x8D50 + RENDERBUFFER_GREEN_SIZE = 0x8D51 + RENDERBUFFER_BLUE_SIZE = 0x8D52 + RENDERBUFFER_ALPHA_SIZE = 0x8D53 + RENDERBUFFER_DEPTH_SIZE = 0x8D54 + RENDERBUFFER_STENCIL_SIZE = 0x8D55 + FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56 + MAX_SAMPLES = 0x8D57 + RGBA32UI = 0x8D70 + RGB32UI = 0x8D71 + RGBA16UI = 0x8D76 + RGB16UI = 0x8D77 + RGBA8UI = 0x8D7C + RGB8UI = 0x8D7D + RGBA32I = 0x8D82 + RGB32I = 0x8D83 + RGBA16I = 0x8D88 + RGB16I = 0x8D89 + RGBA8I = 0x8D8E + RGB8I = 0x8D8F + RED_INTEGER = 0x8D94 + GREEN_INTEGER = 0x8D95 + BLUE_INTEGER = 0x8D96 + ALPHA_INTEGER = 0x8D97 + RGB_INTEGER = 0x8D98 + RGBA_INTEGER = 0x8D99 + BGR_INTEGER = 0x8D9A + BGRA_INTEGER = 0x8D9B + FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD + FRAMEBUFFER_SRGB = 0x8DB9 + COMPRESSED_RED_RGTC1 = 0x8DBB + COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC + COMPRESSED_RG_RGTC2 = 0x8DBD + COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE + SAMPLER_1D_ARRAY = 0x8DC0 + SAMPLER_2D_ARRAY = 0x8DC1 + SAMPLER_1D_ARRAY_SHADOW = 0x8DC3 + SAMPLER_2D_ARRAY_SHADOW = 0x8DC4 + SAMPLER_CUBE_SHADOW = 0x8DC5 + UNSIGNED_INT_VEC2 = 0x8DC6 + UNSIGNED_INT_VEC3 = 0x8DC7 + UNSIGNED_INT_VEC4 = 0x8DC8 + INT_SAMPLER_1D = 0x8DC9 + INT_SAMPLER_2D = 0x8DCA + INT_SAMPLER_3D = 0x8DCB + INT_SAMPLER_CUBE = 0x8DCC + INT_SAMPLER_1D_ARRAY = 0x8DCE + INT_SAMPLER_2D_ARRAY = 0x8DCF + UNSIGNED_INT_SAMPLER_1D = 0x8DD1 + UNSIGNED_INT_SAMPLER_2D = 0x8DD2 + UNSIGNED_INT_SAMPLER_3D = 0x8DD3 + UNSIGNED_INT_SAMPLER_CUBE = 0x8DD4 + UNSIGNED_INT_SAMPLER_1D_ARRAY = 0x8DD6 + UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8DD7 + QUERY_WAIT = 0x8E13 + QUERY_NO_WAIT = 0x8E14 + QUERY_BY_REGION_WAIT = 0x8E15 + QUERY_BY_REGION_NO_WAIT = 0x8E16 + BUFFER_ACCESS_FLAGS = 0x911F + BUFFER_MAP_LENGTH = 0x9120 + BUFFER_MAP_OFFSET = 0x9121 +) + +// https://www.opengl.org/sdk/docs/man3/xhtml/glViewport.xml +func (gl *GL) Viewport(x, y, width, height int) { + C.gl3_0_glViewport(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// DepthRange specifies the mapping of depth values from normalized device +// coordinates to window coordinates. +// +// Parameter nearVal specifies the mapping of the near clipping plane to window +// coordinates (defaults to 0), while farVal specifies the mapping of the far +// clipping plane to window coordinates (defaults to 1). +// +// After clipping and division by w, depth coordinates range from -1 to 1, +// corresponding to the near and far clipping planes. DepthRange specifies a +// linear mapping of the normalized depth coordinates in this range to window +// depth coordinates. Regardless of the actual depth buffer implementation, +// window coordinate depth values are treated as though they range from 0 through 1 +// (like color components). Thus, the values accepted by DepthRange are both +// clamped to this range before they are accepted. +// +// The default setting of (0, 1) maps the near plane to 0 and the far plane to 1. +// With this mapping, the depth buffer range is fully utilized. +// +// It is not necessary that nearVal be less than farVal. Reverse mappings such as +// nearVal 1, and farVal 0 are acceptable. +// +// GL.INVALID_OPERATION is generated if DepthRange is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) DepthRange(nearVal, farVal float64) { + C.gl3_0_glDepthRange(gl.funcs, C.GLdouble(nearVal), C.GLdouble(farVal)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsEnabled.xml +func (gl *GL) IsEnabled(cap glbase.Enum) bool { + glresult := C.gl3_0_glIsEnabled(gl.funcs, C.GLenum(cap)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexLevelParameteriv.xml +func (gl *GL) GetTexLevelParameteriv(target glbase.Enum, level int, pname glbase.Enum, params []int32) { + C.gl3_0_glGetTexLevelParameteriv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexLevelParameterfv.xml +func (gl *GL) GetTexLevelParameterfv(target glbase.Enum, level int, pname glbase.Enum, params []float32) { + C.gl3_0_glGetTexLevelParameterfv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexParameteriv.xml +func (gl *GL) GetTexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_0_glGetTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexParameterfv.xml +func (gl *GL) GetTexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl3_0_glGetTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexImage.xml +func (gl *GL) GetTexImage(target glbase.Enum, level int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glGetTexImage(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetIntegerv.xml +func (gl *GL) GetIntegerv(pname glbase.Enum, params []int32) { + C.gl3_0_glGetIntegerv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetFloatv.xml +func (gl *GL) GetFloatv(pname glbase.Enum, params []float32) { + C.gl3_0_glGetFloatv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetError.xml +func (gl *GL) GetError() glbase.Enum { + glresult := C.gl3_0_glGetError(gl.funcs) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetDoublev.xml +func (gl *GL) GetDoublev(pname glbase.Enum, params []float64) { + C.gl3_0_glGetDoublev(gl.funcs, C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetBooleanv.xml +func (gl *GL) GetBooleanv(pname glbase.Enum, params []bool) { + C.gl3_0_glGetBooleanv(gl.funcs, C.GLenum(pname), (*C.GLboolean)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glReadPixels.xml +func (gl *GL) ReadPixels(x, y, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glReadPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glReadBuffer.xml +func (gl *GL) ReadBuffer(mode glbase.Enum) { + C.gl3_0_glReadBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPixelStorei.xml +func (gl *GL) PixelStorei(pname glbase.Enum, param int32) { + C.gl3_0_glPixelStorei(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPixelStoref.xml +func (gl *GL) PixelStoref(pname glbase.Enum, param float32) { + C.gl3_0_glPixelStoref(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDepthFunc.xml +func (gl *GL) DepthFunc(glfunc glbase.Enum) { + C.gl3_0_glDepthFunc(gl.funcs, C.GLenum(glfunc)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilOp.xml +func (gl *GL) StencilOp(fail, zfail, zpass glbase.Enum) { + C.gl3_0_glStencilOp(gl.funcs, C.GLenum(fail), C.GLenum(zfail), C.GLenum(zpass)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilFunc.xml +func (gl *GL) StencilFunc(glfunc glbase.Enum, ref int32, mask uint32) { + C.gl3_0_glStencilFunc(gl.funcs, C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLogicOp.xml +func (gl *GL) LogicOp(opcode glbase.Enum) { + C.gl3_0_glLogicOp(gl.funcs, C.GLenum(opcode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlendFunc.xml +func (gl *GL) BlendFunc(sfactor, dfactor glbase.Enum) { + C.gl3_0_glBlendFunc(gl.funcs, C.GLenum(sfactor), C.GLenum(dfactor)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFlush.xml +func (gl *GL) Flush() { + C.gl3_0_glFlush(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFinish.xml +func (gl *GL) Finish() { + C.gl3_0_glFinish(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEnable.xml +func (gl *GL) Enable(cap glbase.Enum) { + C.gl3_0_glEnable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDisable.xml +func (gl *GL) Disable(cap glbase.Enum) { + C.gl3_0_glDisable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDepthMask.xml +func (gl *GL) DepthMask(flag bool) { + C.gl3_0_glDepthMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorMask.xml +func (gl *GL) ColorMask(red, green, blue, alpha bool) { + C.gl3_0_glColorMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&red)), *(*C.GLboolean)(unsafe.Pointer(&green)), *(*C.GLboolean)(unsafe.Pointer(&blue)), *(*C.GLboolean)(unsafe.Pointer(&alpha))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilMask.xml +func (gl *GL) StencilMask(mask uint32) { + C.gl3_0_glStencilMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearDepth.xml +func (gl *GL) ClearDepth(depth float64) { + C.gl3_0_glClearDepth(gl.funcs, C.GLdouble(depth)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearStencil.xml +func (gl *GL) ClearStencil(s int32) { + C.gl3_0_glClearStencil(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearColor.xml +func (gl *GL) ClearColor(red, green, blue, alpha float32) { + C.gl3_0_glClearColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClear.xml +func (gl *GL) Clear(mask glbase.Bitfield) { + C.gl3_0_glClear(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawBuffer.xml +func (gl *GL) DrawBuffer(mode glbase.Enum) { + C.gl3_0_glDrawBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexImage2D.xml +func (gl *GL) TexImage2D(target glbase.Enum, level int, internalFormat int32, width, height, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexImage1D.xml +func (gl *GL) TexImage1D(target glbase.Enum, level int, internalFormat int32, width, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameteriv.xml +func (gl *GL) TexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_0_glTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameteri.xml +func (gl *GL) TexParameteri(target, pname glbase.Enum, param int32) { + C.gl3_0_glTexParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameterfv.xml +func (gl *GL) TexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl3_0_glTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameterf.xml +func (gl *GL) TexParameterf(target, pname glbase.Enum, param float32) { + C.gl3_0_glTexParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glScissor.xml +func (gl *GL) Scissor(x, y, width, height int) { + C.gl3_0_glScissor(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPolygonMode.xml +func (gl *GL) PolygonMode(face, mode glbase.Enum) { + C.gl3_0_glPolygonMode(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPointSize.xml +func (gl *GL) PointSize(size float32) { + C.gl3_0_glPointSize(gl.funcs, C.GLfloat(size)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLineWidth.xml +func (gl *GL) LineWidth(width float32) { + C.gl3_0_glLineWidth(gl.funcs, C.GLfloat(width)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glHint.xml +func (gl *GL) Hint(target, mode glbase.Enum) { + C.gl3_0_glHint(gl.funcs, C.GLenum(target), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFrontFace.xml +func (gl *GL) FrontFace(mode glbase.Enum) { + C.gl3_0_glFrontFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCullFace.xml +func (gl *GL) CullFace(mode glbase.Enum) { + C.gl3_0_glCullFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexubv.xml +func (gl *GL) Indexubv(c []uint8) { + C.gl3_0_glIndexubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexub.xml +func (gl *GL) Indexub(c uint8) { + C.gl3_0_glIndexub(gl.funcs, C.GLubyte(c)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsTexture.xml +func (gl *GL) IsTexture(texture glbase.Texture) bool { + glresult := C.gl3_0_glIsTexture(gl.funcs, C.GLuint(texture)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenTextures returns n texture names in textures. There is no guarantee +// that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenTextures. +// +// The generated textures have no dimensionality; they assume the +// dimensionality of the texture target to which they are first bound (see +// BindTexture). +// +// Texture names returned by a call to GenTextures are not returned by +// subsequent calls, unless they are first deleted with DeleteTextures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenTextures is available in GL version 2.0 or greater. +func (gl *GL) GenTextures(n int) []glbase.Texture { + if n == 0 { + return nil + } + textures := make([]glbase.Texture, n) + C.gl3_0_glGenTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) + return textures +} + +// DeleteTextures deletes the textures objects whose names are stored +// in the textures slice. After a texture is deleted, it has no contents or +// dimensionality, and its name is free for reuse (for example by +// GenTextures). If a texture that is currently bound is deleted, the binding +// reverts to 0 (the default texture). +// +// DeleteTextures silently ignores 0's and names that do not correspond to +// existing textures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteTextures is available in GL version 2.0 or greater. +func (gl *GL) DeleteTextures(textures []glbase.Texture) { + n := len(textures) + if n == 0 { + return + } + C.gl3_0_glDeleteTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindTexture.xml +func (gl *GL) BindTexture(target glbase.Enum, texture glbase.Texture) { + C.gl3_0_glBindTexture(gl.funcs, C.GLenum(target), C.GLuint(texture)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexSubImage2D.xml +func (gl *GL) TexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexSubImage1D.xml +func (gl *GL) TexSubImage1D(target glbase.Enum, level, xoffset, width int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyTexSubImage2D.xml +func (gl *GL) CopyTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, x, y, width, height int) { + C.gl3_0_glCopyTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyTexSubImage1D.xml +func (gl *GL) CopyTexSubImage1D(target glbase.Enum, level, xoffset, x, y, width int) { + C.gl3_0_glCopyTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyTexImage2D.xml +func (gl *GL) CopyTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, height, border int) { + C.gl3_0_glCopyTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyTexImage1D.xml +func (gl *GL) CopyTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, border int) { + C.gl3_0_glCopyTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPolygonOffset.xml +func (gl *GL) PolygonOffset(factor, units float32) { + C.gl3_0_glPolygonOffset(gl.funcs, C.GLfloat(factor), C.GLfloat(units)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawElements.xml +func (gl *GL) DrawElements(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glDrawElements(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawArrays.xml +func (gl *GL) DrawArrays(mode glbase.Enum, first, count int) { + C.gl3_0_glDrawArrays(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyTexSubImage3D.xml +func (gl *GL) CopyTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, x, y, width, height int) { + C.gl3_0_glCopyTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexSubImage3D.xml +func (gl *GL) TexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexImage3D.xml +func (gl *GL) TexImage3D(target glbase.Enum, level int, internalFormat int32, width, height int, depth int32, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawRangeElements.xml +func (gl *GL) DrawRangeElements(mode glbase.Enum, start, end uint32, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glDrawRangeElements(gl.funcs, C.GLenum(mode), C.GLuint(start), C.GLuint(end), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlendEquation.xml +func (gl *GL) BlendEquation(mode glbase.Enum) { + C.gl3_0_glBlendEquation(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlendColor.xml +func (gl *GL) BlendColor(red, green, blue, alpha float32) { + C.gl3_0_glBlendColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetCompressedTexImage.xml +func (gl *GL) GetCompressedTexImage(target glbase.Enum, level int, img interface{}) { + var img_ptr unsafe.Pointer + var img_v = reflect.ValueOf(img) + if img != nil && img_v.Kind() != reflect.Slice { + panic("parameter img must be a slice") + } + if img != nil { + img_ptr = unsafe.Pointer(img_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glGetCompressedTexImage(gl.funcs, C.GLenum(target), C.GLint(level), img_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexSubImage1D.xml +func (gl *GL) CompressedTexSubImage1D(target glbase.Enum, level, xoffset, width int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glCompressedTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexSubImage2D.xml +func (gl *GL) CompressedTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glCompressedTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexSubImage3D.xml +func (gl *GL) CompressedTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glCompressedTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexImage1D.xml +func (gl *GL) CompressedTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, width, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glCompressedTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexImage2D.xml +func (gl *GL) CompressedTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glCompressedTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexImage3D.xml +func (gl *GL) CompressedTexImage3D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height int, depth int32, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glCompressedTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSampleCoverage.xml +func (gl *GL) SampleCoverage(value float32, invert bool) { + C.gl3_0_glSampleCoverage(gl.funcs, C.GLfloat(value), *(*C.GLboolean)(unsafe.Pointer(&invert))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glActiveTexture.xml +func (gl *GL) ActiveTexture(texture glbase.Enum) { + C.gl3_0_glActiveTexture(gl.funcs, C.GLenum(texture)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPointParameteriv.xml +func (gl *GL) PointParameteriv(pname glbase.Enum, params []int32) { + C.gl3_0_glPointParameteriv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPointParameteri.xml +func (gl *GL) PointParameteri(pname glbase.Enum, param int32) { + C.gl3_0_glPointParameteri(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPointParameterfv.xml +func (gl *GL) PointParameterfv(pname glbase.Enum, params []float32) { + C.gl3_0_glPointParameterfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPointParameterf.xml +func (gl *GL) PointParameterf(pname glbase.Enum, param float32) { + C.gl3_0_glPointParameterf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiDrawArrays.xml +func (gl *GL) MultiDrawArrays(mode glbase.Enum, first, count []int, drawcount int32) { + C.gl3_0_glMultiDrawArrays(gl.funcs, C.GLenum(mode), (*C.GLint)(unsafe.Pointer(&first[0])), (*C.GLsizei)(unsafe.Pointer(&count[0])), C.GLsizei(drawcount)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlendFuncSeparate.xml +func (gl *GL) BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha glbase.Enum) { + C.gl3_0_glBlendFuncSeparate(gl.funcs, C.GLenum(sfactorRGB), C.GLenum(dfactorRGB), C.GLenum(sfactorAlpha), C.GLenum(dfactorAlpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetBufferParameteriv.xml +func (gl *GL) GetBufferParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_0_glGetBufferParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glUnmapBuffer.xml +func (gl *GL) UnmapBuffer(target glbase.Enum) bool { + glresult := C.gl3_0_glUnmapBuffer(gl.funcs, C.GLenum(target)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetBufferSubData.xml +func (gl *GL) GetBufferSubData(target glbase.Enum, offset, size int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glGetBufferSubData(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(size), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBufferSubData.xml +func (gl *GL) BufferSubData(target glbase.Enum, offset, size int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glBufferSubData(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(size), data_ptr) +} + +// BufferData creates a new data store for the buffer object currently +// bound to target. Any pre-existing data store is deleted. The new data +// store is created with the specified size in bytes and usage. If data is +// not nil, it must be a slice that is used to initialize the data store. +// In that case the size parameter is ignored and the store size will match +// the slice data size. +// +// In its initial state, the new data store is not mapped, it has a NULL +// mapped pointer, and its mapped access is GL.READ_WRITE. +// +// The target constant must be one of GL.ARRAY_BUFFER, GL.COPY_READ_BUFFER, +// GL.COPY_WRITE_BUFFER, GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER, +// GL.PIXEL_UNPACK_BUFFER, GL.TEXTURE_BUFFER, GL.TRANSFORM_FEEDBACK_BUFFER, +// or GL.UNIFORM_BUFFER. +// +// The usage parameter is a hint to the GL implementation as to how a buffer +// object's data store will be accessed. This enables the GL implementation +// to make more intelligent decisions that may significantly impact buffer +// object performance. It does not, however, constrain the actual usage of +// the data store. usage can be broken down into two parts: first, the +// frequency of access (modification and usage), and second, the nature of +// that access. +// +// A usage frequency of STREAM and nature of DRAW is specified via the +// constant GL.STREAM_DRAW, for example. +// +// The usage frequency of access may be one of: +// +// STREAM +// The data store contents will be modified once and used at most a few times. +// +// STATIC +// The data store contents will be modified once and used many times. +// +// DYNAMIC +// The data store contents will be modified repeatedly and used many times. +// +// The usage nature of access may be one of: +// +// DRAW +// The data store contents are modified by the application, and used as +// the source for GL drawing and image specification commands. +// +// READ +// The data store contents are modified by reading data from the GL, +// and used to return that data when queried by the application. +// +// COPY +// The data store contents are modified by reading data from the GL, +// and used as the source for GL drawing and image specification +// commands. +// +// Clients must align data elements consistent with the requirements of the +// client platform, with an additional base-level requirement that an offset +// within a buffer to a datum comprising N bytes be a multiple of N. +// +// Error GL.INVALID_ENUM is generated if target is not one of the accepted +// buffer targets. GL.INVALID_ENUM is generated if usage is not +// GL.STREAM_DRAW, GL.STREAM_READ, GL.STREAM_COPY, GL.STATIC_DRAW, +// GL.STATIC_READ, GL.STATIC_COPY, GL.DYNAMIC_DRAW, GL.DYNAMIC_READ, or +// GL.DYNAMIC_COPY. GL.INVALID_VALUE is generated if size is negative. +// GL.INVALID_OPERATION is generated if the reserved buffer object name 0 is +// bound to target. GL.OUT_OF_MEMORY is generated if the GL is unable to +// create a data store with the specified size. +func (gl *GL) BufferData(target glbase.Enum, size int, data interface{}, usage glbase.Enum) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + if data != nil { + size = int(data_v.Type().Size()) * data_v.Len() + } + C.gl3_0_glBufferData(gl.funcs, C.GLenum(target), C.GLsizeiptr(size), data_ptr, C.GLenum(usage)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsBuffer.xml +func (gl *GL) IsBuffer(buffer glbase.Buffer) bool { + glresult := C.gl3_0_glIsBuffer(gl.funcs, C.GLuint(buffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenBuffers returns n buffer object names. There is no guarantee that +// the names form a contiguous set of integers; however, it is guaranteed +// that none of the returned names was in use immediately before the call to +// GenBuffers. +// +// Buffer object names returned by a call to GenBuffers are not returned by +// subsequent calls, unless they are first deleted with DeleteBuffers. +// +// No buffer objects are associated with the returned buffer object names +// until they are first bound by calling BindBuffer. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if GenBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// GenBuffers is available in GL version 1.5 or greater. +func (gl *GL) GenBuffers(n int) []glbase.Buffer { + if n == 0 { + return nil + } + buffers := make([]glbase.Buffer, n) + C.gl3_0_glGenBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) + return buffers +} + +// DeleteBuffers deletes the buffer objects whose names are stored in the +// buffers slice. +// +// After a buffer object is deleted, it has no contents, and its name is free +// for reuse (for example by GenBuffers). If a buffer object that is +// currently bound is deleted, the binding reverts to 0 (the absence of any +// buffer object, which reverts to client memory usage). +// +// DeleteBuffers silently ignores 0's and names that do not correspond to +// existing buffer objects. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if DeleteBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// DeleteBuffers is available in GL version 1.5 or greater. +func (gl *GL) DeleteBuffers(buffers []glbase.Buffer) { + n := len(buffers) + if n == 0 { + return + } + C.gl3_0_glDeleteBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) +} + +// BindBuffer creates or puts in use a named buffer object. +// Calling BindBuffer with target set to GL.ARRAY_BUFFER, +// GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER or GL.PIXEL_UNPACK_BUFFER +// and buffer set to the name of the new buffer object binds the buffer +// object name to the target. When a buffer object is bound to a target, the +// previous binding for that target is automatically broken. +// +// Buffer object names are unsigned integers. The value zero is reserved, but +// there is no default buffer object for each buffer object target. Instead, +// buffer set to zero effectively unbinds any buffer object previously bound, +// and restores client memory usage for that buffer object target. Buffer +// object names and the corresponding buffer object contents are local to the +// shared display-list space (see XCreateContext) of the current GL rendering +// context; two rendering contexts share buffer object names only if they +// also share display lists. +// +// GenBuffers may be called to generate a set of new buffer object names. +// +// The state of a buffer object immediately after it is first bound is an +// unmapped zero-sized memory buffer with GL.READ_WRITE access and +// GL.STATIC_DRAW usage. +// +// While a non-zero buffer object name is bound, GL operations on the target +// to which it is bound affect the bound buffer object, and queries of the +// target to which it is bound return state from the bound buffer object. +// While buffer object name zero is bound, as in the initial state, attempts +// to modify or query state on the target to which it is bound generates an +// GL.INVALID_OPERATION error. +// +// When vertex array pointer state is changed, for example by a call to +// NormalPointer, the current buffer object binding (GL.ARRAY_BUFFER_BINDING) +// is copied into the corresponding client state for the vertex array type +// being changed, for example GL.NORMAL_ARRAY_BUFFER_BINDING. While a +// non-zero buffer object is bound to the GL.ARRAY_BUFFER target, the vertex +// array pointer parameter that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.ELEMENT_ARRAY_BUFFER +// target, the indices parameter of DrawElements, DrawRangeElements, or +// MultiDrawElements that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_PACK_BUFFER +// target, the following commands are affected: GetCompressedTexImage, +// GetConvolutionFilter, GetHistogram, GetMinmax, GetPixelMap, +// GetPolygonStipple, GetSeparableFilter, GetTexImage, and ReadPixels. The +// pointer parameter that is traditionally interpreted as a pointer to +// client-side memory where the pixels are to be packed is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_UNPACK_BUFFER +// target, the following commands are affected: Bitmap, ColorSubTable, +// ColorTable, CompressedTexImage1D, CompressedTexImage2D, +// CompressedTexImage3D, CompressedTexSubImage1D, CompressedTexSubImage2D, +// CompressedTexSubImage3D, ConvolutionFilter1D, ConvolutionFilter2D, +// DrawPixels, PixelMap, PolygonStipple, SeparableFilter2D, TexImage1D, +// TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, and TexSubImage3D. +// The pointer parameter that is traditionally interpreted as a pointer to +// client-side memory from which the pixels are to be unpacked is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// A buffer object binding created with BindBuffer remains active until a +// different buffer object name is bound to the same target, or until the +// bound buffer object is deleted with DeleteBuffers. +// +// Once created, a named buffer object may be re-bound to any target as often +// as needed. However, the GL implementation may make choices about how to +// optimize the storage of a buffer object based on its initial binding +// target. +// +// Error GL.INVALID_ENUM is generated if target is not one of the allowable +// values. GL.INVALID_OPERATION is generated if BindBuffer is executed +// between the execution of Begin and the corresponding execution of End. +// +// BindBuffer is available in GL version 1.5 or greater. +func (gl *GL) BindBuffer(target glbase.Enum, buffer glbase.Buffer) { + C.gl3_0_glBindBuffer(gl.funcs, C.GLenum(target), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetQueryObjectuiv.xml +func (gl *GL) GetQueryObjectuiv(id uint32, pname glbase.Enum, params []uint32) { + C.gl3_0_glGetQueryObjectuiv(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetQueryObjectiv.xml +func (gl *GL) GetQueryObjectiv(id uint32, pname glbase.Enum, params []int32) { + C.gl3_0_glGetQueryObjectiv(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetQueryiv.xml +func (gl *GL) GetQueryiv(target, pname glbase.Enum, params []int32) { + C.gl3_0_glGetQueryiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEndQuery.xml +func (gl *GL) EndQuery(target glbase.Enum) { + C.gl3_0_glEndQuery(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBeginQuery.xml +func (gl *GL) BeginQuery(target glbase.Enum, id uint32) { + C.gl3_0_glBeginQuery(gl.funcs, C.GLenum(target), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsQuery.xml +func (gl *GL) IsQuery(id uint32) bool { + glresult := C.gl3_0_glIsQuery(gl.funcs, C.GLuint(id)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDeleteQueries.xml +func (gl *GL) DeleteQueries(n int, ids []uint32) { + C.gl3_0_glDeleteQueries(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGenQueries.xml +func (gl *GL) GenQueries(n int, ids []uint32) { + C.gl3_0_glGenQueries(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// VertexAttribPointer specifies the location and data format of the array +// of generic vertex attributes at index to use when rendering. size +// specifies the number of components per attribute and must be 1, 2, 3, or +// 4. type specifies the data type of each component, and stride specifies +// the byte stride from one attribute to the next, allowing vertices and +// attributes to be packed into a single array or stored in separate arrays. +// normalized indicates whether the values stored in an integer format are +// to be mapped to the range [-1,1] (for signed values) or [0,1] +// (for unsigned values) when they are accessed and converted to floating +// point; otherwise, values will be converted to floats directly without +// normalization. offset is a byte offset into the buffer object's data +// store, which must be bound to the GL.ARRAY_BUFFER target with BindBuffer. +// +// The buffer object binding (GL.ARRAY_BUFFER_BINDING) is saved as +// generic vertex attribute array client-side state +// (GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING) for the provided index. +// +// To enable and disable a generic vertex attribute array, call +// EnableVertexAttribArray and DisableVertexAttribArray with index. If +// enabled, the generic vertex attribute array is used when DrawArrays or +// DrawElements is called. Each generic vertex attribute array is initially +// disabled. +// +// VertexAttribPointer is typically implemented on the client side. +// +// Error GL.INVALID_ENUM is generated if type is not an accepted value. +// GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_VALUE is generated if size is not 1, 2, +// 3, or 4. GL.INVALID_VALUE is generated if stride is negative. +func (gl *GL) VertexAttribPointer(index glbase.Attrib, size int, gltype glbase.Enum, normalized bool, stride int, offset uintptr) { + offset_ptr := unsafe.Pointer(offset) + C.gl3_0_glVertexAttribPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLsizei(stride), offset_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glValidateProgram.xml +func (gl *GL) ValidateProgram(program glbase.Program) { + C.gl3_0_glValidateProgram(gl.funcs, C.GLuint(program)) +} + +// UniformMatrix4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*4) != 0 { + panic("invalid value length for UniformMatrix4fv") + } + count := len(value) / (4 * 4) + C.gl3_0_glUniformMatrix4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*3) != 0 { + panic("invalid value length for UniformMatrix3fv") + } + count := len(value) / (3 * 3) + C.gl3_0_glUniformMatrix3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*2) != 0 { + panic("invalid value length for UniformMatrix2fv") + } + count := len(value) / (2 * 2) + C.gl3_0_glUniformMatrix2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform4iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4iv") + } + count := len(value) / 4 + C.gl3_0_glUniform4iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform3iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3iv") + } + count := len(value) / 3 + C.gl3_0_glUniform3iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform2iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2iv") + } + count := len(value) / 2 + C.gl3_0_glUniform2iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform1iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl3_0_glUniform1iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4fv") + } + count := len(value) / 4 + C.gl3_0_glUniform4fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3fv") + } + count := len(value) / 3 + C.gl3_0_glUniform3fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2fv") + } + count := len(value) / 2 + C.gl3_0_glUniform2fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform1fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl3_0_glUniform1fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform4i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4i(location glbase.Uniform, v0, v1, v2, v3 int32) { + C.gl3_0_glUniform4i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2), C.GLint(v3)) +} + +// Uniform3i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3i(location glbase.Uniform, v0, v1, v2 int32) { + C.gl3_0_glUniform3i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2)) +} + +// Uniform2i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2i(location glbase.Uniform, v0, v1 int32) { + C.gl3_0_glUniform2i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1)) +} + +// Uniform1i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1i(location glbase.Uniform, v0 int32) { + C.gl3_0_glUniform1i(gl.funcs, C.GLint(location), C.GLint(v0)) +} + +// Uniform4f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4f(location glbase.Uniform, v0, v1, v2, v3 float32) { + C.gl3_0_glUniform4f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2), C.GLfloat(v3)) +} + +// Uniform3f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3f(location glbase.Uniform, v0, v1, v2 float32) { + C.gl3_0_glUniform3f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2)) +} + +// Uniform2f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2f(location glbase.Uniform, v0, v1 float32) { + C.gl3_0_glUniform2f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1)) +} + +// Uniform1f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1f(location glbase.Uniform, v0 float32) { + C.gl3_0_glUniform1f(gl.funcs, C.GLint(location), C.GLfloat(v0)) +} + +// UseProgram installs the program object specified by program as part of +// current rendering state. One or more executables are created in a program +// object by successfully attaching shader objects to it with AttachShader, +// successfully compiling the shader objects with CompileShader, and +// successfully linking the program object with LinkProgram. +// +// A program object will contain an executable that will run on the vertex +// processor if it contains one or more shader objects of type +// GL.VERTEX_SHADER that have been successfully compiled and linked. +// Similarly, a program object will contain an executable that will run on +// the fragment processor if it contains one or more shader objects of type +// GL.FRAGMENT_SHADER that have been successfully compiled and linked. +// +// Successfully installing an executable on a programmable processor will +// cause the corresponding fixed functionality of OpenGL to be disabled. +// Specifically, if an executable is installed on the vertex processor, the +// OpenGL fixed functionality will be disabled as follows. +// +// - The modelview matrix is not applied to vertex coordinates. +// +// - The projection matrix is not applied to vertex coordinates. +// +// - The texture matrices are not applied to texture coordinates. +// +// - Normals are not transformed to eye coordinates. +// +// - Normals are not rescaled or normalized. +// +// - Normalization of GL.AUTO_NORMAL evaluated normals is not performed. +// +// - Texture coordinates are not generated automatically. +// +// - Per-vertex lighting is not performed. +// +// - Color material computations are not performed. +// +// - Color index lighting is not performed. +// +// - This list also applies when setting the current raster position. +// +// The executable that is installed on the vertex processor is expected to +// implement any or all of the desired functionality from the preceding list. +// Similarly, if an executable is installed on the fragment processor, the +// OpenGL fixed functionality will be disabled as follows. +// +// - Texture environment and texture functions are not applied. +// +// - Texture application is not applied. +// +// - Color sum is not applied. +// +// - Fog is not applied. +// +// Again, the fragment shader that is installed is expected to implement any +// or all of the desired functionality from the preceding list. +// +// While a program object is in use, applications are free to modify attached +// shader objects, compile attached shader objects, attach additional shader +// objects, and detach or delete shader objects. None of these operations +// will affect the executables that are part of the current state. However, +// relinking the program object that is currently in use will install the +// program object as part of the current rendering state if the link +// operation was successful (see LinkProgram). If the program object +// currently in use is relinked unsuccessfully, its link status will be set +// to GL.FALSE, but the executables and associated state will remain part of +// the current state until a subsequent call to UseProgram removes it from +// use. After it is removed from use, it cannot be made part of current state +// until it has been successfully relinked. +// +// If program contains shader objects of type GL.VERTEX_SHADER but it does +// not contain shader objects of type GL.FRAGMENT_SHADER, an executable will +// be installed on the vertex processor, but fixed functionality will be used +// for fragment processing. Similarly, if program contains shader objects of +// type GL.FRAGMENT_SHADER but it does not contain shader objects of type +// GL.VERTEX_SHADER, an executable will be installed on the fragment +// processor, but fixed functionality will be used for vertex processing. If +// program is 0, the programmable processors will be disabled, and fixed +// functionality will be used for both vertex and fragment processing. +// +// While a program object is in use, the state that controls the disabled +// fixed functionality may also be updated using the normal OpenGL calls. +// +// Like display lists and texture objects, the name space for program objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// Applications are responsible for providing the synchronization across API +// calls when objects are accessed from different execution threads. +// +// Error GL.INVALID_VALUE is generated if program is neither 0 nor a value +// generated by OpenGL. GL.INVALID_OPERATION is generated if program is not +// a program object. GL.INVALID_OPERATION is generated if program could not +// be made part of current state. GL.INVALID_OPERATION is generated if +// UseProgram is executed between the execution of Begin and the +// corresponding execution of End. +// +// UseProgram is available in GL version 2.0 or greater. +func (gl *GL) UseProgram(program glbase.Program) { + C.gl3_0_glUseProgram(gl.funcs, C.GLuint(program)) +} + +// ShaderSource sets the source code in shader to the provided source code. Any source +// code previously stored in the shader object is completely replaced. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_VALUE is generated if count is less than 0. +// GL.INVALID_OPERATION is generated if ShaderSource is executed between the +// execution of Begin and the corresponding execution of End. +// +// ShaderSource is available in GL version 2.0 or greater. +func (gl *GL) ShaderSource(shader glbase.Shader, source ...string) { + count := len(source) + length := make([]int32, count) + source_c := make([]unsafe.Pointer, count) + for i, src := range source { + length[i] = int32(len(src)) + if len(src) > 0 { + source_c[i] = *(*unsafe.Pointer)(unsafe.Pointer(&src)) + } else { + source_c[i] = unsafe.Pointer(uintptr(0)) + } + } + C.gl3_0_glShaderSource(gl.funcs, C.GLuint(shader), C.GLsizei(count), (**C.GLchar)(unsafe.Pointer(&source_c[0])), (*C.GLint)(unsafe.Pointer(&length[0]))) +} + +// LinkProgram links the program object specified by program. If any shader +// objects of type GL.VERTEX_SHADER are attached to program, they will be +// used to create an executable that will run on the programmable vertex +// processor. If any shader objects of type GL.FRAGMENT_SHADER are attached +// to program, they will be used to create an executable that will run on the +// programmable fragment processor. +// +// The status of the link operation will be stored as part of the program +// object's state. This value will be set to GL.TRUE if the program object +// was linked without errors and is ready for use, and GL.FALSE otherwise. It +// can be queried by calling GetProgramiv with arguments program and +// GL.LINK_STATUS. +// +// As a result of a successful link operation, all active user-defined +// uniform variables belonging to program will be initialized to 0, and each +// of the program object's active uniform variables will be assigned a +// location that can be queried by calling GetUniformLocation. Also, any +// active user-defined attribute variables that have not been bound to a +// generic vertex attribute index will be bound to one at this time. +// +// Linking of a program object can fail for a number of reasons as specified +// in the OpenGL Shading Language Specification. The following lists some of +// the conditions that will cause a link error. +// +// - The number of active attribute variables supported by the +// implementation has been exceeded. +// +// - The storage limit for uniform variables has been exceeded. +// +// - The number of active uniform variables supported by the implementation +// has been exceeded. +// +// - The main function is missing for the vertex shader or the fragment +// shader. +// +// - A varying variable actually used in the fragment shader is not +// declared in the same way (or is not declared at all) in the vertex +// shader. +// +// - A reference to a function or variable name is unresolved. +// +// - A shared global is declared with two different types or two different +// initial values. +// +// - One or more of the attached shader objects has not been successfully +// compiled. +// +// - Binding a generic attribute matrix caused some rows of the matrix to +// fall outside the allowed maximum of GL.MAX_VERTEX_ATTRIBS. +// +// - Not enough contiguous vertex attribute slots could be found to bind +// attribute matrices. +// +// When a program object has been successfully linked, the program object can +// be made part of current state by calling UseProgram. Whether or not the +// link operation was successful, the program object's information log will +// be overwritten. The information log can be retrieved by calling +// GetProgramInfoLog. +// +// LinkProgram will also install the generated executables as part of the +// current rendering state if the link operation was successful and the +// specified program object is already currently in use as a result of a +// previous call to UseProgram. If the program object currently in use is +// relinked unsuccessfully, its link status will be set to GL.FALSE , but the +// executables and associated state will remain part of the current state +// until a subsequent call to UseProgram removes it from use. After it is +// removed from use, it cannot be made part of current state until it has +// been successfully relinked. +// +// If program contains shader objects of type GL.VERTEX_SHADER but does not +// contain shader objects of type GL.FRAGMENT_SHADER, the vertex shader will +// be linked against the implicit interface for fixed functionality fragment +// processing. Similarly, if program contains shader objects of type +// GL.FRAGMENT_SHADER but it does not contain shader objects of type +// GL.VERTEX_SHADER, the fragment shader will be linked against the implicit +// interface for fixed functionality vertex processing. +// +// The program object's information log is updated and the program is +// generated at the time of the link operation. After the link operation, +// applications are free to modify attached shader objects, compile attached +// shader objects, detach shader objects, delete shader objects, and attach +// additional shader objects. None of these operations affects the +// information log or the program that is part of the program object. +// +// If the link operation is unsuccessful, any information about a previous +// link operation on program is lost (a failed link does not restore the +// old state of program). Certain information can still be retrieved +// from program even after an unsuccessful link operation. See for instance +// GetActiveAttrib and GetActiveUniform. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if LinkProgram is executed +// between the execution of Begin and the corresponding execution of End. +// +// LinkProgram is available in GL version 2.0 or greater. +func (gl *GL) LinkProgram(program glbase.Program) { + C.gl3_0_glLinkProgram(gl.funcs, C.GLuint(program)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsShader.xml +func (gl *GL) IsShader(shader glbase.Shader) bool { + glresult := C.gl3_0_glIsShader(gl.funcs, C.GLuint(shader)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsProgram.xml +func (gl *GL) IsProgram(program glbase.Program) bool { + glresult := C.gl3_0_glIsProgram(gl.funcs, C.GLuint(program)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GetVertexAttribiv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribiv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribiv(index glbase.Attrib, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl3_0_glGetVertexAttribiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetVertexAttribfv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribfv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribfv(index glbase.Attrib, pname glbase.Enum, params []float32) { + var params_c [4]float32 + C.gl3_0_glGetVertexAttribfv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetVertexAttribdv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribdv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribdv(index glbase.Attrib, pname glbase.Enum, params []float64) { + var params_c [4]float64 + C.gl3_0_glGetVertexAttribdv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformiv returns in params the value of the specified uniform +// variable. The type of the uniform variable specified by location +// determines the number of values returned. If the uniform variable is +// defined in the shader as a boolean, int, or float, a single value will be +// returned. If it is defined as a vec2, ivec2, or bvec2, two values will be +// returned. If it is defined as a vec3, ivec3, or bvec3, three values will +// be returned, and so on. To query values stored in uniform variables +// declared as arrays, call GetUniformiv for each element of the array. To +// query values stored in uniform variables declared as structures, call +// GetUniformiv for each field in the structure. The values for uniform +// variables declared as a matrix will be returned in column major order. +// +// The locations assigned to uniform variables are not known until the +// program object is linked. After linking has occurred, the command +// GetUniformLocation can be used to obtain the location of a uniform +// variable. This location value can then be passed to GetUniformiv in order +// to query the current value of the uniform variable. After a program object +// has been linked successfully, the index values for uniform variables +// remain fixed until the next link command occurs. The uniform variable +// values can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if program has not been +// successfully linked. GL.INVALID_OPERATION is generated if location does +// not correspond to a valid uniform variable location for the specified +// program object. GL.INVALID_OPERATION is generated if GetUniformiv is +// executed between the execution of Begin and the corresponding execution of +// End. +// +// GetUniformiv is available in GL version 2.0 or greater. +func (gl *GL) GetUniformiv(program glbase.Program, location glbase.Uniform, params []int32) { + var params_c [4]int32 + C.gl3_0_glGetUniformiv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformfv returns in params the value of the specified uniform +// variable. The type of the uniform variable specified by location +// determines the number of values returned. If the uniform variable is +// defined in the shader as a boolean, int, or float, a single value will be +// returned. If it is defined as a vec2, ivec2, or bvec2, two values will be +// returned. If it is defined as a vec3, ivec3, or bvec3, three values will +// be returned, and so on. To query values stored in uniform variables +// declared as arrays, call GetUniformfv for each element of the array. To +// query values stored in uniform variables declared as structures, call +// GetUniformfv for each field in the structure. The values for uniform +// variables declared as a matrix will be returned in column major order. +// +// The locations assigned to uniform variables are not known until the +// program object is linked. After linking has occurred, the command +// GetUniformLocation can be used to obtain the location of a uniform +// variable. This location value can then be passed to GetUniformfv in order +// to query the current value of the uniform variable. After a program object +// has been linked successfully, the index values for uniform variables +// remain fixed until the next link command occurs. The uniform variable +// values can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if program has not been +// successfully linked. GL.INVALID_OPERATION is generated if location does +// not correspond to a valid uniform variable location for the specified +// program object. GL.INVALID_OPERATION is generated if GetUniformfv is +// executed between the execution of Begin and the corresponding execution of +// End. +// +// GetUniformfv is available in GL version 2.0 or greater. +func (gl *GL) GetUniformfv(program glbase.Program, location glbase.Uniform, params []float32) { + var params_c [4]float32 + C.gl3_0_glGetUniformfv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLfloat)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformLocation returns an integer that represents the location of a +// specific uniform variable within a program object. name must be an active +// uniform variable name in program that is not a structure, an array of +// structures, or a subcomponent of a vector or a matrix. This function +// returns -1 if name does not correspond to an active uniform variable in +// program or if name starts with the reserved prefix "gl_". +// +// Uniform variables that are structures or arrays of structures may be +// queried by calling GetUniformLocation for each field within the +// structure. The array element operator "[]" and the structure field +// operator "." may be used in name in order to select elements within an +// array or fields within a structure. The result of using these operators is +// not allowed to be another structure, an array of structures, or a +// subcomponent of a vector or a matrix. Except if the last part of name +// indicates a uniform variable array, the location of the first element of +// an array can be retrieved by using the name of the array, or by using the +// name appended by "[0]". +// +// The actual locations assigned to uniform variables are not known until the +// program object is linked successfully. After linking has occurred, the +// command GetUniformLocation can be used to obtain the location of a +// uniform variable. This location value can then be passed to Uniform to +// set the value of the uniform variable or to GetUniform in order to query +// the current value of the uniform variable. After a program object has been +// linked successfully, the index values for uniform variables remain fixed +// until the next link command occurs. Uniform variable locations and values +// can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program object. +// GL.INVALID_OPERATION is generated if program has not been successfully +// linked. GL.INVALID_OPERATION is generated if GetUniformLocation is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetUniformLocation is available in GL version 2.0 or greater. +func (gl *GL) GetUniformLocation(program glbase.Program, name string) glbase.Uniform { + name_cstr := C.CString(name) + glresult := C.gl3_0_glGetUniformLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) + return glbase.Uniform(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetShaderSource.xml +func (gl *GL) GetShaderSource(shader glbase.Shader, bufSize int32, length []int32, source []byte) { + C.gl3_0_glGetShaderSource(gl.funcs, C.GLuint(shader), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&source[0]))) +} + +// GetShaderInfoLog returns the information log for the specified shader +// object. The information log for a shader object is modified when the +// shader is compiled. +// +// The information log for a shader object is a string that may contain +// diagnostic messages, warning messages, and other information about the +// last compile operation. When a shader object is created, its information +// log will be a string of length 0, and the size of the current log can be +// obtained by calling GetShaderiv with the value GL.INFO_LOG_LENGTH. +// +// The information log for a shader object is the OpenGL implementer's +// primary mechanism for conveying information about the compilation process. +// Therefore, the information log can be helpful to application developers +// during the development process, even when compilation is successful. +// Application developers should not expect different OpenGL implementations +// to produce identical information logs. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_VALUE is generated if maxLength is less than 0. +// GL.INVALID_OPERATION is generated if GetShaderInfoLog is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetShaderInfoLog is available in GL version 2.0 or greater. +func (gl *GL) GetShaderInfoLog(shader glbase.Shader) []byte { + var params [1]int32 + var length int32 + gl.GetShaderiv(shader, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + C.gl3_0_glGetShaderInfoLog(gl.funcs, C.GLuint(shader), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length)), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) + return infoLog +} + +// GetShaderiv GetShader returns in params the value of a parameter for a specific +// shader object. The following parameters are defined: +// +// GL.SHADER_TYPE +// params returns GL.VERTEX_SHADER if shader is a vertex shader object, +// and GL.FRAGMENT_SHADER if shader is a fragment shader object. +// +// GL.DELETE_STATUS +// params returns GL.TRUE if shader is currently flagged for deletion, +// and GL.FALSE otherwise. +// +// GL.COMPILE_STATUS +// params returns GL.TRUE if the last compile operation on shader was +// successful, and GL.FALSE otherwise. +// +// GL.INFO_LOG_LENGTH +// params returns the number of characters in the information log for +// shader including the null termination character (the size of the +// character buffer required to store the information log). If shader has +// no information log, a value of 0 is returned. +// +// GL.SHADER_SOURCE_LENGTH +// params returns the length of the concatenation of the source strings +// that make up the shader source for the shader, including the null +// termination character. (the size of the character buffer +// required to store the shader source). If no source code exists, 0 is +// returned. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader does not refer to a +// shader object. GL.INVALID_ENUM is generated if pname is not an accepted +// value. GL.INVALID_OPERATION is generated if GetShader is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetShaderiv is available in GL version 2.0 or greater. +func (gl *GL) GetShaderiv(shader glbase.Shader, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl3_0_glGetShaderiv(gl.funcs, C.GLuint(shader), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetProgramInfoLog returns the information log for the specified program +// object. The information log for a program object is modified when the +// program object is linked or validated. +// +// The information log for a program object is either an empty string, or a +// string containing information about the last link operation, or a string +// containing information about the last validation operation. It may contain +// diagnostic messages, warning messages, and other information. When a +// program object is created, its information log will be a string of length +// 0, and the size of the current log can be obtained by calling GetProgramiv +// with the value GL.INFO_LOG_LENGTH. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated +// by OpenGL. GL.INVALID_OPERATION is generated if program is not a +// program object. +func (gl *GL) GetProgramInfoLog(program glbase.Program) []byte { + var params [1]int32 + var length int32 + gl.GetProgramiv(program, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + C.gl3_0_glGetProgramInfoLog(gl.funcs, C.GLuint(program), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length)), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) + return infoLog +} + +// GetProgramiv returns in params the value of a parameter for a specific +// program object. The following parameters are defined: +// +// GL.DELETE_STATUS +// params returns GL.TRUE if program is currently flagged for deletion, +// and GL.FALSE otherwise. +// +// GL.LINK_STATUS +// params returns GL.TRUE if the last link operation on program was +// successful, and GL.FALSE otherwise. +// +// GL.VALIDATE_STATUS +// params returns GL.TRUE or if the last validation operation on +// program was successful, and GL.FALSE otherwise. +// +// GL.INFO_LOG_LENGTH +// params returns the number of characters in the information log for +// program including the null termination character (the size of +// the character buffer required to store the information log). If +// program has no information log, a value of 0 is returned. +// +// GL.ATTACHED_SHADERS +// params returns the number of shader objects attached to program. +// +// GL.ACTIVE_ATTRIBUTES +// params returns the number of active attribute variables for program. +// +// GL.ACTIVE_ATTRIBUTE_MAX_LENGTH +// params returns the length of the longest active attribute name for +// program, including the null termination character (the size of +// the character buffer required to store the longest attribute name). +// If no active attributes exist, 0 is returned. +// +// GL.ACTIVE_UNIFORMS +// params returns the number of active uniform variables for program. +// +// GL.ACTIVE_UNIFORM_MAX_LENGTH +// params returns the length of the longest active uniform variable +// name for program, including the null termination character (i.e., +// the size of the character buffer required to store the longest +// uniform variable name). If no active uniform variables exist, 0 is +// returned. +// +// GL.TRANSFORM_FEEDBACK_BUFFER_MODE +// params returns a symbolic constant indicating the buffer mode used +// when transform feedback is active. This may be GL.SEPARATE_ATTRIBS +// or GL.INTERLEAVED_ATTRIBS. +// +// GL.TRANSFORM_FEEDBACK_VARYINGS +// params returns the number of varying variables to capture in transform +// feedback mode for the program. +// +// GL.TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH +// params returns the length of the longest variable name to be used for +// transform feedback, including the null-terminator. +// +// GL.GEOMETRY_VERTICES_OUT +// params returns the maximum number of vertices that the geometry shader in +// program will output. +// +// GL.GEOMETRY_INPUT_TYPE +// params returns a symbolic constant indicating the primitive type accepted +// as input to the geometry shader contained in program. +// +// GL.GEOMETRY_OUTPUT_TYPE +// params returns a symbolic constant indicating the primitive type that will +// be output by the geometry shader contained in program. +// +// GL.ACTIVE_UNIFORM_BLOCKS and GL.ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH are +// available only if the GL version 3.1 or greater. +// +// GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE and +// GL.GEOMETRY_OUTPUT_TYPE are accepted only if the GL version is 3.2 or +// greater. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program does not refer to a +// program object. GL.INVALID_OPERATION is generated if pname is +// GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE, or +// GL.GEOMETRY_OUTPUT_TYPE, and program does not contain a geometry shader. +// GL.INVALID_ENUM is generated if pname is not an accepted value. +func (gl *GL) GetProgramiv(program glbase.Program, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl3_0_glGetProgramiv(gl.funcs, C.GLuint(program), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetAttribLocation queries the previously linked program object specified +// by program for the attribute variable specified by name and returns the +// index of the generic vertex attribute that is bound to that attribute +// variable. If name is a matrix attribute variable, the index of the first +// column of the matrix is returned. If the named attribute variable is not +// an active attribute in the specified program object or if name starts with +// the reserved prefix "gl_", a value of -1 is returned. +// +// The association between an attribute variable name and a generic attribute +// index can be specified at any time by calling BindAttribLocation. +// Attribute bindings do not go into effect until LinkProgram is called. +// After a program object has been linked successfully, the index values for +// attribute variables remain fixed until the next link command occurs. The +// attribute values can only be queried after a link if the link was +// successful. GetAttribLocation returns the binding that actually went +// into effect the last time LinkProgram was called for the specified +// program object. Attribute bindings that have been specified since the last +// link operation are not returned by GetAttribLocation. +// +// Error GL_INVALID_OPERATION is generated if program is not a value +// generated by OpenGL. GL_INVALID_OPERATION is generated if program is not +// a program object. GL_INVALID_OPERATION is generated if program has not +// been successfully linked. GL_INVALID_OPERATION is generated if +// GetAttribLocation is executed between the execution of Begin and the +// corresponding execution of End. +// +// GetAttribLocation is available in GL version 2.0 or greater. +func (gl *GL) GetAttribLocation(program glbase.Program, name string) glbase.Attrib { + name_cstr := C.CString(name) + glresult := C.gl3_0_glGetAttribLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) + return glbase.Attrib(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetAttachedShaders.xml +func (gl *GL) GetAttachedShaders(program glbase.Program, maxCount int32, count []int, obj []uint32) { + C.gl3_0_glGetAttachedShaders(gl.funcs, C.GLuint(program), C.GLsizei(maxCount), (*C.GLsizei)(unsafe.Pointer(&count[0])), (*C.GLuint)(unsafe.Pointer(&obj[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetActiveUniform.xml +func (gl *GL) GetActiveUniform(program glbase.Program, index uint32, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl3_0_glGetActiveUniform(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetActiveAttrib.xml +func (gl *GL) GetActiveAttrib(program glbase.Program, index glbase.Attrib, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl3_0_glGetActiveAttrib(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEnableVertexAttribArray.xml +func (gl *GL) EnableVertexAttribArray(index glbase.Attrib) { + C.gl3_0_glEnableVertexAttribArray(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDisableVertexAttribArray.xml +func (gl *GL) DisableVertexAttribArray(index glbase.Attrib) { + C.gl3_0_glDisableVertexAttribArray(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDetachShader.xml +func (gl *GL) DetachShader(program glbase.Program, shader glbase.Shader) { + C.gl3_0_glDetachShader(gl.funcs, C.GLuint(program), C.GLuint(shader)) +} + +// DeleteShader frees the memory and invalidates the name associated with +// the shader object specified by shader. This command effectively undoes the +// effects of a call to CreateShader. +// +// If a shader object to be deleted is attached to a program object, it will +// be flagged for deletion, but it will not be deleted until it is no longer +// attached to any program object, for any rendering context (it must +// be detached from wherever it was attached before it will be deleted). A +// value of 0 for shader will be silently ignored. +// +// To determine whether an object has been flagged for deletion, call +// GetShader with arguments shader and GL.DELETE_STATUS. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. +// +// DeleteShader is available in GL version 2.0 or greater. +func (gl *GL) DeleteShader(shader glbase.Shader) { + C.gl3_0_glDeleteShader(gl.funcs, C.GLuint(shader)) +} + +// DeleteProgram frees the memory and invalidates the name associated with +// the program object specified by program. This command effectively undoes +// the effects of a call to CreateProgram. +// +// If a program object is in use as part of current rendering state, it will +// be flagged for deletion, but it will not be deleted until it is no longer +// part of current state for any rendering context. If a program object to be +// deleted has shader objects attached to it, those shader objects will be +// automatically detached but not deleted unless they have already been +// flagged for deletion by a previous call to DeleteShader. A value of 0 +// for program will be silently ignored. +// +// To determine whether a program object has been flagged for deletion, call +// GetProgram with arguments program and GL.DELETE_STATUS. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. +// +// DeleteProgram is available in GL version 2.0 or greater. +func (gl *GL) DeleteProgram(program glbase.Program) { + C.gl3_0_glDeleteProgram(gl.funcs, C.GLuint(program)) +} + +// CreateShader creates an empty shader object and returns a non-zero value +// by which it can be referenced. A shader object is used to maintain the +// source code strings that define a shader. shaderType indicates the type of +// shader to be created. +// +// Two types of shaders are supported. A shader of type GL.VERTEX_SHADER is a +// shader that is intended to run on the programmable vertex processor and +// replace the fixed functionality vertex processing in OpenGL. A shader of +// type GL.FRAGMENT_SHADER is a shader that is intended to run on the +// programmable fragment processor and replace the fixed functionality +// fragment processing in OpenGL. +// +// When created, a shader object's GL.SHADER_TYPE parameter is set to either +// GL.VERTEX_SHADER or GL.FRAGMENT_SHADER, depending on the value of +// shaderType. +// +// Like display lists and texture objects, the name space for shader objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// This function returns 0 if an error occurs creating the shader object. +// +// Error GL.INVALID_ENUM is generated if shaderType is not an accepted value. +// GL.INVALID_OPERATION is generated if CreateShader is executed between the +// execution of Begin and the corresponding execution of End. +// +// CreateShader is available in GL version 2.0 or greater. +func (gl *GL) CreateShader(gltype glbase.Enum) glbase.Shader { + glresult := C.gl3_0_glCreateShader(gl.funcs, C.GLenum(gltype)) + return glbase.Shader(glresult) +} + +// CreateProgram creates an empty program object and returns a non-zero +// value by which it can be referenced. A program object is an object to +// which shader objects can be attached. This provides a mechanism to specify +// the shader objects that will be linked to create a program. It also +// provides a means for checking the compatibility of the shaders that will +// be used to create a program (for instance, checking the compatibility +// between a vertex shader and a fragment shader). When no longer needed as +// part of a program object, shader objects can be detached. +// +// One or more executables are created in a program object by successfully +// attaching shader objects to it with AttachShader, successfully compiling +// the shader objects with CompileShader, and successfully linking the +// program object with LinkProgram. These executables are made part of +// current state when UseProgram is called. Program objects can be deleted +// by calling DeleteProgram. The memory associated with the program object +// will be deleted when it is no longer part of current rendering state for +// any context. +// +// Like display lists and texture objects, the name space for program objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// Applications are responsible for providing the synchronization across API +// calls when objects are accessed from different execution threads. +// +// This function returns 0 if an error occurs creating the program object. +// +// Error GL.INVALID_OPERATION is generated if CreateProgram is executed +// between the execution of Begin and the corresponding execution of End. +// +// CreateProgram is available in GL version 2.0 or greater. +func (gl *GL) CreateProgram() glbase.Program { + glresult := C.gl3_0_glCreateProgram(gl.funcs) + return glbase.Program(glresult) +} + +// CompileShader compiles the source code strings that have been stored in +// the shader object specified by shader. +// +// The compilation status will be stored as part of the shader object's +// state. This value will be set to GL.TRUE if the shader was compiled without +// errors and is ready for use, and GL.FALSE otherwise. It can be queried by +// calling GetShaderiv with arguments shader and GL.COMPILE_STATUS. +// +// Compilation of a shader can fail for a number of reasons as specified by +// the OpenGL Shading Language Specification. Whether or not the compilation +// was successful, information about the compilation can be obtained from the +// shader object's information log by calling GetShaderInfoLog. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_OPERATION is generated if CompileShader is executed +// between the execution of Begin and the corresponding execution of End. +// +// CompileShader is available in GL version 2.0 or greater. +func (gl *GL) CompileShader(shader glbase.Shader) { + C.gl3_0_glCompileShader(gl.funcs, C.GLuint(shader)) +} + +// BindAttribLocation associates a user-defined attribute variable in the program +// object specified by program with a generic vertex attribute index. The name +// parameter specifies the name of the vertex shader attribute variable to +// which index is to be bound. When program is made part of the current state, +// values provided via the generic vertex attribute index will modify the +// value of the user-defined attribute variable specified by name. +// +// If name refers to a matrix attribute variable, index refers to the first +// column of the matrix. Other matrix columns are then automatically bound to +// locations index+1 for a matrix of type mat2; index+1 and index+2 for a +// matrix of type mat3; and index+1, index+2, and index+3 for a matrix of +// type mat4. +// +// This command makes it possible for vertex shaders to use descriptive names +// for attribute variables rather than generic variables that are numbered +// from 0 to GL.MAX_VERTEX_ATTRIBS-1. The values sent to each generic +// attribute index are part of current state, just like standard vertex +// attributes such as color, normal, and vertex position. If a different +// program object is made current by calling UseProgram, the generic vertex +// attributes are tracked in such a way that the same values will be observed +// by attributes in the new program object that are also bound to index. +// +// Attribute variable name-to-generic attribute index bindings for a program +// object can be explicitly assigned at any time by calling +// BindAttribLocation. Attribute bindings do not go into effect until +// LinkProgram is called. After a program object has been linked +// successfully, the index values for generic attributes remain fixed (and +// their values can be queried) until the next link command occurs. +// +// Applications are not allowed to bind any of the standard OpenGL vertex +// attributes using this command, as they are bound automatically when +// needed. Any attribute binding that occurs after the program object has +// been linked will not take effect until the next time the program object is +// linked. +// +// If name was bound previously, that information is lost. Thus you cannot +// bind one user-defined attribute variable to multiple indices, but you can +// bind multiple user-defined attribute variables to the same index. +// +// Applications are allowed to bind more than one user-defined attribute +// variable to the same generic vertex attribute index. This is called +// aliasing, and it is allowed only if just one of the aliased attributes is +// active in the executable program, or if no path through the shader +// consumes more than one attribute of a set of attributes aliased to the +// same location. The compiler and linker are allowed to assume that no +// aliasing is done and are free to employ optimizations that work only in +// the absence of aliasing. OpenGL implementations are not required to do +// error checking to detect aliasing. Because there is no way to bind +// standard attributes, it is not possible to alias generic attributes with +// conventional ones (except for generic attribute 0). +// +// BindAttribLocation can be called before any vertex shader objects are +// bound to the specified program object. It is also permissible to bind a +// generic attribute index to an attribute variable name that is never used +// in a vertex shader. +// +// Active attributes that are not explicitly bound will be bound by the +// linker when LinkProgram is called. The locations assigned can be queried +// by calling GetAttribLocation. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. +// GL.INVALID_OPERATION is generated if name starts with the reserved prefix "gl_". +// GL.INVALID_VALUE is generated if program is not a value generated by OpenGL. +// GL.INVALID_OPERATION is generated if program is not a program object. +// GL.INVALID_OPERATION is generated if BindAttribLocation is executed +// between the execution of Begin and the corresponding execution of End. +// +// BindAttribLocation is available in GL version 2.0 or greater. +func (gl *GL) BindAttribLocation(program glbase.Program, index glbase.Attrib, name string) { + name_cstr := C.CString(name) + C.gl3_0_glBindAttribLocation(gl.funcs, C.GLuint(program), C.GLuint(index), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) +} + +// AttachShader attaches a shader object to a program object. +// +// In order to create an executable, there must be a way to specify the list +// of things that will be linked together. Program objects provide this +// mechanism. Shaders that are to be linked together in a program object must +// first be attached to that program object. This indicates that shader will +// be included in link operations that will be performed on program. +// +// All operations that can be performed on a shader object are valid whether +// or not the shader object is attached to a program object. It is +// permissible to attach a shader object to a program object before source +// code has been loaded into the shader object or before the shader object +// has been compiled. It is permissible to attach multiple shader objects of +// the same type because each may contain a portion of the complete shader. +// It is also permissible to attach a shader object to more than one program +// object. If a shader object is deleted while it is attached to a program +// object, it will be flagged for deletion, and deletion will not occur until +// DetachShader is called to detach it from all program objects to which it +// is attached. +// +// Error GL.INVALID_VALUE is generated if either program or shader is not a +// value generated by OpenGL. GL.INVALID_OPERATION is generated if program +// is not a program object. GL.INVALID_OPERATION is generated if shader is +// not a shader object. GL.INVALID_OPERATION is generated if shader is +// already attached to program. GL.INVALID_OPERATION is generated if +// AttachShader is executed between the execution of Begin and the +// corresponding execution of End. +// +// AttachShader is available in GL version 2.0 or greater. +func (gl *GL) AttachShader(program glbase.Program, shader glbase.Shader) { + C.gl3_0_glAttachShader(gl.funcs, C.GLuint(program), C.GLuint(shader)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilMaskSeparate.xml +func (gl *GL) StencilMaskSeparate(face glbase.Enum, mask uint32) { + C.gl3_0_glStencilMaskSeparate(gl.funcs, C.GLenum(face), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilFuncSeparate.xml +func (gl *GL) StencilFuncSeparate(face, glfunc glbase.Enum, ref int32, mask uint32) { + C.gl3_0_glStencilFuncSeparate(gl.funcs, C.GLenum(face), C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilOpSeparate.xml +func (gl *GL) StencilOpSeparate(face, sfail, dpfail, dppass glbase.Enum) { + C.gl3_0_glStencilOpSeparate(gl.funcs, C.GLenum(face), C.GLenum(sfail), C.GLenum(dpfail), C.GLenum(dppass)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawBuffers.xml +func (gl *GL) DrawBuffers(n int, bufs []glbase.Enum) { + C.gl3_0_glDrawBuffers(gl.funcs, C.GLsizei(n), (*C.GLenum)(unsafe.Pointer(&bufs[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlendEquationSeparate.xml +func (gl *GL) BlendEquationSeparate(modeRGB, modeAlpha glbase.Enum) { + C.gl3_0_glBlendEquationSeparate(gl.funcs, C.GLenum(modeRGB), C.GLenum(modeAlpha)) +} + +// UniformMatrix4x3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4x3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4x3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*3) != 0 { + panic("invalid value length for UniformMatrix4x3fv") + } + count := len(value) / (4 * 3) + C.gl3_0_glUniformMatrix4x3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3x4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3x4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3x4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*4) != 0 { + panic("invalid value length for UniformMatrix3x4fv") + } + count := len(value) / (3 * 4) + C.gl3_0_glUniformMatrix3x4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix4x2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4x2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4x2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*2) != 0 { + panic("invalid value length for UniformMatrix4x2fv") + } + count := len(value) / (4 * 2) + C.gl3_0_glUniformMatrix4x2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2x4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2x4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2x4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*4) != 0 { + panic("invalid value length for UniformMatrix2x4fv") + } + count := len(value) / (2 * 4) + C.gl3_0_glUniformMatrix2x4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3x2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3x2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3x2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*2) != 0 { + panic("invalid value length for UniformMatrix3x2fv") + } + count := len(value) / (3 * 2) + C.gl3_0_glUniformMatrix3x2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2x3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2x3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2x3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*3) != 0 { + panic("invalid value length for UniformMatrix2x3fv") + } + count := len(value) / (2 * 3) + C.gl3_0_glUniformMatrix2x3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsVertexArray.xml +func (gl *GL) IsVertexArray(array uint32) bool { + glresult := C.gl3_0_glIsVertexArray(gl.funcs, C.GLuint(array)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGenVertexArrays.xml +func (gl *GL) GenVertexArrays(n int, arrays []uint32) { + C.gl3_0_glGenVertexArrays(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&arrays[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDeleteVertexArrays.xml +func (gl *GL) DeleteVertexArrays(n int, arrays []uint32) { + C.gl3_0_glDeleteVertexArrays(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&arrays[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindVertexArray.xml +func (gl *GL) BindVertexArray(array uint32) { + C.gl3_0_glBindVertexArray(gl.funcs, C.GLuint(array)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFlushMappedBufferRange.xml +func (gl *GL) FlushMappedBufferRange(target glbase.Enum, offset, length int) { + C.gl3_0_glFlushMappedBufferRange(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(length)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFramebufferTextureLayer.xml +func (gl *GL) FramebufferTextureLayer(target, attachment glbase.Enum, texture glbase.Texture, level int, layer int32) { + C.gl3_0_glFramebufferTextureLayer(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLuint(texture), C.GLint(level), C.GLint(layer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRenderbufferStorageMultisample.xml +func (gl *GL) RenderbufferStorageMultisample(target glbase.Enum, samples int32, internalFormat glbase.Enum, width, height int) { + C.gl3_0_glRenderbufferStorageMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlitFramebuffer.xml +func (gl *GL) BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1 int32, mask glbase.Bitfield, filter glbase.Enum) { + C.gl3_0_glBlitFramebuffer(gl.funcs, C.GLint(srcX0), C.GLint(srcY0), C.GLint(srcX1), C.GLint(srcY1), C.GLint(dstX0), C.GLint(dstY0), C.GLint(dstX1), C.GLint(dstY1), C.GLbitfield(mask), C.GLenum(filter)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGenerateMipmap.xml +func (gl *GL) GenerateMipmap(target glbase.Enum) { + C.gl3_0_glGenerateMipmap(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetFramebufferAttachmentParameteriv.xml +func (gl *GL) GetFramebufferAttachmentParameteriv(target, attachment, pname glbase.Enum, params []int32) { + C.gl3_0_glGetFramebufferAttachmentParameteriv(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFramebufferRenderbuffer.xml +func (gl *GL) FramebufferRenderbuffer(target, attachment, renderbuffertarget glbase.Enum, renderbuffer glbase.Renderbuffer) { + C.gl3_0_glFramebufferRenderbuffer(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(renderbuffertarget), C.GLuint(renderbuffer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFramebufferTexture3D.xml +func (gl *GL) FramebufferTexture3D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int, zoffset int32) { + C.gl3_0_glFramebufferTexture3D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level), C.GLint(zoffset)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFramebufferTexture2D.xml +func (gl *GL) FramebufferTexture2D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int) { + C.gl3_0_glFramebufferTexture2D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFramebufferTexture1D.xml +func (gl *GL) FramebufferTexture1D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int) { + C.gl3_0_glFramebufferTexture1D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCheckFramebufferStatus.xml +func (gl *GL) CheckFramebufferStatus(target glbase.Enum) glbase.Enum { + glresult := C.gl3_0_glCheckFramebufferStatus(gl.funcs, C.GLenum(target)) + return glbase.Enum(glresult) +} + +// GenFramebuffers returns n framebuffer object names in ids. There is no +// guarantee that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenFramebuffers. +// +// Framebuffer object names returned by a call to GenFramebuffers are not +// returned by subsequent calls, unless they are first deleted with +// DeleteFramebuffers. +// +// The names returned in ids are marked as used, for the purposes of +// GenFramebuffers only, but they acquire state and type only when they are +// first bound. +// +// Error GL.INVALID_VALUE is generated if n is negative. +func (gl *GL) GenFramebuffers(n int) []glbase.Framebuffer { + if n == 0 { + return nil + } + framebuffers := make([]glbase.Framebuffer, n) + C.gl3_0_glGenFramebuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&framebuffers[0]))) + return framebuffers +} + +// DeleteFramebuffers deletes the framebuffer objects whose names are +// stored in the framebuffers slice. The name zero is reserved by the GL and +// is silently ignored, should it occur in framebuffers, as are other unused +// names. Once a framebuffer object is deleted, its name is again unused and +// it has no attachments. If a framebuffer that is currently bound to one or +// more of the targets GL.DRAW_FRAMEBUFFER or GL.READ_FRAMEBUFFER is deleted, +// it is as though BindFramebuffer had been executed with the corresponding +// target and framebuffer zero. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteFramebuffers is available in GL version 3.0 or greater. +func (gl *GL) DeleteFramebuffers(framebuffers []glbase.Framebuffer) { + n := len(framebuffers) + if n == 0 { + return + } + C.gl3_0_glDeleteFramebuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&framebuffers[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindFramebuffer.xml +func (gl *GL) BindFramebuffer(target glbase.Enum, framebuffer glbase.Framebuffer) { + C.gl3_0_glBindFramebuffer(gl.funcs, C.GLenum(target), C.GLuint(framebuffer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsFramebuffer.xml +func (gl *GL) IsFramebuffer(framebuffer glbase.Framebuffer) bool { + glresult := C.gl3_0_glIsFramebuffer(gl.funcs, C.GLuint(framebuffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetRenderbufferParameteriv.xml +func (gl *GL) GetRenderbufferParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_0_glGetRenderbufferParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRenderbufferStorage.xml +func (gl *GL) RenderbufferStorage(target, internalFormat glbase.Enum, width, height int) { + C.gl3_0_glRenderbufferStorage(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) +} + +// GenRenderbuffers returns n renderbuffer object names in renderbuffers. +// There is no guarantee that the names form a contiguous set of integers; +// however, it is guaranteed that none of the returned names was in use +// immediately before the call to GenRenderbuffers. +// +// Renderbuffer object names returned by a call to GenRenderbuffers are not +// returned by subsequent calls, unless they are first deleted with +// DeleteRenderbuffers. +// +// The names returned in renderbuffers are marked as used, for the purposes +// of GenRenderbuffers only, but they acquire state and type only when they +// are first bound. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenRenderbuffers is available in GL version 3.0 or greater. +func (gl *GL) GenRenderbuffers(n int) []glbase.Renderbuffer { + if n == 0 { + return nil + } + renderbuffers := make([]glbase.Renderbuffer, n) + C.gl3_0_glGenRenderbuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&renderbuffers[0]))) + return renderbuffers +} + +// DeleteRenderbuffers deletes the renderbuffer objects whose names are stored +// in the renderbuffers slice. The name zero is reserved by the GL and +// is silently ignored, should it occur in renderbuffers, as are other unused +// names. Once a renderbuffer object is deleted, its name is again unused and +// it has no contents. If a renderbuffer that is currently bound to the +// target GL.RENDERBUFFER is deleted, it is as though BindRenderbuffer had +// been executed with a target of GL.RENDERBUFFER and a name of zero. +// +// If a renderbuffer object is attached to one or more attachment points in +// the currently bound framebuffer, then it as if FramebufferRenderbuffer +// had been called, with a renderbuffer of zero for each attachment point to +// which this image was attached in the currently bound framebuffer. In other +// words, this renderbuffer object is first detached from all attachment +// ponits in the currently bound framebuffer. Note that the renderbuffer +// image is specifically not detached from any non-bound framebuffers. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteRenderbuffers is available in GL version 3.0 or greater. +func (gl *GL) DeleteRenderbuffers(renderbuffers []glbase.Renderbuffer) { + n := len(renderbuffers) + if n == 0 { + return + } + C.gl3_0_glDeleteRenderbuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&renderbuffers[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindRenderbuffer.xml +func (gl *GL) BindRenderbuffer(target glbase.Enum, renderbuffer glbase.Renderbuffer) { + C.gl3_0_glBindRenderbuffer(gl.funcs, C.GLenum(target), C.GLuint(renderbuffer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsRenderbuffer.xml +func (gl *GL) IsRenderbuffer(renderbuffer glbase.Renderbuffer) bool { + glresult := C.gl3_0_glIsRenderbuffer(gl.funcs, C.GLuint(renderbuffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearBufferfi.xml +func (gl *GL) ClearBufferfi(buffer glbase.Enum, drawbuffer int32, depth float32, stencil int32) { + C.gl3_0_glClearBufferfi(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), C.GLfloat(depth), C.GLint(stencil)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearBufferfv.xml +func (gl *GL) ClearBufferfv(buffer glbase.Enum, drawbuffer int32, value []float32) { + C.gl3_0_glClearBufferfv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearBufferuiv.xml +func (gl *GL) ClearBufferuiv(buffer glbase.Enum, drawbuffer int32, value []uint32) { + C.gl3_0_glClearBufferuiv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearBufferiv.xml +func (gl *GL) ClearBufferiv(buffer glbase.Enum, drawbuffer int32, value []int32) { + C.gl3_0_glClearBufferiv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexParameterIuiv.xml +func (gl *GL) GetTexParameterIuiv(target, pname glbase.Enum, params []uint32) { + C.gl3_0_glGetTexParameterIuiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexParameterIiv.xml +func (gl *GL) GetTexParameterIiv(target, pname glbase.Enum, params []int32) { + C.gl3_0_glGetTexParameterIiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameterIuiv.xml +func (gl *GL) TexParameterIuiv(target, pname glbase.Enum, params []uint32) { + C.gl3_0_glTexParameterIuiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameterIiv.xml +func (gl *GL) TexParameterIiv(target, pname glbase.Enum, params []int32) { + C.gl3_0_glTexParameterIiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// Uniform4uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4uiv") + } + count := len(value) / 4 + C.gl3_0_glUniform4uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform3uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3uiv") + } + count := len(value) / 3 + C.gl3_0_glUniform3uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform2uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2uiv") + } + count := len(value) / 2 + C.gl3_0_glUniform2uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform1uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl3_0_glUniform1uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform4ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4ui(location glbase.Uniform, v0, v1, v2, v3 uint32) { + C.gl3_0_glUniform4ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2), C.GLuint(v3)) +} + +// Uniform3ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3ui(location glbase.Uniform, v0, v1, v2 uint32) { + C.gl3_0_glUniform3ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2)) +} + +// Uniform2ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2ui(location glbase.Uniform, v0, v1 uint32) { + C.gl3_0_glUniform2ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1)) +} + +// Uniform1ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1ui(location glbase.Uniform, v0 uint32) { + C.gl3_0_glUniform1ui(gl.funcs, C.GLint(location), C.GLuint(v0)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetFragDataLocation.xml +func (gl *GL) GetFragDataLocation(program glbase.Program, name []byte) int32 { + glresult := C.gl3_0_glGetFragDataLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindFragDataLocation.xml +func (gl *GL) BindFragDataLocation(program glbase.Program, color uint32, name []byte) { + C.gl3_0_glBindFragDataLocation(gl.funcs, C.GLuint(program), C.GLuint(color), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetUniformuiv.xml +func (gl *GL) GetUniformuiv(program glbase.Program, location glbase.Uniform, params []uint32) { + C.gl3_0_glGetUniformuiv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetVertexAttribIuiv.xml +func (gl *GL) GetVertexAttribIuiv(index glbase.Attrib, pname glbase.Enum, params []uint32) { + C.gl3_0_glGetVertexAttribIuiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetVertexAttribIiv.xml +func (gl *GL) GetVertexAttribIiv(index glbase.Attrib, pname glbase.Enum, params []int32) { + C.gl3_0_glGetVertexAttribIiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribIPointer.xml +func (gl *GL) VertexAttribIPointer(index glbase.Attrib, size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glVertexAttribIPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEndConditionalRender.xml +func (gl *GL) EndConditionalRender() { + C.gl3_0_glEndConditionalRender(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBeginConditionalRender.xml +func (gl *GL) BeginConditionalRender(id uint32, mode glbase.Enum) { + C.gl3_0_glBeginConditionalRender(gl.funcs, C.GLuint(id), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClampColor.xml +func (gl *GL) ClampColor(target, clamp glbase.Enum) { + C.gl3_0_glClampColor(gl.funcs, C.GLenum(target), C.GLenum(clamp)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTransformFeedbackVarying.xml +func (gl *GL) GetTransformFeedbackVarying(program glbase.Program, index uint32, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl3_0_glGetTransformFeedbackVarying(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLsizei)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindBufferBase.xml +func (gl *GL) BindBufferBase(target glbase.Enum, index uint32, buffer glbase.Buffer) { + C.gl3_0_glBindBufferBase(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindBufferRange.xml +func (gl *GL) BindBufferRange(target glbase.Enum, index uint32, buffer glbase.Buffer, offset, size int) { + C.gl3_0_glBindBufferRange(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(buffer), C.GLintptr(offset), C.GLsizeiptr(size)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEndTransformFeedback.xml +func (gl *GL) EndTransformFeedback() { + C.gl3_0_glEndTransformFeedback(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBeginTransformFeedback.xml +func (gl *GL) BeginTransformFeedback(primitiveMode glbase.Enum) { + C.gl3_0_glBeginTransformFeedback(gl.funcs, C.GLenum(primitiveMode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsEnabledi.xml +func (gl *GL) IsEnabledi(target glbase.Enum, index uint32) bool { + glresult := C.gl3_0_glIsEnabledi(gl.funcs, C.GLenum(target), C.GLuint(index)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDisablei.xml +func (gl *GL) Disablei(target glbase.Enum, index uint32) { + C.gl3_0_glDisablei(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEnablei.xml +func (gl *GL) Enablei(target glbase.Enum, index uint32) { + C.gl3_0_glEnablei(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetIntegeri_v.xml +func (gl *GL) GetIntegeri_v(target glbase.Enum, index uint32, data []int32) { + C.gl3_0_glGetIntegeri_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLint)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetBooleani_v.xml +func (gl *GL) GetBooleani_v(target glbase.Enum, index uint32, data []bool) { + C.gl3_0_glGetBooleani_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLboolean)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorMaski.xml +func (gl *GL) ColorMaski(index uint32, r, g, b, a bool) { + C.gl3_0_glColorMaski(gl.funcs, C.GLuint(index), *(*C.GLboolean)(unsafe.Pointer(&r)), *(*C.GLboolean)(unsafe.Pointer(&g)), *(*C.GLboolean)(unsafe.Pointer(&b)), *(*C.GLboolean)(unsafe.Pointer(&a))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTranslatef.xml +func (gl *GL) Translatef(x, y, z float32) { + C.gl3_0_glTranslatef(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTranslated.xml +func (gl *GL) Translated(x, y, z float64) { + C.gl3_0_glTranslated(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glScalef.xml +func (gl *GL) Scalef(x, y, z float32) { + C.gl3_0_glScalef(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glScaled.xml +func (gl *GL) Scaled(x, y, z float64) { + C.gl3_0_glScaled(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRotatef.xml +func (gl *GL) Rotatef(angle, x, y, z float32) { + C.gl3_0_glRotatef(gl.funcs, C.GLfloat(angle), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRotated.xml +func (gl *GL) Rotated(angle, x, y, z float64) { + C.gl3_0_glRotated(gl.funcs, C.GLdouble(angle), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPushMatrix.xml +func (gl *GL) PushMatrix() { + C.gl3_0_glPushMatrix(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPopMatrix.xml +func (gl *GL) PopMatrix() { + C.gl3_0_glPopMatrix(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glOrtho.xml +func (gl *GL) Ortho(left, right, bottom, top, zNear, zFar float64) { + C.gl3_0_glOrtho(gl.funcs, C.GLdouble(left), C.GLdouble(right), C.GLdouble(bottom), C.GLdouble(top), C.GLdouble(zNear), C.GLdouble(zFar)) +} + +// MultMatrixd multiplies the current matrix with the provided matrix. +// +// The m parameter must hold 16 consecutive elements of a 4x4 column-major matrix. +// +// The current matrix is determined by the current matrix mode (see +// MatrixMode). It is either the projection matrix, modelview matrix, or the +// texture matrix. +// +// For example, if the current matrix is C and the coordinates to be transformed +// are v = (v[0], v[1], v[2], v[3]), then the current transformation is C × v, or +// +// c[0] c[4] c[8] c[12] v[0] +// c[1] c[5] c[9] c[13] v[1] +// c[2] c[6] c[10] c[14] X v[2] +// c[3] c[7] c[11] c[15] v[3] +// +// Calling MultMatrix with an argument of m = m[0], m[1], ..., m[15] +// replaces the current transformation with (C X M) x v, or +// +// c[0] c[4] c[8] c[12] m[0] m[4] m[8] m[12] v[0] +// c[1] c[5] c[9] c[13] m[1] m[5] m[9] m[13] v[1] +// c[2] c[6] c[10] c[14] X m[2] m[6] m[10] m[14] X v[2] +// c[3] c[7] c[11] c[15] m[3] m[7] m[11] m[15] v[3] +// +// Where 'X' denotes matrix multiplication, and v is represented as a 4x1 matrix. +// +// While the elements of the matrix may be specified with single or double +// precision, the GL may store or operate on these values in less-than-single +// precision. +// +// In many computer languages, 4×4 arrays are represented in row-major +// order. The transformations just described represent these matrices in +// column-major order. The order of the multiplication is important. For +// example, if the current transformation is a rotation, and MultMatrix is +// called with a translation matrix, the translation is done directly on the +// coordinates to be transformed, while the rotation is done on the results +// of that translation. +// +// GL.INVALID_OPERATION is generated if MultMatrix is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) MultMatrixd(m []float64) { + if len(m) != 16 { + panic("parameter m must have length 16 for the 4x4 matrix") + } + C.gl3_0_glMultMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// MultMatrixf multiplies the current matrix with the provided matrix. +// +// The m parameter must hold 16 consecutive elements of a 4x4 column-major matrix. +// +// The current matrix is determined by the current matrix mode (see +// MatrixMode). It is either the projection matrix, modelview matrix, or the +// texture matrix. +// +// For example, if the current matrix is C and the coordinates to be transformed +// are v = (v[0], v[1], v[2], v[3]), then the current transformation is C × v, or +// +// c[0] c[4] c[8] c[12] v[0] +// c[1] c[5] c[9] c[13] v[1] +// c[2] c[6] c[10] c[14] X v[2] +// c[3] c[7] c[11] c[15] v[3] +// +// Calling MultMatrix with an argument of m = m[0], m[1], ..., m[15] +// replaces the current transformation with (C X M) x v, or +// +// c[0] c[4] c[8] c[12] m[0] m[4] m[8] m[12] v[0] +// c[1] c[5] c[9] c[13] m[1] m[5] m[9] m[13] v[1] +// c[2] c[6] c[10] c[14] X m[2] m[6] m[10] m[14] X v[2] +// c[3] c[7] c[11] c[15] m[3] m[7] m[11] m[15] v[3] +// +// Where 'X' denotes matrix multiplication, and v is represented as a 4x1 matrix. +// +// While the elements of the matrix may be specified with single or double +// precision, the GL may store or operate on these values in less-than-single +// precision. +// +// In many computer languages, 4×4 arrays are represented in row-major +// order. The transformations just described represent these matrices in +// column-major order. The order of the multiplication is important. For +// example, if the current transformation is a rotation, and MultMatrix is +// called with a translation matrix, the translation is done directly on the +// coordinates to be transformed, while the rotation is done on the results +// of that translation. +// +// GL.INVALID_OPERATION is generated if MultMatrix is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) MultMatrixf(m []float32) { + if len(m) != 16 { + panic("parameter m must have length 16 for the 4x4 matrix") + } + C.gl3_0_glMultMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMatrixMode.xml +func (gl *GL) MatrixMode(mode glbase.Enum) { + C.gl3_0_glMatrixMode(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLoadMatrixd.xml +func (gl *GL) LoadMatrixd(m []float64) { + C.gl3_0_glLoadMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLoadMatrixf.xml +func (gl *GL) LoadMatrixf(m []float32) { + C.gl3_0_glLoadMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLoadIdentity.xml +func (gl *GL) LoadIdentity() { + C.gl3_0_glLoadIdentity(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFrustum.xml +func (gl *GL) Frustum(left, right, bottom, top, zNear, zFar float64) { + C.gl3_0_glFrustum(gl.funcs, C.GLdouble(left), C.GLdouble(right), C.GLdouble(bottom), C.GLdouble(top), C.GLdouble(zNear), C.GLdouble(zFar)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsList.xml +func (gl *GL) IsList(list uint32) bool { + glresult := C.gl3_0_glIsList(gl.funcs, C.GLuint(list)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexGeniv.xml +func (gl *GL) GetTexGeniv(coord, pname glbase.Enum, params []int32) { + C.gl3_0_glGetTexGeniv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexGenfv.xml +func (gl *GL) GetTexGenfv(coord, pname glbase.Enum, params []float32) { + C.gl3_0_glGetTexGenfv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexGendv.xml +func (gl *GL) GetTexGendv(coord, pname glbase.Enum, params []float64) { + C.gl3_0_glGetTexGendv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexEnviv.xml +func (gl *GL) GetTexEnviv(target, pname glbase.Enum, params []int32) { + C.gl3_0_glGetTexEnviv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexEnvfv.xml +func (gl *GL) GetTexEnvfv(target, pname glbase.Enum, params []float32) { + C.gl3_0_glGetTexEnvfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetPolygonStipple.xml +func (gl *GL) GetPolygonStipple(mask []uint8) { + C.gl3_0_glGetPolygonStipple(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&mask[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetPixelMapusv.xml +func (gl *GL) GetPixelMapusv(glmap glbase.Enum, values []uint16) { + C.gl3_0_glGetPixelMapusv(gl.funcs, C.GLenum(glmap), (*C.GLushort)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetPixelMapuiv.xml +func (gl *GL) GetPixelMapuiv(glmap glbase.Enum, values []uint32) { + C.gl3_0_glGetPixelMapuiv(gl.funcs, C.GLenum(glmap), (*C.GLuint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetPixelMapfv.xml +func (gl *GL) GetPixelMapfv(glmap glbase.Enum, values []float32) { + C.gl3_0_glGetPixelMapfv(gl.funcs, C.GLenum(glmap), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetMaterialiv.xml +func (gl *GL) GetMaterialiv(face, pname glbase.Enum, params []int32) { + C.gl3_0_glGetMaterialiv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetMaterialfv.xml +func (gl *GL) GetMaterialfv(face, pname glbase.Enum, params []float32) { + C.gl3_0_glGetMaterialfv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetMapiv.xml +func (gl *GL) GetMapiv(target, query glbase.Enum, v []int32) { + C.gl3_0_glGetMapiv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetMapfv.xml +func (gl *GL) GetMapfv(target, query glbase.Enum, v []float32) { + C.gl3_0_glGetMapfv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetMapdv.xml +func (gl *GL) GetMapdv(target, query glbase.Enum, v []float64) { + C.gl3_0_glGetMapdv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetLightiv.xml +func (gl *GL) GetLightiv(light, pname glbase.Enum, params []int32) { + C.gl3_0_glGetLightiv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetLightfv.xml +func (gl *GL) GetLightfv(light, pname glbase.Enum, params []float32) { + C.gl3_0_glGetLightfv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetClipPlane.xml +func (gl *GL) GetClipPlane(plane glbase.Enum, equation []float64) { + C.gl3_0_glGetClipPlane(gl.funcs, C.GLenum(plane), (*C.GLdouble)(unsafe.Pointer(&equation[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawPixels.xml +func (gl *GL) DrawPixels(width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glDrawPixels(gl.funcs, C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyPixels.xml +func (gl *GL) CopyPixels(x, y, width, height int, gltype glbase.Enum) { + C.gl3_0_glCopyPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(gltype)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPixelMapusv.xml +func (gl *GL) PixelMapusv(glmap glbase.Enum, mapsize int32, values []uint16) { + C.gl3_0_glPixelMapusv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLushort)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPixelMapuiv.xml +func (gl *GL) PixelMapuiv(glmap glbase.Enum, mapsize int32, values []uint32) { + C.gl3_0_glPixelMapuiv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLuint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPixelMapfv.xml +func (gl *GL) PixelMapfv(glmap glbase.Enum, mapsize int32, values []float32) { + C.gl3_0_glPixelMapfv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPixelTransferi.xml +func (gl *GL) PixelTransferi(pname glbase.Enum, param int32) { + C.gl3_0_glPixelTransferi(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPixelTransferf.xml +func (gl *GL) PixelTransferf(pname glbase.Enum, param float32) { + C.gl3_0_glPixelTransferf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPixelZoom.xml +func (gl *GL) PixelZoom(xfactor, yfactor float32) { + C.gl3_0_glPixelZoom(gl.funcs, C.GLfloat(xfactor), C.GLfloat(yfactor)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glAlphaFunc.xml +func (gl *GL) AlphaFunc(glfunc glbase.Enum, ref float32) { + C.gl3_0_glAlphaFunc(gl.funcs, C.GLenum(glfunc), C.GLfloat(ref)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalPoint2.xml +func (gl *GL) EvalPoint2(i, j int32) { + C.gl3_0_glEvalPoint2(gl.funcs, C.GLint(i), C.GLint(j)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalMesh2.xml +func (gl *GL) EvalMesh2(mode glbase.Enum, i1, i2, j1, j2 int32) { + C.gl3_0_glEvalMesh2(gl.funcs, C.GLenum(mode), C.GLint(i1), C.GLint(i2), C.GLint(j1), C.GLint(j2)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalPoint1.xml +func (gl *GL) EvalPoint1(i int32) { + C.gl3_0_glEvalPoint1(gl.funcs, C.GLint(i)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalMesh1.xml +func (gl *GL) EvalMesh1(mode glbase.Enum, i1, i2 int32) { + C.gl3_0_glEvalMesh1(gl.funcs, C.GLenum(mode), C.GLint(i1), C.GLint(i2)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalCoord2fv.xml +func (gl *GL) EvalCoord2fv(u []float32) { + if len(u) != 2 { + panic("parameter u has incorrect length") + } + C.gl3_0_glEvalCoord2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalCoord2f.xml +func (gl *GL) EvalCoord2f(u, v float32) { + C.gl3_0_glEvalCoord2f(gl.funcs, C.GLfloat(u), C.GLfloat(v)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalCoord2dv.xml +func (gl *GL) EvalCoord2dv(u []float64) { + if len(u) != 2 { + panic("parameter u has incorrect length") + } + C.gl3_0_glEvalCoord2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalCoord2d.xml +func (gl *GL) EvalCoord2d(u, v float64) { + C.gl3_0_glEvalCoord2d(gl.funcs, C.GLdouble(u), C.GLdouble(v)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalCoord1fv.xml +func (gl *GL) EvalCoord1fv(u []float32) { + C.gl3_0_glEvalCoord1fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalCoord1f.xml +func (gl *GL) EvalCoord1f(u float32) { + C.gl3_0_glEvalCoord1f(gl.funcs, C.GLfloat(u)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalCoord1dv.xml +func (gl *GL) EvalCoord1dv(u []float64) { + C.gl3_0_glEvalCoord1dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalCoord1d.xml +func (gl *GL) EvalCoord1d(u float64) { + C.gl3_0_glEvalCoord1d(gl.funcs, C.GLdouble(u)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMapGrid2f.xml +func (gl *GL) MapGrid2f(un int32, u1, u2 float32, vn int32, v1, v2 float32) { + C.gl3_0_glMapGrid2f(gl.funcs, C.GLint(un), C.GLfloat(u1), C.GLfloat(u2), C.GLint(vn), C.GLfloat(v1), C.GLfloat(v2)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMapGrid2d.xml +func (gl *GL) MapGrid2d(un int32, u1, u2 float64, vn int32, v1, v2 float64) { + C.gl3_0_glMapGrid2d(gl.funcs, C.GLint(un), C.GLdouble(u1), C.GLdouble(u2), C.GLint(vn), C.GLdouble(v1), C.GLdouble(v2)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMapGrid1f.xml +func (gl *GL) MapGrid1f(un int32, u1, u2 float32) { + C.gl3_0_glMapGrid1f(gl.funcs, C.GLint(un), C.GLfloat(u1), C.GLfloat(u2)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMapGrid1d.xml +func (gl *GL) MapGrid1d(un int32, u1, u2 float64) { + C.gl3_0_glMapGrid1d(gl.funcs, C.GLint(un), C.GLdouble(u1), C.GLdouble(u2)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMap2f.xml +func (gl *GL) Map2f(target glbase.Enum, u1, u2 float32, ustride, uorder int32, v1, v2 float32, vstride, vorder int32, points []float32) { + C.gl3_0_glMap2f(gl.funcs, C.GLenum(target), C.GLfloat(u1), C.GLfloat(u2), C.GLint(ustride), C.GLint(uorder), C.GLfloat(v1), C.GLfloat(v2), C.GLint(vstride), C.GLint(vorder), (*C.GLfloat)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMap2d.xml +func (gl *GL) Map2d(target glbase.Enum, u1, u2 float64, ustride, uorder int32, v1, v2 float64, vstride, vorder int32, points []float64) { + C.gl3_0_glMap2d(gl.funcs, C.GLenum(target), C.GLdouble(u1), C.GLdouble(u2), C.GLint(ustride), C.GLint(uorder), C.GLdouble(v1), C.GLdouble(v2), C.GLint(vstride), C.GLint(vorder), (*C.GLdouble)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMap1f.xml +func (gl *GL) Map1f(target glbase.Enum, u1, u2 float32, stride, order int, points []float32) { + C.gl3_0_glMap1f(gl.funcs, C.GLenum(target), C.GLfloat(u1), C.GLfloat(u2), C.GLint(stride), C.GLint(order), (*C.GLfloat)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMap1d.xml +func (gl *GL) Map1d(target glbase.Enum, u1, u2 float64, stride, order int, points []float64) { + C.gl3_0_glMap1d(gl.funcs, C.GLenum(target), C.GLdouble(u1), C.GLdouble(u2), C.GLint(stride), C.GLint(order), (*C.GLdouble)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPushAttrib.xml +func (gl *GL) PushAttrib(mask glbase.Bitfield) { + C.gl3_0_glPushAttrib(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPopAttrib.xml +func (gl *GL) PopAttrib() { + C.gl3_0_glPopAttrib(gl.funcs) +} + +// Accum executes an operation on the accumulation buffer. +// +// Parameter op defines the accumulation buffer operation (GL.ACCUM, GL.LOAD, +// GL.ADD, GL.MULT, or GL.RETURN) and specifies how the value parameter is +// used. +// +// The accumulation buffer is an extended-range color buffer. Images are not +// rendered into it. Rather, images rendered into one of the color buffers +// are added to the contents of the accumulation buffer after rendering. +// Effects such as antialiasing (of points, lines, and polygons), motion +// blur, and depth of field can be created by accumulating images generated +// with different transformation matrices. +// +// Each pixel in the accumulation buffer consists of red, green, blue, and +// alpha values. The number of bits per component in the accumulation buffer +// depends on the implementation. You can examine this number by calling +// GetIntegerv four times, with arguments GL.ACCUM_RED_BITS, +// GL.ACCUM_GREEN_BITS, GL.ACCUM_BLUE_BITS, and GL.ACCUM_ALPHA_BITS. +// Regardless of the number of bits per component, the range of values stored +// by each component is (-1, 1). The accumulation buffer pixels are mapped +// one-to-one with frame buffer pixels. +// +// All accumulation buffer operations are limited to the area of the current +// scissor box and applied identically to the red, green, blue, and alpha +// components of each pixel. If a Accum operation results in a value outside +// the range (-1, 1), the contents of an accumulation buffer pixel component +// are undefined. +// +// The operations are as follows: +// +// GL.ACCUM +// Obtains R, G, B, and A values from the buffer currently selected for +// reading (see ReadBuffer). Each component value is divided by 2 n - +// 1 , where n is the number of bits allocated to each color component +// in the currently selected buffer. The result is a floating-point +// value in the range 0 1 , which is multiplied by value and added to +// the corresponding pixel component in the accumulation buffer, +// thereby updating the accumulation buffer. +// +// GL.LOAD +// Similar to GL.ACCUM, except that the current value in the +// accumulation buffer is not used in the calculation of the new value. +// That is, the R, G, B, and A values from the currently selected +// buffer are divided by 2 n - 1 , multiplied by value, and then stored +// in the corresponding accumulation buffer cell, overwriting the +// current value. +// +// GL.ADD +// Adds value to each R, G, B, and A in the accumulation buffer. +// +// GL.MULT +// Multiplies each R, G, B, and A in the accumulation buffer by value +// and returns the scaled component to its corresponding accumulation +// buffer location. +// +// GL.RETURN +// Transfers accumulation buffer values to the color buffer or buffers +// currently selected for writing. Each R, G, B, and A component is +// multiplied by value, then multiplied by 2 n - 1 , clamped to the +// range 0 2 n - 1 , and stored in the corresponding display buffer +// cell. The only fragment operations that are applied to this transfer +// are pixel ownership, scissor, dithering, and color writemasks. +// +// To clear the accumulation buffer, call ClearAccum with R, G, B, and A +// values to set it to, then call Clear with the accumulation buffer +// enabled. +// +// Error GL.INVALID_ENUM is generated if op is not an accepted value. +// GL.INVALID_OPERATION is generated if there is no accumulation buffer. +// GL.INVALID_OPERATION is generated if Accum is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) Accum(op glbase.Enum, value float32) { + C.gl3_0_glAccum(gl.funcs, C.GLenum(op), C.GLfloat(value)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexMask.xml +func (gl *GL) IndexMask(mask uint32) { + C.gl3_0_glIndexMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearIndex.xml +func (gl *GL) ClearIndex(c float32) { + C.gl3_0_glClearIndex(gl.funcs, C.GLfloat(c)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearAccum.xml +func (gl *GL) ClearAccum(red, green, blue, alpha float32) { + C.gl3_0_glClearAccum(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPushName.xml +func (gl *GL) PushName(name uint32) { + C.gl3_0_glPushName(gl.funcs, C.GLuint(name)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPopName.xml +func (gl *GL) PopName() { + C.gl3_0_glPopName(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPassThrough.xml +func (gl *GL) PassThrough(token float32) { + C.gl3_0_glPassThrough(gl.funcs, C.GLfloat(token)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLoadName.xml +func (gl *GL) LoadName(name uint32) { + C.gl3_0_glLoadName(gl.funcs, C.GLuint(name)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glInitNames.xml +func (gl *GL) InitNames() { + C.gl3_0_glInitNames(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRenderMode.xml +func (gl *GL) RenderMode(mode glbase.Enum) int32 { + glresult := C.gl3_0_glRenderMode(gl.funcs, C.GLenum(mode)) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSelectBuffer.xml +func (gl *GL) SelectBuffer(size int, buffer []glbase.Buffer) { + C.gl3_0_glSelectBuffer(gl.funcs, C.GLsizei(size), (*C.GLuint)(unsafe.Pointer(&buffer[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFeedbackBuffer.xml +func (gl *GL) FeedbackBuffer(size int, gltype glbase.Enum, buffer []float32) { + C.gl3_0_glFeedbackBuffer(gl.funcs, C.GLsizei(size), C.GLenum(gltype), (*C.GLfloat)(unsafe.Pointer(&buffer[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexGeniv.xml +func (gl *GL) TexGeniv(coord, pname glbase.Enum, params []int32) { + C.gl3_0_glTexGeniv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexGeni.xml +func (gl *GL) TexGeni(coord, pname glbase.Enum, param int32) { + C.gl3_0_glTexGeni(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexGenfv.xml +func (gl *GL) TexGenfv(coord, pname glbase.Enum, params []float32) { + C.gl3_0_glTexGenfv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexGenf.xml +func (gl *GL) TexGenf(coord, pname glbase.Enum, param float32) { + C.gl3_0_glTexGenf(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexGendv.xml +func (gl *GL) TexGendv(coord, pname glbase.Enum, params []float64) { + C.gl3_0_glTexGendv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexGend.xml +func (gl *GL) TexGend(coord, pname glbase.Enum, param float64) { + C.gl3_0_glTexGend(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLdouble(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexEnviv.xml +func (gl *GL) TexEnviv(target, pname glbase.Enum, params []int32) { + C.gl3_0_glTexEnviv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexEnvi.xml +func (gl *GL) TexEnvi(target, pname glbase.Enum, param int32) { + C.gl3_0_glTexEnvi(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexEnvfv.xml +func (gl *GL) TexEnvfv(target, pname glbase.Enum, params []float32) { + C.gl3_0_glTexEnvfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexEnvf.xml +func (gl *GL) TexEnvf(target, pname glbase.Enum, param float32) { + C.gl3_0_glTexEnvf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glShadeModel.xml +func (gl *GL) ShadeModel(mode glbase.Enum) { + C.gl3_0_glShadeModel(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPolygonStipple.xml +func (gl *GL) PolygonStipple(mask []uint8) { + C.gl3_0_glPolygonStipple(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&mask[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMaterialiv.xml +func (gl *GL) Materialiv(face, pname glbase.Enum, params []int32) { + C.gl3_0_glMaterialiv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMateriali.xml +func (gl *GL) Materiali(face, pname glbase.Enum, param int32) { + C.gl3_0_glMateriali(gl.funcs, C.GLenum(face), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMaterialfv.xml +func (gl *GL) Materialfv(face, pname glbase.Enum, params []float32) { + C.gl3_0_glMaterialfv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMaterialf.xml +func (gl *GL) Materialf(face, pname glbase.Enum, param float32) { + C.gl3_0_glMaterialf(gl.funcs, C.GLenum(face), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLineStipple.xml +func (gl *GL) LineStipple(factor int32, pattern uint16) { + C.gl3_0_glLineStipple(gl.funcs, C.GLint(factor), C.GLushort(pattern)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLightModeliv.xml +func (gl *GL) LightModeliv(pname glbase.Enum, params []int32) { + C.gl3_0_glLightModeliv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLightModeli.xml +func (gl *GL) LightModeli(pname glbase.Enum, param int32) { + C.gl3_0_glLightModeli(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLightModelfv.xml +func (gl *GL) LightModelfv(pname glbase.Enum, params []float32) { + C.gl3_0_glLightModelfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLightModelf.xml +func (gl *GL) LightModelf(pname glbase.Enum, param float32) { + C.gl3_0_glLightModelf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLightiv.xml +func (gl *GL) Lightiv(light, pname glbase.Enum, params []int32) { + C.gl3_0_glLightiv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLighti.xml +func (gl *GL) Lighti(light, pname glbase.Enum, param int32) { + C.gl3_0_glLighti(gl.funcs, C.GLenum(light), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLightfv.xml +func (gl *GL) Lightfv(light, pname glbase.Enum, params []float32) { + C.gl3_0_glLightfv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLightf.xml +func (gl *GL) Lightf(light, pname glbase.Enum, param float32) { + C.gl3_0_glLightf(gl.funcs, C.GLenum(light), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFogiv.xml +func (gl *GL) Fogiv(pname glbase.Enum, params []int32) { + C.gl3_0_glFogiv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFogi.xml +func (gl *GL) Fogi(pname glbase.Enum, param int32) { + C.gl3_0_glFogi(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFogfv.xml +func (gl *GL) Fogfv(pname glbase.Enum, params []float32) { + C.gl3_0_glFogfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFogf.xml +func (gl *GL) Fogf(pname glbase.Enum, param float32) { + C.gl3_0_glFogf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorMaterial.xml +func (gl *GL) ColorMaterial(face, mode glbase.Enum) { + C.gl3_0_glColorMaterial(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClipPlane.xml +func (gl *GL) ClipPlane(plane glbase.Enum, equation []float64) { + C.gl3_0_glClipPlane(gl.funcs, C.GLenum(plane), (*C.GLdouble)(unsafe.Pointer(&equation[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex4sv.xml +func (gl *GL) Vertex4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_0_glVertex4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex4s.xml +func (gl *GL) Vertex4s(x, y, z, w int16) { + C.gl3_0_glVertex4s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex4iv.xml +func (gl *GL) Vertex4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_0_glVertex4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex4i.xml +func (gl *GL) Vertex4i(x, y, z, w int) { + C.gl3_0_glVertex4i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex4fv.xml +func (gl *GL) Vertex4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_0_glVertex4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex4f.xml +func (gl *GL) Vertex4f(x, y, z, w float32) { + C.gl3_0_glVertex4f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex4dv.xml +func (gl *GL) Vertex4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_0_glVertex4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex4d.xml +func (gl *GL) Vertex4d(x, y, z, w float64) { + C.gl3_0_glVertex4d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex3sv.xml +func (gl *GL) Vertex3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glVertex3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex3s.xml +func (gl *GL) Vertex3s(x, y, z int16) { + C.gl3_0_glVertex3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex3iv.xml +func (gl *GL) Vertex3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glVertex3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex3i.xml +func (gl *GL) Vertex3i(x, y, z int) { + C.gl3_0_glVertex3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex3fv.xml +func (gl *GL) Vertex3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glVertex3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex3f.xml +func (gl *GL) Vertex3f(x, y, z float32) { + C.gl3_0_glVertex3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex3dv.xml +func (gl *GL) Vertex3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glVertex3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex3d.xml +func (gl *GL) Vertex3d(x, y, z float64) { + C.gl3_0_glVertex3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex2sv.xml +func (gl *GL) Vertex2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_0_glVertex2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex2s.xml +func (gl *GL) Vertex2s(x, y int16) { + C.gl3_0_glVertex2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex2iv.xml +func (gl *GL) Vertex2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_0_glVertex2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex2i.xml +func (gl *GL) Vertex2i(x, y int) { + C.gl3_0_glVertex2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex2fv.xml +func (gl *GL) Vertex2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_0_glVertex2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex2f.xml +func (gl *GL) Vertex2f(x, y float32) { + C.gl3_0_glVertex2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex2dv.xml +func (gl *GL) Vertex2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_0_glVertex2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex2d.xml +func (gl *GL) Vertex2d(x, y float64) { + C.gl3_0_glVertex2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord4sv.xml +func (gl *GL) TexCoord4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_0_glTexCoord4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord4s.xml +func (gl *GL) TexCoord4s(s, t, r, q int16) { + C.gl3_0_glTexCoord4s(gl.funcs, C.GLshort(s), C.GLshort(t), C.GLshort(r), C.GLshort(q)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord4iv.xml +func (gl *GL) TexCoord4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_0_glTexCoord4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord4i.xml +func (gl *GL) TexCoord4i(s, t, r, q int32) { + C.gl3_0_glTexCoord4i(gl.funcs, C.GLint(s), C.GLint(t), C.GLint(r), C.GLint(q)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord4fv.xml +func (gl *GL) TexCoord4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_0_glTexCoord4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord4f.xml +func (gl *GL) TexCoord4f(s, t, r, q float32) { + C.gl3_0_glTexCoord4f(gl.funcs, C.GLfloat(s), C.GLfloat(t), C.GLfloat(r), C.GLfloat(q)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord4dv.xml +func (gl *GL) TexCoord4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_0_glTexCoord4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord4d.xml +func (gl *GL) TexCoord4d(s, t, r, q float64) { + C.gl3_0_glTexCoord4d(gl.funcs, C.GLdouble(s), C.GLdouble(t), C.GLdouble(r), C.GLdouble(q)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord3sv.xml +func (gl *GL) TexCoord3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glTexCoord3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord3s.xml +func (gl *GL) TexCoord3s(s, t, r int16) { + C.gl3_0_glTexCoord3s(gl.funcs, C.GLshort(s), C.GLshort(t), C.GLshort(r)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord3iv.xml +func (gl *GL) TexCoord3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glTexCoord3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord3i.xml +func (gl *GL) TexCoord3i(s, t, r int32) { + C.gl3_0_glTexCoord3i(gl.funcs, C.GLint(s), C.GLint(t), C.GLint(r)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord3fv.xml +func (gl *GL) TexCoord3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glTexCoord3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord3f.xml +func (gl *GL) TexCoord3f(s, t, r float32) { + C.gl3_0_glTexCoord3f(gl.funcs, C.GLfloat(s), C.GLfloat(t), C.GLfloat(r)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord3dv.xml +func (gl *GL) TexCoord3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glTexCoord3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord3d.xml +func (gl *GL) TexCoord3d(s, t, r float64) { + C.gl3_0_glTexCoord3d(gl.funcs, C.GLdouble(s), C.GLdouble(t), C.GLdouble(r)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord2sv.xml +func (gl *GL) TexCoord2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_0_glTexCoord2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord2s.xml +func (gl *GL) TexCoord2s(s, t int16) { + C.gl3_0_glTexCoord2s(gl.funcs, C.GLshort(s), C.GLshort(t)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord2iv.xml +func (gl *GL) TexCoord2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_0_glTexCoord2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord2i.xml +func (gl *GL) TexCoord2i(s, t int32) { + C.gl3_0_glTexCoord2i(gl.funcs, C.GLint(s), C.GLint(t)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord2fv.xml +func (gl *GL) TexCoord2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_0_glTexCoord2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord2f.xml +func (gl *GL) TexCoord2f(s, t float32) { + C.gl3_0_glTexCoord2f(gl.funcs, C.GLfloat(s), C.GLfloat(t)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord2dv.xml +func (gl *GL) TexCoord2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_0_glTexCoord2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord2d.xml +func (gl *GL) TexCoord2d(s, t float64) { + C.gl3_0_glTexCoord2d(gl.funcs, C.GLdouble(s), C.GLdouble(t)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord1sv.xml +func (gl *GL) TexCoord1sv(v []int16) { + C.gl3_0_glTexCoord1sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord1s.xml +func (gl *GL) TexCoord1s(s int16) { + C.gl3_0_glTexCoord1s(gl.funcs, C.GLshort(s)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord1iv.xml +func (gl *GL) TexCoord1iv(v []int32) { + C.gl3_0_glTexCoord1iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord1i.xml +func (gl *GL) TexCoord1i(s int32) { + C.gl3_0_glTexCoord1i(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord1fv.xml +func (gl *GL) TexCoord1fv(v []float32) { + C.gl3_0_glTexCoord1fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord1f.xml +func (gl *GL) TexCoord1f(s float32) { + C.gl3_0_glTexCoord1f(gl.funcs, C.GLfloat(s)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord1dv.xml +func (gl *GL) TexCoord1dv(v []float64) { + C.gl3_0_glTexCoord1dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord1d.xml +func (gl *GL) TexCoord1d(s float64) { + C.gl3_0_glTexCoord1d(gl.funcs, C.GLdouble(s)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRectsv.xml +func (gl *GL) Rectsv(v1, v2 []int16) { + C.gl3_0_glRectsv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v1[0])), (*C.GLshort)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRects.xml +func (gl *GL) Rects(x1, y1, x2, y2 int16) { + C.gl3_0_glRects(gl.funcs, C.GLshort(x1), C.GLshort(y1), C.GLshort(x2), C.GLshort(y2)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRectiv.xml +func (gl *GL) Rectiv(v1, v2 []int32) { + C.gl3_0_glRectiv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v1[0])), (*C.GLint)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRecti.xml +func (gl *GL) Recti(x1, y1, x2, y2 int32) { + C.gl3_0_glRecti(gl.funcs, C.GLint(x1), C.GLint(y1), C.GLint(x2), C.GLint(y2)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRectfv.xml +func (gl *GL) Rectfv(v1, v2 []float32) { + C.gl3_0_glRectfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v1[0])), (*C.GLfloat)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRectf.xml +func (gl *GL) Rectf(x1, y1, x2, y2 float32) { + C.gl3_0_glRectf(gl.funcs, C.GLfloat(x1), C.GLfloat(y1), C.GLfloat(x2), C.GLfloat(y2)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRectdv.xml +func (gl *GL) Rectdv(v1, v2 []float64) { + C.gl3_0_glRectdv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v1[0])), (*C.GLdouble)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRectd.xml +func (gl *GL) Rectd(x1, y1, x2, y2 float64) { + C.gl3_0_glRectd(gl.funcs, C.GLdouble(x1), C.GLdouble(y1), C.GLdouble(x2), C.GLdouble(y2)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos4sv.xml +func (gl *GL) RasterPos4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_0_glRasterPos4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos4s.xml +func (gl *GL) RasterPos4s(x, y, z, w int16) { + C.gl3_0_glRasterPos4s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos4iv.xml +func (gl *GL) RasterPos4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_0_glRasterPos4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos4i.xml +func (gl *GL) RasterPos4i(x, y, z, w int) { + C.gl3_0_glRasterPos4i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos4fv.xml +func (gl *GL) RasterPos4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_0_glRasterPos4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos4f.xml +func (gl *GL) RasterPos4f(x, y, z, w float32) { + C.gl3_0_glRasterPos4f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos4dv.xml +func (gl *GL) RasterPos4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_0_glRasterPos4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos4d.xml +func (gl *GL) RasterPos4d(x, y, z, w float64) { + C.gl3_0_glRasterPos4d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos3sv.xml +func (gl *GL) RasterPos3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glRasterPos3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos3s.xml +func (gl *GL) RasterPos3s(x, y, z int16) { + C.gl3_0_glRasterPos3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos3iv.xml +func (gl *GL) RasterPos3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glRasterPos3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos3i.xml +func (gl *GL) RasterPos3i(x, y, z int) { + C.gl3_0_glRasterPos3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos3fv.xml +func (gl *GL) RasterPos3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glRasterPos3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos3f.xml +func (gl *GL) RasterPos3f(x, y, z float32) { + C.gl3_0_glRasterPos3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos3dv.xml +func (gl *GL) RasterPos3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glRasterPos3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos3d.xml +func (gl *GL) RasterPos3d(x, y, z float64) { + C.gl3_0_glRasterPos3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos2sv.xml +func (gl *GL) RasterPos2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_0_glRasterPos2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos2s.xml +func (gl *GL) RasterPos2s(x, y int16) { + C.gl3_0_glRasterPos2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos2iv.xml +func (gl *GL) RasterPos2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_0_glRasterPos2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos2i.xml +func (gl *GL) RasterPos2i(x, y int) { + C.gl3_0_glRasterPos2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos2fv.xml +func (gl *GL) RasterPos2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_0_glRasterPos2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos2f.xml +func (gl *GL) RasterPos2f(x, y float32) { + C.gl3_0_glRasterPos2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos2dv.xml +func (gl *GL) RasterPos2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_0_glRasterPos2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos2d.xml +func (gl *GL) RasterPos2d(x, y float64) { + C.gl3_0_glRasterPos2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormal3sv.xml +func (gl *GL) Normal3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glNormal3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormal3s.xml +func (gl *GL) Normal3s(nx, ny, nz int16) { + C.gl3_0_glNormal3s(gl.funcs, C.GLshort(nx), C.GLshort(ny), C.GLshort(nz)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormal3iv.xml +func (gl *GL) Normal3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glNormal3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormal3i.xml +func (gl *GL) Normal3i(nx, ny, nz int32) { + C.gl3_0_glNormal3i(gl.funcs, C.GLint(nx), C.GLint(ny), C.GLint(nz)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormal3fv.xml +func (gl *GL) Normal3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glNormal3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormal3f.xml +func (gl *GL) Normal3f(nx, ny, nz float32) { + C.gl3_0_glNormal3f(gl.funcs, C.GLfloat(nx), C.GLfloat(ny), C.GLfloat(nz)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormal3dv.xml +func (gl *GL) Normal3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glNormal3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormal3d.xml +func (gl *GL) Normal3d(nx, ny, nz float64) { + C.gl3_0_glNormal3d(gl.funcs, C.GLdouble(nx), C.GLdouble(ny), C.GLdouble(nz)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormal3bv.xml +func (gl *GL) Normal3bv(v []byte) { + C.gl3_0_glNormal3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormal3b.xml +func (gl *GL) Normal3b(nx, ny, nz byte) { + C.gl3_0_glNormal3b(gl.funcs, C.GLbyte(nx), C.GLbyte(ny), C.GLbyte(nz)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexsv.xml +func (gl *GL) Indexsv(c []int16) { + C.gl3_0_glIndexsv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexs.xml +func (gl *GL) Indexs(c int16) { + C.gl3_0_glIndexs(gl.funcs, C.GLshort(c)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexiv.xml +func (gl *GL) Indexiv(c []int32) { + C.gl3_0_glIndexiv(gl.funcs, (*C.GLint)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexi.xml +func (gl *GL) Indexi(c int32) { + C.gl3_0_glIndexi(gl.funcs, C.GLint(c)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexfv.xml +func (gl *GL) Indexfv(c []float32) { + C.gl3_0_glIndexfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexf.xml +func (gl *GL) Indexf(c float32) { + C.gl3_0_glIndexf(gl.funcs, C.GLfloat(c)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexdv.xml +func (gl *GL) Indexdv(c []float64) { + C.gl3_0_glIndexdv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexd.xml +func (gl *GL) Indexd(c float64) { + C.gl3_0_glIndexd(gl.funcs, C.GLdouble(c)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEnd.xml +func (gl *GL) End() { + C.gl3_0_glEnd(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEdgeFlagv.xml +func (gl *GL) EdgeFlagv(flag []bool) { + C.gl3_0_glEdgeFlagv(gl.funcs, (*C.GLboolean)(unsafe.Pointer(&flag[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEdgeFlag.xml +func (gl *GL) EdgeFlag(flag bool) { + C.gl3_0_glEdgeFlag(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4usv.xml +func (gl *GL) Color4usv(v []uint16) { + C.gl3_0_glColor4usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4us.xml +func (gl *GL) Color4us(red, green, blue, alpha uint16) { + C.gl3_0_glColor4us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue), C.GLushort(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4uiv.xml +func (gl *GL) Color4uiv(v []uint32) { + C.gl3_0_glColor4uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4ui.xml +func (gl *GL) Color4ui(red, green, blue, alpha uint32) { + C.gl3_0_glColor4ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue), C.GLuint(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4ubv.xml +func (gl *GL) Color4ubv(v []uint8) { + C.gl3_0_glColor4ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4ub.xml +func (gl *GL) Color4ub(red, green, blue, alpha uint8) { + C.gl3_0_glColor4ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue), C.GLubyte(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4sv.xml +func (gl *GL) Color4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_0_glColor4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4s.xml +func (gl *GL) Color4s(red, green, blue, alpha int16) { + C.gl3_0_glColor4s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue), C.GLshort(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4iv.xml +func (gl *GL) Color4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_0_glColor4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4i.xml +func (gl *GL) Color4i(red, green, blue, alpha int32) { + C.gl3_0_glColor4i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue), C.GLint(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4fv.xml +func (gl *GL) Color4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_0_glColor4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4f.xml +func (gl *GL) Color4f(red, green, blue, alpha float32) { + C.gl3_0_glColor4f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4dv.xml +func (gl *GL) Color4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_0_glColor4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4d.xml +func (gl *GL) Color4d(red, green, blue, alpha float64) { + C.gl3_0_glColor4d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue), C.GLdouble(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4bv.xml +func (gl *GL) Color4bv(v []byte) { + C.gl3_0_glColor4bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4b.xml +func (gl *GL) Color4b(red, green, blue, alpha byte) { + C.gl3_0_glColor4b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue), C.GLbyte(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3usv.xml +func (gl *GL) Color3usv(v []uint16) { + C.gl3_0_glColor3usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3us.xml +func (gl *GL) Color3us(red, green, blue uint16) { + C.gl3_0_glColor3us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3uiv.xml +func (gl *GL) Color3uiv(v []uint32) { + C.gl3_0_glColor3uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3ui.xml +func (gl *GL) Color3ui(red, green, blue uint32) { + C.gl3_0_glColor3ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3ubv.xml +func (gl *GL) Color3ubv(v []uint8) { + C.gl3_0_glColor3ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3ub.xml +func (gl *GL) Color3ub(red, green, blue uint8) { + C.gl3_0_glColor3ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3sv.xml +func (gl *GL) Color3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glColor3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3s.xml +func (gl *GL) Color3s(red, green, blue int16) { + C.gl3_0_glColor3s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3iv.xml +func (gl *GL) Color3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glColor3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3i.xml +func (gl *GL) Color3i(red, green, blue int32) { + C.gl3_0_glColor3i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3fv.xml +func (gl *GL) Color3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glColor3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3f.xml +func (gl *GL) Color3f(red, green, blue float32) { + C.gl3_0_glColor3f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3dv.xml +func (gl *GL) Color3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glColor3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3d.xml +func (gl *GL) Color3d(red, green, blue float64) { + C.gl3_0_glColor3d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3bv.xml +func (gl *GL) Color3bv(v []byte) { + C.gl3_0_glColor3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3b.xml +func (gl *GL) Color3b(red, green, blue byte) { + C.gl3_0_glColor3b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBitmap.xml +func (gl *GL) Bitmap(width, height int, xorig, yorig, xmove, ymove float32, bitmap []uint8) { + C.gl3_0_glBitmap(gl.funcs, C.GLsizei(width), C.GLsizei(height), C.GLfloat(xorig), C.GLfloat(yorig), C.GLfloat(xmove), C.GLfloat(ymove), (*C.GLubyte)(unsafe.Pointer(&bitmap[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBegin.xml +func (gl *GL) Begin(mode glbase.Enum) { + C.gl3_0_glBegin(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glListBase.xml +func (gl *GL) ListBase(base uint32) { + C.gl3_0_glListBase(gl.funcs, C.GLuint(base)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGenLists.xml +func (gl *GL) GenLists(range_ int32) uint32 { + glresult := C.gl3_0_glGenLists(gl.funcs, C.GLsizei(range_)) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDeleteLists.xml +func (gl *GL) DeleteLists(list uint32, range_ int32) { + C.gl3_0_glDeleteLists(gl.funcs, C.GLuint(list), C.GLsizei(range_)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCallLists.xml +func (gl *GL) CallLists(n int, gltype glbase.Enum, lists interface{}) { + var lists_ptr unsafe.Pointer + var lists_v = reflect.ValueOf(lists) + if lists != nil && lists_v.Kind() != reflect.Slice { + panic("parameter lists must be a slice") + } + if lists != nil { + lists_ptr = unsafe.Pointer(lists_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glCallLists(gl.funcs, C.GLsizei(n), C.GLenum(gltype), lists_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCallList.xml +func (gl *GL) CallList(list uint32) { + C.gl3_0_glCallList(gl.funcs, C.GLuint(list)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEndList.xml +func (gl *GL) EndList() { + C.gl3_0_glEndList(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNewList.xml +func (gl *GL) NewList(list uint32, mode glbase.Enum) { + C.gl3_0_glNewList(gl.funcs, C.GLuint(list), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPushClientAttrib.xml +func (gl *GL) PushClientAttrib(mask glbase.Bitfield) { + C.gl3_0_glPushClientAttrib(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPopClientAttrib.xml +func (gl *GL) PopClientAttrib() { + C.gl3_0_glPopClientAttrib(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPrioritizeTextures.xml +func (gl *GL) PrioritizeTextures(n int, textures []glbase.Texture, priorities []float32) { + C.gl3_0_glPrioritizeTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0])), (*C.GLfloat)(unsafe.Pointer(&priorities[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glAreTexturesResident.xml +func (gl *GL) AreTexturesResident(n int, textures []glbase.Texture, residences []bool) bool { + glresult := C.gl3_0_glAreTexturesResident(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0])), (*C.GLboolean)(unsafe.Pointer(&residences[0]))) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexPointer.xml +func (gl *GL) VertexPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glVertexPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoordPointer.xml +func (gl *GL) TexCoordPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glTexCoordPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormalPointer.xml +func (gl *GL) NormalPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glNormalPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glInterleavedArrays.xml +func (gl *GL) InterleavedArrays(format glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glInterleavedArrays(gl.funcs, C.GLenum(format), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexPointer.xml +func (gl *GL) IndexPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glIndexPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEnableClientState.xml +func (gl *GL) EnableClientState(array glbase.Enum) { + C.gl3_0_glEnableClientState(gl.funcs, C.GLenum(array)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEdgeFlagPointer.xml +func (gl *GL) EdgeFlagPointer(stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glEdgeFlagPointer(gl.funcs, C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDisableClientState.xml +func (gl *GL) DisableClientState(array glbase.Enum) { + C.gl3_0_glDisableClientState(gl.funcs, C.GLenum(array)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorPointer.xml +func (gl *GL) ColorPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glColorPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glArrayElement.xml +func (gl *GL) ArrayElement(i int32) { + C.gl3_0_glArrayElement(gl.funcs, C.GLint(i)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glResetMinmax.xml +func (gl *GL) ResetMinmax(target glbase.Enum) { + C.gl3_0_glResetMinmax(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glResetHistogram.xml +func (gl *GL) ResetHistogram(target glbase.Enum) { + C.gl3_0_glResetHistogram(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMinmax.xml +func (gl *GL) Minmax(target, internalFormat glbase.Enum, sink bool) { + C.gl3_0_glMinmax(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), *(*C.GLboolean)(unsafe.Pointer(&sink))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glHistogram.xml +func (gl *GL) Histogram(target glbase.Enum, width int, internalFormat glbase.Enum, sink bool) { + C.gl3_0_glHistogram(gl.funcs, C.GLenum(target), C.GLsizei(width), C.GLenum(internalFormat), *(*C.GLboolean)(unsafe.Pointer(&sink))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetMinmaxParameteriv.xml +func (gl *GL) GetMinmaxParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_0_glGetMinmaxParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetMinmaxParameterfv.xml +func (gl *GL) GetMinmaxParameterfv(target, pname glbase.Enum, params []float32) { + C.gl3_0_glGetMinmaxParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetMinmax.xml +func (gl *GL) GetMinmax(target glbase.Enum, reset bool, format, gltype glbase.Enum, values interface{}) { + var values_ptr unsafe.Pointer + var values_v = reflect.ValueOf(values) + if values != nil && values_v.Kind() != reflect.Slice { + panic("parameter values must be a slice") + } + if values != nil { + values_ptr = unsafe.Pointer(values_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glGetMinmax(gl.funcs, C.GLenum(target), *(*C.GLboolean)(unsafe.Pointer(&reset)), C.GLenum(format), C.GLenum(gltype), values_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetHistogramParameteriv.xml +func (gl *GL) GetHistogramParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_0_glGetHistogramParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetHistogramParameterfv.xml +func (gl *GL) GetHistogramParameterfv(target, pname glbase.Enum, params []float32) { + C.gl3_0_glGetHistogramParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetHistogram.xml +func (gl *GL) GetHistogram(target glbase.Enum, reset bool, format, gltype glbase.Enum, values interface{}) { + var values_ptr unsafe.Pointer + var values_v = reflect.ValueOf(values) + if values != nil && values_v.Kind() != reflect.Slice { + panic("parameter values must be a slice") + } + if values != nil { + values_ptr = unsafe.Pointer(values_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glGetHistogram(gl.funcs, C.GLenum(target), *(*C.GLboolean)(unsafe.Pointer(&reset)), C.GLenum(format), C.GLenum(gltype), values_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSeparableFilter2D.xml +func (gl *GL) SeparableFilter2D(target, internalFormat glbase.Enum, width, height int, format, gltype glbase.Enum, row, column interface{}) { + var row_ptr unsafe.Pointer + var row_v = reflect.ValueOf(row) + if row != nil && row_v.Kind() != reflect.Slice { + panic("parameter row must be a slice") + } + if row != nil { + row_ptr = unsafe.Pointer(row_v.Index(0).Addr().Pointer()) + } + var column_ptr unsafe.Pointer + var column_v = reflect.ValueOf(column) + if column != nil && column_v.Kind() != reflect.Slice { + panic("parameter column must be a slice") + } + if column != nil { + column_ptr = unsafe.Pointer(column_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glSeparableFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), row_ptr, column_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetSeparableFilter.xml +func (gl *GL) GetSeparableFilter(target, format, gltype glbase.Enum, row, column, span interface{}) { + var row_ptr unsafe.Pointer + var row_v = reflect.ValueOf(row) + if row != nil && row_v.Kind() != reflect.Slice { + panic("parameter row must be a slice") + } + if row != nil { + row_ptr = unsafe.Pointer(row_v.Index(0).Addr().Pointer()) + } + var column_ptr unsafe.Pointer + var column_v = reflect.ValueOf(column) + if column != nil && column_v.Kind() != reflect.Slice { + panic("parameter column must be a slice") + } + if column != nil { + column_ptr = unsafe.Pointer(column_v.Index(0).Addr().Pointer()) + } + var span_ptr unsafe.Pointer + var span_v = reflect.ValueOf(span) + if span != nil && span_v.Kind() != reflect.Slice { + panic("parameter span must be a slice") + } + if span != nil { + span_ptr = unsafe.Pointer(span_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glGetSeparableFilter(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), row_ptr, column_ptr, span_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetConvolutionParameteriv.xml +func (gl *GL) GetConvolutionParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_0_glGetConvolutionParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetConvolutionParameterfv.xml +func (gl *GL) GetConvolutionParameterfv(target, pname glbase.Enum, params []float32) { + C.gl3_0_glGetConvolutionParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetConvolutionFilter.xml +func (gl *GL) GetConvolutionFilter(target, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glGetConvolutionFilter(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyConvolutionFilter2D.xml +func (gl *GL) CopyConvolutionFilter2D(target, internalFormat glbase.Enum, x, y, width, height int) { + C.gl3_0_glCopyConvolutionFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyConvolutionFilter1D.xml +func (gl *GL) CopyConvolutionFilter1D(target, internalFormat glbase.Enum, x, y, width int) { + C.gl3_0_glCopyConvolutionFilter1D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glConvolutionParameteriv.xml +func (gl *GL) ConvolutionParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_0_glConvolutionParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glConvolutionParameteri.xml +func (gl *GL) ConvolutionParameteri(target, pname glbase.Enum, params int32) { + C.gl3_0_glConvolutionParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(params)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glConvolutionParameterfv.xml +func (gl *GL) ConvolutionParameterfv(target, pname glbase.Enum, params []float32) { + C.gl3_0_glConvolutionParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glConvolutionParameterf.xml +func (gl *GL) ConvolutionParameterf(target, pname glbase.Enum, params float32) { + C.gl3_0_glConvolutionParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(params)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glConvolutionFilter2D.xml +func (gl *GL) ConvolutionFilter2D(target, internalFormat glbase.Enum, width, height int, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glConvolutionFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glConvolutionFilter1D.xml +func (gl *GL) ConvolutionFilter1D(target, internalFormat glbase.Enum, width int, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glConvolutionFilter1D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyColorSubTable.xml +func (gl *GL) CopyColorSubTable(target glbase.Enum, start int32, x, y, width int) { + C.gl3_0_glCopyColorSubTable(gl.funcs, C.GLenum(target), C.GLsizei(start), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorSubTable.xml +func (gl *GL) ColorSubTable(target glbase.Enum, start int32, count int, format, gltype glbase.Enum, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glColorSubTable(gl.funcs, C.GLenum(target), C.GLsizei(start), C.GLsizei(count), C.GLenum(format), C.GLenum(gltype), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetColorTableParameteriv.xml +func (gl *GL) GetColorTableParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_0_glGetColorTableParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetColorTableParameterfv.xml +func (gl *GL) GetColorTableParameterfv(target, pname glbase.Enum, params []float32) { + C.gl3_0_glGetColorTableParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetColorTable.xml +func (gl *GL) GetColorTable(target, format, gltype glbase.Enum, table interface{}) { + var table_ptr unsafe.Pointer + var table_v = reflect.ValueOf(table) + if table != nil && table_v.Kind() != reflect.Slice { + panic("parameter table must be a slice") + } + if table != nil { + table_ptr = unsafe.Pointer(table_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glGetColorTable(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), table_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyColorTable.xml +func (gl *GL) CopyColorTable(target, internalFormat glbase.Enum, x, y, width int) { + C.gl3_0_glCopyColorTable(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorTableParameteriv.xml +func (gl *GL) ColorTableParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_0_glColorTableParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorTableParameterfv.xml +func (gl *GL) ColorTableParameterfv(target, pname glbase.Enum, params []float32) { + C.gl3_0_glColorTableParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorTable.xml +func (gl *GL) ColorTable(target, internalFormat glbase.Enum, width int, format, gltype glbase.Enum, table interface{}) { + var table_ptr unsafe.Pointer + var table_v = reflect.ValueOf(table) + if table != nil && table_v.Kind() != reflect.Slice { + panic("parameter table must be a slice") + } + if table != nil { + table_ptr = unsafe.Pointer(table_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glColorTable(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), table_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultTransposeMatrixd.xml +func (gl *GL) MultTransposeMatrixd(m []float64) { + C.gl3_0_glMultTransposeMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultTransposeMatrixf.xml +func (gl *GL) MultTransposeMatrixf(m []float32) { + C.gl3_0_glMultTransposeMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLoadTransposeMatrixd.xml +func (gl *GL) LoadTransposeMatrixd(m []float64) { + C.gl3_0_glLoadTransposeMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLoadTransposeMatrixf.xml +func (gl *GL) LoadTransposeMatrixf(m []float32) { + C.gl3_0_glLoadTransposeMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord4sv.xml +func (gl *GL) MultiTexCoord4sv(target glbase.Enum, v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_0_glMultiTexCoord4sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord4s.xml +func (gl *GL) MultiTexCoord4s(target glbase.Enum, s, t, r, q int16) { + C.gl3_0_glMultiTexCoord4s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t), C.GLshort(r), C.GLshort(q)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord4iv.xml +func (gl *GL) MultiTexCoord4iv(target glbase.Enum, v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_0_glMultiTexCoord4iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord4i.xml +func (gl *GL) MultiTexCoord4i(target glbase.Enum, s, t, r, q int32) { + C.gl3_0_glMultiTexCoord4i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t), C.GLint(r), C.GLint(q)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord4fv.xml +func (gl *GL) MultiTexCoord4fv(target glbase.Enum, v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_0_glMultiTexCoord4fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord4f.xml +func (gl *GL) MultiTexCoord4f(target glbase.Enum, s, t, r, q float32) { + C.gl3_0_glMultiTexCoord4f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t), C.GLfloat(r), C.GLfloat(q)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord4dv.xml +func (gl *GL) MultiTexCoord4dv(target glbase.Enum, v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_0_glMultiTexCoord4dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord4d.xml +func (gl *GL) MultiTexCoord4d(target glbase.Enum, s, t, r, q float64) { + C.gl3_0_glMultiTexCoord4d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t), C.GLdouble(r), C.GLdouble(q)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord3sv.xml +func (gl *GL) MultiTexCoord3sv(target glbase.Enum, v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glMultiTexCoord3sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord3s.xml +func (gl *GL) MultiTexCoord3s(target glbase.Enum, s, t, r int16) { + C.gl3_0_glMultiTexCoord3s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t), C.GLshort(r)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord3iv.xml +func (gl *GL) MultiTexCoord3iv(target glbase.Enum, v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glMultiTexCoord3iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord3i.xml +func (gl *GL) MultiTexCoord3i(target glbase.Enum, s, t, r int32) { + C.gl3_0_glMultiTexCoord3i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t), C.GLint(r)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord3fv.xml +func (gl *GL) MultiTexCoord3fv(target glbase.Enum, v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glMultiTexCoord3fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord3f.xml +func (gl *GL) MultiTexCoord3f(target glbase.Enum, s, t, r float32) { + C.gl3_0_glMultiTexCoord3f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t), C.GLfloat(r)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord3dv.xml +func (gl *GL) MultiTexCoord3dv(target glbase.Enum, v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glMultiTexCoord3dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord3d.xml +func (gl *GL) MultiTexCoord3d(target glbase.Enum, s, t, r float64) { + C.gl3_0_glMultiTexCoord3d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t), C.GLdouble(r)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord2sv.xml +func (gl *GL) MultiTexCoord2sv(target glbase.Enum, v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_0_glMultiTexCoord2sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord2s.xml +func (gl *GL) MultiTexCoord2s(target glbase.Enum, s, t int16) { + C.gl3_0_glMultiTexCoord2s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord2iv.xml +func (gl *GL) MultiTexCoord2iv(target glbase.Enum, v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_0_glMultiTexCoord2iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord2i.xml +func (gl *GL) MultiTexCoord2i(target glbase.Enum, s, t int32) { + C.gl3_0_glMultiTexCoord2i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord2fv.xml +func (gl *GL) MultiTexCoord2fv(target glbase.Enum, v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_0_glMultiTexCoord2fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord2f.xml +func (gl *GL) MultiTexCoord2f(target glbase.Enum, s, t float32) { + C.gl3_0_glMultiTexCoord2f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord2dv.xml +func (gl *GL) MultiTexCoord2dv(target glbase.Enum, v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_0_glMultiTexCoord2dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord2d.xml +func (gl *GL) MultiTexCoord2d(target glbase.Enum, s, t float64) { + C.gl3_0_glMultiTexCoord2d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord1sv.xml +func (gl *GL) MultiTexCoord1sv(target glbase.Enum, v []int16) { + C.gl3_0_glMultiTexCoord1sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord1s.xml +func (gl *GL) MultiTexCoord1s(target glbase.Enum, s int16) { + C.gl3_0_glMultiTexCoord1s(gl.funcs, C.GLenum(target), C.GLshort(s)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord1iv.xml +func (gl *GL) MultiTexCoord1iv(target glbase.Enum, v []int32) { + C.gl3_0_glMultiTexCoord1iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord1i.xml +func (gl *GL) MultiTexCoord1i(target glbase.Enum, s int32) { + C.gl3_0_glMultiTexCoord1i(gl.funcs, C.GLenum(target), C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord1fv.xml +func (gl *GL) MultiTexCoord1fv(target glbase.Enum, v []float32) { + C.gl3_0_glMultiTexCoord1fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord1f.xml +func (gl *GL) MultiTexCoord1f(target glbase.Enum, s float32) { + C.gl3_0_glMultiTexCoord1f(gl.funcs, C.GLenum(target), C.GLfloat(s)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord1dv.xml +func (gl *GL) MultiTexCoord1dv(target glbase.Enum, v []float64) { + C.gl3_0_glMultiTexCoord1dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord1d.xml +func (gl *GL) MultiTexCoord1d(target glbase.Enum, s float64) { + C.gl3_0_glMultiTexCoord1d(gl.funcs, C.GLenum(target), C.GLdouble(s)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClientActiveTexture.xml +func (gl *GL) ClientActiveTexture(texture glbase.Enum) { + C.gl3_0_glClientActiveTexture(gl.funcs, C.GLenum(texture)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos3sv.xml +func (gl *GL) WindowPos3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glWindowPos3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos3s.xml +func (gl *GL) WindowPos3s(x, y, z int16) { + C.gl3_0_glWindowPos3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos3iv.xml +func (gl *GL) WindowPos3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glWindowPos3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos3i.xml +func (gl *GL) WindowPos3i(x, y, z int) { + C.gl3_0_glWindowPos3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos3fv.xml +func (gl *GL) WindowPos3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glWindowPos3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos3f.xml +func (gl *GL) WindowPos3f(x, y, z float32) { + C.gl3_0_glWindowPos3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos3dv.xml +func (gl *GL) WindowPos3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glWindowPos3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos3d.xml +func (gl *GL) WindowPos3d(x, y, z float64) { + C.gl3_0_glWindowPos3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos2sv.xml +func (gl *GL) WindowPos2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_0_glWindowPos2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos2s.xml +func (gl *GL) WindowPos2s(x, y int16) { + C.gl3_0_glWindowPos2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos2iv.xml +func (gl *GL) WindowPos2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_0_glWindowPos2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos2i.xml +func (gl *GL) WindowPos2i(x, y int) { + C.gl3_0_glWindowPos2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos2fv.xml +func (gl *GL) WindowPos2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_0_glWindowPos2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos2f.xml +func (gl *GL) WindowPos2f(x, y float32) { + C.gl3_0_glWindowPos2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos2dv.xml +func (gl *GL) WindowPos2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_0_glWindowPos2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos2d.xml +func (gl *GL) WindowPos2d(x, y float64) { + C.gl3_0_glWindowPos2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColorPointer.xml +func (gl *GL) SecondaryColorPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glSecondaryColorPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3usv.xml +func (gl *GL) SecondaryColor3usv(v []uint16) { + C.gl3_0_glSecondaryColor3usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3us.xml +func (gl *GL) SecondaryColor3us(red, green, blue uint16) { + C.gl3_0_glSecondaryColor3us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3uiv.xml +func (gl *GL) SecondaryColor3uiv(v []uint32) { + C.gl3_0_glSecondaryColor3uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3ui.xml +func (gl *GL) SecondaryColor3ui(red, green, blue uint32) { + C.gl3_0_glSecondaryColor3ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3ubv.xml +func (gl *GL) SecondaryColor3ubv(v []uint8) { + C.gl3_0_glSecondaryColor3ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3ub.xml +func (gl *GL) SecondaryColor3ub(red, green, blue uint8) { + C.gl3_0_glSecondaryColor3ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3sv.xml +func (gl *GL) SecondaryColor3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glSecondaryColor3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3s.xml +func (gl *GL) SecondaryColor3s(red, green, blue int16) { + C.gl3_0_glSecondaryColor3s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3iv.xml +func (gl *GL) SecondaryColor3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glSecondaryColor3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3i.xml +func (gl *GL) SecondaryColor3i(red, green, blue int32) { + C.gl3_0_glSecondaryColor3i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3fv.xml +func (gl *GL) SecondaryColor3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glSecondaryColor3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3f.xml +func (gl *GL) SecondaryColor3f(red, green, blue float32) { + C.gl3_0_glSecondaryColor3f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3dv.xml +func (gl *GL) SecondaryColor3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glSecondaryColor3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3d.xml +func (gl *GL) SecondaryColor3d(red, green, blue float64) { + C.gl3_0_glSecondaryColor3d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3bv.xml +func (gl *GL) SecondaryColor3bv(v []byte) { + C.gl3_0_glSecondaryColor3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3b.xml +func (gl *GL) SecondaryColor3b(red, green, blue byte) { + C.gl3_0_glSecondaryColor3b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFogCoordPointer.xml +func (gl *GL) FogCoordPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl3_0_glFogCoordPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFogCoorddv.xml +func (gl *GL) FogCoorddv(coord []float64) { + C.gl3_0_glFogCoorddv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&coord[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFogCoordd.xml +func (gl *GL) FogCoordd(coord float64) { + C.gl3_0_glFogCoordd(gl.funcs, C.GLdouble(coord)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFogCoordfv.xml +func (gl *GL) FogCoordfv(coord []float32) { + C.gl3_0_glFogCoordfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&coord[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFogCoordf.xml +func (gl *GL) FogCoordf(coord float32) { + C.gl3_0_glFogCoordf(gl.funcs, C.GLfloat(coord)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4usv.xml +func (gl *GL) VertexAttrib4usv(index glbase.Attrib, v []uint16) { + C.gl3_0_glVertexAttrib4usv(gl.funcs, C.GLuint(index), (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4uiv.xml +func (gl *GL) VertexAttrib4uiv(index glbase.Attrib, v []uint32) { + C.gl3_0_glVertexAttrib4uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4ubv.xml +func (gl *GL) VertexAttrib4ubv(index glbase.Attrib, v []uint8) { + C.gl3_0_glVertexAttrib4ubv(gl.funcs, C.GLuint(index), (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4sv.xml +func (gl *GL) VertexAttrib4sv(index glbase.Attrib, v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_0_glVertexAttrib4sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4s.xml +func (gl *GL) VertexAttrib4s(index glbase.Attrib, x, y, z, w int16) { + C.gl3_0_glVertexAttrib4s(gl.funcs, C.GLuint(index), C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4iv.xml +func (gl *GL) VertexAttrib4iv(index glbase.Attrib, v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_0_glVertexAttrib4iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4fv.xml +func (gl *GL) VertexAttrib4fv(index glbase.Attrib, v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_0_glVertexAttrib4fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4f.xml +func (gl *GL) VertexAttrib4f(index glbase.Attrib, x, y, z, w float32) { + C.gl3_0_glVertexAttrib4f(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4dv.xml +func (gl *GL) VertexAttrib4dv(index glbase.Attrib, v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_0_glVertexAttrib4dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4d.xml +func (gl *GL) VertexAttrib4d(index glbase.Attrib, x, y, z, w float64) { + C.gl3_0_glVertexAttrib4d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4bv.xml +func (gl *GL) VertexAttrib4bv(index glbase.Attrib, v []byte) { + C.gl3_0_glVertexAttrib4bv(gl.funcs, C.GLuint(index), (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4Nusv.xml +func (gl *GL) VertexAttrib4Nusv(index glbase.Attrib, v []uint16) { + C.gl3_0_glVertexAttrib4Nusv(gl.funcs, C.GLuint(index), (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4Nuiv.xml +func (gl *GL) VertexAttrib4Nuiv(index glbase.Attrib, v []uint32) { + C.gl3_0_glVertexAttrib4Nuiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4Nubv.xml +func (gl *GL) VertexAttrib4Nubv(index glbase.Attrib, v []uint8) { + C.gl3_0_glVertexAttrib4Nubv(gl.funcs, C.GLuint(index), (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4Nub.xml +func (gl *GL) VertexAttrib4Nub(index glbase.Attrib, x, y, z, w uint8) { + C.gl3_0_glVertexAttrib4Nub(gl.funcs, C.GLuint(index), C.GLubyte(x), C.GLubyte(y), C.GLubyte(z), C.GLubyte(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4Nsv.xml +func (gl *GL) VertexAttrib4Nsv(index glbase.Attrib, v []int16) { + C.gl3_0_glVertexAttrib4Nsv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4Niv.xml +func (gl *GL) VertexAttrib4Niv(index glbase.Attrib, v []int32) { + C.gl3_0_glVertexAttrib4Niv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4Nbv.xml +func (gl *GL) VertexAttrib4Nbv(index glbase.Attrib, v []byte) { + C.gl3_0_glVertexAttrib4Nbv(gl.funcs, C.GLuint(index), (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib3sv.xml +func (gl *GL) VertexAttrib3sv(index glbase.Attrib, v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glVertexAttrib3sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib3s.xml +func (gl *GL) VertexAttrib3s(index glbase.Attrib, x, y, z int16) { + C.gl3_0_glVertexAttrib3s(gl.funcs, C.GLuint(index), C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib3fv.xml +func (gl *GL) VertexAttrib3fv(index glbase.Attrib, v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glVertexAttrib3fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib3f.xml +func (gl *GL) VertexAttrib3f(index glbase.Attrib, x, y, z float32) { + C.gl3_0_glVertexAttrib3f(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib3dv.xml +func (gl *GL) VertexAttrib3dv(index glbase.Attrib, v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glVertexAttrib3dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib3d.xml +func (gl *GL) VertexAttrib3d(index glbase.Attrib, x, y, z float64) { + C.gl3_0_glVertexAttrib3d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib2sv.xml +func (gl *GL) VertexAttrib2sv(index glbase.Attrib, v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_0_glVertexAttrib2sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib2s.xml +func (gl *GL) VertexAttrib2s(index glbase.Attrib, x, y int16) { + C.gl3_0_glVertexAttrib2s(gl.funcs, C.GLuint(index), C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib2fv.xml +func (gl *GL) VertexAttrib2fv(index glbase.Attrib, v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_0_glVertexAttrib2fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib2f.xml +func (gl *GL) VertexAttrib2f(index glbase.Attrib, x, y float32) { + C.gl3_0_glVertexAttrib2f(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib2dv.xml +func (gl *GL) VertexAttrib2dv(index glbase.Attrib, v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_0_glVertexAttrib2dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib2d.xml +func (gl *GL) VertexAttrib2d(index glbase.Attrib, x, y float64) { + C.gl3_0_glVertexAttrib2d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib1sv.xml +func (gl *GL) VertexAttrib1sv(index glbase.Attrib, v []int16) { + C.gl3_0_glVertexAttrib1sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib1s.xml +func (gl *GL) VertexAttrib1s(index glbase.Attrib, x int16) { + C.gl3_0_glVertexAttrib1s(gl.funcs, C.GLuint(index), C.GLshort(x)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib1fv.xml +func (gl *GL) VertexAttrib1fv(index glbase.Attrib, v []float32) { + C.gl3_0_glVertexAttrib1fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib1f.xml +func (gl *GL) VertexAttrib1f(index glbase.Attrib, x float32) { + C.gl3_0_glVertexAttrib1f(gl.funcs, C.GLuint(index), C.GLfloat(x)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib1dv.xml +func (gl *GL) VertexAttrib1dv(index glbase.Attrib, v []float64) { + C.gl3_0_glVertexAttrib1dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib1d.xml +func (gl *GL) VertexAttrib1d(index glbase.Attrib, x float64) { + C.gl3_0_glVertexAttrib1d(gl.funcs, C.GLuint(index), C.GLdouble(x)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI4usv.xml +func (gl *GL) VertexAttribI4usv(index glbase.Attrib, v []uint16) { + C.gl3_0_glVertexAttribI4usv(gl.funcs, C.GLuint(index), (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI4ubv.xml +func (gl *GL) VertexAttribI4ubv(index glbase.Attrib, v []uint8) { + C.gl3_0_glVertexAttribI4ubv(gl.funcs, C.GLuint(index), (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI4sv.xml +func (gl *GL) VertexAttribI4sv(index glbase.Attrib, v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_0_glVertexAttribI4sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI4bv.xml +func (gl *GL) VertexAttribI4bv(index glbase.Attrib, v []byte) { + C.gl3_0_glVertexAttribI4bv(gl.funcs, C.GLuint(index), (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI4uiv.xml +func (gl *GL) VertexAttribI4uiv(index glbase.Attrib, v []uint32) { + C.gl3_0_glVertexAttribI4uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI3uiv.xml +func (gl *GL) VertexAttribI3uiv(index glbase.Attrib, v []uint32) { + C.gl3_0_glVertexAttribI3uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI2uiv.xml +func (gl *GL) VertexAttribI2uiv(index glbase.Attrib, v []uint32) { + C.gl3_0_glVertexAttribI2uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI1uiv.xml +func (gl *GL) VertexAttribI1uiv(index glbase.Attrib, v []uint32) { + C.gl3_0_glVertexAttribI1uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI4iv.xml +func (gl *GL) VertexAttribI4iv(index glbase.Attrib, v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_0_glVertexAttribI4iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI3iv.xml +func (gl *GL) VertexAttribI3iv(index glbase.Attrib, v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_0_glVertexAttribI3iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI2iv.xml +func (gl *GL) VertexAttribI2iv(index glbase.Attrib, v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_0_glVertexAttribI2iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI1iv.xml +func (gl *GL) VertexAttribI1iv(index glbase.Attrib, v []int32) { + C.gl3_0_glVertexAttribI1iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI4ui.xml +func (gl *GL) VertexAttribI4ui(index glbase.Attrib, x, y, z, w uint32) { + C.gl3_0_glVertexAttribI4ui(gl.funcs, C.GLuint(index), C.GLuint(x), C.GLuint(y), C.GLuint(z), C.GLuint(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI3ui.xml +func (gl *GL) VertexAttribI3ui(index glbase.Attrib, x, y, z uint32) { + C.gl3_0_glVertexAttribI3ui(gl.funcs, C.GLuint(index), C.GLuint(x), C.GLuint(y), C.GLuint(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI2ui.xml +func (gl *GL) VertexAttribI2ui(index glbase.Attrib, x, y uint32) { + C.gl3_0_glVertexAttribI2ui(gl.funcs, C.GLuint(index), C.GLuint(x), C.GLuint(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI1ui.xml +func (gl *GL) VertexAttribI1ui(index glbase.Attrib, x uint32) { + C.gl3_0_glVertexAttribI1ui(gl.funcs, C.GLuint(index), C.GLuint(x)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI4i.xml +func (gl *GL) VertexAttribI4i(index glbase.Attrib, x, y, z, w int) { + C.gl3_0_glVertexAttribI4i(gl.funcs, C.GLuint(index), C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI3i.xml +func (gl *GL) VertexAttribI3i(index glbase.Attrib, x, y, z int) { + C.gl3_0_glVertexAttribI3i(gl.funcs, C.GLuint(index), C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI2i.xml +func (gl *GL) VertexAttribI2i(index glbase.Attrib, x, y int) { + C.gl3_0_glVertexAttribI2i(gl.funcs, C.GLuint(index), C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI1i.xml +func (gl *GL) VertexAttribI1i(index glbase.Attrib, x int) { + C.gl3_0_glVertexAttribI1i(gl.funcs, C.GLuint(index), C.GLint(x)) +} diff --git a/gl/3.1/funcs.cpp b/gl/3.1/funcs.cpp new file mode 100644 index 00000000..7f984676 --- /dev/null +++ b/gl/3.1/funcs.cpp @@ -0,0 +1,1422 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#include +#include + +#include "funcs.h" + +void *gl3_1_funcs() { + QOpenGLFunctions_3_1* funcs = QOpenGLContext::currentContext()->versionFunctions(); + if (!funcs) { + return 0; + } + funcs->initializeOpenGLFunctions(); + return funcs; +} + + +void gl3_1_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewport(x, y, width, height); +} + +void gl3_1_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRange(nearVal, farVal); +} + +GLboolean gl3_1_glIsEnabled(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabled(cap); +} + +void gl3_1_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameteriv(target, level, pname, params); +} + +void gl3_1_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameterfv(target, level, pname, params); +} + +void gl3_1_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameteriv(target, pname, params); +} + +void gl3_1_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterfv(target, pname, params); +} + +void gl3_1_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexImage(target, level, format, gltype, pixels); +} + +void gl3_1_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegerv(pname, params); +} + +void gl3_1_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFloatv(pname, params); +} + +GLenum gl3_1_glGetError(void *_glfuncs) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetError(); +} + +void gl3_1_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetDoublev(pname, params); +} + +void gl3_1_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleanv(pname, params); +} + +void gl3_1_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadPixels(x, y, width, height, format, gltype, pixels); +} + +void gl3_1_glReadBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadBuffer(mode); +} + +void gl3_1_glPixelStorei(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStorei(pname, param); +} + +void gl3_1_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStoref(pname, param); +} + +void gl3_1_glDepthFunc(void *_glfuncs, GLenum glfunc) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthFunc(glfunc); +} + +void gl3_1_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOp(fail, zfail, zpass); +} + +void gl3_1_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFunc(glfunc, ref, mask); +} + +void gl3_1_glLogicOp(void *_glfuncs, GLenum opcode) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLogicOp(opcode); +} + +void gl3_1_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFunc(sfactor, dfactor); +} + +void gl3_1_glFlush(void *_glfuncs) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlush(); +} + +void gl3_1_glFinish(void *_glfuncs) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFinish(); +} + +void gl3_1_glEnable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnable(cap); +} + +void gl3_1_glDisable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisable(cap); +} + +void gl3_1_glDepthMask(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthMask(flag); +} + +void gl3_1_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMask(red, green, blue, alpha); +} + +void gl3_1_glStencilMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMask(mask); +} + +void gl3_1_glClearDepth(void *_glfuncs, GLdouble depth) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearDepth(depth); +} + +void gl3_1_glClearStencil(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearStencil(s); +} + +void gl3_1_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearColor(red, green, blue, alpha); +} + +void gl3_1_glClear(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClear(mask); +} + +void gl3_1_glDrawBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffer(mode); +} + +void gl3_1_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage2D(target, level, internalFormat, width, height, border, format, gltype, pixels); +} + +void gl3_1_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage1D(target, level, internalFormat, width, border, format, gltype, pixels); +} + +void gl3_1_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteriv(target, pname, params); +} + +void gl3_1_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteri(target, pname, param); +} + +void gl3_1_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterfv(target, pname, params); +} + +void gl3_1_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterf(target, pname, param); +} + +void gl3_1_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissor(x, y, width, height); +} + +void gl3_1_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonMode(face, mode); +} + +void gl3_1_glPointSize(void *_glfuncs, GLfloat size) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointSize(size); +} + +void gl3_1_glLineWidth(void *_glfuncs, GLfloat width) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineWidth(width); +} + +void gl3_1_glHint(void *_glfuncs, GLenum target, GLenum mode) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glHint(target, mode); +} + +void gl3_1_glFrontFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrontFace(mode); +} + +void gl3_1_glCullFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCullFace(mode); +} + +void gl3_1_glIndexubv(void *_glfuncs, const GLubyte* c) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexubv(c); +} + +void gl3_1_glIndexub(void *_glfuncs, GLubyte c) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexub(c); +} + +GLboolean gl3_1_glIsTexture(void *_glfuncs, GLuint texture) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsTexture(texture); +} + +void gl3_1_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenTextures(n, textures); +} + +void gl3_1_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteTextures(n, textures); +} + +void gl3_1_glBindTexture(void *_glfuncs, GLenum target, GLuint texture) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindTexture(target, texture); +} + +void gl3_1_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, gltype, pixels); +} + +void gl3_1_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage1D(target, level, xoffset, width, format, gltype, pixels); +} + +void gl3_1_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); +} + +void gl3_1_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage1D(target, level, xoffset, x, y, width); +} + +void gl3_1_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage2D(target, level, internalFormat, x, y, width, height, border); +} + +void gl3_1_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage1D(target, level, internalFormat, x, y, width, border); +} + +void gl3_1_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonOffset(factor, units); +} + +void gl3_1_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElements(mode, count, gltype, indices); +} + +void gl3_1_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArrays(mode, first, count); +} + +void gl3_1_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); +} + +void gl3_1_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, gltype, pixels); +} + +void gl3_1_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage3D(target, level, internalFormat, width, height, depth, border, format, gltype, pixels); +} + +void gl3_1_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawRangeElements(mode, start, end, count, gltype, indices); +} + +void gl3_1_glBlendEquation(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquation(mode); +} + +void gl3_1_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendColor(red, green, blue, alpha); +} + +void gl3_1_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetCompressedTexImage(target, level, img); +} + +void gl3_1_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data); +} + +void gl3_1_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); +} + +void gl3_1_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); +} + +void gl3_1_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage1D(target, level, internalFormat, width, border, imageSize, data); +} + +void gl3_1_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data); +} + +void gl3_1_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage3D(target, level, internalFormat, width, height, depth, border, imageSize, data); +} + +void gl3_1_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSampleCoverage(value, invert); +} + +void gl3_1_glActiveTexture(void *_glfuncs, GLenum texture) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glActiveTexture(texture); +} + +void gl3_1_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteriv(pname, params); +} + +void gl3_1_glPointParameteri(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteri(pname, param); +} + +void gl3_1_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterfv(pname, params); +} + +void gl3_1_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterf(pname, param); +} + +void gl3_1_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiDrawArrays(mode, first, count, drawcount); +} + +void gl3_1_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); +} + +void gl3_1_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferParameteriv(target, pname, params); +} + +GLboolean gl3_1_glUnmapBuffer(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glUnmapBuffer(target); +} + +void gl3_1_glGetBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferSubData(target, offset, size, data); +} + +void gl3_1_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferSubData(target, offset, size, data); +} + +void gl3_1_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferData(target, size, data, usage); +} + +GLboolean gl3_1_glIsBuffer(void *_glfuncs, GLuint buffer) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsBuffer(buffer); +} + +void gl3_1_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenBuffers(n, buffers); +} + +void gl3_1_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteBuffers(n, buffers); +} + +void gl3_1_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBuffer(target, buffer); +} + +void gl3_1_glGetQueryObjectuiv(void *_glfuncs, GLuint id, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectuiv(id, pname, params); +} + +void gl3_1_glGetQueryObjectiv(void *_glfuncs, GLuint id, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectiv(id, pname, params); +} + +void gl3_1_glGetQueryiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryiv(target, pname, params); +} + +void gl3_1_glEndQuery(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndQuery(target); +} + +void gl3_1_glBeginQuery(void *_glfuncs, GLenum target, GLuint id) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginQuery(target, id); +} + +GLboolean gl3_1_glIsQuery(void *_glfuncs, GLuint id) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsQuery(id); +} + +void gl3_1_glDeleteQueries(void *_glfuncs, GLsizei n, const GLuint* ids) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteQueries(n, ids); +} + +void gl3_1_glGenQueries(void *_glfuncs, GLsizei n, GLuint* ids) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenQueries(n, ids); +} + +void gl3_1_glVertexAttribPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLboolean normalized, GLsizei stride, const GLvoid* offset) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribPointer(index, size, gltype, normalized, stride, offset); +} + +void gl3_1_glValidateProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glValidateProgram(program); +} + +void gl3_1_glUniformMatrix4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4fv(location, count, transpose, value); +} + +void gl3_1_glUniformMatrix3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3fv(location, count, transpose, value); +} + +void gl3_1_glUniformMatrix2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2fv(location, count, transpose, value); +} + +void gl3_1_glUniform4iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4iv(location, count, value); +} + +void gl3_1_glUniform3iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3iv(location, count, value); +} + +void gl3_1_glUniform2iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2iv(location, count, value); +} + +void gl3_1_glUniform1iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1iv(location, count, value); +} + +void gl3_1_glUniform4fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4fv(location, count, value); +} + +void gl3_1_glUniform3fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3fv(location, count, value); +} + +void gl3_1_glUniform2fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2fv(location, count, value); +} + +void gl3_1_glUniform1fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1fv(location, count, value); +} + +void gl3_1_glUniform4i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4i(location, v0, v1, v2, v3); +} + +void gl3_1_glUniform3i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3i(location, v0, v1, v2); +} + +void gl3_1_glUniform2i(void *_glfuncs, GLint location, GLint v0, GLint v1) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2i(location, v0, v1); +} + +void gl3_1_glUniform1i(void *_glfuncs, GLint location, GLint v0) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1i(location, v0); +} + +void gl3_1_glUniform4f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4f(location, v0, v1, v2, v3); +} + +void gl3_1_glUniform3f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3f(location, v0, v1, v2); +} + +void gl3_1_glUniform2f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2f(location, v0, v1); +} + +void gl3_1_glUniform1f(void *_glfuncs, GLint location, GLfloat v0) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1f(location, v0); +} + +void gl3_1_glUseProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUseProgram(program); +} + +void gl3_1_glShaderSource(void *_glfuncs, GLuint shader, GLsizei count, const GLchar** source, const GLint* length) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShaderSource(shader, count, source, length); +} + +void gl3_1_glLinkProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLinkProgram(program); +} + +GLboolean gl3_1_glIsShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsShader(shader); +} + +GLboolean gl3_1_glIsProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsProgram(program); +} + +void gl3_1_glGetVertexAttribiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribiv(index, pname, params); +} + +void gl3_1_glGetVertexAttribfv(void *_glfuncs, GLuint index, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribfv(index, pname, params); +} + +void gl3_1_glGetVertexAttribdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribdv(index, pname, params); +} + +void gl3_1_glGetUniformiv(void *_glfuncs, GLuint program, GLint location, GLint* params) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformiv(program, location, params); +} + +void gl3_1_glGetUniformfv(void *_glfuncs, GLuint program, GLint location, GLfloat* params) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformfv(program, location, params); +} + +GLint gl3_1_glGetUniformLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetUniformLocation(program, name); +} + +void gl3_1_glGetShaderSource(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderSource(shader, bufSize, length, source); +} + +void gl3_1_glGetShaderInfoLog(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderInfoLog(shader, bufSize, length, infoLog); +} + +void gl3_1_glGetShaderiv(void *_glfuncs, GLuint shader, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderiv(shader, pname, params); +} + +void gl3_1_glGetProgramInfoLog(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramInfoLog(program, bufSize, length, infoLog); +} + +void gl3_1_glGetProgramiv(void *_glfuncs, GLuint program, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramiv(program, pname, params); +} + +GLint gl3_1_glGetAttribLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetAttribLocation(program, name); +} + +void gl3_1_glGetAttachedShaders(void *_glfuncs, GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetAttachedShaders(program, maxCount, count, obj); +} + +void gl3_1_glGetActiveUniform(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniform(program, index, bufSize, length, size, gltype, name); +} + +void gl3_1_glGetActiveAttrib(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveAttrib(program, index, bufSize, length, size, gltype, name); +} + +void gl3_1_glEnableVertexAttribArray(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnableVertexAttribArray(index); +} + +void gl3_1_glDisableVertexAttribArray(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisableVertexAttribArray(index); +} + +void gl3_1_glDetachShader(void *_glfuncs, GLuint program, GLuint shader) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDetachShader(program, shader); +} + +void gl3_1_glDeleteShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteShader(shader); +} + +void gl3_1_glDeleteProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteProgram(program); +} + +GLuint gl3_1_glCreateShader(void *_glfuncs, GLenum gltype) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCreateShader(gltype); +} + +GLuint gl3_1_glCreateProgram(void *_glfuncs) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCreateProgram(); +} + +void gl3_1_glCompileShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompileShader(shader); +} + +void gl3_1_glBindAttribLocation(void *_glfuncs, GLuint program, GLuint index, const GLchar* name) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindAttribLocation(program, index, name); +} + +void gl3_1_glAttachShader(void *_glfuncs, GLuint program, GLuint shader) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAttachShader(program, shader); +} + +void gl3_1_glStencilMaskSeparate(void *_glfuncs, GLenum face, GLuint mask) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMaskSeparate(face, mask); +} + +void gl3_1_glStencilFuncSeparate(void *_glfuncs, GLenum face, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFuncSeparate(face, glfunc, ref, mask); +} + +void gl3_1_glStencilOpSeparate(void *_glfuncs, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOpSeparate(face, sfail, dpfail, dppass); +} + +void gl3_1_glDrawBuffers(void *_glfuncs, GLsizei n, const GLenum* bufs) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffers(n, bufs); +} + +void gl3_1_glBlendEquationSeparate(void *_glfuncs, GLenum modeRGB, GLenum modeAlpha) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquationSeparate(modeRGB, modeAlpha); +} + +void gl3_1_glUniformMatrix4x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x3fv(location, count, transpose, value); +} + +void gl3_1_glUniformMatrix3x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x4fv(location, count, transpose, value); +} + +void gl3_1_glUniformMatrix4x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x2fv(location, count, transpose, value); +} + +void gl3_1_glUniformMatrix2x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x4fv(location, count, transpose, value); +} + +void gl3_1_glUniformMatrix3x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x2fv(location, count, transpose, value); +} + +void gl3_1_glUniformMatrix2x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x3fv(location, count, transpose, value); +} + +GLboolean gl3_1_glIsVertexArray(void *_glfuncs, GLuint array) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsVertexArray(array); +} + +void gl3_1_glGenVertexArrays(void *_glfuncs, GLsizei n, GLuint* arrays) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenVertexArrays(n, arrays); +} + +void gl3_1_glDeleteVertexArrays(void *_glfuncs, GLsizei n, const GLuint* arrays) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteVertexArrays(n, arrays); +} + +void gl3_1_glBindVertexArray(void *_glfuncs, GLuint array) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindVertexArray(array); +} + +void gl3_1_glFlushMappedBufferRange(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr length) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlushMappedBufferRange(target, offset, length); +} + +void gl3_1_glFramebufferTextureLayer(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTextureLayer(target, attachment, texture, level, layer); +} + +void gl3_1_glRenderbufferStorageMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRenderbufferStorageMultisample(target, samples, internalFormat, width, height); +} + +void gl3_1_glBlitFramebuffer(void *_glfuncs, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); +} + +void gl3_1_glGenerateMipmap(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenerateMipmap(target); +} + +void gl3_1_glGetFramebufferAttachmentParameteriv(void *_glfuncs, GLenum target, GLenum attachment, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFramebufferAttachmentParameteriv(target, attachment, pname, params); +} + +void gl3_1_glFramebufferRenderbuffer(void *_glfuncs, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer); +} + +void gl3_1_glFramebufferTexture3D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset); +} + +void gl3_1_glFramebufferTexture2D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture2D(target, attachment, textarget, texture, level); +} + +void gl3_1_glFramebufferTexture1D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture1D(target, attachment, textarget, texture, level); +} + +GLenum gl3_1_glCheckFramebufferStatus(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCheckFramebufferStatus(target); +} + +void gl3_1_glGenFramebuffers(void *_glfuncs, GLsizei n, GLuint* framebuffers) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenFramebuffers(n, framebuffers); +} + +void gl3_1_glDeleteFramebuffers(void *_glfuncs, GLsizei n, const GLuint* framebuffers) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteFramebuffers(n, framebuffers); +} + +void gl3_1_glBindFramebuffer(void *_glfuncs, GLenum target, GLuint framebuffer) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFramebuffer(target, framebuffer); +} + +GLboolean gl3_1_glIsFramebuffer(void *_glfuncs, GLuint framebuffer) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsFramebuffer(framebuffer); +} + +void gl3_1_glGetRenderbufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetRenderbufferParameteriv(target, pname, params); +} + +void gl3_1_glRenderbufferStorage(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRenderbufferStorage(target, internalFormat, width, height); +} + +void gl3_1_glGenRenderbuffers(void *_glfuncs, GLsizei n, GLuint* renderbuffers) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenRenderbuffers(n, renderbuffers); +} + +void gl3_1_glDeleteRenderbuffers(void *_glfuncs, GLsizei n, const GLuint* renderbuffers) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteRenderbuffers(n, renderbuffers); +} + +void gl3_1_glBindRenderbuffer(void *_glfuncs, GLenum target, GLuint renderbuffer) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindRenderbuffer(target, renderbuffer); +} + +GLboolean gl3_1_glIsRenderbuffer(void *_glfuncs, GLuint renderbuffer) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsRenderbuffer(renderbuffer); +} + +void gl3_1_glClearBufferfi(void *_glfuncs, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferfi(buffer, drawbuffer, depth, stencil); +} + +void gl3_1_glClearBufferfv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLfloat* value) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferfv(buffer, drawbuffer, value); +} + +void gl3_1_glClearBufferuiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLuint* value) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferuiv(buffer, drawbuffer, value); +} + +void gl3_1_glClearBufferiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLint* value) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferiv(buffer, drawbuffer, value); +} + +void gl3_1_glGetTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterIuiv(target, pname, params); +} + +void gl3_1_glGetTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterIiv(target, pname, params); +} + +void gl3_1_glTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, const GLuint* params) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterIuiv(target, pname, params); +} + +void gl3_1_glTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterIiv(target, pname, params); +} + +void gl3_1_glUniform4uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4uiv(location, count, value); +} + +void gl3_1_glUniform3uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3uiv(location, count, value); +} + +void gl3_1_glUniform2uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2uiv(location, count, value); +} + +void gl3_1_glUniform1uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1uiv(location, count, value); +} + +void gl3_1_glUniform4ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4ui(location, v0, v1, v2, v3); +} + +void gl3_1_glUniform3ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3ui(location, v0, v1, v2); +} + +void gl3_1_glUniform2ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2ui(location, v0, v1); +} + +void gl3_1_glUniform1ui(void *_glfuncs, GLint location, GLuint v0) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1ui(location, v0); +} + +GLint gl3_1_glGetFragDataLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetFragDataLocation(program, name); +} + +void gl3_1_glBindFragDataLocation(void *_glfuncs, GLuint program, GLuint color, const GLchar* name) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFragDataLocation(program, color, name); +} + +void gl3_1_glGetUniformuiv(void *_glfuncs, GLuint program, GLint location, GLuint* params) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformuiv(program, location, params); +} + +void gl3_1_glGetVertexAttribIuiv(void *_glfuncs, GLuint index, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribIuiv(index, pname, params); +} + +void gl3_1_glGetVertexAttribIiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribIiv(index, pname, params); +} + +void gl3_1_glVertexAttribIPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribIPointer(index, size, gltype, stride, pointer); +} + +void gl3_1_glEndConditionalRender(void *_glfuncs) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndConditionalRender(); +} + +void gl3_1_glBeginConditionalRender(void *_glfuncs, GLuint id, GLenum mode) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginConditionalRender(id, mode); +} + +void gl3_1_glClampColor(void *_glfuncs, GLenum target, GLenum clamp) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClampColor(target, clamp); +} + +void gl3_1_glGetTransformFeedbackVarying(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTransformFeedbackVarying(program, index, bufSize, length, size, gltype, name); +} + +void gl3_1_glBindBufferBase(void *_glfuncs, GLenum target, GLuint index, GLuint buffer) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBufferBase(target, index, buffer); +} + +void gl3_1_glBindBufferRange(void *_glfuncs, GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBufferRange(target, index, buffer, offset, size); +} + +void gl3_1_glEndTransformFeedback(void *_glfuncs) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndTransformFeedback(); +} + +void gl3_1_glBeginTransformFeedback(void *_glfuncs, GLenum primitiveMode) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginTransformFeedback(primitiveMode); +} + +GLboolean gl3_1_glIsEnabledi(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabledi(target, index); +} + +void gl3_1_glDisablei(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisablei(target, index); +} + +void gl3_1_glEnablei(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnablei(target, index); +} + +void gl3_1_glGetIntegeri_v(void *_glfuncs, GLenum target, GLuint index, GLint* data) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegeri_v(target, index, data); +} + +void gl3_1_glGetBooleani_v(void *_glfuncs, GLenum target, GLuint index, GLboolean* data) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleani_v(target, index, data); +} + +void gl3_1_glColorMaski(void *_glfuncs, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMaski(index, r, g, b, a); +} + +void gl3_1_glCopyBufferSubData(void *_glfuncs, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); +} + +void gl3_1_glUniformBlockBinding(void *_glfuncs, GLuint program, GLuint v0, GLuint v1) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformBlockBinding(program, v0, v1); +} + +void gl3_1_glGetActiveUniformBlockName(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName); +} + +void gl3_1_glGetActiveUniformBlockiv(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params); +} + +GLuint gl3_1_glGetUniformBlockIndex(void *_glfuncs, GLuint program, const GLchar* uniformBlockName) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetUniformBlockIndex(program, uniformBlockName); +} + +void gl3_1_glGetActiveUniformName(void *_glfuncs, GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformName(program, uniformIndex, bufSize, length, uniformName); +} + +void gl3_1_glGetActiveUniformsiv(void *_glfuncs, GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params); +} + +void gl3_1_glPrimitiveRestartIndex(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPrimitiveRestartIndex(index); +} + +void gl3_1_glTexBuffer(void *_glfuncs, GLenum target, GLenum internalFormat, GLuint buffer) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexBuffer(target, internalFormat, buffer); +} + +void gl3_1_glDrawElementsInstanced(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsInstanced(mode, count, gltype, indices, instancecount); +} + +void gl3_1_glDrawArraysInstanced(void *_glfuncs, GLenum mode, GLint first, GLsizei count, GLsizei instancecount) +{ + QOpenGLFunctions_3_1* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArraysInstanced(mode, first, count, instancecount); +} + diff --git a/gl/3.1/funcs.h b/gl/3.1/funcs.h new file mode 100644 index 00000000..b06680d6 --- /dev/null +++ b/gl/3.1/funcs.h @@ -0,0 +1,276 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#ifndef __cplusplus +#include +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef char GLchar; +typedef signed char GLbyte; /* 1-byte signed */ +typedef short GLshort; /* 2-byte signed */ +typedef int GLint; /* 4-byte signed */ +typedef unsigned char GLubyte; /* 1-byte unsigned */ +typedef unsigned short GLushort; /* 2-byte unsigned */ +typedef unsigned int GLuint; /* 4-byte unsigned */ +typedef int GLsizei; /* 4-byte signed */ +typedef float GLfloat; /* single precision float */ +typedef float GLclampf; /* single precision float in [0,1] */ +typedef double GLdouble; /* double precision float */ +typedef double GLclampd; /* double precision float in [0,1] */ +typedef int64_t GLint64; +typedef uint64_t GLuint64; +typedef ptrdiff_t GLintptr; +typedef ptrdiff_t GLsizeiptr; +typedef ptrdiff_t GLintptrARB; +typedef ptrdiff_t GLsizeiptrARB; +typedef struct __GLsync *GLsync; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +void *gl3_1_funcs(); + +void gl3_1_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl3_1_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal); +GLboolean gl3_1_glIsEnabled(void *_glfuncs, GLenum cap); +void gl3_1_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params); +void gl3_1_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params); +void gl3_1_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_1_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl3_1_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels); +void gl3_1_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params); +void gl3_1_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params); +GLenum gl3_1_glGetError(void *_glfuncs); +void gl3_1_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params); +void gl3_1_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params); +void gl3_1_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels); +void gl3_1_glReadBuffer(void *_glfuncs, GLenum mode); +void gl3_1_glPixelStorei(void *_glfuncs, GLenum pname, GLint param); +void gl3_1_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param); +void gl3_1_glDepthFunc(void *_glfuncs, GLenum glfunc); +void gl3_1_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass); +void gl3_1_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask); +void gl3_1_glLogicOp(void *_glfuncs, GLenum opcode); +void gl3_1_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor); +void gl3_1_glFlush(void *_glfuncs); +void gl3_1_glFinish(void *_glfuncs); +void gl3_1_glEnable(void *_glfuncs, GLenum cap); +void gl3_1_glDisable(void *_glfuncs, GLenum cap); +void gl3_1_glDepthMask(void *_glfuncs, GLboolean flag); +void gl3_1_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +void gl3_1_glStencilMask(void *_glfuncs, GLuint mask); +void gl3_1_glClearDepth(void *_glfuncs, GLdouble depth); +void gl3_1_glClearStencil(void *_glfuncs, GLint s); +void gl3_1_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl3_1_glClear(void *_glfuncs, GLbitfield mask); +void gl3_1_glDrawBuffer(void *_glfuncs, GLenum mode); +void gl3_1_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_1_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_1_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl3_1_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl3_1_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl3_1_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl3_1_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl3_1_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode); +void gl3_1_glPointSize(void *_glfuncs, GLfloat size); +void gl3_1_glLineWidth(void *_glfuncs, GLfloat width); +void gl3_1_glHint(void *_glfuncs, GLenum target, GLenum mode); +void gl3_1_glFrontFace(void *_glfuncs, GLenum mode); +void gl3_1_glCullFace(void *_glfuncs, GLenum mode); +void gl3_1_glIndexubv(void *_glfuncs, const GLubyte* c); +void gl3_1_glIndexub(void *_glfuncs, GLubyte c); +GLboolean gl3_1_glIsTexture(void *_glfuncs, GLuint texture); +void gl3_1_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures); +void gl3_1_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures); +void gl3_1_glBindTexture(void *_glfuncs, GLenum target, GLuint texture); +void gl3_1_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_1_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_1_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl3_1_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +void gl3_1_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +void gl3_1_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border); +void gl3_1_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units); +void gl3_1_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl3_1_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count); +void gl3_1_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl3_1_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_1_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_1_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl3_1_glBlendEquation(void *_glfuncs, GLenum mode); +void gl3_1_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl3_1_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img); +void gl3_1_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl3_1_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl3_1_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl3_1_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data); +void gl3_1_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data); +void gl3_1_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data); +void gl3_1_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert); +void gl3_1_glActiveTexture(void *_glfuncs, GLenum texture); +void gl3_1_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params); +void gl3_1_glPointParameteri(void *_glfuncs, GLenum pname, GLint param); +void gl3_1_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl3_1_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param); +void gl3_1_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount); +void gl3_1_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +void gl3_1_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +GLboolean gl3_1_glUnmapBuffer(void *_glfuncs, GLenum target); +void gl3_1_glGetBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data); +void gl3_1_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data); +void gl3_1_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage); +GLboolean gl3_1_glIsBuffer(void *_glfuncs, GLuint buffer); +void gl3_1_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers); +void gl3_1_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers); +void gl3_1_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer); +void gl3_1_glGetQueryObjectuiv(void *_glfuncs, GLuint id, GLenum pname, GLuint* params); +void gl3_1_glGetQueryObjectiv(void *_glfuncs, GLuint id, GLenum pname, GLint* params); +void gl3_1_glGetQueryiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_1_glEndQuery(void *_glfuncs, GLenum target); +void gl3_1_glBeginQuery(void *_glfuncs, GLenum target, GLuint id); +GLboolean gl3_1_glIsQuery(void *_glfuncs, GLuint id); +void gl3_1_glDeleteQueries(void *_glfuncs, GLsizei n, const GLuint* ids); +void gl3_1_glGenQueries(void *_glfuncs, GLsizei n, GLuint* ids); +void gl3_1_glVertexAttribPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLboolean normalized, GLsizei stride, const GLvoid* offset); +void gl3_1_glValidateProgram(void *_glfuncs, GLuint program); +void gl3_1_glUniformMatrix4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_1_glUniformMatrix3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_1_glUniformMatrix2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_1_glUniform4iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl3_1_glUniform3iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl3_1_glUniform2iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl3_1_glUniform1iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl3_1_glUniform4fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl3_1_glUniform3fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl3_1_glUniform2fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl3_1_glUniform1fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl3_1_glUniform4i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +void gl3_1_glUniform3i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2); +void gl3_1_glUniform2i(void *_glfuncs, GLint location, GLint v0, GLint v1); +void gl3_1_glUniform1i(void *_glfuncs, GLint location, GLint v0); +void gl3_1_glUniform4f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +void gl3_1_glUniform3f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +void gl3_1_glUniform2f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1); +void gl3_1_glUniform1f(void *_glfuncs, GLint location, GLfloat v0); +void gl3_1_glUseProgram(void *_glfuncs, GLuint program); +void gl3_1_glShaderSource(void *_glfuncs, GLuint shader, GLsizei count, const GLchar** source, const GLint* length); +void gl3_1_glLinkProgram(void *_glfuncs, GLuint program); +GLboolean gl3_1_glIsShader(void *_glfuncs, GLuint shader); +GLboolean gl3_1_glIsProgram(void *_glfuncs, GLuint program); +void gl3_1_glGetVertexAttribiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params); +void gl3_1_glGetVertexAttribfv(void *_glfuncs, GLuint index, GLenum pname, GLfloat* params); +void gl3_1_glGetVertexAttribdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params); +void gl3_1_glGetUniformiv(void *_glfuncs, GLuint program, GLint location, GLint* params); +void gl3_1_glGetUniformfv(void *_glfuncs, GLuint program, GLint location, GLfloat* params); +GLint gl3_1_glGetUniformLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl3_1_glGetShaderSource(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source); +void gl3_1_glGetShaderInfoLog(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl3_1_glGetShaderiv(void *_glfuncs, GLuint shader, GLenum pname, GLint* params); +void gl3_1_glGetProgramInfoLog(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl3_1_glGetProgramiv(void *_glfuncs, GLuint program, GLenum pname, GLint* params); +GLint gl3_1_glGetAttribLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl3_1_glGetAttachedShaders(void *_glfuncs, GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj); +void gl3_1_glGetActiveUniform(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name); +void gl3_1_glGetActiveAttrib(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name); +void gl3_1_glEnableVertexAttribArray(void *_glfuncs, GLuint index); +void gl3_1_glDisableVertexAttribArray(void *_glfuncs, GLuint index); +void gl3_1_glDetachShader(void *_glfuncs, GLuint program, GLuint shader); +void gl3_1_glDeleteShader(void *_glfuncs, GLuint shader); +void gl3_1_glDeleteProgram(void *_glfuncs, GLuint program); +GLuint gl3_1_glCreateShader(void *_glfuncs, GLenum gltype); +GLuint gl3_1_glCreateProgram(void *_glfuncs); +void gl3_1_glCompileShader(void *_glfuncs, GLuint shader); +void gl3_1_glBindAttribLocation(void *_glfuncs, GLuint program, GLuint index, const GLchar* name); +void gl3_1_glAttachShader(void *_glfuncs, GLuint program, GLuint shader); +void gl3_1_glStencilMaskSeparate(void *_glfuncs, GLenum face, GLuint mask); +void gl3_1_glStencilFuncSeparate(void *_glfuncs, GLenum face, GLenum glfunc, GLint ref, GLuint mask); +void gl3_1_glStencilOpSeparate(void *_glfuncs, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +void gl3_1_glDrawBuffers(void *_glfuncs, GLsizei n, const GLenum* bufs); +void gl3_1_glBlendEquationSeparate(void *_glfuncs, GLenum modeRGB, GLenum modeAlpha); +void gl3_1_glUniformMatrix4x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_1_glUniformMatrix3x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_1_glUniformMatrix4x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_1_glUniformMatrix2x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_1_glUniformMatrix3x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_1_glUniformMatrix2x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +GLboolean gl3_1_glIsVertexArray(void *_glfuncs, GLuint array); +void gl3_1_glGenVertexArrays(void *_glfuncs, GLsizei n, GLuint* arrays); +void gl3_1_glDeleteVertexArrays(void *_glfuncs, GLsizei n, const GLuint* arrays); +void gl3_1_glBindVertexArray(void *_glfuncs, GLuint array); +void gl3_1_glFlushMappedBufferRange(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr length); +void gl3_1_glFramebufferTextureLayer(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +void gl3_1_glRenderbufferStorageMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height); +void gl3_1_glBlitFramebuffer(void *_glfuncs, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +void gl3_1_glGenerateMipmap(void *_glfuncs, GLenum target); +void gl3_1_glGetFramebufferAttachmentParameteriv(void *_glfuncs, GLenum target, GLenum attachment, GLenum pname, GLint* params); +void gl3_1_glFramebufferRenderbuffer(void *_glfuncs, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +void gl3_1_glFramebufferTexture3D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +void gl3_1_glFramebufferTexture2D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +void gl3_1_glFramebufferTexture1D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLenum gl3_1_glCheckFramebufferStatus(void *_glfuncs, GLenum target); +void gl3_1_glGenFramebuffers(void *_glfuncs, GLsizei n, GLuint* framebuffers); +void gl3_1_glDeleteFramebuffers(void *_glfuncs, GLsizei n, const GLuint* framebuffers); +void gl3_1_glBindFramebuffer(void *_glfuncs, GLenum target, GLuint framebuffer); +GLboolean gl3_1_glIsFramebuffer(void *_glfuncs, GLuint framebuffer); +void gl3_1_glGetRenderbufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_1_glRenderbufferStorage(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height); +void gl3_1_glGenRenderbuffers(void *_glfuncs, GLsizei n, GLuint* renderbuffers); +void gl3_1_glDeleteRenderbuffers(void *_glfuncs, GLsizei n, const GLuint* renderbuffers); +void gl3_1_glBindRenderbuffer(void *_glfuncs, GLenum target, GLuint renderbuffer); +GLboolean gl3_1_glIsRenderbuffer(void *_glfuncs, GLuint renderbuffer); +void gl3_1_glClearBufferfi(void *_glfuncs, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); +void gl3_1_glClearBufferfv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLfloat* value); +void gl3_1_glClearBufferuiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLuint* value); +void gl3_1_glClearBufferiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLint* value); +void gl3_1_glGetTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, GLuint* params); +void gl3_1_glGetTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_1_glTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, const GLuint* params); +void gl3_1_glTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl3_1_glUniform4uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl3_1_glUniform3uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl3_1_glUniform2uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl3_1_glUniform1uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl3_1_glUniform4ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +void gl3_1_glUniform3ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2); +void gl3_1_glUniform2ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1); +void gl3_1_glUniform1ui(void *_glfuncs, GLint location, GLuint v0); +GLint gl3_1_glGetFragDataLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl3_1_glBindFragDataLocation(void *_glfuncs, GLuint program, GLuint color, const GLchar* name); +void gl3_1_glGetUniformuiv(void *_glfuncs, GLuint program, GLint location, GLuint* params); +void gl3_1_glGetVertexAttribIuiv(void *_glfuncs, GLuint index, GLenum pname, GLuint* params); +void gl3_1_glGetVertexAttribIiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params); +void gl3_1_glVertexAttribIPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl3_1_glEndConditionalRender(void *_glfuncs); +void gl3_1_glBeginConditionalRender(void *_glfuncs, GLuint id, GLenum mode); +void gl3_1_glClampColor(void *_glfuncs, GLenum target, GLenum clamp); +void gl3_1_glGetTransformFeedbackVarying(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* gltype, GLchar* name); +void gl3_1_glBindBufferBase(void *_glfuncs, GLenum target, GLuint index, GLuint buffer); +void gl3_1_glBindBufferRange(void *_glfuncs, GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +void gl3_1_glEndTransformFeedback(void *_glfuncs); +void gl3_1_glBeginTransformFeedback(void *_glfuncs, GLenum primitiveMode); +GLboolean gl3_1_glIsEnabledi(void *_glfuncs, GLenum target, GLuint index); +void gl3_1_glDisablei(void *_glfuncs, GLenum target, GLuint index); +void gl3_1_glEnablei(void *_glfuncs, GLenum target, GLuint index); +void gl3_1_glGetIntegeri_v(void *_glfuncs, GLenum target, GLuint index, GLint* data); +void gl3_1_glGetBooleani_v(void *_glfuncs, GLenum target, GLuint index, GLboolean* data); +void gl3_1_glColorMaski(void *_glfuncs, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +void gl3_1_glCopyBufferSubData(void *_glfuncs, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +void gl3_1_glUniformBlockBinding(void *_glfuncs, GLuint program, GLuint v0, GLuint v1); +void gl3_1_glGetActiveUniformBlockName(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName); +void gl3_1_glGetActiveUniformBlockiv(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params); +GLuint gl3_1_glGetUniformBlockIndex(void *_glfuncs, GLuint program, const GLchar* uniformBlockName); +void gl3_1_glGetActiveUniformName(void *_glfuncs, GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName); +void gl3_1_glGetActiveUniformsiv(void *_glfuncs, GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params); +void gl3_1_glPrimitiveRestartIndex(void *_glfuncs, GLuint index); +void gl3_1_glTexBuffer(void *_glfuncs, GLenum target, GLenum internalFormat, GLuint buffer); +void gl3_1_glDrawElementsInstanced(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount); +void gl3_1_glDrawArraysInstanced(void *_glfuncs, GLenum mode, GLint first, GLsizei count, GLsizei instancecount); + + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/gl/3.1/gl.go b/gl/3.1/gl.go new file mode 100644 index 00000000..495e07b3 --- /dev/null +++ b/gl/3.1/gl.go @@ -0,0 +1,4999 @@ +// ** file automatically generated by glgen -- do not edit manually ** + +package GL + +// #cgo CXXFLAGS: -std=c++0x -pedantic-errors -Wall -fno-strict-aliasing +// #cgo LDFLAGS: -lstdc++ +// #cgo pkg-config: Qt5Core Qt5OpenGL +// +// #include "funcs.h" +// +// void free(void*); +// +import "C" + +import ( + "fmt" + "reflect" + "unsafe" + + "gopkg.in/qml.v1/gl/glbase" +) + +// API returns a value that offers methods matching the OpenGL version 3.1 API. +// +// The returned API must not be used after the provided OpenGL context becomes invalid. +func API(context glbase.Contexter) *GL { + gl := &GL{} + gl.funcs = C.gl3_1_funcs() + if gl.funcs == nil { + panic(fmt.Errorf("OpenGL version 3.1 is not available")) + } + return gl +} + +// GL implements the OpenGL version 3.1 API. Values of this +// type must be created via the API function, and it must not be used after +// the associated OpenGL context becomes invalid. +type GL struct { + funcs unsafe.Pointer +} + +const ( + FALSE = 0 + TRUE = 1 + NONE = 0 + + BYTE = 0x1400 + UNSIGNED_BYTE = 0x1401 + SHORT = 0x1402 + UNSIGNED_SHORT = 0x1403 + INT = 0x1404 + UNSIGNED_INT = 0x1405 + FLOAT = 0x1406 + N2_BYTES = 0x1407 + N3_BYTES = 0x1408 + N4_BYTES = 0x1409 + DOUBLE = 0x140A + HALF_FLOAT = 0x140B + + ACCUM = 0x0100 + LOAD = 0x0101 + RETURN = 0x0102 + MULT = 0x0103 + ADD = 0x0104 + + ACCUM_BUFFER_BIT = 0x00000200 + ALL_ATTRIB_BITS = 0xFFFFFFFF + COLOR_BUFFER_BIT = 0x00004000 + CURRENT_BIT = 0x00000001 + DEPTH_BUFFER_BIT = 0x00000100 + ENABLE_BIT = 0x00002000 + EVAL_BIT = 0x00010000 + FOG_BIT = 0x00000080 + HINT_BIT = 0x00008000 + LIGHTING_BIT = 0x00000040 + LINE_BIT = 0x00000004 + LIST_BIT = 0x00020000 + MULTISAMPLE_BIT = 0x20000000 + PIXEL_MODE_BIT = 0x00000020 + POINT_BIT = 0x00000002 + POLYGON_BIT = 0x00000008 + POLYGON_STIPPLE_BIT = 0x00000010 + SCISSOR_BIT = 0x00080000 + STENCIL_BUFFER_BIT = 0x00000400 + TEXTURE_BIT = 0x00040000 + TRANSFORM_BIT = 0x00001000 + VIEWPORT_BIT = 0x00000800 + + ALWAYS = 0x0207 + EQUAL = 0x0202 + GEQUAL = 0x0206 + GREATER = 0x0204 + LEQUAL = 0x0203 + LESS = 0x0201 + NEVER = 0x0200 + NOTEQUAL = 0x0205 + + LOGIC_OP = 0x0BF1 + + DST_ALPHA = 0x0304 + ONE = 1 + ONE_MINUS_DST_ALPHA = 0x0305 + ONE_MINUS_SRC_ALPHA = 0x0303 + ONE_MINUS_SRC_COLOR = 0x0301 + SRC_ALPHA = 0x0302 + SRC_COLOR = 0x0300 + ZERO = 0 + + DST_COLOR = 0x0306 + ONE_MINUS_DST_COLOR = 0x0307 + SRC_ALPHA_SATURATE = 0x0308 + + CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF + CLIENT_PIXEL_STORE_BIT = 0x00000001 + CLIENT_VERTEX_ARRAY_BIT = 0x00000002 + + CLIP_DISTANCE0 = 0x3000 + CLIP_DISTANCE1 = 0x3001 + CLIP_DISTANCE2 = 0x3002 + CLIP_DISTANCE3 = 0x3003 + CLIP_DISTANCE4 = 0x3004 + CLIP_DISTANCE5 = 0x3005 + CLIP_DISTANCE6 = 0x3006 + CLIP_DISTANCE7 = 0x3007 + CLIP_PLANE0 = 0x3000 + CLIP_PLANE1 = 0x3001 + CLIP_PLANE2 = 0x3002 + CLIP_PLANE3 = 0x3003 + CLIP_PLANE4 = 0x3004 + CLIP_PLANE5 = 0x3005 + + BACK = 0x0405 + FRONT = 0x0404 + FRONT_AND_BACK = 0x0408 + + AMBIENT = 0x1200 + AMBIENT_AND_DIFFUSE = 0x1602 + DIFFUSE = 0x1201 + EMISSION = 0x1600 + SPECULAR = 0x1202 + + CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x00000001 + + AUX0 = 0x0409 + AUX1 = 0x040A + AUX2 = 0x040B + AUX3 = 0x040C + BACK_LEFT = 0x0402 + BACK_RIGHT = 0x0403 + FRONT_LEFT = 0x0400 + FRONT_RIGHT = 0x0401 + LEFT = 0x0406 + RIGHT = 0x0407 + + ALPHA_TEST = 0x0BC0 + AUTO_NORMAL = 0x0D80 + BLEND = 0x0BE2 + COLOR_ARRAY = 0x8076 + COLOR_LOGIC_OP = 0x0BF2 + COLOR_MATERIAL = 0x0B57 + CULL_FACE = 0x0B44 + DEPTH_TEST = 0x0B71 + DITHER = 0x0BD0 + EDGE_FLAG_ARRAY = 0x8079 + FOG = 0x0B60 + INDEX_ARRAY = 0x8077 + INDEX_LOGIC_OP = 0x0BF1 + LIGHT0 = 0x4000 + LIGHT1 = 0x4001 + LIGHT2 = 0x4002 + LIGHT3 = 0x4003 + LIGHT4 = 0x4004 + LIGHT5 = 0x4005 + LIGHT6 = 0x4006 + LIGHT7 = 0x4007 + LIGHTING = 0x0B50 + LINE_SMOOTH = 0x0B20 + LINE_STIPPLE = 0x0B24 + MAP1_COLOR_4 = 0x0D90 + MAP1_INDEX = 0x0D91 + MAP1_NORMAL = 0x0D92 + MAP1_TEXTURE_COORD_1 = 0x0D93 + MAP1_TEXTURE_COORD_2 = 0x0D94 + MAP1_TEXTURE_COORD_3 = 0x0D95 + MAP1_TEXTURE_COORD_4 = 0x0D96 + MAP1_VERTEX_3 = 0x0D97 + MAP1_VERTEX_4 = 0x0D98 + MAP2_COLOR_4 = 0x0DB0 + MAP2_INDEX = 0x0DB1 + MAP2_NORMAL = 0x0DB2 + MAP2_TEXTURE_COORD_1 = 0x0DB3 + MAP2_TEXTURE_COORD_2 = 0x0DB4 + MAP2_TEXTURE_COORD_3 = 0x0DB5 + MAP2_TEXTURE_COORD_4 = 0x0DB6 + MAP2_VERTEX_3 = 0x0DB7 + MAP2_VERTEX_4 = 0x0DB8 + NORMALIZE = 0x0BA1 + NORMAL_ARRAY = 0x8075 + POINT_SMOOTH = 0x0B10 + POLYGON_OFFSET_FILL = 0x8037 + POLYGON_OFFSET_LINE = 0x2A02 + POLYGON_OFFSET_POINT = 0x2A01 + POLYGON_SMOOTH = 0x0B41 + POLYGON_STIPPLE = 0x0B42 + SCISSOR_TEST = 0x0C11 + STENCIL_TEST = 0x0B90 + TEXTURE_1D = 0x0DE0 + TEXTURE_2D = 0x0DE1 + TEXTURE_COORD_ARRAY = 0x8078 + TEXTURE_GEN_Q = 0x0C63 + TEXTURE_GEN_R = 0x0C62 + TEXTURE_GEN_S = 0x0C60 + TEXTURE_GEN_T = 0x0C61 + VERTEX_ARRAY = 0x8074 + + INVALID_ENUM = 0x0500 + INVALID_FRAMEBUFFER_OPERATION = 0x0506 + INVALID_OPERATION = 0x0502 + INVALID_VALUE = 0x0501 + NO_ERROR = 0 + OUT_OF_MEMORY = 0x0505 + STACK_OVERFLOW = 0x0503 + STACK_UNDERFLOW = 0x0504 + + N2D = 0x0600 + N3D = 0x0601 + N3D_COLOR = 0x0602 + N3D_COLOR_TEXTURE = 0x0603 + N4D_COLOR_TEXTURE = 0x0604 + + BITMAP_TOKEN = 0x0704 + COPY_PIXEL_TOKEN = 0x0706 + DRAW_PIXEL_TOKEN = 0x0705 + LINE_RESET_TOKEN = 0x0707 + LINE_TOKEN = 0x0702 + PASS_THROUGH_TOKEN = 0x0700 + POINT_TOKEN = 0x0701 + POLYGON_TOKEN = 0x0703 + + EXP = 0x0800 + EXP2 = 0x0801 + LINEAR = 0x2601 + + FOG_COLOR = 0x0B66 + FOG_DENSITY = 0x0B62 + FOG_END = 0x0B64 + FOG_INDEX = 0x0B61 + FOG_MODE = 0x0B65 + FOG_START = 0x0B63 + + CCW = 0x0901 + CW = 0x0900 + + COEFF = 0x0A00 + DOMAIN = 0x0A02 + ORDER = 0x0A01 + + PIXEL_MAP_A_TO_A = 0x0C79 + PIXEL_MAP_B_TO_B = 0x0C78 + PIXEL_MAP_G_TO_G = 0x0C77 + PIXEL_MAP_I_TO_A = 0x0C75 + PIXEL_MAP_I_TO_B = 0x0C74 + PIXEL_MAP_I_TO_G = 0x0C73 + PIXEL_MAP_I_TO_I = 0x0C70 + PIXEL_MAP_I_TO_R = 0x0C72 + PIXEL_MAP_R_TO_R = 0x0C76 + PIXEL_MAP_S_TO_S = 0x0C71 + + ACCUM_ALPHA_BITS = 0x0D5B + ACCUM_BLUE_BITS = 0x0D5A + ACCUM_CLEAR_VALUE = 0x0B80 + ACCUM_GREEN_BITS = 0x0D59 + ACCUM_RED_BITS = 0x0D58 + ALIASED_LINE_WIDTH_RANGE = 0x846E + ALIASED_POINT_SIZE_RANGE = 0x846D + ALPHA_BIAS = 0x0D1D + ALPHA_BITS = 0x0D55 + ALPHA_SCALE = 0x0D1C + ALPHA_TEST_FUNC = 0x0BC1 + ALPHA_TEST_REF = 0x0BC2 + ATTRIB_STACK_DEPTH = 0x0BB0 + AUX_BUFFERS = 0x0C00 + BLEND_DST = 0x0BE0 + BLEND_SRC = 0x0BE1 + BLUE_BIAS = 0x0D1B + BLUE_BITS = 0x0D54 + BLUE_SCALE = 0x0D1A + CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1 + COLOR_ARRAY_SIZE = 0x8081 + COLOR_ARRAY_STRIDE = 0x8083 + COLOR_ARRAY_TYPE = 0x8082 + COLOR_CLEAR_VALUE = 0x0C22 + COLOR_MATERIAL_FACE = 0x0B55 + COLOR_MATERIAL_PARAMETER = 0x0B56 + COLOR_WRITEMASK = 0x0C23 + CULL_FACE_MODE = 0x0B45 + CURRENT_COLOR = 0x0B00 + CURRENT_INDEX = 0x0B01 + CURRENT_NORMAL = 0x0B02 + CURRENT_RASTER_COLOR = 0x0B04 + CURRENT_RASTER_DISTANCE = 0x0B09 + CURRENT_RASTER_INDEX = 0x0B05 + CURRENT_RASTER_POSITION = 0x0B07 + CURRENT_RASTER_POSITION_VALID = 0x0B08 + CURRENT_RASTER_TEXTURE_COORDS = 0x0B06 + CURRENT_TEXTURE_COORDS = 0x0B03 + DEPTH_BIAS = 0x0D1F + DEPTH_BITS = 0x0D56 + DEPTH_CLEAR_VALUE = 0x0B73 + DEPTH_FUNC = 0x0B74 + DEPTH_RANGE = 0x0B70 + DEPTH_SCALE = 0x0D1E + DEPTH_WRITEMASK = 0x0B72 + DOUBLEBUFFER = 0x0C32 + DRAW_BUFFER = 0x0C01 + EDGE_FLAG = 0x0B43 + EDGE_FLAG_ARRAY_STRIDE = 0x808C + FEEDBACK_BUFFER_SIZE = 0x0DF1 + FEEDBACK_BUFFER_TYPE = 0x0DF2 + FOG_HINT = 0x0C54 + FRONT_FACE = 0x0B46 + GREEN_BIAS = 0x0D19 + GREEN_BITS = 0x0D53 + GREEN_SCALE = 0x0D18 + INDEX_ARRAY_STRIDE = 0x8086 + INDEX_ARRAY_TYPE = 0x8085 + INDEX_BITS = 0x0D51 + INDEX_CLEAR_VALUE = 0x0C20 + INDEX_MODE = 0x0C30 + INDEX_OFFSET = 0x0D13 + INDEX_SHIFT = 0x0D12 + INDEX_WRITEMASK = 0x0C21 + LIGHT_MODEL_AMBIENT = 0x0B53 + LIGHT_MODEL_COLOR_CONTROL = 0x81F8 + LIGHT_MODEL_LOCAL_VIEWER = 0x0B51 + LIGHT_MODEL_TWO_SIDE = 0x0B52 + LINE_SMOOTH_HINT = 0x0C52 + LINE_STIPPLE_PATTERN = 0x0B25 + LINE_STIPPLE_REPEAT = 0x0B26 + LINE_WIDTH = 0x0B21 + LINE_WIDTH_GRANULARITY = 0x0B23 + LINE_WIDTH_RANGE = 0x0B22 + LIST_BASE = 0x0B32 + LIST_INDEX = 0x0B33 + LIST_MODE = 0x0B30 + LOGIC_OP_MODE = 0x0BF0 + MAP1_GRID_DOMAIN = 0x0DD0 + MAP1_GRID_SEGMENTS = 0x0DD1 + MAP2_GRID_DOMAIN = 0x0DD2 + MAP2_GRID_SEGMENTS = 0x0DD3 + MAP_COLOR = 0x0D10 + MAP_STENCIL = 0x0D11 + MATRIX_MODE = 0x0BA0 + MAX_ATTRIB_STACK_DEPTH = 0x0D35 + MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B + MAX_CLIP_DISTANCES = 0x0D32 + MAX_CLIP_PLANES = 0x0D32 + MAX_EVAL_ORDER = 0x0D30 + MAX_LIGHTS = 0x0D31 + MAX_LIST_NESTING = 0x0B31 + MAX_MODELVIEW_STACK_DEPTH = 0x0D36 + MAX_NAME_STACK_DEPTH = 0x0D37 + MAX_PIXEL_MAP_TABLE = 0x0D34 + MAX_PROJECTION_STACK_DEPTH = 0x0D38 + MAX_TEXTURE_SIZE = 0x0D33 + MAX_TEXTURE_STACK_DEPTH = 0x0D39 + MAX_VIEWPORT_DIMS = 0x0D3A + MODELVIEW_MATRIX = 0x0BA6 + MODELVIEW_STACK_DEPTH = 0x0BA3 + NAME_STACK_DEPTH = 0x0D70 + NORMAL_ARRAY_STRIDE = 0x807F + NORMAL_ARRAY_TYPE = 0x807E + PACK_ALIGNMENT = 0x0D05 + PACK_LSB_FIRST = 0x0D01 + PACK_ROW_LENGTH = 0x0D02 + PACK_SKIP_PIXELS = 0x0D04 + PACK_SKIP_ROWS = 0x0D03 + PACK_SWAP_BYTES = 0x0D00 + PERSPECTIVE_CORRECTION_HINT = 0x0C50 + PIXEL_MAP_A_TO_A_SIZE = 0x0CB9 + PIXEL_MAP_B_TO_B_SIZE = 0x0CB8 + PIXEL_MAP_G_TO_G_SIZE = 0x0CB7 + PIXEL_MAP_I_TO_A_SIZE = 0x0CB5 + PIXEL_MAP_I_TO_B_SIZE = 0x0CB4 + PIXEL_MAP_I_TO_G_SIZE = 0x0CB3 + PIXEL_MAP_I_TO_I_SIZE = 0x0CB0 + PIXEL_MAP_I_TO_R_SIZE = 0x0CB2 + PIXEL_MAP_R_TO_R_SIZE = 0x0CB6 + PIXEL_MAP_S_TO_S_SIZE = 0x0CB1 + POINT_SIZE = 0x0B11 + POINT_SIZE_GRANULARITY = 0x0B13 + POINT_SIZE_RANGE = 0x0B12 + POINT_SMOOTH_HINT = 0x0C51 + POLYGON_MODE = 0x0B40 + POLYGON_OFFSET_FACTOR = 0x8038 + POLYGON_OFFSET_UNITS = 0x2A00 + POLYGON_SMOOTH_HINT = 0x0C53 + PROJECTION_MATRIX = 0x0BA7 + PROJECTION_STACK_DEPTH = 0x0BA4 + READ_BUFFER = 0x0C02 + RED_BIAS = 0x0D15 + RED_BITS = 0x0D52 + RED_SCALE = 0x0D14 + RENDER_MODE = 0x0C40 + RGBA_MODE = 0x0C31 + SCISSOR_BOX = 0x0C10 + SELECTION_BUFFER_SIZE = 0x0DF4 + SHADE_MODEL = 0x0B54 + SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23 + SMOOTH_LINE_WIDTH_RANGE = 0x0B22 + SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13 + SMOOTH_POINT_SIZE_RANGE = 0x0B12 + STENCIL_BITS = 0x0D57 + STENCIL_CLEAR_VALUE = 0x0B91 + STENCIL_FAIL = 0x0B94 + STENCIL_FUNC = 0x0B92 + STENCIL_PASS_DEPTH_FAIL = 0x0B95 + STENCIL_PASS_DEPTH_PASS = 0x0B96 + STENCIL_REF = 0x0B97 + STENCIL_VALUE_MASK = 0x0B93 + STENCIL_WRITEMASK = 0x0B98 + STEREO = 0x0C33 + SUBPIXEL_BITS = 0x0D50 + TEXTURE_BINDING_1D = 0x8068 + TEXTURE_BINDING_2D = 0x8069 + TEXTURE_BINDING_3D = 0x806A + TEXTURE_COORD_ARRAY_SIZE = 0x8088 + TEXTURE_COORD_ARRAY_STRIDE = 0x808A + TEXTURE_COORD_ARRAY_TYPE = 0x8089 + TEXTURE_MATRIX = 0x0BA8 + TEXTURE_STACK_DEPTH = 0x0BA5 + UNPACK_ALIGNMENT = 0x0CF5 + UNPACK_LSB_FIRST = 0x0CF1 + UNPACK_ROW_LENGTH = 0x0CF2 + UNPACK_SKIP_PIXELS = 0x0CF4 + UNPACK_SKIP_ROWS = 0x0CF3 + UNPACK_SWAP_BYTES = 0x0CF0 + VERTEX_ARRAY_SIZE = 0x807A + VERTEX_ARRAY_STRIDE = 0x807C + VERTEX_ARRAY_TYPE = 0x807B + VIEWPORT = 0x0BA2 + ZOOM_X = 0x0D16 + ZOOM_Y = 0x0D17 + + COLOR_ARRAY_POINTER = 0x8090 + EDGE_FLAG_ARRAY_POINTER = 0x8093 + FEEDBACK_BUFFER_POINTER = 0x0DF0 + INDEX_ARRAY_POINTER = 0x8091 + NORMAL_ARRAY_POINTER = 0x808F + SELECTION_BUFFER_POINTER = 0x0DF3 + TEXTURE_COORD_ARRAY_POINTER = 0x8092 + VERTEX_ARRAY_POINTER = 0x808E + + TEXTURE_ALPHA_SIZE = 0x805F + TEXTURE_BLUE_SIZE = 0x805E + TEXTURE_BORDER = 0x1005 + TEXTURE_BORDER_COLOR = 0x1004 + TEXTURE_COMPONENTS = 0x1003 + TEXTURE_GREEN_SIZE = 0x805D + TEXTURE_HEIGHT = 0x1001 + TEXTURE_INTENSITY_SIZE = 0x8061 + TEXTURE_INTERNAL_FORMAT = 0x1003 + TEXTURE_LUMINANCE_SIZE = 0x8060 + TEXTURE_MAG_FILTER = 0x2800 + TEXTURE_MIN_FILTER = 0x2801 + TEXTURE_PRIORITY = 0x8066 + TEXTURE_RED_SIZE = 0x805C + TEXTURE_RESIDENT = 0x8067 + TEXTURE_WIDTH = 0x1000 + TEXTURE_WRAP_S = 0x2802 + TEXTURE_WRAP_T = 0x2803 + + DONT_CARE = 0x1100 + FASTEST = 0x1101 + NICEST = 0x1102 + + FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B + GENERATE_MIPMAP_HINT = 0x8192 + TEXTURE_COMPRESSION_HINT = 0x84EF + + C3F_V3F = 0x2A24 + C4F_N3F_V3F = 0x2A26 + C4UB_V2F = 0x2A22 + C4UB_V3F = 0x2A23 + N3F_V3F = 0x2A25 + T2F_C3F_V3F = 0x2A2A + T2F_C4F_N3F_V3F = 0x2A2C + T2F_C4UB_V3F = 0x2A29 + T2F_N3F_V3F = 0x2A2B + T2F_V3F = 0x2A27 + T4F_C4F_N3F_V4F = 0x2A2D + T4F_V4F = 0x2A28 + V2F = 0x2A20 + V3F = 0x2A21 + + MODULATE = 0x2100 + REPLACE = 0x1E01 + + SEPARATE_SPECULAR_COLOR = 0x81FA + SINGLE_COLOR = 0x81F9 + + CONSTANT_ATTENUATION = 0x1207 + LINEAR_ATTENUATION = 0x1208 + POSITION = 0x1203 + QUADRATIC_ATTENUATION = 0x1209 + SPOT_CUTOFF = 0x1206 + SPOT_DIRECTION = 0x1204 + SPOT_EXPONENT = 0x1205 + + COMPILE = 0x1300 + COMPILE_AND_EXECUTE = 0x1301 + + AND = 0x1501 + AND_INVERTED = 0x1504 + AND_REVERSE = 0x1502 + CLEAR = 0x1500 + COPY = 0x1503 + COPY_INVERTED = 0x150C + EQUIV = 0x1509 + INVERT = 0x150A + NAND = 0x150E + NOOP = 0x1505 + NOR = 0x1508 + OR = 0x1507 + OR_INVERTED = 0x150D + OR_REVERSE = 0x150B + SET = 0x150F + XOR = 0x1506 + + MAP_FLUSH_EXPLICIT_BIT = 0x0010 + MAP_INVALIDATE_BUFFER_BIT = 0x0008 + MAP_INVALIDATE_RANGE_BIT = 0x0004 + MAP_READ_BIT = 0x0001 + MAP_UNSYNCHRONIZED_BIT = 0x0020 + MAP_WRITE_BIT = 0x0002 + + COLOR_INDEXES = 0x1603 + SHININESS = 0x1601 + + MODELVIEW = 0x1700 + PROJECTION = 0x1701 + TEXTURE = 0x1702 + + LINE = 0x1B01 + POINT = 0x1B00 + + FILL = 0x1B02 + + COLOR = 0x1800 + DEPTH = 0x1801 + STENCIL = 0x1802 + + ALPHA = 0x1906 + BLUE = 0x1905 + COLOR_INDEX = 0x1900 + DEPTH_COMPONENT = 0x1902 + GREEN = 0x1904 + LUMINANCE = 0x1909 + LUMINANCE_ALPHA = 0x190A + RED = 0x1903 + RGB = 0x1907 + RGBA = 0x1908 + STENCIL_INDEX = 0x1901 + + ALPHA12 = 0x803D + ALPHA16 = 0x803E + ALPHA4 = 0x803B + ALPHA8 = 0x803C + INTENSITY = 0x8049 + INTENSITY12 = 0x804C + INTENSITY16 = 0x804D + INTENSITY4 = 0x804A + INTENSITY8 = 0x804B + LUMINANCE12 = 0x8041 + LUMINANCE12_ALPHA12 = 0x8047 + LUMINANCE12_ALPHA4 = 0x8046 + LUMINANCE16 = 0x8042 + LUMINANCE16_ALPHA16 = 0x8048 + LUMINANCE4 = 0x803F + LUMINANCE4_ALPHA4 = 0x8043 + LUMINANCE6_ALPHA2 = 0x8044 + LUMINANCE8 = 0x8040 + LUMINANCE8_ALPHA8 = 0x8045 + R3_G3_B2 = 0x2A10 + RGB10 = 0x8052 + RGB10_A2 = 0x8059 + RGB12 = 0x8053 + RGB16 = 0x8054 + RGB4 = 0x804F + RGB5 = 0x8050 + RGB5_A1 = 0x8057 + RGB8 = 0x8051 + RGBA12 = 0x805A + RGBA16 = 0x805B + RGBA2 = 0x8055 + RGBA4 = 0x8056 + RGBA8 = 0x8058 + + PACK_IMAGE_HEIGHT = 0x806C + PACK_SKIP_IMAGES = 0x806B + UNPACK_IMAGE_HEIGHT = 0x806E + UNPACK_SKIP_IMAGES = 0x806D + + BITMAP = 0x1A00 + UNSIGNED_BYTE_3_3_2 = 0x8032 + UNSIGNED_INT_10_10_10_2 = 0x8036 + UNSIGNED_INT_8_8_8_8 = 0x8035 + UNSIGNED_SHORT_4_4_4_4 = 0x8033 + UNSIGNED_SHORT_5_5_5_1 = 0x8034 + + POINT_DISTANCE_ATTENUATION = 0x8129 + POINT_FADE_THRESHOLD_SIZE = 0x8128 + POINT_SIZE_MAX = 0x8127 + POINT_SIZE_MIN = 0x8126 + + LINES = 0x0001 + LINE_LOOP = 0x0002 + LINE_STRIP = 0x0003 + POINTS = 0x0000 + POLYGON = 0x0009 + QUADS = 0x0007 + QUAD_STRIP = 0x0008 + TRIANGLES = 0x0004 + TRIANGLE_FAN = 0x0006 + TRIANGLE_STRIP = 0x0005 + + FEEDBACK = 0x1C01 + RENDER = 0x1C00 + SELECT = 0x1C02 + + FLAT = 0x1D00 + SMOOTH = 0x1D01 + + DECR = 0x1E03 + INCR = 0x1E02 + KEEP = 0x1E00 + + EXTENSIONS = 0x1F03 + RENDERER = 0x1F01 + VENDOR = 0x1F00 + VERSION = 0x1F02 + + S = 0x2000 + T = 0x2001 + R = 0x2002 + Q = 0x2003 + + DECAL = 0x2101 + + TEXTURE_ENV_COLOR = 0x2201 + TEXTURE_ENV_MODE = 0x2200 + + TEXTURE_ENV = 0x2300 + + EYE_LINEAR = 0x2400 + OBJECT_LINEAR = 0x2401 + SPHERE_MAP = 0x2402 + + EYE_PLANE = 0x2502 + OBJECT_PLANE = 0x2501 + TEXTURE_GEN_MODE = 0x2500 + + NEAREST = 0x2600 + + LINEAR_MIPMAP_LINEAR = 0x2703 + LINEAR_MIPMAP_NEAREST = 0x2701 + NEAREST_MIPMAP_LINEAR = 0x2702 + NEAREST_MIPMAP_NEAREST = 0x2700 + + GENERATE_MIPMAP = 0x8191 + TEXTURE_WRAP_R = 0x8072 + + PROXY_TEXTURE_1D = 0x8063 + PROXY_TEXTURE_2D = 0x8064 + PROXY_TEXTURE_3D = 0x8070 + TEXTURE_3D = 0x806F + TEXTURE_BASE_LEVEL = 0x813C + TEXTURE_MAX_LEVEL = 0x813D + TEXTURE_MAX_LOD = 0x813B + TEXTURE_MIN_LOD = 0x813A + + CLAMP = 0x2900 + CLAMP_TO_BORDER = 0x812D + CLAMP_TO_EDGE = 0x812F + REPEAT = 0x2901 + + INVALID_INDEX = 0xFFFFFFFF + CONSTANT_COLOR = 0x8001 + ONE_MINUS_CONSTANT_COLOR = 0x8002 + CONSTANT_ALPHA = 0x8003 + ONE_MINUS_CONSTANT_ALPHA = 0x8004 + FUNC_ADD = 0x8006 + MIN = 0x8007 + MAX = 0x8008 + BLEND_EQUATION_RGB = 0x8009 + FUNC_SUBTRACT = 0x800A + FUNC_REVERSE_SUBTRACT = 0x800B + RESCALE_NORMAL = 0x803A + TEXTURE_DEPTH = 0x8071 + MAX_3D_TEXTURE_SIZE = 0x8073 + MULTISAMPLE = 0x809D + SAMPLE_ALPHA_TO_COVERAGE = 0x809E + SAMPLE_ALPHA_TO_ONE = 0x809F + SAMPLE_COVERAGE = 0x80A0 + SAMPLE_BUFFERS = 0x80A8 + SAMPLES = 0x80A9 + SAMPLE_COVERAGE_VALUE = 0x80AA + SAMPLE_COVERAGE_INVERT = 0x80AB + BLEND_DST_RGB = 0x80C8 + BLEND_SRC_RGB = 0x80C9 + BLEND_DST_ALPHA = 0x80CA + BLEND_SRC_ALPHA = 0x80CB + BGR = 0x80E0 + BGRA = 0x80E1 + MAX_ELEMENTS_VERTICES = 0x80E8 + MAX_ELEMENTS_INDICES = 0x80E9 + DEPTH_COMPONENT16 = 0x81A5 + DEPTH_COMPONENT24 = 0x81A6 + DEPTH_COMPONENT32 = 0x81A7 + FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210 + FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211 + FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212 + FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213 + FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214 + FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215 + FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216 + FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217 + FRAMEBUFFER_DEFAULT = 0x8218 + FRAMEBUFFER_UNDEFINED = 0x8219 + DEPTH_STENCIL_ATTACHMENT = 0x821A + MAJOR_VERSION = 0x821B + MINOR_VERSION = 0x821C + NUM_EXTENSIONS = 0x821D + CONTEXT_FLAGS = 0x821E + COMPRESSED_RED = 0x8225 + COMPRESSED_RG = 0x8226 + RG = 0x8227 + RG_INTEGER = 0x8228 + R8 = 0x8229 + R16 = 0x822A + RG8 = 0x822B + RG16 = 0x822C + R16F = 0x822D + R32F = 0x822E + RG16F = 0x822F + RG32F = 0x8230 + R8I = 0x8231 + R8UI = 0x8232 + R16I = 0x8233 + R16UI = 0x8234 + R32I = 0x8235 + R32UI = 0x8236 + RG8I = 0x8237 + RG8UI = 0x8238 + RG16I = 0x8239 + RG16UI = 0x823A + RG32I = 0x823B + RG32UI = 0x823C + UNSIGNED_BYTE_2_3_3_REV = 0x8362 + UNSIGNED_SHORT_5_6_5 = 0x8363 + UNSIGNED_SHORT_5_6_5_REV = 0x8364 + UNSIGNED_SHORT_4_4_4_4_REV = 0x8365 + UNSIGNED_SHORT_1_5_5_5_REV = 0x8366 + UNSIGNED_INT_8_8_8_8_REV = 0x8367 + UNSIGNED_INT_2_10_10_10_REV = 0x8368 + MIRRORED_REPEAT = 0x8370 + FOG_COORDINATE_SOURCE = 0x8450 + FOG_COORD_SRC = 0x8450 + FOG_COORDINATE = 0x8451 + FOG_COORD = 0x8451 + FRAGMENT_DEPTH = 0x8452 + CURRENT_FOG_COORDINATE = 0x8453 + CURRENT_FOG_COORD = 0x8453 + FOG_COORDINATE_ARRAY_TYPE = 0x8454 + FOG_COORD_ARRAY_TYPE = 0x8454 + FOG_COORDINATE_ARRAY_STRIDE = 0x8455 + FOG_COORD_ARRAY_STRIDE = 0x8455 + FOG_COORDINATE_ARRAY_POINTER = 0x8456 + FOG_COORD_ARRAY_POINTER = 0x8456 + FOG_COORDINATE_ARRAY = 0x8457 + FOG_COORD_ARRAY = 0x8457 + COLOR_SUM = 0x8458 + CURRENT_SECONDARY_COLOR = 0x8459 + SECONDARY_COLOR_ARRAY_SIZE = 0x845A + SECONDARY_COLOR_ARRAY_TYPE = 0x845B + SECONDARY_COLOR_ARRAY_STRIDE = 0x845C + SECONDARY_COLOR_ARRAY_POINTER = 0x845D + SECONDARY_COLOR_ARRAY = 0x845E + CURRENT_RASTER_SECONDARY_COLOR = 0x845F + TEXTURE0 = 0x84C0 + TEXTURE1 = 0x84C1 + TEXTURE2 = 0x84C2 + TEXTURE3 = 0x84C3 + TEXTURE4 = 0x84C4 + TEXTURE5 = 0x84C5 + TEXTURE6 = 0x84C6 + TEXTURE7 = 0x84C7 + TEXTURE8 = 0x84C8 + TEXTURE9 = 0x84C9 + TEXTURE10 = 0x84CA + TEXTURE11 = 0x84CB + TEXTURE12 = 0x84CC + TEXTURE13 = 0x84CD + TEXTURE14 = 0x84CE + TEXTURE15 = 0x84CF + TEXTURE16 = 0x84D0 + TEXTURE17 = 0x84D1 + TEXTURE18 = 0x84D2 + TEXTURE19 = 0x84D3 + TEXTURE20 = 0x84D4 + TEXTURE21 = 0x84D5 + TEXTURE22 = 0x84D6 + TEXTURE23 = 0x84D7 + TEXTURE24 = 0x84D8 + TEXTURE25 = 0x84D9 + TEXTURE26 = 0x84DA + TEXTURE27 = 0x84DB + TEXTURE28 = 0x84DC + TEXTURE29 = 0x84DD + TEXTURE30 = 0x84DE + TEXTURE31 = 0x84DF + ACTIVE_TEXTURE = 0x84E0 + CLIENT_ACTIVE_TEXTURE = 0x84E1 + MAX_TEXTURE_UNITS = 0x84E2 + TRANSPOSE_MODELVIEW_MATRIX = 0x84E3 + TRANSPOSE_PROJECTION_MATRIX = 0x84E4 + TRANSPOSE_TEXTURE_MATRIX = 0x84E5 + TRANSPOSE_COLOR_MATRIX = 0x84E6 + SUBTRACT = 0x84E7 + MAX_RENDERBUFFER_SIZE = 0x84E8 + COMPRESSED_ALPHA = 0x84E9 + COMPRESSED_LUMINANCE = 0x84EA + COMPRESSED_LUMINANCE_ALPHA = 0x84EB + COMPRESSED_INTENSITY = 0x84EC + COMPRESSED_RGB = 0x84ED + COMPRESSED_RGBA = 0x84EE + TEXTURE_RECTANGLE = 0x84F5 + TEXTURE_BINDING_RECTANGLE = 0x84F6 + PROXY_TEXTURE_RECTANGLE = 0x84F7 + MAX_RECTANGLE_TEXTURE_SIZE = 0x84F8 + DEPTH_STENCIL = 0x84F9 + UNSIGNED_INT_24_8 = 0x84FA + MAX_TEXTURE_LOD_BIAS = 0x84FD + TEXTURE_FILTER_CONTROL = 0x8500 + TEXTURE_LOD_BIAS = 0x8501 + INCR_WRAP = 0x8507 + DECR_WRAP = 0x8508 + NORMAL_MAP = 0x8511 + REFLECTION_MAP = 0x8512 + TEXTURE_CUBE_MAP = 0x8513 + TEXTURE_BINDING_CUBE_MAP = 0x8514 + TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515 + TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516 + TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517 + TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518 + TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519 + TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A + PROXY_TEXTURE_CUBE_MAP = 0x851B + MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C + COMBINE = 0x8570 + COMBINE_RGB = 0x8571 + COMBINE_ALPHA = 0x8572 + RGB_SCALE = 0x8573 + ADD_SIGNED = 0x8574 + INTERPOLATE = 0x8575 + CONSTANT = 0x8576 + PRIMARY_COLOR = 0x8577 + PREVIOUS = 0x8578 + SOURCE0_RGB = 0x8580 + SRC0_RGB = 0x8580 + SOURCE1_RGB = 0x8581 + SRC1_RGB = 0x8581 + SOURCE2_RGB = 0x8582 + SRC2_RGB = 0x8582 + SOURCE0_ALPHA = 0x8588 + SRC0_ALPHA = 0x8588 + SOURCE1_ALPHA = 0x8589 + SRC1_ALPHA = 0x8589 + SOURCE2_ALPHA = 0x858A + SRC2_ALPHA = 0x858A + OPERAND0_RGB = 0x8590 + OPERAND1_RGB = 0x8591 + OPERAND2_RGB = 0x8592 + OPERAND0_ALPHA = 0x8598 + OPERAND1_ALPHA = 0x8599 + OPERAND2_ALPHA = 0x859A + VERTEX_ARRAY_BINDING = 0x85B5 + VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622 + VERTEX_ATTRIB_ARRAY_SIZE = 0x8623 + VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624 + VERTEX_ATTRIB_ARRAY_TYPE = 0x8625 + CURRENT_VERTEX_ATTRIB = 0x8626 + VERTEX_PROGRAM_POINT_SIZE = 0x8642 + VERTEX_PROGRAM_TWO_SIDE = 0x8643 + VERTEX_ATTRIB_ARRAY_POINTER = 0x8645 + TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0 + TEXTURE_COMPRESSED = 0x86A1 + NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2 + COMPRESSED_TEXTURE_FORMATS = 0x86A3 + DOT3_RGB = 0x86AE + DOT3_RGBA = 0x86AF + BUFFER_SIZE = 0x8764 + BUFFER_USAGE = 0x8765 + STENCIL_BACK_FUNC = 0x8800 + STENCIL_BACK_FAIL = 0x8801 + STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802 + STENCIL_BACK_PASS_DEPTH_PASS = 0x8803 + RGBA32F = 0x8814 + RGB32F = 0x8815 + RGBA16F = 0x881A + RGB16F = 0x881B + MAX_DRAW_BUFFERS = 0x8824 + DRAW_BUFFER0 = 0x8825 + DRAW_BUFFER1 = 0x8826 + DRAW_BUFFER2 = 0x8827 + DRAW_BUFFER3 = 0x8828 + DRAW_BUFFER4 = 0x8829 + DRAW_BUFFER5 = 0x882A + DRAW_BUFFER6 = 0x882B + DRAW_BUFFER7 = 0x882C + DRAW_BUFFER8 = 0x882D + DRAW_BUFFER9 = 0x882E + DRAW_BUFFER10 = 0x882F + DRAW_BUFFER11 = 0x8830 + DRAW_BUFFER12 = 0x8831 + DRAW_BUFFER13 = 0x8832 + DRAW_BUFFER14 = 0x8833 + DRAW_BUFFER15 = 0x8834 + BLEND_EQUATION_ALPHA = 0x883D + TEXTURE_DEPTH_SIZE = 0x884A + DEPTH_TEXTURE_MODE = 0x884B + TEXTURE_COMPARE_MODE = 0x884C + TEXTURE_COMPARE_FUNC = 0x884D + COMPARE_R_TO_TEXTURE = 0x884E + COMPARE_REF_TO_TEXTURE = 0x884E + POINT_SPRITE = 0x8861 + COORD_REPLACE = 0x8862 + QUERY_COUNTER_BITS = 0x8864 + CURRENT_QUERY = 0x8865 + QUERY_RESULT = 0x8866 + QUERY_RESULT_AVAILABLE = 0x8867 + MAX_VERTEX_ATTRIBS = 0x8869 + VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A + MAX_TEXTURE_COORDS = 0x8871 + MAX_TEXTURE_IMAGE_UNITS = 0x8872 + ARRAY_BUFFER = 0x8892 + ELEMENT_ARRAY_BUFFER = 0x8893 + ARRAY_BUFFER_BINDING = 0x8894 + ELEMENT_ARRAY_BUFFER_BINDING = 0x8895 + VERTEX_ARRAY_BUFFER_BINDING = 0x8896 + NORMAL_ARRAY_BUFFER_BINDING = 0x8897 + COLOR_ARRAY_BUFFER_BINDING = 0x8898 + INDEX_ARRAY_BUFFER_BINDING = 0x8899 + TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A + EDGE_FLAG_ARRAY_BUFFER_BINDING = 0x889B + SECONDARY_COLOR_ARRAY_BUFFER_BINDING = 0x889C + FOG_COORDINATE_ARRAY_BUFFER_BINDING = 0x889D + FOG_COORD_ARRAY_BUFFER_BINDING = 0x889D + WEIGHT_ARRAY_BUFFER_BINDING = 0x889E + VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F + READ_ONLY = 0x88B8 + WRITE_ONLY = 0x88B9 + READ_WRITE = 0x88BA + BUFFER_ACCESS = 0x88BB + BUFFER_MAPPED = 0x88BC + BUFFER_MAP_POINTER = 0x88BD + STREAM_DRAW = 0x88E0 + STREAM_READ = 0x88E1 + STREAM_COPY = 0x88E2 + STATIC_DRAW = 0x88E4 + STATIC_READ = 0x88E5 + STATIC_COPY = 0x88E6 + DYNAMIC_DRAW = 0x88E8 + DYNAMIC_READ = 0x88E9 + DYNAMIC_COPY = 0x88EA + PIXEL_PACK_BUFFER = 0x88EB + PIXEL_UNPACK_BUFFER = 0x88EC + PIXEL_PACK_BUFFER_BINDING = 0x88ED + PIXEL_UNPACK_BUFFER_BINDING = 0x88EF + DEPTH24_STENCIL8 = 0x88F0 + TEXTURE_STENCIL_SIZE = 0x88F1 + VERTEX_ATTRIB_ARRAY_INTEGER = 0x88FD + MAX_ARRAY_TEXTURE_LAYERS = 0x88FF + MIN_PROGRAM_TEXEL_OFFSET = 0x8904 + MAX_PROGRAM_TEXEL_OFFSET = 0x8905 + SAMPLES_PASSED = 0x8914 + CLAMP_VERTEX_COLOR = 0x891A + CLAMP_FRAGMENT_COLOR = 0x891B + CLAMP_READ_COLOR = 0x891C + FIXED_ONLY = 0x891D + UNIFORM_BUFFER = 0x8A11 + UNIFORM_BUFFER_BINDING = 0x8A28 + UNIFORM_BUFFER_START = 0x8A29 + UNIFORM_BUFFER_SIZE = 0x8A2A + MAX_VERTEX_UNIFORM_BLOCKS = 0x8A2B + MAX_GEOMETRY_UNIFORM_BLOCKS = 0x8A2C + MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8A2D + MAX_COMBINED_UNIFORM_BLOCKS = 0x8A2E + MAX_UNIFORM_BUFFER_BINDINGS = 0x8A2F + MAX_UNIFORM_BLOCK_SIZE = 0x8A30 + MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31 + MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 0x8A32 + MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33 + UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8A34 + ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35 + ACTIVE_UNIFORM_BLOCKS = 0x8A36 + UNIFORM_TYPE = 0x8A37 + UNIFORM_SIZE = 0x8A38 + UNIFORM_NAME_LENGTH = 0x8A39 + UNIFORM_BLOCK_INDEX = 0x8A3A + UNIFORM_OFFSET = 0x8A3B + UNIFORM_ARRAY_STRIDE = 0x8A3C + UNIFORM_MATRIX_STRIDE = 0x8A3D + UNIFORM_IS_ROW_MAJOR = 0x8A3E + UNIFORM_BLOCK_BINDING = 0x8A3F + UNIFORM_BLOCK_DATA_SIZE = 0x8A40 + UNIFORM_BLOCK_NAME_LENGTH = 0x8A41 + UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8A42 + UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43 + UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44 + UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 0x8A45 + UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46 + FRAGMENT_SHADER = 0x8B30 + VERTEX_SHADER = 0x8B31 + MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49 + MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A + MAX_VARYING_FLOATS = 0x8B4B + MAX_VARYING_COMPONENTS = 0x8B4B + MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C + MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D + SHADER_TYPE = 0x8B4F + FLOAT_VEC2 = 0x8B50 + FLOAT_VEC3 = 0x8B51 + FLOAT_VEC4 = 0x8B52 + INT_VEC2 = 0x8B53 + INT_VEC3 = 0x8B54 + INT_VEC4 = 0x8B55 + BOOL = 0x8B56 + BOOL_VEC2 = 0x8B57 + BOOL_VEC3 = 0x8B58 + BOOL_VEC4 = 0x8B59 + FLOAT_MAT2 = 0x8B5A + FLOAT_MAT3 = 0x8B5B + FLOAT_MAT4 = 0x8B5C + SAMPLER_1D = 0x8B5D + SAMPLER_2D = 0x8B5E + SAMPLER_3D = 0x8B5F + SAMPLER_CUBE = 0x8B60 + SAMPLER_1D_SHADOW = 0x8B61 + SAMPLER_2D_SHADOW = 0x8B62 + SAMPLER_2D_RECT = 0x8B63 + SAMPLER_2D_RECT_SHADOW = 0x8B64 + FLOAT_MAT2x3 = 0x8B65 + FLOAT_MAT2x4 = 0x8B66 + FLOAT_MAT3x2 = 0x8B67 + FLOAT_MAT3x4 = 0x8B68 + FLOAT_MAT4x2 = 0x8B69 + FLOAT_MAT4x3 = 0x8B6A + DELETE_STATUS = 0x8B80 + COMPILE_STATUS = 0x8B81 + LINK_STATUS = 0x8B82 + VALIDATE_STATUS = 0x8B83 + INFO_LOG_LENGTH = 0x8B84 + ATTACHED_SHADERS = 0x8B85 + ACTIVE_UNIFORMS = 0x8B86 + ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87 + SHADER_SOURCE_LENGTH = 0x8B88 + ACTIVE_ATTRIBUTES = 0x8B89 + ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A + SHADING_LANGUAGE_VERSION = 0x8B8C + CURRENT_PROGRAM = 0x8B8D + TEXTURE_RED_TYPE = 0x8C10 + TEXTURE_GREEN_TYPE = 0x8C11 + TEXTURE_BLUE_TYPE = 0x8C12 + TEXTURE_ALPHA_TYPE = 0x8C13 + TEXTURE_DEPTH_TYPE = 0x8C16 + UNSIGNED_NORMALIZED = 0x8C17 + TEXTURE_1D_ARRAY = 0x8C18 + PROXY_TEXTURE_1D_ARRAY = 0x8C19 + TEXTURE_2D_ARRAY = 0x8C1A + PROXY_TEXTURE_2D_ARRAY = 0x8C1B + TEXTURE_BINDING_1D_ARRAY = 0x8C1C + TEXTURE_BINDING_2D_ARRAY = 0x8C1D + TEXTURE_BUFFER = 0x8C2A + MAX_TEXTURE_BUFFER_SIZE = 0x8C2B + TEXTURE_BINDING_BUFFER = 0x8C2C + TEXTURE_BUFFER_DATA_STORE_BINDING = 0x8C2D + R11F_G11F_B10F = 0x8C3A + UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B + RGB9_E5 = 0x8C3D + UNSIGNED_INT_5_9_9_9_REV = 0x8C3E + TEXTURE_SHARED_SIZE = 0x8C3F + SRGB = 0x8C40 + SRGB8 = 0x8C41 + SRGB_ALPHA = 0x8C42 + SRGB8_ALPHA8 = 0x8C43 + SLUMINANCE_ALPHA = 0x8C44 + SLUMINANCE8_ALPHA8 = 0x8C45 + SLUMINANCE = 0x8C46 + SLUMINANCE8 = 0x8C47 + COMPRESSED_SRGB = 0x8C48 + COMPRESSED_SRGB_ALPHA = 0x8C49 + COMPRESSED_SLUMINANCE = 0x8C4A + COMPRESSED_SLUMINANCE_ALPHA = 0x8C4B + TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76 + TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F + MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80 + TRANSFORM_FEEDBACK_VARYINGS = 0x8C83 + TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84 + TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85 + PRIMITIVES_GENERATED = 0x8C87 + TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88 + RASTERIZER_DISCARD = 0x8C89 + MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A + MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B + INTERLEAVED_ATTRIBS = 0x8C8C + SEPARATE_ATTRIBS = 0x8C8D + TRANSFORM_FEEDBACK_BUFFER = 0x8C8E + TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F + POINT_SPRITE_COORD_ORIGIN = 0x8CA0 + LOWER_LEFT = 0x8CA1 + UPPER_LEFT = 0x8CA2 + STENCIL_BACK_REF = 0x8CA3 + STENCIL_BACK_VALUE_MASK = 0x8CA4 + STENCIL_BACK_WRITEMASK = 0x8CA5 + DRAW_FRAMEBUFFER_BINDING = 0x8CA6 + FRAMEBUFFER_BINDING = 0x8CA6 + RENDERBUFFER_BINDING = 0x8CA7 + READ_FRAMEBUFFER = 0x8CA8 + DRAW_FRAMEBUFFER = 0x8CA9 + READ_FRAMEBUFFER_BINDING = 0x8CAA + RENDERBUFFER_SAMPLES = 0x8CAB + DEPTH_COMPONENT32F = 0x8CAC + DEPTH32F_STENCIL8 = 0x8CAD + FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0 + FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1 + FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2 + FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3 + FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4 + FRAMEBUFFER_COMPLETE = 0x8CD5 + FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6 + FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7 + FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB + FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC + FRAMEBUFFER_UNSUPPORTED = 0x8CDD + MAX_COLOR_ATTACHMENTS = 0x8CDF + COLOR_ATTACHMENT0 = 0x8CE0 + COLOR_ATTACHMENT1 = 0x8CE1 + COLOR_ATTACHMENT2 = 0x8CE2 + COLOR_ATTACHMENT3 = 0x8CE3 + COLOR_ATTACHMENT4 = 0x8CE4 + COLOR_ATTACHMENT5 = 0x8CE5 + COLOR_ATTACHMENT6 = 0x8CE6 + COLOR_ATTACHMENT7 = 0x8CE7 + COLOR_ATTACHMENT8 = 0x8CE8 + COLOR_ATTACHMENT9 = 0x8CE9 + COLOR_ATTACHMENT10 = 0x8CEA + COLOR_ATTACHMENT11 = 0x8CEB + COLOR_ATTACHMENT12 = 0x8CEC + COLOR_ATTACHMENT13 = 0x8CED + COLOR_ATTACHMENT14 = 0x8CEE + COLOR_ATTACHMENT15 = 0x8CEF + DEPTH_ATTACHMENT = 0x8D00 + STENCIL_ATTACHMENT = 0x8D20 + FRAMEBUFFER = 0x8D40 + RENDERBUFFER = 0x8D41 + RENDERBUFFER_WIDTH = 0x8D42 + RENDERBUFFER_HEIGHT = 0x8D43 + RENDERBUFFER_INTERNAL_FORMAT = 0x8D44 + STENCIL_INDEX1 = 0x8D46 + STENCIL_INDEX4 = 0x8D47 + STENCIL_INDEX8 = 0x8D48 + STENCIL_INDEX16 = 0x8D49 + RENDERBUFFER_RED_SIZE = 0x8D50 + RENDERBUFFER_GREEN_SIZE = 0x8D51 + RENDERBUFFER_BLUE_SIZE = 0x8D52 + RENDERBUFFER_ALPHA_SIZE = 0x8D53 + RENDERBUFFER_DEPTH_SIZE = 0x8D54 + RENDERBUFFER_STENCIL_SIZE = 0x8D55 + FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56 + MAX_SAMPLES = 0x8D57 + RGBA32UI = 0x8D70 + RGB32UI = 0x8D71 + RGBA16UI = 0x8D76 + RGB16UI = 0x8D77 + RGBA8UI = 0x8D7C + RGB8UI = 0x8D7D + RGBA32I = 0x8D82 + RGB32I = 0x8D83 + RGBA16I = 0x8D88 + RGB16I = 0x8D89 + RGBA8I = 0x8D8E + RGB8I = 0x8D8F + RED_INTEGER = 0x8D94 + GREEN_INTEGER = 0x8D95 + BLUE_INTEGER = 0x8D96 + ALPHA_INTEGER = 0x8D97 + RGB_INTEGER = 0x8D98 + RGBA_INTEGER = 0x8D99 + BGR_INTEGER = 0x8D9A + BGRA_INTEGER = 0x8D9B + FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD + FRAMEBUFFER_SRGB = 0x8DB9 + COMPRESSED_RED_RGTC1 = 0x8DBB + COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC + COMPRESSED_RG_RGTC2 = 0x8DBD + COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE + SAMPLER_1D_ARRAY = 0x8DC0 + SAMPLER_2D_ARRAY = 0x8DC1 + SAMPLER_BUFFER = 0x8DC2 + SAMPLER_1D_ARRAY_SHADOW = 0x8DC3 + SAMPLER_2D_ARRAY_SHADOW = 0x8DC4 + SAMPLER_CUBE_SHADOW = 0x8DC5 + UNSIGNED_INT_VEC2 = 0x8DC6 + UNSIGNED_INT_VEC3 = 0x8DC7 + UNSIGNED_INT_VEC4 = 0x8DC8 + INT_SAMPLER_1D = 0x8DC9 + INT_SAMPLER_2D = 0x8DCA + INT_SAMPLER_3D = 0x8DCB + INT_SAMPLER_CUBE = 0x8DCC + INT_SAMPLER_2D_RECT = 0x8DCD + INT_SAMPLER_1D_ARRAY = 0x8DCE + INT_SAMPLER_2D_ARRAY = 0x8DCF + INT_SAMPLER_BUFFER = 0x8DD0 + UNSIGNED_INT_SAMPLER_1D = 0x8DD1 + UNSIGNED_INT_SAMPLER_2D = 0x8DD2 + UNSIGNED_INT_SAMPLER_3D = 0x8DD3 + UNSIGNED_INT_SAMPLER_CUBE = 0x8DD4 + UNSIGNED_INT_SAMPLER_2D_RECT = 0x8DD5 + UNSIGNED_INT_SAMPLER_1D_ARRAY = 0x8DD6 + UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8DD7 + UNSIGNED_INT_SAMPLER_BUFFER = 0x8DD8 + QUERY_WAIT = 0x8E13 + QUERY_NO_WAIT = 0x8E14 + QUERY_BY_REGION_WAIT = 0x8E15 + QUERY_BY_REGION_NO_WAIT = 0x8E16 + COPY_READ_BUFFER = 0x8F36 + COPY_WRITE_BUFFER = 0x8F37 + R8_SNORM = 0x8F94 + RG8_SNORM = 0x8F95 + RGB8_SNORM = 0x8F96 + RGBA8_SNORM = 0x8F97 + R16_SNORM = 0x8F98 + RG16_SNORM = 0x8F99 + RGB16_SNORM = 0x8F9A + RGBA16_SNORM = 0x8F9B + SIGNED_NORMALIZED = 0x8F9C + PRIMITIVE_RESTART = 0x8F9D + PRIMITIVE_RESTART_INDEX = 0x8F9E + BUFFER_ACCESS_FLAGS = 0x911F + BUFFER_MAP_LENGTH = 0x9120 + BUFFER_MAP_OFFSET = 0x9121 +) + +// https://www.opengl.org/sdk/docs/man3/xhtml/glViewport.xml +func (gl *GL) Viewport(x, y, width, height int) { + C.gl3_1_glViewport(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// DepthRange specifies the mapping of depth values from normalized device +// coordinates to window coordinates. +// +// Parameter nearVal specifies the mapping of the near clipping plane to window +// coordinates (defaults to 0), while farVal specifies the mapping of the far +// clipping plane to window coordinates (defaults to 1). +// +// After clipping and division by w, depth coordinates range from -1 to 1, +// corresponding to the near and far clipping planes. DepthRange specifies a +// linear mapping of the normalized depth coordinates in this range to window +// depth coordinates. Regardless of the actual depth buffer implementation, +// window coordinate depth values are treated as though they range from 0 through 1 +// (like color components). Thus, the values accepted by DepthRange are both +// clamped to this range before they are accepted. +// +// The default setting of (0, 1) maps the near plane to 0 and the far plane to 1. +// With this mapping, the depth buffer range is fully utilized. +// +// It is not necessary that nearVal be less than farVal. Reverse mappings such as +// nearVal 1, and farVal 0 are acceptable. +// +// GL.INVALID_OPERATION is generated if DepthRange is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) DepthRange(nearVal, farVal float64) { + C.gl3_1_glDepthRange(gl.funcs, C.GLdouble(nearVal), C.GLdouble(farVal)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsEnabled.xml +func (gl *GL) IsEnabled(cap glbase.Enum) bool { + glresult := C.gl3_1_glIsEnabled(gl.funcs, C.GLenum(cap)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexLevelParameteriv.xml +func (gl *GL) GetTexLevelParameteriv(target glbase.Enum, level int, pname glbase.Enum, params []int32) { + C.gl3_1_glGetTexLevelParameteriv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexLevelParameterfv.xml +func (gl *GL) GetTexLevelParameterfv(target glbase.Enum, level int, pname glbase.Enum, params []float32) { + C.gl3_1_glGetTexLevelParameterfv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexParameteriv.xml +func (gl *GL) GetTexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_1_glGetTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexParameterfv.xml +func (gl *GL) GetTexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl3_1_glGetTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexImage.xml +func (gl *GL) GetTexImage(target glbase.Enum, level int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_1_glGetTexImage(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetIntegerv.xml +func (gl *GL) GetIntegerv(pname glbase.Enum, params []int32) { + C.gl3_1_glGetIntegerv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetFloatv.xml +func (gl *GL) GetFloatv(pname glbase.Enum, params []float32) { + C.gl3_1_glGetFloatv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetError.xml +func (gl *GL) GetError() glbase.Enum { + glresult := C.gl3_1_glGetError(gl.funcs) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetDoublev.xml +func (gl *GL) GetDoublev(pname glbase.Enum, params []float64) { + C.gl3_1_glGetDoublev(gl.funcs, C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetBooleanv.xml +func (gl *GL) GetBooleanv(pname glbase.Enum, params []bool) { + C.gl3_1_glGetBooleanv(gl.funcs, C.GLenum(pname), (*C.GLboolean)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glReadPixels.xml +func (gl *GL) ReadPixels(x, y, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_1_glReadPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glReadBuffer.xml +func (gl *GL) ReadBuffer(mode glbase.Enum) { + C.gl3_1_glReadBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPixelStorei.xml +func (gl *GL) PixelStorei(pname glbase.Enum, param int32) { + C.gl3_1_glPixelStorei(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPixelStoref.xml +func (gl *GL) PixelStoref(pname glbase.Enum, param float32) { + C.gl3_1_glPixelStoref(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDepthFunc.xml +func (gl *GL) DepthFunc(glfunc glbase.Enum) { + C.gl3_1_glDepthFunc(gl.funcs, C.GLenum(glfunc)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilOp.xml +func (gl *GL) StencilOp(fail, zfail, zpass glbase.Enum) { + C.gl3_1_glStencilOp(gl.funcs, C.GLenum(fail), C.GLenum(zfail), C.GLenum(zpass)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilFunc.xml +func (gl *GL) StencilFunc(glfunc glbase.Enum, ref int32, mask uint32) { + C.gl3_1_glStencilFunc(gl.funcs, C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLogicOp.xml +func (gl *GL) LogicOp(opcode glbase.Enum) { + C.gl3_1_glLogicOp(gl.funcs, C.GLenum(opcode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlendFunc.xml +func (gl *GL) BlendFunc(sfactor, dfactor glbase.Enum) { + C.gl3_1_glBlendFunc(gl.funcs, C.GLenum(sfactor), C.GLenum(dfactor)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFlush.xml +func (gl *GL) Flush() { + C.gl3_1_glFlush(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFinish.xml +func (gl *GL) Finish() { + C.gl3_1_glFinish(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEnable.xml +func (gl *GL) Enable(cap glbase.Enum) { + C.gl3_1_glEnable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDisable.xml +func (gl *GL) Disable(cap glbase.Enum) { + C.gl3_1_glDisable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDepthMask.xml +func (gl *GL) DepthMask(flag bool) { + C.gl3_1_glDepthMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorMask.xml +func (gl *GL) ColorMask(red, green, blue, alpha bool) { + C.gl3_1_glColorMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&red)), *(*C.GLboolean)(unsafe.Pointer(&green)), *(*C.GLboolean)(unsafe.Pointer(&blue)), *(*C.GLboolean)(unsafe.Pointer(&alpha))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilMask.xml +func (gl *GL) StencilMask(mask uint32) { + C.gl3_1_glStencilMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearDepth.xml +func (gl *GL) ClearDepth(depth float64) { + C.gl3_1_glClearDepth(gl.funcs, C.GLdouble(depth)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearStencil.xml +func (gl *GL) ClearStencil(s int32) { + C.gl3_1_glClearStencil(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearColor.xml +func (gl *GL) ClearColor(red, green, blue, alpha float32) { + C.gl3_1_glClearColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClear.xml +func (gl *GL) Clear(mask glbase.Bitfield) { + C.gl3_1_glClear(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawBuffer.xml +func (gl *GL) DrawBuffer(mode glbase.Enum) { + C.gl3_1_glDrawBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexImage2D.xml +func (gl *GL) TexImage2D(target glbase.Enum, level int, internalFormat int32, width, height, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_1_glTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexImage1D.xml +func (gl *GL) TexImage1D(target glbase.Enum, level int, internalFormat int32, width, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_1_glTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameteriv.xml +func (gl *GL) TexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_1_glTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameteri.xml +func (gl *GL) TexParameteri(target, pname glbase.Enum, param int32) { + C.gl3_1_glTexParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameterfv.xml +func (gl *GL) TexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl3_1_glTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameterf.xml +func (gl *GL) TexParameterf(target, pname glbase.Enum, param float32) { + C.gl3_1_glTexParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glScissor.xml +func (gl *GL) Scissor(x, y, width, height int) { + C.gl3_1_glScissor(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPolygonMode.xml +func (gl *GL) PolygonMode(face, mode glbase.Enum) { + C.gl3_1_glPolygonMode(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPointSize.xml +func (gl *GL) PointSize(size float32) { + C.gl3_1_glPointSize(gl.funcs, C.GLfloat(size)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLineWidth.xml +func (gl *GL) LineWidth(width float32) { + C.gl3_1_glLineWidth(gl.funcs, C.GLfloat(width)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glHint.xml +func (gl *GL) Hint(target, mode glbase.Enum) { + C.gl3_1_glHint(gl.funcs, C.GLenum(target), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFrontFace.xml +func (gl *GL) FrontFace(mode glbase.Enum) { + C.gl3_1_glFrontFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCullFace.xml +func (gl *GL) CullFace(mode glbase.Enum) { + C.gl3_1_glCullFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexubv.xml +func (gl *GL) Indexubv(c []uint8) { + C.gl3_1_glIndexubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexub.xml +func (gl *GL) Indexub(c uint8) { + C.gl3_1_glIndexub(gl.funcs, C.GLubyte(c)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsTexture.xml +func (gl *GL) IsTexture(texture glbase.Texture) bool { + glresult := C.gl3_1_glIsTexture(gl.funcs, C.GLuint(texture)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenTextures returns n texture names in textures. There is no guarantee +// that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenTextures. +// +// The generated textures have no dimensionality; they assume the +// dimensionality of the texture target to which they are first bound (see +// BindTexture). +// +// Texture names returned by a call to GenTextures are not returned by +// subsequent calls, unless they are first deleted with DeleteTextures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenTextures is available in GL version 2.0 or greater. +func (gl *GL) GenTextures(n int) []glbase.Texture { + if n == 0 { + return nil + } + textures := make([]glbase.Texture, n) + C.gl3_1_glGenTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) + return textures +} + +// DeleteTextures deletes the textures objects whose names are stored +// in the textures slice. After a texture is deleted, it has no contents or +// dimensionality, and its name is free for reuse (for example by +// GenTextures). If a texture that is currently bound is deleted, the binding +// reverts to 0 (the default texture). +// +// DeleteTextures silently ignores 0's and names that do not correspond to +// existing textures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteTextures is available in GL version 2.0 or greater. +func (gl *GL) DeleteTextures(textures []glbase.Texture) { + n := len(textures) + if n == 0 { + return + } + C.gl3_1_glDeleteTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindTexture.xml +func (gl *GL) BindTexture(target glbase.Enum, texture glbase.Texture) { + C.gl3_1_glBindTexture(gl.funcs, C.GLenum(target), C.GLuint(texture)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexSubImage2D.xml +func (gl *GL) TexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_1_glTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexSubImage1D.xml +func (gl *GL) TexSubImage1D(target glbase.Enum, level, xoffset, width int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_1_glTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyTexSubImage2D.xml +func (gl *GL) CopyTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, x, y, width, height int) { + C.gl3_1_glCopyTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyTexSubImage1D.xml +func (gl *GL) CopyTexSubImage1D(target glbase.Enum, level, xoffset, x, y, width int) { + C.gl3_1_glCopyTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyTexImage2D.xml +func (gl *GL) CopyTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, height, border int) { + C.gl3_1_glCopyTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyTexImage1D.xml +func (gl *GL) CopyTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, border int) { + C.gl3_1_glCopyTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPolygonOffset.xml +func (gl *GL) PolygonOffset(factor, units float32) { + C.gl3_1_glPolygonOffset(gl.funcs, C.GLfloat(factor), C.GLfloat(units)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawElements.xml +func (gl *GL) DrawElements(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl3_1_glDrawElements(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawArrays.xml +func (gl *GL) DrawArrays(mode glbase.Enum, first, count int) { + C.gl3_1_glDrawArrays(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyTexSubImage3D.xml +func (gl *GL) CopyTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, x, y, width, height int) { + C.gl3_1_glCopyTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexSubImage3D.xml +func (gl *GL) TexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_1_glTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexImage3D.xml +func (gl *GL) TexImage3D(target glbase.Enum, level int, internalFormat int32, width, height int, depth int32, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_1_glTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawRangeElements.xml +func (gl *GL) DrawRangeElements(mode glbase.Enum, start, end uint32, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl3_1_glDrawRangeElements(gl.funcs, C.GLenum(mode), C.GLuint(start), C.GLuint(end), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlendEquation.xml +func (gl *GL) BlendEquation(mode glbase.Enum) { + C.gl3_1_glBlendEquation(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlendColor.xml +func (gl *GL) BlendColor(red, green, blue, alpha float32) { + C.gl3_1_glBlendColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetCompressedTexImage.xml +func (gl *GL) GetCompressedTexImage(target glbase.Enum, level int, img interface{}) { + var img_ptr unsafe.Pointer + var img_v = reflect.ValueOf(img) + if img != nil && img_v.Kind() != reflect.Slice { + panic("parameter img must be a slice") + } + if img != nil { + img_ptr = unsafe.Pointer(img_v.Index(0).Addr().Pointer()) + } + C.gl3_1_glGetCompressedTexImage(gl.funcs, C.GLenum(target), C.GLint(level), img_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexSubImage1D.xml +func (gl *GL) CompressedTexSubImage1D(target glbase.Enum, level, xoffset, width int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_1_glCompressedTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexSubImage2D.xml +func (gl *GL) CompressedTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_1_glCompressedTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexSubImage3D.xml +func (gl *GL) CompressedTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_1_glCompressedTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexImage1D.xml +func (gl *GL) CompressedTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, width, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_1_glCompressedTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexImage2D.xml +func (gl *GL) CompressedTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_1_glCompressedTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexImage3D.xml +func (gl *GL) CompressedTexImage3D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height int, depth int32, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_1_glCompressedTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSampleCoverage.xml +func (gl *GL) SampleCoverage(value float32, invert bool) { + C.gl3_1_glSampleCoverage(gl.funcs, C.GLfloat(value), *(*C.GLboolean)(unsafe.Pointer(&invert))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glActiveTexture.xml +func (gl *GL) ActiveTexture(texture glbase.Enum) { + C.gl3_1_glActiveTexture(gl.funcs, C.GLenum(texture)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPointParameteriv.xml +func (gl *GL) PointParameteriv(pname glbase.Enum, params []int32) { + C.gl3_1_glPointParameteriv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPointParameteri.xml +func (gl *GL) PointParameteri(pname glbase.Enum, param int32) { + C.gl3_1_glPointParameteri(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPointParameterfv.xml +func (gl *GL) PointParameterfv(pname glbase.Enum, params []float32) { + C.gl3_1_glPointParameterfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPointParameterf.xml +func (gl *GL) PointParameterf(pname glbase.Enum, param float32) { + C.gl3_1_glPointParameterf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiDrawArrays.xml +func (gl *GL) MultiDrawArrays(mode glbase.Enum, first, count []int, drawcount int32) { + C.gl3_1_glMultiDrawArrays(gl.funcs, C.GLenum(mode), (*C.GLint)(unsafe.Pointer(&first[0])), (*C.GLsizei)(unsafe.Pointer(&count[0])), C.GLsizei(drawcount)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlendFuncSeparate.xml +func (gl *GL) BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha glbase.Enum) { + C.gl3_1_glBlendFuncSeparate(gl.funcs, C.GLenum(sfactorRGB), C.GLenum(dfactorRGB), C.GLenum(sfactorAlpha), C.GLenum(dfactorAlpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetBufferParameteriv.xml +func (gl *GL) GetBufferParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_1_glGetBufferParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glUnmapBuffer.xml +func (gl *GL) UnmapBuffer(target glbase.Enum) bool { + glresult := C.gl3_1_glUnmapBuffer(gl.funcs, C.GLenum(target)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetBufferSubData.xml +func (gl *GL) GetBufferSubData(target glbase.Enum, offset, size int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_1_glGetBufferSubData(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(size), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBufferSubData.xml +func (gl *GL) BufferSubData(target glbase.Enum, offset, size int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_1_glBufferSubData(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(size), data_ptr) +} + +// BufferData creates a new data store for the buffer object currently +// bound to target. Any pre-existing data store is deleted. The new data +// store is created with the specified size in bytes and usage. If data is +// not nil, it must be a slice that is used to initialize the data store. +// In that case the size parameter is ignored and the store size will match +// the slice data size. +// +// In its initial state, the new data store is not mapped, it has a NULL +// mapped pointer, and its mapped access is GL.READ_WRITE. +// +// The target constant must be one of GL.ARRAY_BUFFER, GL.COPY_READ_BUFFER, +// GL.COPY_WRITE_BUFFER, GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER, +// GL.PIXEL_UNPACK_BUFFER, GL.TEXTURE_BUFFER, GL.TRANSFORM_FEEDBACK_BUFFER, +// or GL.UNIFORM_BUFFER. +// +// The usage parameter is a hint to the GL implementation as to how a buffer +// object's data store will be accessed. This enables the GL implementation +// to make more intelligent decisions that may significantly impact buffer +// object performance. It does not, however, constrain the actual usage of +// the data store. usage can be broken down into two parts: first, the +// frequency of access (modification and usage), and second, the nature of +// that access. +// +// A usage frequency of STREAM and nature of DRAW is specified via the +// constant GL.STREAM_DRAW, for example. +// +// The usage frequency of access may be one of: +// +// STREAM +// The data store contents will be modified once and used at most a few times. +// +// STATIC +// The data store contents will be modified once and used many times. +// +// DYNAMIC +// The data store contents will be modified repeatedly and used many times. +// +// The usage nature of access may be one of: +// +// DRAW +// The data store contents are modified by the application, and used as +// the source for GL drawing and image specification commands. +// +// READ +// The data store contents are modified by reading data from the GL, +// and used to return that data when queried by the application. +// +// COPY +// The data store contents are modified by reading data from the GL, +// and used as the source for GL drawing and image specification +// commands. +// +// Clients must align data elements consistent with the requirements of the +// client platform, with an additional base-level requirement that an offset +// within a buffer to a datum comprising N bytes be a multiple of N. +// +// Error GL.INVALID_ENUM is generated if target is not one of the accepted +// buffer targets. GL.INVALID_ENUM is generated if usage is not +// GL.STREAM_DRAW, GL.STREAM_READ, GL.STREAM_COPY, GL.STATIC_DRAW, +// GL.STATIC_READ, GL.STATIC_COPY, GL.DYNAMIC_DRAW, GL.DYNAMIC_READ, or +// GL.DYNAMIC_COPY. GL.INVALID_VALUE is generated if size is negative. +// GL.INVALID_OPERATION is generated if the reserved buffer object name 0 is +// bound to target. GL.OUT_OF_MEMORY is generated if the GL is unable to +// create a data store with the specified size. +func (gl *GL) BufferData(target glbase.Enum, size int, data interface{}, usage glbase.Enum) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + if data != nil { + size = int(data_v.Type().Size()) * data_v.Len() + } + C.gl3_1_glBufferData(gl.funcs, C.GLenum(target), C.GLsizeiptr(size), data_ptr, C.GLenum(usage)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsBuffer.xml +func (gl *GL) IsBuffer(buffer glbase.Buffer) bool { + glresult := C.gl3_1_glIsBuffer(gl.funcs, C.GLuint(buffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenBuffers returns n buffer object names. There is no guarantee that +// the names form a contiguous set of integers; however, it is guaranteed +// that none of the returned names was in use immediately before the call to +// GenBuffers. +// +// Buffer object names returned by a call to GenBuffers are not returned by +// subsequent calls, unless they are first deleted with DeleteBuffers. +// +// No buffer objects are associated with the returned buffer object names +// until they are first bound by calling BindBuffer. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if GenBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// GenBuffers is available in GL version 1.5 or greater. +func (gl *GL) GenBuffers(n int) []glbase.Buffer { + if n == 0 { + return nil + } + buffers := make([]glbase.Buffer, n) + C.gl3_1_glGenBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) + return buffers +} + +// DeleteBuffers deletes the buffer objects whose names are stored in the +// buffers slice. +// +// After a buffer object is deleted, it has no contents, and its name is free +// for reuse (for example by GenBuffers). If a buffer object that is +// currently bound is deleted, the binding reverts to 0 (the absence of any +// buffer object, which reverts to client memory usage). +// +// DeleteBuffers silently ignores 0's and names that do not correspond to +// existing buffer objects. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if DeleteBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// DeleteBuffers is available in GL version 1.5 or greater. +func (gl *GL) DeleteBuffers(buffers []glbase.Buffer) { + n := len(buffers) + if n == 0 { + return + } + C.gl3_1_glDeleteBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) +} + +// BindBuffer creates or puts in use a named buffer object. +// Calling BindBuffer with target set to GL.ARRAY_BUFFER, +// GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER or GL.PIXEL_UNPACK_BUFFER +// and buffer set to the name of the new buffer object binds the buffer +// object name to the target. When a buffer object is bound to a target, the +// previous binding for that target is automatically broken. +// +// Buffer object names are unsigned integers. The value zero is reserved, but +// there is no default buffer object for each buffer object target. Instead, +// buffer set to zero effectively unbinds any buffer object previously bound, +// and restores client memory usage for that buffer object target. Buffer +// object names and the corresponding buffer object contents are local to the +// shared display-list space (see XCreateContext) of the current GL rendering +// context; two rendering contexts share buffer object names only if they +// also share display lists. +// +// GenBuffers may be called to generate a set of new buffer object names. +// +// The state of a buffer object immediately after it is first bound is an +// unmapped zero-sized memory buffer with GL.READ_WRITE access and +// GL.STATIC_DRAW usage. +// +// While a non-zero buffer object name is bound, GL operations on the target +// to which it is bound affect the bound buffer object, and queries of the +// target to which it is bound return state from the bound buffer object. +// While buffer object name zero is bound, as in the initial state, attempts +// to modify or query state on the target to which it is bound generates an +// GL.INVALID_OPERATION error. +// +// When vertex array pointer state is changed, for example by a call to +// NormalPointer, the current buffer object binding (GL.ARRAY_BUFFER_BINDING) +// is copied into the corresponding client state for the vertex array type +// being changed, for example GL.NORMAL_ARRAY_BUFFER_BINDING. While a +// non-zero buffer object is bound to the GL.ARRAY_BUFFER target, the vertex +// array pointer parameter that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.ELEMENT_ARRAY_BUFFER +// target, the indices parameter of DrawElements, DrawRangeElements, or +// MultiDrawElements that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_PACK_BUFFER +// target, the following commands are affected: GetCompressedTexImage, +// GetConvolutionFilter, GetHistogram, GetMinmax, GetPixelMap, +// GetPolygonStipple, GetSeparableFilter, GetTexImage, and ReadPixels. The +// pointer parameter that is traditionally interpreted as a pointer to +// client-side memory where the pixels are to be packed is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_UNPACK_BUFFER +// target, the following commands are affected: Bitmap, ColorSubTable, +// ColorTable, CompressedTexImage1D, CompressedTexImage2D, +// CompressedTexImage3D, CompressedTexSubImage1D, CompressedTexSubImage2D, +// CompressedTexSubImage3D, ConvolutionFilter1D, ConvolutionFilter2D, +// DrawPixels, PixelMap, PolygonStipple, SeparableFilter2D, TexImage1D, +// TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, and TexSubImage3D. +// The pointer parameter that is traditionally interpreted as a pointer to +// client-side memory from which the pixels are to be unpacked is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// A buffer object binding created with BindBuffer remains active until a +// different buffer object name is bound to the same target, or until the +// bound buffer object is deleted with DeleteBuffers. +// +// Once created, a named buffer object may be re-bound to any target as often +// as needed. However, the GL implementation may make choices about how to +// optimize the storage of a buffer object based on its initial binding +// target. +// +// Error GL.INVALID_ENUM is generated if target is not one of the allowable +// values. GL.INVALID_OPERATION is generated if BindBuffer is executed +// between the execution of Begin and the corresponding execution of End. +// +// BindBuffer is available in GL version 1.5 or greater. +func (gl *GL) BindBuffer(target glbase.Enum, buffer glbase.Buffer) { + C.gl3_1_glBindBuffer(gl.funcs, C.GLenum(target), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetQueryObjectuiv.xml +func (gl *GL) GetQueryObjectuiv(id uint32, pname glbase.Enum, params []uint32) { + C.gl3_1_glGetQueryObjectuiv(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetQueryObjectiv.xml +func (gl *GL) GetQueryObjectiv(id uint32, pname glbase.Enum, params []int32) { + C.gl3_1_glGetQueryObjectiv(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetQueryiv.xml +func (gl *GL) GetQueryiv(target, pname glbase.Enum, params []int32) { + C.gl3_1_glGetQueryiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEndQuery.xml +func (gl *GL) EndQuery(target glbase.Enum) { + C.gl3_1_glEndQuery(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBeginQuery.xml +func (gl *GL) BeginQuery(target glbase.Enum, id uint32) { + C.gl3_1_glBeginQuery(gl.funcs, C.GLenum(target), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsQuery.xml +func (gl *GL) IsQuery(id uint32) bool { + glresult := C.gl3_1_glIsQuery(gl.funcs, C.GLuint(id)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDeleteQueries.xml +func (gl *GL) DeleteQueries(n int, ids []uint32) { + C.gl3_1_glDeleteQueries(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGenQueries.xml +func (gl *GL) GenQueries(n int, ids []uint32) { + C.gl3_1_glGenQueries(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// VertexAttribPointer specifies the location and data format of the array +// of generic vertex attributes at index to use when rendering. size +// specifies the number of components per attribute and must be 1, 2, 3, or +// 4. type specifies the data type of each component, and stride specifies +// the byte stride from one attribute to the next, allowing vertices and +// attributes to be packed into a single array or stored in separate arrays. +// normalized indicates whether the values stored in an integer format are +// to be mapped to the range [-1,1] (for signed values) or [0,1] +// (for unsigned values) when they are accessed and converted to floating +// point; otherwise, values will be converted to floats directly without +// normalization. offset is a byte offset into the buffer object's data +// store, which must be bound to the GL.ARRAY_BUFFER target with BindBuffer. +// +// The buffer object binding (GL.ARRAY_BUFFER_BINDING) is saved as +// generic vertex attribute array client-side state +// (GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING) for the provided index. +// +// To enable and disable a generic vertex attribute array, call +// EnableVertexAttribArray and DisableVertexAttribArray with index. If +// enabled, the generic vertex attribute array is used when DrawArrays or +// DrawElements is called. Each generic vertex attribute array is initially +// disabled. +// +// VertexAttribPointer is typically implemented on the client side. +// +// Error GL.INVALID_ENUM is generated if type is not an accepted value. +// GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_VALUE is generated if size is not 1, 2, +// 3, or 4. GL.INVALID_VALUE is generated if stride is negative. +func (gl *GL) VertexAttribPointer(index glbase.Attrib, size int, gltype glbase.Enum, normalized bool, stride int, offset uintptr) { + offset_ptr := unsafe.Pointer(offset) + C.gl3_1_glVertexAttribPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLsizei(stride), offset_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glValidateProgram.xml +func (gl *GL) ValidateProgram(program glbase.Program) { + C.gl3_1_glValidateProgram(gl.funcs, C.GLuint(program)) +} + +// UniformMatrix4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*4) != 0 { + panic("invalid value length for UniformMatrix4fv") + } + count := len(value) / (4 * 4) + C.gl3_1_glUniformMatrix4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*3) != 0 { + panic("invalid value length for UniformMatrix3fv") + } + count := len(value) / (3 * 3) + C.gl3_1_glUniformMatrix3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*2) != 0 { + panic("invalid value length for UniformMatrix2fv") + } + count := len(value) / (2 * 2) + C.gl3_1_glUniformMatrix2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform4iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4iv") + } + count := len(value) / 4 + C.gl3_1_glUniform4iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform3iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3iv") + } + count := len(value) / 3 + C.gl3_1_glUniform3iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform2iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2iv") + } + count := len(value) / 2 + C.gl3_1_glUniform2iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform1iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl3_1_glUniform1iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4fv") + } + count := len(value) / 4 + C.gl3_1_glUniform4fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3fv") + } + count := len(value) / 3 + C.gl3_1_glUniform3fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2fv") + } + count := len(value) / 2 + C.gl3_1_glUniform2fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform1fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl3_1_glUniform1fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform4i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4i(location glbase.Uniform, v0, v1, v2, v3 int32) { + C.gl3_1_glUniform4i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2), C.GLint(v3)) +} + +// Uniform3i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3i(location glbase.Uniform, v0, v1, v2 int32) { + C.gl3_1_glUniform3i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2)) +} + +// Uniform2i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2i(location glbase.Uniform, v0, v1 int32) { + C.gl3_1_glUniform2i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1)) +} + +// Uniform1i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1i(location glbase.Uniform, v0 int32) { + C.gl3_1_glUniform1i(gl.funcs, C.GLint(location), C.GLint(v0)) +} + +// Uniform4f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4f(location glbase.Uniform, v0, v1, v2, v3 float32) { + C.gl3_1_glUniform4f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2), C.GLfloat(v3)) +} + +// Uniform3f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3f(location glbase.Uniform, v0, v1, v2 float32) { + C.gl3_1_glUniform3f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2)) +} + +// Uniform2f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2f(location glbase.Uniform, v0, v1 float32) { + C.gl3_1_glUniform2f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1)) +} + +// Uniform1f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1f(location glbase.Uniform, v0 float32) { + C.gl3_1_glUniform1f(gl.funcs, C.GLint(location), C.GLfloat(v0)) +} + +// UseProgram installs the program object specified by program as part of +// current rendering state. One or more executables are created in a program +// object by successfully attaching shader objects to it with AttachShader, +// successfully compiling the shader objects with CompileShader, and +// successfully linking the program object with LinkProgram. +// +// A program object will contain an executable that will run on the vertex +// processor if it contains one or more shader objects of type +// GL.VERTEX_SHADER that have been successfully compiled and linked. +// Similarly, a program object will contain an executable that will run on +// the fragment processor if it contains one or more shader objects of type +// GL.FRAGMENT_SHADER that have been successfully compiled and linked. +// +// Successfully installing an executable on a programmable processor will +// cause the corresponding fixed functionality of OpenGL to be disabled. +// Specifically, if an executable is installed on the vertex processor, the +// OpenGL fixed functionality will be disabled as follows. +// +// - The modelview matrix is not applied to vertex coordinates. +// +// - The projection matrix is not applied to vertex coordinates. +// +// - The texture matrices are not applied to texture coordinates. +// +// - Normals are not transformed to eye coordinates. +// +// - Normals are not rescaled or normalized. +// +// - Normalization of GL.AUTO_NORMAL evaluated normals is not performed. +// +// - Texture coordinates are not generated automatically. +// +// - Per-vertex lighting is not performed. +// +// - Color material computations are not performed. +// +// - Color index lighting is not performed. +// +// - This list also applies when setting the current raster position. +// +// The executable that is installed on the vertex processor is expected to +// implement any or all of the desired functionality from the preceding list. +// Similarly, if an executable is installed on the fragment processor, the +// OpenGL fixed functionality will be disabled as follows. +// +// - Texture environment and texture functions are not applied. +// +// - Texture application is not applied. +// +// - Color sum is not applied. +// +// - Fog is not applied. +// +// Again, the fragment shader that is installed is expected to implement any +// or all of the desired functionality from the preceding list. +// +// While a program object is in use, applications are free to modify attached +// shader objects, compile attached shader objects, attach additional shader +// objects, and detach or delete shader objects. None of these operations +// will affect the executables that are part of the current state. However, +// relinking the program object that is currently in use will install the +// program object as part of the current rendering state if the link +// operation was successful (see LinkProgram). If the program object +// currently in use is relinked unsuccessfully, its link status will be set +// to GL.FALSE, but the executables and associated state will remain part of +// the current state until a subsequent call to UseProgram removes it from +// use. After it is removed from use, it cannot be made part of current state +// until it has been successfully relinked. +// +// If program contains shader objects of type GL.VERTEX_SHADER but it does +// not contain shader objects of type GL.FRAGMENT_SHADER, an executable will +// be installed on the vertex processor, but fixed functionality will be used +// for fragment processing. Similarly, if program contains shader objects of +// type GL.FRAGMENT_SHADER but it does not contain shader objects of type +// GL.VERTEX_SHADER, an executable will be installed on the fragment +// processor, but fixed functionality will be used for vertex processing. If +// program is 0, the programmable processors will be disabled, and fixed +// functionality will be used for both vertex and fragment processing. +// +// While a program object is in use, the state that controls the disabled +// fixed functionality may also be updated using the normal OpenGL calls. +// +// Like display lists and texture objects, the name space for program objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// Applications are responsible for providing the synchronization across API +// calls when objects are accessed from different execution threads. +// +// Error GL.INVALID_VALUE is generated if program is neither 0 nor a value +// generated by OpenGL. GL.INVALID_OPERATION is generated if program is not +// a program object. GL.INVALID_OPERATION is generated if program could not +// be made part of current state. GL.INVALID_OPERATION is generated if +// UseProgram is executed between the execution of Begin and the +// corresponding execution of End. +// +// UseProgram is available in GL version 2.0 or greater. +func (gl *GL) UseProgram(program glbase.Program) { + C.gl3_1_glUseProgram(gl.funcs, C.GLuint(program)) +} + +// ShaderSource sets the source code in shader to the provided source code. Any source +// code previously stored in the shader object is completely replaced. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_VALUE is generated if count is less than 0. +// GL.INVALID_OPERATION is generated if ShaderSource is executed between the +// execution of Begin and the corresponding execution of End. +// +// ShaderSource is available in GL version 2.0 or greater. +func (gl *GL) ShaderSource(shader glbase.Shader, source ...string) { + count := len(source) + length := make([]int32, count) + source_c := make([]unsafe.Pointer, count) + for i, src := range source { + length[i] = int32(len(src)) + if len(src) > 0 { + source_c[i] = *(*unsafe.Pointer)(unsafe.Pointer(&src)) + } else { + source_c[i] = unsafe.Pointer(uintptr(0)) + } + } + C.gl3_1_glShaderSource(gl.funcs, C.GLuint(shader), C.GLsizei(count), (**C.GLchar)(unsafe.Pointer(&source_c[0])), (*C.GLint)(unsafe.Pointer(&length[0]))) +} + +// LinkProgram links the program object specified by program. If any shader +// objects of type GL.VERTEX_SHADER are attached to program, they will be +// used to create an executable that will run on the programmable vertex +// processor. If any shader objects of type GL.FRAGMENT_SHADER are attached +// to program, they will be used to create an executable that will run on the +// programmable fragment processor. +// +// The status of the link operation will be stored as part of the program +// object's state. This value will be set to GL.TRUE if the program object +// was linked without errors and is ready for use, and GL.FALSE otherwise. It +// can be queried by calling GetProgramiv with arguments program and +// GL.LINK_STATUS. +// +// As a result of a successful link operation, all active user-defined +// uniform variables belonging to program will be initialized to 0, and each +// of the program object's active uniform variables will be assigned a +// location that can be queried by calling GetUniformLocation. Also, any +// active user-defined attribute variables that have not been bound to a +// generic vertex attribute index will be bound to one at this time. +// +// Linking of a program object can fail for a number of reasons as specified +// in the OpenGL Shading Language Specification. The following lists some of +// the conditions that will cause a link error. +// +// - The number of active attribute variables supported by the +// implementation has been exceeded. +// +// - The storage limit for uniform variables has been exceeded. +// +// - The number of active uniform variables supported by the implementation +// has been exceeded. +// +// - The main function is missing for the vertex shader or the fragment +// shader. +// +// - A varying variable actually used in the fragment shader is not +// declared in the same way (or is not declared at all) in the vertex +// shader. +// +// - A reference to a function or variable name is unresolved. +// +// - A shared global is declared with two different types or two different +// initial values. +// +// - One or more of the attached shader objects has not been successfully +// compiled. +// +// - Binding a generic attribute matrix caused some rows of the matrix to +// fall outside the allowed maximum of GL.MAX_VERTEX_ATTRIBS. +// +// - Not enough contiguous vertex attribute slots could be found to bind +// attribute matrices. +// +// When a program object has been successfully linked, the program object can +// be made part of current state by calling UseProgram. Whether or not the +// link operation was successful, the program object's information log will +// be overwritten. The information log can be retrieved by calling +// GetProgramInfoLog. +// +// LinkProgram will also install the generated executables as part of the +// current rendering state if the link operation was successful and the +// specified program object is already currently in use as a result of a +// previous call to UseProgram. If the program object currently in use is +// relinked unsuccessfully, its link status will be set to GL.FALSE , but the +// executables and associated state will remain part of the current state +// until a subsequent call to UseProgram removes it from use. After it is +// removed from use, it cannot be made part of current state until it has +// been successfully relinked. +// +// If program contains shader objects of type GL.VERTEX_SHADER but does not +// contain shader objects of type GL.FRAGMENT_SHADER, the vertex shader will +// be linked against the implicit interface for fixed functionality fragment +// processing. Similarly, if program contains shader objects of type +// GL.FRAGMENT_SHADER but it does not contain shader objects of type +// GL.VERTEX_SHADER, the fragment shader will be linked against the implicit +// interface for fixed functionality vertex processing. +// +// The program object's information log is updated and the program is +// generated at the time of the link operation. After the link operation, +// applications are free to modify attached shader objects, compile attached +// shader objects, detach shader objects, delete shader objects, and attach +// additional shader objects. None of these operations affects the +// information log or the program that is part of the program object. +// +// If the link operation is unsuccessful, any information about a previous +// link operation on program is lost (a failed link does not restore the +// old state of program). Certain information can still be retrieved +// from program even after an unsuccessful link operation. See for instance +// GetActiveAttrib and GetActiveUniform. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if LinkProgram is executed +// between the execution of Begin and the corresponding execution of End. +// +// LinkProgram is available in GL version 2.0 or greater. +func (gl *GL) LinkProgram(program glbase.Program) { + C.gl3_1_glLinkProgram(gl.funcs, C.GLuint(program)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsShader.xml +func (gl *GL) IsShader(shader glbase.Shader) bool { + glresult := C.gl3_1_glIsShader(gl.funcs, C.GLuint(shader)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsProgram.xml +func (gl *GL) IsProgram(program glbase.Program) bool { + glresult := C.gl3_1_glIsProgram(gl.funcs, C.GLuint(program)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GetVertexAttribiv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribiv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribiv(index glbase.Attrib, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl3_1_glGetVertexAttribiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetVertexAttribfv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribfv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribfv(index glbase.Attrib, pname glbase.Enum, params []float32) { + var params_c [4]float32 + C.gl3_1_glGetVertexAttribfv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetVertexAttribdv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribdv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribdv(index glbase.Attrib, pname glbase.Enum, params []float64) { + var params_c [4]float64 + C.gl3_1_glGetVertexAttribdv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformiv returns in params the value of the specified uniform +// variable. The type of the uniform variable specified by location +// determines the number of values returned. If the uniform variable is +// defined in the shader as a boolean, int, or float, a single value will be +// returned. If it is defined as a vec2, ivec2, or bvec2, two values will be +// returned. If it is defined as a vec3, ivec3, or bvec3, three values will +// be returned, and so on. To query values stored in uniform variables +// declared as arrays, call GetUniformiv for each element of the array. To +// query values stored in uniform variables declared as structures, call +// GetUniformiv for each field in the structure. The values for uniform +// variables declared as a matrix will be returned in column major order. +// +// The locations assigned to uniform variables are not known until the +// program object is linked. After linking has occurred, the command +// GetUniformLocation can be used to obtain the location of a uniform +// variable. This location value can then be passed to GetUniformiv in order +// to query the current value of the uniform variable. After a program object +// has been linked successfully, the index values for uniform variables +// remain fixed until the next link command occurs. The uniform variable +// values can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if program has not been +// successfully linked. GL.INVALID_OPERATION is generated if location does +// not correspond to a valid uniform variable location for the specified +// program object. GL.INVALID_OPERATION is generated if GetUniformiv is +// executed between the execution of Begin and the corresponding execution of +// End. +// +// GetUniformiv is available in GL version 2.0 or greater. +func (gl *GL) GetUniformiv(program glbase.Program, location glbase.Uniform, params []int32) { + var params_c [4]int32 + C.gl3_1_glGetUniformiv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformfv returns in params the value of the specified uniform +// variable. The type of the uniform variable specified by location +// determines the number of values returned. If the uniform variable is +// defined in the shader as a boolean, int, or float, a single value will be +// returned. If it is defined as a vec2, ivec2, or bvec2, two values will be +// returned. If it is defined as a vec3, ivec3, or bvec3, three values will +// be returned, and so on. To query values stored in uniform variables +// declared as arrays, call GetUniformfv for each element of the array. To +// query values stored in uniform variables declared as structures, call +// GetUniformfv for each field in the structure. The values for uniform +// variables declared as a matrix will be returned in column major order. +// +// The locations assigned to uniform variables are not known until the +// program object is linked. After linking has occurred, the command +// GetUniformLocation can be used to obtain the location of a uniform +// variable. This location value can then be passed to GetUniformfv in order +// to query the current value of the uniform variable. After a program object +// has been linked successfully, the index values for uniform variables +// remain fixed until the next link command occurs. The uniform variable +// values can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if program has not been +// successfully linked. GL.INVALID_OPERATION is generated if location does +// not correspond to a valid uniform variable location for the specified +// program object. GL.INVALID_OPERATION is generated if GetUniformfv is +// executed between the execution of Begin and the corresponding execution of +// End. +// +// GetUniformfv is available in GL version 2.0 or greater. +func (gl *GL) GetUniformfv(program glbase.Program, location glbase.Uniform, params []float32) { + var params_c [4]float32 + C.gl3_1_glGetUniformfv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLfloat)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformLocation returns an integer that represents the location of a +// specific uniform variable within a program object. name must be an active +// uniform variable name in program that is not a structure, an array of +// structures, or a subcomponent of a vector or a matrix. This function +// returns -1 if name does not correspond to an active uniform variable in +// program or if name starts with the reserved prefix "gl_". +// +// Uniform variables that are structures or arrays of structures may be +// queried by calling GetUniformLocation for each field within the +// structure. The array element operator "[]" and the structure field +// operator "." may be used in name in order to select elements within an +// array or fields within a structure. The result of using these operators is +// not allowed to be another structure, an array of structures, or a +// subcomponent of a vector or a matrix. Except if the last part of name +// indicates a uniform variable array, the location of the first element of +// an array can be retrieved by using the name of the array, or by using the +// name appended by "[0]". +// +// The actual locations assigned to uniform variables are not known until the +// program object is linked successfully. After linking has occurred, the +// command GetUniformLocation can be used to obtain the location of a +// uniform variable. This location value can then be passed to Uniform to +// set the value of the uniform variable or to GetUniform in order to query +// the current value of the uniform variable. After a program object has been +// linked successfully, the index values for uniform variables remain fixed +// until the next link command occurs. Uniform variable locations and values +// can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program object. +// GL.INVALID_OPERATION is generated if program has not been successfully +// linked. GL.INVALID_OPERATION is generated if GetUniformLocation is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetUniformLocation is available in GL version 2.0 or greater. +func (gl *GL) GetUniformLocation(program glbase.Program, name string) glbase.Uniform { + name_cstr := C.CString(name) + glresult := C.gl3_1_glGetUniformLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) + return glbase.Uniform(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetShaderSource.xml +func (gl *GL) GetShaderSource(shader glbase.Shader, bufSize int32, length []int32, source []byte) { + C.gl3_1_glGetShaderSource(gl.funcs, C.GLuint(shader), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&source[0]))) +} + +// GetShaderInfoLog returns the information log for the specified shader +// object. The information log for a shader object is modified when the +// shader is compiled. +// +// The information log for a shader object is a string that may contain +// diagnostic messages, warning messages, and other information about the +// last compile operation. When a shader object is created, its information +// log will be a string of length 0, and the size of the current log can be +// obtained by calling GetShaderiv with the value GL.INFO_LOG_LENGTH. +// +// The information log for a shader object is the OpenGL implementer's +// primary mechanism for conveying information about the compilation process. +// Therefore, the information log can be helpful to application developers +// during the development process, even when compilation is successful. +// Application developers should not expect different OpenGL implementations +// to produce identical information logs. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_VALUE is generated if maxLength is less than 0. +// GL.INVALID_OPERATION is generated if GetShaderInfoLog is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetShaderInfoLog is available in GL version 2.0 or greater. +func (gl *GL) GetShaderInfoLog(shader glbase.Shader) []byte { + var params [1]int32 + var length int32 + gl.GetShaderiv(shader, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + C.gl3_1_glGetShaderInfoLog(gl.funcs, C.GLuint(shader), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length)), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) + return infoLog +} + +// GetShaderiv GetShader returns in params the value of a parameter for a specific +// shader object. The following parameters are defined: +// +// GL.SHADER_TYPE +// params returns GL.VERTEX_SHADER if shader is a vertex shader object, +// and GL.FRAGMENT_SHADER if shader is a fragment shader object. +// +// GL.DELETE_STATUS +// params returns GL.TRUE if shader is currently flagged for deletion, +// and GL.FALSE otherwise. +// +// GL.COMPILE_STATUS +// params returns GL.TRUE if the last compile operation on shader was +// successful, and GL.FALSE otherwise. +// +// GL.INFO_LOG_LENGTH +// params returns the number of characters in the information log for +// shader including the null termination character (the size of the +// character buffer required to store the information log). If shader has +// no information log, a value of 0 is returned. +// +// GL.SHADER_SOURCE_LENGTH +// params returns the length of the concatenation of the source strings +// that make up the shader source for the shader, including the null +// termination character. (the size of the character buffer +// required to store the shader source). If no source code exists, 0 is +// returned. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader does not refer to a +// shader object. GL.INVALID_ENUM is generated if pname is not an accepted +// value. GL.INVALID_OPERATION is generated if GetShader is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetShaderiv is available in GL version 2.0 or greater. +func (gl *GL) GetShaderiv(shader glbase.Shader, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl3_1_glGetShaderiv(gl.funcs, C.GLuint(shader), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetProgramInfoLog returns the information log for the specified program +// object. The information log for a program object is modified when the +// program object is linked or validated. +// +// The information log for a program object is either an empty string, or a +// string containing information about the last link operation, or a string +// containing information about the last validation operation. It may contain +// diagnostic messages, warning messages, and other information. When a +// program object is created, its information log will be a string of length +// 0, and the size of the current log can be obtained by calling GetProgramiv +// with the value GL.INFO_LOG_LENGTH. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated +// by OpenGL. GL.INVALID_OPERATION is generated if program is not a +// program object. +func (gl *GL) GetProgramInfoLog(program glbase.Program) []byte { + var params [1]int32 + var length int32 + gl.GetProgramiv(program, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + C.gl3_1_glGetProgramInfoLog(gl.funcs, C.GLuint(program), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length)), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) + return infoLog +} + +// GetProgramiv returns in params the value of a parameter for a specific +// program object. The following parameters are defined: +// +// GL.DELETE_STATUS +// params returns GL.TRUE if program is currently flagged for deletion, +// and GL.FALSE otherwise. +// +// GL.LINK_STATUS +// params returns GL.TRUE if the last link operation on program was +// successful, and GL.FALSE otherwise. +// +// GL.VALIDATE_STATUS +// params returns GL.TRUE or if the last validation operation on +// program was successful, and GL.FALSE otherwise. +// +// GL.INFO_LOG_LENGTH +// params returns the number of characters in the information log for +// program including the null termination character (the size of +// the character buffer required to store the information log). If +// program has no information log, a value of 0 is returned. +// +// GL.ATTACHED_SHADERS +// params returns the number of shader objects attached to program. +// +// GL.ACTIVE_ATTRIBUTES +// params returns the number of active attribute variables for program. +// +// GL.ACTIVE_ATTRIBUTE_MAX_LENGTH +// params returns the length of the longest active attribute name for +// program, including the null termination character (the size of +// the character buffer required to store the longest attribute name). +// If no active attributes exist, 0 is returned. +// +// GL.ACTIVE_UNIFORMS +// params returns the number of active uniform variables for program. +// +// GL.ACTIVE_UNIFORM_MAX_LENGTH +// params returns the length of the longest active uniform variable +// name for program, including the null termination character (i.e., +// the size of the character buffer required to store the longest +// uniform variable name). If no active uniform variables exist, 0 is +// returned. +// +// GL.TRANSFORM_FEEDBACK_BUFFER_MODE +// params returns a symbolic constant indicating the buffer mode used +// when transform feedback is active. This may be GL.SEPARATE_ATTRIBS +// or GL.INTERLEAVED_ATTRIBS. +// +// GL.TRANSFORM_FEEDBACK_VARYINGS +// params returns the number of varying variables to capture in transform +// feedback mode for the program. +// +// GL.TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH +// params returns the length of the longest variable name to be used for +// transform feedback, including the null-terminator. +// +// GL.GEOMETRY_VERTICES_OUT +// params returns the maximum number of vertices that the geometry shader in +// program will output. +// +// GL.GEOMETRY_INPUT_TYPE +// params returns a symbolic constant indicating the primitive type accepted +// as input to the geometry shader contained in program. +// +// GL.GEOMETRY_OUTPUT_TYPE +// params returns a symbolic constant indicating the primitive type that will +// be output by the geometry shader contained in program. +// +// GL.ACTIVE_UNIFORM_BLOCKS and GL.ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH are +// available only if the GL version 3.1 or greater. +// +// GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE and +// GL.GEOMETRY_OUTPUT_TYPE are accepted only if the GL version is 3.2 or +// greater. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program does not refer to a +// program object. GL.INVALID_OPERATION is generated if pname is +// GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE, or +// GL.GEOMETRY_OUTPUT_TYPE, and program does not contain a geometry shader. +// GL.INVALID_ENUM is generated if pname is not an accepted value. +func (gl *GL) GetProgramiv(program glbase.Program, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl3_1_glGetProgramiv(gl.funcs, C.GLuint(program), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetAttribLocation queries the previously linked program object specified +// by program for the attribute variable specified by name and returns the +// index of the generic vertex attribute that is bound to that attribute +// variable. If name is a matrix attribute variable, the index of the first +// column of the matrix is returned. If the named attribute variable is not +// an active attribute in the specified program object or if name starts with +// the reserved prefix "gl_", a value of -1 is returned. +// +// The association between an attribute variable name and a generic attribute +// index can be specified at any time by calling BindAttribLocation. +// Attribute bindings do not go into effect until LinkProgram is called. +// After a program object has been linked successfully, the index values for +// attribute variables remain fixed until the next link command occurs. The +// attribute values can only be queried after a link if the link was +// successful. GetAttribLocation returns the binding that actually went +// into effect the last time LinkProgram was called for the specified +// program object. Attribute bindings that have been specified since the last +// link operation are not returned by GetAttribLocation. +// +// Error GL_INVALID_OPERATION is generated if program is not a value +// generated by OpenGL. GL_INVALID_OPERATION is generated if program is not +// a program object. GL_INVALID_OPERATION is generated if program has not +// been successfully linked. GL_INVALID_OPERATION is generated if +// GetAttribLocation is executed between the execution of Begin and the +// corresponding execution of End. +// +// GetAttribLocation is available in GL version 2.0 or greater. +func (gl *GL) GetAttribLocation(program glbase.Program, name string) glbase.Attrib { + name_cstr := C.CString(name) + glresult := C.gl3_1_glGetAttribLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) + return glbase.Attrib(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetAttachedShaders.xml +func (gl *GL) GetAttachedShaders(program glbase.Program, maxCount int32, count []int, obj []uint32) { + C.gl3_1_glGetAttachedShaders(gl.funcs, C.GLuint(program), C.GLsizei(maxCount), (*C.GLsizei)(unsafe.Pointer(&count[0])), (*C.GLuint)(unsafe.Pointer(&obj[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetActiveUniform.xml +func (gl *GL) GetActiveUniform(program glbase.Program, index uint32, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl3_1_glGetActiveUniform(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetActiveAttrib.xml +func (gl *GL) GetActiveAttrib(program glbase.Program, index glbase.Attrib, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl3_1_glGetActiveAttrib(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEnableVertexAttribArray.xml +func (gl *GL) EnableVertexAttribArray(index glbase.Attrib) { + C.gl3_1_glEnableVertexAttribArray(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDisableVertexAttribArray.xml +func (gl *GL) DisableVertexAttribArray(index glbase.Attrib) { + C.gl3_1_glDisableVertexAttribArray(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDetachShader.xml +func (gl *GL) DetachShader(program glbase.Program, shader glbase.Shader) { + C.gl3_1_glDetachShader(gl.funcs, C.GLuint(program), C.GLuint(shader)) +} + +// DeleteShader frees the memory and invalidates the name associated with +// the shader object specified by shader. This command effectively undoes the +// effects of a call to CreateShader. +// +// If a shader object to be deleted is attached to a program object, it will +// be flagged for deletion, but it will not be deleted until it is no longer +// attached to any program object, for any rendering context (it must +// be detached from wherever it was attached before it will be deleted). A +// value of 0 for shader will be silently ignored. +// +// To determine whether an object has been flagged for deletion, call +// GetShader with arguments shader and GL.DELETE_STATUS. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. +// +// DeleteShader is available in GL version 2.0 or greater. +func (gl *GL) DeleteShader(shader glbase.Shader) { + C.gl3_1_glDeleteShader(gl.funcs, C.GLuint(shader)) +} + +// DeleteProgram frees the memory and invalidates the name associated with +// the program object specified by program. This command effectively undoes +// the effects of a call to CreateProgram. +// +// If a program object is in use as part of current rendering state, it will +// be flagged for deletion, but it will not be deleted until it is no longer +// part of current state for any rendering context. If a program object to be +// deleted has shader objects attached to it, those shader objects will be +// automatically detached but not deleted unless they have already been +// flagged for deletion by a previous call to DeleteShader. A value of 0 +// for program will be silently ignored. +// +// To determine whether a program object has been flagged for deletion, call +// GetProgram with arguments program and GL.DELETE_STATUS. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. +// +// DeleteProgram is available in GL version 2.0 or greater. +func (gl *GL) DeleteProgram(program glbase.Program) { + C.gl3_1_glDeleteProgram(gl.funcs, C.GLuint(program)) +} + +// CreateShader creates an empty shader object and returns a non-zero value +// by which it can be referenced. A shader object is used to maintain the +// source code strings that define a shader. shaderType indicates the type of +// shader to be created. +// +// Two types of shaders are supported. A shader of type GL.VERTEX_SHADER is a +// shader that is intended to run on the programmable vertex processor and +// replace the fixed functionality vertex processing in OpenGL. A shader of +// type GL.FRAGMENT_SHADER is a shader that is intended to run on the +// programmable fragment processor and replace the fixed functionality +// fragment processing in OpenGL. +// +// When created, a shader object's GL.SHADER_TYPE parameter is set to either +// GL.VERTEX_SHADER or GL.FRAGMENT_SHADER, depending on the value of +// shaderType. +// +// Like display lists and texture objects, the name space for shader objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// This function returns 0 if an error occurs creating the shader object. +// +// Error GL.INVALID_ENUM is generated if shaderType is not an accepted value. +// GL.INVALID_OPERATION is generated if CreateShader is executed between the +// execution of Begin and the corresponding execution of End. +// +// CreateShader is available in GL version 2.0 or greater. +func (gl *GL) CreateShader(gltype glbase.Enum) glbase.Shader { + glresult := C.gl3_1_glCreateShader(gl.funcs, C.GLenum(gltype)) + return glbase.Shader(glresult) +} + +// CreateProgram creates an empty program object and returns a non-zero +// value by which it can be referenced. A program object is an object to +// which shader objects can be attached. This provides a mechanism to specify +// the shader objects that will be linked to create a program. It also +// provides a means for checking the compatibility of the shaders that will +// be used to create a program (for instance, checking the compatibility +// between a vertex shader and a fragment shader). When no longer needed as +// part of a program object, shader objects can be detached. +// +// One or more executables are created in a program object by successfully +// attaching shader objects to it with AttachShader, successfully compiling +// the shader objects with CompileShader, and successfully linking the +// program object with LinkProgram. These executables are made part of +// current state when UseProgram is called. Program objects can be deleted +// by calling DeleteProgram. The memory associated with the program object +// will be deleted when it is no longer part of current rendering state for +// any context. +// +// Like display lists and texture objects, the name space for program objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// Applications are responsible for providing the synchronization across API +// calls when objects are accessed from different execution threads. +// +// This function returns 0 if an error occurs creating the program object. +// +// Error GL.INVALID_OPERATION is generated if CreateProgram is executed +// between the execution of Begin and the corresponding execution of End. +// +// CreateProgram is available in GL version 2.0 or greater. +func (gl *GL) CreateProgram() glbase.Program { + glresult := C.gl3_1_glCreateProgram(gl.funcs) + return glbase.Program(glresult) +} + +// CompileShader compiles the source code strings that have been stored in +// the shader object specified by shader. +// +// The compilation status will be stored as part of the shader object's +// state. This value will be set to GL.TRUE if the shader was compiled without +// errors and is ready for use, and GL.FALSE otherwise. It can be queried by +// calling GetShaderiv with arguments shader and GL.COMPILE_STATUS. +// +// Compilation of a shader can fail for a number of reasons as specified by +// the OpenGL Shading Language Specification. Whether or not the compilation +// was successful, information about the compilation can be obtained from the +// shader object's information log by calling GetShaderInfoLog. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_OPERATION is generated if CompileShader is executed +// between the execution of Begin and the corresponding execution of End. +// +// CompileShader is available in GL version 2.0 or greater. +func (gl *GL) CompileShader(shader glbase.Shader) { + C.gl3_1_glCompileShader(gl.funcs, C.GLuint(shader)) +} + +// BindAttribLocation associates a user-defined attribute variable in the program +// object specified by program with a generic vertex attribute index. The name +// parameter specifies the name of the vertex shader attribute variable to +// which index is to be bound. When program is made part of the current state, +// values provided via the generic vertex attribute index will modify the +// value of the user-defined attribute variable specified by name. +// +// If name refers to a matrix attribute variable, index refers to the first +// column of the matrix. Other matrix columns are then automatically bound to +// locations index+1 for a matrix of type mat2; index+1 and index+2 for a +// matrix of type mat3; and index+1, index+2, and index+3 for a matrix of +// type mat4. +// +// This command makes it possible for vertex shaders to use descriptive names +// for attribute variables rather than generic variables that are numbered +// from 0 to GL.MAX_VERTEX_ATTRIBS-1. The values sent to each generic +// attribute index are part of current state, just like standard vertex +// attributes such as color, normal, and vertex position. If a different +// program object is made current by calling UseProgram, the generic vertex +// attributes are tracked in such a way that the same values will be observed +// by attributes in the new program object that are also bound to index. +// +// Attribute variable name-to-generic attribute index bindings for a program +// object can be explicitly assigned at any time by calling +// BindAttribLocation. Attribute bindings do not go into effect until +// LinkProgram is called. After a program object has been linked +// successfully, the index values for generic attributes remain fixed (and +// their values can be queried) until the next link command occurs. +// +// Applications are not allowed to bind any of the standard OpenGL vertex +// attributes using this command, as they are bound automatically when +// needed. Any attribute binding that occurs after the program object has +// been linked will not take effect until the next time the program object is +// linked. +// +// If name was bound previously, that information is lost. Thus you cannot +// bind one user-defined attribute variable to multiple indices, but you can +// bind multiple user-defined attribute variables to the same index. +// +// Applications are allowed to bind more than one user-defined attribute +// variable to the same generic vertex attribute index. This is called +// aliasing, and it is allowed only if just one of the aliased attributes is +// active in the executable program, or if no path through the shader +// consumes more than one attribute of a set of attributes aliased to the +// same location. The compiler and linker are allowed to assume that no +// aliasing is done and are free to employ optimizations that work only in +// the absence of aliasing. OpenGL implementations are not required to do +// error checking to detect aliasing. Because there is no way to bind +// standard attributes, it is not possible to alias generic attributes with +// conventional ones (except for generic attribute 0). +// +// BindAttribLocation can be called before any vertex shader objects are +// bound to the specified program object. It is also permissible to bind a +// generic attribute index to an attribute variable name that is never used +// in a vertex shader. +// +// Active attributes that are not explicitly bound will be bound by the +// linker when LinkProgram is called. The locations assigned can be queried +// by calling GetAttribLocation. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. +// GL.INVALID_OPERATION is generated if name starts with the reserved prefix "gl_". +// GL.INVALID_VALUE is generated if program is not a value generated by OpenGL. +// GL.INVALID_OPERATION is generated if program is not a program object. +// GL.INVALID_OPERATION is generated if BindAttribLocation is executed +// between the execution of Begin and the corresponding execution of End. +// +// BindAttribLocation is available in GL version 2.0 or greater. +func (gl *GL) BindAttribLocation(program glbase.Program, index glbase.Attrib, name string) { + name_cstr := C.CString(name) + C.gl3_1_glBindAttribLocation(gl.funcs, C.GLuint(program), C.GLuint(index), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) +} + +// AttachShader attaches a shader object to a program object. +// +// In order to create an executable, there must be a way to specify the list +// of things that will be linked together. Program objects provide this +// mechanism. Shaders that are to be linked together in a program object must +// first be attached to that program object. This indicates that shader will +// be included in link operations that will be performed on program. +// +// All operations that can be performed on a shader object are valid whether +// or not the shader object is attached to a program object. It is +// permissible to attach a shader object to a program object before source +// code has been loaded into the shader object or before the shader object +// has been compiled. It is permissible to attach multiple shader objects of +// the same type because each may contain a portion of the complete shader. +// It is also permissible to attach a shader object to more than one program +// object. If a shader object is deleted while it is attached to a program +// object, it will be flagged for deletion, and deletion will not occur until +// DetachShader is called to detach it from all program objects to which it +// is attached. +// +// Error GL.INVALID_VALUE is generated if either program or shader is not a +// value generated by OpenGL. GL.INVALID_OPERATION is generated if program +// is not a program object. GL.INVALID_OPERATION is generated if shader is +// not a shader object. GL.INVALID_OPERATION is generated if shader is +// already attached to program. GL.INVALID_OPERATION is generated if +// AttachShader is executed between the execution of Begin and the +// corresponding execution of End. +// +// AttachShader is available in GL version 2.0 or greater. +func (gl *GL) AttachShader(program glbase.Program, shader glbase.Shader) { + C.gl3_1_glAttachShader(gl.funcs, C.GLuint(program), C.GLuint(shader)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilMaskSeparate.xml +func (gl *GL) StencilMaskSeparate(face glbase.Enum, mask uint32) { + C.gl3_1_glStencilMaskSeparate(gl.funcs, C.GLenum(face), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilFuncSeparate.xml +func (gl *GL) StencilFuncSeparate(face, glfunc glbase.Enum, ref int32, mask uint32) { + C.gl3_1_glStencilFuncSeparate(gl.funcs, C.GLenum(face), C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilOpSeparate.xml +func (gl *GL) StencilOpSeparate(face, sfail, dpfail, dppass glbase.Enum) { + C.gl3_1_glStencilOpSeparate(gl.funcs, C.GLenum(face), C.GLenum(sfail), C.GLenum(dpfail), C.GLenum(dppass)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawBuffers.xml +func (gl *GL) DrawBuffers(n int, bufs []glbase.Enum) { + C.gl3_1_glDrawBuffers(gl.funcs, C.GLsizei(n), (*C.GLenum)(unsafe.Pointer(&bufs[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlendEquationSeparate.xml +func (gl *GL) BlendEquationSeparate(modeRGB, modeAlpha glbase.Enum) { + C.gl3_1_glBlendEquationSeparate(gl.funcs, C.GLenum(modeRGB), C.GLenum(modeAlpha)) +} + +// UniformMatrix4x3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4x3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4x3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*3) != 0 { + panic("invalid value length for UniformMatrix4x3fv") + } + count := len(value) / (4 * 3) + C.gl3_1_glUniformMatrix4x3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3x4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3x4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3x4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*4) != 0 { + panic("invalid value length for UniformMatrix3x4fv") + } + count := len(value) / (3 * 4) + C.gl3_1_glUniformMatrix3x4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix4x2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4x2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4x2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*2) != 0 { + panic("invalid value length for UniformMatrix4x2fv") + } + count := len(value) / (4 * 2) + C.gl3_1_glUniformMatrix4x2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2x4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2x4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2x4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*4) != 0 { + panic("invalid value length for UniformMatrix2x4fv") + } + count := len(value) / (2 * 4) + C.gl3_1_glUniformMatrix2x4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3x2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3x2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3x2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*2) != 0 { + panic("invalid value length for UniformMatrix3x2fv") + } + count := len(value) / (3 * 2) + C.gl3_1_glUniformMatrix3x2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2x3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2x3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2x3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*3) != 0 { + panic("invalid value length for UniformMatrix2x3fv") + } + count := len(value) / (2 * 3) + C.gl3_1_glUniformMatrix2x3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsVertexArray.xml +func (gl *GL) IsVertexArray(array uint32) bool { + glresult := C.gl3_1_glIsVertexArray(gl.funcs, C.GLuint(array)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGenVertexArrays.xml +func (gl *GL) GenVertexArrays(n int, arrays []uint32) { + C.gl3_1_glGenVertexArrays(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&arrays[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDeleteVertexArrays.xml +func (gl *GL) DeleteVertexArrays(n int, arrays []uint32) { + C.gl3_1_glDeleteVertexArrays(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&arrays[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindVertexArray.xml +func (gl *GL) BindVertexArray(array uint32) { + C.gl3_1_glBindVertexArray(gl.funcs, C.GLuint(array)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFlushMappedBufferRange.xml +func (gl *GL) FlushMappedBufferRange(target glbase.Enum, offset, length int) { + C.gl3_1_glFlushMappedBufferRange(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(length)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFramebufferTextureLayer.xml +func (gl *GL) FramebufferTextureLayer(target, attachment glbase.Enum, texture glbase.Texture, level int, layer int32) { + C.gl3_1_glFramebufferTextureLayer(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLuint(texture), C.GLint(level), C.GLint(layer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRenderbufferStorageMultisample.xml +func (gl *GL) RenderbufferStorageMultisample(target glbase.Enum, samples int32, internalFormat glbase.Enum, width, height int) { + C.gl3_1_glRenderbufferStorageMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlitFramebuffer.xml +func (gl *GL) BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1 int32, mask glbase.Bitfield, filter glbase.Enum) { + C.gl3_1_glBlitFramebuffer(gl.funcs, C.GLint(srcX0), C.GLint(srcY0), C.GLint(srcX1), C.GLint(srcY1), C.GLint(dstX0), C.GLint(dstY0), C.GLint(dstX1), C.GLint(dstY1), C.GLbitfield(mask), C.GLenum(filter)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGenerateMipmap.xml +func (gl *GL) GenerateMipmap(target glbase.Enum) { + C.gl3_1_glGenerateMipmap(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetFramebufferAttachmentParameteriv.xml +func (gl *GL) GetFramebufferAttachmentParameteriv(target, attachment, pname glbase.Enum, params []int32) { + C.gl3_1_glGetFramebufferAttachmentParameteriv(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFramebufferRenderbuffer.xml +func (gl *GL) FramebufferRenderbuffer(target, attachment, renderbuffertarget glbase.Enum, renderbuffer glbase.Renderbuffer) { + C.gl3_1_glFramebufferRenderbuffer(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(renderbuffertarget), C.GLuint(renderbuffer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFramebufferTexture3D.xml +func (gl *GL) FramebufferTexture3D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int, zoffset int32) { + C.gl3_1_glFramebufferTexture3D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level), C.GLint(zoffset)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFramebufferTexture2D.xml +func (gl *GL) FramebufferTexture2D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int) { + C.gl3_1_glFramebufferTexture2D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFramebufferTexture1D.xml +func (gl *GL) FramebufferTexture1D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int) { + C.gl3_1_glFramebufferTexture1D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCheckFramebufferStatus.xml +func (gl *GL) CheckFramebufferStatus(target glbase.Enum) glbase.Enum { + glresult := C.gl3_1_glCheckFramebufferStatus(gl.funcs, C.GLenum(target)) + return glbase.Enum(glresult) +} + +// GenFramebuffers returns n framebuffer object names in ids. There is no +// guarantee that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenFramebuffers. +// +// Framebuffer object names returned by a call to GenFramebuffers are not +// returned by subsequent calls, unless they are first deleted with +// DeleteFramebuffers. +// +// The names returned in ids are marked as used, for the purposes of +// GenFramebuffers only, but they acquire state and type only when they are +// first bound. +// +// Error GL.INVALID_VALUE is generated if n is negative. +func (gl *GL) GenFramebuffers(n int) []glbase.Framebuffer { + if n == 0 { + return nil + } + framebuffers := make([]glbase.Framebuffer, n) + C.gl3_1_glGenFramebuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&framebuffers[0]))) + return framebuffers +} + +// DeleteFramebuffers deletes the framebuffer objects whose names are +// stored in the framebuffers slice. The name zero is reserved by the GL and +// is silently ignored, should it occur in framebuffers, as are other unused +// names. Once a framebuffer object is deleted, its name is again unused and +// it has no attachments. If a framebuffer that is currently bound to one or +// more of the targets GL.DRAW_FRAMEBUFFER or GL.READ_FRAMEBUFFER is deleted, +// it is as though BindFramebuffer had been executed with the corresponding +// target and framebuffer zero. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteFramebuffers is available in GL version 3.0 or greater. +func (gl *GL) DeleteFramebuffers(framebuffers []glbase.Framebuffer) { + n := len(framebuffers) + if n == 0 { + return + } + C.gl3_1_glDeleteFramebuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&framebuffers[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindFramebuffer.xml +func (gl *GL) BindFramebuffer(target glbase.Enum, framebuffer glbase.Framebuffer) { + C.gl3_1_glBindFramebuffer(gl.funcs, C.GLenum(target), C.GLuint(framebuffer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsFramebuffer.xml +func (gl *GL) IsFramebuffer(framebuffer glbase.Framebuffer) bool { + glresult := C.gl3_1_glIsFramebuffer(gl.funcs, C.GLuint(framebuffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetRenderbufferParameteriv.xml +func (gl *GL) GetRenderbufferParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_1_glGetRenderbufferParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRenderbufferStorage.xml +func (gl *GL) RenderbufferStorage(target, internalFormat glbase.Enum, width, height int) { + C.gl3_1_glRenderbufferStorage(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) +} + +// GenRenderbuffers returns n renderbuffer object names in renderbuffers. +// There is no guarantee that the names form a contiguous set of integers; +// however, it is guaranteed that none of the returned names was in use +// immediately before the call to GenRenderbuffers. +// +// Renderbuffer object names returned by a call to GenRenderbuffers are not +// returned by subsequent calls, unless they are first deleted with +// DeleteRenderbuffers. +// +// The names returned in renderbuffers are marked as used, for the purposes +// of GenRenderbuffers only, but they acquire state and type only when they +// are first bound. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenRenderbuffers is available in GL version 3.0 or greater. +func (gl *GL) GenRenderbuffers(n int) []glbase.Renderbuffer { + if n == 0 { + return nil + } + renderbuffers := make([]glbase.Renderbuffer, n) + C.gl3_1_glGenRenderbuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&renderbuffers[0]))) + return renderbuffers +} + +// DeleteRenderbuffers deletes the renderbuffer objects whose names are stored +// in the renderbuffers slice. The name zero is reserved by the GL and +// is silently ignored, should it occur in renderbuffers, as are other unused +// names. Once a renderbuffer object is deleted, its name is again unused and +// it has no contents. If a renderbuffer that is currently bound to the +// target GL.RENDERBUFFER is deleted, it is as though BindRenderbuffer had +// been executed with a target of GL.RENDERBUFFER and a name of zero. +// +// If a renderbuffer object is attached to one or more attachment points in +// the currently bound framebuffer, then it as if FramebufferRenderbuffer +// had been called, with a renderbuffer of zero for each attachment point to +// which this image was attached in the currently bound framebuffer. In other +// words, this renderbuffer object is first detached from all attachment +// ponits in the currently bound framebuffer. Note that the renderbuffer +// image is specifically not detached from any non-bound framebuffers. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteRenderbuffers is available in GL version 3.0 or greater. +func (gl *GL) DeleteRenderbuffers(renderbuffers []glbase.Renderbuffer) { + n := len(renderbuffers) + if n == 0 { + return + } + C.gl3_1_glDeleteRenderbuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&renderbuffers[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindRenderbuffer.xml +func (gl *GL) BindRenderbuffer(target glbase.Enum, renderbuffer glbase.Renderbuffer) { + C.gl3_1_glBindRenderbuffer(gl.funcs, C.GLenum(target), C.GLuint(renderbuffer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsRenderbuffer.xml +func (gl *GL) IsRenderbuffer(renderbuffer glbase.Renderbuffer) bool { + glresult := C.gl3_1_glIsRenderbuffer(gl.funcs, C.GLuint(renderbuffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearBufferfi.xml +func (gl *GL) ClearBufferfi(buffer glbase.Enum, drawbuffer int32, depth float32, stencil int32) { + C.gl3_1_glClearBufferfi(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), C.GLfloat(depth), C.GLint(stencil)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearBufferfv.xml +func (gl *GL) ClearBufferfv(buffer glbase.Enum, drawbuffer int32, value []float32) { + C.gl3_1_glClearBufferfv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearBufferuiv.xml +func (gl *GL) ClearBufferuiv(buffer glbase.Enum, drawbuffer int32, value []uint32) { + C.gl3_1_glClearBufferuiv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearBufferiv.xml +func (gl *GL) ClearBufferiv(buffer glbase.Enum, drawbuffer int32, value []int32) { + C.gl3_1_glClearBufferiv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexParameterIuiv.xml +func (gl *GL) GetTexParameterIuiv(target, pname glbase.Enum, params []uint32) { + C.gl3_1_glGetTexParameterIuiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexParameterIiv.xml +func (gl *GL) GetTexParameterIiv(target, pname glbase.Enum, params []int32) { + C.gl3_1_glGetTexParameterIiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameterIuiv.xml +func (gl *GL) TexParameterIuiv(target, pname glbase.Enum, params []uint32) { + C.gl3_1_glTexParameterIuiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameterIiv.xml +func (gl *GL) TexParameterIiv(target, pname glbase.Enum, params []int32) { + C.gl3_1_glTexParameterIiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// Uniform4uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4uiv") + } + count := len(value) / 4 + C.gl3_1_glUniform4uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform3uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3uiv") + } + count := len(value) / 3 + C.gl3_1_glUniform3uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform2uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2uiv") + } + count := len(value) / 2 + C.gl3_1_glUniform2uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform1uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl3_1_glUniform1uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform4ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4ui(location glbase.Uniform, v0, v1, v2, v3 uint32) { + C.gl3_1_glUniform4ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2), C.GLuint(v3)) +} + +// Uniform3ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3ui(location glbase.Uniform, v0, v1, v2 uint32) { + C.gl3_1_glUniform3ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2)) +} + +// Uniform2ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2ui(location glbase.Uniform, v0, v1 uint32) { + C.gl3_1_glUniform2ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1)) +} + +// Uniform1ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1ui(location glbase.Uniform, v0 uint32) { + C.gl3_1_glUniform1ui(gl.funcs, C.GLint(location), C.GLuint(v0)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetFragDataLocation.xml +func (gl *GL) GetFragDataLocation(program glbase.Program, name []byte) int32 { + glresult := C.gl3_1_glGetFragDataLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindFragDataLocation.xml +func (gl *GL) BindFragDataLocation(program glbase.Program, color uint32, name []byte) { + C.gl3_1_glBindFragDataLocation(gl.funcs, C.GLuint(program), C.GLuint(color), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetUniformuiv.xml +func (gl *GL) GetUniformuiv(program glbase.Program, location glbase.Uniform, params []uint32) { + C.gl3_1_glGetUniformuiv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetVertexAttribIuiv.xml +func (gl *GL) GetVertexAttribIuiv(index glbase.Attrib, pname glbase.Enum, params []uint32) { + C.gl3_1_glGetVertexAttribIuiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetVertexAttribIiv.xml +func (gl *GL) GetVertexAttribIiv(index glbase.Attrib, pname glbase.Enum, params []int32) { + C.gl3_1_glGetVertexAttribIiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribIPointer.xml +func (gl *GL) VertexAttribIPointer(index glbase.Attrib, size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl3_1_glVertexAttribIPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEndConditionalRender.xml +func (gl *GL) EndConditionalRender() { + C.gl3_1_glEndConditionalRender(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBeginConditionalRender.xml +func (gl *GL) BeginConditionalRender(id uint32, mode glbase.Enum) { + C.gl3_1_glBeginConditionalRender(gl.funcs, C.GLuint(id), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClampColor.xml +func (gl *GL) ClampColor(target, clamp glbase.Enum) { + C.gl3_1_glClampColor(gl.funcs, C.GLenum(target), C.GLenum(clamp)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTransformFeedbackVarying.xml +func (gl *GL) GetTransformFeedbackVarying(program glbase.Program, index uint32, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl3_1_glGetTransformFeedbackVarying(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLsizei)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindBufferBase.xml +func (gl *GL) BindBufferBase(target glbase.Enum, index uint32, buffer glbase.Buffer) { + C.gl3_1_glBindBufferBase(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindBufferRange.xml +func (gl *GL) BindBufferRange(target glbase.Enum, index uint32, buffer glbase.Buffer, offset, size int) { + C.gl3_1_glBindBufferRange(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(buffer), C.GLintptr(offset), C.GLsizeiptr(size)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEndTransformFeedback.xml +func (gl *GL) EndTransformFeedback() { + C.gl3_1_glEndTransformFeedback(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBeginTransformFeedback.xml +func (gl *GL) BeginTransformFeedback(primitiveMode glbase.Enum) { + C.gl3_1_glBeginTransformFeedback(gl.funcs, C.GLenum(primitiveMode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsEnabledi.xml +func (gl *GL) IsEnabledi(target glbase.Enum, index uint32) bool { + glresult := C.gl3_1_glIsEnabledi(gl.funcs, C.GLenum(target), C.GLuint(index)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDisablei.xml +func (gl *GL) Disablei(target glbase.Enum, index uint32) { + C.gl3_1_glDisablei(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEnablei.xml +func (gl *GL) Enablei(target glbase.Enum, index uint32) { + C.gl3_1_glEnablei(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetIntegeri_v.xml +func (gl *GL) GetIntegeri_v(target glbase.Enum, index uint32, data []int32) { + C.gl3_1_glGetIntegeri_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLint)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetBooleani_v.xml +func (gl *GL) GetBooleani_v(target glbase.Enum, index uint32, data []bool) { + C.gl3_1_glGetBooleani_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLboolean)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorMaski.xml +func (gl *GL) ColorMaski(index uint32, r, g, b, a bool) { + C.gl3_1_glColorMaski(gl.funcs, C.GLuint(index), *(*C.GLboolean)(unsafe.Pointer(&r)), *(*C.GLboolean)(unsafe.Pointer(&g)), *(*C.GLboolean)(unsafe.Pointer(&b)), *(*C.GLboolean)(unsafe.Pointer(&a))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyBufferSubData.xml +func (gl *GL) CopyBufferSubData(readTarget, writeTarget glbase.Enum, readOffset, writeOffset, size int) { + C.gl3_1_glCopyBufferSubData(gl.funcs, C.GLenum(readTarget), C.GLenum(writeTarget), C.GLintptr(readOffset), C.GLintptr(writeOffset), C.GLsizeiptr(size)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glUniformBlockBinding.xml +func (gl *GL) UniformBlockBinding(program glbase.Program, v0, v1 uint32) { + C.gl3_1_glUniformBlockBinding(gl.funcs, C.GLuint(program), C.GLuint(v0), C.GLuint(v1)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetActiveUniformBlockName.xml +func (gl *GL) GetActiveUniformBlockName(program glbase.Program, uniformBlockIndex uint32, bufSize int32, length []int32, uniformBlockName []byte) { + C.gl3_1_glGetActiveUniformBlockName(gl.funcs, C.GLuint(program), C.GLuint(uniformBlockIndex), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&uniformBlockName[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetActiveUniformBlockiv.xml +func (gl *GL) GetActiveUniformBlockiv(program glbase.Program, uniformBlockIndex uint32, pname glbase.Enum, params []int32) { + C.gl3_1_glGetActiveUniformBlockiv(gl.funcs, C.GLuint(program), C.GLuint(uniformBlockIndex), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetUniformBlockIndex.xml +func (gl *GL) GetUniformBlockIndex(program glbase.Program, uniformBlockName []byte) uint32 { + glresult := C.gl3_1_glGetUniformBlockIndex(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&uniformBlockName[0]))) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetActiveUniformName.xml +func (gl *GL) GetActiveUniformName(program glbase.Program, uniformIndex uint32, bufSize int32, length []int32, uniformName []byte) { + C.gl3_1_glGetActiveUniformName(gl.funcs, C.GLuint(program), C.GLuint(uniformIndex), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&uniformName[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetActiveUniformsiv.xml +func (gl *GL) GetActiveUniformsiv(program glbase.Program, uniformCount int32, uniformIndices []uint32, pname glbase.Enum, params []int32) { + C.gl3_1_glGetActiveUniformsiv(gl.funcs, C.GLuint(program), C.GLsizei(uniformCount), (*C.GLuint)(unsafe.Pointer(&uniformIndices[0])), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPrimitiveRestartIndex.xml +func (gl *GL) PrimitiveRestartIndex(index uint32) { + C.gl3_1_glPrimitiveRestartIndex(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexBuffer.xml +func (gl *GL) TexBuffer(target, internalFormat glbase.Enum, buffer glbase.Buffer) { + C.gl3_1_glTexBuffer(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawElementsInstanced.xml +func (gl *GL) DrawElementsInstanced(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, instancecount int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl3_1_glDrawElementsInstanced(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLsizei(instancecount)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawArraysInstanced.xml +func (gl *GL) DrawArraysInstanced(mode glbase.Enum, first, count int, instancecount int32) { + C.gl3_1_glDrawArraysInstanced(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count), C.GLsizei(instancecount)) +} diff --git a/gl/3.2compat/funcs.cpp b/gl/3.2compat/funcs.cpp new file mode 100644 index 00000000..c35066eb --- /dev/null +++ b/gl/3.2compat/funcs.cpp @@ -0,0 +1,4140 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#include +#include + +#include "funcs.h" + +void *gl3_2compat_funcs() { + QOpenGLFunctions_3_2_Compatibility* funcs = QOpenGLContext::currentContext()->versionFunctions(); + if (!funcs) { + return 0; + } + funcs->initializeOpenGLFunctions(); + return funcs; +} + + +void gl3_2compat_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewport(x, y, width, height); +} + +void gl3_2compat_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRange(nearVal, farVal); +} + +GLboolean gl3_2compat_glIsEnabled(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabled(cap); +} + +void gl3_2compat_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameteriv(target, level, pname, params); +} + +void gl3_2compat_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameterfv(target, level, pname, params); +} + +void gl3_2compat_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameteriv(target, pname, params); +} + +void gl3_2compat_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterfv(target, pname, params); +} + +void gl3_2compat_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexImage(target, level, format, gltype, pixels); +} + +void gl3_2compat_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegerv(pname, params); +} + +void gl3_2compat_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFloatv(pname, params); +} + +GLenum gl3_2compat_glGetError(void *_glfuncs) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetError(); +} + +void gl3_2compat_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetDoublev(pname, params); +} + +void gl3_2compat_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleanv(pname, params); +} + +void gl3_2compat_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadPixels(x, y, width, height, format, gltype, pixels); +} + +void gl3_2compat_glReadBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadBuffer(mode); +} + +void gl3_2compat_glPixelStorei(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStorei(pname, param); +} + +void gl3_2compat_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStoref(pname, param); +} + +void gl3_2compat_glDepthFunc(void *_glfuncs, GLenum glfunc) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthFunc(glfunc); +} + +void gl3_2compat_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOp(fail, zfail, zpass); +} + +void gl3_2compat_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFunc(glfunc, ref, mask); +} + +void gl3_2compat_glLogicOp(void *_glfuncs, GLenum opcode) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLogicOp(opcode); +} + +void gl3_2compat_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFunc(sfactor, dfactor); +} + +void gl3_2compat_glFlush(void *_glfuncs) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlush(); +} + +void gl3_2compat_glFinish(void *_glfuncs) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFinish(); +} + +void gl3_2compat_glEnable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnable(cap); +} + +void gl3_2compat_glDisable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisable(cap); +} + +void gl3_2compat_glDepthMask(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthMask(flag); +} + +void gl3_2compat_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMask(red, green, blue, alpha); +} + +void gl3_2compat_glStencilMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMask(mask); +} + +void gl3_2compat_glClearDepth(void *_glfuncs, GLdouble depth) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearDepth(depth); +} + +void gl3_2compat_glClearStencil(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearStencil(s); +} + +void gl3_2compat_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearColor(red, green, blue, alpha); +} + +void gl3_2compat_glClear(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClear(mask); +} + +void gl3_2compat_glDrawBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffer(mode); +} + +void gl3_2compat_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage2D(target, level, internalFormat, width, height, border, format, gltype, pixels); +} + +void gl3_2compat_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage1D(target, level, internalFormat, width, border, format, gltype, pixels); +} + +void gl3_2compat_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteriv(target, pname, params); +} + +void gl3_2compat_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteri(target, pname, param); +} + +void gl3_2compat_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterfv(target, pname, params); +} + +void gl3_2compat_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterf(target, pname, param); +} + +void gl3_2compat_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissor(x, y, width, height); +} + +void gl3_2compat_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonMode(face, mode); +} + +void gl3_2compat_glPointSize(void *_glfuncs, GLfloat size) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointSize(size); +} + +void gl3_2compat_glLineWidth(void *_glfuncs, GLfloat width) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineWidth(width); +} + +void gl3_2compat_glHint(void *_glfuncs, GLenum target, GLenum mode) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glHint(target, mode); +} + +void gl3_2compat_glFrontFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrontFace(mode); +} + +void gl3_2compat_glCullFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCullFace(mode); +} + +void gl3_2compat_glIndexubv(void *_glfuncs, const GLubyte* c) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexubv(c); +} + +void gl3_2compat_glIndexub(void *_glfuncs, GLubyte c) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexub(c); +} + +GLboolean gl3_2compat_glIsTexture(void *_glfuncs, GLuint texture) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsTexture(texture); +} + +void gl3_2compat_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenTextures(n, textures); +} + +void gl3_2compat_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteTextures(n, textures); +} + +void gl3_2compat_glBindTexture(void *_glfuncs, GLenum target, GLuint texture) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindTexture(target, texture); +} + +void gl3_2compat_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, gltype, pixels); +} + +void gl3_2compat_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage1D(target, level, xoffset, width, format, gltype, pixels); +} + +void gl3_2compat_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); +} + +void gl3_2compat_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage1D(target, level, xoffset, x, y, width); +} + +void gl3_2compat_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage2D(target, level, internalFormat, x, y, width, height, border); +} + +void gl3_2compat_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage1D(target, level, internalFormat, x, y, width, border); +} + +void gl3_2compat_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonOffset(factor, units); +} + +void gl3_2compat_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElements(mode, count, gltype, indices); +} + +void gl3_2compat_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArrays(mode, first, count); +} + +void gl3_2compat_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); +} + +void gl3_2compat_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, gltype, pixels); +} + +void gl3_2compat_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage3D(target, level, internalFormat, width, height, depth, border, format, gltype, pixels); +} + +void gl3_2compat_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawRangeElements(mode, start, end, count, gltype, indices); +} + +void gl3_2compat_glBlendEquation(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquation(mode); +} + +void gl3_2compat_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendColor(red, green, blue, alpha); +} + +void gl3_2compat_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetCompressedTexImage(target, level, img); +} + +void gl3_2compat_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data); +} + +void gl3_2compat_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); +} + +void gl3_2compat_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); +} + +void gl3_2compat_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage1D(target, level, internalFormat, width, border, imageSize, data); +} + +void gl3_2compat_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data); +} + +void gl3_2compat_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage3D(target, level, internalFormat, width, height, depth, border, imageSize, data); +} + +void gl3_2compat_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSampleCoverage(value, invert); +} + +void gl3_2compat_glActiveTexture(void *_glfuncs, GLenum texture) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glActiveTexture(texture); +} + +void gl3_2compat_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteriv(pname, params); +} + +void gl3_2compat_glPointParameteri(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteri(pname, param); +} + +void gl3_2compat_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterfv(pname, params); +} + +void gl3_2compat_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterf(pname, param); +} + +void gl3_2compat_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiDrawArrays(mode, first, count, drawcount); +} + +void gl3_2compat_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); +} + +void gl3_2compat_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferParameteriv(target, pname, params); +} + +GLboolean gl3_2compat_glUnmapBuffer(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glUnmapBuffer(target); +} + +void gl3_2compat_glGetBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferSubData(target, offset, size, data); +} + +void gl3_2compat_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferSubData(target, offset, size, data); +} + +void gl3_2compat_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferData(target, size, data, usage); +} + +GLboolean gl3_2compat_glIsBuffer(void *_glfuncs, GLuint buffer) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsBuffer(buffer); +} + +void gl3_2compat_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenBuffers(n, buffers); +} + +void gl3_2compat_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteBuffers(n, buffers); +} + +void gl3_2compat_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBuffer(target, buffer); +} + +void gl3_2compat_glGetQueryObjectuiv(void *_glfuncs, GLuint id, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectuiv(id, pname, params); +} + +void gl3_2compat_glGetQueryObjectiv(void *_glfuncs, GLuint id, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectiv(id, pname, params); +} + +void gl3_2compat_glGetQueryiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryiv(target, pname, params); +} + +void gl3_2compat_glEndQuery(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndQuery(target); +} + +void gl3_2compat_glBeginQuery(void *_glfuncs, GLenum target, GLuint id) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginQuery(target, id); +} + +GLboolean gl3_2compat_glIsQuery(void *_glfuncs, GLuint id) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsQuery(id); +} + +void gl3_2compat_glDeleteQueries(void *_glfuncs, GLsizei n, const GLuint* ids) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteQueries(n, ids); +} + +void gl3_2compat_glGenQueries(void *_glfuncs, GLsizei n, GLuint* ids) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenQueries(n, ids); +} + +void gl3_2compat_glVertexAttribPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLboolean normalized, GLsizei stride, const GLvoid* offset) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribPointer(index, size, gltype, normalized, stride, offset); +} + +void gl3_2compat_glValidateProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glValidateProgram(program); +} + +void gl3_2compat_glUniformMatrix4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4fv(location, count, transpose, value); +} + +void gl3_2compat_glUniformMatrix3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3fv(location, count, transpose, value); +} + +void gl3_2compat_glUniformMatrix2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2fv(location, count, transpose, value); +} + +void gl3_2compat_glUniform4iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4iv(location, count, value); +} + +void gl3_2compat_glUniform3iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3iv(location, count, value); +} + +void gl3_2compat_glUniform2iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2iv(location, count, value); +} + +void gl3_2compat_glUniform1iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1iv(location, count, value); +} + +void gl3_2compat_glUniform4fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4fv(location, count, value); +} + +void gl3_2compat_glUniform3fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3fv(location, count, value); +} + +void gl3_2compat_glUniform2fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2fv(location, count, value); +} + +void gl3_2compat_glUniform1fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1fv(location, count, value); +} + +void gl3_2compat_glUniform4i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4i(location, v0, v1, v2, v3); +} + +void gl3_2compat_glUniform3i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3i(location, v0, v1, v2); +} + +void gl3_2compat_glUniform2i(void *_glfuncs, GLint location, GLint v0, GLint v1) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2i(location, v0, v1); +} + +void gl3_2compat_glUniform1i(void *_glfuncs, GLint location, GLint v0) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1i(location, v0); +} + +void gl3_2compat_glUniform4f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4f(location, v0, v1, v2, v3); +} + +void gl3_2compat_glUniform3f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3f(location, v0, v1, v2); +} + +void gl3_2compat_glUniform2f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2f(location, v0, v1); +} + +void gl3_2compat_glUniform1f(void *_glfuncs, GLint location, GLfloat v0) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1f(location, v0); +} + +void gl3_2compat_glUseProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUseProgram(program); +} + +void gl3_2compat_glShaderSource(void *_glfuncs, GLuint shader, GLsizei count, const GLchar** source, const GLint* length) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShaderSource(shader, count, source, length); +} + +void gl3_2compat_glLinkProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLinkProgram(program); +} + +GLboolean gl3_2compat_glIsShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsShader(shader); +} + +GLboolean gl3_2compat_glIsProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsProgram(program); +} + +void gl3_2compat_glGetVertexAttribiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribiv(index, pname, params); +} + +void gl3_2compat_glGetVertexAttribfv(void *_glfuncs, GLuint index, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribfv(index, pname, params); +} + +void gl3_2compat_glGetVertexAttribdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribdv(index, pname, params); +} + +void gl3_2compat_glGetUniformiv(void *_glfuncs, GLuint program, GLint location, GLint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformiv(program, location, params); +} + +void gl3_2compat_glGetUniformfv(void *_glfuncs, GLuint program, GLint location, GLfloat* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformfv(program, location, params); +} + +GLint gl3_2compat_glGetUniformLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetUniformLocation(program, name); +} + +void gl3_2compat_glGetShaderSource(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderSource(shader, bufSize, length, source); +} + +void gl3_2compat_glGetShaderInfoLog(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderInfoLog(shader, bufSize, length, infoLog); +} + +void gl3_2compat_glGetShaderiv(void *_glfuncs, GLuint shader, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderiv(shader, pname, params); +} + +void gl3_2compat_glGetProgramInfoLog(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramInfoLog(program, bufSize, length, infoLog); +} + +void gl3_2compat_glGetProgramiv(void *_glfuncs, GLuint program, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramiv(program, pname, params); +} + +GLint gl3_2compat_glGetAttribLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetAttribLocation(program, name); +} + +void gl3_2compat_glGetAttachedShaders(void *_glfuncs, GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetAttachedShaders(program, maxCount, count, obj); +} + +void gl3_2compat_glGetActiveUniform(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniform(program, index, bufSize, length, size, gltype, name); +} + +void gl3_2compat_glGetActiveAttrib(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveAttrib(program, index, bufSize, length, size, gltype, name); +} + +void gl3_2compat_glEnableVertexAttribArray(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnableVertexAttribArray(index); +} + +void gl3_2compat_glDisableVertexAttribArray(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisableVertexAttribArray(index); +} + +void gl3_2compat_glDetachShader(void *_glfuncs, GLuint program, GLuint shader) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDetachShader(program, shader); +} + +void gl3_2compat_glDeleteShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteShader(shader); +} + +void gl3_2compat_glDeleteProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteProgram(program); +} + +GLuint gl3_2compat_glCreateShader(void *_glfuncs, GLenum gltype) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCreateShader(gltype); +} + +GLuint gl3_2compat_glCreateProgram(void *_glfuncs) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCreateProgram(); +} + +void gl3_2compat_glCompileShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompileShader(shader); +} + +void gl3_2compat_glBindAttribLocation(void *_glfuncs, GLuint program, GLuint index, const GLchar* name) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindAttribLocation(program, index, name); +} + +void gl3_2compat_glAttachShader(void *_glfuncs, GLuint program, GLuint shader) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAttachShader(program, shader); +} + +void gl3_2compat_glStencilMaskSeparate(void *_glfuncs, GLenum face, GLuint mask) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMaskSeparate(face, mask); +} + +void gl3_2compat_glStencilFuncSeparate(void *_glfuncs, GLenum face, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFuncSeparate(face, glfunc, ref, mask); +} + +void gl3_2compat_glStencilOpSeparate(void *_glfuncs, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOpSeparate(face, sfail, dpfail, dppass); +} + +void gl3_2compat_glDrawBuffers(void *_glfuncs, GLsizei n, const GLenum* bufs) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffers(n, bufs); +} + +void gl3_2compat_glBlendEquationSeparate(void *_glfuncs, GLenum modeRGB, GLenum modeAlpha) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquationSeparate(modeRGB, modeAlpha); +} + +void gl3_2compat_glUniformMatrix4x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x3fv(location, count, transpose, value); +} + +void gl3_2compat_glUniformMatrix3x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x4fv(location, count, transpose, value); +} + +void gl3_2compat_glUniformMatrix4x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x2fv(location, count, transpose, value); +} + +void gl3_2compat_glUniformMatrix2x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x4fv(location, count, transpose, value); +} + +void gl3_2compat_glUniformMatrix3x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x2fv(location, count, transpose, value); +} + +void gl3_2compat_glUniformMatrix2x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x3fv(location, count, transpose, value); +} + +GLboolean gl3_2compat_glIsVertexArray(void *_glfuncs, GLuint array) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsVertexArray(array); +} + +void gl3_2compat_glGenVertexArrays(void *_glfuncs, GLsizei n, GLuint* arrays) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenVertexArrays(n, arrays); +} + +void gl3_2compat_glDeleteVertexArrays(void *_glfuncs, GLsizei n, const GLuint* arrays) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteVertexArrays(n, arrays); +} + +void gl3_2compat_glBindVertexArray(void *_glfuncs, GLuint array) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindVertexArray(array); +} + +void gl3_2compat_glFlushMappedBufferRange(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr length) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlushMappedBufferRange(target, offset, length); +} + +void gl3_2compat_glFramebufferTextureLayer(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTextureLayer(target, attachment, texture, level, layer); +} + +void gl3_2compat_glRenderbufferStorageMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRenderbufferStorageMultisample(target, samples, internalFormat, width, height); +} + +void gl3_2compat_glBlitFramebuffer(void *_glfuncs, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); +} + +void gl3_2compat_glGenerateMipmap(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenerateMipmap(target); +} + +void gl3_2compat_glGetFramebufferAttachmentParameteriv(void *_glfuncs, GLenum target, GLenum attachment, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFramebufferAttachmentParameteriv(target, attachment, pname, params); +} + +void gl3_2compat_glFramebufferRenderbuffer(void *_glfuncs, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer); +} + +void gl3_2compat_glFramebufferTexture3D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset); +} + +void gl3_2compat_glFramebufferTexture2D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture2D(target, attachment, textarget, texture, level); +} + +void gl3_2compat_glFramebufferTexture1D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture1D(target, attachment, textarget, texture, level); +} + +GLenum gl3_2compat_glCheckFramebufferStatus(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCheckFramebufferStatus(target); +} + +void gl3_2compat_glGenFramebuffers(void *_glfuncs, GLsizei n, GLuint* framebuffers) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenFramebuffers(n, framebuffers); +} + +void gl3_2compat_glDeleteFramebuffers(void *_glfuncs, GLsizei n, const GLuint* framebuffers) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteFramebuffers(n, framebuffers); +} + +void gl3_2compat_glBindFramebuffer(void *_glfuncs, GLenum target, GLuint framebuffer) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFramebuffer(target, framebuffer); +} + +GLboolean gl3_2compat_glIsFramebuffer(void *_glfuncs, GLuint framebuffer) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsFramebuffer(framebuffer); +} + +void gl3_2compat_glGetRenderbufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetRenderbufferParameteriv(target, pname, params); +} + +void gl3_2compat_glRenderbufferStorage(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRenderbufferStorage(target, internalFormat, width, height); +} + +void gl3_2compat_glGenRenderbuffers(void *_glfuncs, GLsizei n, GLuint* renderbuffers) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenRenderbuffers(n, renderbuffers); +} + +void gl3_2compat_glDeleteRenderbuffers(void *_glfuncs, GLsizei n, const GLuint* renderbuffers) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteRenderbuffers(n, renderbuffers); +} + +void gl3_2compat_glBindRenderbuffer(void *_glfuncs, GLenum target, GLuint renderbuffer) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindRenderbuffer(target, renderbuffer); +} + +GLboolean gl3_2compat_glIsRenderbuffer(void *_glfuncs, GLuint renderbuffer) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsRenderbuffer(renderbuffer); +} + +void gl3_2compat_glClearBufferfi(void *_glfuncs, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferfi(buffer, drawbuffer, depth, stencil); +} + +void gl3_2compat_glClearBufferfv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLfloat* value) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferfv(buffer, drawbuffer, value); +} + +void gl3_2compat_glClearBufferuiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLuint* value) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferuiv(buffer, drawbuffer, value); +} + +void gl3_2compat_glClearBufferiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLint* value) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferiv(buffer, drawbuffer, value); +} + +void gl3_2compat_glGetTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterIuiv(target, pname, params); +} + +void gl3_2compat_glGetTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterIiv(target, pname, params); +} + +void gl3_2compat_glTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, const GLuint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterIuiv(target, pname, params); +} + +void gl3_2compat_glTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterIiv(target, pname, params); +} + +void gl3_2compat_glUniform4uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4uiv(location, count, value); +} + +void gl3_2compat_glUniform3uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3uiv(location, count, value); +} + +void gl3_2compat_glUniform2uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2uiv(location, count, value); +} + +void gl3_2compat_glUniform1uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1uiv(location, count, value); +} + +void gl3_2compat_glUniform4ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4ui(location, v0, v1, v2, v3); +} + +void gl3_2compat_glUniform3ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3ui(location, v0, v1, v2); +} + +void gl3_2compat_glUniform2ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2ui(location, v0, v1); +} + +void gl3_2compat_glUniform1ui(void *_glfuncs, GLint location, GLuint v0) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1ui(location, v0); +} + +GLint gl3_2compat_glGetFragDataLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetFragDataLocation(program, name); +} + +void gl3_2compat_glBindFragDataLocation(void *_glfuncs, GLuint program, GLuint color, const GLchar* name) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFragDataLocation(program, color, name); +} + +void gl3_2compat_glGetUniformuiv(void *_glfuncs, GLuint program, GLint location, GLuint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformuiv(program, location, params); +} + +void gl3_2compat_glGetVertexAttribIuiv(void *_glfuncs, GLuint index, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribIuiv(index, pname, params); +} + +void gl3_2compat_glGetVertexAttribIiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribIiv(index, pname, params); +} + +void gl3_2compat_glVertexAttribIPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribIPointer(index, size, gltype, stride, pointer); +} + +void gl3_2compat_glEndConditionalRender(void *_glfuncs) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndConditionalRender(); +} + +void gl3_2compat_glBeginConditionalRender(void *_glfuncs, GLuint id, GLenum mode) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginConditionalRender(id, mode); +} + +void gl3_2compat_glClampColor(void *_glfuncs, GLenum target, GLenum clamp) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClampColor(target, clamp); +} + +void gl3_2compat_glGetTransformFeedbackVarying(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTransformFeedbackVarying(program, index, bufSize, length, size, gltype, name); +} + +void gl3_2compat_glBindBufferBase(void *_glfuncs, GLenum target, GLuint index, GLuint buffer) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBufferBase(target, index, buffer); +} + +void gl3_2compat_glBindBufferRange(void *_glfuncs, GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBufferRange(target, index, buffer, offset, size); +} + +void gl3_2compat_glEndTransformFeedback(void *_glfuncs) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndTransformFeedback(); +} + +void gl3_2compat_glBeginTransformFeedback(void *_glfuncs, GLenum primitiveMode) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginTransformFeedback(primitiveMode); +} + +GLboolean gl3_2compat_glIsEnabledi(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabledi(target, index); +} + +void gl3_2compat_glDisablei(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisablei(target, index); +} + +void gl3_2compat_glEnablei(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnablei(target, index); +} + +void gl3_2compat_glGetIntegeri_v(void *_glfuncs, GLenum target, GLuint index, GLint* data) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegeri_v(target, index, data); +} + +void gl3_2compat_glGetBooleani_v(void *_glfuncs, GLenum target, GLuint index, GLboolean* data) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleani_v(target, index, data); +} + +void gl3_2compat_glColorMaski(void *_glfuncs, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMaski(index, r, g, b, a); +} + +void gl3_2compat_glCopyBufferSubData(void *_glfuncs, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); +} + +void gl3_2compat_glUniformBlockBinding(void *_glfuncs, GLuint program, GLuint v0, GLuint v1) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformBlockBinding(program, v0, v1); +} + +void gl3_2compat_glGetActiveUniformBlockName(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName); +} + +void gl3_2compat_glGetActiveUniformBlockiv(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params); +} + +GLuint gl3_2compat_glGetUniformBlockIndex(void *_glfuncs, GLuint program, const GLchar* uniformBlockName) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetUniformBlockIndex(program, uniformBlockName); +} + +void gl3_2compat_glGetActiveUniformName(void *_glfuncs, GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformName(program, uniformIndex, bufSize, length, uniformName); +} + +void gl3_2compat_glGetActiveUniformsiv(void *_glfuncs, GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params); +} + +void gl3_2compat_glPrimitiveRestartIndex(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPrimitiveRestartIndex(index); +} + +void gl3_2compat_glTexBuffer(void *_glfuncs, GLenum target, GLenum internalFormat, GLuint buffer) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexBuffer(target, internalFormat, buffer); +} + +void gl3_2compat_glDrawElementsInstanced(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsInstanced(mode, count, gltype, indices, instancecount); +} + +void gl3_2compat_glDrawArraysInstanced(void *_glfuncs, GLenum mode, GLint first, GLsizei count, GLsizei instancecount) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArraysInstanced(mode, first, count, instancecount); +} + +void gl3_2compat_glSampleMaski(void *_glfuncs, GLuint index, GLbitfield mask) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSampleMaski(index, mask); +} + +void gl3_2compat_glGetMultisamplefv(void *_glfuncs, GLenum pname, GLuint index, GLfloat* val) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMultisamplefv(pname, index, val); +} + +void gl3_2compat_glTexImage3DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage3DMultisample(target, samples, internalFormat, width, height, depth, fixedsamplelocations); +} + +void gl3_2compat_glTexImage2DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage2DMultisample(target, samples, internalFormat, width, height, fixedsamplelocations); +} + +void gl3_2compat_glGetSynciv(void *_glfuncs, GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSynciv(sync, pname, bufSize, length, values); +} + +void gl3_2compat_glGetInteger64v(void *_glfuncs, GLenum pname, GLint64* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetInteger64v(pname, params); +} + +void gl3_2compat_glWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWaitSync(sync, flags, timeout); +} + +GLenum gl3_2compat_glClientWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glClientWaitSync(sync, flags, timeout); +} + +void gl3_2compat_glDeleteSync(void *_glfuncs, GLsync sync) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteSync(sync); +} + +GLboolean gl3_2compat_glIsSync(void *_glfuncs, GLsync sync) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsSync(sync); +} + +GLsync gl3_2compat_glFenceSync(void *_glfuncs, GLenum condition, GLbitfield flags) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glFenceSync(condition, flags); +} + +void gl3_2compat_glProvokingVertex(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProvokingVertex(mode); +} + +void gl3_2compat_glDrawElementsInstancedBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLint basevertex) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsInstancedBaseVertex(mode, count, gltype, indices, instancecount, basevertex); +} + +void gl3_2compat_glDrawRangeElementsBaseVertex(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawRangeElementsBaseVertex(mode, start, end, count, gltype, indices, basevertex); +} + +void gl3_2compat_glDrawElementsBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsBaseVertex(mode, count, gltype, indices, basevertex); +} + +void gl3_2compat_glFramebufferTexture(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture(target, attachment, texture, level); +} + +void gl3_2compat_glGetBufferParameteri64v(void *_glfuncs, GLenum target, GLenum pname, GLint64* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferParameteri64v(target, pname, params); +} + +void gl3_2compat_glGetInteger64i_v(void *_glfuncs, GLenum target, GLuint index, GLint64* data) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetInteger64i_v(target, index, data); +} + +void gl3_2compat_glTranslatef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTranslatef(x, y, z); +} + +void gl3_2compat_glTranslated(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTranslated(x, y, z); +} + +void gl3_2compat_glScalef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScalef(x, y, z); +} + +void gl3_2compat_glScaled(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScaled(x, y, z); +} + +void gl3_2compat_glRotatef(void *_glfuncs, GLfloat angle, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRotatef(angle, x, y, z); +} + +void gl3_2compat_glRotated(void *_glfuncs, GLdouble angle, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRotated(angle, x, y, z); +} + +void gl3_2compat_glPushMatrix(void *_glfuncs) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushMatrix(); +} + +void gl3_2compat_glPopMatrix(void *_glfuncs) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopMatrix(); +} + +void gl3_2compat_glOrtho(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glOrtho(left, right, bottom, top, zNear, zFar); +} + +void gl3_2compat_glMultMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultMatrixd(m); +} + +void gl3_2compat_glMultMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultMatrixf(m); +} + +void gl3_2compat_glMatrixMode(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMatrixMode(mode); +} + +void gl3_2compat_glLoadMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadMatrixd(m); +} + +void gl3_2compat_glLoadMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadMatrixf(m); +} + +void gl3_2compat_glLoadIdentity(void *_glfuncs) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadIdentity(); +} + +void gl3_2compat_glFrustum(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrustum(left, right, bottom, top, zNear, zFar); +} + +GLboolean gl3_2compat_glIsList(void *_glfuncs, GLuint list) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsList(list); +} + +void gl3_2compat_glGetTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGeniv(coord, pname, params); +} + +void gl3_2compat_glGetTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGenfv(coord, pname, params); +} + +void gl3_2compat_glGetTexGendv(void *_glfuncs, GLenum coord, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGendv(coord, pname, params); +} + +void gl3_2compat_glGetTexEnviv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexEnviv(target, pname, params); +} + +void gl3_2compat_glGetTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexEnvfv(target, pname, params); +} + +void gl3_2compat_glGetPolygonStipple(void *_glfuncs, GLubyte* mask) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPolygonStipple(mask); +} + +void gl3_2compat_glGetPixelMapusv(void *_glfuncs, GLenum glmap, GLushort* values) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapusv(glmap, values); +} + +void gl3_2compat_glGetPixelMapuiv(void *_glfuncs, GLenum glmap, GLuint* values) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapuiv(glmap, values); +} + +void gl3_2compat_glGetPixelMapfv(void *_glfuncs, GLenum glmap, GLfloat* values) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapfv(glmap, values); +} + +void gl3_2compat_glGetMaterialiv(void *_glfuncs, GLenum face, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMaterialiv(face, pname, params); +} + +void gl3_2compat_glGetMaterialfv(void *_glfuncs, GLenum face, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMaterialfv(face, pname, params); +} + +void gl3_2compat_glGetMapiv(void *_glfuncs, GLenum target, GLenum query, GLint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapiv(target, query, v); +} + +void gl3_2compat_glGetMapfv(void *_glfuncs, GLenum target, GLenum query, GLfloat* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapfv(target, query, v); +} + +void gl3_2compat_glGetMapdv(void *_glfuncs, GLenum target, GLenum query, GLdouble* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapdv(target, query, v); +} + +void gl3_2compat_glGetLightiv(void *_glfuncs, GLenum light, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetLightiv(light, pname, params); +} + +void gl3_2compat_glGetLightfv(void *_glfuncs, GLenum light, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetLightfv(light, pname, params); +} + +void gl3_2compat_glGetClipPlane(void *_glfuncs, GLenum plane, GLdouble* equation) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetClipPlane(plane, equation); +} + +void gl3_2compat_glDrawPixels(void *_glfuncs, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawPixels(width, height, format, gltype, pixels); +} + +void gl3_2compat_glCopyPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum gltype) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyPixels(x, y, width, height, gltype); +} + +void gl3_2compat_glPixelMapusv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLushort* values) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapusv(glmap, mapsize, values); +} + +void gl3_2compat_glPixelMapuiv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLuint* values) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapuiv(glmap, mapsize, values); +} + +void gl3_2compat_glPixelMapfv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLfloat* values) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapfv(glmap, mapsize, values); +} + +void gl3_2compat_glPixelTransferi(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelTransferi(pname, param); +} + +void gl3_2compat_glPixelTransferf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelTransferf(pname, param); +} + +void gl3_2compat_glPixelZoom(void *_glfuncs, GLfloat xfactor, GLfloat yfactor) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelZoom(xfactor, yfactor); +} + +void gl3_2compat_glAlphaFunc(void *_glfuncs, GLenum glfunc, GLfloat ref) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAlphaFunc(glfunc, ref); +} + +void gl3_2compat_glEvalPoint2(void *_glfuncs, GLint i, GLint j) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalPoint2(i, j); +} + +void gl3_2compat_glEvalMesh2(void *_glfuncs, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalMesh2(mode, i1, i2, j1, j2); +} + +void gl3_2compat_glEvalPoint1(void *_glfuncs, GLint i) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalPoint1(i); +} + +void gl3_2compat_glEvalMesh1(void *_glfuncs, GLenum mode, GLint i1, GLint i2) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalMesh1(mode, i1, i2); +} + +void gl3_2compat_glEvalCoord2fv(void *_glfuncs, const GLfloat* u) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2fv(u); +} + +void gl3_2compat_glEvalCoord2f(void *_glfuncs, GLfloat u, GLfloat v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2f(u, v); +} + +void gl3_2compat_glEvalCoord2dv(void *_glfuncs, const GLdouble* u) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2dv(u); +} + +void gl3_2compat_glEvalCoord2d(void *_glfuncs, GLdouble u, GLdouble v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2d(u, v); +} + +void gl3_2compat_glEvalCoord1fv(void *_glfuncs, const GLfloat* u) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1fv(u); +} + +void gl3_2compat_glEvalCoord1f(void *_glfuncs, GLfloat u) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1f(u); +} + +void gl3_2compat_glEvalCoord1dv(void *_glfuncs, const GLdouble* u) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1dv(u); +} + +void gl3_2compat_glEvalCoord1d(void *_glfuncs, GLdouble u) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1d(u); +} + +void gl3_2compat_glMapGrid2f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid2f(un, u1, u2, vn, v1, v2); +} + +void gl3_2compat_glMapGrid2d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid2d(un, u1, u2, vn, v1, v2); +} + +void gl3_2compat_glMapGrid1f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid1f(un, u1, u2); +} + +void gl3_2compat_glMapGrid1d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid1d(un, u1, u2); +} + +void gl3_2compat_glMap2f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); +} + +void gl3_2compat_glMap2d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); +} + +void gl3_2compat_glMap1f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap1f(target, u1, u2, stride, order, points); +} + +void gl3_2compat_glMap1d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap1d(target, u1, u2, stride, order, points); +} + +void gl3_2compat_glPushAttrib(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushAttrib(mask); +} + +void gl3_2compat_glPopAttrib(void *_glfuncs) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopAttrib(); +} + +void gl3_2compat_glAccum(void *_glfuncs, GLenum op, GLfloat value) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAccum(op, value); +} + +void gl3_2compat_glIndexMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexMask(mask); +} + +void gl3_2compat_glClearIndex(void *_glfuncs, GLfloat c) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearIndex(c); +} + +void gl3_2compat_glClearAccum(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearAccum(red, green, blue, alpha); +} + +void gl3_2compat_glPushName(void *_glfuncs, GLuint name) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushName(name); +} + +void gl3_2compat_glPopName(void *_glfuncs) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopName(); +} + +void gl3_2compat_glPassThrough(void *_glfuncs, GLfloat token) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPassThrough(token); +} + +void gl3_2compat_glLoadName(void *_glfuncs, GLuint name) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadName(name); +} + +void gl3_2compat_glInitNames(void *_glfuncs) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInitNames(); +} + +GLint gl3_2compat_glRenderMode(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glRenderMode(mode); +} + +void gl3_2compat_glSelectBuffer(void *_glfuncs, GLsizei size, GLuint* buffer) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSelectBuffer(size, buffer); +} + +void gl3_2compat_glFeedbackBuffer(void *_glfuncs, GLsizei size, GLenum gltype, GLfloat* buffer) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFeedbackBuffer(size, gltype, buffer); +} + +void gl3_2compat_glTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGeniv(coord, pname, params); +} + +void gl3_2compat_glTexGeni(void *_glfuncs, GLenum coord, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGeni(coord, pname, param); +} + +void gl3_2compat_glTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGenfv(coord, pname, params); +} + +void gl3_2compat_glTexGenf(void *_glfuncs, GLenum coord, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGenf(coord, pname, param); +} + +void gl3_2compat_glTexGendv(void *_glfuncs, GLenum coord, GLenum pname, const GLdouble* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGendv(coord, pname, params); +} + +void gl3_2compat_glTexGend(void *_glfuncs, GLenum coord, GLenum pname, GLdouble param) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGend(coord, pname, param); +} + +void gl3_2compat_glTexEnviv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnviv(target, pname, params); +} + +void gl3_2compat_glTexEnvi(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvi(target, pname, param); +} + +void gl3_2compat_glTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvfv(target, pname, params); +} + +void gl3_2compat_glTexEnvf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvf(target, pname, param); +} + +void gl3_2compat_glShadeModel(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShadeModel(mode); +} + +void gl3_2compat_glPolygonStipple(void *_glfuncs, const GLubyte* mask) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonStipple(mask); +} + +void gl3_2compat_glMaterialiv(void *_glfuncs, GLenum face, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialiv(face, pname, params); +} + +void gl3_2compat_glMateriali(void *_glfuncs, GLenum face, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMateriali(face, pname, param); +} + +void gl3_2compat_glMaterialfv(void *_glfuncs, GLenum face, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialfv(face, pname, params); +} + +void gl3_2compat_glMaterialf(void *_glfuncs, GLenum face, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialf(face, pname, param); +} + +void gl3_2compat_glLineStipple(void *_glfuncs, GLint factor, GLushort pattern) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineStipple(factor, pattern); +} + +void gl3_2compat_glLightModeliv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModeliv(pname, params); +} + +void gl3_2compat_glLightModeli(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModeli(pname, param); +} + +void gl3_2compat_glLightModelfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModelfv(pname, params); +} + +void gl3_2compat_glLightModelf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModelf(pname, param); +} + +void gl3_2compat_glLightiv(void *_glfuncs, GLenum light, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightiv(light, pname, params); +} + +void gl3_2compat_glLighti(void *_glfuncs, GLenum light, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLighti(light, pname, param); +} + +void gl3_2compat_glLightfv(void *_glfuncs, GLenum light, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightfv(light, pname, params); +} + +void gl3_2compat_glLightf(void *_glfuncs, GLenum light, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightf(light, pname, param); +} + +void gl3_2compat_glFogiv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogiv(pname, params); +} + +void gl3_2compat_glFogi(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogi(pname, param); +} + +void gl3_2compat_glFogfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogfv(pname, params); +} + +void gl3_2compat_glFogf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogf(pname, param); +} + +void gl3_2compat_glColorMaterial(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMaterial(face, mode); +} + +void gl3_2compat_glClipPlane(void *_glfuncs, GLenum plane, const GLdouble* equation) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClipPlane(plane, equation); +} + +void gl3_2compat_glVertex4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4sv(v); +} + +void gl3_2compat_glVertex4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4s(x, y, z, w); +} + +void gl3_2compat_glVertex4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4iv(v); +} + +void gl3_2compat_glVertex4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4i(x, y, z, w); +} + +void gl3_2compat_glVertex4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4fv(v); +} + +void gl3_2compat_glVertex4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4f(x, y, z, w); +} + +void gl3_2compat_glVertex4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4dv(v); +} + +void gl3_2compat_glVertex4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4d(x, y, z, w); +} + +void gl3_2compat_glVertex3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3sv(v); +} + +void gl3_2compat_glVertex3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3s(x, y, z); +} + +void gl3_2compat_glVertex3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3iv(v); +} + +void gl3_2compat_glVertex3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3i(x, y, z); +} + +void gl3_2compat_glVertex3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3fv(v); +} + +void gl3_2compat_glVertex3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3f(x, y, z); +} + +void gl3_2compat_glVertex3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3dv(v); +} + +void gl3_2compat_glVertex3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3d(x, y, z); +} + +void gl3_2compat_glVertex2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2sv(v); +} + +void gl3_2compat_glVertex2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2s(x, y); +} + +void gl3_2compat_glVertex2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2iv(v); +} + +void gl3_2compat_glVertex2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2i(x, y); +} + +void gl3_2compat_glVertex2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2fv(v); +} + +void gl3_2compat_glVertex2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2f(x, y); +} + +void gl3_2compat_glVertex2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2dv(v); +} + +void gl3_2compat_glVertex2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2d(x, y); +} + +void gl3_2compat_glTexCoord4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4sv(v); +} + +void gl3_2compat_glTexCoord4s(void *_glfuncs, GLshort s, GLshort t, GLshort r, GLshort q) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4s(s, t, r, q); +} + +void gl3_2compat_glTexCoord4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4iv(v); +} + +void gl3_2compat_glTexCoord4i(void *_glfuncs, GLint s, GLint t, GLint r, GLint q) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4i(s, t, r, q); +} + +void gl3_2compat_glTexCoord4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4fv(v); +} + +void gl3_2compat_glTexCoord4f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4f(s, t, r, q); +} + +void gl3_2compat_glTexCoord4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4dv(v); +} + +void gl3_2compat_glTexCoord4d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r, GLdouble q) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4d(s, t, r, q); +} + +void gl3_2compat_glTexCoord3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3sv(v); +} + +void gl3_2compat_glTexCoord3s(void *_glfuncs, GLshort s, GLshort t, GLshort r) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3s(s, t, r); +} + +void gl3_2compat_glTexCoord3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3iv(v); +} + +void gl3_2compat_glTexCoord3i(void *_glfuncs, GLint s, GLint t, GLint r) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3i(s, t, r); +} + +void gl3_2compat_glTexCoord3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3fv(v); +} + +void gl3_2compat_glTexCoord3f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3f(s, t, r); +} + +void gl3_2compat_glTexCoord3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3dv(v); +} + +void gl3_2compat_glTexCoord3d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3d(s, t, r); +} + +void gl3_2compat_glTexCoord2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2sv(v); +} + +void gl3_2compat_glTexCoord2s(void *_glfuncs, GLshort s, GLshort t) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2s(s, t); +} + +void gl3_2compat_glTexCoord2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2iv(v); +} + +void gl3_2compat_glTexCoord2i(void *_glfuncs, GLint s, GLint t) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2i(s, t); +} + +void gl3_2compat_glTexCoord2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2fv(v); +} + +void gl3_2compat_glTexCoord2f(void *_glfuncs, GLfloat s, GLfloat t) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2f(s, t); +} + +void gl3_2compat_glTexCoord2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2dv(v); +} + +void gl3_2compat_glTexCoord2d(void *_glfuncs, GLdouble s, GLdouble t) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2d(s, t); +} + +void gl3_2compat_glTexCoord1sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1sv(v); +} + +void gl3_2compat_glTexCoord1s(void *_glfuncs, GLshort s) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1s(s); +} + +void gl3_2compat_glTexCoord1iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1iv(v); +} + +void gl3_2compat_glTexCoord1i(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1i(s); +} + +void gl3_2compat_glTexCoord1fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1fv(v); +} + +void gl3_2compat_glTexCoord1f(void *_glfuncs, GLfloat s) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1f(s); +} + +void gl3_2compat_glTexCoord1dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1dv(v); +} + +void gl3_2compat_glTexCoord1d(void *_glfuncs, GLdouble s) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1d(s); +} + +void gl3_2compat_glRectsv(void *_glfuncs, const GLshort* v1, const GLshort* v2) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectsv(v1, v2); +} + +void gl3_2compat_glRects(void *_glfuncs, GLshort x1, GLshort y1, GLshort x2, GLshort y2) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRects(x1, y1, x2, y2); +} + +void gl3_2compat_glRectiv(void *_glfuncs, const GLint* v1, const GLint* v2) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectiv(v1, v2); +} + +void gl3_2compat_glRecti(void *_glfuncs, GLint x1, GLint y1, GLint x2, GLint y2) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRecti(x1, y1, x2, y2); +} + +void gl3_2compat_glRectfv(void *_glfuncs, const GLfloat* v1, const GLfloat* v2) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectfv(v1, v2); +} + +void gl3_2compat_glRectf(void *_glfuncs, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectf(x1, y1, x2, y2); +} + +void gl3_2compat_glRectdv(void *_glfuncs, const GLdouble* v1, const GLdouble* v2) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectdv(v1, v2); +} + +void gl3_2compat_glRectd(void *_glfuncs, GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectd(x1, y1, x2, y2); +} + +void gl3_2compat_glRasterPos4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4sv(v); +} + +void gl3_2compat_glRasterPos4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4s(x, y, z, w); +} + +void gl3_2compat_glRasterPos4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4iv(v); +} + +void gl3_2compat_glRasterPos4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4i(x, y, z, w); +} + +void gl3_2compat_glRasterPos4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4fv(v); +} + +void gl3_2compat_glRasterPos4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4f(x, y, z, w); +} + +void gl3_2compat_glRasterPos4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4dv(v); +} + +void gl3_2compat_glRasterPos4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4d(x, y, z, w); +} + +void gl3_2compat_glRasterPos3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3sv(v); +} + +void gl3_2compat_glRasterPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3s(x, y, z); +} + +void gl3_2compat_glRasterPos3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3iv(v); +} + +void gl3_2compat_glRasterPos3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3i(x, y, z); +} + +void gl3_2compat_glRasterPos3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3fv(v); +} + +void gl3_2compat_glRasterPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3f(x, y, z); +} + +void gl3_2compat_glRasterPos3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3dv(v); +} + +void gl3_2compat_glRasterPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3d(x, y, z); +} + +void gl3_2compat_glRasterPos2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2sv(v); +} + +void gl3_2compat_glRasterPos2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2s(x, y); +} + +void gl3_2compat_glRasterPos2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2iv(v); +} + +void gl3_2compat_glRasterPos2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2i(x, y); +} + +void gl3_2compat_glRasterPos2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2fv(v); +} + +void gl3_2compat_glRasterPos2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2f(x, y); +} + +void gl3_2compat_glRasterPos2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2dv(v); +} + +void gl3_2compat_glRasterPos2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2d(x, y); +} + +void gl3_2compat_glNormal3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3sv(v); +} + +void gl3_2compat_glNormal3s(void *_glfuncs, GLshort nx, GLshort ny, GLshort nz) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3s(nx, ny, nz); +} + +void gl3_2compat_glNormal3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3iv(v); +} + +void gl3_2compat_glNormal3i(void *_glfuncs, GLint nx, GLint ny, GLint nz) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3i(nx, ny, nz); +} + +void gl3_2compat_glNormal3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3fv(v); +} + +void gl3_2compat_glNormal3f(void *_glfuncs, GLfloat nx, GLfloat ny, GLfloat nz) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3f(nx, ny, nz); +} + +void gl3_2compat_glNormal3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3dv(v); +} + +void gl3_2compat_glNormal3d(void *_glfuncs, GLdouble nx, GLdouble ny, GLdouble nz) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3d(nx, ny, nz); +} + +void gl3_2compat_glNormal3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3bv(v); +} + +void gl3_2compat_glNormal3b(void *_glfuncs, GLbyte nx, GLbyte ny, GLbyte nz) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3b(nx, ny, nz); +} + +void gl3_2compat_glIndexsv(void *_glfuncs, const GLshort* c) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexsv(c); +} + +void gl3_2compat_glIndexs(void *_glfuncs, GLshort c) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexs(c); +} + +void gl3_2compat_glIndexiv(void *_glfuncs, const GLint* c) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexiv(c); +} + +void gl3_2compat_glIndexi(void *_glfuncs, GLint c) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexi(c); +} + +void gl3_2compat_glIndexfv(void *_glfuncs, const GLfloat* c) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexfv(c); +} + +void gl3_2compat_glIndexf(void *_glfuncs, GLfloat c) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexf(c); +} + +void gl3_2compat_glIndexdv(void *_glfuncs, const GLdouble* c) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexdv(c); +} + +void gl3_2compat_glIndexd(void *_glfuncs, GLdouble c) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexd(c); +} + +void gl3_2compat_glEnd(void *_glfuncs) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnd(); +} + +void gl3_2compat_glEdgeFlagv(void *_glfuncs, const GLboolean* flag) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlagv(flag); +} + +void gl3_2compat_glEdgeFlag(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlag(flag); +} + +void gl3_2compat_glColor4usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4usv(v); +} + +void gl3_2compat_glColor4us(void *_glfuncs, GLushort red, GLushort green, GLushort blue, GLushort alpha) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4us(red, green, blue, alpha); +} + +void gl3_2compat_glColor4uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4uiv(v); +} + +void gl3_2compat_glColor4ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue, GLuint alpha) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ui(red, green, blue, alpha); +} + +void gl3_2compat_glColor4ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ubv(v); +} + +void gl3_2compat_glColor4ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ub(red, green, blue, alpha); +} + +void gl3_2compat_glColor4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4sv(v); +} + +void gl3_2compat_glColor4s(void *_glfuncs, GLshort red, GLshort green, GLshort blue, GLshort alpha) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4s(red, green, blue, alpha); +} + +void gl3_2compat_glColor4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4iv(v); +} + +void gl3_2compat_glColor4i(void *_glfuncs, GLint red, GLint green, GLint blue, GLint alpha) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4i(red, green, blue, alpha); +} + +void gl3_2compat_glColor4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4fv(v); +} + +void gl3_2compat_glColor4f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4f(red, green, blue, alpha); +} + +void gl3_2compat_glColor4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4dv(v); +} + +void gl3_2compat_glColor4d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4d(red, green, blue, alpha); +} + +void gl3_2compat_glColor4bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4bv(v); +} + +void gl3_2compat_glColor4b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4b(red, green, blue, alpha); +} + +void gl3_2compat_glColor3usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3usv(v); +} + +void gl3_2compat_glColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3us(red, green, blue); +} + +void gl3_2compat_glColor3uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3uiv(v); +} + +void gl3_2compat_glColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ui(red, green, blue); +} + +void gl3_2compat_glColor3ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ubv(v); +} + +void gl3_2compat_glColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ub(red, green, blue); +} + +void gl3_2compat_glColor3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3sv(v); +} + +void gl3_2compat_glColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3s(red, green, blue); +} + +void gl3_2compat_glColor3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3iv(v); +} + +void gl3_2compat_glColor3i(void *_glfuncs, GLint red, GLint green, GLint blue) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3i(red, green, blue); +} + +void gl3_2compat_glColor3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3fv(v); +} + +void gl3_2compat_glColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3f(red, green, blue); +} + +void gl3_2compat_glColor3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3dv(v); +} + +void gl3_2compat_glColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3d(red, green, blue); +} + +void gl3_2compat_glColor3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3bv(v); +} + +void gl3_2compat_glColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3b(red, green, blue); +} + +void gl3_2compat_glBitmap(void *_glfuncs, GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBitmap(width, height, xorig, yorig, xmove, ymove, bitmap); +} + +void gl3_2compat_glBegin(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBegin(mode); +} + +void gl3_2compat_glListBase(void *_glfuncs, GLuint base) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glListBase(base); +} + +GLuint gl3_2compat_glGenLists(void *_glfuncs, GLsizei range_) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGenLists(range_); +} + +void gl3_2compat_glDeleteLists(void *_glfuncs, GLuint list, GLsizei range_) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteLists(list, range_); +} + +void gl3_2compat_glCallLists(void *_glfuncs, GLsizei n, GLenum gltype, const GLvoid* lists) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCallLists(n, gltype, lists); +} + +void gl3_2compat_glCallList(void *_glfuncs, GLuint list) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCallList(list); +} + +void gl3_2compat_glEndList(void *_glfuncs) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndList(); +} + +void gl3_2compat_glNewList(void *_glfuncs, GLuint list, GLenum mode) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNewList(list, mode); +} + +void gl3_2compat_glPushClientAttrib(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushClientAttrib(mask); +} + +void gl3_2compat_glPopClientAttrib(void *_glfuncs) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopClientAttrib(); +} + +void gl3_2compat_glPrioritizeTextures(void *_glfuncs, GLsizei n, const GLuint* textures, const GLfloat* priorities) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPrioritizeTextures(n, textures, priorities); +} + +GLboolean gl3_2compat_glAreTexturesResident(void *_glfuncs, GLsizei n, const GLuint* textures, GLboolean* residences) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glAreTexturesResident(n, textures, residences); +} + +void gl3_2compat_glVertexPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexPointer(size, gltype, stride, pointer); +} + +void gl3_2compat_glTexCoordPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordPointer(size, gltype, stride, pointer); +} + +void gl3_2compat_glNormalPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormalPointer(gltype, stride, pointer); +} + +void gl3_2compat_glInterleavedArrays(void *_glfuncs, GLenum format, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInterleavedArrays(format, stride, pointer); +} + +void gl3_2compat_glIndexPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexPointer(gltype, stride, pointer); +} + +void gl3_2compat_glEnableClientState(void *_glfuncs, GLenum array) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnableClientState(array); +} + +void gl3_2compat_glEdgeFlagPointer(void *_glfuncs, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlagPointer(stride, pointer); +} + +void gl3_2compat_glDisableClientState(void *_glfuncs, GLenum array) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisableClientState(array); +} + +void gl3_2compat_glColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorPointer(size, gltype, stride, pointer); +} + +void gl3_2compat_glArrayElement(void *_glfuncs, GLint i) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glArrayElement(i); +} + +void gl3_2compat_glResetMinmax(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glResetMinmax(target); +} + +void gl3_2compat_glResetHistogram(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glResetHistogram(target); +} + +void gl3_2compat_glMinmax(void *_glfuncs, GLenum target, GLenum internalFormat, GLboolean sink) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMinmax(target, internalFormat, sink); +} + +void gl3_2compat_glHistogram(void *_glfuncs, GLenum target, GLsizei width, GLenum internalFormat, GLboolean sink) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glHistogram(target, width, internalFormat, sink); +} + +void gl3_2compat_glGetMinmaxParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmaxParameteriv(target, pname, params); +} + +void gl3_2compat_glGetMinmaxParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmaxParameterfv(target, pname, params); +} + +void gl3_2compat_glGetMinmax(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmax(target, reset, format, gltype, values); +} + +void gl3_2compat_glGetHistogramParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogramParameteriv(target, pname, params); +} + +void gl3_2compat_glGetHistogramParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogramParameterfv(target, pname, params); +} + +void gl3_2compat_glGetHistogram(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogram(target, reset, format, gltype, values); +} + +void gl3_2compat_glSeparableFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* row, const GLvoid* column) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSeparableFilter2D(target, internalFormat, width, height, format, gltype, row, column); +} + +void gl3_2compat_glGetSeparableFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* row, GLvoid* column, GLvoid* span) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSeparableFilter(target, format, gltype, row, column, span); +} + +void gl3_2compat_glGetConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionParameteriv(target, pname, params); +} + +void gl3_2compat_glGetConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionParameterfv(target, pname, params); +} + +void gl3_2compat_glGetConvolutionFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* image) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionFilter(target, format, gltype, image); +} + +void gl3_2compat_glCopyConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyConvolutionFilter2D(target, internalFormat, x, y, width, height); +} + +void gl3_2compat_glCopyConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyConvolutionFilter1D(target, internalFormat, x, y, width); +} + +void gl3_2compat_glConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameteriv(target, pname, params); +} + +void gl3_2compat_glConvolutionParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameteri(target, pname, params); +} + +void gl3_2compat_glConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameterfv(target, pname, params); +} + +void gl3_2compat_glConvolutionParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameterf(target, pname, params); +} + +void gl3_2compat_glConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* image) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionFilter2D(target, internalFormat, width, height, format, gltype, image); +} + +void gl3_2compat_glConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* image) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionFilter1D(target, internalFormat, width, format, gltype, image); +} + +void gl3_2compat_glCopyColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyColorSubTable(target, start, x, y, width); +} + +void gl3_2compat_glColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum gltype, const GLvoid* data) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorSubTable(target, start, count, format, gltype, data); +} + +void gl3_2compat_glGetColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTableParameteriv(target, pname, params); +} + +void gl3_2compat_glGetColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTableParameterfv(target, pname, params); +} + +void gl3_2compat_glGetColorTable(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* table) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTable(target, format, gltype, table); +} + +void gl3_2compat_glCopyColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyColorTable(target, internalFormat, x, y, width); +} + +void gl3_2compat_glColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTableParameteriv(target, pname, params); +} + +void gl3_2compat_glColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTableParameterfv(target, pname, params); +} + +void gl3_2compat_glColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* table) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTable(target, internalFormat, width, format, gltype, table); +} + +void gl3_2compat_glMultTransposeMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultTransposeMatrixd(m); +} + +void gl3_2compat_glMultTransposeMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultTransposeMatrixf(m); +} + +void gl3_2compat_glLoadTransposeMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadTransposeMatrixd(m); +} + +void gl3_2compat_glLoadTransposeMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadTransposeMatrixf(m); +} + +void gl3_2compat_glMultiTexCoord4sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4sv(target, v); +} + +void gl3_2compat_glMultiTexCoord4s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r, GLshort q) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4s(target, s, t, r, q); +} + +void gl3_2compat_glMultiTexCoord4iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4iv(target, v); +} + +void gl3_2compat_glMultiTexCoord4i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r, GLint q) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4i(target, s, t, r, q); +} + +void gl3_2compat_glMultiTexCoord4fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4fv(target, v); +} + +void gl3_2compat_glMultiTexCoord4f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4f(target, s, t, r, q); +} + +void gl3_2compat_glMultiTexCoord4dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4dv(target, v); +} + +void gl3_2compat_glMultiTexCoord4d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4d(target, s, t, r, q); +} + +void gl3_2compat_glMultiTexCoord3sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3sv(target, v); +} + +void gl3_2compat_glMultiTexCoord3s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3s(target, s, t, r); +} + +void gl3_2compat_glMultiTexCoord3iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3iv(target, v); +} + +void gl3_2compat_glMultiTexCoord3i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3i(target, s, t, r); +} + +void gl3_2compat_glMultiTexCoord3fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3fv(target, v); +} + +void gl3_2compat_glMultiTexCoord3f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3f(target, s, t, r); +} + +void gl3_2compat_glMultiTexCoord3dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3dv(target, v); +} + +void gl3_2compat_glMultiTexCoord3d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3d(target, s, t, r); +} + +void gl3_2compat_glMultiTexCoord2sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2sv(target, v); +} + +void gl3_2compat_glMultiTexCoord2s(void *_glfuncs, GLenum target, GLshort s, GLshort t) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2s(target, s, t); +} + +void gl3_2compat_glMultiTexCoord2iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2iv(target, v); +} + +void gl3_2compat_glMultiTexCoord2i(void *_glfuncs, GLenum target, GLint s, GLint t) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2i(target, s, t); +} + +void gl3_2compat_glMultiTexCoord2fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2fv(target, v); +} + +void gl3_2compat_glMultiTexCoord2f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2f(target, s, t); +} + +void gl3_2compat_glMultiTexCoord2dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2dv(target, v); +} + +void gl3_2compat_glMultiTexCoord2d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2d(target, s, t); +} + +void gl3_2compat_glMultiTexCoord1sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1sv(target, v); +} + +void gl3_2compat_glMultiTexCoord1s(void *_glfuncs, GLenum target, GLshort s) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1s(target, s); +} + +void gl3_2compat_glMultiTexCoord1iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1iv(target, v); +} + +void gl3_2compat_glMultiTexCoord1i(void *_glfuncs, GLenum target, GLint s) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1i(target, s); +} + +void gl3_2compat_glMultiTexCoord1fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1fv(target, v); +} + +void gl3_2compat_glMultiTexCoord1f(void *_glfuncs, GLenum target, GLfloat s) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1f(target, s); +} + +void gl3_2compat_glMultiTexCoord1dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1dv(target, v); +} + +void gl3_2compat_glMultiTexCoord1d(void *_glfuncs, GLenum target, GLdouble s) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1d(target, s); +} + +void gl3_2compat_glClientActiveTexture(void *_glfuncs, GLenum texture) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClientActiveTexture(texture); +} + +void gl3_2compat_glWindowPos3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3sv(v); +} + +void gl3_2compat_glWindowPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3s(x, y, z); +} + +void gl3_2compat_glWindowPos3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3iv(v); +} + +void gl3_2compat_glWindowPos3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3i(x, y, z); +} + +void gl3_2compat_glWindowPos3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3fv(v); +} + +void gl3_2compat_glWindowPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3f(x, y, z); +} + +void gl3_2compat_glWindowPos3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3dv(v); +} + +void gl3_2compat_glWindowPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3d(x, y, z); +} + +void gl3_2compat_glWindowPos2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2sv(v); +} + +void gl3_2compat_glWindowPos2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2s(x, y); +} + +void gl3_2compat_glWindowPos2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2iv(v); +} + +void gl3_2compat_glWindowPos2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2i(x, y); +} + +void gl3_2compat_glWindowPos2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2fv(v); +} + +void gl3_2compat_glWindowPos2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2f(x, y); +} + +void gl3_2compat_glWindowPos2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2dv(v); +} + +void gl3_2compat_glWindowPos2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2d(x, y); +} + +void gl3_2compat_glSecondaryColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColorPointer(size, gltype, stride, pointer); +} + +void gl3_2compat_glSecondaryColor3usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3usv(v); +} + +void gl3_2compat_glSecondaryColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3us(red, green, blue); +} + +void gl3_2compat_glSecondaryColor3uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3uiv(v); +} + +void gl3_2compat_glSecondaryColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3ui(red, green, blue); +} + +void gl3_2compat_glSecondaryColor3ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3ubv(v); +} + +void gl3_2compat_glSecondaryColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3ub(red, green, blue); +} + +void gl3_2compat_glSecondaryColor3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3sv(v); +} + +void gl3_2compat_glSecondaryColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3s(red, green, blue); +} + +void gl3_2compat_glSecondaryColor3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3iv(v); +} + +void gl3_2compat_glSecondaryColor3i(void *_glfuncs, GLint red, GLint green, GLint blue) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3i(red, green, blue); +} + +void gl3_2compat_glSecondaryColor3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3fv(v); +} + +void gl3_2compat_glSecondaryColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3f(red, green, blue); +} + +void gl3_2compat_glSecondaryColor3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3dv(v); +} + +void gl3_2compat_glSecondaryColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3d(red, green, blue); +} + +void gl3_2compat_glSecondaryColor3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3bv(v); +} + +void gl3_2compat_glSecondaryColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3b(red, green, blue); +} + +void gl3_2compat_glFogCoordPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordPointer(gltype, stride, pointer); +} + +void gl3_2compat_glFogCoorddv(void *_glfuncs, const GLdouble* coord) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoorddv(coord); +} + +void gl3_2compat_glFogCoordd(void *_glfuncs, GLdouble coord) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordd(coord); +} + +void gl3_2compat_glFogCoordfv(void *_glfuncs, const GLfloat* coord) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordfv(coord); +} + +void gl3_2compat_glFogCoordf(void *_glfuncs, GLfloat coord) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordf(coord); +} + +void gl3_2compat_glVertexAttrib4usv(void *_glfuncs, GLuint index, const GLushort* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4usv(index, v); +} + +void gl3_2compat_glVertexAttrib4uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4uiv(index, v); +} + +void gl3_2compat_glVertexAttrib4ubv(void *_glfuncs, GLuint index, const GLubyte* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4ubv(index, v); +} + +void gl3_2compat_glVertexAttrib4sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4sv(index, v); +} + +void gl3_2compat_glVertexAttrib4s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4s(index, x, y, z, w); +} + +void gl3_2compat_glVertexAttrib4iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4iv(index, v); +} + +void gl3_2compat_glVertexAttrib4fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4fv(index, v); +} + +void gl3_2compat_glVertexAttrib4f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4f(index, x, y, z, w); +} + +void gl3_2compat_glVertexAttrib4dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4dv(index, v); +} + +void gl3_2compat_glVertexAttrib4d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4d(index, x, y, z, w); +} + +void gl3_2compat_glVertexAttrib4bv(void *_glfuncs, GLuint index, const GLbyte* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4bv(index, v); +} + +void gl3_2compat_glVertexAttrib4Nusv(void *_glfuncs, GLuint index, const GLushort* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nusv(index, v); +} + +void gl3_2compat_glVertexAttrib4Nuiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nuiv(index, v); +} + +void gl3_2compat_glVertexAttrib4Nubv(void *_glfuncs, GLuint index, const GLubyte* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nubv(index, v); +} + +void gl3_2compat_glVertexAttrib4Nub(void *_glfuncs, GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nub(index, x, y, z, w); +} + +void gl3_2compat_glVertexAttrib4Nsv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nsv(index, v); +} + +void gl3_2compat_glVertexAttrib4Niv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Niv(index, v); +} + +void gl3_2compat_glVertexAttrib4Nbv(void *_glfuncs, GLuint index, const GLbyte* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nbv(index, v); +} + +void gl3_2compat_glVertexAttrib3sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3sv(index, v); +} + +void gl3_2compat_glVertexAttrib3s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3s(index, x, y, z); +} + +void gl3_2compat_glVertexAttrib3fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3fv(index, v); +} + +void gl3_2compat_glVertexAttrib3f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3f(index, x, y, z); +} + +void gl3_2compat_glVertexAttrib3dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3dv(index, v); +} + +void gl3_2compat_glVertexAttrib3d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3d(index, x, y, z); +} + +void gl3_2compat_glVertexAttrib2sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2sv(index, v); +} + +void gl3_2compat_glVertexAttrib2s(void *_glfuncs, GLuint index, GLshort x, GLshort y) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2s(index, x, y); +} + +void gl3_2compat_glVertexAttrib2fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2fv(index, v); +} + +void gl3_2compat_glVertexAttrib2f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2f(index, x, y); +} + +void gl3_2compat_glVertexAttrib2dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2dv(index, v); +} + +void gl3_2compat_glVertexAttrib2d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2d(index, x, y); +} + +void gl3_2compat_glVertexAttrib1sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1sv(index, v); +} + +void gl3_2compat_glVertexAttrib1s(void *_glfuncs, GLuint index, GLshort x) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1s(index, x); +} + +void gl3_2compat_glVertexAttrib1fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1fv(index, v); +} + +void gl3_2compat_glVertexAttrib1f(void *_glfuncs, GLuint index, GLfloat x) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1f(index, x); +} + +void gl3_2compat_glVertexAttrib1dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1dv(index, v); +} + +void gl3_2compat_glVertexAttrib1d(void *_glfuncs, GLuint index, GLdouble x) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1d(index, x); +} + +void gl3_2compat_glVertexAttribI4usv(void *_glfuncs, GLuint index, const GLushort* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4usv(index, v); +} + +void gl3_2compat_glVertexAttribI4ubv(void *_glfuncs, GLuint index, const GLubyte* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4ubv(index, v); +} + +void gl3_2compat_glVertexAttribI4sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4sv(index, v); +} + +void gl3_2compat_glVertexAttribI4bv(void *_glfuncs, GLuint index, const GLbyte* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4bv(index, v); +} + +void gl3_2compat_glVertexAttribI4uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4uiv(index, v); +} + +void gl3_2compat_glVertexAttribI3uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI3uiv(index, v); +} + +void gl3_2compat_glVertexAttribI2uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI2uiv(index, v); +} + +void gl3_2compat_glVertexAttribI1uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI1uiv(index, v); +} + +void gl3_2compat_glVertexAttribI4iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4iv(index, v); +} + +void gl3_2compat_glVertexAttribI3iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI3iv(index, v); +} + +void gl3_2compat_glVertexAttribI2iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI2iv(index, v); +} + +void gl3_2compat_glVertexAttribI1iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI1iv(index, v); +} + +void gl3_2compat_glVertexAttribI4ui(void *_glfuncs, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4ui(index, x, y, z, w); +} + +void gl3_2compat_glVertexAttribI3ui(void *_glfuncs, GLuint index, GLuint x, GLuint y, GLuint z) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI3ui(index, x, y, z); +} + +void gl3_2compat_glVertexAttribI2ui(void *_glfuncs, GLuint index, GLuint x, GLuint y) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI2ui(index, x, y); +} + +void gl3_2compat_glVertexAttribI1ui(void *_glfuncs, GLuint index, GLuint x) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI1ui(index, x); +} + +void gl3_2compat_glVertexAttribI4i(void *_glfuncs, GLuint index, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4i(index, x, y, z, w); +} + +void gl3_2compat_glVertexAttribI3i(void *_glfuncs, GLuint index, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI3i(index, x, y, z); +} + +void gl3_2compat_glVertexAttribI2i(void *_glfuncs, GLuint index, GLint x, GLint y) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI2i(index, x, y); +} + +void gl3_2compat_glVertexAttribI1i(void *_glfuncs, GLuint index, GLint x) +{ + QOpenGLFunctions_3_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI1i(index, x); +} + diff --git a/gl/3.2compat/funcs.h b/gl/3.2compat/funcs.h new file mode 100644 index 00000000..17fa70e2 --- /dev/null +++ b/gl/3.2compat/funcs.h @@ -0,0 +1,729 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#ifndef __cplusplus +#include +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef char GLchar; +typedef signed char GLbyte; /* 1-byte signed */ +typedef short GLshort; /* 2-byte signed */ +typedef int GLint; /* 4-byte signed */ +typedef unsigned char GLubyte; /* 1-byte unsigned */ +typedef unsigned short GLushort; /* 2-byte unsigned */ +typedef unsigned int GLuint; /* 4-byte unsigned */ +typedef int GLsizei; /* 4-byte signed */ +typedef float GLfloat; /* single precision float */ +typedef float GLclampf; /* single precision float in [0,1] */ +typedef double GLdouble; /* double precision float */ +typedef double GLclampd; /* double precision float in [0,1] */ +typedef int64_t GLint64; +typedef uint64_t GLuint64; +typedef ptrdiff_t GLintptr; +typedef ptrdiff_t GLsizeiptr; +typedef ptrdiff_t GLintptrARB; +typedef ptrdiff_t GLsizeiptrARB; +typedef struct __GLsync *GLsync; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +void *gl3_2compat_funcs(); + +void gl3_2compat_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl3_2compat_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal); +GLboolean gl3_2compat_glIsEnabled(void *_glfuncs, GLenum cap); +void gl3_2compat_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params); +void gl3_2compat_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params); +void gl3_2compat_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_2compat_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl3_2compat_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels); +void gl3_2compat_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params); +void gl3_2compat_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params); +GLenum gl3_2compat_glGetError(void *_glfuncs); +void gl3_2compat_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params); +void gl3_2compat_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params); +void gl3_2compat_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels); +void gl3_2compat_glReadBuffer(void *_glfuncs, GLenum mode); +void gl3_2compat_glPixelStorei(void *_glfuncs, GLenum pname, GLint param); +void gl3_2compat_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param); +void gl3_2compat_glDepthFunc(void *_glfuncs, GLenum glfunc); +void gl3_2compat_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass); +void gl3_2compat_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask); +void gl3_2compat_glLogicOp(void *_glfuncs, GLenum opcode); +void gl3_2compat_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor); +void gl3_2compat_glFlush(void *_glfuncs); +void gl3_2compat_glFinish(void *_glfuncs); +void gl3_2compat_glEnable(void *_glfuncs, GLenum cap); +void gl3_2compat_glDisable(void *_glfuncs, GLenum cap); +void gl3_2compat_glDepthMask(void *_glfuncs, GLboolean flag); +void gl3_2compat_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +void gl3_2compat_glStencilMask(void *_glfuncs, GLuint mask); +void gl3_2compat_glClearDepth(void *_glfuncs, GLdouble depth); +void gl3_2compat_glClearStencil(void *_glfuncs, GLint s); +void gl3_2compat_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl3_2compat_glClear(void *_glfuncs, GLbitfield mask); +void gl3_2compat_glDrawBuffer(void *_glfuncs, GLenum mode); +void gl3_2compat_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_2compat_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_2compat_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl3_2compat_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl3_2compat_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl3_2compat_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl3_2compat_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl3_2compat_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode); +void gl3_2compat_glPointSize(void *_glfuncs, GLfloat size); +void gl3_2compat_glLineWidth(void *_glfuncs, GLfloat width); +void gl3_2compat_glHint(void *_glfuncs, GLenum target, GLenum mode); +void gl3_2compat_glFrontFace(void *_glfuncs, GLenum mode); +void gl3_2compat_glCullFace(void *_glfuncs, GLenum mode); +void gl3_2compat_glIndexubv(void *_glfuncs, const GLubyte* c); +void gl3_2compat_glIndexub(void *_glfuncs, GLubyte c); +GLboolean gl3_2compat_glIsTexture(void *_glfuncs, GLuint texture); +void gl3_2compat_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures); +void gl3_2compat_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures); +void gl3_2compat_glBindTexture(void *_glfuncs, GLenum target, GLuint texture); +void gl3_2compat_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_2compat_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_2compat_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl3_2compat_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +void gl3_2compat_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +void gl3_2compat_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border); +void gl3_2compat_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units); +void gl3_2compat_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl3_2compat_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count); +void gl3_2compat_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl3_2compat_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_2compat_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_2compat_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl3_2compat_glBlendEquation(void *_glfuncs, GLenum mode); +void gl3_2compat_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl3_2compat_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img); +void gl3_2compat_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl3_2compat_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl3_2compat_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl3_2compat_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data); +void gl3_2compat_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data); +void gl3_2compat_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data); +void gl3_2compat_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert); +void gl3_2compat_glActiveTexture(void *_glfuncs, GLenum texture); +void gl3_2compat_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params); +void gl3_2compat_glPointParameteri(void *_glfuncs, GLenum pname, GLint param); +void gl3_2compat_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl3_2compat_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param); +void gl3_2compat_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount); +void gl3_2compat_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +void gl3_2compat_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +GLboolean gl3_2compat_glUnmapBuffer(void *_glfuncs, GLenum target); +void gl3_2compat_glGetBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data); +void gl3_2compat_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data); +void gl3_2compat_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage); +GLboolean gl3_2compat_glIsBuffer(void *_glfuncs, GLuint buffer); +void gl3_2compat_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers); +void gl3_2compat_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers); +void gl3_2compat_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer); +void gl3_2compat_glGetQueryObjectuiv(void *_glfuncs, GLuint id, GLenum pname, GLuint* params); +void gl3_2compat_glGetQueryObjectiv(void *_glfuncs, GLuint id, GLenum pname, GLint* params); +void gl3_2compat_glGetQueryiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_2compat_glEndQuery(void *_glfuncs, GLenum target); +void gl3_2compat_glBeginQuery(void *_glfuncs, GLenum target, GLuint id); +GLboolean gl3_2compat_glIsQuery(void *_glfuncs, GLuint id); +void gl3_2compat_glDeleteQueries(void *_glfuncs, GLsizei n, const GLuint* ids); +void gl3_2compat_glGenQueries(void *_glfuncs, GLsizei n, GLuint* ids); +void gl3_2compat_glVertexAttribPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLboolean normalized, GLsizei stride, const GLvoid* offset); +void gl3_2compat_glValidateProgram(void *_glfuncs, GLuint program); +void gl3_2compat_glUniformMatrix4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_2compat_glUniformMatrix3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_2compat_glUniformMatrix2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_2compat_glUniform4iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl3_2compat_glUniform3iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl3_2compat_glUniform2iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl3_2compat_glUniform1iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl3_2compat_glUniform4fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl3_2compat_glUniform3fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl3_2compat_glUniform2fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl3_2compat_glUniform1fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl3_2compat_glUniform4i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +void gl3_2compat_glUniform3i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2); +void gl3_2compat_glUniform2i(void *_glfuncs, GLint location, GLint v0, GLint v1); +void gl3_2compat_glUniform1i(void *_glfuncs, GLint location, GLint v0); +void gl3_2compat_glUniform4f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +void gl3_2compat_glUniform3f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +void gl3_2compat_glUniform2f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1); +void gl3_2compat_glUniform1f(void *_glfuncs, GLint location, GLfloat v0); +void gl3_2compat_glUseProgram(void *_glfuncs, GLuint program); +void gl3_2compat_glShaderSource(void *_glfuncs, GLuint shader, GLsizei count, const GLchar** source, const GLint* length); +void gl3_2compat_glLinkProgram(void *_glfuncs, GLuint program); +GLboolean gl3_2compat_glIsShader(void *_glfuncs, GLuint shader); +GLboolean gl3_2compat_glIsProgram(void *_glfuncs, GLuint program); +void gl3_2compat_glGetVertexAttribiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params); +void gl3_2compat_glGetVertexAttribfv(void *_glfuncs, GLuint index, GLenum pname, GLfloat* params); +void gl3_2compat_glGetVertexAttribdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params); +void gl3_2compat_glGetUniformiv(void *_glfuncs, GLuint program, GLint location, GLint* params); +void gl3_2compat_glGetUniformfv(void *_glfuncs, GLuint program, GLint location, GLfloat* params); +GLint gl3_2compat_glGetUniformLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl3_2compat_glGetShaderSource(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source); +void gl3_2compat_glGetShaderInfoLog(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl3_2compat_glGetShaderiv(void *_glfuncs, GLuint shader, GLenum pname, GLint* params); +void gl3_2compat_glGetProgramInfoLog(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl3_2compat_glGetProgramiv(void *_glfuncs, GLuint program, GLenum pname, GLint* params); +GLint gl3_2compat_glGetAttribLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl3_2compat_glGetAttachedShaders(void *_glfuncs, GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj); +void gl3_2compat_glGetActiveUniform(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name); +void gl3_2compat_glGetActiveAttrib(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name); +void gl3_2compat_glEnableVertexAttribArray(void *_glfuncs, GLuint index); +void gl3_2compat_glDisableVertexAttribArray(void *_glfuncs, GLuint index); +void gl3_2compat_glDetachShader(void *_glfuncs, GLuint program, GLuint shader); +void gl3_2compat_glDeleteShader(void *_glfuncs, GLuint shader); +void gl3_2compat_glDeleteProgram(void *_glfuncs, GLuint program); +GLuint gl3_2compat_glCreateShader(void *_glfuncs, GLenum gltype); +GLuint gl3_2compat_glCreateProgram(void *_glfuncs); +void gl3_2compat_glCompileShader(void *_glfuncs, GLuint shader); +void gl3_2compat_glBindAttribLocation(void *_glfuncs, GLuint program, GLuint index, const GLchar* name); +void gl3_2compat_glAttachShader(void *_glfuncs, GLuint program, GLuint shader); +void gl3_2compat_glStencilMaskSeparate(void *_glfuncs, GLenum face, GLuint mask); +void gl3_2compat_glStencilFuncSeparate(void *_glfuncs, GLenum face, GLenum glfunc, GLint ref, GLuint mask); +void gl3_2compat_glStencilOpSeparate(void *_glfuncs, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +void gl3_2compat_glDrawBuffers(void *_glfuncs, GLsizei n, const GLenum* bufs); +void gl3_2compat_glBlendEquationSeparate(void *_glfuncs, GLenum modeRGB, GLenum modeAlpha); +void gl3_2compat_glUniformMatrix4x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_2compat_glUniformMatrix3x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_2compat_glUniformMatrix4x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_2compat_glUniformMatrix2x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_2compat_glUniformMatrix3x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_2compat_glUniformMatrix2x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +GLboolean gl3_2compat_glIsVertexArray(void *_glfuncs, GLuint array); +void gl3_2compat_glGenVertexArrays(void *_glfuncs, GLsizei n, GLuint* arrays); +void gl3_2compat_glDeleteVertexArrays(void *_glfuncs, GLsizei n, const GLuint* arrays); +void gl3_2compat_glBindVertexArray(void *_glfuncs, GLuint array); +void gl3_2compat_glFlushMappedBufferRange(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr length); +void gl3_2compat_glFramebufferTextureLayer(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +void gl3_2compat_glRenderbufferStorageMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height); +void gl3_2compat_glBlitFramebuffer(void *_glfuncs, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +void gl3_2compat_glGenerateMipmap(void *_glfuncs, GLenum target); +void gl3_2compat_glGetFramebufferAttachmentParameteriv(void *_glfuncs, GLenum target, GLenum attachment, GLenum pname, GLint* params); +void gl3_2compat_glFramebufferRenderbuffer(void *_glfuncs, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +void gl3_2compat_glFramebufferTexture3D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +void gl3_2compat_glFramebufferTexture2D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +void gl3_2compat_glFramebufferTexture1D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLenum gl3_2compat_glCheckFramebufferStatus(void *_glfuncs, GLenum target); +void gl3_2compat_glGenFramebuffers(void *_glfuncs, GLsizei n, GLuint* framebuffers); +void gl3_2compat_glDeleteFramebuffers(void *_glfuncs, GLsizei n, const GLuint* framebuffers); +void gl3_2compat_glBindFramebuffer(void *_glfuncs, GLenum target, GLuint framebuffer); +GLboolean gl3_2compat_glIsFramebuffer(void *_glfuncs, GLuint framebuffer); +void gl3_2compat_glGetRenderbufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_2compat_glRenderbufferStorage(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height); +void gl3_2compat_glGenRenderbuffers(void *_glfuncs, GLsizei n, GLuint* renderbuffers); +void gl3_2compat_glDeleteRenderbuffers(void *_glfuncs, GLsizei n, const GLuint* renderbuffers); +void gl3_2compat_glBindRenderbuffer(void *_glfuncs, GLenum target, GLuint renderbuffer); +GLboolean gl3_2compat_glIsRenderbuffer(void *_glfuncs, GLuint renderbuffer); +void gl3_2compat_glClearBufferfi(void *_glfuncs, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); +void gl3_2compat_glClearBufferfv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLfloat* value); +void gl3_2compat_glClearBufferuiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLuint* value); +void gl3_2compat_glClearBufferiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLint* value); +void gl3_2compat_glGetTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, GLuint* params); +void gl3_2compat_glGetTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_2compat_glTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, const GLuint* params); +void gl3_2compat_glTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl3_2compat_glUniform4uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl3_2compat_glUniform3uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl3_2compat_glUniform2uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl3_2compat_glUniform1uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl3_2compat_glUniform4ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +void gl3_2compat_glUniform3ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2); +void gl3_2compat_glUniform2ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1); +void gl3_2compat_glUniform1ui(void *_glfuncs, GLint location, GLuint v0); +GLint gl3_2compat_glGetFragDataLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl3_2compat_glBindFragDataLocation(void *_glfuncs, GLuint program, GLuint color, const GLchar* name); +void gl3_2compat_glGetUniformuiv(void *_glfuncs, GLuint program, GLint location, GLuint* params); +void gl3_2compat_glGetVertexAttribIuiv(void *_glfuncs, GLuint index, GLenum pname, GLuint* params); +void gl3_2compat_glGetVertexAttribIiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params); +void gl3_2compat_glVertexAttribIPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl3_2compat_glEndConditionalRender(void *_glfuncs); +void gl3_2compat_glBeginConditionalRender(void *_glfuncs, GLuint id, GLenum mode); +void gl3_2compat_glClampColor(void *_glfuncs, GLenum target, GLenum clamp); +void gl3_2compat_glGetTransformFeedbackVarying(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* gltype, GLchar* name); +void gl3_2compat_glBindBufferBase(void *_glfuncs, GLenum target, GLuint index, GLuint buffer); +void gl3_2compat_glBindBufferRange(void *_glfuncs, GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +void gl3_2compat_glEndTransformFeedback(void *_glfuncs); +void gl3_2compat_glBeginTransformFeedback(void *_glfuncs, GLenum primitiveMode); +GLboolean gl3_2compat_glIsEnabledi(void *_glfuncs, GLenum target, GLuint index); +void gl3_2compat_glDisablei(void *_glfuncs, GLenum target, GLuint index); +void gl3_2compat_glEnablei(void *_glfuncs, GLenum target, GLuint index); +void gl3_2compat_glGetIntegeri_v(void *_glfuncs, GLenum target, GLuint index, GLint* data); +void gl3_2compat_glGetBooleani_v(void *_glfuncs, GLenum target, GLuint index, GLboolean* data); +void gl3_2compat_glColorMaski(void *_glfuncs, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +void gl3_2compat_glCopyBufferSubData(void *_glfuncs, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +void gl3_2compat_glUniformBlockBinding(void *_glfuncs, GLuint program, GLuint v0, GLuint v1); +void gl3_2compat_glGetActiveUniformBlockName(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName); +void gl3_2compat_glGetActiveUniformBlockiv(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params); +GLuint gl3_2compat_glGetUniformBlockIndex(void *_glfuncs, GLuint program, const GLchar* uniformBlockName); +void gl3_2compat_glGetActiveUniformName(void *_glfuncs, GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName); +void gl3_2compat_glGetActiveUniformsiv(void *_glfuncs, GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params); +void gl3_2compat_glPrimitiveRestartIndex(void *_glfuncs, GLuint index); +void gl3_2compat_glTexBuffer(void *_glfuncs, GLenum target, GLenum internalFormat, GLuint buffer); +void gl3_2compat_glDrawElementsInstanced(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount); +void gl3_2compat_glDrawArraysInstanced(void *_glfuncs, GLenum mode, GLint first, GLsizei count, GLsizei instancecount); +void gl3_2compat_glSampleMaski(void *_glfuncs, GLuint index, GLbitfield mask); +void gl3_2compat_glGetMultisamplefv(void *_glfuncs, GLenum pname, GLuint index, GLfloat* val); +void gl3_2compat_glTexImage3DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); +void gl3_2compat_glTexImage2DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +void gl3_2compat_glGetSynciv(void *_glfuncs, GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values); +void gl3_2compat_glGetInteger64v(void *_glfuncs, GLenum pname, GLint64* params); +void gl3_2compat_glWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout); +GLenum gl3_2compat_glClientWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout); +void gl3_2compat_glDeleteSync(void *_glfuncs, GLsync sync); +GLboolean gl3_2compat_glIsSync(void *_glfuncs, GLsync sync); +GLsync gl3_2compat_glFenceSync(void *_glfuncs, GLenum condition, GLbitfield flags); +void gl3_2compat_glProvokingVertex(void *_glfuncs, GLenum mode); +void gl3_2compat_glDrawElementsInstancedBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLint basevertex); +void gl3_2compat_glDrawRangeElementsBaseVertex(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex); +void gl3_2compat_glDrawElementsBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex); +void gl3_2compat_glFramebufferTexture(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level); +void gl3_2compat_glGetBufferParameteri64v(void *_glfuncs, GLenum target, GLenum pname, GLint64* params); +void gl3_2compat_glGetInteger64i_v(void *_glfuncs, GLenum target, GLuint index, GLint64* data); +void gl3_2compat_glTranslatef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl3_2compat_glTranslated(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl3_2compat_glScalef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl3_2compat_glScaled(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl3_2compat_glRotatef(void *_glfuncs, GLfloat angle, GLfloat x, GLfloat y, GLfloat z); +void gl3_2compat_glRotated(void *_glfuncs, GLdouble angle, GLdouble x, GLdouble y, GLdouble z); +void gl3_2compat_glPushMatrix(void *_glfuncs); +void gl3_2compat_glPopMatrix(void *_glfuncs); +void gl3_2compat_glOrtho(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +void gl3_2compat_glMultMatrixd(void *_glfuncs, const GLdouble* m); +void gl3_2compat_glMultMatrixf(void *_glfuncs, const GLfloat* m); +void gl3_2compat_glMatrixMode(void *_glfuncs, GLenum mode); +void gl3_2compat_glLoadMatrixd(void *_glfuncs, const GLdouble* m); +void gl3_2compat_glLoadMatrixf(void *_glfuncs, const GLfloat* m); +void gl3_2compat_glLoadIdentity(void *_glfuncs); +void gl3_2compat_glFrustum(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +GLboolean gl3_2compat_glIsList(void *_glfuncs, GLuint list); +void gl3_2compat_glGetTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, GLint* params); +void gl3_2compat_glGetTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, GLfloat* params); +void gl3_2compat_glGetTexGendv(void *_glfuncs, GLenum coord, GLenum pname, GLdouble* params); +void gl3_2compat_glGetTexEnviv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_2compat_glGetTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl3_2compat_glGetPolygonStipple(void *_glfuncs, GLubyte* mask); +void gl3_2compat_glGetPixelMapusv(void *_glfuncs, GLenum glmap, GLushort* values); +void gl3_2compat_glGetPixelMapuiv(void *_glfuncs, GLenum glmap, GLuint* values); +void gl3_2compat_glGetPixelMapfv(void *_glfuncs, GLenum glmap, GLfloat* values); +void gl3_2compat_glGetMaterialiv(void *_glfuncs, GLenum face, GLenum pname, GLint* params); +void gl3_2compat_glGetMaterialfv(void *_glfuncs, GLenum face, GLenum pname, GLfloat* params); +void gl3_2compat_glGetMapiv(void *_glfuncs, GLenum target, GLenum query, GLint* v); +void gl3_2compat_glGetMapfv(void *_glfuncs, GLenum target, GLenum query, GLfloat* v); +void gl3_2compat_glGetMapdv(void *_glfuncs, GLenum target, GLenum query, GLdouble* v); +void gl3_2compat_glGetLightiv(void *_glfuncs, GLenum light, GLenum pname, GLint* params); +void gl3_2compat_glGetLightfv(void *_glfuncs, GLenum light, GLenum pname, GLfloat* params); +void gl3_2compat_glGetClipPlane(void *_glfuncs, GLenum plane, GLdouble* equation); +void gl3_2compat_glDrawPixels(void *_glfuncs, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_2compat_glCopyPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum gltype); +void gl3_2compat_glPixelMapusv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLushort* values); +void gl3_2compat_glPixelMapuiv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLuint* values); +void gl3_2compat_glPixelMapfv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLfloat* values); +void gl3_2compat_glPixelTransferi(void *_glfuncs, GLenum pname, GLint param); +void gl3_2compat_glPixelTransferf(void *_glfuncs, GLenum pname, GLfloat param); +void gl3_2compat_glPixelZoom(void *_glfuncs, GLfloat xfactor, GLfloat yfactor); +void gl3_2compat_glAlphaFunc(void *_glfuncs, GLenum glfunc, GLfloat ref); +void gl3_2compat_glEvalPoint2(void *_glfuncs, GLint i, GLint j); +void gl3_2compat_glEvalMesh2(void *_glfuncs, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); +void gl3_2compat_glEvalPoint1(void *_glfuncs, GLint i); +void gl3_2compat_glEvalMesh1(void *_glfuncs, GLenum mode, GLint i1, GLint i2); +void gl3_2compat_glEvalCoord2fv(void *_glfuncs, const GLfloat* u); +void gl3_2compat_glEvalCoord2f(void *_glfuncs, GLfloat u, GLfloat v); +void gl3_2compat_glEvalCoord2dv(void *_glfuncs, const GLdouble* u); +void gl3_2compat_glEvalCoord2d(void *_glfuncs, GLdouble u, GLdouble v); +void gl3_2compat_glEvalCoord1fv(void *_glfuncs, const GLfloat* u); +void gl3_2compat_glEvalCoord1f(void *_glfuncs, GLfloat u); +void gl3_2compat_glEvalCoord1dv(void *_glfuncs, const GLdouble* u); +void gl3_2compat_glEvalCoord1d(void *_glfuncs, GLdouble u); +void gl3_2compat_glMapGrid2f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); +void gl3_2compat_glMapGrid2d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); +void gl3_2compat_glMapGrid1f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2); +void gl3_2compat_glMapGrid1d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2); +void gl3_2compat_glMap2f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points); +void gl3_2compat_glMap2d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points); +void gl3_2compat_glMap1f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points); +void gl3_2compat_glMap1d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points); +void gl3_2compat_glPushAttrib(void *_glfuncs, GLbitfield mask); +void gl3_2compat_glPopAttrib(void *_glfuncs); +void gl3_2compat_glAccum(void *_glfuncs, GLenum op, GLfloat value); +void gl3_2compat_glIndexMask(void *_glfuncs, GLuint mask); +void gl3_2compat_glClearIndex(void *_glfuncs, GLfloat c); +void gl3_2compat_glClearAccum(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl3_2compat_glPushName(void *_glfuncs, GLuint name); +void gl3_2compat_glPopName(void *_glfuncs); +void gl3_2compat_glPassThrough(void *_glfuncs, GLfloat token); +void gl3_2compat_glLoadName(void *_glfuncs, GLuint name); +void gl3_2compat_glInitNames(void *_glfuncs); +GLint gl3_2compat_glRenderMode(void *_glfuncs, GLenum mode); +void gl3_2compat_glSelectBuffer(void *_glfuncs, GLsizei size, GLuint* buffer); +void gl3_2compat_glFeedbackBuffer(void *_glfuncs, GLsizei size, GLenum gltype, GLfloat* buffer); +void gl3_2compat_glTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, const GLint* params); +void gl3_2compat_glTexGeni(void *_glfuncs, GLenum coord, GLenum pname, GLint param); +void gl3_2compat_glTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, const GLfloat* params); +void gl3_2compat_glTexGenf(void *_glfuncs, GLenum coord, GLenum pname, GLfloat param); +void gl3_2compat_glTexGendv(void *_glfuncs, GLenum coord, GLenum pname, const GLdouble* params); +void gl3_2compat_glTexGend(void *_glfuncs, GLenum coord, GLenum pname, GLdouble param); +void gl3_2compat_glTexEnviv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl3_2compat_glTexEnvi(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl3_2compat_glTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl3_2compat_glTexEnvf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl3_2compat_glShadeModel(void *_glfuncs, GLenum mode); +void gl3_2compat_glPolygonStipple(void *_glfuncs, const GLubyte* mask); +void gl3_2compat_glMaterialiv(void *_glfuncs, GLenum face, GLenum pname, const GLint* params); +void gl3_2compat_glMateriali(void *_glfuncs, GLenum face, GLenum pname, GLint param); +void gl3_2compat_glMaterialfv(void *_glfuncs, GLenum face, GLenum pname, const GLfloat* params); +void gl3_2compat_glMaterialf(void *_glfuncs, GLenum face, GLenum pname, GLfloat param); +void gl3_2compat_glLineStipple(void *_glfuncs, GLint factor, GLushort pattern); +void gl3_2compat_glLightModeliv(void *_glfuncs, GLenum pname, const GLint* params); +void gl3_2compat_glLightModeli(void *_glfuncs, GLenum pname, GLint param); +void gl3_2compat_glLightModelfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl3_2compat_glLightModelf(void *_glfuncs, GLenum pname, GLfloat param); +void gl3_2compat_glLightiv(void *_glfuncs, GLenum light, GLenum pname, const GLint* params); +void gl3_2compat_glLighti(void *_glfuncs, GLenum light, GLenum pname, GLint param); +void gl3_2compat_glLightfv(void *_glfuncs, GLenum light, GLenum pname, const GLfloat* params); +void gl3_2compat_glLightf(void *_glfuncs, GLenum light, GLenum pname, GLfloat param); +void gl3_2compat_glFogiv(void *_glfuncs, GLenum pname, const GLint* params); +void gl3_2compat_glFogi(void *_glfuncs, GLenum pname, GLint param); +void gl3_2compat_glFogfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl3_2compat_glFogf(void *_glfuncs, GLenum pname, GLfloat param); +void gl3_2compat_glColorMaterial(void *_glfuncs, GLenum face, GLenum mode); +void gl3_2compat_glClipPlane(void *_glfuncs, GLenum plane, const GLdouble* equation); +void gl3_2compat_glVertex4sv(void *_glfuncs, const GLshort* v); +void gl3_2compat_glVertex4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w); +void gl3_2compat_glVertex4iv(void *_glfuncs, const GLint* v); +void gl3_2compat_glVertex4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w); +void gl3_2compat_glVertex4fv(void *_glfuncs, const GLfloat* v); +void gl3_2compat_glVertex4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl3_2compat_glVertex4dv(void *_glfuncs, const GLdouble* v); +void gl3_2compat_glVertex4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl3_2compat_glVertex3sv(void *_glfuncs, const GLshort* v); +void gl3_2compat_glVertex3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl3_2compat_glVertex3iv(void *_glfuncs, const GLint* v); +void gl3_2compat_glVertex3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl3_2compat_glVertex3fv(void *_glfuncs, const GLfloat* v); +void gl3_2compat_glVertex3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl3_2compat_glVertex3dv(void *_glfuncs, const GLdouble* v); +void gl3_2compat_glVertex3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl3_2compat_glVertex2sv(void *_glfuncs, const GLshort* v); +void gl3_2compat_glVertex2s(void *_glfuncs, GLshort x, GLshort y); +void gl3_2compat_glVertex2iv(void *_glfuncs, const GLint* v); +void gl3_2compat_glVertex2i(void *_glfuncs, GLint x, GLint y); +void gl3_2compat_glVertex2fv(void *_glfuncs, const GLfloat* v); +void gl3_2compat_glVertex2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl3_2compat_glVertex2dv(void *_glfuncs, const GLdouble* v); +void gl3_2compat_glVertex2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl3_2compat_glTexCoord4sv(void *_glfuncs, const GLshort* v); +void gl3_2compat_glTexCoord4s(void *_glfuncs, GLshort s, GLshort t, GLshort r, GLshort q); +void gl3_2compat_glTexCoord4iv(void *_glfuncs, const GLint* v); +void gl3_2compat_glTexCoord4i(void *_glfuncs, GLint s, GLint t, GLint r, GLint q); +void gl3_2compat_glTexCoord4fv(void *_glfuncs, const GLfloat* v); +void gl3_2compat_glTexCoord4f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +void gl3_2compat_glTexCoord4dv(void *_glfuncs, const GLdouble* v); +void gl3_2compat_glTexCoord4d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +void gl3_2compat_glTexCoord3sv(void *_glfuncs, const GLshort* v); +void gl3_2compat_glTexCoord3s(void *_glfuncs, GLshort s, GLshort t, GLshort r); +void gl3_2compat_glTexCoord3iv(void *_glfuncs, const GLint* v); +void gl3_2compat_glTexCoord3i(void *_glfuncs, GLint s, GLint t, GLint r); +void gl3_2compat_glTexCoord3fv(void *_glfuncs, const GLfloat* v); +void gl3_2compat_glTexCoord3f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r); +void gl3_2compat_glTexCoord3dv(void *_glfuncs, const GLdouble* v); +void gl3_2compat_glTexCoord3d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r); +void gl3_2compat_glTexCoord2sv(void *_glfuncs, const GLshort* v); +void gl3_2compat_glTexCoord2s(void *_glfuncs, GLshort s, GLshort t); +void gl3_2compat_glTexCoord2iv(void *_glfuncs, const GLint* v); +void gl3_2compat_glTexCoord2i(void *_glfuncs, GLint s, GLint t); +void gl3_2compat_glTexCoord2fv(void *_glfuncs, const GLfloat* v); +void gl3_2compat_glTexCoord2f(void *_glfuncs, GLfloat s, GLfloat t); +void gl3_2compat_glTexCoord2dv(void *_glfuncs, const GLdouble* v); +void gl3_2compat_glTexCoord2d(void *_glfuncs, GLdouble s, GLdouble t); +void gl3_2compat_glTexCoord1sv(void *_glfuncs, const GLshort* v); +void gl3_2compat_glTexCoord1s(void *_glfuncs, GLshort s); +void gl3_2compat_glTexCoord1iv(void *_glfuncs, const GLint* v); +void gl3_2compat_glTexCoord1i(void *_glfuncs, GLint s); +void gl3_2compat_glTexCoord1fv(void *_glfuncs, const GLfloat* v); +void gl3_2compat_glTexCoord1f(void *_glfuncs, GLfloat s); +void gl3_2compat_glTexCoord1dv(void *_glfuncs, const GLdouble* v); +void gl3_2compat_glTexCoord1d(void *_glfuncs, GLdouble s); +void gl3_2compat_glRectsv(void *_glfuncs, const GLshort* v1, const GLshort* v2); +void gl3_2compat_glRects(void *_glfuncs, GLshort x1, GLshort y1, GLshort x2, GLshort y2); +void gl3_2compat_glRectiv(void *_glfuncs, const GLint* v1, const GLint* v2); +void gl3_2compat_glRecti(void *_glfuncs, GLint x1, GLint y1, GLint x2, GLint y2); +void gl3_2compat_glRectfv(void *_glfuncs, const GLfloat* v1, const GLfloat* v2); +void gl3_2compat_glRectf(void *_glfuncs, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); +void gl3_2compat_glRectdv(void *_glfuncs, const GLdouble* v1, const GLdouble* v2); +void gl3_2compat_glRectd(void *_glfuncs, GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); +void gl3_2compat_glRasterPos4sv(void *_glfuncs, const GLshort* v); +void gl3_2compat_glRasterPos4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w); +void gl3_2compat_glRasterPos4iv(void *_glfuncs, const GLint* v); +void gl3_2compat_glRasterPos4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w); +void gl3_2compat_glRasterPos4fv(void *_glfuncs, const GLfloat* v); +void gl3_2compat_glRasterPos4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl3_2compat_glRasterPos4dv(void *_glfuncs, const GLdouble* v); +void gl3_2compat_glRasterPos4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl3_2compat_glRasterPos3sv(void *_glfuncs, const GLshort* v); +void gl3_2compat_glRasterPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl3_2compat_glRasterPos3iv(void *_glfuncs, const GLint* v); +void gl3_2compat_glRasterPos3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl3_2compat_glRasterPos3fv(void *_glfuncs, const GLfloat* v); +void gl3_2compat_glRasterPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl3_2compat_glRasterPos3dv(void *_glfuncs, const GLdouble* v); +void gl3_2compat_glRasterPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl3_2compat_glRasterPos2sv(void *_glfuncs, const GLshort* v); +void gl3_2compat_glRasterPos2s(void *_glfuncs, GLshort x, GLshort y); +void gl3_2compat_glRasterPos2iv(void *_glfuncs, const GLint* v); +void gl3_2compat_glRasterPos2i(void *_glfuncs, GLint x, GLint y); +void gl3_2compat_glRasterPos2fv(void *_glfuncs, const GLfloat* v); +void gl3_2compat_glRasterPos2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl3_2compat_glRasterPos2dv(void *_glfuncs, const GLdouble* v); +void gl3_2compat_glRasterPos2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl3_2compat_glNormal3sv(void *_glfuncs, const GLshort* v); +void gl3_2compat_glNormal3s(void *_glfuncs, GLshort nx, GLshort ny, GLshort nz); +void gl3_2compat_glNormal3iv(void *_glfuncs, const GLint* v); +void gl3_2compat_glNormal3i(void *_glfuncs, GLint nx, GLint ny, GLint nz); +void gl3_2compat_glNormal3fv(void *_glfuncs, const GLfloat* v); +void gl3_2compat_glNormal3f(void *_glfuncs, GLfloat nx, GLfloat ny, GLfloat nz); +void gl3_2compat_glNormal3dv(void *_glfuncs, const GLdouble* v); +void gl3_2compat_glNormal3d(void *_glfuncs, GLdouble nx, GLdouble ny, GLdouble nz); +void gl3_2compat_glNormal3bv(void *_glfuncs, const GLbyte* v); +void gl3_2compat_glNormal3b(void *_glfuncs, GLbyte nx, GLbyte ny, GLbyte nz); +void gl3_2compat_glIndexsv(void *_glfuncs, const GLshort* c); +void gl3_2compat_glIndexs(void *_glfuncs, GLshort c); +void gl3_2compat_glIndexiv(void *_glfuncs, const GLint* c); +void gl3_2compat_glIndexi(void *_glfuncs, GLint c); +void gl3_2compat_glIndexfv(void *_glfuncs, const GLfloat* c); +void gl3_2compat_glIndexf(void *_glfuncs, GLfloat c); +void gl3_2compat_glIndexdv(void *_glfuncs, const GLdouble* c); +void gl3_2compat_glIndexd(void *_glfuncs, GLdouble c); +void gl3_2compat_glEnd(void *_glfuncs); +void gl3_2compat_glEdgeFlagv(void *_glfuncs, const GLboolean* flag); +void gl3_2compat_glEdgeFlag(void *_glfuncs, GLboolean flag); +void gl3_2compat_glColor4usv(void *_glfuncs, const GLushort* v); +void gl3_2compat_glColor4us(void *_glfuncs, GLushort red, GLushort green, GLushort blue, GLushort alpha); +void gl3_2compat_glColor4uiv(void *_glfuncs, const GLuint* v); +void gl3_2compat_glColor4ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue, GLuint alpha); +void gl3_2compat_glColor4ubv(void *_glfuncs, const GLubyte* v); +void gl3_2compat_glColor4ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); +void gl3_2compat_glColor4sv(void *_glfuncs, const GLshort* v); +void gl3_2compat_glColor4s(void *_glfuncs, GLshort red, GLshort green, GLshort blue, GLshort alpha); +void gl3_2compat_glColor4iv(void *_glfuncs, const GLint* v); +void gl3_2compat_glColor4i(void *_glfuncs, GLint red, GLint green, GLint blue, GLint alpha); +void gl3_2compat_glColor4fv(void *_glfuncs, const GLfloat* v); +void gl3_2compat_glColor4f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl3_2compat_glColor4dv(void *_glfuncs, const GLdouble* v); +void gl3_2compat_glColor4d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); +void gl3_2compat_glColor4bv(void *_glfuncs, const GLbyte* v); +void gl3_2compat_glColor4b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); +void gl3_2compat_glColor3usv(void *_glfuncs, const GLushort* v); +void gl3_2compat_glColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue); +void gl3_2compat_glColor3uiv(void *_glfuncs, const GLuint* v); +void gl3_2compat_glColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue); +void gl3_2compat_glColor3ubv(void *_glfuncs, const GLubyte* v); +void gl3_2compat_glColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue); +void gl3_2compat_glColor3sv(void *_glfuncs, const GLshort* v); +void gl3_2compat_glColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue); +void gl3_2compat_glColor3iv(void *_glfuncs, const GLint* v); +void gl3_2compat_glColor3i(void *_glfuncs, GLint red, GLint green, GLint blue); +void gl3_2compat_glColor3fv(void *_glfuncs, const GLfloat* v); +void gl3_2compat_glColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue); +void gl3_2compat_glColor3dv(void *_glfuncs, const GLdouble* v); +void gl3_2compat_glColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue); +void gl3_2compat_glColor3bv(void *_glfuncs, const GLbyte* v); +void gl3_2compat_glColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue); +void gl3_2compat_glBitmap(void *_glfuncs, GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap); +void gl3_2compat_glBegin(void *_glfuncs, GLenum mode); +void gl3_2compat_glListBase(void *_glfuncs, GLuint base); +GLuint gl3_2compat_glGenLists(void *_glfuncs, GLsizei range_); +void gl3_2compat_glDeleteLists(void *_glfuncs, GLuint list, GLsizei range_); +void gl3_2compat_glCallLists(void *_glfuncs, GLsizei n, GLenum gltype, const GLvoid* lists); +void gl3_2compat_glCallList(void *_glfuncs, GLuint list); +void gl3_2compat_glEndList(void *_glfuncs); +void gl3_2compat_glNewList(void *_glfuncs, GLuint list, GLenum mode); +void gl3_2compat_glPushClientAttrib(void *_glfuncs, GLbitfield mask); +void gl3_2compat_glPopClientAttrib(void *_glfuncs); +void gl3_2compat_glPrioritizeTextures(void *_glfuncs, GLsizei n, const GLuint* textures, const GLfloat* priorities); +GLboolean gl3_2compat_glAreTexturesResident(void *_glfuncs, GLsizei n, const GLuint* textures, GLboolean* residences); +void gl3_2compat_glVertexPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl3_2compat_glTexCoordPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl3_2compat_glNormalPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl3_2compat_glInterleavedArrays(void *_glfuncs, GLenum format, GLsizei stride, const GLvoid* pointer); +void gl3_2compat_glIndexPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl3_2compat_glEnableClientState(void *_glfuncs, GLenum array); +void gl3_2compat_glEdgeFlagPointer(void *_glfuncs, GLsizei stride, const GLvoid* pointer); +void gl3_2compat_glDisableClientState(void *_glfuncs, GLenum array); +void gl3_2compat_glColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl3_2compat_glArrayElement(void *_glfuncs, GLint i); +void gl3_2compat_glResetMinmax(void *_glfuncs, GLenum target); +void gl3_2compat_glResetHistogram(void *_glfuncs, GLenum target); +void gl3_2compat_glMinmax(void *_glfuncs, GLenum target, GLenum internalFormat, GLboolean sink); +void gl3_2compat_glHistogram(void *_glfuncs, GLenum target, GLsizei width, GLenum internalFormat, GLboolean sink); +void gl3_2compat_glGetMinmaxParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_2compat_glGetMinmaxParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl3_2compat_glGetMinmax(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values); +void gl3_2compat_glGetHistogramParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_2compat_glGetHistogramParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl3_2compat_glGetHistogram(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values); +void gl3_2compat_glSeparableFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* row, const GLvoid* column); +void gl3_2compat_glGetSeparableFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* row, GLvoid* column, GLvoid* span); +void gl3_2compat_glGetConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_2compat_glGetConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl3_2compat_glGetConvolutionFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* image); +void gl3_2compat_glCopyConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height); +void gl3_2compat_glCopyConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width); +void gl3_2compat_glConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl3_2compat_glConvolutionParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint params); +void gl3_2compat_glConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl3_2compat_glConvolutionParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat params); +void gl3_2compat_glConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* image); +void gl3_2compat_glConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* image); +void gl3_2compat_glCopyColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); +void gl3_2compat_glColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum gltype, const GLvoid* data); +void gl3_2compat_glGetColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_2compat_glGetColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl3_2compat_glGetColorTable(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* table); +void gl3_2compat_glCopyColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width); +void gl3_2compat_glColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl3_2compat_glColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl3_2compat_glColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* table); +void gl3_2compat_glMultTransposeMatrixd(void *_glfuncs, const GLdouble* m); +void gl3_2compat_glMultTransposeMatrixf(void *_glfuncs, const GLfloat* m); +void gl3_2compat_glLoadTransposeMatrixd(void *_glfuncs, const GLdouble* m); +void gl3_2compat_glLoadTransposeMatrixf(void *_glfuncs, const GLfloat* m); +void gl3_2compat_glMultiTexCoord4sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl3_2compat_glMultiTexCoord4s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); +void gl3_2compat_glMultiTexCoord4iv(void *_glfuncs, GLenum target, const GLint* v); +void gl3_2compat_glMultiTexCoord4i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r, GLint q); +void gl3_2compat_glMultiTexCoord4fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl3_2compat_glMultiTexCoord4f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +void gl3_2compat_glMultiTexCoord4dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl3_2compat_glMultiTexCoord4d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +void gl3_2compat_glMultiTexCoord3sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl3_2compat_glMultiTexCoord3s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r); +void gl3_2compat_glMultiTexCoord3iv(void *_glfuncs, GLenum target, const GLint* v); +void gl3_2compat_glMultiTexCoord3i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r); +void gl3_2compat_glMultiTexCoord3fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl3_2compat_glMultiTexCoord3f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r); +void gl3_2compat_glMultiTexCoord3dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl3_2compat_glMultiTexCoord3d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r); +void gl3_2compat_glMultiTexCoord2sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl3_2compat_glMultiTexCoord2s(void *_glfuncs, GLenum target, GLshort s, GLshort t); +void gl3_2compat_glMultiTexCoord2iv(void *_glfuncs, GLenum target, const GLint* v); +void gl3_2compat_glMultiTexCoord2i(void *_glfuncs, GLenum target, GLint s, GLint t); +void gl3_2compat_glMultiTexCoord2fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl3_2compat_glMultiTexCoord2f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t); +void gl3_2compat_glMultiTexCoord2dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl3_2compat_glMultiTexCoord2d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t); +void gl3_2compat_glMultiTexCoord1sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl3_2compat_glMultiTexCoord1s(void *_glfuncs, GLenum target, GLshort s); +void gl3_2compat_glMultiTexCoord1iv(void *_glfuncs, GLenum target, const GLint* v); +void gl3_2compat_glMultiTexCoord1i(void *_glfuncs, GLenum target, GLint s); +void gl3_2compat_glMultiTexCoord1fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl3_2compat_glMultiTexCoord1f(void *_glfuncs, GLenum target, GLfloat s); +void gl3_2compat_glMultiTexCoord1dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl3_2compat_glMultiTexCoord1d(void *_glfuncs, GLenum target, GLdouble s); +void gl3_2compat_glClientActiveTexture(void *_glfuncs, GLenum texture); +void gl3_2compat_glWindowPos3sv(void *_glfuncs, const GLshort* v); +void gl3_2compat_glWindowPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl3_2compat_glWindowPos3iv(void *_glfuncs, const GLint* v); +void gl3_2compat_glWindowPos3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl3_2compat_glWindowPos3fv(void *_glfuncs, const GLfloat* v); +void gl3_2compat_glWindowPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl3_2compat_glWindowPos3dv(void *_glfuncs, const GLdouble* v); +void gl3_2compat_glWindowPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl3_2compat_glWindowPos2sv(void *_glfuncs, const GLshort* v); +void gl3_2compat_glWindowPos2s(void *_glfuncs, GLshort x, GLshort y); +void gl3_2compat_glWindowPos2iv(void *_glfuncs, const GLint* v); +void gl3_2compat_glWindowPos2i(void *_glfuncs, GLint x, GLint y); +void gl3_2compat_glWindowPos2fv(void *_glfuncs, const GLfloat* v); +void gl3_2compat_glWindowPos2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl3_2compat_glWindowPos2dv(void *_glfuncs, const GLdouble* v); +void gl3_2compat_glWindowPos2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl3_2compat_glSecondaryColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl3_2compat_glSecondaryColor3usv(void *_glfuncs, const GLushort* v); +void gl3_2compat_glSecondaryColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue); +void gl3_2compat_glSecondaryColor3uiv(void *_glfuncs, const GLuint* v); +void gl3_2compat_glSecondaryColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue); +void gl3_2compat_glSecondaryColor3ubv(void *_glfuncs, const GLubyte* v); +void gl3_2compat_glSecondaryColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue); +void gl3_2compat_glSecondaryColor3sv(void *_glfuncs, const GLshort* v); +void gl3_2compat_glSecondaryColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue); +void gl3_2compat_glSecondaryColor3iv(void *_glfuncs, const GLint* v); +void gl3_2compat_glSecondaryColor3i(void *_glfuncs, GLint red, GLint green, GLint blue); +void gl3_2compat_glSecondaryColor3fv(void *_glfuncs, const GLfloat* v); +void gl3_2compat_glSecondaryColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue); +void gl3_2compat_glSecondaryColor3dv(void *_glfuncs, const GLdouble* v); +void gl3_2compat_glSecondaryColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue); +void gl3_2compat_glSecondaryColor3bv(void *_glfuncs, const GLbyte* v); +void gl3_2compat_glSecondaryColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue); +void gl3_2compat_glFogCoordPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl3_2compat_glFogCoorddv(void *_glfuncs, const GLdouble* coord); +void gl3_2compat_glFogCoordd(void *_glfuncs, GLdouble coord); +void gl3_2compat_glFogCoordfv(void *_glfuncs, const GLfloat* coord); +void gl3_2compat_glFogCoordf(void *_glfuncs, GLfloat coord); +void gl3_2compat_glVertexAttrib4usv(void *_glfuncs, GLuint index, const GLushort* v); +void gl3_2compat_glVertexAttrib4uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl3_2compat_glVertexAttrib4ubv(void *_glfuncs, GLuint index, const GLubyte* v); +void gl3_2compat_glVertexAttrib4sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl3_2compat_glVertexAttrib4s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +void gl3_2compat_glVertexAttrib4iv(void *_glfuncs, GLuint index, const GLint* v); +void gl3_2compat_glVertexAttrib4fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl3_2compat_glVertexAttrib4f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl3_2compat_glVertexAttrib4dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl3_2compat_glVertexAttrib4d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl3_2compat_glVertexAttrib4bv(void *_glfuncs, GLuint index, const GLbyte* v); +void gl3_2compat_glVertexAttrib4Nusv(void *_glfuncs, GLuint index, const GLushort* v); +void gl3_2compat_glVertexAttrib4Nuiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl3_2compat_glVertexAttrib4Nubv(void *_glfuncs, GLuint index, const GLubyte* v); +void gl3_2compat_glVertexAttrib4Nub(void *_glfuncs, GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +void gl3_2compat_glVertexAttrib4Nsv(void *_glfuncs, GLuint index, const GLshort* v); +void gl3_2compat_glVertexAttrib4Niv(void *_glfuncs, GLuint index, const GLint* v); +void gl3_2compat_glVertexAttrib4Nbv(void *_glfuncs, GLuint index, const GLbyte* v); +void gl3_2compat_glVertexAttrib3sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl3_2compat_glVertexAttrib3s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z); +void gl3_2compat_glVertexAttrib3fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl3_2compat_glVertexAttrib3f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z); +void gl3_2compat_glVertexAttrib3dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl3_2compat_glVertexAttrib3d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z); +void gl3_2compat_glVertexAttrib2sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl3_2compat_glVertexAttrib2s(void *_glfuncs, GLuint index, GLshort x, GLshort y); +void gl3_2compat_glVertexAttrib2fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl3_2compat_glVertexAttrib2f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y); +void gl3_2compat_glVertexAttrib2dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl3_2compat_glVertexAttrib2d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y); +void gl3_2compat_glVertexAttrib1sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl3_2compat_glVertexAttrib1s(void *_glfuncs, GLuint index, GLshort x); +void gl3_2compat_glVertexAttrib1fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl3_2compat_glVertexAttrib1f(void *_glfuncs, GLuint index, GLfloat x); +void gl3_2compat_glVertexAttrib1dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl3_2compat_glVertexAttrib1d(void *_glfuncs, GLuint index, GLdouble x); +void gl3_2compat_glVertexAttribI4usv(void *_glfuncs, GLuint index, const GLushort* v); +void gl3_2compat_glVertexAttribI4ubv(void *_glfuncs, GLuint index, const GLubyte* v); +void gl3_2compat_glVertexAttribI4sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl3_2compat_glVertexAttribI4bv(void *_glfuncs, GLuint index, const GLbyte* v); +void gl3_2compat_glVertexAttribI4uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl3_2compat_glVertexAttribI3uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl3_2compat_glVertexAttribI2uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl3_2compat_glVertexAttribI1uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl3_2compat_glVertexAttribI4iv(void *_glfuncs, GLuint index, const GLint* v); +void gl3_2compat_glVertexAttribI3iv(void *_glfuncs, GLuint index, const GLint* v); +void gl3_2compat_glVertexAttribI2iv(void *_glfuncs, GLuint index, const GLint* v); +void gl3_2compat_glVertexAttribI1iv(void *_glfuncs, GLuint index, const GLint* v); +void gl3_2compat_glVertexAttribI4ui(void *_glfuncs, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +void gl3_2compat_glVertexAttribI3ui(void *_glfuncs, GLuint index, GLuint x, GLuint y, GLuint z); +void gl3_2compat_glVertexAttribI2ui(void *_glfuncs, GLuint index, GLuint x, GLuint y); +void gl3_2compat_glVertexAttribI1ui(void *_glfuncs, GLuint index, GLuint x); +void gl3_2compat_glVertexAttribI4i(void *_glfuncs, GLuint index, GLint x, GLint y, GLint z, GLint w); +void gl3_2compat_glVertexAttribI3i(void *_glfuncs, GLuint index, GLint x, GLint y, GLint z); +void gl3_2compat_glVertexAttribI2i(void *_glfuncs, GLuint index, GLint x, GLint y); +void gl3_2compat_glVertexAttribI1i(void *_glfuncs, GLuint index, GLint x); + + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/gl/3.2compat/gl.go b/gl/3.2compat/gl.go new file mode 100644 index 00000000..3cf74a01 --- /dev/null +++ b/gl/3.2compat/gl.go @@ -0,0 +1,7973 @@ +// ** file automatically generated by glgen -- do not edit manually ** + +package GL + +// #cgo CXXFLAGS: -std=c++0x -pedantic-errors -Wall -fno-strict-aliasing +// #cgo LDFLAGS: -lstdc++ +// #cgo pkg-config: Qt5Core Qt5OpenGL +// +// #include "funcs.h" +// +// void free(void*); +// +import "C" + +import ( + "fmt" + "reflect" + "unsafe" + + "gopkg.in/qml.v1/gl/glbase" +) + +// API returns a value that offers methods matching the OpenGL version 3.2 API. +// +// The returned API must not be used after the provided OpenGL context becomes invalid. +func API(context glbase.Contexter) *GL { + gl := &GL{} + gl.funcs = C.gl3_2compat_funcs() + if gl.funcs == nil { + panic(fmt.Errorf("OpenGL version 3.2 is not available")) + } + return gl +} + +// GL implements the OpenGL version 3.2 API. Values of this +// type must be created via the API function, and it must not be used after +// the associated OpenGL context becomes invalid. +type GL struct { + funcs unsafe.Pointer +} + +const ( + FALSE = 0 + TRUE = 1 + NONE = 0 + + BYTE = 0x1400 + UNSIGNED_BYTE = 0x1401 + SHORT = 0x1402 + UNSIGNED_SHORT = 0x1403 + INT = 0x1404 + UNSIGNED_INT = 0x1405 + FLOAT = 0x1406 + N2_BYTES = 0x1407 + N3_BYTES = 0x1408 + N4_BYTES = 0x1409 + DOUBLE = 0x140A + HALF_FLOAT = 0x140B + + ACCUM = 0x0100 + LOAD = 0x0101 + RETURN = 0x0102 + MULT = 0x0103 + ADD = 0x0104 + + ACCUM_BUFFER_BIT = 0x00000200 + ALL_ATTRIB_BITS = 0xFFFFFFFF + COLOR_BUFFER_BIT = 0x00004000 + CURRENT_BIT = 0x00000001 + DEPTH_BUFFER_BIT = 0x00000100 + ENABLE_BIT = 0x00002000 + EVAL_BIT = 0x00010000 + FOG_BIT = 0x00000080 + HINT_BIT = 0x00008000 + LIGHTING_BIT = 0x00000040 + LINE_BIT = 0x00000004 + LIST_BIT = 0x00020000 + MULTISAMPLE_BIT = 0x20000000 + PIXEL_MODE_BIT = 0x00000020 + POINT_BIT = 0x00000002 + POLYGON_BIT = 0x00000008 + POLYGON_STIPPLE_BIT = 0x00000010 + SCISSOR_BIT = 0x00080000 + STENCIL_BUFFER_BIT = 0x00000400 + TEXTURE_BIT = 0x00040000 + TRANSFORM_BIT = 0x00001000 + VIEWPORT_BIT = 0x00000800 + + ALWAYS = 0x0207 + EQUAL = 0x0202 + GEQUAL = 0x0206 + GREATER = 0x0204 + LEQUAL = 0x0203 + LESS = 0x0201 + NEVER = 0x0200 + NOTEQUAL = 0x0205 + + LOGIC_OP = 0x0BF1 + + DST_ALPHA = 0x0304 + ONE = 1 + ONE_MINUS_DST_ALPHA = 0x0305 + ONE_MINUS_SRC_ALPHA = 0x0303 + ONE_MINUS_SRC_COLOR = 0x0301 + SRC_ALPHA = 0x0302 + SRC_COLOR = 0x0300 + ZERO = 0 + + DST_COLOR = 0x0306 + ONE_MINUS_DST_COLOR = 0x0307 + SRC_ALPHA_SATURATE = 0x0308 + + CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF + CLIENT_PIXEL_STORE_BIT = 0x00000001 + CLIENT_VERTEX_ARRAY_BIT = 0x00000002 + + CLIP_DISTANCE0 = 0x3000 + CLIP_DISTANCE1 = 0x3001 + CLIP_DISTANCE2 = 0x3002 + CLIP_DISTANCE3 = 0x3003 + CLIP_DISTANCE4 = 0x3004 + CLIP_DISTANCE5 = 0x3005 + CLIP_DISTANCE6 = 0x3006 + CLIP_DISTANCE7 = 0x3007 + CLIP_PLANE0 = 0x3000 + CLIP_PLANE1 = 0x3001 + CLIP_PLANE2 = 0x3002 + CLIP_PLANE3 = 0x3003 + CLIP_PLANE4 = 0x3004 + CLIP_PLANE5 = 0x3005 + + BACK = 0x0405 + FRONT = 0x0404 + FRONT_AND_BACK = 0x0408 + + AMBIENT = 0x1200 + AMBIENT_AND_DIFFUSE = 0x1602 + DIFFUSE = 0x1201 + EMISSION = 0x1600 + SPECULAR = 0x1202 + + CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x00000001 + + CONTEXT_COMPATIBILITY_PROFILE_BIT = 0x00000002 + CONTEXT_CORE_PROFILE_BIT = 0x00000001 + + AUX0 = 0x0409 + AUX1 = 0x040A + AUX2 = 0x040B + AUX3 = 0x040C + BACK_LEFT = 0x0402 + BACK_RIGHT = 0x0403 + FRONT_LEFT = 0x0400 + FRONT_RIGHT = 0x0401 + LEFT = 0x0406 + RIGHT = 0x0407 + + ALPHA_TEST = 0x0BC0 + AUTO_NORMAL = 0x0D80 + BLEND = 0x0BE2 + COLOR_ARRAY = 0x8076 + COLOR_LOGIC_OP = 0x0BF2 + COLOR_MATERIAL = 0x0B57 + CULL_FACE = 0x0B44 + DEPTH_TEST = 0x0B71 + DITHER = 0x0BD0 + EDGE_FLAG_ARRAY = 0x8079 + FOG = 0x0B60 + INDEX_ARRAY = 0x8077 + INDEX_LOGIC_OP = 0x0BF1 + LIGHT0 = 0x4000 + LIGHT1 = 0x4001 + LIGHT2 = 0x4002 + LIGHT3 = 0x4003 + LIGHT4 = 0x4004 + LIGHT5 = 0x4005 + LIGHT6 = 0x4006 + LIGHT7 = 0x4007 + LIGHTING = 0x0B50 + LINE_SMOOTH = 0x0B20 + LINE_STIPPLE = 0x0B24 + MAP1_COLOR_4 = 0x0D90 + MAP1_INDEX = 0x0D91 + MAP1_NORMAL = 0x0D92 + MAP1_TEXTURE_COORD_1 = 0x0D93 + MAP1_TEXTURE_COORD_2 = 0x0D94 + MAP1_TEXTURE_COORD_3 = 0x0D95 + MAP1_TEXTURE_COORD_4 = 0x0D96 + MAP1_VERTEX_3 = 0x0D97 + MAP1_VERTEX_4 = 0x0D98 + MAP2_COLOR_4 = 0x0DB0 + MAP2_INDEX = 0x0DB1 + MAP2_NORMAL = 0x0DB2 + MAP2_TEXTURE_COORD_1 = 0x0DB3 + MAP2_TEXTURE_COORD_2 = 0x0DB4 + MAP2_TEXTURE_COORD_3 = 0x0DB5 + MAP2_TEXTURE_COORD_4 = 0x0DB6 + MAP2_VERTEX_3 = 0x0DB7 + MAP2_VERTEX_4 = 0x0DB8 + NORMALIZE = 0x0BA1 + NORMAL_ARRAY = 0x8075 + POINT_SMOOTH = 0x0B10 + POLYGON_OFFSET_FILL = 0x8037 + POLYGON_OFFSET_LINE = 0x2A02 + POLYGON_OFFSET_POINT = 0x2A01 + POLYGON_SMOOTH = 0x0B41 + POLYGON_STIPPLE = 0x0B42 + SCISSOR_TEST = 0x0C11 + STENCIL_TEST = 0x0B90 + TEXTURE_1D = 0x0DE0 + TEXTURE_2D = 0x0DE1 + TEXTURE_COORD_ARRAY = 0x8078 + TEXTURE_GEN_Q = 0x0C63 + TEXTURE_GEN_R = 0x0C62 + TEXTURE_GEN_S = 0x0C60 + TEXTURE_GEN_T = 0x0C61 + VERTEX_ARRAY = 0x8074 + + INVALID_ENUM = 0x0500 + INVALID_FRAMEBUFFER_OPERATION = 0x0506 + INVALID_OPERATION = 0x0502 + INVALID_VALUE = 0x0501 + NO_ERROR = 0 + OUT_OF_MEMORY = 0x0505 + STACK_OVERFLOW = 0x0503 + STACK_UNDERFLOW = 0x0504 + + N2D = 0x0600 + N3D = 0x0601 + N3D_COLOR = 0x0602 + N3D_COLOR_TEXTURE = 0x0603 + N4D_COLOR_TEXTURE = 0x0604 + + BITMAP_TOKEN = 0x0704 + COPY_PIXEL_TOKEN = 0x0706 + DRAW_PIXEL_TOKEN = 0x0705 + LINE_RESET_TOKEN = 0x0707 + LINE_TOKEN = 0x0702 + PASS_THROUGH_TOKEN = 0x0700 + POINT_TOKEN = 0x0701 + POLYGON_TOKEN = 0x0703 + + EXP = 0x0800 + EXP2 = 0x0801 + LINEAR = 0x2601 + + FOG_COLOR = 0x0B66 + FOG_DENSITY = 0x0B62 + FOG_END = 0x0B64 + FOG_INDEX = 0x0B61 + FOG_MODE = 0x0B65 + FOG_START = 0x0B63 + + CCW = 0x0901 + CW = 0x0900 + + COEFF = 0x0A00 + DOMAIN = 0x0A02 + ORDER = 0x0A01 + + PIXEL_MAP_A_TO_A = 0x0C79 + PIXEL_MAP_B_TO_B = 0x0C78 + PIXEL_MAP_G_TO_G = 0x0C77 + PIXEL_MAP_I_TO_A = 0x0C75 + PIXEL_MAP_I_TO_B = 0x0C74 + PIXEL_MAP_I_TO_G = 0x0C73 + PIXEL_MAP_I_TO_I = 0x0C70 + PIXEL_MAP_I_TO_R = 0x0C72 + PIXEL_MAP_R_TO_R = 0x0C76 + PIXEL_MAP_S_TO_S = 0x0C71 + + ACCUM_ALPHA_BITS = 0x0D5B + ACCUM_BLUE_BITS = 0x0D5A + ACCUM_CLEAR_VALUE = 0x0B80 + ACCUM_GREEN_BITS = 0x0D59 + ACCUM_RED_BITS = 0x0D58 + ALIASED_LINE_WIDTH_RANGE = 0x846E + ALIASED_POINT_SIZE_RANGE = 0x846D + ALPHA_BIAS = 0x0D1D + ALPHA_BITS = 0x0D55 + ALPHA_SCALE = 0x0D1C + ALPHA_TEST_FUNC = 0x0BC1 + ALPHA_TEST_REF = 0x0BC2 + ATTRIB_STACK_DEPTH = 0x0BB0 + AUX_BUFFERS = 0x0C00 + BLEND_DST = 0x0BE0 + BLEND_SRC = 0x0BE1 + BLUE_BIAS = 0x0D1B + BLUE_BITS = 0x0D54 + BLUE_SCALE = 0x0D1A + CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1 + COLOR_ARRAY_SIZE = 0x8081 + COLOR_ARRAY_STRIDE = 0x8083 + COLOR_ARRAY_TYPE = 0x8082 + COLOR_CLEAR_VALUE = 0x0C22 + COLOR_MATERIAL_FACE = 0x0B55 + COLOR_MATERIAL_PARAMETER = 0x0B56 + COLOR_WRITEMASK = 0x0C23 + CULL_FACE_MODE = 0x0B45 + CURRENT_COLOR = 0x0B00 + CURRENT_INDEX = 0x0B01 + CURRENT_NORMAL = 0x0B02 + CURRENT_RASTER_COLOR = 0x0B04 + CURRENT_RASTER_DISTANCE = 0x0B09 + CURRENT_RASTER_INDEX = 0x0B05 + CURRENT_RASTER_POSITION = 0x0B07 + CURRENT_RASTER_POSITION_VALID = 0x0B08 + CURRENT_RASTER_TEXTURE_COORDS = 0x0B06 + CURRENT_TEXTURE_COORDS = 0x0B03 + DEPTH_BIAS = 0x0D1F + DEPTH_BITS = 0x0D56 + DEPTH_CLEAR_VALUE = 0x0B73 + DEPTH_FUNC = 0x0B74 + DEPTH_RANGE = 0x0B70 + DEPTH_SCALE = 0x0D1E + DEPTH_WRITEMASK = 0x0B72 + DOUBLEBUFFER = 0x0C32 + DRAW_BUFFER = 0x0C01 + EDGE_FLAG = 0x0B43 + EDGE_FLAG_ARRAY_STRIDE = 0x808C + FEEDBACK_BUFFER_SIZE = 0x0DF1 + FEEDBACK_BUFFER_TYPE = 0x0DF2 + FOG_HINT = 0x0C54 + FRONT_FACE = 0x0B46 + GREEN_BIAS = 0x0D19 + GREEN_BITS = 0x0D53 + GREEN_SCALE = 0x0D18 + INDEX_ARRAY_STRIDE = 0x8086 + INDEX_ARRAY_TYPE = 0x8085 + INDEX_BITS = 0x0D51 + INDEX_CLEAR_VALUE = 0x0C20 + INDEX_MODE = 0x0C30 + INDEX_OFFSET = 0x0D13 + INDEX_SHIFT = 0x0D12 + INDEX_WRITEMASK = 0x0C21 + LIGHT_MODEL_AMBIENT = 0x0B53 + LIGHT_MODEL_COLOR_CONTROL = 0x81F8 + LIGHT_MODEL_LOCAL_VIEWER = 0x0B51 + LIGHT_MODEL_TWO_SIDE = 0x0B52 + LINE_SMOOTH_HINT = 0x0C52 + LINE_STIPPLE_PATTERN = 0x0B25 + LINE_STIPPLE_REPEAT = 0x0B26 + LINE_WIDTH = 0x0B21 + LINE_WIDTH_GRANULARITY = 0x0B23 + LINE_WIDTH_RANGE = 0x0B22 + LIST_BASE = 0x0B32 + LIST_INDEX = 0x0B33 + LIST_MODE = 0x0B30 + LOGIC_OP_MODE = 0x0BF0 + MAP1_GRID_DOMAIN = 0x0DD0 + MAP1_GRID_SEGMENTS = 0x0DD1 + MAP2_GRID_DOMAIN = 0x0DD2 + MAP2_GRID_SEGMENTS = 0x0DD3 + MAP_COLOR = 0x0D10 + MAP_STENCIL = 0x0D11 + MATRIX_MODE = 0x0BA0 + MAX_ATTRIB_STACK_DEPTH = 0x0D35 + MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B + MAX_CLIP_DISTANCES = 0x0D32 + MAX_CLIP_PLANES = 0x0D32 + MAX_EVAL_ORDER = 0x0D30 + MAX_LIGHTS = 0x0D31 + MAX_LIST_NESTING = 0x0B31 + MAX_MODELVIEW_STACK_DEPTH = 0x0D36 + MAX_NAME_STACK_DEPTH = 0x0D37 + MAX_PIXEL_MAP_TABLE = 0x0D34 + MAX_PROJECTION_STACK_DEPTH = 0x0D38 + MAX_TEXTURE_SIZE = 0x0D33 + MAX_TEXTURE_STACK_DEPTH = 0x0D39 + MAX_VIEWPORT_DIMS = 0x0D3A + MODELVIEW_MATRIX = 0x0BA6 + MODELVIEW_STACK_DEPTH = 0x0BA3 + NAME_STACK_DEPTH = 0x0D70 + NORMAL_ARRAY_STRIDE = 0x807F + NORMAL_ARRAY_TYPE = 0x807E + PACK_ALIGNMENT = 0x0D05 + PACK_LSB_FIRST = 0x0D01 + PACK_ROW_LENGTH = 0x0D02 + PACK_SKIP_PIXELS = 0x0D04 + PACK_SKIP_ROWS = 0x0D03 + PACK_SWAP_BYTES = 0x0D00 + PERSPECTIVE_CORRECTION_HINT = 0x0C50 + PIXEL_MAP_A_TO_A_SIZE = 0x0CB9 + PIXEL_MAP_B_TO_B_SIZE = 0x0CB8 + PIXEL_MAP_G_TO_G_SIZE = 0x0CB7 + PIXEL_MAP_I_TO_A_SIZE = 0x0CB5 + PIXEL_MAP_I_TO_B_SIZE = 0x0CB4 + PIXEL_MAP_I_TO_G_SIZE = 0x0CB3 + PIXEL_MAP_I_TO_I_SIZE = 0x0CB0 + PIXEL_MAP_I_TO_R_SIZE = 0x0CB2 + PIXEL_MAP_R_TO_R_SIZE = 0x0CB6 + PIXEL_MAP_S_TO_S_SIZE = 0x0CB1 + POINT_SIZE = 0x0B11 + POINT_SIZE_GRANULARITY = 0x0B13 + POINT_SIZE_RANGE = 0x0B12 + POINT_SMOOTH_HINT = 0x0C51 + POLYGON_MODE = 0x0B40 + POLYGON_OFFSET_FACTOR = 0x8038 + POLYGON_OFFSET_UNITS = 0x2A00 + POLYGON_SMOOTH_HINT = 0x0C53 + PROJECTION_MATRIX = 0x0BA7 + PROJECTION_STACK_DEPTH = 0x0BA4 + READ_BUFFER = 0x0C02 + RED_BIAS = 0x0D15 + RED_BITS = 0x0D52 + RED_SCALE = 0x0D14 + RENDER_MODE = 0x0C40 + RGBA_MODE = 0x0C31 + SCISSOR_BOX = 0x0C10 + SELECTION_BUFFER_SIZE = 0x0DF4 + SHADE_MODEL = 0x0B54 + SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23 + SMOOTH_LINE_WIDTH_RANGE = 0x0B22 + SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13 + SMOOTH_POINT_SIZE_RANGE = 0x0B12 + STENCIL_BITS = 0x0D57 + STENCIL_CLEAR_VALUE = 0x0B91 + STENCIL_FAIL = 0x0B94 + STENCIL_FUNC = 0x0B92 + STENCIL_PASS_DEPTH_FAIL = 0x0B95 + STENCIL_PASS_DEPTH_PASS = 0x0B96 + STENCIL_REF = 0x0B97 + STENCIL_VALUE_MASK = 0x0B93 + STENCIL_WRITEMASK = 0x0B98 + STEREO = 0x0C33 + SUBPIXEL_BITS = 0x0D50 + TEXTURE_BINDING_1D = 0x8068 + TEXTURE_BINDING_2D = 0x8069 + TEXTURE_BINDING_3D = 0x806A + TEXTURE_COORD_ARRAY_SIZE = 0x8088 + TEXTURE_COORD_ARRAY_STRIDE = 0x808A + TEXTURE_COORD_ARRAY_TYPE = 0x8089 + TEXTURE_MATRIX = 0x0BA8 + TEXTURE_STACK_DEPTH = 0x0BA5 + UNPACK_ALIGNMENT = 0x0CF5 + UNPACK_LSB_FIRST = 0x0CF1 + UNPACK_ROW_LENGTH = 0x0CF2 + UNPACK_SKIP_PIXELS = 0x0CF4 + UNPACK_SKIP_ROWS = 0x0CF3 + UNPACK_SWAP_BYTES = 0x0CF0 + VERTEX_ARRAY_SIZE = 0x807A + VERTEX_ARRAY_STRIDE = 0x807C + VERTEX_ARRAY_TYPE = 0x807B + VIEWPORT = 0x0BA2 + ZOOM_X = 0x0D16 + ZOOM_Y = 0x0D17 + + COLOR_ARRAY_POINTER = 0x8090 + EDGE_FLAG_ARRAY_POINTER = 0x8093 + FEEDBACK_BUFFER_POINTER = 0x0DF0 + INDEX_ARRAY_POINTER = 0x8091 + NORMAL_ARRAY_POINTER = 0x808F + SELECTION_BUFFER_POINTER = 0x0DF3 + TEXTURE_COORD_ARRAY_POINTER = 0x8092 + VERTEX_ARRAY_POINTER = 0x808E + + TEXTURE_ALPHA_SIZE = 0x805F + TEXTURE_BLUE_SIZE = 0x805E + TEXTURE_BORDER = 0x1005 + TEXTURE_BORDER_COLOR = 0x1004 + TEXTURE_COMPONENTS = 0x1003 + TEXTURE_GREEN_SIZE = 0x805D + TEXTURE_HEIGHT = 0x1001 + TEXTURE_INTENSITY_SIZE = 0x8061 + TEXTURE_INTERNAL_FORMAT = 0x1003 + TEXTURE_LUMINANCE_SIZE = 0x8060 + TEXTURE_MAG_FILTER = 0x2800 + TEXTURE_MIN_FILTER = 0x2801 + TEXTURE_PRIORITY = 0x8066 + TEXTURE_RED_SIZE = 0x805C + TEXTURE_RESIDENT = 0x8067 + TEXTURE_WIDTH = 0x1000 + TEXTURE_WRAP_S = 0x2802 + TEXTURE_WRAP_T = 0x2803 + + DONT_CARE = 0x1100 + FASTEST = 0x1101 + NICEST = 0x1102 + + FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B + GENERATE_MIPMAP_HINT = 0x8192 + TEXTURE_COMPRESSION_HINT = 0x84EF + + C3F_V3F = 0x2A24 + C4F_N3F_V3F = 0x2A26 + C4UB_V2F = 0x2A22 + C4UB_V3F = 0x2A23 + N3F_V3F = 0x2A25 + T2F_C3F_V3F = 0x2A2A + T2F_C4F_N3F_V3F = 0x2A2C + T2F_C4UB_V3F = 0x2A29 + T2F_N3F_V3F = 0x2A2B + T2F_V3F = 0x2A27 + T4F_C4F_N3F_V4F = 0x2A2D + T4F_V4F = 0x2A28 + V2F = 0x2A20 + V3F = 0x2A21 + + MODULATE = 0x2100 + REPLACE = 0x1E01 + + SEPARATE_SPECULAR_COLOR = 0x81FA + SINGLE_COLOR = 0x81F9 + + CONSTANT_ATTENUATION = 0x1207 + LINEAR_ATTENUATION = 0x1208 + POSITION = 0x1203 + QUADRATIC_ATTENUATION = 0x1209 + SPOT_CUTOFF = 0x1206 + SPOT_DIRECTION = 0x1204 + SPOT_EXPONENT = 0x1205 + + COMPILE = 0x1300 + COMPILE_AND_EXECUTE = 0x1301 + + AND = 0x1501 + AND_INVERTED = 0x1504 + AND_REVERSE = 0x1502 + CLEAR = 0x1500 + COPY = 0x1503 + COPY_INVERTED = 0x150C + EQUIV = 0x1509 + INVERT = 0x150A + NAND = 0x150E + NOOP = 0x1505 + NOR = 0x1508 + OR = 0x1507 + OR_INVERTED = 0x150D + OR_REVERSE = 0x150B + SET = 0x150F + XOR = 0x1506 + + MAP_FLUSH_EXPLICIT_BIT = 0x0010 + MAP_INVALIDATE_BUFFER_BIT = 0x0008 + MAP_INVALIDATE_RANGE_BIT = 0x0004 + MAP_READ_BIT = 0x0001 + MAP_UNSYNCHRONIZED_BIT = 0x0020 + MAP_WRITE_BIT = 0x0002 + + COLOR_INDEXES = 0x1603 + SHININESS = 0x1601 + + MODELVIEW = 0x1700 + PROJECTION = 0x1701 + TEXTURE = 0x1702 + + LINE = 0x1B01 + POINT = 0x1B00 + + FILL = 0x1B02 + + COLOR = 0x1800 + DEPTH = 0x1801 + STENCIL = 0x1802 + + ALPHA = 0x1906 + BLUE = 0x1905 + COLOR_INDEX = 0x1900 + DEPTH_COMPONENT = 0x1902 + GREEN = 0x1904 + LUMINANCE = 0x1909 + LUMINANCE_ALPHA = 0x190A + RED = 0x1903 + RGB = 0x1907 + RGBA = 0x1908 + STENCIL_INDEX = 0x1901 + + ALPHA12 = 0x803D + ALPHA16 = 0x803E + ALPHA4 = 0x803B + ALPHA8 = 0x803C + INTENSITY = 0x8049 + INTENSITY12 = 0x804C + INTENSITY16 = 0x804D + INTENSITY4 = 0x804A + INTENSITY8 = 0x804B + LUMINANCE12 = 0x8041 + LUMINANCE12_ALPHA12 = 0x8047 + LUMINANCE12_ALPHA4 = 0x8046 + LUMINANCE16 = 0x8042 + LUMINANCE16_ALPHA16 = 0x8048 + LUMINANCE4 = 0x803F + LUMINANCE4_ALPHA4 = 0x8043 + LUMINANCE6_ALPHA2 = 0x8044 + LUMINANCE8 = 0x8040 + LUMINANCE8_ALPHA8 = 0x8045 + R3_G3_B2 = 0x2A10 + RGB10 = 0x8052 + RGB10_A2 = 0x8059 + RGB12 = 0x8053 + RGB16 = 0x8054 + RGB4 = 0x804F + RGB5 = 0x8050 + RGB5_A1 = 0x8057 + RGB8 = 0x8051 + RGBA12 = 0x805A + RGBA16 = 0x805B + RGBA2 = 0x8055 + RGBA4 = 0x8056 + RGBA8 = 0x8058 + + PACK_IMAGE_HEIGHT = 0x806C + PACK_SKIP_IMAGES = 0x806B + UNPACK_IMAGE_HEIGHT = 0x806E + UNPACK_SKIP_IMAGES = 0x806D + + BITMAP = 0x1A00 + UNSIGNED_BYTE_3_3_2 = 0x8032 + UNSIGNED_INT_10_10_10_2 = 0x8036 + UNSIGNED_INT_8_8_8_8 = 0x8035 + UNSIGNED_SHORT_4_4_4_4 = 0x8033 + UNSIGNED_SHORT_5_5_5_1 = 0x8034 + + POINT_DISTANCE_ATTENUATION = 0x8129 + POINT_FADE_THRESHOLD_SIZE = 0x8128 + POINT_SIZE_MAX = 0x8127 + POINT_SIZE_MIN = 0x8126 + + LINES = 0x0001 + LINES_ADJACENCY = 0x000A + LINE_LOOP = 0x0002 + LINE_STRIP = 0x0003 + LINE_STRIP_ADJACENCY = 0x000B + POINTS = 0x0000 + POLYGON = 0x0009 + QUADS = 0x0007 + QUAD_STRIP = 0x0008 + TRIANGLES = 0x0004 + TRIANGLES_ADJACENCY = 0x000C + TRIANGLE_FAN = 0x0006 + TRIANGLE_STRIP = 0x0005 + TRIANGLE_STRIP_ADJACENCY = 0x000D + + FEEDBACK = 0x1C01 + RENDER = 0x1C00 + SELECT = 0x1C02 + + FLAT = 0x1D00 + SMOOTH = 0x1D01 + + DECR = 0x1E03 + INCR = 0x1E02 + KEEP = 0x1E00 + + EXTENSIONS = 0x1F03 + RENDERER = 0x1F01 + VENDOR = 0x1F00 + VERSION = 0x1F02 + + S = 0x2000 + T = 0x2001 + R = 0x2002 + Q = 0x2003 + + DECAL = 0x2101 + + TEXTURE_ENV_COLOR = 0x2201 + TEXTURE_ENV_MODE = 0x2200 + + TEXTURE_ENV = 0x2300 + + EYE_LINEAR = 0x2400 + OBJECT_LINEAR = 0x2401 + SPHERE_MAP = 0x2402 + + EYE_PLANE = 0x2502 + OBJECT_PLANE = 0x2501 + TEXTURE_GEN_MODE = 0x2500 + + NEAREST = 0x2600 + + LINEAR_MIPMAP_LINEAR = 0x2703 + LINEAR_MIPMAP_NEAREST = 0x2701 + NEAREST_MIPMAP_LINEAR = 0x2702 + NEAREST_MIPMAP_NEAREST = 0x2700 + + GENERATE_MIPMAP = 0x8191 + TEXTURE_WRAP_R = 0x8072 + + PROXY_TEXTURE_1D = 0x8063 + PROXY_TEXTURE_2D = 0x8064 + PROXY_TEXTURE_3D = 0x8070 + TEXTURE_3D = 0x806F + TEXTURE_BASE_LEVEL = 0x813C + TEXTURE_MAX_LEVEL = 0x813D + TEXTURE_MAX_LOD = 0x813B + TEXTURE_MIN_LOD = 0x813A + + CLAMP = 0x2900 + CLAMP_TO_BORDER = 0x812D + CLAMP_TO_EDGE = 0x812F + REPEAT = 0x2901 + + SYNC_FLUSH_COMMANDS_BIT = 0x00000001 + INVALID_INDEX = 0xFFFFFFFF + TIMEOUT_IGNORED = 0xFFFFFFFFFFFFFFFF + CONSTANT_COLOR = 0x8001 + ONE_MINUS_CONSTANT_COLOR = 0x8002 + CONSTANT_ALPHA = 0x8003 + ONE_MINUS_CONSTANT_ALPHA = 0x8004 + FUNC_ADD = 0x8006 + MIN = 0x8007 + MAX = 0x8008 + BLEND_EQUATION_RGB = 0x8009 + FUNC_SUBTRACT = 0x800A + FUNC_REVERSE_SUBTRACT = 0x800B + RESCALE_NORMAL = 0x803A + TEXTURE_DEPTH = 0x8071 + MAX_3D_TEXTURE_SIZE = 0x8073 + MULTISAMPLE = 0x809D + SAMPLE_ALPHA_TO_COVERAGE = 0x809E + SAMPLE_ALPHA_TO_ONE = 0x809F + SAMPLE_COVERAGE = 0x80A0 + SAMPLE_BUFFERS = 0x80A8 + SAMPLES = 0x80A9 + SAMPLE_COVERAGE_VALUE = 0x80AA + SAMPLE_COVERAGE_INVERT = 0x80AB + BLEND_DST_RGB = 0x80C8 + BLEND_SRC_RGB = 0x80C9 + BLEND_DST_ALPHA = 0x80CA + BLEND_SRC_ALPHA = 0x80CB + BGR = 0x80E0 + BGRA = 0x80E1 + MAX_ELEMENTS_VERTICES = 0x80E8 + MAX_ELEMENTS_INDICES = 0x80E9 + DEPTH_COMPONENT16 = 0x81A5 + DEPTH_COMPONENT24 = 0x81A6 + DEPTH_COMPONENT32 = 0x81A7 + FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210 + FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211 + FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212 + FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213 + FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214 + FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215 + FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216 + FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217 + FRAMEBUFFER_DEFAULT = 0x8218 + FRAMEBUFFER_UNDEFINED = 0x8219 + DEPTH_STENCIL_ATTACHMENT = 0x821A + MAJOR_VERSION = 0x821B + MINOR_VERSION = 0x821C + NUM_EXTENSIONS = 0x821D + CONTEXT_FLAGS = 0x821E + INDEX = 0x8222 + COMPRESSED_RED = 0x8225 + COMPRESSED_RG = 0x8226 + RG = 0x8227 + RG_INTEGER = 0x8228 + R8 = 0x8229 + R16 = 0x822A + RG8 = 0x822B + RG16 = 0x822C + R16F = 0x822D + R32F = 0x822E + RG16F = 0x822F + RG32F = 0x8230 + R8I = 0x8231 + R8UI = 0x8232 + R16I = 0x8233 + R16UI = 0x8234 + R32I = 0x8235 + R32UI = 0x8236 + RG8I = 0x8237 + RG8UI = 0x8238 + RG16I = 0x8239 + RG16UI = 0x823A + RG32I = 0x823B + RG32UI = 0x823C + UNSIGNED_BYTE_2_3_3_REV = 0x8362 + UNSIGNED_SHORT_5_6_5 = 0x8363 + UNSIGNED_SHORT_5_6_5_REV = 0x8364 + UNSIGNED_SHORT_4_4_4_4_REV = 0x8365 + UNSIGNED_SHORT_1_5_5_5_REV = 0x8366 + UNSIGNED_INT_8_8_8_8_REV = 0x8367 + UNSIGNED_INT_2_10_10_10_REV = 0x8368 + MIRRORED_REPEAT = 0x8370 + FOG_COORDINATE_SOURCE = 0x8450 + FOG_COORD_SRC = 0x8450 + FOG_COORDINATE = 0x8451 + FOG_COORD = 0x8451 + FRAGMENT_DEPTH = 0x8452 + CURRENT_FOG_COORDINATE = 0x8453 + CURRENT_FOG_COORD = 0x8453 + FOG_COORDINATE_ARRAY_TYPE = 0x8454 + FOG_COORD_ARRAY_TYPE = 0x8454 + FOG_COORDINATE_ARRAY_STRIDE = 0x8455 + FOG_COORD_ARRAY_STRIDE = 0x8455 + FOG_COORDINATE_ARRAY_POINTER = 0x8456 + FOG_COORD_ARRAY_POINTER = 0x8456 + FOG_COORDINATE_ARRAY = 0x8457 + FOG_COORD_ARRAY = 0x8457 + COLOR_SUM = 0x8458 + CURRENT_SECONDARY_COLOR = 0x8459 + SECONDARY_COLOR_ARRAY_SIZE = 0x845A + SECONDARY_COLOR_ARRAY_TYPE = 0x845B + SECONDARY_COLOR_ARRAY_STRIDE = 0x845C + SECONDARY_COLOR_ARRAY_POINTER = 0x845D + SECONDARY_COLOR_ARRAY = 0x845E + CURRENT_RASTER_SECONDARY_COLOR = 0x845F + TEXTURE0 = 0x84C0 + TEXTURE1 = 0x84C1 + TEXTURE2 = 0x84C2 + TEXTURE3 = 0x84C3 + TEXTURE4 = 0x84C4 + TEXTURE5 = 0x84C5 + TEXTURE6 = 0x84C6 + TEXTURE7 = 0x84C7 + TEXTURE8 = 0x84C8 + TEXTURE9 = 0x84C9 + TEXTURE10 = 0x84CA + TEXTURE11 = 0x84CB + TEXTURE12 = 0x84CC + TEXTURE13 = 0x84CD + TEXTURE14 = 0x84CE + TEXTURE15 = 0x84CF + TEXTURE16 = 0x84D0 + TEXTURE17 = 0x84D1 + TEXTURE18 = 0x84D2 + TEXTURE19 = 0x84D3 + TEXTURE20 = 0x84D4 + TEXTURE21 = 0x84D5 + TEXTURE22 = 0x84D6 + TEXTURE23 = 0x84D7 + TEXTURE24 = 0x84D8 + TEXTURE25 = 0x84D9 + TEXTURE26 = 0x84DA + TEXTURE27 = 0x84DB + TEXTURE28 = 0x84DC + TEXTURE29 = 0x84DD + TEXTURE30 = 0x84DE + TEXTURE31 = 0x84DF + ACTIVE_TEXTURE = 0x84E0 + CLIENT_ACTIVE_TEXTURE = 0x84E1 + MAX_TEXTURE_UNITS = 0x84E2 + TRANSPOSE_MODELVIEW_MATRIX = 0x84E3 + TRANSPOSE_PROJECTION_MATRIX = 0x84E4 + TRANSPOSE_TEXTURE_MATRIX = 0x84E5 + TRANSPOSE_COLOR_MATRIX = 0x84E6 + SUBTRACT = 0x84E7 + MAX_RENDERBUFFER_SIZE = 0x84E8 + COMPRESSED_ALPHA = 0x84E9 + COMPRESSED_LUMINANCE = 0x84EA + COMPRESSED_LUMINANCE_ALPHA = 0x84EB + COMPRESSED_INTENSITY = 0x84EC + COMPRESSED_RGB = 0x84ED + COMPRESSED_RGBA = 0x84EE + TEXTURE_RECTANGLE = 0x84F5 + TEXTURE_BINDING_RECTANGLE = 0x84F6 + PROXY_TEXTURE_RECTANGLE = 0x84F7 + MAX_RECTANGLE_TEXTURE_SIZE = 0x84F8 + DEPTH_STENCIL = 0x84F9 + UNSIGNED_INT_24_8 = 0x84FA + MAX_TEXTURE_LOD_BIAS = 0x84FD + TEXTURE_FILTER_CONTROL = 0x8500 + TEXTURE_LOD_BIAS = 0x8501 + INCR_WRAP = 0x8507 + DECR_WRAP = 0x8508 + NORMAL_MAP = 0x8511 + REFLECTION_MAP = 0x8512 + TEXTURE_CUBE_MAP = 0x8513 + TEXTURE_BINDING_CUBE_MAP = 0x8514 + TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515 + TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516 + TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517 + TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518 + TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519 + TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A + PROXY_TEXTURE_CUBE_MAP = 0x851B + MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C + COMBINE = 0x8570 + COMBINE_RGB = 0x8571 + COMBINE_ALPHA = 0x8572 + RGB_SCALE = 0x8573 + ADD_SIGNED = 0x8574 + INTERPOLATE = 0x8575 + CONSTANT = 0x8576 + PRIMARY_COLOR = 0x8577 + PREVIOUS = 0x8578 + SOURCE0_RGB = 0x8580 + SRC0_RGB = 0x8580 + SOURCE1_RGB = 0x8581 + SRC1_RGB = 0x8581 + SOURCE2_RGB = 0x8582 + SRC2_RGB = 0x8582 + SOURCE0_ALPHA = 0x8588 + SRC0_ALPHA = 0x8588 + SOURCE1_ALPHA = 0x8589 + SRC1_ALPHA = 0x8589 + SOURCE2_ALPHA = 0x858A + SRC2_ALPHA = 0x858A + OPERAND0_RGB = 0x8590 + OPERAND1_RGB = 0x8591 + OPERAND2_RGB = 0x8592 + OPERAND0_ALPHA = 0x8598 + OPERAND1_ALPHA = 0x8599 + OPERAND2_ALPHA = 0x859A + VERTEX_ARRAY_BINDING = 0x85B5 + VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622 + VERTEX_ATTRIB_ARRAY_SIZE = 0x8623 + VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624 + VERTEX_ATTRIB_ARRAY_TYPE = 0x8625 + CURRENT_VERTEX_ATTRIB = 0x8626 + VERTEX_PROGRAM_POINT_SIZE = 0x8642 + PROGRAM_POINT_SIZE = 0x8642 + VERTEX_PROGRAM_TWO_SIDE = 0x8643 + VERTEX_ATTRIB_ARRAY_POINTER = 0x8645 + DEPTH_CLAMP = 0x864F + TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0 + TEXTURE_COMPRESSED = 0x86A1 + NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2 + COMPRESSED_TEXTURE_FORMATS = 0x86A3 + DOT3_RGB = 0x86AE + DOT3_RGBA = 0x86AF + BUFFER_SIZE = 0x8764 + BUFFER_USAGE = 0x8765 + STENCIL_BACK_FUNC = 0x8800 + STENCIL_BACK_FAIL = 0x8801 + STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802 + STENCIL_BACK_PASS_DEPTH_PASS = 0x8803 + RGBA32F = 0x8814 + RGB32F = 0x8815 + RGBA16F = 0x881A + RGB16F = 0x881B + MAX_DRAW_BUFFERS = 0x8824 + DRAW_BUFFER0 = 0x8825 + DRAW_BUFFER1 = 0x8826 + DRAW_BUFFER2 = 0x8827 + DRAW_BUFFER3 = 0x8828 + DRAW_BUFFER4 = 0x8829 + DRAW_BUFFER5 = 0x882A + DRAW_BUFFER6 = 0x882B + DRAW_BUFFER7 = 0x882C + DRAW_BUFFER8 = 0x882D + DRAW_BUFFER9 = 0x882E + DRAW_BUFFER10 = 0x882F + DRAW_BUFFER11 = 0x8830 + DRAW_BUFFER12 = 0x8831 + DRAW_BUFFER13 = 0x8832 + DRAW_BUFFER14 = 0x8833 + DRAW_BUFFER15 = 0x8834 + BLEND_EQUATION_ALPHA = 0x883D + TEXTURE_DEPTH_SIZE = 0x884A + DEPTH_TEXTURE_MODE = 0x884B + TEXTURE_COMPARE_MODE = 0x884C + TEXTURE_COMPARE_FUNC = 0x884D + COMPARE_R_TO_TEXTURE = 0x884E + COMPARE_REF_TO_TEXTURE = 0x884E + TEXTURE_CUBE_MAP_SEAMLESS = 0x884F + POINT_SPRITE = 0x8861 + COORD_REPLACE = 0x8862 + QUERY_COUNTER_BITS = 0x8864 + CURRENT_QUERY = 0x8865 + QUERY_RESULT = 0x8866 + QUERY_RESULT_AVAILABLE = 0x8867 + MAX_VERTEX_ATTRIBS = 0x8869 + VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A + MAX_TEXTURE_COORDS = 0x8871 + MAX_TEXTURE_IMAGE_UNITS = 0x8872 + ARRAY_BUFFER = 0x8892 + ELEMENT_ARRAY_BUFFER = 0x8893 + ARRAY_BUFFER_BINDING = 0x8894 + ELEMENT_ARRAY_BUFFER_BINDING = 0x8895 + VERTEX_ARRAY_BUFFER_BINDING = 0x8896 + NORMAL_ARRAY_BUFFER_BINDING = 0x8897 + COLOR_ARRAY_BUFFER_BINDING = 0x8898 + INDEX_ARRAY_BUFFER_BINDING = 0x8899 + TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A + EDGE_FLAG_ARRAY_BUFFER_BINDING = 0x889B + SECONDARY_COLOR_ARRAY_BUFFER_BINDING = 0x889C + FOG_COORDINATE_ARRAY_BUFFER_BINDING = 0x889D + FOG_COORD_ARRAY_BUFFER_BINDING = 0x889D + WEIGHT_ARRAY_BUFFER_BINDING = 0x889E + VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F + READ_ONLY = 0x88B8 + WRITE_ONLY = 0x88B9 + READ_WRITE = 0x88BA + BUFFER_ACCESS = 0x88BB + BUFFER_MAPPED = 0x88BC + BUFFER_MAP_POINTER = 0x88BD + STREAM_DRAW = 0x88E0 + STREAM_READ = 0x88E1 + STREAM_COPY = 0x88E2 + STATIC_DRAW = 0x88E4 + STATIC_READ = 0x88E5 + STATIC_COPY = 0x88E6 + DYNAMIC_DRAW = 0x88E8 + DYNAMIC_READ = 0x88E9 + DYNAMIC_COPY = 0x88EA + PIXEL_PACK_BUFFER = 0x88EB + PIXEL_UNPACK_BUFFER = 0x88EC + PIXEL_PACK_BUFFER_BINDING = 0x88ED + PIXEL_UNPACK_BUFFER_BINDING = 0x88EF + DEPTH24_STENCIL8 = 0x88F0 + TEXTURE_STENCIL_SIZE = 0x88F1 + VERTEX_ATTRIB_ARRAY_INTEGER = 0x88FD + MAX_ARRAY_TEXTURE_LAYERS = 0x88FF + MIN_PROGRAM_TEXEL_OFFSET = 0x8904 + MAX_PROGRAM_TEXEL_OFFSET = 0x8905 + SAMPLES_PASSED = 0x8914 + GEOMETRY_VERTICES_OUT = 0x8916 + GEOMETRY_INPUT_TYPE = 0x8917 + GEOMETRY_OUTPUT_TYPE = 0x8918 + CLAMP_VERTEX_COLOR = 0x891A + CLAMP_FRAGMENT_COLOR = 0x891B + CLAMP_READ_COLOR = 0x891C + FIXED_ONLY = 0x891D + UNIFORM_BUFFER = 0x8A11 + UNIFORM_BUFFER_BINDING = 0x8A28 + UNIFORM_BUFFER_START = 0x8A29 + UNIFORM_BUFFER_SIZE = 0x8A2A + MAX_VERTEX_UNIFORM_BLOCKS = 0x8A2B + MAX_GEOMETRY_UNIFORM_BLOCKS = 0x8A2C + MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8A2D + MAX_COMBINED_UNIFORM_BLOCKS = 0x8A2E + MAX_UNIFORM_BUFFER_BINDINGS = 0x8A2F + MAX_UNIFORM_BLOCK_SIZE = 0x8A30 + MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31 + MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 0x8A32 + MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33 + UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8A34 + ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35 + ACTIVE_UNIFORM_BLOCKS = 0x8A36 + UNIFORM_TYPE = 0x8A37 + UNIFORM_SIZE = 0x8A38 + UNIFORM_NAME_LENGTH = 0x8A39 + UNIFORM_BLOCK_INDEX = 0x8A3A + UNIFORM_OFFSET = 0x8A3B + UNIFORM_ARRAY_STRIDE = 0x8A3C + UNIFORM_MATRIX_STRIDE = 0x8A3D + UNIFORM_IS_ROW_MAJOR = 0x8A3E + UNIFORM_BLOCK_BINDING = 0x8A3F + UNIFORM_BLOCK_DATA_SIZE = 0x8A40 + UNIFORM_BLOCK_NAME_LENGTH = 0x8A41 + UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8A42 + UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43 + UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44 + UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 0x8A45 + UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46 + FRAGMENT_SHADER = 0x8B30 + VERTEX_SHADER = 0x8B31 + MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49 + MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A + MAX_VARYING_FLOATS = 0x8B4B + MAX_VARYING_COMPONENTS = 0x8B4B + MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C + MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D + SHADER_TYPE = 0x8B4F + FLOAT_VEC2 = 0x8B50 + FLOAT_VEC3 = 0x8B51 + FLOAT_VEC4 = 0x8B52 + INT_VEC2 = 0x8B53 + INT_VEC3 = 0x8B54 + INT_VEC4 = 0x8B55 + BOOL = 0x8B56 + BOOL_VEC2 = 0x8B57 + BOOL_VEC3 = 0x8B58 + BOOL_VEC4 = 0x8B59 + FLOAT_MAT2 = 0x8B5A + FLOAT_MAT3 = 0x8B5B + FLOAT_MAT4 = 0x8B5C + SAMPLER_1D = 0x8B5D + SAMPLER_2D = 0x8B5E + SAMPLER_3D = 0x8B5F + SAMPLER_CUBE = 0x8B60 + SAMPLER_1D_SHADOW = 0x8B61 + SAMPLER_2D_SHADOW = 0x8B62 + SAMPLER_2D_RECT = 0x8B63 + SAMPLER_2D_RECT_SHADOW = 0x8B64 + FLOAT_MAT2x3 = 0x8B65 + FLOAT_MAT2x4 = 0x8B66 + FLOAT_MAT3x2 = 0x8B67 + FLOAT_MAT3x4 = 0x8B68 + FLOAT_MAT4x2 = 0x8B69 + FLOAT_MAT4x3 = 0x8B6A + DELETE_STATUS = 0x8B80 + COMPILE_STATUS = 0x8B81 + LINK_STATUS = 0x8B82 + VALIDATE_STATUS = 0x8B83 + INFO_LOG_LENGTH = 0x8B84 + ATTACHED_SHADERS = 0x8B85 + ACTIVE_UNIFORMS = 0x8B86 + ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87 + SHADER_SOURCE_LENGTH = 0x8B88 + ACTIVE_ATTRIBUTES = 0x8B89 + ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A + SHADING_LANGUAGE_VERSION = 0x8B8C + CURRENT_PROGRAM = 0x8B8D + TEXTURE_RED_TYPE = 0x8C10 + TEXTURE_GREEN_TYPE = 0x8C11 + TEXTURE_BLUE_TYPE = 0x8C12 + TEXTURE_ALPHA_TYPE = 0x8C13 + TEXTURE_LUMINANCE_TYPE = 0x8C14 + TEXTURE_INTENSITY_TYPE = 0x8C15 + TEXTURE_DEPTH_TYPE = 0x8C16 + UNSIGNED_NORMALIZED = 0x8C17 + TEXTURE_1D_ARRAY = 0x8C18 + PROXY_TEXTURE_1D_ARRAY = 0x8C19 + TEXTURE_2D_ARRAY = 0x8C1A + PROXY_TEXTURE_2D_ARRAY = 0x8C1B + TEXTURE_BINDING_1D_ARRAY = 0x8C1C + TEXTURE_BINDING_2D_ARRAY = 0x8C1D + MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = 0x8C29 + TEXTURE_BUFFER = 0x8C2A + MAX_TEXTURE_BUFFER_SIZE = 0x8C2B + TEXTURE_BINDING_BUFFER = 0x8C2C + TEXTURE_BUFFER_DATA_STORE_BINDING = 0x8C2D + R11F_G11F_B10F = 0x8C3A + UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B + RGB9_E5 = 0x8C3D + UNSIGNED_INT_5_9_9_9_REV = 0x8C3E + TEXTURE_SHARED_SIZE = 0x8C3F + SRGB = 0x8C40 + SRGB8 = 0x8C41 + SRGB_ALPHA = 0x8C42 + SRGB8_ALPHA8 = 0x8C43 + SLUMINANCE_ALPHA = 0x8C44 + SLUMINANCE8_ALPHA8 = 0x8C45 + SLUMINANCE = 0x8C46 + SLUMINANCE8 = 0x8C47 + COMPRESSED_SRGB = 0x8C48 + COMPRESSED_SRGB_ALPHA = 0x8C49 + COMPRESSED_SLUMINANCE = 0x8C4A + COMPRESSED_SLUMINANCE_ALPHA = 0x8C4B + TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76 + TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F + MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80 + TRANSFORM_FEEDBACK_VARYINGS = 0x8C83 + TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84 + TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85 + PRIMITIVES_GENERATED = 0x8C87 + TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88 + RASTERIZER_DISCARD = 0x8C89 + MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A + MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B + INTERLEAVED_ATTRIBS = 0x8C8C + SEPARATE_ATTRIBS = 0x8C8D + TRANSFORM_FEEDBACK_BUFFER = 0x8C8E + TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F + POINT_SPRITE_COORD_ORIGIN = 0x8CA0 + LOWER_LEFT = 0x8CA1 + UPPER_LEFT = 0x8CA2 + STENCIL_BACK_REF = 0x8CA3 + STENCIL_BACK_VALUE_MASK = 0x8CA4 + STENCIL_BACK_WRITEMASK = 0x8CA5 + DRAW_FRAMEBUFFER_BINDING = 0x8CA6 + FRAMEBUFFER_BINDING = 0x8CA6 + RENDERBUFFER_BINDING = 0x8CA7 + READ_FRAMEBUFFER = 0x8CA8 + DRAW_FRAMEBUFFER = 0x8CA9 + READ_FRAMEBUFFER_BINDING = 0x8CAA + RENDERBUFFER_SAMPLES = 0x8CAB + DEPTH_COMPONENT32F = 0x8CAC + DEPTH32F_STENCIL8 = 0x8CAD + FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0 + FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1 + FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2 + FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3 + FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4 + FRAMEBUFFER_COMPLETE = 0x8CD5 + FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6 + FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7 + FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB + FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC + FRAMEBUFFER_UNSUPPORTED = 0x8CDD + MAX_COLOR_ATTACHMENTS = 0x8CDF + COLOR_ATTACHMENT0 = 0x8CE0 + COLOR_ATTACHMENT1 = 0x8CE1 + COLOR_ATTACHMENT2 = 0x8CE2 + COLOR_ATTACHMENT3 = 0x8CE3 + COLOR_ATTACHMENT4 = 0x8CE4 + COLOR_ATTACHMENT5 = 0x8CE5 + COLOR_ATTACHMENT6 = 0x8CE6 + COLOR_ATTACHMENT7 = 0x8CE7 + COLOR_ATTACHMENT8 = 0x8CE8 + COLOR_ATTACHMENT9 = 0x8CE9 + COLOR_ATTACHMENT10 = 0x8CEA + COLOR_ATTACHMENT11 = 0x8CEB + COLOR_ATTACHMENT12 = 0x8CEC + COLOR_ATTACHMENT13 = 0x8CED + COLOR_ATTACHMENT14 = 0x8CEE + COLOR_ATTACHMENT15 = 0x8CEF + DEPTH_ATTACHMENT = 0x8D00 + STENCIL_ATTACHMENT = 0x8D20 + FRAMEBUFFER = 0x8D40 + RENDERBUFFER = 0x8D41 + RENDERBUFFER_WIDTH = 0x8D42 + RENDERBUFFER_HEIGHT = 0x8D43 + RENDERBUFFER_INTERNAL_FORMAT = 0x8D44 + STENCIL_INDEX1 = 0x8D46 + STENCIL_INDEX4 = 0x8D47 + STENCIL_INDEX8 = 0x8D48 + STENCIL_INDEX16 = 0x8D49 + RENDERBUFFER_RED_SIZE = 0x8D50 + RENDERBUFFER_GREEN_SIZE = 0x8D51 + RENDERBUFFER_BLUE_SIZE = 0x8D52 + RENDERBUFFER_ALPHA_SIZE = 0x8D53 + RENDERBUFFER_DEPTH_SIZE = 0x8D54 + RENDERBUFFER_STENCIL_SIZE = 0x8D55 + FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56 + MAX_SAMPLES = 0x8D57 + RGBA32UI = 0x8D70 + RGB32UI = 0x8D71 + RGBA16UI = 0x8D76 + RGB16UI = 0x8D77 + RGBA8UI = 0x8D7C + RGB8UI = 0x8D7D + RGBA32I = 0x8D82 + RGB32I = 0x8D83 + RGBA16I = 0x8D88 + RGB16I = 0x8D89 + RGBA8I = 0x8D8E + RGB8I = 0x8D8F + RED_INTEGER = 0x8D94 + GREEN_INTEGER = 0x8D95 + BLUE_INTEGER = 0x8D96 + ALPHA_INTEGER = 0x8D97 + RGB_INTEGER = 0x8D98 + RGBA_INTEGER = 0x8D99 + BGR_INTEGER = 0x8D9A + BGRA_INTEGER = 0x8D9B + FRAMEBUFFER_ATTACHMENT_LAYERED = 0x8DA7 + FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = 0x8DA8 + FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD + FRAMEBUFFER_SRGB = 0x8DB9 + COMPRESSED_RED_RGTC1 = 0x8DBB + COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC + COMPRESSED_RG_RGTC2 = 0x8DBD + COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE + SAMPLER_1D_ARRAY = 0x8DC0 + SAMPLER_2D_ARRAY = 0x8DC1 + SAMPLER_BUFFER = 0x8DC2 + SAMPLER_1D_ARRAY_SHADOW = 0x8DC3 + SAMPLER_2D_ARRAY_SHADOW = 0x8DC4 + SAMPLER_CUBE_SHADOW = 0x8DC5 + UNSIGNED_INT_VEC2 = 0x8DC6 + UNSIGNED_INT_VEC3 = 0x8DC7 + UNSIGNED_INT_VEC4 = 0x8DC8 + INT_SAMPLER_1D = 0x8DC9 + INT_SAMPLER_2D = 0x8DCA + INT_SAMPLER_3D = 0x8DCB + INT_SAMPLER_CUBE = 0x8DCC + INT_SAMPLER_2D_RECT = 0x8DCD + INT_SAMPLER_1D_ARRAY = 0x8DCE + INT_SAMPLER_2D_ARRAY = 0x8DCF + INT_SAMPLER_BUFFER = 0x8DD0 + UNSIGNED_INT_SAMPLER_1D = 0x8DD1 + UNSIGNED_INT_SAMPLER_2D = 0x8DD2 + UNSIGNED_INT_SAMPLER_3D = 0x8DD3 + UNSIGNED_INT_SAMPLER_CUBE = 0x8DD4 + UNSIGNED_INT_SAMPLER_2D_RECT = 0x8DD5 + UNSIGNED_INT_SAMPLER_1D_ARRAY = 0x8DD6 + UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8DD7 + UNSIGNED_INT_SAMPLER_BUFFER = 0x8DD8 + GEOMETRY_SHADER = 0x8DD9 + MAX_GEOMETRY_UNIFORM_COMPONENTS = 0x8DDF + MAX_GEOMETRY_OUTPUT_VERTICES = 0x8DE0 + MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = 0x8DE1 + QUERY_WAIT = 0x8E13 + QUERY_NO_WAIT = 0x8E14 + QUERY_BY_REGION_WAIT = 0x8E15 + QUERY_BY_REGION_NO_WAIT = 0x8E16 + QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = 0x8E4C + FIRST_VERTEX_CONVENTION = 0x8E4D + LAST_VERTEX_CONVENTION = 0x8E4E + PROVOKING_VERTEX = 0x8E4F + SAMPLE_POSITION = 0x8E50 + SAMPLE_MASK = 0x8E51 + SAMPLE_MASK_VALUE = 0x8E52 + MAX_SAMPLE_MASK_WORDS = 0x8E59 + COPY_READ_BUFFER = 0x8F36 + COPY_WRITE_BUFFER = 0x8F37 + R8_SNORM = 0x8F94 + RG8_SNORM = 0x8F95 + RGB8_SNORM = 0x8F96 + RGBA8_SNORM = 0x8F97 + R16_SNORM = 0x8F98 + RG16_SNORM = 0x8F99 + RGB16_SNORM = 0x8F9A + RGBA16_SNORM = 0x8F9B + SIGNED_NORMALIZED = 0x8F9C + PRIMITIVE_RESTART = 0x8F9D + PRIMITIVE_RESTART_INDEX = 0x8F9E + TEXTURE_2D_MULTISAMPLE = 0x9100 + PROXY_TEXTURE_2D_MULTISAMPLE = 0x9101 + TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9102 + PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9103 + TEXTURE_BINDING_2D_MULTISAMPLE = 0x9104 + TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = 0x9105 + TEXTURE_SAMPLES = 0x9106 + TEXTURE_FIXED_SAMPLE_LOCATIONS = 0x9107 + SAMPLER_2D_MULTISAMPLE = 0x9108 + INT_SAMPLER_2D_MULTISAMPLE = 0x9109 + UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = 0x910A + SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910B + INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910C + UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910D + MAX_COLOR_TEXTURE_SAMPLES = 0x910E + MAX_DEPTH_TEXTURE_SAMPLES = 0x910F + MAX_INTEGER_SAMPLES = 0x9110 + MAX_SERVER_WAIT_TIMEOUT = 0x9111 + OBJECT_TYPE = 0x9112 + SYNC_CONDITION = 0x9113 + SYNC_STATUS = 0x9114 + SYNC_FLAGS = 0x9115 + SYNC_FENCE = 0x9116 + SYNC_GPU_COMMANDS_COMPLETE = 0x9117 + UNSIGNALED = 0x9118 + SIGNALED = 0x9119 + ALREADY_SIGNALED = 0x911A + TIMEOUT_EXPIRED = 0x911B + CONDITION_SATISFIED = 0x911C + WAIT_FAILED = 0x911D + BUFFER_ACCESS_FLAGS = 0x911F + BUFFER_MAP_LENGTH = 0x9120 + BUFFER_MAP_OFFSET = 0x9121 + MAX_VERTEX_OUTPUT_COMPONENTS = 0x9122 + MAX_GEOMETRY_INPUT_COMPONENTS = 0x9123 + MAX_GEOMETRY_OUTPUT_COMPONENTS = 0x9124 + MAX_FRAGMENT_INPUT_COMPONENTS = 0x9125 + CONTEXT_PROFILE_MASK = 0x9126 +) + +// https://www.opengl.org/sdk/docs/man3/xhtml/glViewport.xml +func (gl *GL) Viewport(x, y, width, height int) { + C.gl3_2compat_glViewport(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// DepthRange specifies the mapping of depth values from normalized device +// coordinates to window coordinates. +// +// Parameter nearVal specifies the mapping of the near clipping plane to window +// coordinates (defaults to 0), while farVal specifies the mapping of the far +// clipping plane to window coordinates (defaults to 1). +// +// After clipping and division by w, depth coordinates range from -1 to 1, +// corresponding to the near and far clipping planes. DepthRange specifies a +// linear mapping of the normalized depth coordinates in this range to window +// depth coordinates. Regardless of the actual depth buffer implementation, +// window coordinate depth values are treated as though they range from 0 through 1 +// (like color components). Thus, the values accepted by DepthRange are both +// clamped to this range before they are accepted. +// +// The default setting of (0, 1) maps the near plane to 0 and the far plane to 1. +// With this mapping, the depth buffer range is fully utilized. +// +// It is not necessary that nearVal be less than farVal. Reverse mappings such as +// nearVal 1, and farVal 0 are acceptable. +// +// GL.INVALID_OPERATION is generated if DepthRange is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) DepthRange(nearVal, farVal float64) { + C.gl3_2compat_glDepthRange(gl.funcs, C.GLdouble(nearVal), C.GLdouble(farVal)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsEnabled.xml +func (gl *GL) IsEnabled(cap glbase.Enum) bool { + glresult := C.gl3_2compat_glIsEnabled(gl.funcs, C.GLenum(cap)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexLevelParameteriv.xml +func (gl *GL) GetTexLevelParameteriv(target glbase.Enum, level int, pname glbase.Enum, params []int32) { + C.gl3_2compat_glGetTexLevelParameteriv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexLevelParameterfv.xml +func (gl *GL) GetTexLevelParameterfv(target glbase.Enum, level int, pname glbase.Enum, params []float32) { + C.gl3_2compat_glGetTexLevelParameterfv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexParameteriv.xml +func (gl *GL) GetTexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_2compat_glGetTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexParameterfv.xml +func (gl *GL) GetTexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl3_2compat_glGetTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexImage.xml +func (gl *GL) GetTexImage(target glbase.Enum, level int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glGetTexImage(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetIntegerv.xml +func (gl *GL) GetIntegerv(pname glbase.Enum, params []int32) { + C.gl3_2compat_glGetIntegerv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetFloatv.xml +func (gl *GL) GetFloatv(pname glbase.Enum, params []float32) { + C.gl3_2compat_glGetFloatv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetError.xml +func (gl *GL) GetError() glbase.Enum { + glresult := C.gl3_2compat_glGetError(gl.funcs) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetDoublev.xml +func (gl *GL) GetDoublev(pname glbase.Enum, params []float64) { + C.gl3_2compat_glGetDoublev(gl.funcs, C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetBooleanv.xml +func (gl *GL) GetBooleanv(pname glbase.Enum, params []bool) { + C.gl3_2compat_glGetBooleanv(gl.funcs, C.GLenum(pname), (*C.GLboolean)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glReadPixels.xml +func (gl *GL) ReadPixels(x, y, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glReadPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glReadBuffer.xml +func (gl *GL) ReadBuffer(mode glbase.Enum) { + C.gl3_2compat_glReadBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPixelStorei.xml +func (gl *GL) PixelStorei(pname glbase.Enum, param int32) { + C.gl3_2compat_glPixelStorei(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPixelStoref.xml +func (gl *GL) PixelStoref(pname glbase.Enum, param float32) { + C.gl3_2compat_glPixelStoref(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDepthFunc.xml +func (gl *GL) DepthFunc(glfunc glbase.Enum) { + C.gl3_2compat_glDepthFunc(gl.funcs, C.GLenum(glfunc)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilOp.xml +func (gl *GL) StencilOp(fail, zfail, zpass glbase.Enum) { + C.gl3_2compat_glStencilOp(gl.funcs, C.GLenum(fail), C.GLenum(zfail), C.GLenum(zpass)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilFunc.xml +func (gl *GL) StencilFunc(glfunc glbase.Enum, ref int32, mask uint32) { + C.gl3_2compat_glStencilFunc(gl.funcs, C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLogicOp.xml +func (gl *GL) LogicOp(opcode glbase.Enum) { + C.gl3_2compat_glLogicOp(gl.funcs, C.GLenum(opcode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlendFunc.xml +func (gl *GL) BlendFunc(sfactor, dfactor glbase.Enum) { + C.gl3_2compat_glBlendFunc(gl.funcs, C.GLenum(sfactor), C.GLenum(dfactor)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFlush.xml +func (gl *GL) Flush() { + C.gl3_2compat_glFlush(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFinish.xml +func (gl *GL) Finish() { + C.gl3_2compat_glFinish(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEnable.xml +func (gl *GL) Enable(cap glbase.Enum) { + C.gl3_2compat_glEnable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDisable.xml +func (gl *GL) Disable(cap glbase.Enum) { + C.gl3_2compat_glDisable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDepthMask.xml +func (gl *GL) DepthMask(flag bool) { + C.gl3_2compat_glDepthMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorMask.xml +func (gl *GL) ColorMask(red, green, blue, alpha bool) { + C.gl3_2compat_glColorMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&red)), *(*C.GLboolean)(unsafe.Pointer(&green)), *(*C.GLboolean)(unsafe.Pointer(&blue)), *(*C.GLboolean)(unsafe.Pointer(&alpha))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilMask.xml +func (gl *GL) StencilMask(mask uint32) { + C.gl3_2compat_glStencilMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearDepth.xml +func (gl *GL) ClearDepth(depth float64) { + C.gl3_2compat_glClearDepth(gl.funcs, C.GLdouble(depth)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearStencil.xml +func (gl *GL) ClearStencil(s int32) { + C.gl3_2compat_glClearStencil(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearColor.xml +func (gl *GL) ClearColor(red, green, blue, alpha float32) { + C.gl3_2compat_glClearColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClear.xml +func (gl *GL) Clear(mask glbase.Bitfield) { + C.gl3_2compat_glClear(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawBuffer.xml +func (gl *GL) DrawBuffer(mode glbase.Enum) { + C.gl3_2compat_glDrawBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexImage2D.xml +func (gl *GL) TexImage2D(target glbase.Enum, level int, internalFormat int32, width, height, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexImage1D.xml +func (gl *GL) TexImage1D(target glbase.Enum, level int, internalFormat int32, width, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameteriv.xml +func (gl *GL) TexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_2compat_glTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameteri.xml +func (gl *GL) TexParameteri(target, pname glbase.Enum, param int32) { + C.gl3_2compat_glTexParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameterfv.xml +func (gl *GL) TexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl3_2compat_glTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameterf.xml +func (gl *GL) TexParameterf(target, pname glbase.Enum, param float32) { + C.gl3_2compat_glTexParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glScissor.xml +func (gl *GL) Scissor(x, y, width, height int) { + C.gl3_2compat_glScissor(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPolygonMode.xml +func (gl *GL) PolygonMode(face, mode glbase.Enum) { + C.gl3_2compat_glPolygonMode(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPointSize.xml +func (gl *GL) PointSize(size float32) { + C.gl3_2compat_glPointSize(gl.funcs, C.GLfloat(size)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLineWidth.xml +func (gl *GL) LineWidth(width float32) { + C.gl3_2compat_glLineWidth(gl.funcs, C.GLfloat(width)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glHint.xml +func (gl *GL) Hint(target, mode glbase.Enum) { + C.gl3_2compat_glHint(gl.funcs, C.GLenum(target), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFrontFace.xml +func (gl *GL) FrontFace(mode glbase.Enum) { + C.gl3_2compat_glFrontFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCullFace.xml +func (gl *GL) CullFace(mode glbase.Enum) { + C.gl3_2compat_glCullFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexubv.xml +func (gl *GL) Indexubv(c []uint8) { + C.gl3_2compat_glIndexubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexub.xml +func (gl *GL) Indexub(c uint8) { + C.gl3_2compat_glIndexub(gl.funcs, C.GLubyte(c)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsTexture.xml +func (gl *GL) IsTexture(texture glbase.Texture) bool { + glresult := C.gl3_2compat_glIsTexture(gl.funcs, C.GLuint(texture)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenTextures returns n texture names in textures. There is no guarantee +// that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenTextures. +// +// The generated textures have no dimensionality; they assume the +// dimensionality of the texture target to which they are first bound (see +// BindTexture). +// +// Texture names returned by a call to GenTextures are not returned by +// subsequent calls, unless they are first deleted with DeleteTextures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenTextures is available in GL version 2.0 or greater. +func (gl *GL) GenTextures(n int) []glbase.Texture { + if n == 0 { + return nil + } + textures := make([]glbase.Texture, n) + C.gl3_2compat_glGenTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) + return textures +} + +// DeleteTextures deletes the textures objects whose names are stored +// in the textures slice. After a texture is deleted, it has no contents or +// dimensionality, and its name is free for reuse (for example by +// GenTextures). If a texture that is currently bound is deleted, the binding +// reverts to 0 (the default texture). +// +// DeleteTextures silently ignores 0's and names that do not correspond to +// existing textures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteTextures is available in GL version 2.0 or greater. +func (gl *GL) DeleteTextures(textures []glbase.Texture) { + n := len(textures) + if n == 0 { + return + } + C.gl3_2compat_glDeleteTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindTexture.xml +func (gl *GL) BindTexture(target glbase.Enum, texture glbase.Texture) { + C.gl3_2compat_glBindTexture(gl.funcs, C.GLenum(target), C.GLuint(texture)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexSubImage2D.xml +func (gl *GL) TexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexSubImage1D.xml +func (gl *GL) TexSubImage1D(target glbase.Enum, level, xoffset, width int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyTexSubImage2D.xml +func (gl *GL) CopyTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, x, y, width, height int) { + C.gl3_2compat_glCopyTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyTexSubImage1D.xml +func (gl *GL) CopyTexSubImage1D(target glbase.Enum, level, xoffset, x, y, width int) { + C.gl3_2compat_glCopyTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyTexImage2D.xml +func (gl *GL) CopyTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, height, border int) { + C.gl3_2compat_glCopyTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyTexImage1D.xml +func (gl *GL) CopyTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, border int) { + C.gl3_2compat_glCopyTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPolygonOffset.xml +func (gl *GL) PolygonOffset(factor, units float32) { + C.gl3_2compat_glPolygonOffset(gl.funcs, C.GLfloat(factor), C.GLfloat(units)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawElements.xml +func (gl *GL) DrawElements(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glDrawElements(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawArrays.xml +func (gl *GL) DrawArrays(mode glbase.Enum, first, count int) { + C.gl3_2compat_glDrawArrays(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyTexSubImage3D.xml +func (gl *GL) CopyTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, x, y, width, height int) { + C.gl3_2compat_glCopyTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexSubImage3D.xml +func (gl *GL) TexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexImage3D.xml +func (gl *GL) TexImage3D(target glbase.Enum, level int, internalFormat int32, width, height int, depth int32, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawRangeElements.xml +func (gl *GL) DrawRangeElements(mode glbase.Enum, start, end uint32, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glDrawRangeElements(gl.funcs, C.GLenum(mode), C.GLuint(start), C.GLuint(end), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlendEquation.xml +func (gl *GL) BlendEquation(mode glbase.Enum) { + C.gl3_2compat_glBlendEquation(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlendColor.xml +func (gl *GL) BlendColor(red, green, blue, alpha float32) { + C.gl3_2compat_glBlendColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetCompressedTexImage.xml +func (gl *GL) GetCompressedTexImage(target glbase.Enum, level int, img interface{}) { + var img_ptr unsafe.Pointer + var img_v = reflect.ValueOf(img) + if img != nil && img_v.Kind() != reflect.Slice { + panic("parameter img must be a slice") + } + if img != nil { + img_ptr = unsafe.Pointer(img_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glGetCompressedTexImage(gl.funcs, C.GLenum(target), C.GLint(level), img_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexSubImage1D.xml +func (gl *GL) CompressedTexSubImage1D(target glbase.Enum, level, xoffset, width int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glCompressedTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexSubImage2D.xml +func (gl *GL) CompressedTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glCompressedTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexSubImage3D.xml +func (gl *GL) CompressedTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glCompressedTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexImage1D.xml +func (gl *GL) CompressedTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, width, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glCompressedTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexImage2D.xml +func (gl *GL) CompressedTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glCompressedTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexImage3D.xml +func (gl *GL) CompressedTexImage3D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height int, depth int32, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glCompressedTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSampleCoverage.xml +func (gl *GL) SampleCoverage(value float32, invert bool) { + C.gl3_2compat_glSampleCoverage(gl.funcs, C.GLfloat(value), *(*C.GLboolean)(unsafe.Pointer(&invert))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glActiveTexture.xml +func (gl *GL) ActiveTexture(texture glbase.Enum) { + C.gl3_2compat_glActiveTexture(gl.funcs, C.GLenum(texture)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPointParameteriv.xml +func (gl *GL) PointParameteriv(pname glbase.Enum, params []int32) { + C.gl3_2compat_glPointParameteriv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPointParameteri.xml +func (gl *GL) PointParameteri(pname glbase.Enum, param int32) { + C.gl3_2compat_glPointParameteri(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPointParameterfv.xml +func (gl *GL) PointParameterfv(pname glbase.Enum, params []float32) { + C.gl3_2compat_glPointParameterfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPointParameterf.xml +func (gl *GL) PointParameterf(pname glbase.Enum, param float32) { + C.gl3_2compat_glPointParameterf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiDrawArrays.xml +func (gl *GL) MultiDrawArrays(mode glbase.Enum, first, count []int, drawcount int32) { + C.gl3_2compat_glMultiDrawArrays(gl.funcs, C.GLenum(mode), (*C.GLint)(unsafe.Pointer(&first[0])), (*C.GLsizei)(unsafe.Pointer(&count[0])), C.GLsizei(drawcount)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlendFuncSeparate.xml +func (gl *GL) BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha glbase.Enum) { + C.gl3_2compat_glBlendFuncSeparate(gl.funcs, C.GLenum(sfactorRGB), C.GLenum(dfactorRGB), C.GLenum(sfactorAlpha), C.GLenum(dfactorAlpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetBufferParameteriv.xml +func (gl *GL) GetBufferParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_2compat_glGetBufferParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glUnmapBuffer.xml +func (gl *GL) UnmapBuffer(target glbase.Enum) bool { + glresult := C.gl3_2compat_glUnmapBuffer(gl.funcs, C.GLenum(target)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetBufferSubData.xml +func (gl *GL) GetBufferSubData(target glbase.Enum, offset, size int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glGetBufferSubData(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(size), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBufferSubData.xml +func (gl *GL) BufferSubData(target glbase.Enum, offset, size int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glBufferSubData(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(size), data_ptr) +} + +// BufferData creates a new data store for the buffer object currently +// bound to target. Any pre-existing data store is deleted. The new data +// store is created with the specified size in bytes and usage. If data is +// not nil, it must be a slice that is used to initialize the data store. +// In that case the size parameter is ignored and the store size will match +// the slice data size. +// +// In its initial state, the new data store is not mapped, it has a NULL +// mapped pointer, and its mapped access is GL.READ_WRITE. +// +// The target constant must be one of GL.ARRAY_BUFFER, GL.COPY_READ_BUFFER, +// GL.COPY_WRITE_BUFFER, GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER, +// GL.PIXEL_UNPACK_BUFFER, GL.TEXTURE_BUFFER, GL.TRANSFORM_FEEDBACK_BUFFER, +// or GL.UNIFORM_BUFFER. +// +// The usage parameter is a hint to the GL implementation as to how a buffer +// object's data store will be accessed. This enables the GL implementation +// to make more intelligent decisions that may significantly impact buffer +// object performance. It does not, however, constrain the actual usage of +// the data store. usage can be broken down into two parts: first, the +// frequency of access (modification and usage), and second, the nature of +// that access. +// +// A usage frequency of STREAM and nature of DRAW is specified via the +// constant GL.STREAM_DRAW, for example. +// +// The usage frequency of access may be one of: +// +// STREAM +// The data store contents will be modified once and used at most a few times. +// +// STATIC +// The data store contents will be modified once and used many times. +// +// DYNAMIC +// The data store contents will be modified repeatedly and used many times. +// +// The usage nature of access may be one of: +// +// DRAW +// The data store contents are modified by the application, and used as +// the source for GL drawing and image specification commands. +// +// READ +// The data store contents are modified by reading data from the GL, +// and used to return that data when queried by the application. +// +// COPY +// The data store contents are modified by reading data from the GL, +// and used as the source for GL drawing and image specification +// commands. +// +// Clients must align data elements consistent with the requirements of the +// client platform, with an additional base-level requirement that an offset +// within a buffer to a datum comprising N bytes be a multiple of N. +// +// Error GL.INVALID_ENUM is generated if target is not one of the accepted +// buffer targets. GL.INVALID_ENUM is generated if usage is not +// GL.STREAM_DRAW, GL.STREAM_READ, GL.STREAM_COPY, GL.STATIC_DRAW, +// GL.STATIC_READ, GL.STATIC_COPY, GL.DYNAMIC_DRAW, GL.DYNAMIC_READ, or +// GL.DYNAMIC_COPY. GL.INVALID_VALUE is generated if size is negative. +// GL.INVALID_OPERATION is generated if the reserved buffer object name 0 is +// bound to target. GL.OUT_OF_MEMORY is generated if the GL is unable to +// create a data store with the specified size. +func (gl *GL) BufferData(target glbase.Enum, size int, data interface{}, usage glbase.Enum) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + if data != nil { + size = int(data_v.Type().Size()) * data_v.Len() + } + C.gl3_2compat_glBufferData(gl.funcs, C.GLenum(target), C.GLsizeiptr(size), data_ptr, C.GLenum(usage)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsBuffer.xml +func (gl *GL) IsBuffer(buffer glbase.Buffer) bool { + glresult := C.gl3_2compat_glIsBuffer(gl.funcs, C.GLuint(buffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenBuffers returns n buffer object names. There is no guarantee that +// the names form a contiguous set of integers; however, it is guaranteed +// that none of the returned names was in use immediately before the call to +// GenBuffers. +// +// Buffer object names returned by a call to GenBuffers are not returned by +// subsequent calls, unless they are first deleted with DeleteBuffers. +// +// No buffer objects are associated with the returned buffer object names +// until they are first bound by calling BindBuffer. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if GenBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// GenBuffers is available in GL version 1.5 or greater. +func (gl *GL) GenBuffers(n int) []glbase.Buffer { + if n == 0 { + return nil + } + buffers := make([]glbase.Buffer, n) + C.gl3_2compat_glGenBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) + return buffers +} + +// DeleteBuffers deletes the buffer objects whose names are stored in the +// buffers slice. +// +// After a buffer object is deleted, it has no contents, and its name is free +// for reuse (for example by GenBuffers). If a buffer object that is +// currently bound is deleted, the binding reverts to 0 (the absence of any +// buffer object, which reverts to client memory usage). +// +// DeleteBuffers silently ignores 0's and names that do not correspond to +// existing buffer objects. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if DeleteBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// DeleteBuffers is available in GL version 1.5 or greater. +func (gl *GL) DeleteBuffers(buffers []glbase.Buffer) { + n := len(buffers) + if n == 0 { + return + } + C.gl3_2compat_glDeleteBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) +} + +// BindBuffer creates or puts in use a named buffer object. +// Calling BindBuffer with target set to GL.ARRAY_BUFFER, +// GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER or GL.PIXEL_UNPACK_BUFFER +// and buffer set to the name of the new buffer object binds the buffer +// object name to the target. When a buffer object is bound to a target, the +// previous binding for that target is automatically broken. +// +// Buffer object names are unsigned integers. The value zero is reserved, but +// there is no default buffer object for each buffer object target. Instead, +// buffer set to zero effectively unbinds any buffer object previously bound, +// and restores client memory usage for that buffer object target. Buffer +// object names and the corresponding buffer object contents are local to the +// shared display-list space (see XCreateContext) of the current GL rendering +// context; two rendering contexts share buffer object names only if they +// also share display lists. +// +// GenBuffers may be called to generate a set of new buffer object names. +// +// The state of a buffer object immediately after it is first bound is an +// unmapped zero-sized memory buffer with GL.READ_WRITE access and +// GL.STATIC_DRAW usage. +// +// While a non-zero buffer object name is bound, GL operations on the target +// to which it is bound affect the bound buffer object, and queries of the +// target to which it is bound return state from the bound buffer object. +// While buffer object name zero is bound, as in the initial state, attempts +// to modify or query state on the target to which it is bound generates an +// GL.INVALID_OPERATION error. +// +// When vertex array pointer state is changed, for example by a call to +// NormalPointer, the current buffer object binding (GL.ARRAY_BUFFER_BINDING) +// is copied into the corresponding client state for the vertex array type +// being changed, for example GL.NORMAL_ARRAY_BUFFER_BINDING. While a +// non-zero buffer object is bound to the GL.ARRAY_BUFFER target, the vertex +// array pointer parameter that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.ELEMENT_ARRAY_BUFFER +// target, the indices parameter of DrawElements, DrawRangeElements, or +// MultiDrawElements that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_PACK_BUFFER +// target, the following commands are affected: GetCompressedTexImage, +// GetConvolutionFilter, GetHistogram, GetMinmax, GetPixelMap, +// GetPolygonStipple, GetSeparableFilter, GetTexImage, and ReadPixels. The +// pointer parameter that is traditionally interpreted as a pointer to +// client-side memory where the pixels are to be packed is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_UNPACK_BUFFER +// target, the following commands are affected: Bitmap, ColorSubTable, +// ColorTable, CompressedTexImage1D, CompressedTexImage2D, +// CompressedTexImage3D, CompressedTexSubImage1D, CompressedTexSubImage2D, +// CompressedTexSubImage3D, ConvolutionFilter1D, ConvolutionFilter2D, +// DrawPixels, PixelMap, PolygonStipple, SeparableFilter2D, TexImage1D, +// TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, and TexSubImage3D. +// The pointer parameter that is traditionally interpreted as a pointer to +// client-side memory from which the pixels are to be unpacked is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// A buffer object binding created with BindBuffer remains active until a +// different buffer object name is bound to the same target, or until the +// bound buffer object is deleted with DeleteBuffers. +// +// Once created, a named buffer object may be re-bound to any target as often +// as needed. However, the GL implementation may make choices about how to +// optimize the storage of a buffer object based on its initial binding +// target. +// +// Error GL.INVALID_ENUM is generated if target is not one of the allowable +// values. GL.INVALID_OPERATION is generated if BindBuffer is executed +// between the execution of Begin and the corresponding execution of End. +// +// BindBuffer is available in GL version 1.5 or greater. +func (gl *GL) BindBuffer(target glbase.Enum, buffer glbase.Buffer) { + C.gl3_2compat_glBindBuffer(gl.funcs, C.GLenum(target), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetQueryObjectuiv.xml +func (gl *GL) GetQueryObjectuiv(id uint32, pname glbase.Enum, params []uint32) { + C.gl3_2compat_glGetQueryObjectuiv(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetQueryObjectiv.xml +func (gl *GL) GetQueryObjectiv(id uint32, pname glbase.Enum, params []int32) { + C.gl3_2compat_glGetQueryObjectiv(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetQueryiv.xml +func (gl *GL) GetQueryiv(target, pname glbase.Enum, params []int32) { + C.gl3_2compat_glGetQueryiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEndQuery.xml +func (gl *GL) EndQuery(target glbase.Enum) { + C.gl3_2compat_glEndQuery(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBeginQuery.xml +func (gl *GL) BeginQuery(target glbase.Enum, id uint32) { + C.gl3_2compat_glBeginQuery(gl.funcs, C.GLenum(target), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsQuery.xml +func (gl *GL) IsQuery(id uint32) bool { + glresult := C.gl3_2compat_glIsQuery(gl.funcs, C.GLuint(id)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDeleteQueries.xml +func (gl *GL) DeleteQueries(n int, ids []uint32) { + C.gl3_2compat_glDeleteQueries(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGenQueries.xml +func (gl *GL) GenQueries(n int, ids []uint32) { + C.gl3_2compat_glGenQueries(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// VertexAttribPointer specifies the location and data format of the array +// of generic vertex attributes at index to use when rendering. size +// specifies the number of components per attribute and must be 1, 2, 3, or +// 4. type specifies the data type of each component, and stride specifies +// the byte stride from one attribute to the next, allowing vertices and +// attributes to be packed into a single array or stored in separate arrays. +// normalized indicates whether the values stored in an integer format are +// to be mapped to the range [-1,1] (for signed values) or [0,1] +// (for unsigned values) when they are accessed and converted to floating +// point; otherwise, values will be converted to floats directly without +// normalization. offset is a byte offset into the buffer object's data +// store, which must be bound to the GL.ARRAY_BUFFER target with BindBuffer. +// +// The buffer object binding (GL.ARRAY_BUFFER_BINDING) is saved as +// generic vertex attribute array client-side state +// (GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING) for the provided index. +// +// To enable and disable a generic vertex attribute array, call +// EnableVertexAttribArray and DisableVertexAttribArray with index. If +// enabled, the generic vertex attribute array is used when DrawArrays or +// DrawElements is called. Each generic vertex attribute array is initially +// disabled. +// +// VertexAttribPointer is typically implemented on the client side. +// +// Error GL.INVALID_ENUM is generated if type is not an accepted value. +// GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_VALUE is generated if size is not 1, 2, +// 3, or 4. GL.INVALID_VALUE is generated if stride is negative. +func (gl *GL) VertexAttribPointer(index glbase.Attrib, size int, gltype glbase.Enum, normalized bool, stride int, offset uintptr) { + offset_ptr := unsafe.Pointer(offset) + C.gl3_2compat_glVertexAttribPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLsizei(stride), offset_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glValidateProgram.xml +func (gl *GL) ValidateProgram(program glbase.Program) { + C.gl3_2compat_glValidateProgram(gl.funcs, C.GLuint(program)) +} + +// UniformMatrix4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*4) != 0 { + panic("invalid value length for UniformMatrix4fv") + } + count := len(value) / (4 * 4) + C.gl3_2compat_glUniformMatrix4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*3) != 0 { + panic("invalid value length for UniformMatrix3fv") + } + count := len(value) / (3 * 3) + C.gl3_2compat_glUniformMatrix3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*2) != 0 { + panic("invalid value length for UniformMatrix2fv") + } + count := len(value) / (2 * 2) + C.gl3_2compat_glUniformMatrix2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform4iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4iv") + } + count := len(value) / 4 + C.gl3_2compat_glUniform4iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform3iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3iv") + } + count := len(value) / 3 + C.gl3_2compat_glUniform3iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform2iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2iv") + } + count := len(value) / 2 + C.gl3_2compat_glUniform2iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform1iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl3_2compat_glUniform1iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4fv") + } + count := len(value) / 4 + C.gl3_2compat_glUniform4fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3fv") + } + count := len(value) / 3 + C.gl3_2compat_glUniform3fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2fv") + } + count := len(value) / 2 + C.gl3_2compat_glUniform2fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform1fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl3_2compat_glUniform1fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform4i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4i(location glbase.Uniform, v0, v1, v2, v3 int32) { + C.gl3_2compat_glUniform4i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2), C.GLint(v3)) +} + +// Uniform3i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3i(location glbase.Uniform, v0, v1, v2 int32) { + C.gl3_2compat_glUniform3i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2)) +} + +// Uniform2i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2i(location glbase.Uniform, v0, v1 int32) { + C.gl3_2compat_glUniform2i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1)) +} + +// Uniform1i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1i(location glbase.Uniform, v0 int32) { + C.gl3_2compat_glUniform1i(gl.funcs, C.GLint(location), C.GLint(v0)) +} + +// Uniform4f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4f(location glbase.Uniform, v0, v1, v2, v3 float32) { + C.gl3_2compat_glUniform4f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2), C.GLfloat(v3)) +} + +// Uniform3f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3f(location glbase.Uniform, v0, v1, v2 float32) { + C.gl3_2compat_glUniform3f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2)) +} + +// Uniform2f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2f(location glbase.Uniform, v0, v1 float32) { + C.gl3_2compat_glUniform2f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1)) +} + +// Uniform1f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1f(location glbase.Uniform, v0 float32) { + C.gl3_2compat_glUniform1f(gl.funcs, C.GLint(location), C.GLfloat(v0)) +} + +// UseProgram installs the program object specified by program as part of +// current rendering state. One or more executables are created in a program +// object by successfully attaching shader objects to it with AttachShader, +// successfully compiling the shader objects with CompileShader, and +// successfully linking the program object with LinkProgram. +// +// A program object will contain an executable that will run on the vertex +// processor if it contains one or more shader objects of type +// GL.VERTEX_SHADER that have been successfully compiled and linked. +// Similarly, a program object will contain an executable that will run on +// the fragment processor if it contains one or more shader objects of type +// GL.FRAGMENT_SHADER that have been successfully compiled and linked. +// +// Successfully installing an executable on a programmable processor will +// cause the corresponding fixed functionality of OpenGL to be disabled. +// Specifically, if an executable is installed on the vertex processor, the +// OpenGL fixed functionality will be disabled as follows. +// +// - The modelview matrix is not applied to vertex coordinates. +// +// - The projection matrix is not applied to vertex coordinates. +// +// - The texture matrices are not applied to texture coordinates. +// +// - Normals are not transformed to eye coordinates. +// +// - Normals are not rescaled or normalized. +// +// - Normalization of GL.AUTO_NORMAL evaluated normals is not performed. +// +// - Texture coordinates are not generated automatically. +// +// - Per-vertex lighting is not performed. +// +// - Color material computations are not performed. +// +// - Color index lighting is not performed. +// +// - This list also applies when setting the current raster position. +// +// The executable that is installed on the vertex processor is expected to +// implement any or all of the desired functionality from the preceding list. +// Similarly, if an executable is installed on the fragment processor, the +// OpenGL fixed functionality will be disabled as follows. +// +// - Texture environment and texture functions are not applied. +// +// - Texture application is not applied. +// +// - Color sum is not applied. +// +// - Fog is not applied. +// +// Again, the fragment shader that is installed is expected to implement any +// or all of the desired functionality from the preceding list. +// +// While a program object is in use, applications are free to modify attached +// shader objects, compile attached shader objects, attach additional shader +// objects, and detach or delete shader objects. None of these operations +// will affect the executables that are part of the current state. However, +// relinking the program object that is currently in use will install the +// program object as part of the current rendering state if the link +// operation was successful (see LinkProgram). If the program object +// currently in use is relinked unsuccessfully, its link status will be set +// to GL.FALSE, but the executables and associated state will remain part of +// the current state until a subsequent call to UseProgram removes it from +// use. After it is removed from use, it cannot be made part of current state +// until it has been successfully relinked. +// +// If program contains shader objects of type GL.VERTEX_SHADER but it does +// not contain shader objects of type GL.FRAGMENT_SHADER, an executable will +// be installed on the vertex processor, but fixed functionality will be used +// for fragment processing. Similarly, if program contains shader objects of +// type GL.FRAGMENT_SHADER but it does not contain shader objects of type +// GL.VERTEX_SHADER, an executable will be installed on the fragment +// processor, but fixed functionality will be used for vertex processing. If +// program is 0, the programmable processors will be disabled, and fixed +// functionality will be used for both vertex and fragment processing. +// +// While a program object is in use, the state that controls the disabled +// fixed functionality may also be updated using the normal OpenGL calls. +// +// Like display lists and texture objects, the name space for program objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// Applications are responsible for providing the synchronization across API +// calls when objects are accessed from different execution threads. +// +// Error GL.INVALID_VALUE is generated if program is neither 0 nor a value +// generated by OpenGL. GL.INVALID_OPERATION is generated if program is not +// a program object. GL.INVALID_OPERATION is generated if program could not +// be made part of current state. GL.INVALID_OPERATION is generated if +// UseProgram is executed between the execution of Begin and the +// corresponding execution of End. +// +// UseProgram is available in GL version 2.0 or greater. +func (gl *GL) UseProgram(program glbase.Program) { + C.gl3_2compat_glUseProgram(gl.funcs, C.GLuint(program)) +} + +// ShaderSource sets the source code in shader to the provided source code. Any source +// code previously stored in the shader object is completely replaced. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_VALUE is generated if count is less than 0. +// GL.INVALID_OPERATION is generated if ShaderSource is executed between the +// execution of Begin and the corresponding execution of End. +// +// ShaderSource is available in GL version 2.0 or greater. +func (gl *GL) ShaderSource(shader glbase.Shader, source ...string) { + count := len(source) + length := make([]int32, count) + source_c := make([]unsafe.Pointer, count) + for i, src := range source { + length[i] = int32(len(src)) + if len(src) > 0 { + source_c[i] = *(*unsafe.Pointer)(unsafe.Pointer(&src)) + } else { + source_c[i] = unsafe.Pointer(uintptr(0)) + } + } + C.gl3_2compat_glShaderSource(gl.funcs, C.GLuint(shader), C.GLsizei(count), (**C.GLchar)(unsafe.Pointer(&source_c[0])), (*C.GLint)(unsafe.Pointer(&length[0]))) +} + +// LinkProgram links the program object specified by program. If any shader +// objects of type GL.VERTEX_SHADER are attached to program, they will be +// used to create an executable that will run on the programmable vertex +// processor. If any shader objects of type GL.FRAGMENT_SHADER are attached +// to program, they will be used to create an executable that will run on the +// programmable fragment processor. +// +// The status of the link operation will be stored as part of the program +// object's state. This value will be set to GL.TRUE if the program object +// was linked without errors and is ready for use, and GL.FALSE otherwise. It +// can be queried by calling GetProgramiv with arguments program and +// GL.LINK_STATUS. +// +// As a result of a successful link operation, all active user-defined +// uniform variables belonging to program will be initialized to 0, and each +// of the program object's active uniform variables will be assigned a +// location that can be queried by calling GetUniformLocation. Also, any +// active user-defined attribute variables that have not been bound to a +// generic vertex attribute index will be bound to one at this time. +// +// Linking of a program object can fail for a number of reasons as specified +// in the OpenGL Shading Language Specification. The following lists some of +// the conditions that will cause a link error. +// +// - The number of active attribute variables supported by the +// implementation has been exceeded. +// +// - The storage limit for uniform variables has been exceeded. +// +// - The number of active uniform variables supported by the implementation +// has been exceeded. +// +// - The main function is missing for the vertex shader or the fragment +// shader. +// +// - A varying variable actually used in the fragment shader is not +// declared in the same way (or is not declared at all) in the vertex +// shader. +// +// - A reference to a function or variable name is unresolved. +// +// - A shared global is declared with two different types or two different +// initial values. +// +// - One or more of the attached shader objects has not been successfully +// compiled. +// +// - Binding a generic attribute matrix caused some rows of the matrix to +// fall outside the allowed maximum of GL.MAX_VERTEX_ATTRIBS. +// +// - Not enough contiguous vertex attribute slots could be found to bind +// attribute matrices. +// +// When a program object has been successfully linked, the program object can +// be made part of current state by calling UseProgram. Whether or not the +// link operation was successful, the program object's information log will +// be overwritten. The information log can be retrieved by calling +// GetProgramInfoLog. +// +// LinkProgram will also install the generated executables as part of the +// current rendering state if the link operation was successful and the +// specified program object is already currently in use as a result of a +// previous call to UseProgram. If the program object currently in use is +// relinked unsuccessfully, its link status will be set to GL.FALSE , but the +// executables and associated state will remain part of the current state +// until a subsequent call to UseProgram removes it from use. After it is +// removed from use, it cannot be made part of current state until it has +// been successfully relinked. +// +// If program contains shader objects of type GL.VERTEX_SHADER but does not +// contain shader objects of type GL.FRAGMENT_SHADER, the vertex shader will +// be linked against the implicit interface for fixed functionality fragment +// processing. Similarly, if program contains shader objects of type +// GL.FRAGMENT_SHADER but it does not contain shader objects of type +// GL.VERTEX_SHADER, the fragment shader will be linked against the implicit +// interface for fixed functionality vertex processing. +// +// The program object's information log is updated and the program is +// generated at the time of the link operation. After the link operation, +// applications are free to modify attached shader objects, compile attached +// shader objects, detach shader objects, delete shader objects, and attach +// additional shader objects. None of these operations affects the +// information log or the program that is part of the program object. +// +// If the link operation is unsuccessful, any information about a previous +// link operation on program is lost (a failed link does not restore the +// old state of program). Certain information can still be retrieved +// from program even after an unsuccessful link operation. See for instance +// GetActiveAttrib and GetActiveUniform. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if LinkProgram is executed +// between the execution of Begin and the corresponding execution of End. +// +// LinkProgram is available in GL version 2.0 or greater. +func (gl *GL) LinkProgram(program glbase.Program) { + C.gl3_2compat_glLinkProgram(gl.funcs, C.GLuint(program)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsShader.xml +func (gl *GL) IsShader(shader glbase.Shader) bool { + glresult := C.gl3_2compat_glIsShader(gl.funcs, C.GLuint(shader)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsProgram.xml +func (gl *GL) IsProgram(program glbase.Program) bool { + glresult := C.gl3_2compat_glIsProgram(gl.funcs, C.GLuint(program)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GetVertexAttribiv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribiv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribiv(index glbase.Attrib, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl3_2compat_glGetVertexAttribiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetVertexAttribfv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribfv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribfv(index glbase.Attrib, pname glbase.Enum, params []float32) { + var params_c [4]float32 + C.gl3_2compat_glGetVertexAttribfv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetVertexAttribdv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribdv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribdv(index glbase.Attrib, pname glbase.Enum, params []float64) { + var params_c [4]float64 + C.gl3_2compat_glGetVertexAttribdv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformiv returns in params the value of the specified uniform +// variable. The type of the uniform variable specified by location +// determines the number of values returned. If the uniform variable is +// defined in the shader as a boolean, int, or float, a single value will be +// returned. If it is defined as a vec2, ivec2, or bvec2, two values will be +// returned. If it is defined as a vec3, ivec3, or bvec3, three values will +// be returned, and so on. To query values stored in uniform variables +// declared as arrays, call GetUniformiv for each element of the array. To +// query values stored in uniform variables declared as structures, call +// GetUniformiv for each field in the structure. The values for uniform +// variables declared as a matrix will be returned in column major order. +// +// The locations assigned to uniform variables are not known until the +// program object is linked. After linking has occurred, the command +// GetUniformLocation can be used to obtain the location of a uniform +// variable. This location value can then be passed to GetUniformiv in order +// to query the current value of the uniform variable. After a program object +// has been linked successfully, the index values for uniform variables +// remain fixed until the next link command occurs. The uniform variable +// values can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if program has not been +// successfully linked. GL.INVALID_OPERATION is generated if location does +// not correspond to a valid uniform variable location for the specified +// program object. GL.INVALID_OPERATION is generated if GetUniformiv is +// executed between the execution of Begin and the corresponding execution of +// End. +// +// GetUniformiv is available in GL version 2.0 or greater. +func (gl *GL) GetUniformiv(program glbase.Program, location glbase.Uniform, params []int32) { + var params_c [4]int32 + C.gl3_2compat_glGetUniformiv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformfv returns in params the value of the specified uniform +// variable. The type of the uniform variable specified by location +// determines the number of values returned. If the uniform variable is +// defined in the shader as a boolean, int, or float, a single value will be +// returned. If it is defined as a vec2, ivec2, or bvec2, two values will be +// returned. If it is defined as a vec3, ivec3, or bvec3, three values will +// be returned, and so on. To query values stored in uniform variables +// declared as arrays, call GetUniformfv for each element of the array. To +// query values stored in uniform variables declared as structures, call +// GetUniformfv for each field in the structure. The values for uniform +// variables declared as a matrix will be returned in column major order. +// +// The locations assigned to uniform variables are not known until the +// program object is linked. After linking has occurred, the command +// GetUniformLocation can be used to obtain the location of a uniform +// variable. This location value can then be passed to GetUniformfv in order +// to query the current value of the uniform variable. After a program object +// has been linked successfully, the index values for uniform variables +// remain fixed until the next link command occurs. The uniform variable +// values can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if program has not been +// successfully linked. GL.INVALID_OPERATION is generated if location does +// not correspond to a valid uniform variable location for the specified +// program object. GL.INVALID_OPERATION is generated if GetUniformfv is +// executed between the execution of Begin and the corresponding execution of +// End. +// +// GetUniformfv is available in GL version 2.0 or greater. +func (gl *GL) GetUniformfv(program glbase.Program, location glbase.Uniform, params []float32) { + var params_c [4]float32 + C.gl3_2compat_glGetUniformfv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLfloat)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformLocation returns an integer that represents the location of a +// specific uniform variable within a program object. name must be an active +// uniform variable name in program that is not a structure, an array of +// structures, or a subcomponent of a vector or a matrix. This function +// returns -1 if name does not correspond to an active uniform variable in +// program or if name starts with the reserved prefix "gl_". +// +// Uniform variables that are structures or arrays of structures may be +// queried by calling GetUniformLocation for each field within the +// structure. The array element operator "[]" and the structure field +// operator "." may be used in name in order to select elements within an +// array or fields within a structure. The result of using these operators is +// not allowed to be another structure, an array of structures, or a +// subcomponent of a vector or a matrix. Except if the last part of name +// indicates a uniform variable array, the location of the first element of +// an array can be retrieved by using the name of the array, or by using the +// name appended by "[0]". +// +// The actual locations assigned to uniform variables are not known until the +// program object is linked successfully. After linking has occurred, the +// command GetUniformLocation can be used to obtain the location of a +// uniform variable. This location value can then be passed to Uniform to +// set the value of the uniform variable or to GetUniform in order to query +// the current value of the uniform variable. After a program object has been +// linked successfully, the index values for uniform variables remain fixed +// until the next link command occurs. Uniform variable locations and values +// can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program object. +// GL.INVALID_OPERATION is generated if program has not been successfully +// linked. GL.INVALID_OPERATION is generated if GetUniformLocation is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetUniformLocation is available in GL version 2.0 or greater. +func (gl *GL) GetUniformLocation(program glbase.Program, name string) glbase.Uniform { + name_cstr := C.CString(name) + glresult := C.gl3_2compat_glGetUniformLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) + return glbase.Uniform(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetShaderSource.xml +func (gl *GL) GetShaderSource(shader glbase.Shader, bufSize int32, length []int32, source []byte) { + C.gl3_2compat_glGetShaderSource(gl.funcs, C.GLuint(shader), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&source[0]))) +} + +// GetShaderInfoLog returns the information log for the specified shader +// object. The information log for a shader object is modified when the +// shader is compiled. +// +// The information log for a shader object is a string that may contain +// diagnostic messages, warning messages, and other information about the +// last compile operation. When a shader object is created, its information +// log will be a string of length 0, and the size of the current log can be +// obtained by calling GetShaderiv with the value GL.INFO_LOG_LENGTH. +// +// The information log for a shader object is the OpenGL implementer's +// primary mechanism for conveying information about the compilation process. +// Therefore, the information log can be helpful to application developers +// during the development process, even when compilation is successful. +// Application developers should not expect different OpenGL implementations +// to produce identical information logs. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_VALUE is generated if maxLength is less than 0. +// GL.INVALID_OPERATION is generated if GetShaderInfoLog is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetShaderInfoLog is available in GL version 2.0 or greater. +func (gl *GL) GetShaderInfoLog(shader glbase.Shader) []byte { + var params [1]int32 + var length int32 + gl.GetShaderiv(shader, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + C.gl3_2compat_glGetShaderInfoLog(gl.funcs, C.GLuint(shader), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length)), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) + return infoLog +} + +// GetShaderiv GetShader returns in params the value of a parameter for a specific +// shader object. The following parameters are defined: +// +// GL.SHADER_TYPE +// params returns GL.VERTEX_SHADER if shader is a vertex shader object, +// and GL.FRAGMENT_SHADER if shader is a fragment shader object. +// +// GL.DELETE_STATUS +// params returns GL.TRUE if shader is currently flagged for deletion, +// and GL.FALSE otherwise. +// +// GL.COMPILE_STATUS +// params returns GL.TRUE if the last compile operation on shader was +// successful, and GL.FALSE otherwise. +// +// GL.INFO_LOG_LENGTH +// params returns the number of characters in the information log for +// shader including the null termination character (the size of the +// character buffer required to store the information log). If shader has +// no information log, a value of 0 is returned. +// +// GL.SHADER_SOURCE_LENGTH +// params returns the length of the concatenation of the source strings +// that make up the shader source for the shader, including the null +// termination character. (the size of the character buffer +// required to store the shader source). If no source code exists, 0 is +// returned. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader does not refer to a +// shader object. GL.INVALID_ENUM is generated if pname is not an accepted +// value. GL.INVALID_OPERATION is generated if GetShader is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetShaderiv is available in GL version 2.0 or greater. +func (gl *GL) GetShaderiv(shader glbase.Shader, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl3_2compat_glGetShaderiv(gl.funcs, C.GLuint(shader), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetProgramInfoLog returns the information log for the specified program +// object. The information log for a program object is modified when the +// program object is linked or validated. +// +// The information log for a program object is either an empty string, or a +// string containing information about the last link operation, or a string +// containing information about the last validation operation. It may contain +// diagnostic messages, warning messages, and other information. When a +// program object is created, its information log will be a string of length +// 0, and the size of the current log can be obtained by calling GetProgramiv +// with the value GL.INFO_LOG_LENGTH. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated +// by OpenGL. GL.INVALID_OPERATION is generated if program is not a +// program object. +func (gl *GL) GetProgramInfoLog(program glbase.Program) []byte { + var params [1]int32 + var length int32 + gl.GetProgramiv(program, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + C.gl3_2compat_glGetProgramInfoLog(gl.funcs, C.GLuint(program), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length)), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) + return infoLog +} + +// GetProgramiv returns in params the value of a parameter for a specific +// program object. The following parameters are defined: +// +// GL.DELETE_STATUS +// params returns GL.TRUE if program is currently flagged for deletion, +// and GL.FALSE otherwise. +// +// GL.LINK_STATUS +// params returns GL.TRUE if the last link operation on program was +// successful, and GL.FALSE otherwise. +// +// GL.VALIDATE_STATUS +// params returns GL.TRUE or if the last validation operation on +// program was successful, and GL.FALSE otherwise. +// +// GL.INFO_LOG_LENGTH +// params returns the number of characters in the information log for +// program including the null termination character (the size of +// the character buffer required to store the information log). If +// program has no information log, a value of 0 is returned. +// +// GL.ATTACHED_SHADERS +// params returns the number of shader objects attached to program. +// +// GL.ACTIVE_ATTRIBUTES +// params returns the number of active attribute variables for program. +// +// GL.ACTIVE_ATTRIBUTE_MAX_LENGTH +// params returns the length of the longest active attribute name for +// program, including the null termination character (the size of +// the character buffer required to store the longest attribute name). +// If no active attributes exist, 0 is returned. +// +// GL.ACTIVE_UNIFORMS +// params returns the number of active uniform variables for program. +// +// GL.ACTIVE_UNIFORM_MAX_LENGTH +// params returns the length of the longest active uniform variable +// name for program, including the null termination character (i.e., +// the size of the character buffer required to store the longest +// uniform variable name). If no active uniform variables exist, 0 is +// returned. +// +// GL.TRANSFORM_FEEDBACK_BUFFER_MODE +// params returns a symbolic constant indicating the buffer mode used +// when transform feedback is active. This may be GL.SEPARATE_ATTRIBS +// or GL.INTERLEAVED_ATTRIBS. +// +// GL.TRANSFORM_FEEDBACK_VARYINGS +// params returns the number of varying variables to capture in transform +// feedback mode for the program. +// +// GL.TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH +// params returns the length of the longest variable name to be used for +// transform feedback, including the null-terminator. +// +// GL.GEOMETRY_VERTICES_OUT +// params returns the maximum number of vertices that the geometry shader in +// program will output. +// +// GL.GEOMETRY_INPUT_TYPE +// params returns a symbolic constant indicating the primitive type accepted +// as input to the geometry shader contained in program. +// +// GL.GEOMETRY_OUTPUT_TYPE +// params returns a symbolic constant indicating the primitive type that will +// be output by the geometry shader contained in program. +// +// GL.ACTIVE_UNIFORM_BLOCKS and GL.ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH are +// available only if the GL version 3.1 or greater. +// +// GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE and +// GL.GEOMETRY_OUTPUT_TYPE are accepted only if the GL version is 3.2 or +// greater. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program does not refer to a +// program object. GL.INVALID_OPERATION is generated if pname is +// GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE, or +// GL.GEOMETRY_OUTPUT_TYPE, and program does not contain a geometry shader. +// GL.INVALID_ENUM is generated if pname is not an accepted value. +func (gl *GL) GetProgramiv(program glbase.Program, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl3_2compat_glGetProgramiv(gl.funcs, C.GLuint(program), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetAttribLocation queries the previously linked program object specified +// by program for the attribute variable specified by name and returns the +// index of the generic vertex attribute that is bound to that attribute +// variable. If name is a matrix attribute variable, the index of the first +// column of the matrix is returned. If the named attribute variable is not +// an active attribute in the specified program object or if name starts with +// the reserved prefix "gl_", a value of -1 is returned. +// +// The association between an attribute variable name and a generic attribute +// index can be specified at any time by calling BindAttribLocation. +// Attribute bindings do not go into effect until LinkProgram is called. +// After a program object has been linked successfully, the index values for +// attribute variables remain fixed until the next link command occurs. The +// attribute values can only be queried after a link if the link was +// successful. GetAttribLocation returns the binding that actually went +// into effect the last time LinkProgram was called for the specified +// program object. Attribute bindings that have been specified since the last +// link operation are not returned by GetAttribLocation. +// +// Error GL_INVALID_OPERATION is generated if program is not a value +// generated by OpenGL. GL_INVALID_OPERATION is generated if program is not +// a program object. GL_INVALID_OPERATION is generated if program has not +// been successfully linked. GL_INVALID_OPERATION is generated if +// GetAttribLocation is executed between the execution of Begin and the +// corresponding execution of End. +// +// GetAttribLocation is available in GL version 2.0 or greater. +func (gl *GL) GetAttribLocation(program glbase.Program, name string) glbase.Attrib { + name_cstr := C.CString(name) + glresult := C.gl3_2compat_glGetAttribLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) + return glbase.Attrib(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetAttachedShaders.xml +func (gl *GL) GetAttachedShaders(program glbase.Program, maxCount int32, count []int, obj []uint32) { + C.gl3_2compat_glGetAttachedShaders(gl.funcs, C.GLuint(program), C.GLsizei(maxCount), (*C.GLsizei)(unsafe.Pointer(&count[0])), (*C.GLuint)(unsafe.Pointer(&obj[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetActiveUniform.xml +func (gl *GL) GetActiveUniform(program glbase.Program, index uint32, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl3_2compat_glGetActiveUniform(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetActiveAttrib.xml +func (gl *GL) GetActiveAttrib(program glbase.Program, index glbase.Attrib, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl3_2compat_glGetActiveAttrib(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEnableVertexAttribArray.xml +func (gl *GL) EnableVertexAttribArray(index glbase.Attrib) { + C.gl3_2compat_glEnableVertexAttribArray(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDisableVertexAttribArray.xml +func (gl *GL) DisableVertexAttribArray(index glbase.Attrib) { + C.gl3_2compat_glDisableVertexAttribArray(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDetachShader.xml +func (gl *GL) DetachShader(program glbase.Program, shader glbase.Shader) { + C.gl3_2compat_glDetachShader(gl.funcs, C.GLuint(program), C.GLuint(shader)) +} + +// DeleteShader frees the memory and invalidates the name associated with +// the shader object specified by shader. This command effectively undoes the +// effects of a call to CreateShader. +// +// If a shader object to be deleted is attached to a program object, it will +// be flagged for deletion, but it will not be deleted until it is no longer +// attached to any program object, for any rendering context (it must +// be detached from wherever it was attached before it will be deleted). A +// value of 0 for shader will be silently ignored. +// +// To determine whether an object has been flagged for deletion, call +// GetShader with arguments shader and GL.DELETE_STATUS. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. +// +// DeleteShader is available in GL version 2.0 or greater. +func (gl *GL) DeleteShader(shader glbase.Shader) { + C.gl3_2compat_glDeleteShader(gl.funcs, C.GLuint(shader)) +} + +// DeleteProgram frees the memory and invalidates the name associated with +// the program object specified by program. This command effectively undoes +// the effects of a call to CreateProgram. +// +// If a program object is in use as part of current rendering state, it will +// be flagged for deletion, but it will not be deleted until it is no longer +// part of current state for any rendering context. If a program object to be +// deleted has shader objects attached to it, those shader objects will be +// automatically detached but not deleted unless they have already been +// flagged for deletion by a previous call to DeleteShader. A value of 0 +// for program will be silently ignored. +// +// To determine whether a program object has been flagged for deletion, call +// GetProgram with arguments program and GL.DELETE_STATUS. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. +// +// DeleteProgram is available in GL version 2.0 or greater. +func (gl *GL) DeleteProgram(program glbase.Program) { + C.gl3_2compat_glDeleteProgram(gl.funcs, C.GLuint(program)) +} + +// CreateShader creates an empty shader object and returns a non-zero value +// by which it can be referenced. A shader object is used to maintain the +// source code strings that define a shader. shaderType indicates the type of +// shader to be created. +// +// Two types of shaders are supported. A shader of type GL.VERTEX_SHADER is a +// shader that is intended to run on the programmable vertex processor and +// replace the fixed functionality vertex processing in OpenGL. A shader of +// type GL.FRAGMENT_SHADER is a shader that is intended to run on the +// programmable fragment processor and replace the fixed functionality +// fragment processing in OpenGL. +// +// When created, a shader object's GL.SHADER_TYPE parameter is set to either +// GL.VERTEX_SHADER or GL.FRAGMENT_SHADER, depending on the value of +// shaderType. +// +// Like display lists and texture objects, the name space for shader objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// This function returns 0 if an error occurs creating the shader object. +// +// Error GL.INVALID_ENUM is generated if shaderType is not an accepted value. +// GL.INVALID_OPERATION is generated if CreateShader is executed between the +// execution of Begin and the corresponding execution of End. +// +// CreateShader is available in GL version 2.0 or greater. +func (gl *GL) CreateShader(gltype glbase.Enum) glbase.Shader { + glresult := C.gl3_2compat_glCreateShader(gl.funcs, C.GLenum(gltype)) + return glbase.Shader(glresult) +} + +// CreateProgram creates an empty program object and returns a non-zero +// value by which it can be referenced. A program object is an object to +// which shader objects can be attached. This provides a mechanism to specify +// the shader objects that will be linked to create a program. It also +// provides a means for checking the compatibility of the shaders that will +// be used to create a program (for instance, checking the compatibility +// between a vertex shader and a fragment shader). When no longer needed as +// part of a program object, shader objects can be detached. +// +// One or more executables are created in a program object by successfully +// attaching shader objects to it with AttachShader, successfully compiling +// the shader objects with CompileShader, and successfully linking the +// program object with LinkProgram. These executables are made part of +// current state when UseProgram is called. Program objects can be deleted +// by calling DeleteProgram. The memory associated with the program object +// will be deleted when it is no longer part of current rendering state for +// any context. +// +// Like display lists and texture objects, the name space for program objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// Applications are responsible for providing the synchronization across API +// calls when objects are accessed from different execution threads. +// +// This function returns 0 if an error occurs creating the program object. +// +// Error GL.INVALID_OPERATION is generated if CreateProgram is executed +// between the execution of Begin and the corresponding execution of End. +// +// CreateProgram is available in GL version 2.0 or greater. +func (gl *GL) CreateProgram() glbase.Program { + glresult := C.gl3_2compat_glCreateProgram(gl.funcs) + return glbase.Program(glresult) +} + +// CompileShader compiles the source code strings that have been stored in +// the shader object specified by shader. +// +// The compilation status will be stored as part of the shader object's +// state. This value will be set to GL.TRUE if the shader was compiled without +// errors and is ready for use, and GL.FALSE otherwise. It can be queried by +// calling GetShaderiv with arguments shader and GL.COMPILE_STATUS. +// +// Compilation of a shader can fail for a number of reasons as specified by +// the OpenGL Shading Language Specification. Whether or not the compilation +// was successful, information about the compilation can be obtained from the +// shader object's information log by calling GetShaderInfoLog. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_OPERATION is generated if CompileShader is executed +// between the execution of Begin and the corresponding execution of End. +// +// CompileShader is available in GL version 2.0 or greater. +func (gl *GL) CompileShader(shader glbase.Shader) { + C.gl3_2compat_glCompileShader(gl.funcs, C.GLuint(shader)) +} + +// BindAttribLocation associates a user-defined attribute variable in the program +// object specified by program with a generic vertex attribute index. The name +// parameter specifies the name of the vertex shader attribute variable to +// which index is to be bound. When program is made part of the current state, +// values provided via the generic vertex attribute index will modify the +// value of the user-defined attribute variable specified by name. +// +// If name refers to a matrix attribute variable, index refers to the first +// column of the matrix. Other matrix columns are then automatically bound to +// locations index+1 for a matrix of type mat2; index+1 and index+2 for a +// matrix of type mat3; and index+1, index+2, and index+3 for a matrix of +// type mat4. +// +// This command makes it possible for vertex shaders to use descriptive names +// for attribute variables rather than generic variables that are numbered +// from 0 to GL.MAX_VERTEX_ATTRIBS-1. The values sent to each generic +// attribute index are part of current state, just like standard vertex +// attributes such as color, normal, and vertex position. If a different +// program object is made current by calling UseProgram, the generic vertex +// attributes are tracked in such a way that the same values will be observed +// by attributes in the new program object that are also bound to index. +// +// Attribute variable name-to-generic attribute index bindings for a program +// object can be explicitly assigned at any time by calling +// BindAttribLocation. Attribute bindings do not go into effect until +// LinkProgram is called. After a program object has been linked +// successfully, the index values for generic attributes remain fixed (and +// their values can be queried) until the next link command occurs. +// +// Applications are not allowed to bind any of the standard OpenGL vertex +// attributes using this command, as they are bound automatically when +// needed. Any attribute binding that occurs after the program object has +// been linked will not take effect until the next time the program object is +// linked. +// +// If name was bound previously, that information is lost. Thus you cannot +// bind one user-defined attribute variable to multiple indices, but you can +// bind multiple user-defined attribute variables to the same index. +// +// Applications are allowed to bind more than one user-defined attribute +// variable to the same generic vertex attribute index. This is called +// aliasing, and it is allowed only if just one of the aliased attributes is +// active in the executable program, or if no path through the shader +// consumes more than one attribute of a set of attributes aliased to the +// same location. The compiler and linker are allowed to assume that no +// aliasing is done and are free to employ optimizations that work only in +// the absence of aliasing. OpenGL implementations are not required to do +// error checking to detect aliasing. Because there is no way to bind +// standard attributes, it is not possible to alias generic attributes with +// conventional ones (except for generic attribute 0). +// +// BindAttribLocation can be called before any vertex shader objects are +// bound to the specified program object. It is also permissible to bind a +// generic attribute index to an attribute variable name that is never used +// in a vertex shader. +// +// Active attributes that are not explicitly bound will be bound by the +// linker when LinkProgram is called. The locations assigned can be queried +// by calling GetAttribLocation. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. +// GL.INVALID_OPERATION is generated if name starts with the reserved prefix "gl_". +// GL.INVALID_VALUE is generated if program is not a value generated by OpenGL. +// GL.INVALID_OPERATION is generated if program is not a program object. +// GL.INVALID_OPERATION is generated if BindAttribLocation is executed +// between the execution of Begin and the corresponding execution of End. +// +// BindAttribLocation is available in GL version 2.0 or greater. +func (gl *GL) BindAttribLocation(program glbase.Program, index glbase.Attrib, name string) { + name_cstr := C.CString(name) + C.gl3_2compat_glBindAttribLocation(gl.funcs, C.GLuint(program), C.GLuint(index), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) +} + +// AttachShader attaches a shader object to a program object. +// +// In order to create an executable, there must be a way to specify the list +// of things that will be linked together. Program objects provide this +// mechanism. Shaders that are to be linked together in a program object must +// first be attached to that program object. This indicates that shader will +// be included in link operations that will be performed on program. +// +// All operations that can be performed on a shader object are valid whether +// or not the shader object is attached to a program object. It is +// permissible to attach a shader object to a program object before source +// code has been loaded into the shader object or before the shader object +// has been compiled. It is permissible to attach multiple shader objects of +// the same type because each may contain a portion of the complete shader. +// It is also permissible to attach a shader object to more than one program +// object. If a shader object is deleted while it is attached to a program +// object, it will be flagged for deletion, and deletion will not occur until +// DetachShader is called to detach it from all program objects to which it +// is attached. +// +// Error GL.INVALID_VALUE is generated if either program or shader is not a +// value generated by OpenGL. GL.INVALID_OPERATION is generated if program +// is not a program object. GL.INVALID_OPERATION is generated if shader is +// not a shader object. GL.INVALID_OPERATION is generated if shader is +// already attached to program. GL.INVALID_OPERATION is generated if +// AttachShader is executed between the execution of Begin and the +// corresponding execution of End. +// +// AttachShader is available in GL version 2.0 or greater. +func (gl *GL) AttachShader(program glbase.Program, shader glbase.Shader) { + C.gl3_2compat_glAttachShader(gl.funcs, C.GLuint(program), C.GLuint(shader)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilMaskSeparate.xml +func (gl *GL) StencilMaskSeparate(face glbase.Enum, mask uint32) { + C.gl3_2compat_glStencilMaskSeparate(gl.funcs, C.GLenum(face), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilFuncSeparate.xml +func (gl *GL) StencilFuncSeparate(face, glfunc glbase.Enum, ref int32, mask uint32) { + C.gl3_2compat_glStencilFuncSeparate(gl.funcs, C.GLenum(face), C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilOpSeparate.xml +func (gl *GL) StencilOpSeparate(face, sfail, dpfail, dppass glbase.Enum) { + C.gl3_2compat_glStencilOpSeparate(gl.funcs, C.GLenum(face), C.GLenum(sfail), C.GLenum(dpfail), C.GLenum(dppass)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawBuffers.xml +func (gl *GL) DrawBuffers(n int, bufs []glbase.Enum) { + C.gl3_2compat_glDrawBuffers(gl.funcs, C.GLsizei(n), (*C.GLenum)(unsafe.Pointer(&bufs[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlendEquationSeparate.xml +func (gl *GL) BlendEquationSeparate(modeRGB, modeAlpha glbase.Enum) { + C.gl3_2compat_glBlendEquationSeparate(gl.funcs, C.GLenum(modeRGB), C.GLenum(modeAlpha)) +} + +// UniformMatrix4x3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4x3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4x3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*3) != 0 { + panic("invalid value length for UniformMatrix4x3fv") + } + count := len(value) / (4 * 3) + C.gl3_2compat_glUniformMatrix4x3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3x4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3x4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3x4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*4) != 0 { + panic("invalid value length for UniformMatrix3x4fv") + } + count := len(value) / (3 * 4) + C.gl3_2compat_glUniformMatrix3x4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix4x2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4x2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4x2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*2) != 0 { + panic("invalid value length for UniformMatrix4x2fv") + } + count := len(value) / (4 * 2) + C.gl3_2compat_glUniformMatrix4x2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2x4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2x4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2x4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*4) != 0 { + panic("invalid value length for UniformMatrix2x4fv") + } + count := len(value) / (2 * 4) + C.gl3_2compat_glUniformMatrix2x4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3x2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3x2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3x2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*2) != 0 { + panic("invalid value length for UniformMatrix3x2fv") + } + count := len(value) / (3 * 2) + C.gl3_2compat_glUniformMatrix3x2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2x3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2x3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2x3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*3) != 0 { + panic("invalid value length for UniformMatrix2x3fv") + } + count := len(value) / (2 * 3) + C.gl3_2compat_glUniformMatrix2x3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsVertexArray.xml +func (gl *GL) IsVertexArray(array uint32) bool { + glresult := C.gl3_2compat_glIsVertexArray(gl.funcs, C.GLuint(array)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGenVertexArrays.xml +func (gl *GL) GenVertexArrays(n int, arrays []uint32) { + C.gl3_2compat_glGenVertexArrays(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&arrays[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDeleteVertexArrays.xml +func (gl *GL) DeleteVertexArrays(n int, arrays []uint32) { + C.gl3_2compat_glDeleteVertexArrays(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&arrays[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindVertexArray.xml +func (gl *GL) BindVertexArray(array uint32) { + C.gl3_2compat_glBindVertexArray(gl.funcs, C.GLuint(array)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFlushMappedBufferRange.xml +func (gl *GL) FlushMappedBufferRange(target glbase.Enum, offset, length int) { + C.gl3_2compat_glFlushMappedBufferRange(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(length)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFramebufferTextureLayer.xml +func (gl *GL) FramebufferTextureLayer(target, attachment glbase.Enum, texture glbase.Texture, level int, layer int32) { + C.gl3_2compat_glFramebufferTextureLayer(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLuint(texture), C.GLint(level), C.GLint(layer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRenderbufferStorageMultisample.xml +func (gl *GL) RenderbufferStorageMultisample(target glbase.Enum, samples int32, internalFormat glbase.Enum, width, height int) { + C.gl3_2compat_glRenderbufferStorageMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlitFramebuffer.xml +func (gl *GL) BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1 int32, mask glbase.Bitfield, filter glbase.Enum) { + C.gl3_2compat_glBlitFramebuffer(gl.funcs, C.GLint(srcX0), C.GLint(srcY0), C.GLint(srcX1), C.GLint(srcY1), C.GLint(dstX0), C.GLint(dstY0), C.GLint(dstX1), C.GLint(dstY1), C.GLbitfield(mask), C.GLenum(filter)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGenerateMipmap.xml +func (gl *GL) GenerateMipmap(target glbase.Enum) { + C.gl3_2compat_glGenerateMipmap(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetFramebufferAttachmentParameteriv.xml +func (gl *GL) GetFramebufferAttachmentParameteriv(target, attachment, pname glbase.Enum, params []int32) { + C.gl3_2compat_glGetFramebufferAttachmentParameteriv(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFramebufferRenderbuffer.xml +func (gl *GL) FramebufferRenderbuffer(target, attachment, renderbuffertarget glbase.Enum, renderbuffer glbase.Renderbuffer) { + C.gl3_2compat_glFramebufferRenderbuffer(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(renderbuffertarget), C.GLuint(renderbuffer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFramebufferTexture3D.xml +func (gl *GL) FramebufferTexture3D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int, zoffset int32) { + C.gl3_2compat_glFramebufferTexture3D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level), C.GLint(zoffset)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFramebufferTexture2D.xml +func (gl *GL) FramebufferTexture2D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int) { + C.gl3_2compat_glFramebufferTexture2D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFramebufferTexture1D.xml +func (gl *GL) FramebufferTexture1D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int) { + C.gl3_2compat_glFramebufferTexture1D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCheckFramebufferStatus.xml +func (gl *GL) CheckFramebufferStatus(target glbase.Enum) glbase.Enum { + glresult := C.gl3_2compat_glCheckFramebufferStatus(gl.funcs, C.GLenum(target)) + return glbase.Enum(glresult) +} + +// GenFramebuffers returns n framebuffer object names in ids. There is no +// guarantee that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenFramebuffers. +// +// Framebuffer object names returned by a call to GenFramebuffers are not +// returned by subsequent calls, unless they are first deleted with +// DeleteFramebuffers. +// +// The names returned in ids are marked as used, for the purposes of +// GenFramebuffers only, but they acquire state and type only when they are +// first bound. +// +// Error GL.INVALID_VALUE is generated if n is negative. +func (gl *GL) GenFramebuffers(n int) []glbase.Framebuffer { + if n == 0 { + return nil + } + framebuffers := make([]glbase.Framebuffer, n) + C.gl3_2compat_glGenFramebuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&framebuffers[0]))) + return framebuffers +} + +// DeleteFramebuffers deletes the framebuffer objects whose names are +// stored in the framebuffers slice. The name zero is reserved by the GL and +// is silently ignored, should it occur in framebuffers, as are other unused +// names. Once a framebuffer object is deleted, its name is again unused and +// it has no attachments. If a framebuffer that is currently bound to one or +// more of the targets GL.DRAW_FRAMEBUFFER or GL.READ_FRAMEBUFFER is deleted, +// it is as though BindFramebuffer had been executed with the corresponding +// target and framebuffer zero. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteFramebuffers is available in GL version 3.0 or greater. +func (gl *GL) DeleteFramebuffers(framebuffers []glbase.Framebuffer) { + n := len(framebuffers) + if n == 0 { + return + } + C.gl3_2compat_glDeleteFramebuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&framebuffers[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindFramebuffer.xml +func (gl *GL) BindFramebuffer(target glbase.Enum, framebuffer glbase.Framebuffer) { + C.gl3_2compat_glBindFramebuffer(gl.funcs, C.GLenum(target), C.GLuint(framebuffer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsFramebuffer.xml +func (gl *GL) IsFramebuffer(framebuffer glbase.Framebuffer) bool { + glresult := C.gl3_2compat_glIsFramebuffer(gl.funcs, C.GLuint(framebuffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetRenderbufferParameteriv.xml +func (gl *GL) GetRenderbufferParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_2compat_glGetRenderbufferParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRenderbufferStorage.xml +func (gl *GL) RenderbufferStorage(target, internalFormat glbase.Enum, width, height int) { + C.gl3_2compat_glRenderbufferStorage(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) +} + +// GenRenderbuffers returns n renderbuffer object names in renderbuffers. +// There is no guarantee that the names form a contiguous set of integers; +// however, it is guaranteed that none of the returned names was in use +// immediately before the call to GenRenderbuffers. +// +// Renderbuffer object names returned by a call to GenRenderbuffers are not +// returned by subsequent calls, unless they are first deleted with +// DeleteRenderbuffers. +// +// The names returned in renderbuffers are marked as used, for the purposes +// of GenRenderbuffers only, but they acquire state and type only when they +// are first bound. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenRenderbuffers is available in GL version 3.0 or greater. +func (gl *GL) GenRenderbuffers(n int) []glbase.Renderbuffer { + if n == 0 { + return nil + } + renderbuffers := make([]glbase.Renderbuffer, n) + C.gl3_2compat_glGenRenderbuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&renderbuffers[0]))) + return renderbuffers +} + +// DeleteRenderbuffers deletes the renderbuffer objects whose names are stored +// in the renderbuffers slice. The name zero is reserved by the GL and +// is silently ignored, should it occur in renderbuffers, as are other unused +// names. Once a renderbuffer object is deleted, its name is again unused and +// it has no contents. If a renderbuffer that is currently bound to the +// target GL.RENDERBUFFER is deleted, it is as though BindRenderbuffer had +// been executed with a target of GL.RENDERBUFFER and a name of zero. +// +// If a renderbuffer object is attached to one or more attachment points in +// the currently bound framebuffer, then it as if FramebufferRenderbuffer +// had been called, with a renderbuffer of zero for each attachment point to +// which this image was attached in the currently bound framebuffer. In other +// words, this renderbuffer object is first detached from all attachment +// ponits in the currently bound framebuffer. Note that the renderbuffer +// image is specifically not detached from any non-bound framebuffers. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteRenderbuffers is available in GL version 3.0 or greater. +func (gl *GL) DeleteRenderbuffers(renderbuffers []glbase.Renderbuffer) { + n := len(renderbuffers) + if n == 0 { + return + } + C.gl3_2compat_glDeleteRenderbuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&renderbuffers[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindRenderbuffer.xml +func (gl *GL) BindRenderbuffer(target glbase.Enum, renderbuffer glbase.Renderbuffer) { + C.gl3_2compat_glBindRenderbuffer(gl.funcs, C.GLenum(target), C.GLuint(renderbuffer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsRenderbuffer.xml +func (gl *GL) IsRenderbuffer(renderbuffer glbase.Renderbuffer) bool { + glresult := C.gl3_2compat_glIsRenderbuffer(gl.funcs, C.GLuint(renderbuffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearBufferfi.xml +func (gl *GL) ClearBufferfi(buffer glbase.Enum, drawbuffer int32, depth float32, stencil int32) { + C.gl3_2compat_glClearBufferfi(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), C.GLfloat(depth), C.GLint(stencil)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearBufferfv.xml +func (gl *GL) ClearBufferfv(buffer glbase.Enum, drawbuffer int32, value []float32) { + C.gl3_2compat_glClearBufferfv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearBufferuiv.xml +func (gl *GL) ClearBufferuiv(buffer glbase.Enum, drawbuffer int32, value []uint32) { + C.gl3_2compat_glClearBufferuiv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearBufferiv.xml +func (gl *GL) ClearBufferiv(buffer glbase.Enum, drawbuffer int32, value []int32) { + C.gl3_2compat_glClearBufferiv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexParameterIuiv.xml +func (gl *GL) GetTexParameterIuiv(target, pname glbase.Enum, params []uint32) { + C.gl3_2compat_glGetTexParameterIuiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexParameterIiv.xml +func (gl *GL) GetTexParameterIiv(target, pname glbase.Enum, params []int32) { + C.gl3_2compat_glGetTexParameterIiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameterIuiv.xml +func (gl *GL) TexParameterIuiv(target, pname glbase.Enum, params []uint32) { + C.gl3_2compat_glTexParameterIuiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameterIiv.xml +func (gl *GL) TexParameterIiv(target, pname glbase.Enum, params []int32) { + C.gl3_2compat_glTexParameterIiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// Uniform4uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4uiv") + } + count := len(value) / 4 + C.gl3_2compat_glUniform4uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform3uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3uiv") + } + count := len(value) / 3 + C.gl3_2compat_glUniform3uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform2uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2uiv") + } + count := len(value) / 2 + C.gl3_2compat_glUniform2uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform1uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl3_2compat_glUniform1uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform4ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4ui(location glbase.Uniform, v0, v1, v2, v3 uint32) { + C.gl3_2compat_glUniform4ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2), C.GLuint(v3)) +} + +// Uniform3ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3ui(location glbase.Uniform, v0, v1, v2 uint32) { + C.gl3_2compat_glUniform3ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2)) +} + +// Uniform2ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2ui(location glbase.Uniform, v0, v1 uint32) { + C.gl3_2compat_glUniform2ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1)) +} + +// Uniform1ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1ui(location glbase.Uniform, v0 uint32) { + C.gl3_2compat_glUniform1ui(gl.funcs, C.GLint(location), C.GLuint(v0)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetFragDataLocation.xml +func (gl *GL) GetFragDataLocation(program glbase.Program, name []byte) int32 { + glresult := C.gl3_2compat_glGetFragDataLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindFragDataLocation.xml +func (gl *GL) BindFragDataLocation(program glbase.Program, color uint32, name []byte) { + C.gl3_2compat_glBindFragDataLocation(gl.funcs, C.GLuint(program), C.GLuint(color), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetUniformuiv.xml +func (gl *GL) GetUniformuiv(program glbase.Program, location glbase.Uniform, params []uint32) { + C.gl3_2compat_glGetUniformuiv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetVertexAttribIuiv.xml +func (gl *GL) GetVertexAttribIuiv(index glbase.Attrib, pname glbase.Enum, params []uint32) { + C.gl3_2compat_glGetVertexAttribIuiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetVertexAttribIiv.xml +func (gl *GL) GetVertexAttribIiv(index glbase.Attrib, pname glbase.Enum, params []int32) { + C.gl3_2compat_glGetVertexAttribIiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribIPointer.xml +func (gl *GL) VertexAttribIPointer(index glbase.Attrib, size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glVertexAttribIPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEndConditionalRender.xml +func (gl *GL) EndConditionalRender() { + C.gl3_2compat_glEndConditionalRender(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBeginConditionalRender.xml +func (gl *GL) BeginConditionalRender(id uint32, mode glbase.Enum) { + C.gl3_2compat_glBeginConditionalRender(gl.funcs, C.GLuint(id), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClampColor.xml +func (gl *GL) ClampColor(target, clamp glbase.Enum) { + C.gl3_2compat_glClampColor(gl.funcs, C.GLenum(target), C.GLenum(clamp)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTransformFeedbackVarying.xml +func (gl *GL) GetTransformFeedbackVarying(program glbase.Program, index uint32, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl3_2compat_glGetTransformFeedbackVarying(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLsizei)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindBufferBase.xml +func (gl *GL) BindBufferBase(target glbase.Enum, index uint32, buffer glbase.Buffer) { + C.gl3_2compat_glBindBufferBase(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindBufferRange.xml +func (gl *GL) BindBufferRange(target glbase.Enum, index uint32, buffer glbase.Buffer, offset, size int) { + C.gl3_2compat_glBindBufferRange(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(buffer), C.GLintptr(offset), C.GLsizeiptr(size)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEndTransformFeedback.xml +func (gl *GL) EndTransformFeedback() { + C.gl3_2compat_glEndTransformFeedback(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBeginTransformFeedback.xml +func (gl *GL) BeginTransformFeedback(primitiveMode glbase.Enum) { + C.gl3_2compat_glBeginTransformFeedback(gl.funcs, C.GLenum(primitiveMode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsEnabledi.xml +func (gl *GL) IsEnabledi(target glbase.Enum, index uint32) bool { + glresult := C.gl3_2compat_glIsEnabledi(gl.funcs, C.GLenum(target), C.GLuint(index)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDisablei.xml +func (gl *GL) Disablei(target glbase.Enum, index uint32) { + C.gl3_2compat_glDisablei(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEnablei.xml +func (gl *GL) Enablei(target glbase.Enum, index uint32) { + C.gl3_2compat_glEnablei(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetIntegeri_v.xml +func (gl *GL) GetIntegeri_v(target glbase.Enum, index uint32, data []int32) { + C.gl3_2compat_glGetIntegeri_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLint)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetBooleani_v.xml +func (gl *GL) GetBooleani_v(target glbase.Enum, index uint32, data []bool) { + C.gl3_2compat_glGetBooleani_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLboolean)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorMaski.xml +func (gl *GL) ColorMaski(index uint32, r, g, b, a bool) { + C.gl3_2compat_glColorMaski(gl.funcs, C.GLuint(index), *(*C.GLboolean)(unsafe.Pointer(&r)), *(*C.GLboolean)(unsafe.Pointer(&g)), *(*C.GLboolean)(unsafe.Pointer(&b)), *(*C.GLboolean)(unsafe.Pointer(&a))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyBufferSubData.xml +func (gl *GL) CopyBufferSubData(readTarget, writeTarget glbase.Enum, readOffset, writeOffset, size int) { + C.gl3_2compat_glCopyBufferSubData(gl.funcs, C.GLenum(readTarget), C.GLenum(writeTarget), C.GLintptr(readOffset), C.GLintptr(writeOffset), C.GLsizeiptr(size)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glUniformBlockBinding.xml +func (gl *GL) UniformBlockBinding(program glbase.Program, v0, v1 uint32) { + C.gl3_2compat_glUniformBlockBinding(gl.funcs, C.GLuint(program), C.GLuint(v0), C.GLuint(v1)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetActiveUniformBlockName.xml +func (gl *GL) GetActiveUniformBlockName(program glbase.Program, uniformBlockIndex uint32, bufSize int32, length []int32, uniformBlockName []byte) { + C.gl3_2compat_glGetActiveUniformBlockName(gl.funcs, C.GLuint(program), C.GLuint(uniformBlockIndex), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&uniformBlockName[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetActiveUniformBlockiv.xml +func (gl *GL) GetActiveUniformBlockiv(program glbase.Program, uniformBlockIndex uint32, pname glbase.Enum, params []int32) { + C.gl3_2compat_glGetActiveUniformBlockiv(gl.funcs, C.GLuint(program), C.GLuint(uniformBlockIndex), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetUniformBlockIndex.xml +func (gl *GL) GetUniformBlockIndex(program glbase.Program, uniformBlockName []byte) uint32 { + glresult := C.gl3_2compat_glGetUniformBlockIndex(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&uniformBlockName[0]))) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetActiveUniformName.xml +func (gl *GL) GetActiveUniformName(program glbase.Program, uniformIndex uint32, bufSize int32, length []int32, uniformName []byte) { + C.gl3_2compat_glGetActiveUniformName(gl.funcs, C.GLuint(program), C.GLuint(uniformIndex), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&uniformName[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetActiveUniformsiv.xml +func (gl *GL) GetActiveUniformsiv(program glbase.Program, uniformCount int32, uniformIndices []uint32, pname glbase.Enum, params []int32) { + C.gl3_2compat_glGetActiveUniformsiv(gl.funcs, C.GLuint(program), C.GLsizei(uniformCount), (*C.GLuint)(unsafe.Pointer(&uniformIndices[0])), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPrimitiveRestartIndex.xml +func (gl *GL) PrimitiveRestartIndex(index uint32) { + C.gl3_2compat_glPrimitiveRestartIndex(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexBuffer.xml +func (gl *GL) TexBuffer(target, internalFormat glbase.Enum, buffer glbase.Buffer) { + C.gl3_2compat_glTexBuffer(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawElementsInstanced.xml +func (gl *GL) DrawElementsInstanced(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, instancecount int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glDrawElementsInstanced(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLsizei(instancecount)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawArraysInstanced.xml +func (gl *GL) DrawArraysInstanced(mode glbase.Enum, first, count int, instancecount int32) { + C.gl3_2compat_glDrawArraysInstanced(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count), C.GLsizei(instancecount)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSampleMaski.xml +func (gl *GL) SampleMaski(index uint32, mask glbase.Bitfield) { + C.gl3_2compat_glSampleMaski(gl.funcs, C.GLuint(index), C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetMultisamplefv.xml +func (gl *GL) GetMultisamplefv(pname glbase.Enum, index uint32, val []float32) { + C.gl3_2compat_glGetMultisamplefv(gl.funcs, C.GLenum(pname), C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&val[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexImage3DMultisample.xml +func (gl *GL) TexImage3DMultisample(target glbase.Enum, samples, internalFormat int32, width, height int, depth int32, fixedsamplelocations bool) { + C.gl3_2compat_glTexImage3DMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), *(*C.GLboolean)(unsafe.Pointer(&fixedsamplelocations))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexImage2DMultisample.xml +func (gl *GL) TexImage2DMultisample(target glbase.Enum, samples, internalFormat int32, width, height int, fixedsamplelocations bool) { + C.gl3_2compat_glTexImage2DMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), *(*C.GLboolean)(unsafe.Pointer(&fixedsamplelocations))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetSynciv.xml +func (gl *GL) GetSynciv(sync glbase.Sync, pname glbase.Enum, bufSize int32, length, values []int32) { + C.gl3_2compat_glGetSynciv(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLenum(pname), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetInteger64v.xml +func (gl *GL) GetInteger64v(pname glbase.Enum, params []int64) { + C.gl3_2compat_glGetInteger64v(gl.funcs, C.GLenum(pname), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWaitSync.xml +func (gl *GL) WaitSync(sync glbase.Sync, flags glbase.Bitfield, timeout uint64) { + C.gl3_2compat_glWaitSync(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLbitfield(flags), C.GLuint64(timeout)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClientWaitSync.xml +func (gl *GL) ClientWaitSync(sync glbase.Sync, flags glbase.Bitfield, timeout uint64) glbase.Enum { + glresult := C.gl3_2compat_glClientWaitSync(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLbitfield(flags), C.GLuint64(timeout)) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDeleteSync.xml +func (gl *GL) DeleteSync(sync glbase.Sync) { + C.gl3_2compat_glDeleteSync(gl.funcs, C.GLsync(unsafe.Pointer(sync))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsSync.xml +func (gl *GL) IsSync(sync glbase.Sync) bool { + glresult := C.gl3_2compat_glIsSync(gl.funcs, C.GLsync(unsafe.Pointer(sync))) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFenceSync.xml +func (gl *GL) FenceSync(condition glbase.Enum, flags glbase.Bitfield) glbase.Sync { + glresult := C.gl3_2compat_glFenceSync(gl.funcs, C.GLenum(condition), C.GLbitfield(flags)) + return glbase.Sync(unsafe.Pointer(glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glProvokingVertex.xml +func (gl *GL) ProvokingVertex(mode glbase.Enum) { + C.gl3_2compat_glProvokingVertex(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawElementsInstancedBaseVertex.xml +func (gl *GL) DrawElementsInstancedBaseVertex(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, instancecount, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glDrawElementsInstancedBaseVertex(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLsizei(instancecount), C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawRangeElementsBaseVertex.xml +func (gl *GL) DrawRangeElementsBaseVertex(mode glbase.Enum, start, end uint32, count int, gltype glbase.Enum, indices interface{}, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glDrawRangeElementsBaseVertex(gl.funcs, C.GLenum(mode), C.GLuint(start), C.GLuint(end), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawElementsBaseVertex.xml +func (gl *GL) DrawElementsBaseVertex(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glDrawElementsBaseVertex(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFramebufferTexture.xml +func (gl *GL) FramebufferTexture(target, attachment glbase.Enum, texture glbase.Texture, level int) { + C.gl3_2compat_glFramebufferTexture(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetBufferParameteri64v.xml +func (gl *GL) GetBufferParameteri64v(target, pname glbase.Enum, params []int64) { + C.gl3_2compat_glGetBufferParameteri64v(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetInteger64i_v.xml +func (gl *GL) GetInteger64i_v(target glbase.Enum, index uint32, data []int64) { + C.gl3_2compat_glGetInteger64i_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLint64)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTranslatef.xml +func (gl *GL) Translatef(x, y, z float32) { + C.gl3_2compat_glTranslatef(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTranslated.xml +func (gl *GL) Translated(x, y, z float64) { + C.gl3_2compat_glTranslated(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glScalef.xml +func (gl *GL) Scalef(x, y, z float32) { + C.gl3_2compat_glScalef(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glScaled.xml +func (gl *GL) Scaled(x, y, z float64) { + C.gl3_2compat_glScaled(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRotatef.xml +func (gl *GL) Rotatef(angle, x, y, z float32) { + C.gl3_2compat_glRotatef(gl.funcs, C.GLfloat(angle), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRotated.xml +func (gl *GL) Rotated(angle, x, y, z float64) { + C.gl3_2compat_glRotated(gl.funcs, C.GLdouble(angle), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPushMatrix.xml +func (gl *GL) PushMatrix() { + C.gl3_2compat_glPushMatrix(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPopMatrix.xml +func (gl *GL) PopMatrix() { + C.gl3_2compat_glPopMatrix(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glOrtho.xml +func (gl *GL) Ortho(left, right, bottom, top, zNear, zFar float64) { + C.gl3_2compat_glOrtho(gl.funcs, C.GLdouble(left), C.GLdouble(right), C.GLdouble(bottom), C.GLdouble(top), C.GLdouble(zNear), C.GLdouble(zFar)) +} + +// MultMatrixd multiplies the current matrix with the provided matrix. +// +// The m parameter must hold 16 consecutive elements of a 4x4 column-major matrix. +// +// The current matrix is determined by the current matrix mode (see +// MatrixMode). It is either the projection matrix, modelview matrix, or the +// texture matrix. +// +// For example, if the current matrix is C and the coordinates to be transformed +// are v = (v[0], v[1], v[2], v[3]), then the current transformation is C × v, or +// +// c[0] c[4] c[8] c[12] v[0] +// c[1] c[5] c[9] c[13] v[1] +// c[2] c[6] c[10] c[14] X v[2] +// c[3] c[7] c[11] c[15] v[3] +// +// Calling MultMatrix with an argument of m = m[0], m[1], ..., m[15] +// replaces the current transformation with (C X M) x v, or +// +// c[0] c[4] c[8] c[12] m[0] m[4] m[8] m[12] v[0] +// c[1] c[5] c[9] c[13] m[1] m[5] m[9] m[13] v[1] +// c[2] c[6] c[10] c[14] X m[2] m[6] m[10] m[14] X v[2] +// c[3] c[7] c[11] c[15] m[3] m[7] m[11] m[15] v[3] +// +// Where 'X' denotes matrix multiplication, and v is represented as a 4x1 matrix. +// +// While the elements of the matrix may be specified with single or double +// precision, the GL may store or operate on these values in less-than-single +// precision. +// +// In many computer languages, 4×4 arrays are represented in row-major +// order. The transformations just described represent these matrices in +// column-major order. The order of the multiplication is important. For +// example, if the current transformation is a rotation, and MultMatrix is +// called with a translation matrix, the translation is done directly on the +// coordinates to be transformed, while the rotation is done on the results +// of that translation. +// +// GL.INVALID_OPERATION is generated if MultMatrix is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) MultMatrixd(m []float64) { + if len(m) != 16 { + panic("parameter m must have length 16 for the 4x4 matrix") + } + C.gl3_2compat_glMultMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// MultMatrixf multiplies the current matrix with the provided matrix. +// +// The m parameter must hold 16 consecutive elements of a 4x4 column-major matrix. +// +// The current matrix is determined by the current matrix mode (see +// MatrixMode). It is either the projection matrix, modelview matrix, or the +// texture matrix. +// +// For example, if the current matrix is C and the coordinates to be transformed +// are v = (v[0], v[1], v[2], v[3]), then the current transformation is C × v, or +// +// c[0] c[4] c[8] c[12] v[0] +// c[1] c[5] c[9] c[13] v[1] +// c[2] c[6] c[10] c[14] X v[2] +// c[3] c[7] c[11] c[15] v[3] +// +// Calling MultMatrix with an argument of m = m[0], m[1], ..., m[15] +// replaces the current transformation with (C X M) x v, or +// +// c[0] c[4] c[8] c[12] m[0] m[4] m[8] m[12] v[0] +// c[1] c[5] c[9] c[13] m[1] m[5] m[9] m[13] v[1] +// c[2] c[6] c[10] c[14] X m[2] m[6] m[10] m[14] X v[2] +// c[3] c[7] c[11] c[15] m[3] m[7] m[11] m[15] v[3] +// +// Where 'X' denotes matrix multiplication, and v is represented as a 4x1 matrix. +// +// While the elements of the matrix may be specified with single or double +// precision, the GL may store or operate on these values in less-than-single +// precision. +// +// In many computer languages, 4×4 arrays are represented in row-major +// order. The transformations just described represent these matrices in +// column-major order. The order of the multiplication is important. For +// example, if the current transformation is a rotation, and MultMatrix is +// called with a translation matrix, the translation is done directly on the +// coordinates to be transformed, while the rotation is done on the results +// of that translation. +// +// GL.INVALID_OPERATION is generated if MultMatrix is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) MultMatrixf(m []float32) { + if len(m) != 16 { + panic("parameter m must have length 16 for the 4x4 matrix") + } + C.gl3_2compat_glMultMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMatrixMode.xml +func (gl *GL) MatrixMode(mode glbase.Enum) { + C.gl3_2compat_glMatrixMode(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLoadMatrixd.xml +func (gl *GL) LoadMatrixd(m []float64) { + C.gl3_2compat_glLoadMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLoadMatrixf.xml +func (gl *GL) LoadMatrixf(m []float32) { + C.gl3_2compat_glLoadMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLoadIdentity.xml +func (gl *GL) LoadIdentity() { + C.gl3_2compat_glLoadIdentity(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFrustum.xml +func (gl *GL) Frustum(left, right, bottom, top, zNear, zFar float64) { + C.gl3_2compat_glFrustum(gl.funcs, C.GLdouble(left), C.GLdouble(right), C.GLdouble(bottom), C.GLdouble(top), C.GLdouble(zNear), C.GLdouble(zFar)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsList.xml +func (gl *GL) IsList(list uint32) bool { + glresult := C.gl3_2compat_glIsList(gl.funcs, C.GLuint(list)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexGeniv.xml +func (gl *GL) GetTexGeniv(coord, pname glbase.Enum, params []int32) { + C.gl3_2compat_glGetTexGeniv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexGenfv.xml +func (gl *GL) GetTexGenfv(coord, pname glbase.Enum, params []float32) { + C.gl3_2compat_glGetTexGenfv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexGendv.xml +func (gl *GL) GetTexGendv(coord, pname glbase.Enum, params []float64) { + C.gl3_2compat_glGetTexGendv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexEnviv.xml +func (gl *GL) GetTexEnviv(target, pname glbase.Enum, params []int32) { + C.gl3_2compat_glGetTexEnviv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexEnvfv.xml +func (gl *GL) GetTexEnvfv(target, pname glbase.Enum, params []float32) { + C.gl3_2compat_glGetTexEnvfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetPolygonStipple.xml +func (gl *GL) GetPolygonStipple(mask []uint8) { + C.gl3_2compat_glGetPolygonStipple(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&mask[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetPixelMapusv.xml +func (gl *GL) GetPixelMapusv(glmap glbase.Enum, values []uint16) { + C.gl3_2compat_glGetPixelMapusv(gl.funcs, C.GLenum(glmap), (*C.GLushort)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetPixelMapuiv.xml +func (gl *GL) GetPixelMapuiv(glmap glbase.Enum, values []uint32) { + C.gl3_2compat_glGetPixelMapuiv(gl.funcs, C.GLenum(glmap), (*C.GLuint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetPixelMapfv.xml +func (gl *GL) GetPixelMapfv(glmap glbase.Enum, values []float32) { + C.gl3_2compat_glGetPixelMapfv(gl.funcs, C.GLenum(glmap), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetMaterialiv.xml +func (gl *GL) GetMaterialiv(face, pname glbase.Enum, params []int32) { + C.gl3_2compat_glGetMaterialiv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetMaterialfv.xml +func (gl *GL) GetMaterialfv(face, pname glbase.Enum, params []float32) { + C.gl3_2compat_glGetMaterialfv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetMapiv.xml +func (gl *GL) GetMapiv(target, query glbase.Enum, v []int32) { + C.gl3_2compat_glGetMapiv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetMapfv.xml +func (gl *GL) GetMapfv(target, query glbase.Enum, v []float32) { + C.gl3_2compat_glGetMapfv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetMapdv.xml +func (gl *GL) GetMapdv(target, query glbase.Enum, v []float64) { + C.gl3_2compat_glGetMapdv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetLightiv.xml +func (gl *GL) GetLightiv(light, pname glbase.Enum, params []int32) { + C.gl3_2compat_glGetLightiv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetLightfv.xml +func (gl *GL) GetLightfv(light, pname glbase.Enum, params []float32) { + C.gl3_2compat_glGetLightfv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetClipPlane.xml +func (gl *GL) GetClipPlane(plane glbase.Enum, equation []float64) { + C.gl3_2compat_glGetClipPlane(gl.funcs, C.GLenum(plane), (*C.GLdouble)(unsafe.Pointer(&equation[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawPixels.xml +func (gl *GL) DrawPixels(width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glDrawPixels(gl.funcs, C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyPixels.xml +func (gl *GL) CopyPixels(x, y, width, height int, gltype glbase.Enum) { + C.gl3_2compat_glCopyPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(gltype)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPixelMapusv.xml +func (gl *GL) PixelMapusv(glmap glbase.Enum, mapsize int32, values []uint16) { + C.gl3_2compat_glPixelMapusv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLushort)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPixelMapuiv.xml +func (gl *GL) PixelMapuiv(glmap glbase.Enum, mapsize int32, values []uint32) { + C.gl3_2compat_glPixelMapuiv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLuint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPixelMapfv.xml +func (gl *GL) PixelMapfv(glmap glbase.Enum, mapsize int32, values []float32) { + C.gl3_2compat_glPixelMapfv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPixelTransferi.xml +func (gl *GL) PixelTransferi(pname glbase.Enum, param int32) { + C.gl3_2compat_glPixelTransferi(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPixelTransferf.xml +func (gl *GL) PixelTransferf(pname glbase.Enum, param float32) { + C.gl3_2compat_glPixelTransferf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPixelZoom.xml +func (gl *GL) PixelZoom(xfactor, yfactor float32) { + C.gl3_2compat_glPixelZoom(gl.funcs, C.GLfloat(xfactor), C.GLfloat(yfactor)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glAlphaFunc.xml +func (gl *GL) AlphaFunc(glfunc glbase.Enum, ref float32) { + C.gl3_2compat_glAlphaFunc(gl.funcs, C.GLenum(glfunc), C.GLfloat(ref)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalPoint2.xml +func (gl *GL) EvalPoint2(i, j int32) { + C.gl3_2compat_glEvalPoint2(gl.funcs, C.GLint(i), C.GLint(j)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalMesh2.xml +func (gl *GL) EvalMesh2(mode glbase.Enum, i1, i2, j1, j2 int32) { + C.gl3_2compat_glEvalMesh2(gl.funcs, C.GLenum(mode), C.GLint(i1), C.GLint(i2), C.GLint(j1), C.GLint(j2)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalPoint1.xml +func (gl *GL) EvalPoint1(i int32) { + C.gl3_2compat_glEvalPoint1(gl.funcs, C.GLint(i)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalMesh1.xml +func (gl *GL) EvalMesh1(mode glbase.Enum, i1, i2 int32) { + C.gl3_2compat_glEvalMesh1(gl.funcs, C.GLenum(mode), C.GLint(i1), C.GLint(i2)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalCoord2fv.xml +func (gl *GL) EvalCoord2fv(u []float32) { + if len(u) != 2 { + panic("parameter u has incorrect length") + } + C.gl3_2compat_glEvalCoord2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalCoord2f.xml +func (gl *GL) EvalCoord2f(u, v float32) { + C.gl3_2compat_glEvalCoord2f(gl.funcs, C.GLfloat(u), C.GLfloat(v)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalCoord2dv.xml +func (gl *GL) EvalCoord2dv(u []float64) { + if len(u) != 2 { + panic("parameter u has incorrect length") + } + C.gl3_2compat_glEvalCoord2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalCoord2d.xml +func (gl *GL) EvalCoord2d(u, v float64) { + C.gl3_2compat_glEvalCoord2d(gl.funcs, C.GLdouble(u), C.GLdouble(v)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalCoord1fv.xml +func (gl *GL) EvalCoord1fv(u []float32) { + C.gl3_2compat_glEvalCoord1fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalCoord1f.xml +func (gl *GL) EvalCoord1f(u float32) { + C.gl3_2compat_glEvalCoord1f(gl.funcs, C.GLfloat(u)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalCoord1dv.xml +func (gl *GL) EvalCoord1dv(u []float64) { + C.gl3_2compat_glEvalCoord1dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalCoord1d.xml +func (gl *GL) EvalCoord1d(u float64) { + C.gl3_2compat_glEvalCoord1d(gl.funcs, C.GLdouble(u)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMapGrid2f.xml +func (gl *GL) MapGrid2f(un int32, u1, u2 float32, vn int32, v1, v2 float32) { + C.gl3_2compat_glMapGrid2f(gl.funcs, C.GLint(un), C.GLfloat(u1), C.GLfloat(u2), C.GLint(vn), C.GLfloat(v1), C.GLfloat(v2)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMapGrid2d.xml +func (gl *GL) MapGrid2d(un int32, u1, u2 float64, vn int32, v1, v2 float64) { + C.gl3_2compat_glMapGrid2d(gl.funcs, C.GLint(un), C.GLdouble(u1), C.GLdouble(u2), C.GLint(vn), C.GLdouble(v1), C.GLdouble(v2)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMapGrid1f.xml +func (gl *GL) MapGrid1f(un int32, u1, u2 float32) { + C.gl3_2compat_glMapGrid1f(gl.funcs, C.GLint(un), C.GLfloat(u1), C.GLfloat(u2)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMapGrid1d.xml +func (gl *GL) MapGrid1d(un int32, u1, u2 float64) { + C.gl3_2compat_glMapGrid1d(gl.funcs, C.GLint(un), C.GLdouble(u1), C.GLdouble(u2)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMap2f.xml +func (gl *GL) Map2f(target glbase.Enum, u1, u2 float32, ustride, uorder int32, v1, v2 float32, vstride, vorder int32, points []float32) { + C.gl3_2compat_glMap2f(gl.funcs, C.GLenum(target), C.GLfloat(u1), C.GLfloat(u2), C.GLint(ustride), C.GLint(uorder), C.GLfloat(v1), C.GLfloat(v2), C.GLint(vstride), C.GLint(vorder), (*C.GLfloat)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMap2d.xml +func (gl *GL) Map2d(target glbase.Enum, u1, u2 float64, ustride, uorder int32, v1, v2 float64, vstride, vorder int32, points []float64) { + C.gl3_2compat_glMap2d(gl.funcs, C.GLenum(target), C.GLdouble(u1), C.GLdouble(u2), C.GLint(ustride), C.GLint(uorder), C.GLdouble(v1), C.GLdouble(v2), C.GLint(vstride), C.GLint(vorder), (*C.GLdouble)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMap1f.xml +func (gl *GL) Map1f(target glbase.Enum, u1, u2 float32, stride, order int, points []float32) { + C.gl3_2compat_glMap1f(gl.funcs, C.GLenum(target), C.GLfloat(u1), C.GLfloat(u2), C.GLint(stride), C.GLint(order), (*C.GLfloat)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMap1d.xml +func (gl *GL) Map1d(target glbase.Enum, u1, u2 float64, stride, order int, points []float64) { + C.gl3_2compat_glMap1d(gl.funcs, C.GLenum(target), C.GLdouble(u1), C.GLdouble(u2), C.GLint(stride), C.GLint(order), (*C.GLdouble)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPushAttrib.xml +func (gl *GL) PushAttrib(mask glbase.Bitfield) { + C.gl3_2compat_glPushAttrib(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPopAttrib.xml +func (gl *GL) PopAttrib() { + C.gl3_2compat_glPopAttrib(gl.funcs) +} + +// Accum executes an operation on the accumulation buffer. +// +// Parameter op defines the accumulation buffer operation (GL.ACCUM, GL.LOAD, +// GL.ADD, GL.MULT, or GL.RETURN) and specifies how the value parameter is +// used. +// +// The accumulation buffer is an extended-range color buffer. Images are not +// rendered into it. Rather, images rendered into one of the color buffers +// are added to the contents of the accumulation buffer after rendering. +// Effects such as antialiasing (of points, lines, and polygons), motion +// blur, and depth of field can be created by accumulating images generated +// with different transformation matrices. +// +// Each pixel in the accumulation buffer consists of red, green, blue, and +// alpha values. The number of bits per component in the accumulation buffer +// depends on the implementation. You can examine this number by calling +// GetIntegerv four times, with arguments GL.ACCUM_RED_BITS, +// GL.ACCUM_GREEN_BITS, GL.ACCUM_BLUE_BITS, and GL.ACCUM_ALPHA_BITS. +// Regardless of the number of bits per component, the range of values stored +// by each component is (-1, 1). The accumulation buffer pixels are mapped +// one-to-one with frame buffer pixels. +// +// All accumulation buffer operations are limited to the area of the current +// scissor box and applied identically to the red, green, blue, and alpha +// components of each pixel. If a Accum operation results in a value outside +// the range (-1, 1), the contents of an accumulation buffer pixel component +// are undefined. +// +// The operations are as follows: +// +// GL.ACCUM +// Obtains R, G, B, and A values from the buffer currently selected for +// reading (see ReadBuffer). Each component value is divided by 2 n - +// 1 , where n is the number of bits allocated to each color component +// in the currently selected buffer. The result is a floating-point +// value in the range 0 1 , which is multiplied by value and added to +// the corresponding pixel component in the accumulation buffer, +// thereby updating the accumulation buffer. +// +// GL.LOAD +// Similar to GL.ACCUM, except that the current value in the +// accumulation buffer is not used in the calculation of the new value. +// That is, the R, G, B, and A values from the currently selected +// buffer are divided by 2 n - 1 , multiplied by value, and then stored +// in the corresponding accumulation buffer cell, overwriting the +// current value. +// +// GL.ADD +// Adds value to each R, G, B, and A in the accumulation buffer. +// +// GL.MULT +// Multiplies each R, G, B, and A in the accumulation buffer by value +// and returns the scaled component to its corresponding accumulation +// buffer location. +// +// GL.RETURN +// Transfers accumulation buffer values to the color buffer or buffers +// currently selected for writing. Each R, G, B, and A component is +// multiplied by value, then multiplied by 2 n - 1 , clamped to the +// range 0 2 n - 1 , and stored in the corresponding display buffer +// cell. The only fragment operations that are applied to this transfer +// are pixel ownership, scissor, dithering, and color writemasks. +// +// To clear the accumulation buffer, call ClearAccum with R, G, B, and A +// values to set it to, then call Clear with the accumulation buffer +// enabled. +// +// Error GL.INVALID_ENUM is generated if op is not an accepted value. +// GL.INVALID_OPERATION is generated if there is no accumulation buffer. +// GL.INVALID_OPERATION is generated if Accum is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) Accum(op glbase.Enum, value float32) { + C.gl3_2compat_glAccum(gl.funcs, C.GLenum(op), C.GLfloat(value)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexMask.xml +func (gl *GL) IndexMask(mask uint32) { + C.gl3_2compat_glIndexMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearIndex.xml +func (gl *GL) ClearIndex(c float32) { + C.gl3_2compat_glClearIndex(gl.funcs, C.GLfloat(c)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearAccum.xml +func (gl *GL) ClearAccum(red, green, blue, alpha float32) { + C.gl3_2compat_glClearAccum(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPushName.xml +func (gl *GL) PushName(name uint32) { + C.gl3_2compat_glPushName(gl.funcs, C.GLuint(name)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPopName.xml +func (gl *GL) PopName() { + C.gl3_2compat_glPopName(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPassThrough.xml +func (gl *GL) PassThrough(token float32) { + C.gl3_2compat_glPassThrough(gl.funcs, C.GLfloat(token)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLoadName.xml +func (gl *GL) LoadName(name uint32) { + C.gl3_2compat_glLoadName(gl.funcs, C.GLuint(name)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glInitNames.xml +func (gl *GL) InitNames() { + C.gl3_2compat_glInitNames(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRenderMode.xml +func (gl *GL) RenderMode(mode glbase.Enum) int32 { + glresult := C.gl3_2compat_glRenderMode(gl.funcs, C.GLenum(mode)) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSelectBuffer.xml +func (gl *GL) SelectBuffer(size int, buffer []glbase.Buffer) { + C.gl3_2compat_glSelectBuffer(gl.funcs, C.GLsizei(size), (*C.GLuint)(unsafe.Pointer(&buffer[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFeedbackBuffer.xml +func (gl *GL) FeedbackBuffer(size int, gltype glbase.Enum, buffer []float32) { + C.gl3_2compat_glFeedbackBuffer(gl.funcs, C.GLsizei(size), C.GLenum(gltype), (*C.GLfloat)(unsafe.Pointer(&buffer[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexGeniv.xml +func (gl *GL) TexGeniv(coord, pname glbase.Enum, params []int32) { + C.gl3_2compat_glTexGeniv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexGeni.xml +func (gl *GL) TexGeni(coord, pname glbase.Enum, param int32) { + C.gl3_2compat_glTexGeni(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexGenfv.xml +func (gl *GL) TexGenfv(coord, pname glbase.Enum, params []float32) { + C.gl3_2compat_glTexGenfv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexGenf.xml +func (gl *GL) TexGenf(coord, pname glbase.Enum, param float32) { + C.gl3_2compat_glTexGenf(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexGendv.xml +func (gl *GL) TexGendv(coord, pname glbase.Enum, params []float64) { + C.gl3_2compat_glTexGendv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexGend.xml +func (gl *GL) TexGend(coord, pname glbase.Enum, param float64) { + C.gl3_2compat_glTexGend(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLdouble(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexEnviv.xml +func (gl *GL) TexEnviv(target, pname glbase.Enum, params []int32) { + C.gl3_2compat_glTexEnviv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexEnvi.xml +func (gl *GL) TexEnvi(target, pname glbase.Enum, param int32) { + C.gl3_2compat_glTexEnvi(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexEnvfv.xml +func (gl *GL) TexEnvfv(target, pname glbase.Enum, params []float32) { + C.gl3_2compat_glTexEnvfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexEnvf.xml +func (gl *GL) TexEnvf(target, pname glbase.Enum, param float32) { + C.gl3_2compat_glTexEnvf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glShadeModel.xml +func (gl *GL) ShadeModel(mode glbase.Enum) { + C.gl3_2compat_glShadeModel(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPolygonStipple.xml +func (gl *GL) PolygonStipple(mask []uint8) { + C.gl3_2compat_glPolygonStipple(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&mask[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMaterialiv.xml +func (gl *GL) Materialiv(face, pname glbase.Enum, params []int32) { + C.gl3_2compat_glMaterialiv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMateriali.xml +func (gl *GL) Materiali(face, pname glbase.Enum, param int32) { + C.gl3_2compat_glMateriali(gl.funcs, C.GLenum(face), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMaterialfv.xml +func (gl *GL) Materialfv(face, pname glbase.Enum, params []float32) { + C.gl3_2compat_glMaterialfv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMaterialf.xml +func (gl *GL) Materialf(face, pname glbase.Enum, param float32) { + C.gl3_2compat_glMaterialf(gl.funcs, C.GLenum(face), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLineStipple.xml +func (gl *GL) LineStipple(factor int32, pattern uint16) { + C.gl3_2compat_glLineStipple(gl.funcs, C.GLint(factor), C.GLushort(pattern)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLightModeliv.xml +func (gl *GL) LightModeliv(pname glbase.Enum, params []int32) { + C.gl3_2compat_glLightModeliv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLightModeli.xml +func (gl *GL) LightModeli(pname glbase.Enum, param int32) { + C.gl3_2compat_glLightModeli(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLightModelfv.xml +func (gl *GL) LightModelfv(pname glbase.Enum, params []float32) { + C.gl3_2compat_glLightModelfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLightModelf.xml +func (gl *GL) LightModelf(pname glbase.Enum, param float32) { + C.gl3_2compat_glLightModelf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLightiv.xml +func (gl *GL) Lightiv(light, pname glbase.Enum, params []int32) { + C.gl3_2compat_glLightiv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLighti.xml +func (gl *GL) Lighti(light, pname glbase.Enum, param int32) { + C.gl3_2compat_glLighti(gl.funcs, C.GLenum(light), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLightfv.xml +func (gl *GL) Lightfv(light, pname glbase.Enum, params []float32) { + C.gl3_2compat_glLightfv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLightf.xml +func (gl *GL) Lightf(light, pname glbase.Enum, param float32) { + C.gl3_2compat_glLightf(gl.funcs, C.GLenum(light), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFogiv.xml +func (gl *GL) Fogiv(pname glbase.Enum, params []int32) { + C.gl3_2compat_glFogiv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFogi.xml +func (gl *GL) Fogi(pname glbase.Enum, param int32) { + C.gl3_2compat_glFogi(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFogfv.xml +func (gl *GL) Fogfv(pname glbase.Enum, params []float32) { + C.gl3_2compat_glFogfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFogf.xml +func (gl *GL) Fogf(pname glbase.Enum, param float32) { + C.gl3_2compat_glFogf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorMaterial.xml +func (gl *GL) ColorMaterial(face, mode glbase.Enum) { + C.gl3_2compat_glColorMaterial(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClipPlane.xml +func (gl *GL) ClipPlane(plane glbase.Enum, equation []float64) { + C.gl3_2compat_glClipPlane(gl.funcs, C.GLenum(plane), (*C.GLdouble)(unsafe.Pointer(&equation[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex4sv.xml +func (gl *GL) Vertex4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glVertex4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex4s.xml +func (gl *GL) Vertex4s(x, y, z, w int16) { + C.gl3_2compat_glVertex4s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex4iv.xml +func (gl *GL) Vertex4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glVertex4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex4i.xml +func (gl *GL) Vertex4i(x, y, z, w int) { + C.gl3_2compat_glVertex4i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex4fv.xml +func (gl *GL) Vertex4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glVertex4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex4f.xml +func (gl *GL) Vertex4f(x, y, z, w float32) { + C.gl3_2compat_glVertex4f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex4dv.xml +func (gl *GL) Vertex4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glVertex4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex4d.xml +func (gl *GL) Vertex4d(x, y, z, w float64) { + C.gl3_2compat_glVertex4d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex3sv.xml +func (gl *GL) Vertex3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glVertex3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex3s.xml +func (gl *GL) Vertex3s(x, y, z int16) { + C.gl3_2compat_glVertex3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex3iv.xml +func (gl *GL) Vertex3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glVertex3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex3i.xml +func (gl *GL) Vertex3i(x, y, z int) { + C.gl3_2compat_glVertex3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex3fv.xml +func (gl *GL) Vertex3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glVertex3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex3f.xml +func (gl *GL) Vertex3f(x, y, z float32) { + C.gl3_2compat_glVertex3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex3dv.xml +func (gl *GL) Vertex3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glVertex3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex3d.xml +func (gl *GL) Vertex3d(x, y, z float64) { + C.gl3_2compat_glVertex3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex2sv.xml +func (gl *GL) Vertex2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glVertex2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex2s.xml +func (gl *GL) Vertex2s(x, y int16) { + C.gl3_2compat_glVertex2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex2iv.xml +func (gl *GL) Vertex2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glVertex2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex2i.xml +func (gl *GL) Vertex2i(x, y int) { + C.gl3_2compat_glVertex2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex2fv.xml +func (gl *GL) Vertex2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glVertex2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex2f.xml +func (gl *GL) Vertex2f(x, y float32) { + C.gl3_2compat_glVertex2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex2dv.xml +func (gl *GL) Vertex2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glVertex2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex2d.xml +func (gl *GL) Vertex2d(x, y float64) { + C.gl3_2compat_glVertex2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord4sv.xml +func (gl *GL) TexCoord4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glTexCoord4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord4s.xml +func (gl *GL) TexCoord4s(s, t, r, q int16) { + C.gl3_2compat_glTexCoord4s(gl.funcs, C.GLshort(s), C.GLshort(t), C.GLshort(r), C.GLshort(q)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord4iv.xml +func (gl *GL) TexCoord4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glTexCoord4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord4i.xml +func (gl *GL) TexCoord4i(s, t, r, q int32) { + C.gl3_2compat_glTexCoord4i(gl.funcs, C.GLint(s), C.GLint(t), C.GLint(r), C.GLint(q)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord4fv.xml +func (gl *GL) TexCoord4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glTexCoord4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord4f.xml +func (gl *GL) TexCoord4f(s, t, r, q float32) { + C.gl3_2compat_glTexCoord4f(gl.funcs, C.GLfloat(s), C.GLfloat(t), C.GLfloat(r), C.GLfloat(q)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord4dv.xml +func (gl *GL) TexCoord4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glTexCoord4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord4d.xml +func (gl *GL) TexCoord4d(s, t, r, q float64) { + C.gl3_2compat_glTexCoord4d(gl.funcs, C.GLdouble(s), C.GLdouble(t), C.GLdouble(r), C.GLdouble(q)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord3sv.xml +func (gl *GL) TexCoord3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glTexCoord3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord3s.xml +func (gl *GL) TexCoord3s(s, t, r int16) { + C.gl3_2compat_glTexCoord3s(gl.funcs, C.GLshort(s), C.GLshort(t), C.GLshort(r)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord3iv.xml +func (gl *GL) TexCoord3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glTexCoord3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord3i.xml +func (gl *GL) TexCoord3i(s, t, r int32) { + C.gl3_2compat_glTexCoord3i(gl.funcs, C.GLint(s), C.GLint(t), C.GLint(r)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord3fv.xml +func (gl *GL) TexCoord3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glTexCoord3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord3f.xml +func (gl *GL) TexCoord3f(s, t, r float32) { + C.gl3_2compat_glTexCoord3f(gl.funcs, C.GLfloat(s), C.GLfloat(t), C.GLfloat(r)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord3dv.xml +func (gl *GL) TexCoord3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glTexCoord3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord3d.xml +func (gl *GL) TexCoord3d(s, t, r float64) { + C.gl3_2compat_glTexCoord3d(gl.funcs, C.GLdouble(s), C.GLdouble(t), C.GLdouble(r)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord2sv.xml +func (gl *GL) TexCoord2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glTexCoord2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord2s.xml +func (gl *GL) TexCoord2s(s, t int16) { + C.gl3_2compat_glTexCoord2s(gl.funcs, C.GLshort(s), C.GLshort(t)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord2iv.xml +func (gl *GL) TexCoord2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glTexCoord2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord2i.xml +func (gl *GL) TexCoord2i(s, t int32) { + C.gl3_2compat_glTexCoord2i(gl.funcs, C.GLint(s), C.GLint(t)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord2fv.xml +func (gl *GL) TexCoord2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glTexCoord2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord2f.xml +func (gl *GL) TexCoord2f(s, t float32) { + C.gl3_2compat_glTexCoord2f(gl.funcs, C.GLfloat(s), C.GLfloat(t)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord2dv.xml +func (gl *GL) TexCoord2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glTexCoord2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord2d.xml +func (gl *GL) TexCoord2d(s, t float64) { + C.gl3_2compat_glTexCoord2d(gl.funcs, C.GLdouble(s), C.GLdouble(t)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord1sv.xml +func (gl *GL) TexCoord1sv(v []int16) { + C.gl3_2compat_glTexCoord1sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord1s.xml +func (gl *GL) TexCoord1s(s int16) { + C.gl3_2compat_glTexCoord1s(gl.funcs, C.GLshort(s)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord1iv.xml +func (gl *GL) TexCoord1iv(v []int32) { + C.gl3_2compat_glTexCoord1iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord1i.xml +func (gl *GL) TexCoord1i(s int32) { + C.gl3_2compat_glTexCoord1i(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord1fv.xml +func (gl *GL) TexCoord1fv(v []float32) { + C.gl3_2compat_glTexCoord1fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord1f.xml +func (gl *GL) TexCoord1f(s float32) { + C.gl3_2compat_glTexCoord1f(gl.funcs, C.GLfloat(s)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord1dv.xml +func (gl *GL) TexCoord1dv(v []float64) { + C.gl3_2compat_glTexCoord1dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord1d.xml +func (gl *GL) TexCoord1d(s float64) { + C.gl3_2compat_glTexCoord1d(gl.funcs, C.GLdouble(s)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRectsv.xml +func (gl *GL) Rectsv(v1, v2 []int16) { + C.gl3_2compat_glRectsv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v1[0])), (*C.GLshort)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRects.xml +func (gl *GL) Rects(x1, y1, x2, y2 int16) { + C.gl3_2compat_glRects(gl.funcs, C.GLshort(x1), C.GLshort(y1), C.GLshort(x2), C.GLshort(y2)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRectiv.xml +func (gl *GL) Rectiv(v1, v2 []int32) { + C.gl3_2compat_glRectiv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v1[0])), (*C.GLint)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRecti.xml +func (gl *GL) Recti(x1, y1, x2, y2 int32) { + C.gl3_2compat_glRecti(gl.funcs, C.GLint(x1), C.GLint(y1), C.GLint(x2), C.GLint(y2)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRectfv.xml +func (gl *GL) Rectfv(v1, v2 []float32) { + C.gl3_2compat_glRectfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v1[0])), (*C.GLfloat)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRectf.xml +func (gl *GL) Rectf(x1, y1, x2, y2 float32) { + C.gl3_2compat_glRectf(gl.funcs, C.GLfloat(x1), C.GLfloat(y1), C.GLfloat(x2), C.GLfloat(y2)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRectdv.xml +func (gl *GL) Rectdv(v1, v2 []float64) { + C.gl3_2compat_glRectdv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v1[0])), (*C.GLdouble)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRectd.xml +func (gl *GL) Rectd(x1, y1, x2, y2 float64) { + C.gl3_2compat_glRectd(gl.funcs, C.GLdouble(x1), C.GLdouble(y1), C.GLdouble(x2), C.GLdouble(y2)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos4sv.xml +func (gl *GL) RasterPos4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glRasterPos4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos4s.xml +func (gl *GL) RasterPos4s(x, y, z, w int16) { + C.gl3_2compat_glRasterPos4s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos4iv.xml +func (gl *GL) RasterPos4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glRasterPos4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos4i.xml +func (gl *GL) RasterPos4i(x, y, z, w int) { + C.gl3_2compat_glRasterPos4i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos4fv.xml +func (gl *GL) RasterPos4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glRasterPos4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos4f.xml +func (gl *GL) RasterPos4f(x, y, z, w float32) { + C.gl3_2compat_glRasterPos4f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos4dv.xml +func (gl *GL) RasterPos4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glRasterPos4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos4d.xml +func (gl *GL) RasterPos4d(x, y, z, w float64) { + C.gl3_2compat_glRasterPos4d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos3sv.xml +func (gl *GL) RasterPos3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glRasterPos3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos3s.xml +func (gl *GL) RasterPos3s(x, y, z int16) { + C.gl3_2compat_glRasterPos3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos3iv.xml +func (gl *GL) RasterPos3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glRasterPos3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos3i.xml +func (gl *GL) RasterPos3i(x, y, z int) { + C.gl3_2compat_glRasterPos3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos3fv.xml +func (gl *GL) RasterPos3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glRasterPos3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos3f.xml +func (gl *GL) RasterPos3f(x, y, z float32) { + C.gl3_2compat_glRasterPos3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos3dv.xml +func (gl *GL) RasterPos3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glRasterPos3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos3d.xml +func (gl *GL) RasterPos3d(x, y, z float64) { + C.gl3_2compat_glRasterPos3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos2sv.xml +func (gl *GL) RasterPos2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glRasterPos2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos2s.xml +func (gl *GL) RasterPos2s(x, y int16) { + C.gl3_2compat_glRasterPos2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos2iv.xml +func (gl *GL) RasterPos2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glRasterPos2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos2i.xml +func (gl *GL) RasterPos2i(x, y int) { + C.gl3_2compat_glRasterPos2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos2fv.xml +func (gl *GL) RasterPos2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glRasterPos2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos2f.xml +func (gl *GL) RasterPos2f(x, y float32) { + C.gl3_2compat_glRasterPos2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos2dv.xml +func (gl *GL) RasterPos2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glRasterPos2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos2d.xml +func (gl *GL) RasterPos2d(x, y float64) { + C.gl3_2compat_glRasterPos2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormal3sv.xml +func (gl *GL) Normal3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glNormal3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormal3s.xml +func (gl *GL) Normal3s(nx, ny, nz int16) { + C.gl3_2compat_glNormal3s(gl.funcs, C.GLshort(nx), C.GLshort(ny), C.GLshort(nz)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormal3iv.xml +func (gl *GL) Normal3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glNormal3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormal3i.xml +func (gl *GL) Normal3i(nx, ny, nz int32) { + C.gl3_2compat_glNormal3i(gl.funcs, C.GLint(nx), C.GLint(ny), C.GLint(nz)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormal3fv.xml +func (gl *GL) Normal3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glNormal3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormal3f.xml +func (gl *GL) Normal3f(nx, ny, nz float32) { + C.gl3_2compat_glNormal3f(gl.funcs, C.GLfloat(nx), C.GLfloat(ny), C.GLfloat(nz)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormal3dv.xml +func (gl *GL) Normal3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glNormal3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormal3d.xml +func (gl *GL) Normal3d(nx, ny, nz float64) { + C.gl3_2compat_glNormal3d(gl.funcs, C.GLdouble(nx), C.GLdouble(ny), C.GLdouble(nz)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormal3bv.xml +func (gl *GL) Normal3bv(v []byte) { + C.gl3_2compat_glNormal3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormal3b.xml +func (gl *GL) Normal3b(nx, ny, nz byte) { + C.gl3_2compat_glNormal3b(gl.funcs, C.GLbyte(nx), C.GLbyte(ny), C.GLbyte(nz)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexsv.xml +func (gl *GL) Indexsv(c []int16) { + C.gl3_2compat_glIndexsv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexs.xml +func (gl *GL) Indexs(c int16) { + C.gl3_2compat_glIndexs(gl.funcs, C.GLshort(c)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexiv.xml +func (gl *GL) Indexiv(c []int32) { + C.gl3_2compat_glIndexiv(gl.funcs, (*C.GLint)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexi.xml +func (gl *GL) Indexi(c int32) { + C.gl3_2compat_glIndexi(gl.funcs, C.GLint(c)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexfv.xml +func (gl *GL) Indexfv(c []float32) { + C.gl3_2compat_glIndexfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexf.xml +func (gl *GL) Indexf(c float32) { + C.gl3_2compat_glIndexf(gl.funcs, C.GLfloat(c)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexdv.xml +func (gl *GL) Indexdv(c []float64) { + C.gl3_2compat_glIndexdv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexd.xml +func (gl *GL) Indexd(c float64) { + C.gl3_2compat_glIndexd(gl.funcs, C.GLdouble(c)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEnd.xml +func (gl *GL) End() { + C.gl3_2compat_glEnd(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEdgeFlagv.xml +func (gl *GL) EdgeFlagv(flag []bool) { + C.gl3_2compat_glEdgeFlagv(gl.funcs, (*C.GLboolean)(unsafe.Pointer(&flag[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEdgeFlag.xml +func (gl *GL) EdgeFlag(flag bool) { + C.gl3_2compat_glEdgeFlag(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4usv.xml +func (gl *GL) Color4usv(v []uint16) { + C.gl3_2compat_glColor4usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4us.xml +func (gl *GL) Color4us(red, green, blue, alpha uint16) { + C.gl3_2compat_glColor4us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue), C.GLushort(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4uiv.xml +func (gl *GL) Color4uiv(v []uint32) { + C.gl3_2compat_glColor4uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4ui.xml +func (gl *GL) Color4ui(red, green, blue, alpha uint32) { + C.gl3_2compat_glColor4ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue), C.GLuint(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4ubv.xml +func (gl *GL) Color4ubv(v []uint8) { + C.gl3_2compat_glColor4ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4ub.xml +func (gl *GL) Color4ub(red, green, blue, alpha uint8) { + C.gl3_2compat_glColor4ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue), C.GLubyte(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4sv.xml +func (gl *GL) Color4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glColor4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4s.xml +func (gl *GL) Color4s(red, green, blue, alpha int16) { + C.gl3_2compat_glColor4s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue), C.GLshort(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4iv.xml +func (gl *GL) Color4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glColor4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4i.xml +func (gl *GL) Color4i(red, green, blue, alpha int32) { + C.gl3_2compat_glColor4i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue), C.GLint(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4fv.xml +func (gl *GL) Color4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glColor4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4f.xml +func (gl *GL) Color4f(red, green, blue, alpha float32) { + C.gl3_2compat_glColor4f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4dv.xml +func (gl *GL) Color4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glColor4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4d.xml +func (gl *GL) Color4d(red, green, blue, alpha float64) { + C.gl3_2compat_glColor4d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue), C.GLdouble(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4bv.xml +func (gl *GL) Color4bv(v []byte) { + C.gl3_2compat_glColor4bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4b.xml +func (gl *GL) Color4b(red, green, blue, alpha byte) { + C.gl3_2compat_glColor4b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue), C.GLbyte(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3usv.xml +func (gl *GL) Color3usv(v []uint16) { + C.gl3_2compat_glColor3usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3us.xml +func (gl *GL) Color3us(red, green, blue uint16) { + C.gl3_2compat_glColor3us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3uiv.xml +func (gl *GL) Color3uiv(v []uint32) { + C.gl3_2compat_glColor3uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3ui.xml +func (gl *GL) Color3ui(red, green, blue uint32) { + C.gl3_2compat_glColor3ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3ubv.xml +func (gl *GL) Color3ubv(v []uint8) { + C.gl3_2compat_glColor3ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3ub.xml +func (gl *GL) Color3ub(red, green, blue uint8) { + C.gl3_2compat_glColor3ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3sv.xml +func (gl *GL) Color3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glColor3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3s.xml +func (gl *GL) Color3s(red, green, blue int16) { + C.gl3_2compat_glColor3s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3iv.xml +func (gl *GL) Color3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glColor3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3i.xml +func (gl *GL) Color3i(red, green, blue int32) { + C.gl3_2compat_glColor3i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3fv.xml +func (gl *GL) Color3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glColor3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3f.xml +func (gl *GL) Color3f(red, green, blue float32) { + C.gl3_2compat_glColor3f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3dv.xml +func (gl *GL) Color3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glColor3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3d.xml +func (gl *GL) Color3d(red, green, blue float64) { + C.gl3_2compat_glColor3d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3bv.xml +func (gl *GL) Color3bv(v []byte) { + C.gl3_2compat_glColor3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3b.xml +func (gl *GL) Color3b(red, green, blue byte) { + C.gl3_2compat_glColor3b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBitmap.xml +func (gl *GL) Bitmap(width, height int, xorig, yorig, xmove, ymove float32, bitmap []uint8) { + C.gl3_2compat_glBitmap(gl.funcs, C.GLsizei(width), C.GLsizei(height), C.GLfloat(xorig), C.GLfloat(yorig), C.GLfloat(xmove), C.GLfloat(ymove), (*C.GLubyte)(unsafe.Pointer(&bitmap[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBegin.xml +func (gl *GL) Begin(mode glbase.Enum) { + C.gl3_2compat_glBegin(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glListBase.xml +func (gl *GL) ListBase(base uint32) { + C.gl3_2compat_glListBase(gl.funcs, C.GLuint(base)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGenLists.xml +func (gl *GL) GenLists(range_ int32) uint32 { + glresult := C.gl3_2compat_glGenLists(gl.funcs, C.GLsizei(range_)) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDeleteLists.xml +func (gl *GL) DeleteLists(list uint32, range_ int32) { + C.gl3_2compat_glDeleteLists(gl.funcs, C.GLuint(list), C.GLsizei(range_)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCallLists.xml +func (gl *GL) CallLists(n int, gltype glbase.Enum, lists interface{}) { + var lists_ptr unsafe.Pointer + var lists_v = reflect.ValueOf(lists) + if lists != nil && lists_v.Kind() != reflect.Slice { + panic("parameter lists must be a slice") + } + if lists != nil { + lists_ptr = unsafe.Pointer(lists_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glCallLists(gl.funcs, C.GLsizei(n), C.GLenum(gltype), lists_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCallList.xml +func (gl *GL) CallList(list uint32) { + C.gl3_2compat_glCallList(gl.funcs, C.GLuint(list)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEndList.xml +func (gl *GL) EndList() { + C.gl3_2compat_glEndList(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNewList.xml +func (gl *GL) NewList(list uint32, mode glbase.Enum) { + C.gl3_2compat_glNewList(gl.funcs, C.GLuint(list), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPushClientAttrib.xml +func (gl *GL) PushClientAttrib(mask glbase.Bitfield) { + C.gl3_2compat_glPushClientAttrib(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPopClientAttrib.xml +func (gl *GL) PopClientAttrib() { + C.gl3_2compat_glPopClientAttrib(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPrioritizeTextures.xml +func (gl *GL) PrioritizeTextures(n int, textures []glbase.Texture, priorities []float32) { + C.gl3_2compat_glPrioritizeTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0])), (*C.GLfloat)(unsafe.Pointer(&priorities[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glAreTexturesResident.xml +func (gl *GL) AreTexturesResident(n int, textures []glbase.Texture, residences []bool) bool { + glresult := C.gl3_2compat_glAreTexturesResident(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0])), (*C.GLboolean)(unsafe.Pointer(&residences[0]))) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexPointer.xml +func (gl *GL) VertexPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glVertexPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoordPointer.xml +func (gl *GL) TexCoordPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glTexCoordPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormalPointer.xml +func (gl *GL) NormalPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glNormalPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glInterleavedArrays.xml +func (gl *GL) InterleavedArrays(format glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glInterleavedArrays(gl.funcs, C.GLenum(format), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexPointer.xml +func (gl *GL) IndexPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glIndexPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEnableClientState.xml +func (gl *GL) EnableClientState(array glbase.Enum) { + C.gl3_2compat_glEnableClientState(gl.funcs, C.GLenum(array)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEdgeFlagPointer.xml +func (gl *GL) EdgeFlagPointer(stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glEdgeFlagPointer(gl.funcs, C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDisableClientState.xml +func (gl *GL) DisableClientState(array glbase.Enum) { + C.gl3_2compat_glDisableClientState(gl.funcs, C.GLenum(array)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorPointer.xml +func (gl *GL) ColorPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glColorPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glArrayElement.xml +func (gl *GL) ArrayElement(i int32) { + C.gl3_2compat_glArrayElement(gl.funcs, C.GLint(i)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glResetMinmax.xml +func (gl *GL) ResetMinmax(target glbase.Enum) { + C.gl3_2compat_glResetMinmax(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glResetHistogram.xml +func (gl *GL) ResetHistogram(target glbase.Enum) { + C.gl3_2compat_glResetHistogram(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMinmax.xml +func (gl *GL) Minmax(target, internalFormat glbase.Enum, sink bool) { + C.gl3_2compat_glMinmax(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), *(*C.GLboolean)(unsafe.Pointer(&sink))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glHistogram.xml +func (gl *GL) Histogram(target glbase.Enum, width int, internalFormat glbase.Enum, sink bool) { + C.gl3_2compat_glHistogram(gl.funcs, C.GLenum(target), C.GLsizei(width), C.GLenum(internalFormat), *(*C.GLboolean)(unsafe.Pointer(&sink))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetMinmaxParameteriv.xml +func (gl *GL) GetMinmaxParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_2compat_glGetMinmaxParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetMinmaxParameterfv.xml +func (gl *GL) GetMinmaxParameterfv(target, pname glbase.Enum, params []float32) { + C.gl3_2compat_glGetMinmaxParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetMinmax.xml +func (gl *GL) GetMinmax(target glbase.Enum, reset bool, format, gltype glbase.Enum, values interface{}) { + var values_ptr unsafe.Pointer + var values_v = reflect.ValueOf(values) + if values != nil && values_v.Kind() != reflect.Slice { + panic("parameter values must be a slice") + } + if values != nil { + values_ptr = unsafe.Pointer(values_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glGetMinmax(gl.funcs, C.GLenum(target), *(*C.GLboolean)(unsafe.Pointer(&reset)), C.GLenum(format), C.GLenum(gltype), values_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetHistogramParameteriv.xml +func (gl *GL) GetHistogramParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_2compat_glGetHistogramParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetHistogramParameterfv.xml +func (gl *GL) GetHistogramParameterfv(target, pname glbase.Enum, params []float32) { + C.gl3_2compat_glGetHistogramParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetHistogram.xml +func (gl *GL) GetHistogram(target glbase.Enum, reset bool, format, gltype glbase.Enum, values interface{}) { + var values_ptr unsafe.Pointer + var values_v = reflect.ValueOf(values) + if values != nil && values_v.Kind() != reflect.Slice { + panic("parameter values must be a slice") + } + if values != nil { + values_ptr = unsafe.Pointer(values_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glGetHistogram(gl.funcs, C.GLenum(target), *(*C.GLboolean)(unsafe.Pointer(&reset)), C.GLenum(format), C.GLenum(gltype), values_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSeparableFilter2D.xml +func (gl *GL) SeparableFilter2D(target, internalFormat glbase.Enum, width, height int, format, gltype glbase.Enum, row, column interface{}) { + var row_ptr unsafe.Pointer + var row_v = reflect.ValueOf(row) + if row != nil && row_v.Kind() != reflect.Slice { + panic("parameter row must be a slice") + } + if row != nil { + row_ptr = unsafe.Pointer(row_v.Index(0).Addr().Pointer()) + } + var column_ptr unsafe.Pointer + var column_v = reflect.ValueOf(column) + if column != nil && column_v.Kind() != reflect.Slice { + panic("parameter column must be a slice") + } + if column != nil { + column_ptr = unsafe.Pointer(column_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glSeparableFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), row_ptr, column_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetSeparableFilter.xml +func (gl *GL) GetSeparableFilter(target, format, gltype glbase.Enum, row, column, span interface{}) { + var row_ptr unsafe.Pointer + var row_v = reflect.ValueOf(row) + if row != nil && row_v.Kind() != reflect.Slice { + panic("parameter row must be a slice") + } + if row != nil { + row_ptr = unsafe.Pointer(row_v.Index(0).Addr().Pointer()) + } + var column_ptr unsafe.Pointer + var column_v = reflect.ValueOf(column) + if column != nil && column_v.Kind() != reflect.Slice { + panic("parameter column must be a slice") + } + if column != nil { + column_ptr = unsafe.Pointer(column_v.Index(0).Addr().Pointer()) + } + var span_ptr unsafe.Pointer + var span_v = reflect.ValueOf(span) + if span != nil && span_v.Kind() != reflect.Slice { + panic("parameter span must be a slice") + } + if span != nil { + span_ptr = unsafe.Pointer(span_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glGetSeparableFilter(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), row_ptr, column_ptr, span_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetConvolutionParameteriv.xml +func (gl *GL) GetConvolutionParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_2compat_glGetConvolutionParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetConvolutionParameterfv.xml +func (gl *GL) GetConvolutionParameterfv(target, pname glbase.Enum, params []float32) { + C.gl3_2compat_glGetConvolutionParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetConvolutionFilter.xml +func (gl *GL) GetConvolutionFilter(target, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glGetConvolutionFilter(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyConvolutionFilter2D.xml +func (gl *GL) CopyConvolutionFilter2D(target, internalFormat glbase.Enum, x, y, width, height int) { + C.gl3_2compat_glCopyConvolutionFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyConvolutionFilter1D.xml +func (gl *GL) CopyConvolutionFilter1D(target, internalFormat glbase.Enum, x, y, width int) { + C.gl3_2compat_glCopyConvolutionFilter1D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glConvolutionParameteriv.xml +func (gl *GL) ConvolutionParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_2compat_glConvolutionParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glConvolutionParameteri.xml +func (gl *GL) ConvolutionParameteri(target, pname glbase.Enum, params int32) { + C.gl3_2compat_glConvolutionParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(params)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glConvolutionParameterfv.xml +func (gl *GL) ConvolutionParameterfv(target, pname glbase.Enum, params []float32) { + C.gl3_2compat_glConvolutionParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glConvolutionParameterf.xml +func (gl *GL) ConvolutionParameterf(target, pname glbase.Enum, params float32) { + C.gl3_2compat_glConvolutionParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(params)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glConvolutionFilter2D.xml +func (gl *GL) ConvolutionFilter2D(target, internalFormat glbase.Enum, width, height int, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glConvolutionFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glConvolutionFilter1D.xml +func (gl *GL) ConvolutionFilter1D(target, internalFormat glbase.Enum, width int, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glConvolutionFilter1D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyColorSubTable.xml +func (gl *GL) CopyColorSubTable(target glbase.Enum, start int32, x, y, width int) { + C.gl3_2compat_glCopyColorSubTable(gl.funcs, C.GLenum(target), C.GLsizei(start), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorSubTable.xml +func (gl *GL) ColorSubTable(target glbase.Enum, start int32, count int, format, gltype glbase.Enum, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glColorSubTable(gl.funcs, C.GLenum(target), C.GLsizei(start), C.GLsizei(count), C.GLenum(format), C.GLenum(gltype), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetColorTableParameteriv.xml +func (gl *GL) GetColorTableParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_2compat_glGetColorTableParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetColorTableParameterfv.xml +func (gl *GL) GetColorTableParameterfv(target, pname glbase.Enum, params []float32) { + C.gl3_2compat_glGetColorTableParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetColorTable.xml +func (gl *GL) GetColorTable(target, format, gltype glbase.Enum, table interface{}) { + var table_ptr unsafe.Pointer + var table_v = reflect.ValueOf(table) + if table != nil && table_v.Kind() != reflect.Slice { + panic("parameter table must be a slice") + } + if table != nil { + table_ptr = unsafe.Pointer(table_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glGetColorTable(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), table_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyColorTable.xml +func (gl *GL) CopyColorTable(target, internalFormat glbase.Enum, x, y, width int) { + C.gl3_2compat_glCopyColorTable(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorTableParameteriv.xml +func (gl *GL) ColorTableParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_2compat_glColorTableParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorTableParameterfv.xml +func (gl *GL) ColorTableParameterfv(target, pname glbase.Enum, params []float32) { + C.gl3_2compat_glColorTableParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorTable.xml +func (gl *GL) ColorTable(target, internalFormat glbase.Enum, width int, format, gltype glbase.Enum, table interface{}) { + var table_ptr unsafe.Pointer + var table_v = reflect.ValueOf(table) + if table != nil && table_v.Kind() != reflect.Slice { + panic("parameter table must be a slice") + } + if table != nil { + table_ptr = unsafe.Pointer(table_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glColorTable(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), table_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultTransposeMatrixd.xml +func (gl *GL) MultTransposeMatrixd(m []float64) { + C.gl3_2compat_glMultTransposeMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultTransposeMatrixf.xml +func (gl *GL) MultTransposeMatrixf(m []float32) { + C.gl3_2compat_glMultTransposeMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLoadTransposeMatrixd.xml +func (gl *GL) LoadTransposeMatrixd(m []float64) { + C.gl3_2compat_glLoadTransposeMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLoadTransposeMatrixf.xml +func (gl *GL) LoadTransposeMatrixf(m []float32) { + C.gl3_2compat_glLoadTransposeMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord4sv.xml +func (gl *GL) MultiTexCoord4sv(target glbase.Enum, v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glMultiTexCoord4sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord4s.xml +func (gl *GL) MultiTexCoord4s(target glbase.Enum, s, t, r, q int16) { + C.gl3_2compat_glMultiTexCoord4s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t), C.GLshort(r), C.GLshort(q)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord4iv.xml +func (gl *GL) MultiTexCoord4iv(target glbase.Enum, v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glMultiTexCoord4iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord4i.xml +func (gl *GL) MultiTexCoord4i(target glbase.Enum, s, t, r, q int32) { + C.gl3_2compat_glMultiTexCoord4i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t), C.GLint(r), C.GLint(q)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord4fv.xml +func (gl *GL) MultiTexCoord4fv(target glbase.Enum, v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glMultiTexCoord4fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord4f.xml +func (gl *GL) MultiTexCoord4f(target glbase.Enum, s, t, r, q float32) { + C.gl3_2compat_glMultiTexCoord4f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t), C.GLfloat(r), C.GLfloat(q)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord4dv.xml +func (gl *GL) MultiTexCoord4dv(target glbase.Enum, v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glMultiTexCoord4dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord4d.xml +func (gl *GL) MultiTexCoord4d(target glbase.Enum, s, t, r, q float64) { + C.gl3_2compat_glMultiTexCoord4d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t), C.GLdouble(r), C.GLdouble(q)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord3sv.xml +func (gl *GL) MultiTexCoord3sv(target glbase.Enum, v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glMultiTexCoord3sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord3s.xml +func (gl *GL) MultiTexCoord3s(target glbase.Enum, s, t, r int16) { + C.gl3_2compat_glMultiTexCoord3s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t), C.GLshort(r)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord3iv.xml +func (gl *GL) MultiTexCoord3iv(target glbase.Enum, v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glMultiTexCoord3iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord3i.xml +func (gl *GL) MultiTexCoord3i(target glbase.Enum, s, t, r int32) { + C.gl3_2compat_glMultiTexCoord3i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t), C.GLint(r)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord3fv.xml +func (gl *GL) MultiTexCoord3fv(target glbase.Enum, v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glMultiTexCoord3fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord3f.xml +func (gl *GL) MultiTexCoord3f(target glbase.Enum, s, t, r float32) { + C.gl3_2compat_glMultiTexCoord3f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t), C.GLfloat(r)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord3dv.xml +func (gl *GL) MultiTexCoord3dv(target glbase.Enum, v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glMultiTexCoord3dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord3d.xml +func (gl *GL) MultiTexCoord3d(target glbase.Enum, s, t, r float64) { + C.gl3_2compat_glMultiTexCoord3d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t), C.GLdouble(r)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord2sv.xml +func (gl *GL) MultiTexCoord2sv(target glbase.Enum, v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glMultiTexCoord2sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord2s.xml +func (gl *GL) MultiTexCoord2s(target glbase.Enum, s, t int16) { + C.gl3_2compat_glMultiTexCoord2s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord2iv.xml +func (gl *GL) MultiTexCoord2iv(target glbase.Enum, v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glMultiTexCoord2iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord2i.xml +func (gl *GL) MultiTexCoord2i(target glbase.Enum, s, t int32) { + C.gl3_2compat_glMultiTexCoord2i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord2fv.xml +func (gl *GL) MultiTexCoord2fv(target glbase.Enum, v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glMultiTexCoord2fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord2f.xml +func (gl *GL) MultiTexCoord2f(target glbase.Enum, s, t float32) { + C.gl3_2compat_glMultiTexCoord2f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord2dv.xml +func (gl *GL) MultiTexCoord2dv(target glbase.Enum, v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glMultiTexCoord2dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord2d.xml +func (gl *GL) MultiTexCoord2d(target glbase.Enum, s, t float64) { + C.gl3_2compat_glMultiTexCoord2d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord1sv.xml +func (gl *GL) MultiTexCoord1sv(target glbase.Enum, v []int16) { + C.gl3_2compat_glMultiTexCoord1sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord1s.xml +func (gl *GL) MultiTexCoord1s(target glbase.Enum, s int16) { + C.gl3_2compat_glMultiTexCoord1s(gl.funcs, C.GLenum(target), C.GLshort(s)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord1iv.xml +func (gl *GL) MultiTexCoord1iv(target glbase.Enum, v []int32) { + C.gl3_2compat_glMultiTexCoord1iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord1i.xml +func (gl *GL) MultiTexCoord1i(target glbase.Enum, s int32) { + C.gl3_2compat_glMultiTexCoord1i(gl.funcs, C.GLenum(target), C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord1fv.xml +func (gl *GL) MultiTexCoord1fv(target glbase.Enum, v []float32) { + C.gl3_2compat_glMultiTexCoord1fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord1f.xml +func (gl *GL) MultiTexCoord1f(target glbase.Enum, s float32) { + C.gl3_2compat_glMultiTexCoord1f(gl.funcs, C.GLenum(target), C.GLfloat(s)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord1dv.xml +func (gl *GL) MultiTexCoord1dv(target glbase.Enum, v []float64) { + C.gl3_2compat_glMultiTexCoord1dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord1d.xml +func (gl *GL) MultiTexCoord1d(target glbase.Enum, s float64) { + C.gl3_2compat_glMultiTexCoord1d(gl.funcs, C.GLenum(target), C.GLdouble(s)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClientActiveTexture.xml +func (gl *GL) ClientActiveTexture(texture glbase.Enum) { + C.gl3_2compat_glClientActiveTexture(gl.funcs, C.GLenum(texture)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos3sv.xml +func (gl *GL) WindowPos3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glWindowPos3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos3s.xml +func (gl *GL) WindowPos3s(x, y, z int16) { + C.gl3_2compat_glWindowPos3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos3iv.xml +func (gl *GL) WindowPos3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glWindowPos3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos3i.xml +func (gl *GL) WindowPos3i(x, y, z int) { + C.gl3_2compat_glWindowPos3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos3fv.xml +func (gl *GL) WindowPos3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glWindowPos3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos3f.xml +func (gl *GL) WindowPos3f(x, y, z float32) { + C.gl3_2compat_glWindowPos3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos3dv.xml +func (gl *GL) WindowPos3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glWindowPos3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos3d.xml +func (gl *GL) WindowPos3d(x, y, z float64) { + C.gl3_2compat_glWindowPos3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos2sv.xml +func (gl *GL) WindowPos2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glWindowPos2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos2s.xml +func (gl *GL) WindowPos2s(x, y int16) { + C.gl3_2compat_glWindowPos2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos2iv.xml +func (gl *GL) WindowPos2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glWindowPos2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos2i.xml +func (gl *GL) WindowPos2i(x, y int) { + C.gl3_2compat_glWindowPos2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos2fv.xml +func (gl *GL) WindowPos2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glWindowPos2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos2f.xml +func (gl *GL) WindowPos2f(x, y float32) { + C.gl3_2compat_glWindowPos2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos2dv.xml +func (gl *GL) WindowPos2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glWindowPos2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos2d.xml +func (gl *GL) WindowPos2d(x, y float64) { + C.gl3_2compat_glWindowPos2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColorPointer.xml +func (gl *GL) SecondaryColorPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glSecondaryColorPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3usv.xml +func (gl *GL) SecondaryColor3usv(v []uint16) { + C.gl3_2compat_glSecondaryColor3usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3us.xml +func (gl *GL) SecondaryColor3us(red, green, blue uint16) { + C.gl3_2compat_glSecondaryColor3us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3uiv.xml +func (gl *GL) SecondaryColor3uiv(v []uint32) { + C.gl3_2compat_glSecondaryColor3uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3ui.xml +func (gl *GL) SecondaryColor3ui(red, green, blue uint32) { + C.gl3_2compat_glSecondaryColor3ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3ubv.xml +func (gl *GL) SecondaryColor3ubv(v []uint8) { + C.gl3_2compat_glSecondaryColor3ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3ub.xml +func (gl *GL) SecondaryColor3ub(red, green, blue uint8) { + C.gl3_2compat_glSecondaryColor3ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3sv.xml +func (gl *GL) SecondaryColor3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glSecondaryColor3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3s.xml +func (gl *GL) SecondaryColor3s(red, green, blue int16) { + C.gl3_2compat_glSecondaryColor3s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3iv.xml +func (gl *GL) SecondaryColor3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glSecondaryColor3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3i.xml +func (gl *GL) SecondaryColor3i(red, green, blue int32) { + C.gl3_2compat_glSecondaryColor3i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3fv.xml +func (gl *GL) SecondaryColor3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glSecondaryColor3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3f.xml +func (gl *GL) SecondaryColor3f(red, green, blue float32) { + C.gl3_2compat_glSecondaryColor3f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3dv.xml +func (gl *GL) SecondaryColor3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glSecondaryColor3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3d.xml +func (gl *GL) SecondaryColor3d(red, green, blue float64) { + C.gl3_2compat_glSecondaryColor3d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3bv.xml +func (gl *GL) SecondaryColor3bv(v []byte) { + C.gl3_2compat_glSecondaryColor3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3b.xml +func (gl *GL) SecondaryColor3b(red, green, blue byte) { + C.gl3_2compat_glSecondaryColor3b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFogCoordPointer.xml +func (gl *GL) FogCoordPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl3_2compat_glFogCoordPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFogCoorddv.xml +func (gl *GL) FogCoorddv(coord []float64) { + C.gl3_2compat_glFogCoorddv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&coord[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFogCoordd.xml +func (gl *GL) FogCoordd(coord float64) { + C.gl3_2compat_glFogCoordd(gl.funcs, C.GLdouble(coord)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFogCoordfv.xml +func (gl *GL) FogCoordfv(coord []float32) { + C.gl3_2compat_glFogCoordfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&coord[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFogCoordf.xml +func (gl *GL) FogCoordf(coord float32) { + C.gl3_2compat_glFogCoordf(gl.funcs, C.GLfloat(coord)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4usv.xml +func (gl *GL) VertexAttrib4usv(index glbase.Attrib, v []uint16) { + C.gl3_2compat_glVertexAttrib4usv(gl.funcs, C.GLuint(index), (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4uiv.xml +func (gl *GL) VertexAttrib4uiv(index glbase.Attrib, v []uint32) { + C.gl3_2compat_glVertexAttrib4uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4ubv.xml +func (gl *GL) VertexAttrib4ubv(index glbase.Attrib, v []uint8) { + C.gl3_2compat_glVertexAttrib4ubv(gl.funcs, C.GLuint(index), (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4sv.xml +func (gl *GL) VertexAttrib4sv(index glbase.Attrib, v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glVertexAttrib4sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4s.xml +func (gl *GL) VertexAttrib4s(index glbase.Attrib, x, y, z, w int16) { + C.gl3_2compat_glVertexAttrib4s(gl.funcs, C.GLuint(index), C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4iv.xml +func (gl *GL) VertexAttrib4iv(index glbase.Attrib, v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glVertexAttrib4iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4fv.xml +func (gl *GL) VertexAttrib4fv(index glbase.Attrib, v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glVertexAttrib4fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4f.xml +func (gl *GL) VertexAttrib4f(index glbase.Attrib, x, y, z, w float32) { + C.gl3_2compat_glVertexAttrib4f(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4dv.xml +func (gl *GL) VertexAttrib4dv(index glbase.Attrib, v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glVertexAttrib4dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4d.xml +func (gl *GL) VertexAttrib4d(index glbase.Attrib, x, y, z, w float64) { + C.gl3_2compat_glVertexAttrib4d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4bv.xml +func (gl *GL) VertexAttrib4bv(index glbase.Attrib, v []byte) { + C.gl3_2compat_glVertexAttrib4bv(gl.funcs, C.GLuint(index), (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4Nusv.xml +func (gl *GL) VertexAttrib4Nusv(index glbase.Attrib, v []uint16) { + C.gl3_2compat_glVertexAttrib4Nusv(gl.funcs, C.GLuint(index), (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4Nuiv.xml +func (gl *GL) VertexAttrib4Nuiv(index glbase.Attrib, v []uint32) { + C.gl3_2compat_glVertexAttrib4Nuiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4Nubv.xml +func (gl *GL) VertexAttrib4Nubv(index glbase.Attrib, v []uint8) { + C.gl3_2compat_glVertexAttrib4Nubv(gl.funcs, C.GLuint(index), (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4Nub.xml +func (gl *GL) VertexAttrib4Nub(index glbase.Attrib, x, y, z, w uint8) { + C.gl3_2compat_glVertexAttrib4Nub(gl.funcs, C.GLuint(index), C.GLubyte(x), C.GLubyte(y), C.GLubyte(z), C.GLubyte(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4Nsv.xml +func (gl *GL) VertexAttrib4Nsv(index glbase.Attrib, v []int16) { + C.gl3_2compat_glVertexAttrib4Nsv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4Niv.xml +func (gl *GL) VertexAttrib4Niv(index glbase.Attrib, v []int32) { + C.gl3_2compat_glVertexAttrib4Niv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4Nbv.xml +func (gl *GL) VertexAttrib4Nbv(index glbase.Attrib, v []byte) { + C.gl3_2compat_glVertexAttrib4Nbv(gl.funcs, C.GLuint(index), (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib3sv.xml +func (gl *GL) VertexAttrib3sv(index glbase.Attrib, v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glVertexAttrib3sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib3s.xml +func (gl *GL) VertexAttrib3s(index glbase.Attrib, x, y, z int16) { + C.gl3_2compat_glVertexAttrib3s(gl.funcs, C.GLuint(index), C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib3fv.xml +func (gl *GL) VertexAttrib3fv(index glbase.Attrib, v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glVertexAttrib3fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib3f.xml +func (gl *GL) VertexAttrib3f(index glbase.Attrib, x, y, z float32) { + C.gl3_2compat_glVertexAttrib3f(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib3dv.xml +func (gl *GL) VertexAttrib3dv(index glbase.Attrib, v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glVertexAttrib3dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib3d.xml +func (gl *GL) VertexAttrib3d(index glbase.Attrib, x, y, z float64) { + C.gl3_2compat_glVertexAttrib3d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib2sv.xml +func (gl *GL) VertexAttrib2sv(index glbase.Attrib, v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glVertexAttrib2sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib2s.xml +func (gl *GL) VertexAttrib2s(index glbase.Attrib, x, y int16) { + C.gl3_2compat_glVertexAttrib2s(gl.funcs, C.GLuint(index), C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib2fv.xml +func (gl *GL) VertexAttrib2fv(index glbase.Attrib, v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glVertexAttrib2fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib2f.xml +func (gl *GL) VertexAttrib2f(index glbase.Attrib, x, y float32) { + C.gl3_2compat_glVertexAttrib2f(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib2dv.xml +func (gl *GL) VertexAttrib2dv(index glbase.Attrib, v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glVertexAttrib2dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib2d.xml +func (gl *GL) VertexAttrib2d(index glbase.Attrib, x, y float64) { + C.gl3_2compat_glVertexAttrib2d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib1sv.xml +func (gl *GL) VertexAttrib1sv(index glbase.Attrib, v []int16) { + C.gl3_2compat_glVertexAttrib1sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib1s.xml +func (gl *GL) VertexAttrib1s(index glbase.Attrib, x int16) { + C.gl3_2compat_glVertexAttrib1s(gl.funcs, C.GLuint(index), C.GLshort(x)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib1fv.xml +func (gl *GL) VertexAttrib1fv(index glbase.Attrib, v []float32) { + C.gl3_2compat_glVertexAttrib1fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib1f.xml +func (gl *GL) VertexAttrib1f(index glbase.Attrib, x float32) { + C.gl3_2compat_glVertexAttrib1f(gl.funcs, C.GLuint(index), C.GLfloat(x)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib1dv.xml +func (gl *GL) VertexAttrib1dv(index glbase.Attrib, v []float64) { + C.gl3_2compat_glVertexAttrib1dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib1d.xml +func (gl *GL) VertexAttrib1d(index glbase.Attrib, x float64) { + C.gl3_2compat_glVertexAttrib1d(gl.funcs, C.GLuint(index), C.GLdouble(x)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI4usv.xml +func (gl *GL) VertexAttribI4usv(index glbase.Attrib, v []uint16) { + C.gl3_2compat_glVertexAttribI4usv(gl.funcs, C.GLuint(index), (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI4ubv.xml +func (gl *GL) VertexAttribI4ubv(index glbase.Attrib, v []uint8) { + C.gl3_2compat_glVertexAttribI4ubv(gl.funcs, C.GLuint(index), (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI4sv.xml +func (gl *GL) VertexAttribI4sv(index glbase.Attrib, v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glVertexAttribI4sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI4bv.xml +func (gl *GL) VertexAttribI4bv(index glbase.Attrib, v []byte) { + C.gl3_2compat_glVertexAttribI4bv(gl.funcs, C.GLuint(index), (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI4uiv.xml +func (gl *GL) VertexAttribI4uiv(index glbase.Attrib, v []uint32) { + C.gl3_2compat_glVertexAttribI4uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI3uiv.xml +func (gl *GL) VertexAttribI3uiv(index glbase.Attrib, v []uint32) { + C.gl3_2compat_glVertexAttribI3uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI2uiv.xml +func (gl *GL) VertexAttribI2uiv(index glbase.Attrib, v []uint32) { + C.gl3_2compat_glVertexAttribI2uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI1uiv.xml +func (gl *GL) VertexAttribI1uiv(index glbase.Attrib, v []uint32) { + C.gl3_2compat_glVertexAttribI1uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI4iv.xml +func (gl *GL) VertexAttribI4iv(index glbase.Attrib, v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glVertexAttribI4iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI3iv.xml +func (gl *GL) VertexAttribI3iv(index glbase.Attrib, v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glVertexAttribI3iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI2iv.xml +func (gl *GL) VertexAttribI2iv(index glbase.Attrib, v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_2compat_glVertexAttribI2iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI1iv.xml +func (gl *GL) VertexAttribI1iv(index glbase.Attrib, v []int32) { + C.gl3_2compat_glVertexAttribI1iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI4ui.xml +func (gl *GL) VertexAttribI4ui(index glbase.Attrib, x, y, z, w uint32) { + C.gl3_2compat_glVertexAttribI4ui(gl.funcs, C.GLuint(index), C.GLuint(x), C.GLuint(y), C.GLuint(z), C.GLuint(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI3ui.xml +func (gl *GL) VertexAttribI3ui(index glbase.Attrib, x, y, z uint32) { + C.gl3_2compat_glVertexAttribI3ui(gl.funcs, C.GLuint(index), C.GLuint(x), C.GLuint(y), C.GLuint(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI2ui.xml +func (gl *GL) VertexAttribI2ui(index glbase.Attrib, x, y uint32) { + C.gl3_2compat_glVertexAttribI2ui(gl.funcs, C.GLuint(index), C.GLuint(x), C.GLuint(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI1ui.xml +func (gl *GL) VertexAttribI1ui(index glbase.Attrib, x uint32) { + C.gl3_2compat_glVertexAttribI1ui(gl.funcs, C.GLuint(index), C.GLuint(x)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI4i.xml +func (gl *GL) VertexAttribI4i(index glbase.Attrib, x, y, z, w int) { + C.gl3_2compat_glVertexAttribI4i(gl.funcs, C.GLuint(index), C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI3i.xml +func (gl *GL) VertexAttribI3i(index glbase.Attrib, x, y, z int) { + C.gl3_2compat_glVertexAttribI3i(gl.funcs, C.GLuint(index), C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI2i.xml +func (gl *GL) VertexAttribI2i(index glbase.Attrib, x, y int) { + C.gl3_2compat_glVertexAttribI2i(gl.funcs, C.GLuint(index), C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI1i.xml +func (gl *GL) VertexAttribI1i(index glbase.Attrib, x int) { + C.gl3_2compat_glVertexAttribI1i(gl.funcs, C.GLuint(index), C.GLint(x)) +} diff --git a/gl/3.2core/funcs.cpp b/gl/3.2core/funcs.cpp new file mode 100644 index 00000000..adacb68e --- /dev/null +++ b/gl/3.2core/funcs.cpp @@ -0,0 +1,1530 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#include +#include + +#include "funcs.h" + +void *gl3_2core_funcs() { + QOpenGLFunctions_3_2_Core* funcs = QOpenGLContext::currentContext()->versionFunctions(); + if (!funcs) { + return 0; + } + funcs->initializeOpenGLFunctions(); + return funcs; +} + + +void gl3_2core_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewport(x, y, width, height); +} + +void gl3_2core_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRange(nearVal, farVal); +} + +GLboolean gl3_2core_glIsEnabled(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabled(cap); +} + +void gl3_2core_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameteriv(target, level, pname, params); +} + +void gl3_2core_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameterfv(target, level, pname, params); +} + +void gl3_2core_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameteriv(target, pname, params); +} + +void gl3_2core_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterfv(target, pname, params); +} + +void gl3_2core_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexImage(target, level, format, gltype, pixels); +} + +void gl3_2core_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegerv(pname, params); +} + +void gl3_2core_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFloatv(pname, params); +} + +GLenum gl3_2core_glGetError(void *_glfuncs) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetError(); +} + +void gl3_2core_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetDoublev(pname, params); +} + +void gl3_2core_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleanv(pname, params); +} + +void gl3_2core_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadPixels(x, y, width, height, format, gltype, pixels); +} + +void gl3_2core_glReadBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadBuffer(mode); +} + +void gl3_2core_glPixelStorei(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStorei(pname, param); +} + +void gl3_2core_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStoref(pname, param); +} + +void gl3_2core_glDepthFunc(void *_glfuncs, GLenum glfunc) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthFunc(glfunc); +} + +void gl3_2core_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOp(fail, zfail, zpass); +} + +void gl3_2core_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFunc(glfunc, ref, mask); +} + +void gl3_2core_glLogicOp(void *_glfuncs, GLenum opcode) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLogicOp(opcode); +} + +void gl3_2core_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFunc(sfactor, dfactor); +} + +void gl3_2core_glFlush(void *_glfuncs) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlush(); +} + +void gl3_2core_glFinish(void *_glfuncs) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFinish(); +} + +void gl3_2core_glEnable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnable(cap); +} + +void gl3_2core_glDisable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisable(cap); +} + +void gl3_2core_glDepthMask(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthMask(flag); +} + +void gl3_2core_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMask(red, green, blue, alpha); +} + +void gl3_2core_glStencilMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMask(mask); +} + +void gl3_2core_glClearDepth(void *_glfuncs, GLdouble depth) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearDepth(depth); +} + +void gl3_2core_glClearStencil(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearStencil(s); +} + +void gl3_2core_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearColor(red, green, blue, alpha); +} + +void gl3_2core_glClear(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClear(mask); +} + +void gl3_2core_glDrawBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffer(mode); +} + +void gl3_2core_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage2D(target, level, internalFormat, width, height, border, format, gltype, pixels); +} + +void gl3_2core_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage1D(target, level, internalFormat, width, border, format, gltype, pixels); +} + +void gl3_2core_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteriv(target, pname, params); +} + +void gl3_2core_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteri(target, pname, param); +} + +void gl3_2core_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterfv(target, pname, params); +} + +void gl3_2core_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterf(target, pname, param); +} + +void gl3_2core_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissor(x, y, width, height); +} + +void gl3_2core_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonMode(face, mode); +} + +void gl3_2core_glPointSize(void *_glfuncs, GLfloat size) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointSize(size); +} + +void gl3_2core_glLineWidth(void *_glfuncs, GLfloat width) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineWidth(width); +} + +void gl3_2core_glHint(void *_glfuncs, GLenum target, GLenum mode) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glHint(target, mode); +} + +void gl3_2core_glFrontFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrontFace(mode); +} + +void gl3_2core_glCullFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCullFace(mode); +} + +void gl3_2core_glIndexubv(void *_glfuncs, const GLubyte* c) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexubv(c); +} + +void gl3_2core_glIndexub(void *_glfuncs, GLubyte c) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexub(c); +} + +GLboolean gl3_2core_glIsTexture(void *_glfuncs, GLuint texture) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsTexture(texture); +} + +void gl3_2core_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenTextures(n, textures); +} + +void gl3_2core_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteTextures(n, textures); +} + +void gl3_2core_glBindTexture(void *_glfuncs, GLenum target, GLuint texture) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindTexture(target, texture); +} + +void gl3_2core_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, gltype, pixels); +} + +void gl3_2core_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage1D(target, level, xoffset, width, format, gltype, pixels); +} + +void gl3_2core_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); +} + +void gl3_2core_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage1D(target, level, xoffset, x, y, width); +} + +void gl3_2core_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage2D(target, level, internalFormat, x, y, width, height, border); +} + +void gl3_2core_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage1D(target, level, internalFormat, x, y, width, border); +} + +void gl3_2core_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonOffset(factor, units); +} + +void gl3_2core_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElements(mode, count, gltype, indices); +} + +void gl3_2core_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArrays(mode, first, count); +} + +void gl3_2core_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); +} + +void gl3_2core_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, gltype, pixels); +} + +void gl3_2core_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage3D(target, level, internalFormat, width, height, depth, border, format, gltype, pixels); +} + +void gl3_2core_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawRangeElements(mode, start, end, count, gltype, indices); +} + +void gl3_2core_glBlendEquation(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquation(mode); +} + +void gl3_2core_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendColor(red, green, blue, alpha); +} + +void gl3_2core_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetCompressedTexImage(target, level, img); +} + +void gl3_2core_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data); +} + +void gl3_2core_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); +} + +void gl3_2core_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); +} + +void gl3_2core_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage1D(target, level, internalFormat, width, border, imageSize, data); +} + +void gl3_2core_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data); +} + +void gl3_2core_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage3D(target, level, internalFormat, width, height, depth, border, imageSize, data); +} + +void gl3_2core_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSampleCoverage(value, invert); +} + +void gl3_2core_glActiveTexture(void *_glfuncs, GLenum texture) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glActiveTexture(texture); +} + +void gl3_2core_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteriv(pname, params); +} + +void gl3_2core_glPointParameteri(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteri(pname, param); +} + +void gl3_2core_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterfv(pname, params); +} + +void gl3_2core_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterf(pname, param); +} + +void gl3_2core_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiDrawArrays(mode, first, count, drawcount); +} + +void gl3_2core_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); +} + +void gl3_2core_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferParameteriv(target, pname, params); +} + +GLboolean gl3_2core_glUnmapBuffer(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glUnmapBuffer(target); +} + +void gl3_2core_glGetBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferSubData(target, offset, size, data); +} + +void gl3_2core_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferSubData(target, offset, size, data); +} + +void gl3_2core_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferData(target, size, data, usage); +} + +GLboolean gl3_2core_glIsBuffer(void *_glfuncs, GLuint buffer) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsBuffer(buffer); +} + +void gl3_2core_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenBuffers(n, buffers); +} + +void gl3_2core_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteBuffers(n, buffers); +} + +void gl3_2core_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBuffer(target, buffer); +} + +void gl3_2core_glGetQueryObjectuiv(void *_glfuncs, GLuint id, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectuiv(id, pname, params); +} + +void gl3_2core_glGetQueryObjectiv(void *_glfuncs, GLuint id, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectiv(id, pname, params); +} + +void gl3_2core_glGetQueryiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryiv(target, pname, params); +} + +void gl3_2core_glEndQuery(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndQuery(target); +} + +void gl3_2core_glBeginQuery(void *_glfuncs, GLenum target, GLuint id) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginQuery(target, id); +} + +GLboolean gl3_2core_glIsQuery(void *_glfuncs, GLuint id) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsQuery(id); +} + +void gl3_2core_glDeleteQueries(void *_glfuncs, GLsizei n, const GLuint* ids) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteQueries(n, ids); +} + +void gl3_2core_glGenQueries(void *_glfuncs, GLsizei n, GLuint* ids) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenQueries(n, ids); +} + +void gl3_2core_glVertexAttribPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLboolean normalized, GLsizei stride, const GLvoid* offset) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribPointer(index, size, gltype, normalized, stride, offset); +} + +void gl3_2core_glValidateProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glValidateProgram(program); +} + +void gl3_2core_glUniformMatrix4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4fv(location, count, transpose, value); +} + +void gl3_2core_glUniformMatrix3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3fv(location, count, transpose, value); +} + +void gl3_2core_glUniformMatrix2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2fv(location, count, transpose, value); +} + +void gl3_2core_glUniform4iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4iv(location, count, value); +} + +void gl3_2core_glUniform3iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3iv(location, count, value); +} + +void gl3_2core_glUniform2iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2iv(location, count, value); +} + +void gl3_2core_glUniform1iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1iv(location, count, value); +} + +void gl3_2core_glUniform4fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4fv(location, count, value); +} + +void gl3_2core_glUniform3fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3fv(location, count, value); +} + +void gl3_2core_glUniform2fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2fv(location, count, value); +} + +void gl3_2core_glUniform1fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1fv(location, count, value); +} + +void gl3_2core_glUniform4i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4i(location, v0, v1, v2, v3); +} + +void gl3_2core_glUniform3i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3i(location, v0, v1, v2); +} + +void gl3_2core_glUniform2i(void *_glfuncs, GLint location, GLint v0, GLint v1) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2i(location, v0, v1); +} + +void gl3_2core_glUniform1i(void *_glfuncs, GLint location, GLint v0) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1i(location, v0); +} + +void gl3_2core_glUniform4f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4f(location, v0, v1, v2, v3); +} + +void gl3_2core_glUniform3f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3f(location, v0, v1, v2); +} + +void gl3_2core_glUniform2f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2f(location, v0, v1); +} + +void gl3_2core_glUniform1f(void *_glfuncs, GLint location, GLfloat v0) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1f(location, v0); +} + +void gl3_2core_glUseProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUseProgram(program); +} + +void gl3_2core_glShaderSource(void *_glfuncs, GLuint shader, GLsizei count, const GLchar** source, const GLint* length) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShaderSource(shader, count, source, length); +} + +void gl3_2core_glLinkProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLinkProgram(program); +} + +GLboolean gl3_2core_glIsShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsShader(shader); +} + +GLboolean gl3_2core_glIsProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsProgram(program); +} + +void gl3_2core_glGetVertexAttribiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribiv(index, pname, params); +} + +void gl3_2core_glGetVertexAttribfv(void *_glfuncs, GLuint index, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribfv(index, pname, params); +} + +void gl3_2core_glGetVertexAttribdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribdv(index, pname, params); +} + +void gl3_2core_glGetUniformiv(void *_glfuncs, GLuint program, GLint location, GLint* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformiv(program, location, params); +} + +void gl3_2core_glGetUniformfv(void *_glfuncs, GLuint program, GLint location, GLfloat* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformfv(program, location, params); +} + +GLint gl3_2core_glGetUniformLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetUniformLocation(program, name); +} + +void gl3_2core_glGetShaderSource(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderSource(shader, bufSize, length, source); +} + +void gl3_2core_glGetShaderInfoLog(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderInfoLog(shader, bufSize, length, infoLog); +} + +void gl3_2core_glGetShaderiv(void *_glfuncs, GLuint shader, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderiv(shader, pname, params); +} + +void gl3_2core_glGetProgramInfoLog(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramInfoLog(program, bufSize, length, infoLog); +} + +void gl3_2core_glGetProgramiv(void *_glfuncs, GLuint program, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramiv(program, pname, params); +} + +GLint gl3_2core_glGetAttribLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetAttribLocation(program, name); +} + +void gl3_2core_glGetAttachedShaders(void *_glfuncs, GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetAttachedShaders(program, maxCount, count, obj); +} + +void gl3_2core_glGetActiveUniform(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniform(program, index, bufSize, length, size, gltype, name); +} + +void gl3_2core_glGetActiveAttrib(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveAttrib(program, index, bufSize, length, size, gltype, name); +} + +void gl3_2core_glEnableVertexAttribArray(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnableVertexAttribArray(index); +} + +void gl3_2core_glDisableVertexAttribArray(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisableVertexAttribArray(index); +} + +void gl3_2core_glDetachShader(void *_glfuncs, GLuint program, GLuint shader) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDetachShader(program, shader); +} + +void gl3_2core_glDeleteShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteShader(shader); +} + +void gl3_2core_glDeleteProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteProgram(program); +} + +GLuint gl3_2core_glCreateShader(void *_glfuncs, GLenum gltype) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCreateShader(gltype); +} + +GLuint gl3_2core_glCreateProgram(void *_glfuncs) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCreateProgram(); +} + +void gl3_2core_glCompileShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompileShader(shader); +} + +void gl3_2core_glBindAttribLocation(void *_glfuncs, GLuint program, GLuint index, const GLchar* name) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindAttribLocation(program, index, name); +} + +void gl3_2core_glAttachShader(void *_glfuncs, GLuint program, GLuint shader) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAttachShader(program, shader); +} + +void gl3_2core_glStencilMaskSeparate(void *_glfuncs, GLenum face, GLuint mask) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMaskSeparate(face, mask); +} + +void gl3_2core_glStencilFuncSeparate(void *_glfuncs, GLenum face, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFuncSeparate(face, glfunc, ref, mask); +} + +void gl3_2core_glStencilOpSeparate(void *_glfuncs, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOpSeparate(face, sfail, dpfail, dppass); +} + +void gl3_2core_glDrawBuffers(void *_glfuncs, GLsizei n, const GLenum* bufs) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffers(n, bufs); +} + +void gl3_2core_glBlendEquationSeparate(void *_glfuncs, GLenum modeRGB, GLenum modeAlpha) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquationSeparate(modeRGB, modeAlpha); +} + +void gl3_2core_glUniformMatrix4x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x3fv(location, count, transpose, value); +} + +void gl3_2core_glUniformMatrix3x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x4fv(location, count, transpose, value); +} + +void gl3_2core_glUniformMatrix4x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x2fv(location, count, transpose, value); +} + +void gl3_2core_glUniformMatrix2x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x4fv(location, count, transpose, value); +} + +void gl3_2core_glUniformMatrix3x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x2fv(location, count, transpose, value); +} + +void gl3_2core_glUniformMatrix2x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x3fv(location, count, transpose, value); +} + +GLboolean gl3_2core_glIsVertexArray(void *_glfuncs, GLuint array) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsVertexArray(array); +} + +void gl3_2core_glGenVertexArrays(void *_glfuncs, GLsizei n, GLuint* arrays) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenVertexArrays(n, arrays); +} + +void gl3_2core_glDeleteVertexArrays(void *_glfuncs, GLsizei n, const GLuint* arrays) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteVertexArrays(n, arrays); +} + +void gl3_2core_glBindVertexArray(void *_glfuncs, GLuint array) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindVertexArray(array); +} + +void gl3_2core_glFlushMappedBufferRange(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr length) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlushMappedBufferRange(target, offset, length); +} + +void gl3_2core_glFramebufferTextureLayer(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTextureLayer(target, attachment, texture, level, layer); +} + +void gl3_2core_glRenderbufferStorageMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRenderbufferStorageMultisample(target, samples, internalFormat, width, height); +} + +void gl3_2core_glBlitFramebuffer(void *_glfuncs, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); +} + +void gl3_2core_glGenerateMipmap(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenerateMipmap(target); +} + +void gl3_2core_glGetFramebufferAttachmentParameteriv(void *_glfuncs, GLenum target, GLenum attachment, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFramebufferAttachmentParameteriv(target, attachment, pname, params); +} + +void gl3_2core_glFramebufferRenderbuffer(void *_glfuncs, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer); +} + +void gl3_2core_glFramebufferTexture3D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset); +} + +void gl3_2core_glFramebufferTexture2D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture2D(target, attachment, textarget, texture, level); +} + +void gl3_2core_glFramebufferTexture1D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture1D(target, attachment, textarget, texture, level); +} + +GLenum gl3_2core_glCheckFramebufferStatus(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCheckFramebufferStatus(target); +} + +void gl3_2core_glGenFramebuffers(void *_glfuncs, GLsizei n, GLuint* framebuffers) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenFramebuffers(n, framebuffers); +} + +void gl3_2core_glDeleteFramebuffers(void *_glfuncs, GLsizei n, const GLuint* framebuffers) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteFramebuffers(n, framebuffers); +} + +void gl3_2core_glBindFramebuffer(void *_glfuncs, GLenum target, GLuint framebuffer) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFramebuffer(target, framebuffer); +} + +GLboolean gl3_2core_glIsFramebuffer(void *_glfuncs, GLuint framebuffer) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsFramebuffer(framebuffer); +} + +void gl3_2core_glGetRenderbufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetRenderbufferParameteriv(target, pname, params); +} + +void gl3_2core_glRenderbufferStorage(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRenderbufferStorage(target, internalFormat, width, height); +} + +void gl3_2core_glGenRenderbuffers(void *_glfuncs, GLsizei n, GLuint* renderbuffers) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenRenderbuffers(n, renderbuffers); +} + +void gl3_2core_glDeleteRenderbuffers(void *_glfuncs, GLsizei n, const GLuint* renderbuffers) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteRenderbuffers(n, renderbuffers); +} + +void gl3_2core_glBindRenderbuffer(void *_glfuncs, GLenum target, GLuint renderbuffer) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindRenderbuffer(target, renderbuffer); +} + +GLboolean gl3_2core_glIsRenderbuffer(void *_glfuncs, GLuint renderbuffer) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsRenderbuffer(renderbuffer); +} + +void gl3_2core_glClearBufferfi(void *_glfuncs, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferfi(buffer, drawbuffer, depth, stencil); +} + +void gl3_2core_glClearBufferfv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLfloat* value) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferfv(buffer, drawbuffer, value); +} + +void gl3_2core_glClearBufferuiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLuint* value) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferuiv(buffer, drawbuffer, value); +} + +void gl3_2core_glClearBufferiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLint* value) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferiv(buffer, drawbuffer, value); +} + +void gl3_2core_glGetTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterIuiv(target, pname, params); +} + +void gl3_2core_glGetTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterIiv(target, pname, params); +} + +void gl3_2core_glTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, const GLuint* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterIuiv(target, pname, params); +} + +void gl3_2core_glTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterIiv(target, pname, params); +} + +void gl3_2core_glUniform4uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4uiv(location, count, value); +} + +void gl3_2core_glUniform3uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3uiv(location, count, value); +} + +void gl3_2core_glUniform2uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2uiv(location, count, value); +} + +void gl3_2core_glUniform1uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1uiv(location, count, value); +} + +void gl3_2core_glUniform4ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4ui(location, v0, v1, v2, v3); +} + +void gl3_2core_glUniform3ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3ui(location, v0, v1, v2); +} + +void gl3_2core_glUniform2ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2ui(location, v0, v1); +} + +void gl3_2core_glUniform1ui(void *_glfuncs, GLint location, GLuint v0) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1ui(location, v0); +} + +GLint gl3_2core_glGetFragDataLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetFragDataLocation(program, name); +} + +void gl3_2core_glBindFragDataLocation(void *_glfuncs, GLuint program, GLuint color, const GLchar* name) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFragDataLocation(program, color, name); +} + +void gl3_2core_glGetUniformuiv(void *_glfuncs, GLuint program, GLint location, GLuint* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformuiv(program, location, params); +} + +void gl3_2core_glGetVertexAttribIuiv(void *_glfuncs, GLuint index, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribIuiv(index, pname, params); +} + +void gl3_2core_glGetVertexAttribIiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribIiv(index, pname, params); +} + +void gl3_2core_glVertexAttribIPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribIPointer(index, size, gltype, stride, pointer); +} + +void gl3_2core_glEndConditionalRender(void *_glfuncs) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndConditionalRender(); +} + +void gl3_2core_glBeginConditionalRender(void *_glfuncs, GLuint id, GLenum mode) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginConditionalRender(id, mode); +} + +void gl3_2core_glClampColor(void *_glfuncs, GLenum target, GLenum clamp) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClampColor(target, clamp); +} + +void gl3_2core_glGetTransformFeedbackVarying(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTransformFeedbackVarying(program, index, bufSize, length, size, gltype, name); +} + +void gl3_2core_glBindBufferBase(void *_glfuncs, GLenum target, GLuint index, GLuint buffer) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBufferBase(target, index, buffer); +} + +void gl3_2core_glBindBufferRange(void *_glfuncs, GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBufferRange(target, index, buffer, offset, size); +} + +void gl3_2core_glEndTransformFeedback(void *_glfuncs) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndTransformFeedback(); +} + +void gl3_2core_glBeginTransformFeedback(void *_glfuncs, GLenum primitiveMode) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginTransformFeedback(primitiveMode); +} + +GLboolean gl3_2core_glIsEnabledi(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabledi(target, index); +} + +void gl3_2core_glDisablei(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisablei(target, index); +} + +void gl3_2core_glEnablei(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnablei(target, index); +} + +void gl3_2core_glGetIntegeri_v(void *_glfuncs, GLenum target, GLuint index, GLint* data) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegeri_v(target, index, data); +} + +void gl3_2core_glGetBooleani_v(void *_glfuncs, GLenum target, GLuint index, GLboolean* data) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleani_v(target, index, data); +} + +void gl3_2core_glColorMaski(void *_glfuncs, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMaski(index, r, g, b, a); +} + +void gl3_2core_glCopyBufferSubData(void *_glfuncs, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); +} + +void gl3_2core_glUniformBlockBinding(void *_glfuncs, GLuint program, GLuint v0, GLuint v1) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformBlockBinding(program, v0, v1); +} + +void gl3_2core_glGetActiveUniformBlockName(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName); +} + +void gl3_2core_glGetActiveUniformBlockiv(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params); +} + +GLuint gl3_2core_glGetUniformBlockIndex(void *_glfuncs, GLuint program, const GLchar* uniformBlockName) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetUniformBlockIndex(program, uniformBlockName); +} + +void gl3_2core_glGetActiveUniformName(void *_glfuncs, GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformName(program, uniformIndex, bufSize, length, uniformName); +} + +void gl3_2core_glGetActiveUniformsiv(void *_glfuncs, GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params); +} + +void gl3_2core_glPrimitiveRestartIndex(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPrimitiveRestartIndex(index); +} + +void gl3_2core_glTexBuffer(void *_glfuncs, GLenum target, GLenum internalFormat, GLuint buffer) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexBuffer(target, internalFormat, buffer); +} + +void gl3_2core_glDrawElementsInstanced(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsInstanced(mode, count, gltype, indices, instancecount); +} + +void gl3_2core_glDrawArraysInstanced(void *_glfuncs, GLenum mode, GLint first, GLsizei count, GLsizei instancecount) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArraysInstanced(mode, first, count, instancecount); +} + +void gl3_2core_glSampleMaski(void *_glfuncs, GLuint index, GLbitfield mask) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSampleMaski(index, mask); +} + +void gl3_2core_glGetMultisamplefv(void *_glfuncs, GLenum pname, GLuint index, GLfloat* val) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMultisamplefv(pname, index, val); +} + +void gl3_2core_glTexImage3DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage3DMultisample(target, samples, internalFormat, width, height, depth, fixedsamplelocations); +} + +void gl3_2core_glTexImage2DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage2DMultisample(target, samples, internalFormat, width, height, fixedsamplelocations); +} + +void gl3_2core_glGetSynciv(void *_glfuncs, GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSynciv(sync, pname, bufSize, length, values); +} + +void gl3_2core_glGetInteger64v(void *_glfuncs, GLenum pname, GLint64* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetInteger64v(pname, params); +} + +void gl3_2core_glWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWaitSync(sync, flags, timeout); +} + +GLenum gl3_2core_glClientWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glClientWaitSync(sync, flags, timeout); +} + +void gl3_2core_glDeleteSync(void *_glfuncs, GLsync sync) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteSync(sync); +} + +GLboolean gl3_2core_glIsSync(void *_glfuncs, GLsync sync) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsSync(sync); +} + +GLsync gl3_2core_glFenceSync(void *_glfuncs, GLenum condition, GLbitfield flags) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glFenceSync(condition, flags); +} + +void gl3_2core_glProvokingVertex(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProvokingVertex(mode); +} + +void gl3_2core_glDrawElementsInstancedBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLint basevertex) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsInstancedBaseVertex(mode, count, gltype, indices, instancecount, basevertex); +} + +void gl3_2core_glDrawRangeElementsBaseVertex(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawRangeElementsBaseVertex(mode, start, end, count, gltype, indices, basevertex); +} + +void gl3_2core_glDrawElementsBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsBaseVertex(mode, count, gltype, indices, basevertex); +} + +void gl3_2core_glFramebufferTexture(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture(target, attachment, texture, level); +} + +void gl3_2core_glGetBufferParameteri64v(void *_glfuncs, GLenum target, GLenum pname, GLint64* params) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferParameteri64v(target, pname, params); +} + +void gl3_2core_glGetInteger64i_v(void *_glfuncs, GLenum target, GLuint index, GLint64* data) +{ + QOpenGLFunctions_3_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetInteger64i_v(target, index, data); +} + diff --git a/gl/3.2core/funcs.h b/gl/3.2core/funcs.h new file mode 100644 index 00000000..b0a5c4da --- /dev/null +++ b/gl/3.2core/funcs.h @@ -0,0 +1,294 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#ifndef __cplusplus +#include +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef char GLchar; +typedef signed char GLbyte; /* 1-byte signed */ +typedef short GLshort; /* 2-byte signed */ +typedef int GLint; /* 4-byte signed */ +typedef unsigned char GLubyte; /* 1-byte unsigned */ +typedef unsigned short GLushort; /* 2-byte unsigned */ +typedef unsigned int GLuint; /* 4-byte unsigned */ +typedef int GLsizei; /* 4-byte signed */ +typedef float GLfloat; /* single precision float */ +typedef float GLclampf; /* single precision float in [0,1] */ +typedef double GLdouble; /* double precision float */ +typedef double GLclampd; /* double precision float in [0,1] */ +typedef int64_t GLint64; +typedef uint64_t GLuint64; +typedef ptrdiff_t GLintptr; +typedef ptrdiff_t GLsizeiptr; +typedef ptrdiff_t GLintptrARB; +typedef ptrdiff_t GLsizeiptrARB; +typedef struct __GLsync *GLsync; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +void *gl3_2core_funcs(); + +void gl3_2core_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl3_2core_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal); +GLboolean gl3_2core_glIsEnabled(void *_glfuncs, GLenum cap); +void gl3_2core_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params); +void gl3_2core_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params); +void gl3_2core_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_2core_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl3_2core_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels); +void gl3_2core_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params); +void gl3_2core_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params); +GLenum gl3_2core_glGetError(void *_glfuncs); +void gl3_2core_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params); +void gl3_2core_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params); +void gl3_2core_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels); +void gl3_2core_glReadBuffer(void *_glfuncs, GLenum mode); +void gl3_2core_glPixelStorei(void *_glfuncs, GLenum pname, GLint param); +void gl3_2core_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param); +void gl3_2core_glDepthFunc(void *_glfuncs, GLenum glfunc); +void gl3_2core_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass); +void gl3_2core_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask); +void gl3_2core_glLogicOp(void *_glfuncs, GLenum opcode); +void gl3_2core_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor); +void gl3_2core_glFlush(void *_glfuncs); +void gl3_2core_glFinish(void *_glfuncs); +void gl3_2core_glEnable(void *_glfuncs, GLenum cap); +void gl3_2core_glDisable(void *_glfuncs, GLenum cap); +void gl3_2core_glDepthMask(void *_glfuncs, GLboolean flag); +void gl3_2core_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +void gl3_2core_glStencilMask(void *_glfuncs, GLuint mask); +void gl3_2core_glClearDepth(void *_glfuncs, GLdouble depth); +void gl3_2core_glClearStencil(void *_glfuncs, GLint s); +void gl3_2core_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl3_2core_glClear(void *_glfuncs, GLbitfield mask); +void gl3_2core_glDrawBuffer(void *_glfuncs, GLenum mode); +void gl3_2core_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_2core_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_2core_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl3_2core_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl3_2core_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl3_2core_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl3_2core_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl3_2core_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode); +void gl3_2core_glPointSize(void *_glfuncs, GLfloat size); +void gl3_2core_glLineWidth(void *_glfuncs, GLfloat width); +void gl3_2core_glHint(void *_glfuncs, GLenum target, GLenum mode); +void gl3_2core_glFrontFace(void *_glfuncs, GLenum mode); +void gl3_2core_glCullFace(void *_glfuncs, GLenum mode); +void gl3_2core_glIndexubv(void *_glfuncs, const GLubyte* c); +void gl3_2core_glIndexub(void *_glfuncs, GLubyte c); +GLboolean gl3_2core_glIsTexture(void *_glfuncs, GLuint texture); +void gl3_2core_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures); +void gl3_2core_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures); +void gl3_2core_glBindTexture(void *_glfuncs, GLenum target, GLuint texture); +void gl3_2core_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_2core_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_2core_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl3_2core_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +void gl3_2core_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +void gl3_2core_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border); +void gl3_2core_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units); +void gl3_2core_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl3_2core_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count); +void gl3_2core_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl3_2core_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_2core_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_2core_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl3_2core_glBlendEquation(void *_glfuncs, GLenum mode); +void gl3_2core_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl3_2core_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img); +void gl3_2core_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl3_2core_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl3_2core_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl3_2core_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data); +void gl3_2core_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data); +void gl3_2core_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data); +void gl3_2core_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert); +void gl3_2core_glActiveTexture(void *_glfuncs, GLenum texture); +void gl3_2core_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params); +void gl3_2core_glPointParameteri(void *_glfuncs, GLenum pname, GLint param); +void gl3_2core_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl3_2core_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param); +void gl3_2core_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount); +void gl3_2core_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +void gl3_2core_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +GLboolean gl3_2core_glUnmapBuffer(void *_glfuncs, GLenum target); +void gl3_2core_glGetBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data); +void gl3_2core_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data); +void gl3_2core_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage); +GLboolean gl3_2core_glIsBuffer(void *_glfuncs, GLuint buffer); +void gl3_2core_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers); +void gl3_2core_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers); +void gl3_2core_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer); +void gl3_2core_glGetQueryObjectuiv(void *_glfuncs, GLuint id, GLenum pname, GLuint* params); +void gl3_2core_glGetQueryObjectiv(void *_glfuncs, GLuint id, GLenum pname, GLint* params); +void gl3_2core_glGetQueryiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_2core_glEndQuery(void *_glfuncs, GLenum target); +void gl3_2core_glBeginQuery(void *_glfuncs, GLenum target, GLuint id); +GLboolean gl3_2core_glIsQuery(void *_glfuncs, GLuint id); +void gl3_2core_glDeleteQueries(void *_glfuncs, GLsizei n, const GLuint* ids); +void gl3_2core_glGenQueries(void *_glfuncs, GLsizei n, GLuint* ids); +void gl3_2core_glVertexAttribPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLboolean normalized, GLsizei stride, const GLvoid* offset); +void gl3_2core_glValidateProgram(void *_glfuncs, GLuint program); +void gl3_2core_glUniformMatrix4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_2core_glUniformMatrix3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_2core_glUniformMatrix2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_2core_glUniform4iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl3_2core_glUniform3iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl3_2core_glUniform2iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl3_2core_glUniform1iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl3_2core_glUniform4fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl3_2core_glUniform3fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl3_2core_glUniform2fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl3_2core_glUniform1fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl3_2core_glUniform4i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +void gl3_2core_glUniform3i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2); +void gl3_2core_glUniform2i(void *_glfuncs, GLint location, GLint v0, GLint v1); +void gl3_2core_glUniform1i(void *_glfuncs, GLint location, GLint v0); +void gl3_2core_glUniform4f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +void gl3_2core_glUniform3f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +void gl3_2core_glUniform2f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1); +void gl3_2core_glUniform1f(void *_glfuncs, GLint location, GLfloat v0); +void gl3_2core_glUseProgram(void *_glfuncs, GLuint program); +void gl3_2core_glShaderSource(void *_glfuncs, GLuint shader, GLsizei count, const GLchar** source, const GLint* length); +void gl3_2core_glLinkProgram(void *_glfuncs, GLuint program); +GLboolean gl3_2core_glIsShader(void *_glfuncs, GLuint shader); +GLboolean gl3_2core_glIsProgram(void *_glfuncs, GLuint program); +void gl3_2core_glGetVertexAttribiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params); +void gl3_2core_glGetVertexAttribfv(void *_glfuncs, GLuint index, GLenum pname, GLfloat* params); +void gl3_2core_glGetVertexAttribdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params); +void gl3_2core_glGetUniformiv(void *_glfuncs, GLuint program, GLint location, GLint* params); +void gl3_2core_glGetUniformfv(void *_glfuncs, GLuint program, GLint location, GLfloat* params); +GLint gl3_2core_glGetUniformLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl3_2core_glGetShaderSource(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source); +void gl3_2core_glGetShaderInfoLog(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl3_2core_glGetShaderiv(void *_glfuncs, GLuint shader, GLenum pname, GLint* params); +void gl3_2core_glGetProgramInfoLog(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl3_2core_glGetProgramiv(void *_glfuncs, GLuint program, GLenum pname, GLint* params); +GLint gl3_2core_glGetAttribLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl3_2core_glGetAttachedShaders(void *_glfuncs, GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj); +void gl3_2core_glGetActiveUniform(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name); +void gl3_2core_glGetActiveAttrib(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name); +void gl3_2core_glEnableVertexAttribArray(void *_glfuncs, GLuint index); +void gl3_2core_glDisableVertexAttribArray(void *_glfuncs, GLuint index); +void gl3_2core_glDetachShader(void *_glfuncs, GLuint program, GLuint shader); +void gl3_2core_glDeleteShader(void *_glfuncs, GLuint shader); +void gl3_2core_glDeleteProgram(void *_glfuncs, GLuint program); +GLuint gl3_2core_glCreateShader(void *_glfuncs, GLenum gltype); +GLuint gl3_2core_glCreateProgram(void *_glfuncs); +void gl3_2core_glCompileShader(void *_glfuncs, GLuint shader); +void gl3_2core_glBindAttribLocation(void *_glfuncs, GLuint program, GLuint index, const GLchar* name); +void gl3_2core_glAttachShader(void *_glfuncs, GLuint program, GLuint shader); +void gl3_2core_glStencilMaskSeparate(void *_glfuncs, GLenum face, GLuint mask); +void gl3_2core_glStencilFuncSeparate(void *_glfuncs, GLenum face, GLenum glfunc, GLint ref, GLuint mask); +void gl3_2core_glStencilOpSeparate(void *_glfuncs, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +void gl3_2core_glDrawBuffers(void *_glfuncs, GLsizei n, const GLenum* bufs); +void gl3_2core_glBlendEquationSeparate(void *_glfuncs, GLenum modeRGB, GLenum modeAlpha); +void gl3_2core_glUniformMatrix4x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_2core_glUniformMatrix3x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_2core_glUniformMatrix4x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_2core_glUniformMatrix2x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_2core_glUniformMatrix3x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_2core_glUniformMatrix2x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +GLboolean gl3_2core_glIsVertexArray(void *_glfuncs, GLuint array); +void gl3_2core_glGenVertexArrays(void *_glfuncs, GLsizei n, GLuint* arrays); +void gl3_2core_glDeleteVertexArrays(void *_glfuncs, GLsizei n, const GLuint* arrays); +void gl3_2core_glBindVertexArray(void *_glfuncs, GLuint array); +void gl3_2core_glFlushMappedBufferRange(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr length); +void gl3_2core_glFramebufferTextureLayer(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +void gl3_2core_glRenderbufferStorageMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height); +void gl3_2core_glBlitFramebuffer(void *_glfuncs, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +void gl3_2core_glGenerateMipmap(void *_glfuncs, GLenum target); +void gl3_2core_glGetFramebufferAttachmentParameteriv(void *_glfuncs, GLenum target, GLenum attachment, GLenum pname, GLint* params); +void gl3_2core_glFramebufferRenderbuffer(void *_glfuncs, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +void gl3_2core_glFramebufferTexture3D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +void gl3_2core_glFramebufferTexture2D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +void gl3_2core_glFramebufferTexture1D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLenum gl3_2core_glCheckFramebufferStatus(void *_glfuncs, GLenum target); +void gl3_2core_glGenFramebuffers(void *_glfuncs, GLsizei n, GLuint* framebuffers); +void gl3_2core_glDeleteFramebuffers(void *_glfuncs, GLsizei n, const GLuint* framebuffers); +void gl3_2core_glBindFramebuffer(void *_glfuncs, GLenum target, GLuint framebuffer); +GLboolean gl3_2core_glIsFramebuffer(void *_glfuncs, GLuint framebuffer); +void gl3_2core_glGetRenderbufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_2core_glRenderbufferStorage(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height); +void gl3_2core_glGenRenderbuffers(void *_glfuncs, GLsizei n, GLuint* renderbuffers); +void gl3_2core_glDeleteRenderbuffers(void *_glfuncs, GLsizei n, const GLuint* renderbuffers); +void gl3_2core_glBindRenderbuffer(void *_glfuncs, GLenum target, GLuint renderbuffer); +GLboolean gl3_2core_glIsRenderbuffer(void *_glfuncs, GLuint renderbuffer); +void gl3_2core_glClearBufferfi(void *_glfuncs, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); +void gl3_2core_glClearBufferfv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLfloat* value); +void gl3_2core_glClearBufferuiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLuint* value); +void gl3_2core_glClearBufferiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLint* value); +void gl3_2core_glGetTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, GLuint* params); +void gl3_2core_glGetTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_2core_glTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, const GLuint* params); +void gl3_2core_glTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl3_2core_glUniform4uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl3_2core_glUniform3uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl3_2core_glUniform2uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl3_2core_glUniform1uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl3_2core_glUniform4ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +void gl3_2core_glUniform3ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2); +void gl3_2core_glUniform2ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1); +void gl3_2core_glUniform1ui(void *_glfuncs, GLint location, GLuint v0); +GLint gl3_2core_glGetFragDataLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl3_2core_glBindFragDataLocation(void *_glfuncs, GLuint program, GLuint color, const GLchar* name); +void gl3_2core_glGetUniformuiv(void *_glfuncs, GLuint program, GLint location, GLuint* params); +void gl3_2core_glGetVertexAttribIuiv(void *_glfuncs, GLuint index, GLenum pname, GLuint* params); +void gl3_2core_glGetVertexAttribIiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params); +void gl3_2core_glVertexAttribIPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl3_2core_glEndConditionalRender(void *_glfuncs); +void gl3_2core_glBeginConditionalRender(void *_glfuncs, GLuint id, GLenum mode); +void gl3_2core_glClampColor(void *_glfuncs, GLenum target, GLenum clamp); +void gl3_2core_glGetTransformFeedbackVarying(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* gltype, GLchar* name); +void gl3_2core_glBindBufferBase(void *_glfuncs, GLenum target, GLuint index, GLuint buffer); +void gl3_2core_glBindBufferRange(void *_glfuncs, GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +void gl3_2core_glEndTransformFeedback(void *_glfuncs); +void gl3_2core_glBeginTransformFeedback(void *_glfuncs, GLenum primitiveMode); +GLboolean gl3_2core_glIsEnabledi(void *_glfuncs, GLenum target, GLuint index); +void gl3_2core_glDisablei(void *_glfuncs, GLenum target, GLuint index); +void gl3_2core_glEnablei(void *_glfuncs, GLenum target, GLuint index); +void gl3_2core_glGetIntegeri_v(void *_glfuncs, GLenum target, GLuint index, GLint* data); +void gl3_2core_glGetBooleani_v(void *_glfuncs, GLenum target, GLuint index, GLboolean* data); +void gl3_2core_glColorMaski(void *_glfuncs, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +void gl3_2core_glCopyBufferSubData(void *_glfuncs, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +void gl3_2core_glUniformBlockBinding(void *_glfuncs, GLuint program, GLuint v0, GLuint v1); +void gl3_2core_glGetActiveUniformBlockName(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName); +void gl3_2core_glGetActiveUniformBlockiv(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params); +GLuint gl3_2core_glGetUniformBlockIndex(void *_glfuncs, GLuint program, const GLchar* uniformBlockName); +void gl3_2core_glGetActiveUniformName(void *_glfuncs, GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName); +void gl3_2core_glGetActiveUniformsiv(void *_glfuncs, GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params); +void gl3_2core_glPrimitiveRestartIndex(void *_glfuncs, GLuint index); +void gl3_2core_glTexBuffer(void *_glfuncs, GLenum target, GLenum internalFormat, GLuint buffer); +void gl3_2core_glDrawElementsInstanced(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount); +void gl3_2core_glDrawArraysInstanced(void *_glfuncs, GLenum mode, GLint first, GLsizei count, GLsizei instancecount); +void gl3_2core_glSampleMaski(void *_glfuncs, GLuint index, GLbitfield mask); +void gl3_2core_glGetMultisamplefv(void *_glfuncs, GLenum pname, GLuint index, GLfloat* val); +void gl3_2core_glTexImage3DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); +void gl3_2core_glTexImage2DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +void gl3_2core_glGetSynciv(void *_glfuncs, GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values); +void gl3_2core_glGetInteger64v(void *_glfuncs, GLenum pname, GLint64* params); +void gl3_2core_glWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout); +GLenum gl3_2core_glClientWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout); +void gl3_2core_glDeleteSync(void *_glfuncs, GLsync sync); +GLboolean gl3_2core_glIsSync(void *_glfuncs, GLsync sync); +GLsync gl3_2core_glFenceSync(void *_glfuncs, GLenum condition, GLbitfield flags); +void gl3_2core_glProvokingVertex(void *_glfuncs, GLenum mode); +void gl3_2core_glDrawElementsInstancedBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLint basevertex); +void gl3_2core_glDrawRangeElementsBaseVertex(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex); +void gl3_2core_glDrawElementsBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex); +void gl3_2core_glFramebufferTexture(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level); +void gl3_2core_glGetBufferParameteri64v(void *_glfuncs, GLenum target, GLenum pname, GLint64* params); +void gl3_2core_glGetInteger64i_v(void *_glfuncs, GLenum target, GLuint index, GLint64* data); + + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/gl/3.2core/gl.go b/gl/3.2core/gl.go new file mode 100644 index 00000000..80805299 --- /dev/null +++ b/gl/3.2core/gl.go @@ -0,0 +1,4729 @@ +// ** file automatically generated by glgen -- do not edit manually ** + +package GL + +// #cgo CXXFLAGS: -std=c++0x -pedantic-errors -Wall -fno-strict-aliasing +// #cgo LDFLAGS: -lstdc++ +// #cgo pkg-config: Qt5Core Qt5OpenGL +// +// #include "funcs.h" +// +// void free(void*); +// +import "C" + +import ( + "fmt" + "reflect" + "unsafe" + + "gopkg.in/qml.v1/gl/glbase" +) + +// API returns a value that offers methods matching the OpenGL version 3.2 API. +// +// The returned API must not be used after the provided OpenGL context becomes invalid. +func API(context glbase.Contexter) *GL { + gl := &GL{} + gl.funcs = C.gl3_2core_funcs() + if gl.funcs == nil { + panic(fmt.Errorf("OpenGL version 3.2 is not available")) + } + return gl +} + +// GL implements the OpenGL version 3.2 API. Values of this +// type must be created via the API function, and it must not be used after +// the associated OpenGL context becomes invalid. +type GL struct { + funcs unsafe.Pointer +} + +const ( + FALSE = 0 + TRUE = 1 + NONE = 0 + + BYTE = 0x1400 + UNSIGNED_BYTE = 0x1401 + SHORT = 0x1402 + UNSIGNED_SHORT = 0x1403 + INT = 0x1404 + UNSIGNED_INT = 0x1405 + FLOAT = 0x1406 + DOUBLE = 0x140A + HALF_FLOAT = 0x140B + + COLOR_BUFFER_BIT = 0x00004000 + DEPTH_BUFFER_BIT = 0x00000100 + STENCIL_BUFFER_BIT = 0x00000400 + + ALWAYS = 0x0207 + EQUAL = 0x0202 + GEQUAL = 0x0206 + GREATER = 0x0204 + LEQUAL = 0x0203 + LESS = 0x0201 + NEVER = 0x0200 + NOTEQUAL = 0x0205 + + DST_ALPHA = 0x0304 + ONE = 1 + ONE_MINUS_DST_ALPHA = 0x0305 + ONE_MINUS_SRC_ALPHA = 0x0303 + ONE_MINUS_SRC_COLOR = 0x0301 + SRC_ALPHA = 0x0302 + SRC_COLOR = 0x0300 + ZERO = 0 + + DST_COLOR = 0x0306 + ONE_MINUS_DST_COLOR = 0x0307 + SRC_ALPHA_SATURATE = 0x0308 + + CLIP_DISTANCE0 = 0x3000 + CLIP_DISTANCE1 = 0x3001 + CLIP_DISTANCE2 = 0x3002 + CLIP_DISTANCE3 = 0x3003 + CLIP_DISTANCE4 = 0x3004 + CLIP_DISTANCE5 = 0x3005 + CLIP_DISTANCE6 = 0x3006 + CLIP_DISTANCE7 = 0x3007 + + BACK = 0x0405 + FRONT = 0x0404 + FRONT_AND_BACK = 0x0408 + + CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x00000001 + + CONTEXT_COMPATIBILITY_PROFILE_BIT = 0x00000002 + CONTEXT_CORE_PROFILE_BIT = 0x00000001 + + BACK_LEFT = 0x0402 + BACK_RIGHT = 0x0403 + FRONT_LEFT = 0x0400 + FRONT_RIGHT = 0x0401 + LEFT = 0x0406 + RIGHT = 0x0407 + + BLEND = 0x0BE2 + COLOR_LOGIC_OP = 0x0BF2 + CULL_FACE = 0x0B44 + DEPTH_TEST = 0x0B71 + DITHER = 0x0BD0 + LINE_SMOOTH = 0x0B20 + POLYGON_OFFSET_FILL = 0x8037 + POLYGON_OFFSET_LINE = 0x2A02 + POLYGON_OFFSET_POINT = 0x2A01 + POLYGON_SMOOTH = 0x0B41 + SCISSOR_TEST = 0x0C11 + STENCIL_TEST = 0x0B90 + TEXTURE_1D = 0x0DE0 + TEXTURE_2D = 0x0DE1 + + INVALID_ENUM = 0x0500 + INVALID_FRAMEBUFFER_OPERATION = 0x0506 + INVALID_OPERATION = 0x0502 + INVALID_VALUE = 0x0501 + NO_ERROR = 0 + OUT_OF_MEMORY = 0x0505 + + LINEAR = 0x2601 + + CCW = 0x0901 + CW = 0x0900 + + ALIASED_LINE_WIDTH_RANGE = 0x846E + BLEND_DST = 0x0BE0 + BLEND_SRC = 0x0BE1 + COLOR_CLEAR_VALUE = 0x0C22 + COLOR_WRITEMASK = 0x0C23 + CULL_FACE_MODE = 0x0B45 + DEPTH_CLEAR_VALUE = 0x0B73 + DEPTH_FUNC = 0x0B74 + DEPTH_RANGE = 0x0B70 + DEPTH_WRITEMASK = 0x0B72 + DOUBLEBUFFER = 0x0C32 + DRAW_BUFFER = 0x0C01 + FRONT_FACE = 0x0B46 + LINE_SMOOTH_HINT = 0x0C52 + LINE_WIDTH = 0x0B21 + LINE_WIDTH_GRANULARITY = 0x0B23 + LINE_WIDTH_RANGE = 0x0B22 + LOGIC_OP_MODE = 0x0BF0 + MAX_CLIP_DISTANCES = 0x0D32 + MAX_TEXTURE_SIZE = 0x0D33 + MAX_VIEWPORT_DIMS = 0x0D3A + PACK_ALIGNMENT = 0x0D05 + PACK_LSB_FIRST = 0x0D01 + PACK_ROW_LENGTH = 0x0D02 + PACK_SKIP_PIXELS = 0x0D04 + PACK_SKIP_ROWS = 0x0D03 + PACK_SWAP_BYTES = 0x0D00 + POINT_SIZE = 0x0B11 + POINT_SIZE_GRANULARITY = 0x0B13 + POINT_SIZE_RANGE = 0x0B12 + POLYGON_MODE = 0x0B40 + POLYGON_OFFSET_FACTOR = 0x8038 + POLYGON_OFFSET_UNITS = 0x2A00 + POLYGON_SMOOTH_HINT = 0x0C53 + READ_BUFFER = 0x0C02 + SCISSOR_BOX = 0x0C10 + SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23 + SMOOTH_LINE_WIDTH_RANGE = 0x0B22 + SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13 + SMOOTH_POINT_SIZE_RANGE = 0x0B12 + STENCIL_CLEAR_VALUE = 0x0B91 + STENCIL_FAIL = 0x0B94 + STENCIL_FUNC = 0x0B92 + STENCIL_PASS_DEPTH_FAIL = 0x0B95 + STENCIL_PASS_DEPTH_PASS = 0x0B96 + STENCIL_REF = 0x0B97 + STENCIL_VALUE_MASK = 0x0B93 + STENCIL_WRITEMASK = 0x0B98 + STEREO = 0x0C33 + SUBPIXEL_BITS = 0x0D50 + TEXTURE_BINDING_1D = 0x8068 + TEXTURE_BINDING_2D = 0x8069 + TEXTURE_BINDING_3D = 0x806A + UNPACK_ALIGNMENT = 0x0CF5 + UNPACK_LSB_FIRST = 0x0CF1 + UNPACK_ROW_LENGTH = 0x0CF2 + UNPACK_SKIP_PIXELS = 0x0CF4 + UNPACK_SKIP_ROWS = 0x0CF3 + UNPACK_SWAP_BYTES = 0x0CF0 + VIEWPORT = 0x0BA2 + + TEXTURE_ALPHA_SIZE = 0x805F + TEXTURE_BLUE_SIZE = 0x805E + TEXTURE_BORDER_COLOR = 0x1004 + TEXTURE_GREEN_SIZE = 0x805D + TEXTURE_HEIGHT = 0x1001 + TEXTURE_INTERNAL_FORMAT = 0x1003 + TEXTURE_MAG_FILTER = 0x2800 + TEXTURE_MIN_FILTER = 0x2801 + TEXTURE_RED_SIZE = 0x805C + TEXTURE_WIDTH = 0x1000 + TEXTURE_WRAP_S = 0x2802 + TEXTURE_WRAP_T = 0x2803 + + DONT_CARE = 0x1100 + FASTEST = 0x1101 + NICEST = 0x1102 + + FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B + TEXTURE_COMPRESSION_HINT = 0x84EF + + REPLACE = 0x1E01 + + AND = 0x1501 + AND_INVERTED = 0x1504 + AND_REVERSE = 0x1502 + CLEAR = 0x1500 + COPY = 0x1503 + COPY_INVERTED = 0x150C + EQUIV = 0x1509 + INVERT = 0x150A + NAND = 0x150E + NOOP = 0x1505 + NOR = 0x1508 + OR = 0x1507 + OR_INVERTED = 0x150D + OR_REVERSE = 0x150B + SET = 0x150F + XOR = 0x1506 + + MAP_FLUSH_EXPLICIT_BIT = 0x0010 + MAP_INVALIDATE_BUFFER_BIT = 0x0008 + MAP_INVALIDATE_RANGE_BIT = 0x0004 + MAP_READ_BIT = 0x0001 + MAP_UNSYNCHRONIZED_BIT = 0x0020 + MAP_WRITE_BIT = 0x0002 + + TEXTURE = 0x1702 + + LINE = 0x1B01 + POINT = 0x1B00 + + FILL = 0x1B02 + + COLOR = 0x1800 + DEPTH = 0x1801 + STENCIL = 0x1802 + + ALPHA = 0x1906 + BLUE = 0x1905 + DEPTH_COMPONENT = 0x1902 + GREEN = 0x1904 + RED = 0x1903 + RGB = 0x1907 + RGBA = 0x1908 + STENCIL_INDEX = 0x1901 + + R3_G3_B2 = 0x2A10 + RGB10 = 0x8052 + RGB10_A2 = 0x8059 + RGB12 = 0x8053 + RGB16 = 0x8054 + RGB4 = 0x804F + RGB5 = 0x8050 + RGB5_A1 = 0x8057 + RGB8 = 0x8051 + RGBA12 = 0x805A + RGBA16 = 0x805B + RGBA2 = 0x8055 + RGBA4 = 0x8056 + RGBA8 = 0x8058 + + PACK_IMAGE_HEIGHT = 0x806C + PACK_SKIP_IMAGES = 0x806B + UNPACK_IMAGE_HEIGHT = 0x806E + UNPACK_SKIP_IMAGES = 0x806D + + UNSIGNED_BYTE_3_3_2 = 0x8032 + UNSIGNED_INT_10_10_10_2 = 0x8036 + UNSIGNED_INT_8_8_8_8 = 0x8035 + UNSIGNED_SHORT_4_4_4_4 = 0x8033 + UNSIGNED_SHORT_5_5_5_1 = 0x8034 + + POINT_FADE_THRESHOLD_SIZE = 0x8128 + + LINES = 0x0001 + LINES_ADJACENCY = 0x000A + LINE_LOOP = 0x0002 + LINE_STRIP = 0x0003 + LINE_STRIP_ADJACENCY = 0x000B + POINTS = 0x0000 + TRIANGLES = 0x0004 + TRIANGLES_ADJACENCY = 0x000C + TRIANGLE_FAN = 0x0006 + TRIANGLE_STRIP = 0x0005 + TRIANGLE_STRIP_ADJACENCY = 0x000D + + DECR = 0x1E03 + INCR = 0x1E02 + KEEP = 0x1E00 + + EXTENSIONS = 0x1F03 + RENDERER = 0x1F01 + VENDOR = 0x1F00 + VERSION = 0x1F02 + + NEAREST = 0x2600 + + LINEAR_MIPMAP_LINEAR = 0x2703 + LINEAR_MIPMAP_NEAREST = 0x2701 + NEAREST_MIPMAP_LINEAR = 0x2702 + NEAREST_MIPMAP_NEAREST = 0x2700 + + TEXTURE_WRAP_R = 0x8072 + + PROXY_TEXTURE_1D = 0x8063 + PROXY_TEXTURE_2D = 0x8064 + PROXY_TEXTURE_3D = 0x8070 + TEXTURE_3D = 0x806F + TEXTURE_BASE_LEVEL = 0x813C + TEXTURE_MAX_LEVEL = 0x813D + TEXTURE_MAX_LOD = 0x813B + TEXTURE_MIN_LOD = 0x813A + + CLAMP_TO_BORDER = 0x812D + CLAMP_TO_EDGE = 0x812F + REPEAT = 0x2901 + + SYNC_FLUSH_COMMANDS_BIT = 0x00000001 + INVALID_INDEX = 0xFFFFFFFF + TIMEOUT_IGNORED = 0xFFFFFFFFFFFFFFFF + CONSTANT_COLOR = 0x8001 + ONE_MINUS_CONSTANT_COLOR = 0x8002 + CONSTANT_ALPHA = 0x8003 + ONE_MINUS_CONSTANT_ALPHA = 0x8004 + FUNC_ADD = 0x8006 + MIN = 0x8007 + MAX = 0x8008 + BLEND_EQUATION_RGB = 0x8009 + FUNC_SUBTRACT = 0x800A + FUNC_REVERSE_SUBTRACT = 0x800B + TEXTURE_DEPTH = 0x8071 + MAX_3D_TEXTURE_SIZE = 0x8073 + MULTISAMPLE = 0x809D + SAMPLE_ALPHA_TO_COVERAGE = 0x809E + SAMPLE_ALPHA_TO_ONE = 0x809F + SAMPLE_COVERAGE = 0x80A0 + SAMPLE_BUFFERS = 0x80A8 + SAMPLES = 0x80A9 + SAMPLE_COVERAGE_VALUE = 0x80AA + SAMPLE_COVERAGE_INVERT = 0x80AB + BLEND_DST_RGB = 0x80C8 + BLEND_SRC_RGB = 0x80C9 + BLEND_DST_ALPHA = 0x80CA + BLEND_SRC_ALPHA = 0x80CB + BGR = 0x80E0 + BGRA = 0x80E1 + MAX_ELEMENTS_VERTICES = 0x80E8 + MAX_ELEMENTS_INDICES = 0x80E9 + DEPTH_COMPONENT16 = 0x81A5 + DEPTH_COMPONENT24 = 0x81A6 + DEPTH_COMPONENT32 = 0x81A7 + FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210 + FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211 + FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212 + FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213 + FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214 + FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215 + FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216 + FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217 + FRAMEBUFFER_DEFAULT = 0x8218 + FRAMEBUFFER_UNDEFINED = 0x8219 + DEPTH_STENCIL_ATTACHMENT = 0x821A + MAJOR_VERSION = 0x821B + MINOR_VERSION = 0x821C + NUM_EXTENSIONS = 0x821D + CONTEXT_FLAGS = 0x821E + COMPRESSED_RED = 0x8225 + COMPRESSED_RG = 0x8226 + RG = 0x8227 + RG_INTEGER = 0x8228 + R8 = 0x8229 + R16 = 0x822A + RG8 = 0x822B + RG16 = 0x822C + R16F = 0x822D + R32F = 0x822E + RG16F = 0x822F + RG32F = 0x8230 + R8I = 0x8231 + R8UI = 0x8232 + R16I = 0x8233 + R16UI = 0x8234 + R32I = 0x8235 + R32UI = 0x8236 + RG8I = 0x8237 + RG8UI = 0x8238 + RG16I = 0x8239 + RG16UI = 0x823A + RG32I = 0x823B + RG32UI = 0x823C + UNSIGNED_BYTE_2_3_3_REV = 0x8362 + UNSIGNED_SHORT_5_6_5 = 0x8363 + UNSIGNED_SHORT_5_6_5_REV = 0x8364 + UNSIGNED_SHORT_4_4_4_4_REV = 0x8365 + UNSIGNED_SHORT_1_5_5_5_REV = 0x8366 + UNSIGNED_INT_8_8_8_8_REV = 0x8367 + UNSIGNED_INT_2_10_10_10_REV = 0x8368 + MIRRORED_REPEAT = 0x8370 + TEXTURE0 = 0x84C0 + TEXTURE1 = 0x84C1 + TEXTURE2 = 0x84C2 + TEXTURE3 = 0x84C3 + TEXTURE4 = 0x84C4 + TEXTURE5 = 0x84C5 + TEXTURE6 = 0x84C6 + TEXTURE7 = 0x84C7 + TEXTURE8 = 0x84C8 + TEXTURE9 = 0x84C9 + TEXTURE10 = 0x84CA + TEXTURE11 = 0x84CB + TEXTURE12 = 0x84CC + TEXTURE13 = 0x84CD + TEXTURE14 = 0x84CE + TEXTURE15 = 0x84CF + TEXTURE16 = 0x84D0 + TEXTURE17 = 0x84D1 + TEXTURE18 = 0x84D2 + TEXTURE19 = 0x84D3 + TEXTURE20 = 0x84D4 + TEXTURE21 = 0x84D5 + TEXTURE22 = 0x84D6 + TEXTURE23 = 0x84D7 + TEXTURE24 = 0x84D8 + TEXTURE25 = 0x84D9 + TEXTURE26 = 0x84DA + TEXTURE27 = 0x84DB + TEXTURE28 = 0x84DC + TEXTURE29 = 0x84DD + TEXTURE30 = 0x84DE + TEXTURE31 = 0x84DF + ACTIVE_TEXTURE = 0x84E0 + MAX_RENDERBUFFER_SIZE = 0x84E8 + COMPRESSED_RGB = 0x84ED + COMPRESSED_RGBA = 0x84EE + TEXTURE_RECTANGLE = 0x84F5 + TEXTURE_BINDING_RECTANGLE = 0x84F6 + PROXY_TEXTURE_RECTANGLE = 0x84F7 + MAX_RECTANGLE_TEXTURE_SIZE = 0x84F8 + DEPTH_STENCIL = 0x84F9 + UNSIGNED_INT_24_8 = 0x84FA + MAX_TEXTURE_LOD_BIAS = 0x84FD + TEXTURE_LOD_BIAS = 0x8501 + INCR_WRAP = 0x8507 + DECR_WRAP = 0x8508 + TEXTURE_CUBE_MAP = 0x8513 + TEXTURE_BINDING_CUBE_MAP = 0x8514 + TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515 + TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516 + TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517 + TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518 + TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519 + TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A + PROXY_TEXTURE_CUBE_MAP = 0x851B + MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C + SRC1_ALPHA = 0x8589 + VERTEX_ARRAY_BINDING = 0x85B5 + VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622 + VERTEX_ATTRIB_ARRAY_SIZE = 0x8623 + VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624 + VERTEX_ATTRIB_ARRAY_TYPE = 0x8625 + CURRENT_VERTEX_ATTRIB = 0x8626 + VERTEX_PROGRAM_POINT_SIZE = 0x8642 + PROGRAM_POINT_SIZE = 0x8642 + VERTEX_ATTRIB_ARRAY_POINTER = 0x8645 + DEPTH_CLAMP = 0x864F + TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0 + TEXTURE_COMPRESSED = 0x86A1 + NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2 + COMPRESSED_TEXTURE_FORMATS = 0x86A3 + BUFFER_SIZE = 0x8764 + BUFFER_USAGE = 0x8765 + STENCIL_BACK_FUNC = 0x8800 + STENCIL_BACK_FAIL = 0x8801 + STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802 + STENCIL_BACK_PASS_DEPTH_PASS = 0x8803 + RGBA32F = 0x8814 + RGB32F = 0x8815 + RGBA16F = 0x881A + RGB16F = 0x881B + MAX_DRAW_BUFFERS = 0x8824 + DRAW_BUFFER0 = 0x8825 + DRAW_BUFFER1 = 0x8826 + DRAW_BUFFER2 = 0x8827 + DRAW_BUFFER3 = 0x8828 + DRAW_BUFFER4 = 0x8829 + DRAW_BUFFER5 = 0x882A + DRAW_BUFFER6 = 0x882B + DRAW_BUFFER7 = 0x882C + DRAW_BUFFER8 = 0x882D + DRAW_BUFFER9 = 0x882E + DRAW_BUFFER10 = 0x882F + DRAW_BUFFER11 = 0x8830 + DRAW_BUFFER12 = 0x8831 + DRAW_BUFFER13 = 0x8832 + DRAW_BUFFER14 = 0x8833 + DRAW_BUFFER15 = 0x8834 + BLEND_EQUATION_ALPHA = 0x883D + TEXTURE_DEPTH_SIZE = 0x884A + TEXTURE_COMPARE_MODE = 0x884C + TEXTURE_COMPARE_FUNC = 0x884D + COMPARE_REF_TO_TEXTURE = 0x884E + TEXTURE_CUBE_MAP_SEAMLESS = 0x884F + QUERY_COUNTER_BITS = 0x8864 + CURRENT_QUERY = 0x8865 + QUERY_RESULT = 0x8866 + QUERY_RESULT_AVAILABLE = 0x8867 + MAX_VERTEX_ATTRIBS = 0x8869 + VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A + MAX_TEXTURE_IMAGE_UNITS = 0x8872 + ARRAY_BUFFER = 0x8892 + ELEMENT_ARRAY_BUFFER = 0x8893 + ARRAY_BUFFER_BINDING = 0x8894 + ELEMENT_ARRAY_BUFFER_BINDING = 0x8895 + VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F + READ_ONLY = 0x88B8 + WRITE_ONLY = 0x88B9 + READ_WRITE = 0x88BA + BUFFER_ACCESS = 0x88BB + BUFFER_MAPPED = 0x88BC + BUFFER_MAP_POINTER = 0x88BD + STREAM_DRAW = 0x88E0 + STREAM_READ = 0x88E1 + STREAM_COPY = 0x88E2 + STATIC_DRAW = 0x88E4 + STATIC_READ = 0x88E5 + STATIC_COPY = 0x88E6 + DYNAMIC_DRAW = 0x88E8 + DYNAMIC_READ = 0x88E9 + DYNAMIC_COPY = 0x88EA + PIXEL_PACK_BUFFER = 0x88EB + PIXEL_UNPACK_BUFFER = 0x88EC + PIXEL_PACK_BUFFER_BINDING = 0x88ED + PIXEL_UNPACK_BUFFER_BINDING = 0x88EF + DEPTH24_STENCIL8 = 0x88F0 + TEXTURE_STENCIL_SIZE = 0x88F1 + VERTEX_ATTRIB_ARRAY_INTEGER = 0x88FD + MAX_ARRAY_TEXTURE_LAYERS = 0x88FF + MIN_PROGRAM_TEXEL_OFFSET = 0x8904 + MAX_PROGRAM_TEXEL_OFFSET = 0x8905 + SAMPLES_PASSED = 0x8914 + GEOMETRY_VERTICES_OUT = 0x8916 + GEOMETRY_INPUT_TYPE = 0x8917 + GEOMETRY_OUTPUT_TYPE = 0x8918 + CLAMP_READ_COLOR = 0x891C + FIXED_ONLY = 0x891D + UNIFORM_BUFFER = 0x8A11 + UNIFORM_BUFFER_BINDING = 0x8A28 + UNIFORM_BUFFER_START = 0x8A29 + UNIFORM_BUFFER_SIZE = 0x8A2A + MAX_VERTEX_UNIFORM_BLOCKS = 0x8A2B + MAX_GEOMETRY_UNIFORM_BLOCKS = 0x8A2C + MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8A2D + MAX_COMBINED_UNIFORM_BLOCKS = 0x8A2E + MAX_UNIFORM_BUFFER_BINDINGS = 0x8A2F + MAX_UNIFORM_BLOCK_SIZE = 0x8A30 + MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31 + MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 0x8A32 + MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33 + UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8A34 + ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35 + ACTIVE_UNIFORM_BLOCKS = 0x8A36 + UNIFORM_TYPE = 0x8A37 + UNIFORM_SIZE = 0x8A38 + UNIFORM_NAME_LENGTH = 0x8A39 + UNIFORM_BLOCK_INDEX = 0x8A3A + UNIFORM_OFFSET = 0x8A3B + UNIFORM_ARRAY_STRIDE = 0x8A3C + UNIFORM_MATRIX_STRIDE = 0x8A3D + UNIFORM_IS_ROW_MAJOR = 0x8A3E + UNIFORM_BLOCK_BINDING = 0x8A3F + UNIFORM_BLOCK_DATA_SIZE = 0x8A40 + UNIFORM_BLOCK_NAME_LENGTH = 0x8A41 + UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8A42 + UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43 + UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44 + UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 0x8A45 + UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46 + FRAGMENT_SHADER = 0x8B30 + VERTEX_SHADER = 0x8B31 + MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49 + MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A + MAX_VARYING_FLOATS = 0x8B4B + MAX_VARYING_COMPONENTS = 0x8B4B + MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C + MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D + SHADER_TYPE = 0x8B4F + FLOAT_VEC2 = 0x8B50 + FLOAT_VEC3 = 0x8B51 + FLOAT_VEC4 = 0x8B52 + INT_VEC2 = 0x8B53 + INT_VEC3 = 0x8B54 + INT_VEC4 = 0x8B55 + BOOL = 0x8B56 + BOOL_VEC2 = 0x8B57 + BOOL_VEC3 = 0x8B58 + BOOL_VEC4 = 0x8B59 + FLOAT_MAT2 = 0x8B5A + FLOAT_MAT3 = 0x8B5B + FLOAT_MAT4 = 0x8B5C + SAMPLER_1D = 0x8B5D + SAMPLER_2D = 0x8B5E + SAMPLER_3D = 0x8B5F + SAMPLER_CUBE = 0x8B60 + SAMPLER_1D_SHADOW = 0x8B61 + SAMPLER_2D_SHADOW = 0x8B62 + SAMPLER_2D_RECT = 0x8B63 + SAMPLER_2D_RECT_SHADOW = 0x8B64 + FLOAT_MAT2x3 = 0x8B65 + FLOAT_MAT2x4 = 0x8B66 + FLOAT_MAT3x2 = 0x8B67 + FLOAT_MAT3x4 = 0x8B68 + FLOAT_MAT4x2 = 0x8B69 + FLOAT_MAT4x3 = 0x8B6A + DELETE_STATUS = 0x8B80 + COMPILE_STATUS = 0x8B81 + LINK_STATUS = 0x8B82 + VALIDATE_STATUS = 0x8B83 + INFO_LOG_LENGTH = 0x8B84 + ATTACHED_SHADERS = 0x8B85 + ACTIVE_UNIFORMS = 0x8B86 + ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87 + SHADER_SOURCE_LENGTH = 0x8B88 + ACTIVE_ATTRIBUTES = 0x8B89 + ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A + SHADING_LANGUAGE_VERSION = 0x8B8C + CURRENT_PROGRAM = 0x8B8D + TEXTURE_RED_TYPE = 0x8C10 + TEXTURE_GREEN_TYPE = 0x8C11 + TEXTURE_BLUE_TYPE = 0x8C12 + TEXTURE_ALPHA_TYPE = 0x8C13 + TEXTURE_DEPTH_TYPE = 0x8C16 + UNSIGNED_NORMALIZED = 0x8C17 + TEXTURE_1D_ARRAY = 0x8C18 + PROXY_TEXTURE_1D_ARRAY = 0x8C19 + TEXTURE_2D_ARRAY = 0x8C1A + PROXY_TEXTURE_2D_ARRAY = 0x8C1B + TEXTURE_BINDING_1D_ARRAY = 0x8C1C + TEXTURE_BINDING_2D_ARRAY = 0x8C1D + MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = 0x8C29 + TEXTURE_BUFFER = 0x8C2A + MAX_TEXTURE_BUFFER_SIZE = 0x8C2B + TEXTURE_BINDING_BUFFER = 0x8C2C + TEXTURE_BUFFER_DATA_STORE_BINDING = 0x8C2D + R11F_G11F_B10F = 0x8C3A + UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B + RGB9_E5 = 0x8C3D + UNSIGNED_INT_5_9_9_9_REV = 0x8C3E + TEXTURE_SHARED_SIZE = 0x8C3F + SRGB = 0x8C40 + SRGB8 = 0x8C41 + SRGB_ALPHA = 0x8C42 + SRGB8_ALPHA8 = 0x8C43 + COMPRESSED_SRGB = 0x8C48 + COMPRESSED_SRGB_ALPHA = 0x8C49 + TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76 + TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F + MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80 + TRANSFORM_FEEDBACK_VARYINGS = 0x8C83 + TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84 + TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85 + PRIMITIVES_GENERATED = 0x8C87 + TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88 + RASTERIZER_DISCARD = 0x8C89 + MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A + MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B + INTERLEAVED_ATTRIBS = 0x8C8C + SEPARATE_ATTRIBS = 0x8C8D + TRANSFORM_FEEDBACK_BUFFER = 0x8C8E + TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F + POINT_SPRITE_COORD_ORIGIN = 0x8CA0 + LOWER_LEFT = 0x8CA1 + UPPER_LEFT = 0x8CA2 + STENCIL_BACK_REF = 0x8CA3 + STENCIL_BACK_VALUE_MASK = 0x8CA4 + STENCIL_BACK_WRITEMASK = 0x8CA5 + DRAW_FRAMEBUFFER_BINDING = 0x8CA6 + FRAMEBUFFER_BINDING = 0x8CA6 + RENDERBUFFER_BINDING = 0x8CA7 + READ_FRAMEBUFFER = 0x8CA8 + DRAW_FRAMEBUFFER = 0x8CA9 + READ_FRAMEBUFFER_BINDING = 0x8CAA + RENDERBUFFER_SAMPLES = 0x8CAB + DEPTH_COMPONENT32F = 0x8CAC + DEPTH32F_STENCIL8 = 0x8CAD + FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0 + FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1 + FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2 + FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3 + FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4 + FRAMEBUFFER_COMPLETE = 0x8CD5 + FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6 + FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7 + FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB + FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC + FRAMEBUFFER_UNSUPPORTED = 0x8CDD + MAX_COLOR_ATTACHMENTS = 0x8CDF + COLOR_ATTACHMENT0 = 0x8CE0 + COLOR_ATTACHMENT1 = 0x8CE1 + COLOR_ATTACHMENT2 = 0x8CE2 + COLOR_ATTACHMENT3 = 0x8CE3 + COLOR_ATTACHMENT4 = 0x8CE4 + COLOR_ATTACHMENT5 = 0x8CE5 + COLOR_ATTACHMENT6 = 0x8CE6 + COLOR_ATTACHMENT7 = 0x8CE7 + COLOR_ATTACHMENT8 = 0x8CE8 + COLOR_ATTACHMENT9 = 0x8CE9 + COLOR_ATTACHMENT10 = 0x8CEA + COLOR_ATTACHMENT11 = 0x8CEB + COLOR_ATTACHMENT12 = 0x8CEC + COLOR_ATTACHMENT13 = 0x8CED + COLOR_ATTACHMENT14 = 0x8CEE + COLOR_ATTACHMENT15 = 0x8CEF + DEPTH_ATTACHMENT = 0x8D00 + STENCIL_ATTACHMENT = 0x8D20 + FRAMEBUFFER = 0x8D40 + RENDERBUFFER = 0x8D41 + RENDERBUFFER_WIDTH = 0x8D42 + RENDERBUFFER_HEIGHT = 0x8D43 + RENDERBUFFER_INTERNAL_FORMAT = 0x8D44 + STENCIL_INDEX1 = 0x8D46 + STENCIL_INDEX4 = 0x8D47 + STENCIL_INDEX8 = 0x8D48 + STENCIL_INDEX16 = 0x8D49 + RENDERBUFFER_RED_SIZE = 0x8D50 + RENDERBUFFER_GREEN_SIZE = 0x8D51 + RENDERBUFFER_BLUE_SIZE = 0x8D52 + RENDERBUFFER_ALPHA_SIZE = 0x8D53 + RENDERBUFFER_DEPTH_SIZE = 0x8D54 + RENDERBUFFER_STENCIL_SIZE = 0x8D55 + FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56 + MAX_SAMPLES = 0x8D57 + RGBA32UI = 0x8D70 + RGB32UI = 0x8D71 + RGBA16UI = 0x8D76 + RGB16UI = 0x8D77 + RGBA8UI = 0x8D7C + RGB8UI = 0x8D7D + RGBA32I = 0x8D82 + RGB32I = 0x8D83 + RGBA16I = 0x8D88 + RGB16I = 0x8D89 + RGBA8I = 0x8D8E + RGB8I = 0x8D8F + RED_INTEGER = 0x8D94 + GREEN_INTEGER = 0x8D95 + BLUE_INTEGER = 0x8D96 + RGB_INTEGER = 0x8D98 + RGBA_INTEGER = 0x8D99 + BGR_INTEGER = 0x8D9A + BGRA_INTEGER = 0x8D9B + FRAMEBUFFER_ATTACHMENT_LAYERED = 0x8DA7 + FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = 0x8DA8 + FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD + FRAMEBUFFER_SRGB = 0x8DB9 + COMPRESSED_RED_RGTC1 = 0x8DBB + COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC + COMPRESSED_RG_RGTC2 = 0x8DBD + COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE + SAMPLER_1D_ARRAY = 0x8DC0 + SAMPLER_2D_ARRAY = 0x8DC1 + SAMPLER_BUFFER = 0x8DC2 + SAMPLER_1D_ARRAY_SHADOW = 0x8DC3 + SAMPLER_2D_ARRAY_SHADOW = 0x8DC4 + SAMPLER_CUBE_SHADOW = 0x8DC5 + UNSIGNED_INT_VEC2 = 0x8DC6 + UNSIGNED_INT_VEC3 = 0x8DC7 + UNSIGNED_INT_VEC4 = 0x8DC8 + INT_SAMPLER_1D = 0x8DC9 + INT_SAMPLER_2D = 0x8DCA + INT_SAMPLER_3D = 0x8DCB + INT_SAMPLER_CUBE = 0x8DCC + INT_SAMPLER_2D_RECT = 0x8DCD + INT_SAMPLER_1D_ARRAY = 0x8DCE + INT_SAMPLER_2D_ARRAY = 0x8DCF + INT_SAMPLER_BUFFER = 0x8DD0 + UNSIGNED_INT_SAMPLER_1D = 0x8DD1 + UNSIGNED_INT_SAMPLER_2D = 0x8DD2 + UNSIGNED_INT_SAMPLER_3D = 0x8DD3 + UNSIGNED_INT_SAMPLER_CUBE = 0x8DD4 + UNSIGNED_INT_SAMPLER_2D_RECT = 0x8DD5 + UNSIGNED_INT_SAMPLER_1D_ARRAY = 0x8DD6 + UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8DD7 + UNSIGNED_INT_SAMPLER_BUFFER = 0x8DD8 + GEOMETRY_SHADER = 0x8DD9 + MAX_GEOMETRY_UNIFORM_COMPONENTS = 0x8DDF + MAX_GEOMETRY_OUTPUT_VERTICES = 0x8DE0 + MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = 0x8DE1 + QUERY_WAIT = 0x8E13 + QUERY_NO_WAIT = 0x8E14 + QUERY_BY_REGION_WAIT = 0x8E15 + QUERY_BY_REGION_NO_WAIT = 0x8E16 + QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = 0x8E4C + FIRST_VERTEX_CONVENTION = 0x8E4D + LAST_VERTEX_CONVENTION = 0x8E4E + PROVOKING_VERTEX = 0x8E4F + SAMPLE_POSITION = 0x8E50 + SAMPLE_MASK = 0x8E51 + SAMPLE_MASK_VALUE = 0x8E52 + MAX_SAMPLE_MASK_WORDS = 0x8E59 + COPY_READ_BUFFER = 0x8F36 + COPY_WRITE_BUFFER = 0x8F37 + R8_SNORM = 0x8F94 + RG8_SNORM = 0x8F95 + RGB8_SNORM = 0x8F96 + RGBA8_SNORM = 0x8F97 + R16_SNORM = 0x8F98 + RG16_SNORM = 0x8F99 + RGB16_SNORM = 0x8F9A + RGBA16_SNORM = 0x8F9B + SIGNED_NORMALIZED = 0x8F9C + PRIMITIVE_RESTART = 0x8F9D + PRIMITIVE_RESTART_INDEX = 0x8F9E + TEXTURE_2D_MULTISAMPLE = 0x9100 + PROXY_TEXTURE_2D_MULTISAMPLE = 0x9101 + TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9102 + PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9103 + TEXTURE_BINDING_2D_MULTISAMPLE = 0x9104 + TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = 0x9105 + TEXTURE_SAMPLES = 0x9106 + TEXTURE_FIXED_SAMPLE_LOCATIONS = 0x9107 + SAMPLER_2D_MULTISAMPLE = 0x9108 + INT_SAMPLER_2D_MULTISAMPLE = 0x9109 + UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = 0x910A + SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910B + INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910C + UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910D + MAX_COLOR_TEXTURE_SAMPLES = 0x910E + MAX_DEPTH_TEXTURE_SAMPLES = 0x910F + MAX_INTEGER_SAMPLES = 0x9110 + MAX_SERVER_WAIT_TIMEOUT = 0x9111 + OBJECT_TYPE = 0x9112 + SYNC_CONDITION = 0x9113 + SYNC_STATUS = 0x9114 + SYNC_FLAGS = 0x9115 + SYNC_FENCE = 0x9116 + SYNC_GPU_COMMANDS_COMPLETE = 0x9117 + UNSIGNALED = 0x9118 + SIGNALED = 0x9119 + ALREADY_SIGNALED = 0x911A + TIMEOUT_EXPIRED = 0x911B + CONDITION_SATISFIED = 0x911C + WAIT_FAILED = 0x911D + BUFFER_ACCESS_FLAGS = 0x911F + BUFFER_MAP_LENGTH = 0x9120 + BUFFER_MAP_OFFSET = 0x9121 + MAX_VERTEX_OUTPUT_COMPONENTS = 0x9122 + MAX_GEOMETRY_INPUT_COMPONENTS = 0x9123 + MAX_GEOMETRY_OUTPUT_COMPONENTS = 0x9124 + MAX_FRAGMENT_INPUT_COMPONENTS = 0x9125 + CONTEXT_PROFILE_MASK = 0x9126 +) + +// https://www.opengl.org/sdk/docs/man3/xhtml/glViewport.xml +func (gl *GL) Viewport(x, y, width, height int) { + C.gl3_2core_glViewport(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// DepthRange specifies the mapping of depth values from normalized device +// coordinates to window coordinates. +// +// Parameter nearVal specifies the mapping of the near clipping plane to window +// coordinates (defaults to 0), while farVal specifies the mapping of the far +// clipping plane to window coordinates (defaults to 1). +// +// After clipping and division by w, depth coordinates range from -1 to 1, +// corresponding to the near and far clipping planes. DepthRange specifies a +// linear mapping of the normalized depth coordinates in this range to window +// depth coordinates. Regardless of the actual depth buffer implementation, +// window coordinate depth values are treated as though they range from 0 through 1 +// (like color components). Thus, the values accepted by DepthRange are both +// clamped to this range before they are accepted. +// +// The default setting of (0, 1) maps the near plane to 0 and the far plane to 1. +// With this mapping, the depth buffer range is fully utilized. +// +// It is not necessary that nearVal be less than farVal. Reverse mappings such as +// nearVal 1, and farVal 0 are acceptable. +// +// GL.INVALID_OPERATION is generated if DepthRange is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) DepthRange(nearVal, farVal float64) { + C.gl3_2core_glDepthRange(gl.funcs, C.GLdouble(nearVal), C.GLdouble(farVal)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsEnabled.xml +func (gl *GL) IsEnabled(cap glbase.Enum) bool { + glresult := C.gl3_2core_glIsEnabled(gl.funcs, C.GLenum(cap)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexLevelParameteriv.xml +func (gl *GL) GetTexLevelParameteriv(target glbase.Enum, level int, pname glbase.Enum, params []int32) { + C.gl3_2core_glGetTexLevelParameteriv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexLevelParameterfv.xml +func (gl *GL) GetTexLevelParameterfv(target glbase.Enum, level int, pname glbase.Enum, params []float32) { + C.gl3_2core_glGetTexLevelParameterfv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexParameteriv.xml +func (gl *GL) GetTexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_2core_glGetTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexParameterfv.xml +func (gl *GL) GetTexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl3_2core_glGetTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexImage.xml +func (gl *GL) GetTexImage(target glbase.Enum, level int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_2core_glGetTexImage(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetIntegerv.xml +func (gl *GL) GetIntegerv(pname glbase.Enum, params []int32) { + C.gl3_2core_glGetIntegerv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetFloatv.xml +func (gl *GL) GetFloatv(pname glbase.Enum, params []float32) { + C.gl3_2core_glGetFloatv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetError.xml +func (gl *GL) GetError() glbase.Enum { + glresult := C.gl3_2core_glGetError(gl.funcs) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetDoublev.xml +func (gl *GL) GetDoublev(pname glbase.Enum, params []float64) { + C.gl3_2core_glGetDoublev(gl.funcs, C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetBooleanv.xml +func (gl *GL) GetBooleanv(pname glbase.Enum, params []bool) { + C.gl3_2core_glGetBooleanv(gl.funcs, C.GLenum(pname), (*C.GLboolean)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glReadPixels.xml +func (gl *GL) ReadPixels(x, y, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_2core_glReadPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glReadBuffer.xml +func (gl *GL) ReadBuffer(mode glbase.Enum) { + C.gl3_2core_glReadBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPixelStorei.xml +func (gl *GL) PixelStorei(pname glbase.Enum, param int32) { + C.gl3_2core_glPixelStorei(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPixelStoref.xml +func (gl *GL) PixelStoref(pname glbase.Enum, param float32) { + C.gl3_2core_glPixelStoref(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDepthFunc.xml +func (gl *GL) DepthFunc(glfunc glbase.Enum) { + C.gl3_2core_glDepthFunc(gl.funcs, C.GLenum(glfunc)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilOp.xml +func (gl *GL) StencilOp(fail, zfail, zpass glbase.Enum) { + C.gl3_2core_glStencilOp(gl.funcs, C.GLenum(fail), C.GLenum(zfail), C.GLenum(zpass)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilFunc.xml +func (gl *GL) StencilFunc(glfunc glbase.Enum, ref int32, mask uint32) { + C.gl3_2core_glStencilFunc(gl.funcs, C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLogicOp.xml +func (gl *GL) LogicOp(opcode glbase.Enum) { + C.gl3_2core_glLogicOp(gl.funcs, C.GLenum(opcode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlendFunc.xml +func (gl *GL) BlendFunc(sfactor, dfactor glbase.Enum) { + C.gl3_2core_glBlendFunc(gl.funcs, C.GLenum(sfactor), C.GLenum(dfactor)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFlush.xml +func (gl *GL) Flush() { + C.gl3_2core_glFlush(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFinish.xml +func (gl *GL) Finish() { + C.gl3_2core_glFinish(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEnable.xml +func (gl *GL) Enable(cap glbase.Enum) { + C.gl3_2core_glEnable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDisable.xml +func (gl *GL) Disable(cap glbase.Enum) { + C.gl3_2core_glDisable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDepthMask.xml +func (gl *GL) DepthMask(flag bool) { + C.gl3_2core_glDepthMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorMask.xml +func (gl *GL) ColorMask(red, green, blue, alpha bool) { + C.gl3_2core_glColorMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&red)), *(*C.GLboolean)(unsafe.Pointer(&green)), *(*C.GLboolean)(unsafe.Pointer(&blue)), *(*C.GLboolean)(unsafe.Pointer(&alpha))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilMask.xml +func (gl *GL) StencilMask(mask uint32) { + C.gl3_2core_glStencilMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearDepth.xml +func (gl *GL) ClearDepth(depth float64) { + C.gl3_2core_glClearDepth(gl.funcs, C.GLdouble(depth)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearStencil.xml +func (gl *GL) ClearStencil(s int32) { + C.gl3_2core_glClearStencil(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearColor.xml +func (gl *GL) ClearColor(red, green, blue, alpha float32) { + C.gl3_2core_glClearColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClear.xml +func (gl *GL) Clear(mask glbase.Bitfield) { + C.gl3_2core_glClear(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawBuffer.xml +func (gl *GL) DrawBuffer(mode glbase.Enum) { + C.gl3_2core_glDrawBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexImage2D.xml +func (gl *GL) TexImage2D(target glbase.Enum, level int, internalFormat int32, width, height, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_2core_glTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexImage1D.xml +func (gl *GL) TexImage1D(target glbase.Enum, level int, internalFormat int32, width, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_2core_glTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameteriv.xml +func (gl *GL) TexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_2core_glTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameteri.xml +func (gl *GL) TexParameteri(target, pname glbase.Enum, param int32) { + C.gl3_2core_glTexParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameterfv.xml +func (gl *GL) TexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl3_2core_glTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameterf.xml +func (gl *GL) TexParameterf(target, pname glbase.Enum, param float32) { + C.gl3_2core_glTexParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glScissor.xml +func (gl *GL) Scissor(x, y, width, height int) { + C.gl3_2core_glScissor(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPolygonMode.xml +func (gl *GL) PolygonMode(face, mode glbase.Enum) { + C.gl3_2core_glPolygonMode(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPointSize.xml +func (gl *GL) PointSize(size float32) { + C.gl3_2core_glPointSize(gl.funcs, C.GLfloat(size)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLineWidth.xml +func (gl *GL) LineWidth(width float32) { + C.gl3_2core_glLineWidth(gl.funcs, C.GLfloat(width)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glHint.xml +func (gl *GL) Hint(target, mode glbase.Enum) { + C.gl3_2core_glHint(gl.funcs, C.GLenum(target), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFrontFace.xml +func (gl *GL) FrontFace(mode glbase.Enum) { + C.gl3_2core_glFrontFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCullFace.xml +func (gl *GL) CullFace(mode glbase.Enum) { + C.gl3_2core_glCullFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexubv.xml +func (gl *GL) Indexubv(c []uint8) { + C.gl3_2core_glIndexubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexub.xml +func (gl *GL) Indexub(c uint8) { + C.gl3_2core_glIndexub(gl.funcs, C.GLubyte(c)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsTexture.xml +func (gl *GL) IsTexture(texture glbase.Texture) bool { + glresult := C.gl3_2core_glIsTexture(gl.funcs, C.GLuint(texture)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenTextures returns n texture names in textures. There is no guarantee +// that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenTextures. +// +// The generated textures have no dimensionality; they assume the +// dimensionality of the texture target to which they are first bound (see +// BindTexture). +// +// Texture names returned by a call to GenTextures are not returned by +// subsequent calls, unless they are first deleted with DeleteTextures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenTextures is available in GL version 2.0 or greater. +func (gl *GL) GenTextures(n int) []glbase.Texture { + if n == 0 { + return nil + } + textures := make([]glbase.Texture, n) + C.gl3_2core_glGenTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) + return textures +} + +// DeleteTextures deletes the textures objects whose names are stored +// in the textures slice. After a texture is deleted, it has no contents or +// dimensionality, and its name is free for reuse (for example by +// GenTextures). If a texture that is currently bound is deleted, the binding +// reverts to 0 (the default texture). +// +// DeleteTextures silently ignores 0's and names that do not correspond to +// existing textures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteTextures is available in GL version 2.0 or greater. +func (gl *GL) DeleteTextures(textures []glbase.Texture) { + n := len(textures) + if n == 0 { + return + } + C.gl3_2core_glDeleteTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindTexture.xml +func (gl *GL) BindTexture(target glbase.Enum, texture glbase.Texture) { + C.gl3_2core_glBindTexture(gl.funcs, C.GLenum(target), C.GLuint(texture)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexSubImage2D.xml +func (gl *GL) TexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_2core_glTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexSubImage1D.xml +func (gl *GL) TexSubImage1D(target glbase.Enum, level, xoffset, width int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_2core_glTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyTexSubImage2D.xml +func (gl *GL) CopyTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, x, y, width, height int) { + C.gl3_2core_glCopyTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyTexSubImage1D.xml +func (gl *GL) CopyTexSubImage1D(target glbase.Enum, level, xoffset, x, y, width int) { + C.gl3_2core_glCopyTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyTexImage2D.xml +func (gl *GL) CopyTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, height, border int) { + C.gl3_2core_glCopyTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyTexImage1D.xml +func (gl *GL) CopyTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, border int) { + C.gl3_2core_glCopyTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPolygonOffset.xml +func (gl *GL) PolygonOffset(factor, units float32) { + C.gl3_2core_glPolygonOffset(gl.funcs, C.GLfloat(factor), C.GLfloat(units)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawElements.xml +func (gl *GL) DrawElements(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl3_2core_glDrawElements(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawArrays.xml +func (gl *GL) DrawArrays(mode glbase.Enum, first, count int) { + C.gl3_2core_glDrawArrays(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyTexSubImage3D.xml +func (gl *GL) CopyTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, x, y, width, height int) { + C.gl3_2core_glCopyTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexSubImage3D.xml +func (gl *GL) TexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_2core_glTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexImage3D.xml +func (gl *GL) TexImage3D(target glbase.Enum, level int, internalFormat int32, width, height int, depth int32, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_2core_glTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawRangeElements.xml +func (gl *GL) DrawRangeElements(mode glbase.Enum, start, end uint32, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl3_2core_glDrawRangeElements(gl.funcs, C.GLenum(mode), C.GLuint(start), C.GLuint(end), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlendEquation.xml +func (gl *GL) BlendEquation(mode glbase.Enum) { + C.gl3_2core_glBlendEquation(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlendColor.xml +func (gl *GL) BlendColor(red, green, blue, alpha float32) { + C.gl3_2core_glBlendColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetCompressedTexImage.xml +func (gl *GL) GetCompressedTexImage(target glbase.Enum, level int, img interface{}) { + var img_ptr unsafe.Pointer + var img_v = reflect.ValueOf(img) + if img != nil && img_v.Kind() != reflect.Slice { + panic("parameter img must be a slice") + } + if img != nil { + img_ptr = unsafe.Pointer(img_v.Index(0).Addr().Pointer()) + } + C.gl3_2core_glGetCompressedTexImage(gl.funcs, C.GLenum(target), C.GLint(level), img_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexSubImage1D.xml +func (gl *GL) CompressedTexSubImage1D(target glbase.Enum, level, xoffset, width int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_2core_glCompressedTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexSubImage2D.xml +func (gl *GL) CompressedTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_2core_glCompressedTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexSubImage3D.xml +func (gl *GL) CompressedTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_2core_glCompressedTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexImage1D.xml +func (gl *GL) CompressedTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, width, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_2core_glCompressedTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexImage2D.xml +func (gl *GL) CompressedTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_2core_glCompressedTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexImage3D.xml +func (gl *GL) CompressedTexImage3D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height int, depth int32, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_2core_glCompressedTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSampleCoverage.xml +func (gl *GL) SampleCoverage(value float32, invert bool) { + C.gl3_2core_glSampleCoverage(gl.funcs, C.GLfloat(value), *(*C.GLboolean)(unsafe.Pointer(&invert))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glActiveTexture.xml +func (gl *GL) ActiveTexture(texture glbase.Enum) { + C.gl3_2core_glActiveTexture(gl.funcs, C.GLenum(texture)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPointParameteriv.xml +func (gl *GL) PointParameteriv(pname glbase.Enum, params []int32) { + C.gl3_2core_glPointParameteriv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPointParameteri.xml +func (gl *GL) PointParameteri(pname glbase.Enum, param int32) { + C.gl3_2core_glPointParameteri(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPointParameterfv.xml +func (gl *GL) PointParameterfv(pname glbase.Enum, params []float32) { + C.gl3_2core_glPointParameterfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPointParameterf.xml +func (gl *GL) PointParameterf(pname glbase.Enum, param float32) { + C.gl3_2core_glPointParameterf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiDrawArrays.xml +func (gl *GL) MultiDrawArrays(mode glbase.Enum, first, count []int, drawcount int32) { + C.gl3_2core_glMultiDrawArrays(gl.funcs, C.GLenum(mode), (*C.GLint)(unsafe.Pointer(&first[0])), (*C.GLsizei)(unsafe.Pointer(&count[0])), C.GLsizei(drawcount)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlendFuncSeparate.xml +func (gl *GL) BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha glbase.Enum) { + C.gl3_2core_glBlendFuncSeparate(gl.funcs, C.GLenum(sfactorRGB), C.GLenum(dfactorRGB), C.GLenum(sfactorAlpha), C.GLenum(dfactorAlpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetBufferParameteriv.xml +func (gl *GL) GetBufferParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_2core_glGetBufferParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glUnmapBuffer.xml +func (gl *GL) UnmapBuffer(target glbase.Enum) bool { + glresult := C.gl3_2core_glUnmapBuffer(gl.funcs, C.GLenum(target)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetBufferSubData.xml +func (gl *GL) GetBufferSubData(target glbase.Enum, offset, size int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_2core_glGetBufferSubData(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(size), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBufferSubData.xml +func (gl *GL) BufferSubData(target glbase.Enum, offset, size int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_2core_glBufferSubData(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(size), data_ptr) +} + +// BufferData creates a new data store for the buffer object currently +// bound to target. Any pre-existing data store is deleted. The new data +// store is created with the specified size in bytes and usage. If data is +// not nil, it must be a slice that is used to initialize the data store. +// In that case the size parameter is ignored and the store size will match +// the slice data size. +// +// In its initial state, the new data store is not mapped, it has a NULL +// mapped pointer, and its mapped access is GL.READ_WRITE. +// +// The target constant must be one of GL.ARRAY_BUFFER, GL.COPY_READ_BUFFER, +// GL.COPY_WRITE_BUFFER, GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER, +// GL.PIXEL_UNPACK_BUFFER, GL.TEXTURE_BUFFER, GL.TRANSFORM_FEEDBACK_BUFFER, +// or GL.UNIFORM_BUFFER. +// +// The usage parameter is a hint to the GL implementation as to how a buffer +// object's data store will be accessed. This enables the GL implementation +// to make more intelligent decisions that may significantly impact buffer +// object performance. It does not, however, constrain the actual usage of +// the data store. usage can be broken down into two parts: first, the +// frequency of access (modification and usage), and second, the nature of +// that access. +// +// A usage frequency of STREAM and nature of DRAW is specified via the +// constant GL.STREAM_DRAW, for example. +// +// The usage frequency of access may be one of: +// +// STREAM +// The data store contents will be modified once and used at most a few times. +// +// STATIC +// The data store contents will be modified once and used many times. +// +// DYNAMIC +// The data store contents will be modified repeatedly and used many times. +// +// The usage nature of access may be one of: +// +// DRAW +// The data store contents are modified by the application, and used as +// the source for GL drawing and image specification commands. +// +// READ +// The data store contents are modified by reading data from the GL, +// and used to return that data when queried by the application. +// +// COPY +// The data store contents are modified by reading data from the GL, +// and used as the source for GL drawing and image specification +// commands. +// +// Clients must align data elements consistent with the requirements of the +// client platform, with an additional base-level requirement that an offset +// within a buffer to a datum comprising N bytes be a multiple of N. +// +// Error GL.INVALID_ENUM is generated if target is not one of the accepted +// buffer targets. GL.INVALID_ENUM is generated if usage is not +// GL.STREAM_DRAW, GL.STREAM_READ, GL.STREAM_COPY, GL.STATIC_DRAW, +// GL.STATIC_READ, GL.STATIC_COPY, GL.DYNAMIC_DRAW, GL.DYNAMIC_READ, or +// GL.DYNAMIC_COPY. GL.INVALID_VALUE is generated if size is negative. +// GL.INVALID_OPERATION is generated if the reserved buffer object name 0 is +// bound to target. GL.OUT_OF_MEMORY is generated if the GL is unable to +// create a data store with the specified size. +func (gl *GL) BufferData(target glbase.Enum, size int, data interface{}, usage glbase.Enum) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + if data != nil { + size = int(data_v.Type().Size()) * data_v.Len() + } + C.gl3_2core_glBufferData(gl.funcs, C.GLenum(target), C.GLsizeiptr(size), data_ptr, C.GLenum(usage)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsBuffer.xml +func (gl *GL) IsBuffer(buffer glbase.Buffer) bool { + glresult := C.gl3_2core_glIsBuffer(gl.funcs, C.GLuint(buffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenBuffers returns n buffer object names. There is no guarantee that +// the names form a contiguous set of integers; however, it is guaranteed +// that none of the returned names was in use immediately before the call to +// GenBuffers. +// +// Buffer object names returned by a call to GenBuffers are not returned by +// subsequent calls, unless they are first deleted with DeleteBuffers. +// +// No buffer objects are associated with the returned buffer object names +// until they are first bound by calling BindBuffer. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if GenBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// GenBuffers is available in GL version 1.5 or greater. +func (gl *GL) GenBuffers(n int) []glbase.Buffer { + if n == 0 { + return nil + } + buffers := make([]glbase.Buffer, n) + C.gl3_2core_glGenBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) + return buffers +} + +// DeleteBuffers deletes the buffer objects whose names are stored in the +// buffers slice. +// +// After a buffer object is deleted, it has no contents, and its name is free +// for reuse (for example by GenBuffers). If a buffer object that is +// currently bound is deleted, the binding reverts to 0 (the absence of any +// buffer object, which reverts to client memory usage). +// +// DeleteBuffers silently ignores 0's and names that do not correspond to +// existing buffer objects. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if DeleteBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// DeleteBuffers is available in GL version 1.5 or greater. +func (gl *GL) DeleteBuffers(buffers []glbase.Buffer) { + n := len(buffers) + if n == 0 { + return + } + C.gl3_2core_glDeleteBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) +} + +// BindBuffer creates or puts in use a named buffer object. +// Calling BindBuffer with target set to GL.ARRAY_BUFFER, +// GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER or GL.PIXEL_UNPACK_BUFFER +// and buffer set to the name of the new buffer object binds the buffer +// object name to the target. When a buffer object is bound to a target, the +// previous binding for that target is automatically broken. +// +// Buffer object names are unsigned integers. The value zero is reserved, but +// there is no default buffer object for each buffer object target. Instead, +// buffer set to zero effectively unbinds any buffer object previously bound, +// and restores client memory usage for that buffer object target. Buffer +// object names and the corresponding buffer object contents are local to the +// shared display-list space (see XCreateContext) of the current GL rendering +// context; two rendering contexts share buffer object names only if they +// also share display lists. +// +// GenBuffers may be called to generate a set of new buffer object names. +// +// The state of a buffer object immediately after it is first bound is an +// unmapped zero-sized memory buffer with GL.READ_WRITE access and +// GL.STATIC_DRAW usage. +// +// While a non-zero buffer object name is bound, GL operations on the target +// to which it is bound affect the bound buffer object, and queries of the +// target to which it is bound return state from the bound buffer object. +// While buffer object name zero is bound, as in the initial state, attempts +// to modify or query state on the target to which it is bound generates an +// GL.INVALID_OPERATION error. +// +// When vertex array pointer state is changed, for example by a call to +// NormalPointer, the current buffer object binding (GL.ARRAY_BUFFER_BINDING) +// is copied into the corresponding client state for the vertex array type +// being changed, for example GL.NORMAL_ARRAY_BUFFER_BINDING. While a +// non-zero buffer object is bound to the GL.ARRAY_BUFFER target, the vertex +// array pointer parameter that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.ELEMENT_ARRAY_BUFFER +// target, the indices parameter of DrawElements, DrawRangeElements, or +// MultiDrawElements that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_PACK_BUFFER +// target, the following commands are affected: GetCompressedTexImage, +// GetConvolutionFilter, GetHistogram, GetMinmax, GetPixelMap, +// GetPolygonStipple, GetSeparableFilter, GetTexImage, and ReadPixels. The +// pointer parameter that is traditionally interpreted as a pointer to +// client-side memory where the pixels are to be packed is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_UNPACK_BUFFER +// target, the following commands are affected: Bitmap, ColorSubTable, +// ColorTable, CompressedTexImage1D, CompressedTexImage2D, +// CompressedTexImage3D, CompressedTexSubImage1D, CompressedTexSubImage2D, +// CompressedTexSubImage3D, ConvolutionFilter1D, ConvolutionFilter2D, +// DrawPixels, PixelMap, PolygonStipple, SeparableFilter2D, TexImage1D, +// TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, and TexSubImage3D. +// The pointer parameter that is traditionally interpreted as a pointer to +// client-side memory from which the pixels are to be unpacked is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// A buffer object binding created with BindBuffer remains active until a +// different buffer object name is bound to the same target, or until the +// bound buffer object is deleted with DeleteBuffers. +// +// Once created, a named buffer object may be re-bound to any target as often +// as needed. However, the GL implementation may make choices about how to +// optimize the storage of a buffer object based on its initial binding +// target. +// +// Error GL.INVALID_ENUM is generated if target is not one of the allowable +// values. GL.INVALID_OPERATION is generated if BindBuffer is executed +// between the execution of Begin and the corresponding execution of End. +// +// BindBuffer is available in GL version 1.5 or greater. +func (gl *GL) BindBuffer(target glbase.Enum, buffer glbase.Buffer) { + C.gl3_2core_glBindBuffer(gl.funcs, C.GLenum(target), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetQueryObjectuiv.xml +func (gl *GL) GetQueryObjectuiv(id uint32, pname glbase.Enum, params []uint32) { + C.gl3_2core_glGetQueryObjectuiv(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetQueryObjectiv.xml +func (gl *GL) GetQueryObjectiv(id uint32, pname glbase.Enum, params []int32) { + C.gl3_2core_glGetQueryObjectiv(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetQueryiv.xml +func (gl *GL) GetQueryiv(target, pname glbase.Enum, params []int32) { + C.gl3_2core_glGetQueryiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEndQuery.xml +func (gl *GL) EndQuery(target glbase.Enum) { + C.gl3_2core_glEndQuery(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBeginQuery.xml +func (gl *GL) BeginQuery(target glbase.Enum, id uint32) { + C.gl3_2core_glBeginQuery(gl.funcs, C.GLenum(target), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsQuery.xml +func (gl *GL) IsQuery(id uint32) bool { + glresult := C.gl3_2core_glIsQuery(gl.funcs, C.GLuint(id)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDeleteQueries.xml +func (gl *GL) DeleteQueries(n int, ids []uint32) { + C.gl3_2core_glDeleteQueries(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGenQueries.xml +func (gl *GL) GenQueries(n int, ids []uint32) { + C.gl3_2core_glGenQueries(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// VertexAttribPointer specifies the location and data format of the array +// of generic vertex attributes at index to use when rendering. size +// specifies the number of components per attribute and must be 1, 2, 3, or +// 4. type specifies the data type of each component, and stride specifies +// the byte stride from one attribute to the next, allowing vertices and +// attributes to be packed into a single array or stored in separate arrays. +// normalized indicates whether the values stored in an integer format are +// to be mapped to the range [-1,1] (for signed values) or [0,1] +// (for unsigned values) when they are accessed and converted to floating +// point; otherwise, values will be converted to floats directly without +// normalization. offset is a byte offset into the buffer object's data +// store, which must be bound to the GL.ARRAY_BUFFER target with BindBuffer. +// +// The buffer object binding (GL.ARRAY_BUFFER_BINDING) is saved as +// generic vertex attribute array client-side state +// (GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING) for the provided index. +// +// To enable and disable a generic vertex attribute array, call +// EnableVertexAttribArray and DisableVertexAttribArray with index. If +// enabled, the generic vertex attribute array is used when DrawArrays or +// DrawElements is called. Each generic vertex attribute array is initially +// disabled. +// +// VertexAttribPointer is typically implemented on the client side. +// +// Error GL.INVALID_ENUM is generated if type is not an accepted value. +// GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_VALUE is generated if size is not 1, 2, +// 3, or 4. GL.INVALID_VALUE is generated if stride is negative. +func (gl *GL) VertexAttribPointer(index glbase.Attrib, size int, gltype glbase.Enum, normalized bool, stride int, offset uintptr) { + offset_ptr := unsafe.Pointer(offset) + C.gl3_2core_glVertexAttribPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLsizei(stride), offset_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glValidateProgram.xml +func (gl *GL) ValidateProgram(program glbase.Program) { + C.gl3_2core_glValidateProgram(gl.funcs, C.GLuint(program)) +} + +// UniformMatrix4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*4) != 0 { + panic("invalid value length for UniformMatrix4fv") + } + count := len(value) / (4 * 4) + C.gl3_2core_glUniformMatrix4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*3) != 0 { + panic("invalid value length for UniformMatrix3fv") + } + count := len(value) / (3 * 3) + C.gl3_2core_glUniformMatrix3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*2) != 0 { + panic("invalid value length for UniformMatrix2fv") + } + count := len(value) / (2 * 2) + C.gl3_2core_glUniformMatrix2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform4iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4iv") + } + count := len(value) / 4 + C.gl3_2core_glUniform4iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform3iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3iv") + } + count := len(value) / 3 + C.gl3_2core_glUniform3iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform2iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2iv") + } + count := len(value) / 2 + C.gl3_2core_glUniform2iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform1iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl3_2core_glUniform1iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4fv") + } + count := len(value) / 4 + C.gl3_2core_glUniform4fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3fv") + } + count := len(value) / 3 + C.gl3_2core_glUniform3fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2fv") + } + count := len(value) / 2 + C.gl3_2core_glUniform2fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform1fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl3_2core_glUniform1fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform4i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4i(location glbase.Uniform, v0, v1, v2, v3 int32) { + C.gl3_2core_glUniform4i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2), C.GLint(v3)) +} + +// Uniform3i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3i(location glbase.Uniform, v0, v1, v2 int32) { + C.gl3_2core_glUniform3i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2)) +} + +// Uniform2i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2i(location glbase.Uniform, v0, v1 int32) { + C.gl3_2core_glUniform2i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1)) +} + +// Uniform1i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1i(location glbase.Uniform, v0 int32) { + C.gl3_2core_glUniform1i(gl.funcs, C.GLint(location), C.GLint(v0)) +} + +// Uniform4f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4f(location glbase.Uniform, v0, v1, v2, v3 float32) { + C.gl3_2core_glUniform4f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2), C.GLfloat(v3)) +} + +// Uniform3f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3f(location glbase.Uniform, v0, v1, v2 float32) { + C.gl3_2core_glUniform3f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2)) +} + +// Uniform2f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2f(location glbase.Uniform, v0, v1 float32) { + C.gl3_2core_glUniform2f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1)) +} + +// Uniform1f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1f(location glbase.Uniform, v0 float32) { + C.gl3_2core_glUniform1f(gl.funcs, C.GLint(location), C.GLfloat(v0)) +} + +// UseProgram installs the program object specified by program as part of +// current rendering state. One or more executables are created in a program +// object by successfully attaching shader objects to it with AttachShader, +// successfully compiling the shader objects with CompileShader, and +// successfully linking the program object with LinkProgram. +// +// A program object will contain an executable that will run on the vertex +// processor if it contains one or more shader objects of type +// GL.VERTEX_SHADER that have been successfully compiled and linked. +// Similarly, a program object will contain an executable that will run on +// the fragment processor if it contains one or more shader objects of type +// GL.FRAGMENT_SHADER that have been successfully compiled and linked. +// +// Successfully installing an executable on a programmable processor will +// cause the corresponding fixed functionality of OpenGL to be disabled. +// Specifically, if an executable is installed on the vertex processor, the +// OpenGL fixed functionality will be disabled as follows. +// +// - The modelview matrix is not applied to vertex coordinates. +// +// - The projection matrix is not applied to vertex coordinates. +// +// - The texture matrices are not applied to texture coordinates. +// +// - Normals are not transformed to eye coordinates. +// +// - Normals are not rescaled or normalized. +// +// - Normalization of GL.AUTO_NORMAL evaluated normals is not performed. +// +// - Texture coordinates are not generated automatically. +// +// - Per-vertex lighting is not performed. +// +// - Color material computations are not performed. +// +// - Color index lighting is not performed. +// +// - This list also applies when setting the current raster position. +// +// The executable that is installed on the vertex processor is expected to +// implement any or all of the desired functionality from the preceding list. +// Similarly, if an executable is installed on the fragment processor, the +// OpenGL fixed functionality will be disabled as follows. +// +// - Texture environment and texture functions are not applied. +// +// - Texture application is not applied. +// +// - Color sum is not applied. +// +// - Fog is not applied. +// +// Again, the fragment shader that is installed is expected to implement any +// or all of the desired functionality from the preceding list. +// +// While a program object is in use, applications are free to modify attached +// shader objects, compile attached shader objects, attach additional shader +// objects, and detach or delete shader objects. None of these operations +// will affect the executables that are part of the current state. However, +// relinking the program object that is currently in use will install the +// program object as part of the current rendering state if the link +// operation was successful (see LinkProgram). If the program object +// currently in use is relinked unsuccessfully, its link status will be set +// to GL.FALSE, but the executables and associated state will remain part of +// the current state until a subsequent call to UseProgram removes it from +// use. After it is removed from use, it cannot be made part of current state +// until it has been successfully relinked. +// +// If program contains shader objects of type GL.VERTEX_SHADER but it does +// not contain shader objects of type GL.FRAGMENT_SHADER, an executable will +// be installed on the vertex processor, but fixed functionality will be used +// for fragment processing. Similarly, if program contains shader objects of +// type GL.FRAGMENT_SHADER but it does not contain shader objects of type +// GL.VERTEX_SHADER, an executable will be installed on the fragment +// processor, but fixed functionality will be used for vertex processing. If +// program is 0, the programmable processors will be disabled, and fixed +// functionality will be used for both vertex and fragment processing. +// +// While a program object is in use, the state that controls the disabled +// fixed functionality may also be updated using the normal OpenGL calls. +// +// Like display lists and texture objects, the name space for program objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// Applications are responsible for providing the synchronization across API +// calls when objects are accessed from different execution threads. +// +// Error GL.INVALID_VALUE is generated if program is neither 0 nor a value +// generated by OpenGL. GL.INVALID_OPERATION is generated if program is not +// a program object. GL.INVALID_OPERATION is generated if program could not +// be made part of current state. GL.INVALID_OPERATION is generated if +// UseProgram is executed between the execution of Begin and the +// corresponding execution of End. +// +// UseProgram is available in GL version 2.0 or greater. +func (gl *GL) UseProgram(program glbase.Program) { + C.gl3_2core_glUseProgram(gl.funcs, C.GLuint(program)) +} + +// ShaderSource sets the source code in shader to the provided source code. Any source +// code previously stored in the shader object is completely replaced. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_VALUE is generated if count is less than 0. +// GL.INVALID_OPERATION is generated if ShaderSource is executed between the +// execution of Begin and the corresponding execution of End. +// +// ShaderSource is available in GL version 2.0 or greater. +func (gl *GL) ShaderSource(shader glbase.Shader, source ...string) { + count := len(source) + length := make([]int32, count) + source_c := make([]unsafe.Pointer, count) + for i, src := range source { + length[i] = int32(len(src)) + if len(src) > 0 { + source_c[i] = *(*unsafe.Pointer)(unsafe.Pointer(&src)) + } else { + source_c[i] = unsafe.Pointer(uintptr(0)) + } + } + C.gl3_2core_glShaderSource(gl.funcs, C.GLuint(shader), C.GLsizei(count), (**C.GLchar)(unsafe.Pointer(&source_c[0])), (*C.GLint)(unsafe.Pointer(&length[0]))) +} + +// LinkProgram links the program object specified by program. If any shader +// objects of type GL.VERTEX_SHADER are attached to program, they will be +// used to create an executable that will run on the programmable vertex +// processor. If any shader objects of type GL.FRAGMENT_SHADER are attached +// to program, they will be used to create an executable that will run on the +// programmable fragment processor. +// +// The status of the link operation will be stored as part of the program +// object's state. This value will be set to GL.TRUE if the program object +// was linked without errors and is ready for use, and GL.FALSE otherwise. It +// can be queried by calling GetProgramiv with arguments program and +// GL.LINK_STATUS. +// +// As a result of a successful link operation, all active user-defined +// uniform variables belonging to program will be initialized to 0, and each +// of the program object's active uniform variables will be assigned a +// location that can be queried by calling GetUniformLocation. Also, any +// active user-defined attribute variables that have not been bound to a +// generic vertex attribute index will be bound to one at this time. +// +// Linking of a program object can fail for a number of reasons as specified +// in the OpenGL Shading Language Specification. The following lists some of +// the conditions that will cause a link error. +// +// - The number of active attribute variables supported by the +// implementation has been exceeded. +// +// - The storage limit for uniform variables has been exceeded. +// +// - The number of active uniform variables supported by the implementation +// has been exceeded. +// +// - The main function is missing for the vertex shader or the fragment +// shader. +// +// - A varying variable actually used in the fragment shader is not +// declared in the same way (or is not declared at all) in the vertex +// shader. +// +// - A reference to a function or variable name is unresolved. +// +// - A shared global is declared with two different types or two different +// initial values. +// +// - One or more of the attached shader objects has not been successfully +// compiled. +// +// - Binding a generic attribute matrix caused some rows of the matrix to +// fall outside the allowed maximum of GL.MAX_VERTEX_ATTRIBS. +// +// - Not enough contiguous vertex attribute slots could be found to bind +// attribute matrices. +// +// When a program object has been successfully linked, the program object can +// be made part of current state by calling UseProgram. Whether or not the +// link operation was successful, the program object's information log will +// be overwritten. The information log can be retrieved by calling +// GetProgramInfoLog. +// +// LinkProgram will also install the generated executables as part of the +// current rendering state if the link operation was successful and the +// specified program object is already currently in use as a result of a +// previous call to UseProgram. If the program object currently in use is +// relinked unsuccessfully, its link status will be set to GL.FALSE , but the +// executables and associated state will remain part of the current state +// until a subsequent call to UseProgram removes it from use. After it is +// removed from use, it cannot be made part of current state until it has +// been successfully relinked. +// +// If program contains shader objects of type GL.VERTEX_SHADER but does not +// contain shader objects of type GL.FRAGMENT_SHADER, the vertex shader will +// be linked against the implicit interface for fixed functionality fragment +// processing. Similarly, if program contains shader objects of type +// GL.FRAGMENT_SHADER but it does not contain shader objects of type +// GL.VERTEX_SHADER, the fragment shader will be linked against the implicit +// interface for fixed functionality vertex processing. +// +// The program object's information log is updated and the program is +// generated at the time of the link operation. After the link operation, +// applications are free to modify attached shader objects, compile attached +// shader objects, detach shader objects, delete shader objects, and attach +// additional shader objects. None of these operations affects the +// information log or the program that is part of the program object. +// +// If the link operation is unsuccessful, any information about a previous +// link operation on program is lost (a failed link does not restore the +// old state of program). Certain information can still be retrieved +// from program even after an unsuccessful link operation. See for instance +// GetActiveAttrib and GetActiveUniform. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if LinkProgram is executed +// between the execution of Begin and the corresponding execution of End. +// +// LinkProgram is available in GL version 2.0 or greater. +func (gl *GL) LinkProgram(program glbase.Program) { + C.gl3_2core_glLinkProgram(gl.funcs, C.GLuint(program)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsShader.xml +func (gl *GL) IsShader(shader glbase.Shader) bool { + glresult := C.gl3_2core_glIsShader(gl.funcs, C.GLuint(shader)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsProgram.xml +func (gl *GL) IsProgram(program glbase.Program) bool { + glresult := C.gl3_2core_glIsProgram(gl.funcs, C.GLuint(program)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GetVertexAttribiv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribiv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribiv(index glbase.Attrib, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl3_2core_glGetVertexAttribiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetVertexAttribfv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribfv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribfv(index glbase.Attrib, pname glbase.Enum, params []float32) { + var params_c [4]float32 + C.gl3_2core_glGetVertexAttribfv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetVertexAttribdv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribdv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribdv(index glbase.Attrib, pname glbase.Enum, params []float64) { + var params_c [4]float64 + C.gl3_2core_glGetVertexAttribdv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformiv returns in params the value of the specified uniform +// variable. The type of the uniform variable specified by location +// determines the number of values returned. If the uniform variable is +// defined in the shader as a boolean, int, or float, a single value will be +// returned. If it is defined as a vec2, ivec2, or bvec2, two values will be +// returned. If it is defined as a vec3, ivec3, or bvec3, three values will +// be returned, and so on. To query values stored in uniform variables +// declared as arrays, call GetUniformiv for each element of the array. To +// query values stored in uniform variables declared as structures, call +// GetUniformiv for each field in the structure. The values for uniform +// variables declared as a matrix will be returned in column major order. +// +// The locations assigned to uniform variables are not known until the +// program object is linked. After linking has occurred, the command +// GetUniformLocation can be used to obtain the location of a uniform +// variable. This location value can then be passed to GetUniformiv in order +// to query the current value of the uniform variable. After a program object +// has been linked successfully, the index values for uniform variables +// remain fixed until the next link command occurs. The uniform variable +// values can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if program has not been +// successfully linked. GL.INVALID_OPERATION is generated if location does +// not correspond to a valid uniform variable location for the specified +// program object. GL.INVALID_OPERATION is generated if GetUniformiv is +// executed between the execution of Begin and the corresponding execution of +// End. +// +// GetUniformiv is available in GL version 2.0 or greater. +func (gl *GL) GetUniformiv(program glbase.Program, location glbase.Uniform, params []int32) { + var params_c [4]int32 + C.gl3_2core_glGetUniformiv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformfv returns in params the value of the specified uniform +// variable. The type of the uniform variable specified by location +// determines the number of values returned. If the uniform variable is +// defined in the shader as a boolean, int, or float, a single value will be +// returned. If it is defined as a vec2, ivec2, or bvec2, two values will be +// returned. If it is defined as a vec3, ivec3, or bvec3, three values will +// be returned, and so on. To query values stored in uniform variables +// declared as arrays, call GetUniformfv for each element of the array. To +// query values stored in uniform variables declared as structures, call +// GetUniformfv for each field in the structure. The values for uniform +// variables declared as a matrix will be returned in column major order. +// +// The locations assigned to uniform variables are not known until the +// program object is linked. After linking has occurred, the command +// GetUniformLocation can be used to obtain the location of a uniform +// variable. This location value can then be passed to GetUniformfv in order +// to query the current value of the uniform variable. After a program object +// has been linked successfully, the index values for uniform variables +// remain fixed until the next link command occurs. The uniform variable +// values can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if program has not been +// successfully linked. GL.INVALID_OPERATION is generated if location does +// not correspond to a valid uniform variable location for the specified +// program object. GL.INVALID_OPERATION is generated if GetUniformfv is +// executed between the execution of Begin and the corresponding execution of +// End. +// +// GetUniformfv is available in GL version 2.0 or greater. +func (gl *GL) GetUniformfv(program glbase.Program, location glbase.Uniform, params []float32) { + var params_c [4]float32 + C.gl3_2core_glGetUniformfv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLfloat)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformLocation returns an integer that represents the location of a +// specific uniform variable within a program object. name must be an active +// uniform variable name in program that is not a structure, an array of +// structures, or a subcomponent of a vector or a matrix. This function +// returns -1 if name does not correspond to an active uniform variable in +// program or if name starts with the reserved prefix "gl_". +// +// Uniform variables that are structures or arrays of structures may be +// queried by calling GetUniformLocation for each field within the +// structure. The array element operator "[]" and the structure field +// operator "." may be used in name in order to select elements within an +// array or fields within a structure. The result of using these operators is +// not allowed to be another structure, an array of structures, or a +// subcomponent of a vector or a matrix. Except if the last part of name +// indicates a uniform variable array, the location of the first element of +// an array can be retrieved by using the name of the array, or by using the +// name appended by "[0]". +// +// The actual locations assigned to uniform variables are not known until the +// program object is linked successfully. After linking has occurred, the +// command GetUniformLocation can be used to obtain the location of a +// uniform variable. This location value can then be passed to Uniform to +// set the value of the uniform variable or to GetUniform in order to query +// the current value of the uniform variable. After a program object has been +// linked successfully, the index values for uniform variables remain fixed +// until the next link command occurs. Uniform variable locations and values +// can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program object. +// GL.INVALID_OPERATION is generated if program has not been successfully +// linked. GL.INVALID_OPERATION is generated if GetUniformLocation is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetUniformLocation is available in GL version 2.0 or greater. +func (gl *GL) GetUniformLocation(program glbase.Program, name string) glbase.Uniform { + name_cstr := C.CString(name) + glresult := C.gl3_2core_glGetUniformLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) + return glbase.Uniform(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetShaderSource.xml +func (gl *GL) GetShaderSource(shader glbase.Shader, bufSize int32, length []int32, source []byte) { + C.gl3_2core_glGetShaderSource(gl.funcs, C.GLuint(shader), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&source[0]))) +} + +// GetShaderInfoLog returns the information log for the specified shader +// object. The information log for a shader object is modified when the +// shader is compiled. +// +// The information log for a shader object is a string that may contain +// diagnostic messages, warning messages, and other information about the +// last compile operation. When a shader object is created, its information +// log will be a string of length 0, and the size of the current log can be +// obtained by calling GetShaderiv with the value GL.INFO_LOG_LENGTH. +// +// The information log for a shader object is the OpenGL implementer's +// primary mechanism for conveying information about the compilation process. +// Therefore, the information log can be helpful to application developers +// during the development process, even when compilation is successful. +// Application developers should not expect different OpenGL implementations +// to produce identical information logs. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_VALUE is generated if maxLength is less than 0. +// GL.INVALID_OPERATION is generated if GetShaderInfoLog is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetShaderInfoLog is available in GL version 2.0 or greater. +func (gl *GL) GetShaderInfoLog(shader glbase.Shader) []byte { + var params [1]int32 + var length int32 + gl.GetShaderiv(shader, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + C.gl3_2core_glGetShaderInfoLog(gl.funcs, C.GLuint(shader), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length)), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) + return infoLog +} + +// GetShaderiv GetShader returns in params the value of a parameter for a specific +// shader object. The following parameters are defined: +// +// GL.SHADER_TYPE +// params returns GL.VERTEX_SHADER if shader is a vertex shader object, +// and GL.FRAGMENT_SHADER if shader is a fragment shader object. +// +// GL.DELETE_STATUS +// params returns GL.TRUE if shader is currently flagged for deletion, +// and GL.FALSE otherwise. +// +// GL.COMPILE_STATUS +// params returns GL.TRUE if the last compile operation on shader was +// successful, and GL.FALSE otherwise. +// +// GL.INFO_LOG_LENGTH +// params returns the number of characters in the information log for +// shader including the null termination character (the size of the +// character buffer required to store the information log). If shader has +// no information log, a value of 0 is returned. +// +// GL.SHADER_SOURCE_LENGTH +// params returns the length of the concatenation of the source strings +// that make up the shader source for the shader, including the null +// termination character. (the size of the character buffer +// required to store the shader source). If no source code exists, 0 is +// returned. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader does not refer to a +// shader object. GL.INVALID_ENUM is generated if pname is not an accepted +// value. GL.INVALID_OPERATION is generated if GetShader is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetShaderiv is available in GL version 2.0 or greater. +func (gl *GL) GetShaderiv(shader glbase.Shader, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl3_2core_glGetShaderiv(gl.funcs, C.GLuint(shader), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetProgramInfoLog returns the information log for the specified program +// object. The information log for a program object is modified when the +// program object is linked or validated. +// +// The information log for a program object is either an empty string, or a +// string containing information about the last link operation, or a string +// containing information about the last validation operation. It may contain +// diagnostic messages, warning messages, and other information. When a +// program object is created, its information log will be a string of length +// 0, and the size of the current log can be obtained by calling GetProgramiv +// with the value GL.INFO_LOG_LENGTH. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated +// by OpenGL. GL.INVALID_OPERATION is generated if program is not a +// program object. +func (gl *GL) GetProgramInfoLog(program glbase.Program) []byte { + var params [1]int32 + var length int32 + gl.GetProgramiv(program, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + C.gl3_2core_glGetProgramInfoLog(gl.funcs, C.GLuint(program), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length)), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) + return infoLog +} + +// GetProgramiv returns in params the value of a parameter for a specific +// program object. The following parameters are defined: +// +// GL.DELETE_STATUS +// params returns GL.TRUE if program is currently flagged for deletion, +// and GL.FALSE otherwise. +// +// GL.LINK_STATUS +// params returns GL.TRUE if the last link operation on program was +// successful, and GL.FALSE otherwise. +// +// GL.VALIDATE_STATUS +// params returns GL.TRUE or if the last validation operation on +// program was successful, and GL.FALSE otherwise. +// +// GL.INFO_LOG_LENGTH +// params returns the number of characters in the information log for +// program including the null termination character (the size of +// the character buffer required to store the information log). If +// program has no information log, a value of 0 is returned. +// +// GL.ATTACHED_SHADERS +// params returns the number of shader objects attached to program. +// +// GL.ACTIVE_ATTRIBUTES +// params returns the number of active attribute variables for program. +// +// GL.ACTIVE_ATTRIBUTE_MAX_LENGTH +// params returns the length of the longest active attribute name for +// program, including the null termination character (the size of +// the character buffer required to store the longest attribute name). +// If no active attributes exist, 0 is returned. +// +// GL.ACTIVE_UNIFORMS +// params returns the number of active uniform variables for program. +// +// GL.ACTIVE_UNIFORM_MAX_LENGTH +// params returns the length of the longest active uniform variable +// name for program, including the null termination character (i.e., +// the size of the character buffer required to store the longest +// uniform variable name). If no active uniform variables exist, 0 is +// returned. +// +// GL.TRANSFORM_FEEDBACK_BUFFER_MODE +// params returns a symbolic constant indicating the buffer mode used +// when transform feedback is active. This may be GL.SEPARATE_ATTRIBS +// or GL.INTERLEAVED_ATTRIBS. +// +// GL.TRANSFORM_FEEDBACK_VARYINGS +// params returns the number of varying variables to capture in transform +// feedback mode for the program. +// +// GL.TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH +// params returns the length of the longest variable name to be used for +// transform feedback, including the null-terminator. +// +// GL.GEOMETRY_VERTICES_OUT +// params returns the maximum number of vertices that the geometry shader in +// program will output. +// +// GL.GEOMETRY_INPUT_TYPE +// params returns a symbolic constant indicating the primitive type accepted +// as input to the geometry shader contained in program. +// +// GL.GEOMETRY_OUTPUT_TYPE +// params returns a symbolic constant indicating the primitive type that will +// be output by the geometry shader contained in program. +// +// GL.ACTIVE_UNIFORM_BLOCKS and GL.ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH are +// available only if the GL version 3.1 or greater. +// +// GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE and +// GL.GEOMETRY_OUTPUT_TYPE are accepted only if the GL version is 3.2 or +// greater. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program does not refer to a +// program object. GL.INVALID_OPERATION is generated if pname is +// GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE, or +// GL.GEOMETRY_OUTPUT_TYPE, and program does not contain a geometry shader. +// GL.INVALID_ENUM is generated if pname is not an accepted value. +func (gl *GL) GetProgramiv(program glbase.Program, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl3_2core_glGetProgramiv(gl.funcs, C.GLuint(program), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetAttribLocation queries the previously linked program object specified +// by program for the attribute variable specified by name and returns the +// index of the generic vertex attribute that is bound to that attribute +// variable. If name is a matrix attribute variable, the index of the first +// column of the matrix is returned. If the named attribute variable is not +// an active attribute in the specified program object or if name starts with +// the reserved prefix "gl_", a value of -1 is returned. +// +// The association between an attribute variable name and a generic attribute +// index can be specified at any time by calling BindAttribLocation. +// Attribute bindings do not go into effect until LinkProgram is called. +// After a program object has been linked successfully, the index values for +// attribute variables remain fixed until the next link command occurs. The +// attribute values can only be queried after a link if the link was +// successful. GetAttribLocation returns the binding that actually went +// into effect the last time LinkProgram was called for the specified +// program object. Attribute bindings that have been specified since the last +// link operation are not returned by GetAttribLocation. +// +// Error GL_INVALID_OPERATION is generated if program is not a value +// generated by OpenGL. GL_INVALID_OPERATION is generated if program is not +// a program object. GL_INVALID_OPERATION is generated if program has not +// been successfully linked. GL_INVALID_OPERATION is generated if +// GetAttribLocation is executed between the execution of Begin and the +// corresponding execution of End. +// +// GetAttribLocation is available in GL version 2.0 or greater. +func (gl *GL) GetAttribLocation(program glbase.Program, name string) glbase.Attrib { + name_cstr := C.CString(name) + glresult := C.gl3_2core_glGetAttribLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) + return glbase.Attrib(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetAttachedShaders.xml +func (gl *GL) GetAttachedShaders(program glbase.Program, maxCount int32, count []int, obj []uint32) { + C.gl3_2core_glGetAttachedShaders(gl.funcs, C.GLuint(program), C.GLsizei(maxCount), (*C.GLsizei)(unsafe.Pointer(&count[0])), (*C.GLuint)(unsafe.Pointer(&obj[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetActiveUniform.xml +func (gl *GL) GetActiveUniform(program glbase.Program, index uint32, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl3_2core_glGetActiveUniform(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetActiveAttrib.xml +func (gl *GL) GetActiveAttrib(program glbase.Program, index glbase.Attrib, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl3_2core_glGetActiveAttrib(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEnableVertexAttribArray.xml +func (gl *GL) EnableVertexAttribArray(index glbase.Attrib) { + C.gl3_2core_glEnableVertexAttribArray(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDisableVertexAttribArray.xml +func (gl *GL) DisableVertexAttribArray(index glbase.Attrib) { + C.gl3_2core_glDisableVertexAttribArray(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDetachShader.xml +func (gl *GL) DetachShader(program glbase.Program, shader glbase.Shader) { + C.gl3_2core_glDetachShader(gl.funcs, C.GLuint(program), C.GLuint(shader)) +} + +// DeleteShader frees the memory and invalidates the name associated with +// the shader object specified by shader. This command effectively undoes the +// effects of a call to CreateShader. +// +// If a shader object to be deleted is attached to a program object, it will +// be flagged for deletion, but it will not be deleted until it is no longer +// attached to any program object, for any rendering context (it must +// be detached from wherever it was attached before it will be deleted). A +// value of 0 for shader will be silently ignored. +// +// To determine whether an object has been flagged for deletion, call +// GetShader with arguments shader and GL.DELETE_STATUS. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. +// +// DeleteShader is available in GL version 2.0 or greater. +func (gl *GL) DeleteShader(shader glbase.Shader) { + C.gl3_2core_glDeleteShader(gl.funcs, C.GLuint(shader)) +} + +// DeleteProgram frees the memory and invalidates the name associated with +// the program object specified by program. This command effectively undoes +// the effects of a call to CreateProgram. +// +// If a program object is in use as part of current rendering state, it will +// be flagged for deletion, but it will not be deleted until it is no longer +// part of current state for any rendering context. If a program object to be +// deleted has shader objects attached to it, those shader objects will be +// automatically detached but not deleted unless they have already been +// flagged for deletion by a previous call to DeleteShader. A value of 0 +// for program will be silently ignored. +// +// To determine whether a program object has been flagged for deletion, call +// GetProgram with arguments program and GL.DELETE_STATUS. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. +// +// DeleteProgram is available in GL version 2.0 or greater. +func (gl *GL) DeleteProgram(program glbase.Program) { + C.gl3_2core_glDeleteProgram(gl.funcs, C.GLuint(program)) +} + +// CreateShader creates an empty shader object and returns a non-zero value +// by which it can be referenced. A shader object is used to maintain the +// source code strings that define a shader. shaderType indicates the type of +// shader to be created. +// +// Two types of shaders are supported. A shader of type GL.VERTEX_SHADER is a +// shader that is intended to run on the programmable vertex processor and +// replace the fixed functionality vertex processing in OpenGL. A shader of +// type GL.FRAGMENT_SHADER is a shader that is intended to run on the +// programmable fragment processor and replace the fixed functionality +// fragment processing in OpenGL. +// +// When created, a shader object's GL.SHADER_TYPE parameter is set to either +// GL.VERTEX_SHADER or GL.FRAGMENT_SHADER, depending on the value of +// shaderType. +// +// Like display lists and texture objects, the name space for shader objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// This function returns 0 if an error occurs creating the shader object. +// +// Error GL.INVALID_ENUM is generated if shaderType is not an accepted value. +// GL.INVALID_OPERATION is generated if CreateShader is executed between the +// execution of Begin and the corresponding execution of End. +// +// CreateShader is available in GL version 2.0 or greater. +func (gl *GL) CreateShader(gltype glbase.Enum) glbase.Shader { + glresult := C.gl3_2core_glCreateShader(gl.funcs, C.GLenum(gltype)) + return glbase.Shader(glresult) +} + +// CreateProgram creates an empty program object and returns a non-zero +// value by which it can be referenced. A program object is an object to +// which shader objects can be attached. This provides a mechanism to specify +// the shader objects that will be linked to create a program. It also +// provides a means for checking the compatibility of the shaders that will +// be used to create a program (for instance, checking the compatibility +// between a vertex shader and a fragment shader). When no longer needed as +// part of a program object, shader objects can be detached. +// +// One or more executables are created in a program object by successfully +// attaching shader objects to it with AttachShader, successfully compiling +// the shader objects with CompileShader, and successfully linking the +// program object with LinkProgram. These executables are made part of +// current state when UseProgram is called. Program objects can be deleted +// by calling DeleteProgram. The memory associated with the program object +// will be deleted when it is no longer part of current rendering state for +// any context. +// +// Like display lists and texture objects, the name space for program objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// Applications are responsible for providing the synchronization across API +// calls when objects are accessed from different execution threads. +// +// This function returns 0 if an error occurs creating the program object. +// +// Error GL.INVALID_OPERATION is generated if CreateProgram is executed +// between the execution of Begin and the corresponding execution of End. +// +// CreateProgram is available in GL version 2.0 or greater. +func (gl *GL) CreateProgram() glbase.Program { + glresult := C.gl3_2core_glCreateProgram(gl.funcs) + return glbase.Program(glresult) +} + +// CompileShader compiles the source code strings that have been stored in +// the shader object specified by shader. +// +// The compilation status will be stored as part of the shader object's +// state. This value will be set to GL.TRUE if the shader was compiled without +// errors and is ready for use, and GL.FALSE otherwise. It can be queried by +// calling GetShaderiv with arguments shader and GL.COMPILE_STATUS. +// +// Compilation of a shader can fail for a number of reasons as specified by +// the OpenGL Shading Language Specification. Whether or not the compilation +// was successful, information about the compilation can be obtained from the +// shader object's information log by calling GetShaderInfoLog. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_OPERATION is generated if CompileShader is executed +// between the execution of Begin and the corresponding execution of End. +// +// CompileShader is available in GL version 2.0 or greater. +func (gl *GL) CompileShader(shader glbase.Shader) { + C.gl3_2core_glCompileShader(gl.funcs, C.GLuint(shader)) +} + +// BindAttribLocation associates a user-defined attribute variable in the program +// object specified by program with a generic vertex attribute index. The name +// parameter specifies the name of the vertex shader attribute variable to +// which index is to be bound. When program is made part of the current state, +// values provided via the generic vertex attribute index will modify the +// value of the user-defined attribute variable specified by name. +// +// If name refers to a matrix attribute variable, index refers to the first +// column of the matrix. Other matrix columns are then automatically bound to +// locations index+1 for a matrix of type mat2; index+1 and index+2 for a +// matrix of type mat3; and index+1, index+2, and index+3 for a matrix of +// type mat4. +// +// This command makes it possible for vertex shaders to use descriptive names +// for attribute variables rather than generic variables that are numbered +// from 0 to GL.MAX_VERTEX_ATTRIBS-1. The values sent to each generic +// attribute index are part of current state, just like standard vertex +// attributes such as color, normal, and vertex position. If a different +// program object is made current by calling UseProgram, the generic vertex +// attributes are tracked in such a way that the same values will be observed +// by attributes in the new program object that are also bound to index. +// +// Attribute variable name-to-generic attribute index bindings for a program +// object can be explicitly assigned at any time by calling +// BindAttribLocation. Attribute bindings do not go into effect until +// LinkProgram is called. After a program object has been linked +// successfully, the index values for generic attributes remain fixed (and +// their values can be queried) until the next link command occurs. +// +// Applications are not allowed to bind any of the standard OpenGL vertex +// attributes using this command, as they are bound automatically when +// needed. Any attribute binding that occurs after the program object has +// been linked will not take effect until the next time the program object is +// linked. +// +// If name was bound previously, that information is lost. Thus you cannot +// bind one user-defined attribute variable to multiple indices, but you can +// bind multiple user-defined attribute variables to the same index. +// +// Applications are allowed to bind more than one user-defined attribute +// variable to the same generic vertex attribute index. This is called +// aliasing, and it is allowed only if just one of the aliased attributes is +// active in the executable program, or if no path through the shader +// consumes more than one attribute of a set of attributes aliased to the +// same location. The compiler and linker are allowed to assume that no +// aliasing is done and are free to employ optimizations that work only in +// the absence of aliasing. OpenGL implementations are not required to do +// error checking to detect aliasing. Because there is no way to bind +// standard attributes, it is not possible to alias generic attributes with +// conventional ones (except for generic attribute 0). +// +// BindAttribLocation can be called before any vertex shader objects are +// bound to the specified program object. It is also permissible to bind a +// generic attribute index to an attribute variable name that is never used +// in a vertex shader. +// +// Active attributes that are not explicitly bound will be bound by the +// linker when LinkProgram is called. The locations assigned can be queried +// by calling GetAttribLocation. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. +// GL.INVALID_OPERATION is generated if name starts with the reserved prefix "gl_". +// GL.INVALID_VALUE is generated if program is not a value generated by OpenGL. +// GL.INVALID_OPERATION is generated if program is not a program object. +// GL.INVALID_OPERATION is generated if BindAttribLocation is executed +// between the execution of Begin and the corresponding execution of End. +// +// BindAttribLocation is available in GL version 2.0 or greater. +func (gl *GL) BindAttribLocation(program glbase.Program, index glbase.Attrib, name string) { + name_cstr := C.CString(name) + C.gl3_2core_glBindAttribLocation(gl.funcs, C.GLuint(program), C.GLuint(index), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) +} + +// AttachShader attaches a shader object to a program object. +// +// In order to create an executable, there must be a way to specify the list +// of things that will be linked together. Program objects provide this +// mechanism. Shaders that are to be linked together in a program object must +// first be attached to that program object. This indicates that shader will +// be included in link operations that will be performed on program. +// +// All operations that can be performed on a shader object are valid whether +// or not the shader object is attached to a program object. It is +// permissible to attach a shader object to a program object before source +// code has been loaded into the shader object or before the shader object +// has been compiled. It is permissible to attach multiple shader objects of +// the same type because each may contain a portion of the complete shader. +// It is also permissible to attach a shader object to more than one program +// object. If a shader object is deleted while it is attached to a program +// object, it will be flagged for deletion, and deletion will not occur until +// DetachShader is called to detach it from all program objects to which it +// is attached. +// +// Error GL.INVALID_VALUE is generated if either program or shader is not a +// value generated by OpenGL. GL.INVALID_OPERATION is generated if program +// is not a program object. GL.INVALID_OPERATION is generated if shader is +// not a shader object. GL.INVALID_OPERATION is generated if shader is +// already attached to program. GL.INVALID_OPERATION is generated if +// AttachShader is executed between the execution of Begin and the +// corresponding execution of End. +// +// AttachShader is available in GL version 2.0 or greater. +func (gl *GL) AttachShader(program glbase.Program, shader glbase.Shader) { + C.gl3_2core_glAttachShader(gl.funcs, C.GLuint(program), C.GLuint(shader)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilMaskSeparate.xml +func (gl *GL) StencilMaskSeparate(face glbase.Enum, mask uint32) { + C.gl3_2core_glStencilMaskSeparate(gl.funcs, C.GLenum(face), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilFuncSeparate.xml +func (gl *GL) StencilFuncSeparate(face, glfunc glbase.Enum, ref int32, mask uint32) { + C.gl3_2core_glStencilFuncSeparate(gl.funcs, C.GLenum(face), C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilOpSeparate.xml +func (gl *GL) StencilOpSeparate(face, sfail, dpfail, dppass glbase.Enum) { + C.gl3_2core_glStencilOpSeparate(gl.funcs, C.GLenum(face), C.GLenum(sfail), C.GLenum(dpfail), C.GLenum(dppass)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawBuffers.xml +func (gl *GL) DrawBuffers(n int, bufs []glbase.Enum) { + C.gl3_2core_glDrawBuffers(gl.funcs, C.GLsizei(n), (*C.GLenum)(unsafe.Pointer(&bufs[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlendEquationSeparate.xml +func (gl *GL) BlendEquationSeparate(modeRGB, modeAlpha glbase.Enum) { + C.gl3_2core_glBlendEquationSeparate(gl.funcs, C.GLenum(modeRGB), C.GLenum(modeAlpha)) +} + +// UniformMatrix4x3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4x3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4x3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*3) != 0 { + panic("invalid value length for UniformMatrix4x3fv") + } + count := len(value) / (4 * 3) + C.gl3_2core_glUniformMatrix4x3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3x4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3x4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3x4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*4) != 0 { + panic("invalid value length for UniformMatrix3x4fv") + } + count := len(value) / (3 * 4) + C.gl3_2core_glUniformMatrix3x4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix4x2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4x2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4x2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*2) != 0 { + panic("invalid value length for UniformMatrix4x2fv") + } + count := len(value) / (4 * 2) + C.gl3_2core_glUniformMatrix4x2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2x4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2x4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2x4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*4) != 0 { + panic("invalid value length for UniformMatrix2x4fv") + } + count := len(value) / (2 * 4) + C.gl3_2core_glUniformMatrix2x4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3x2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3x2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3x2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*2) != 0 { + panic("invalid value length for UniformMatrix3x2fv") + } + count := len(value) / (3 * 2) + C.gl3_2core_glUniformMatrix3x2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2x3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2x3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2x3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*3) != 0 { + panic("invalid value length for UniformMatrix2x3fv") + } + count := len(value) / (2 * 3) + C.gl3_2core_glUniformMatrix2x3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsVertexArray.xml +func (gl *GL) IsVertexArray(array uint32) bool { + glresult := C.gl3_2core_glIsVertexArray(gl.funcs, C.GLuint(array)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGenVertexArrays.xml +func (gl *GL) GenVertexArrays(n int, arrays []uint32) { + C.gl3_2core_glGenVertexArrays(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&arrays[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDeleteVertexArrays.xml +func (gl *GL) DeleteVertexArrays(n int, arrays []uint32) { + C.gl3_2core_glDeleteVertexArrays(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&arrays[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindVertexArray.xml +func (gl *GL) BindVertexArray(array uint32) { + C.gl3_2core_glBindVertexArray(gl.funcs, C.GLuint(array)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFlushMappedBufferRange.xml +func (gl *GL) FlushMappedBufferRange(target glbase.Enum, offset, length int) { + C.gl3_2core_glFlushMappedBufferRange(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(length)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFramebufferTextureLayer.xml +func (gl *GL) FramebufferTextureLayer(target, attachment glbase.Enum, texture glbase.Texture, level int, layer int32) { + C.gl3_2core_glFramebufferTextureLayer(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLuint(texture), C.GLint(level), C.GLint(layer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRenderbufferStorageMultisample.xml +func (gl *GL) RenderbufferStorageMultisample(target glbase.Enum, samples int32, internalFormat glbase.Enum, width, height int) { + C.gl3_2core_glRenderbufferStorageMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlitFramebuffer.xml +func (gl *GL) BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1 int32, mask glbase.Bitfield, filter glbase.Enum) { + C.gl3_2core_glBlitFramebuffer(gl.funcs, C.GLint(srcX0), C.GLint(srcY0), C.GLint(srcX1), C.GLint(srcY1), C.GLint(dstX0), C.GLint(dstY0), C.GLint(dstX1), C.GLint(dstY1), C.GLbitfield(mask), C.GLenum(filter)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGenerateMipmap.xml +func (gl *GL) GenerateMipmap(target glbase.Enum) { + C.gl3_2core_glGenerateMipmap(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetFramebufferAttachmentParameteriv.xml +func (gl *GL) GetFramebufferAttachmentParameteriv(target, attachment, pname glbase.Enum, params []int32) { + C.gl3_2core_glGetFramebufferAttachmentParameteriv(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFramebufferRenderbuffer.xml +func (gl *GL) FramebufferRenderbuffer(target, attachment, renderbuffertarget glbase.Enum, renderbuffer glbase.Renderbuffer) { + C.gl3_2core_glFramebufferRenderbuffer(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(renderbuffertarget), C.GLuint(renderbuffer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFramebufferTexture3D.xml +func (gl *GL) FramebufferTexture3D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int, zoffset int32) { + C.gl3_2core_glFramebufferTexture3D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level), C.GLint(zoffset)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFramebufferTexture2D.xml +func (gl *GL) FramebufferTexture2D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int) { + C.gl3_2core_glFramebufferTexture2D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFramebufferTexture1D.xml +func (gl *GL) FramebufferTexture1D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int) { + C.gl3_2core_glFramebufferTexture1D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCheckFramebufferStatus.xml +func (gl *GL) CheckFramebufferStatus(target glbase.Enum) glbase.Enum { + glresult := C.gl3_2core_glCheckFramebufferStatus(gl.funcs, C.GLenum(target)) + return glbase.Enum(glresult) +} + +// GenFramebuffers returns n framebuffer object names in ids. There is no +// guarantee that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenFramebuffers. +// +// Framebuffer object names returned by a call to GenFramebuffers are not +// returned by subsequent calls, unless they are first deleted with +// DeleteFramebuffers. +// +// The names returned in ids are marked as used, for the purposes of +// GenFramebuffers only, but they acquire state and type only when they are +// first bound. +// +// Error GL.INVALID_VALUE is generated if n is negative. +func (gl *GL) GenFramebuffers(n int) []glbase.Framebuffer { + if n == 0 { + return nil + } + framebuffers := make([]glbase.Framebuffer, n) + C.gl3_2core_glGenFramebuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&framebuffers[0]))) + return framebuffers +} + +// DeleteFramebuffers deletes the framebuffer objects whose names are +// stored in the framebuffers slice. The name zero is reserved by the GL and +// is silently ignored, should it occur in framebuffers, as are other unused +// names. Once a framebuffer object is deleted, its name is again unused and +// it has no attachments. If a framebuffer that is currently bound to one or +// more of the targets GL.DRAW_FRAMEBUFFER or GL.READ_FRAMEBUFFER is deleted, +// it is as though BindFramebuffer had been executed with the corresponding +// target and framebuffer zero. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteFramebuffers is available in GL version 3.0 or greater. +func (gl *GL) DeleteFramebuffers(framebuffers []glbase.Framebuffer) { + n := len(framebuffers) + if n == 0 { + return + } + C.gl3_2core_glDeleteFramebuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&framebuffers[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindFramebuffer.xml +func (gl *GL) BindFramebuffer(target glbase.Enum, framebuffer glbase.Framebuffer) { + C.gl3_2core_glBindFramebuffer(gl.funcs, C.GLenum(target), C.GLuint(framebuffer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsFramebuffer.xml +func (gl *GL) IsFramebuffer(framebuffer glbase.Framebuffer) bool { + glresult := C.gl3_2core_glIsFramebuffer(gl.funcs, C.GLuint(framebuffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetRenderbufferParameteriv.xml +func (gl *GL) GetRenderbufferParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_2core_glGetRenderbufferParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRenderbufferStorage.xml +func (gl *GL) RenderbufferStorage(target, internalFormat glbase.Enum, width, height int) { + C.gl3_2core_glRenderbufferStorage(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) +} + +// GenRenderbuffers returns n renderbuffer object names in renderbuffers. +// There is no guarantee that the names form a contiguous set of integers; +// however, it is guaranteed that none of the returned names was in use +// immediately before the call to GenRenderbuffers. +// +// Renderbuffer object names returned by a call to GenRenderbuffers are not +// returned by subsequent calls, unless they are first deleted with +// DeleteRenderbuffers. +// +// The names returned in renderbuffers are marked as used, for the purposes +// of GenRenderbuffers only, but they acquire state and type only when they +// are first bound. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenRenderbuffers is available in GL version 3.0 or greater. +func (gl *GL) GenRenderbuffers(n int) []glbase.Renderbuffer { + if n == 0 { + return nil + } + renderbuffers := make([]glbase.Renderbuffer, n) + C.gl3_2core_glGenRenderbuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&renderbuffers[0]))) + return renderbuffers +} + +// DeleteRenderbuffers deletes the renderbuffer objects whose names are stored +// in the renderbuffers slice. The name zero is reserved by the GL and +// is silently ignored, should it occur in renderbuffers, as are other unused +// names. Once a renderbuffer object is deleted, its name is again unused and +// it has no contents. If a renderbuffer that is currently bound to the +// target GL.RENDERBUFFER is deleted, it is as though BindRenderbuffer had +// been executed with a target of GL.RENDERBUFFER and a name of zero. +// +// If a renderbuffer object is attached to one or more attachment points in +// the currently bound framebuffer, then it as if FramebufferRenderbuffer +// had been called, with a renderbuffer of zero for each attachment point to +// which this image was attached in the currently bound framebuffer. In other +// words, this renderbuffer object is first detached from all attachment +// ponits in the currently bound framebuffer. Note that the renderbuffer +// image is specifically not detached from any non-bound framebuffers. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteRenderbuffers is available in GL version 3.0 or greater. +func (gl *GL) DeleteRenderbuffers(renderbuffers []glbase.Renderbuffer) { + n := len(renderbuffers) + if n == 0 { + return + } + C.gl3_2core_glDeleteRenderbuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&renderbuffers[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindRenderbuffer.xml +func (gl *GL) BindRenderbuffer(target glbase.Enum, renderbuffer glbase.Renderbuffer) { + C.gl3_2core_glBindRenderbuffer(gl.funcs, C.GLenum(target), C.GLuint(renderbuffer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsRenderbuffer.xml +func (gl *GL) IsRenderbuffer(renderbuffer glbase.Renderbuffer) bool { + glresult := C.gl3_2core_glIsRenderbuffer(gl.funcs, C.GLuint(renderbuffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearBufferfi.xml +func (gl *GL) ClearBufferfi(buffer glbase.Enum, drawbuffer int32, depth float32, stencil int32) { + C.gl3_2core_glClearBufferfi(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), C.GLfloat(depth), C.GLint(stencil)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearBufferfv.xml +func (gl *GL) ClearBufferfv(buffer glbase.Enum, drawbuffer int32, value []float32) { + C.gl3_2core_glClearBufferfv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearBufferuiv.xml +func (gl *GL) ClearBufferuiv(buffer glbase.Enum, drawbuffer int32, value []uint32) { + C.gl3_2core_glClearBufferuiv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearBufferiv.xml +func (gl *GL) ClearBufferiv(buffer glbase.Enum, drawbuffer int32, value []int32) { + C.gl3_2core_glClearBufferiv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexParameterIuiv.xml +func (gl *GL) GetTexParameterIuiv(target, pname glbase.Enum, params []uint32) { + C.gl3_2core_glGetTexParameterIuiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexParameterIiv.xml +func (gl *GL) GetTexParameterIiv(target, pname glbase.Enum, params []int32) { + C.gl3_2core_glGetTexParameterIiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameterIuiv.xml +func (gl *GL) TexParameterIuiv(target, pname glbase.Enum, params []uint32) { + C.gl3_2core_glTexParameterIuiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameterIiv.xml +func (gl *GL) TexParameterIiv(target, pname glbase.Enum, params []int32) { + C.gl3_2core_glTexParameterIiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// Uniform4uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4uiv") + } + count := len(value) / 4 + C.gl3_2core_glUniform4uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform3uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3uiv") + } + count := len(value) / 3 + C.gl3_2core_glUniform3uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform2uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2uiv") + } + count := len(value) / 2 + C.gl3_2core_glUniform2uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform1uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl3_2core_glUniform1uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform4ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4ui(location glbase.Uniform, v0, v1, v2, v3 uint32) { + C.gl3_2core_glUniform4ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2), C.GLuint(v3)) +} + +// Uniform3ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3ui(location glbase.Uniform, v0, v1, v2 uint32) { + C.gl3_2core_glUniform3ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2)) +} + +// Uniform2ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2ui(location glbase.Uniform, v0, v1 uint32) { + C.gl3_2core_glUniform2ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1)) +} + +// Uniform1ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1ui(location glbase.Uniform, v0 uint32) { + C.gl3_2core_glUniform1ui(gl.funcs, C.GLint(location), C.GLuint(v0)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetFragDataLocation.xml +func (gl *GL) GetFragDataLocation(program glbase.Program, name []byte) int32 { + glresult := C.gl3_2core_glGetFragDataLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindFragDataLocation.xml +func (gl *GL) BindFragDataLocation(program glbase.Program, color uint32, name []byte) { + C.gl3_2core_glBindFragDataLocation(gl.funcs, C.GLuint(program), C.GLuint(color), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetUniformuiv.xml +func (gl *GL) GetUniformuiv(program glbase.Program, location glbase.Uniform, params []uint32) { + C.gl3_2core_glGetUniformuiv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetVertexAttribIuiv.xml +func (gl *GL) GetVertexAttribIuiv(index glbase.Attrib, pname glbase.Enum, params []uint32) { + C.gl3_2core_glGetVertexAttribIuiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetVertexAttribIiv.xml +func (gl *GL) GetVertexAttribIiv(index glbase.Attrib, pname glbase.Enum, params []int32) { + C.gl3_2core_glGetVertexAttribIiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribIPointer.xml +func (gl *GL) VertexAttribIPointer(index glbase.Attrib, size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl3_2core_glVertexAttribIPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEndConditionalRender.xml +func (gl *GL) EndConditionalRender() { + C.gl3_2core_glEndConditionalRender(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBeginConditionalRender.xml +func (gl *GL) BeginConditionalRender(id uint32, mode glbase.Enum) { + C.gl3_2core_glBeginConditionalRender(gl.funcs, C.GLuint(id), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClampColor.xml +func (gl *GL) ClampColor(target, clamp glbase.Enum) { + C.gl3_2core_glClampColor(gl.funcs, C.GLenum(target), C.GLenum(clamp)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTransformFeedbackVarying.xml +func (gl *GL) GetTransformFeedbackVarying(program glbase.Program, index uint32, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl3_2core_glGetTransformFeedbackVarying(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLsizei)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindBufferBase.xml +func (gl *GL) BindBufferBase(target glbase.Enum, index uint32, buffer glbase.Buffer) { + C.gl3_2core_glBindBufferBase(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindBufferRange.xml +func (gl *GL) BindBufferRange(target glbase.Enum, index uint32, buffer glbase.Buffer, offset, size int) { + C.gl3_2core_glBindBufferRange(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(buffer), C.GLintptr(offset), C.GLsizeiptr(size)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEndTransformFeedback.xml +func (gl *GL) EndTransformFeedback() { + C.gl3_2core_glEndTransformFeedback(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBeginTransformFeedback.xml +func (gl *GL) BeginTransformFeedback(primitiveMode glbase.Enum) { + C.gl3_2core_glBeginTransformFeedback(gl.funcs, C.GLenum(primitiveMode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsEnabledi.xml +func (gl *GL) IsEnabledi(target glbase.Enum, index uint32) bool { + glresult := C.gl3_2core_glIsEnabledi(gl.funcs, C.GLenum(target), C.GLuint(index)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDisablei.xml +func (gl *GL) Disablei(target glbase.Enum, index uint32) { + C.gl3_2core_glDisablei(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEnablei.xml +func (gl *GL) Enablei(target glbase.Enum, index uint32) { + C.gl3_2core_glEnablei(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetIntegeri_v.xml +func (gl *GL) GetIntegeri_v(target glbase.Enum, index uint32, data []int32) { + C.gl3_2core_glGetIntegeri_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLint)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetBooleani_v.xml +func (gl *GL) GetBooleani_v(target glbase.Enum, index uint32, data []bool) { + C.gl3_2core_glGetBooleani_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLboolean)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorMaski.xml +func (gl *GL) ColorMaski(index uint32, r, g, b, a bool) { + C.gl3_2core_glColorMaski(gl.funcs, C.GLuint(index), *(*C.GLboolean)(unsafe.Pointer(&r)), *(*C.GLboolean)(unsafe.Pointer(&g)), *(*C.GLboolean)(unsafe.Pointer(&b)), *(*C.GLboolean)(unsafe.Pointer(&a))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyBufferSubData.xml +func (gl *GL) CopyBufferSubData(readTarget, writeTarget glbase.Enum, readOffset, writeOffset, size int) { + C.gl3_2core_glCopyBufferSubData(gl.funcs, C.GLenum(readTarget), C.GLenum(writeTarget), C.GLintptr(readOffset), C.GLintptr(writeOffset), C.GLsizeiptr(size)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glUniformBlockBinding.xml +func (gl *GL) UniformBlockBinding(program glbase.Program, v0, v1 uint32) { + C.gl3_2core_glUniformBlockBinding(gl.funcs, C.GLuint(program), C.GLuint(v0), C.GLuint(v1)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetActiveUniformBlockName.xml +func (gl *GL) GetActiveUniformBlockName(program glbase.Program, uniformBlockIndex uint32, bufSize int32, length []int32, uniformBlockName []byte) { + C.gl3_2core_glGetActiveUniformBlockName(gl.funcs, C.GLuint(program), C.GLuint(uniformBlockIndex), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&uniformBlockName[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetActiveUniformBlockiv.xml +func (gl *GL) GetActiveUniformBlockiv(program glbase.Program, uniformBlockIndex uint32, pname glbase.Enum, params []int32) { + C.gl3_2core_glGetActiveUniformBlockiv(gl.funcs, C.GLuint(program), C.GLuint(uniformBlockIndex), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetUniformBlockIndex.xml +func (gl *GL) GetUniformBlockIndex(program glbase.Program, uniformBlockName []byte) uint32 { + glresult := C.gl3_2core_glGetUniformBlockIndex(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&uniformBlockName[0]))) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetActiveUniformName.xml +func (gl *GL) GetActiveUniformName(program glbase.Program, uniformIndex uint32, bufSize int32, length []int32, uniformName []byte) { + C.gl3_2core_glGetActiveUniformName(gl.funcs, C.GLuint(program), C.GLuint(uniformIndex), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&uniformName[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetActiveUniformsiv.xml +func (gl *GL) GetActiveUniformsiv(program glbase.Program, uniformCount int32, uniformIndices []uint32, pname glbase.Enum, params []int32) { + C.gl3_2core_glGetActiveUniformsiv(gl.funcs, C.GLuint(program), C.GLsizei(uniformCount), (*C.GLuint)(unsafe.Pointer(&uniformIndices[0])), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPrimitiveRestartIndex.xml +func (gl *GL) PrimitiveRestartIndex(index uint32) { + C.gl3_2core_glPrimitiveRestartIndex(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexBuffer.xml +func (gl *GL) TexBuffer(target, internalFormat glbase.Enum, buffer glbase.Buffer) { + C.gl3_2core_glTexBuffer(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawElementsInstanced.xml +func (gl *GL) DrawElementsInstanced(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, instancecount int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl3_2core_glDrawElementsInstanced(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLsizei(instancecount)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawArraysInstanced.xml +func (gl *GL) DrawArraysInstanced(mode glbase.Enum, first, count int, instancecount int32) { + C.gl3_2core_glDrawArraysInstanced(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count), C.GLsizei(instancecount)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSampleMaski.xml +func (gl *GL) SampleMaski(index uint32, mask glbase.Bitfield) { + C.gl3_2core_glSampleMaski(gl.funcs, C.GLuint(index), C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetMultisamplefv.xml +func (gl *GL) GetMultisamplefv(pname glbase.Enum, index uint32, val []float32) { + C.gl3_2core_glGetMultisamplefv(gl.funcs, C.GLenum(pname), C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&val[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexImage3DMultisample.xml +func (gl *GL) TexImage3DMultisample(target glbase.Enum, samples, internalFormat int32, width, height int, depth int32, fixedsamplelocations bool) { + C.gl3_2core_glTexImage3DMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), *(*C.GLboolean)(unsafe.Pointer(&fixedsamplelocations))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexImage2DMultisample.xml +func (gl *GL) TexImage2DMultisample(target glbase.Enum, samples, internalFormat int32, width, height int, fixedsamplelocations bool) { + C.gl3_2core_glTexImage2DMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), *(*C.GLboolean)(unsafe.Pointer(&fixedsamplelocations))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetSynciv.xml +func (gl *GL) GetSynciv(sync glbase.Sync, pname glbase.Enum, bufSize int32, length, values []int32) { + C.gl3_2core_glGetSynciv(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLenum(pname), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetInteger64v.xml +func (gl *GL) GetInteger64v(pname glbase.Enum, params []int64) { + C.gl3_2core_glGetInteger64v(gl.funcs, C.GLenum(pname), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWaitSync.xml +func (gl *GL) WaitSync(sync glbase.Sync, flags glbase.Bitfield, timeout uint64) { + C.gl3_2core_glWaitSync(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLbitfield(flags), C.GLuint64(timeout)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClientWaitSync.xml +func (gl *GL) ClientWaitSync(sync glbase.Sync, flags glbase.Bitfield, timeout uint64) glbase.Enum { + glresult := C.gl3_2core_glClientWaitSync(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLbitfield(flags), C.GLuint64(timeout)) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDeleteSync.xml +func (gl *GL) DeleteSync(sync glbase.Sync) { + C.gl3_2core_glDeleteSync(gl.funcs, C.GLsync(unsafe.Pointer(sync))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsSync.xml +func (gl *GL) IsSync(sync glbase.Sync) bool { + glresult := C.gl3_2core_glIsSync(gl.funcs, C.GLsync(unsafe.Pointer(sync))) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFenceSync.xml +func (gl *GL) FenceSync(condition glbase.Enum, flags glbase.Bitfield) glbase.Sync { + glresult := C.gl3_2core_glFenceSync(gl.funcs, C.GLenum(condition), C.GLbitfield(flags)) + return glbase.Sync(unsafe.Pointer(glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glProvokingVertex.xml +func (gl *GL) ProvokingVertex(mode glbase.Enum) { + C.gl3_2core_glProvokingVertex(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawElementsInstancedBaseVertex.xml +func (gl *GL) DrawElementsInstancedBaseVertex(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, instancecount, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl3_2core_glDrawElementsInstancedBaseVertex(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLsizei(instancecount), C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawRangeElementsBaseVertex.xml +func (gl *GL) DrawRangeElementsBaseVertex(mode glbase.Enum, start, end uint32, count int, gltype glbase.Enum, indices interface{}, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl3_2core_glDrawRangeElementsBaseVertex(gl.funcs, C.GLenum(mode), C.GLuint(start), C.GLuint(end), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawElementsBaseVertex.xml +func (gl *GL) DrawElementsBaseVertex(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl3_2core_glDrawElementsBaseVertex(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFramebufferTexture.xml +func (gl *GL) FramebufferTexture(target, attachment glbase.Enum, texture glbase.Texture, level int) { + C.gl3_2core_glFramebufferTexture(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetBufferParameteri64v.xml +func (gl *GL) GetBufferParameteri64v(target, pname glbase.Enum, params []int64) { + C.gl3_2core_glGetBufferParameteri64v(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetInteger64i_v.xml +func (gl *GL) GetInteger64i_v(target glbase.Enum, index uint32, data []int64) { + C.gl3_2core_glGetInteger64i_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLint64)(unsafe.Pointer(&data[0]))) +} diff --git a/gl/3.3compat/funcs.cpp b/gl/3.3compat/funcs.cpp new file mode 100644 index 00000000..65c02b7d --- /dev/null +++ b/gl/3.3compat/funcs.cpp @@ -0,0 +1,4488 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#include +#include + +#include "funcs.h" + +void *gl3_3compat_funcs() { + QOpenGLFunctions_3_3_Compatibility* funcs = QOpenGLContext::currentContext()->versionFunctions(); + if (!funcs) { + return 0; + } + funcs->initializeOpenGLFunctions(); + return funcs; +} + + +void gl3_3compat_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewport(x, y, width, height); +} + +void gl3_3compat_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRange(nearVal, farVal); +} + +GLboolean gl3_3compat_glIsEnabled(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabled(cap); +} + +void gl3_3compat_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameteriv(target, level, pname, params); +} + +void gl3_3compat_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameterfv(target, level, pname, params); +} + +void gl3_3compat_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameteriv(target, pname, params); +} + +void gl3_3compat_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterfv(target, pname, params); +} + +void gl3_3compat_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexImage(target, level, format, gltype, pixels); +} + +void gl3_3compat_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegerv(pname, params); +} + +void gl3_3compat_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFloatv(pname, params); +} + +GLenum gl3_3compat_glGetError(void *_glfuncs) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetError(); +} + +void gl3_3compat_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetDoublev(pname, params); +} + +void gl3_3compat_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleanv(pname, params); +} + +void gl3_3compat_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadPixels(x, y, width, height, format, gltype, pixels); +} + +void gl3_3compat_glReadBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadBuffer(mode); +} + +void gl3_3compat_glPixelStorei(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStorei(pname, param); +} + +void gl3_3compat_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStoref(pname, param); +} + +void gl3_3compat_glDepthFunc(void *_glfuncs, GLenum glfunc) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthFunc(glfunc); +} + +void gl3_3compat_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOp(fail, zfail, zpass); +} + +void gl3_3compat_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFunc(glfunc, ref, mask); +} + +void gl3_3compat_glLogicOp(void *_glfuncs, GLenum opcode) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLogicOp(opcode); +} + +void gl3_3compat_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFunc(sfactor, dfactor); +} + +void gl3_3compat_glFlush(void *_glfuncs) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlush(); +} + +void gl3_3compat_glFinish(void *_glfuncs) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFinish(); +} + +void gl3_3compat_glEnable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnable(cap); +} + +void gl3_3compat_glDisable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisable(cap); +} + +void gl3_3compat_glDepthMask(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthMask(flag); +} + +void gl3_3compat_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMask(red, green, blue, alpha); +} + +void gl3_3compat_glStencilMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMask(mask); +} + +void gl3_3compat_glClearDepth(void *_glfuncs, GLdouble depth) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearDepth(depth); +} + +void gl3_3compat_glClearStencil(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearStencil(s); +} + +void gl3_3compat_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearColor(red, green, blue, alpha); +} + +void gl3_3compat_glClear(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClear(mask); +} + +void gl3_3compat_glDrawBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffer(mode); +} + +void gl3_3compat_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage2D(target, level, internalFormat, width, height, border, format, gltype, pixels); +} + +void gl3_3compat_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage1D(target, level, internalFormat, width, border, format, gltype, pixels); +} + +void gl3_3compat_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteriv(target, pname, params); +} + +void gl3_3compat_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteri(target, pname, param); +} + +void gl3_3compat_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterfv(target, pname, params); +} + +void gl3_3compat_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterf(target, pname, param); +} + +void gl3_3compat_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissor(x, y, width, height); +} + +void gl3_3compat_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonMode(face, mode); +} + +void gl3_3compat_glPointSize(void *_glfuncs, GLfloat size) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointSize(size); +} + +void gl3_3compat_glLineWidth(void *_glfuncs, GLfloat width) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineWidth(width); +} + +void gl3_3compat_glHint(void *_glfuncs, GLenum target, GLenum mode) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glHint(target, mode); +} + +void gl3_3compat_glFrontFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrontFace(mode); +} + +void gl3_3compat_glCullFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCullFace(mode); +} + +void gl3_3compat_glIndexubv(void *_glfuncs, const GLubyte* c) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexubv(c); +} + +void gl3_3compat_glIndexub(void *_glfuncs, GLubyte c) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexub(c); +} + +GLboolean gl3_3compat_glIsTexture(void *_glfuncs, GLuint texture) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsTexture(texture); +} + +void gl3_3compat_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenTextures(n, textures); +} + +void gl3_3compat_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteTextures(n, textures); +} + +void gl3_3compat_glBindTexture(void *_glfuncs, GLenum target, GLuint texture) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindTexture(target, texture); +} + +void gl3_3compat_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, gltype, pixels); +} + +void gl3_3compat_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage1D(target, level, xoffset, width, format, gltype, pixels); +} + +void gl3_3compat_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); +} + +void gl3_3compat_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage1D(target, level, xoffset, x, y, width); +} + +void gl3_3compat_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage2D(target, level, internalFormat, x, y, width, height, border); +} + +void gl3_3compat_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage1D(target, level, internalFormat, x, y, width, border); +} + +void gl3_3compat_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonOffset(factor, units); +} + +void gl3_3compat_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElements(mode, count, gltype, indices); +} + +void gl3_3compat_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArrays(mode, first, count); +} + +void gl3_3compat_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); +} + +void gl3_3compat_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, gltype, pixels); +} + +void gl3_3compat_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage3D(target, level, internalFormat, width, height, depth, border, format, gltype, pixels); +} + +void gl3_3compat_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawRangeElements(mode, start, end, count, gltype, indices); +} + +void gl3_3compat_glBlendEquation(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquation(mode); +} + +void gl3_3compat_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendColor(red, green, blue, alpha); +} + +void gl3_3compat_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetCompressedTexImage(target, level, img); +} + +void gl3_3compat_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data); +} + +void gl3_3compat_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); +} + +void gl3_3compat_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); +} + +void gl3_3compat_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage1D(target, level, internalFormat, width, border, imageSize, data); +} + +void gl3_3compat_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data); +} + +void gl3_3compat_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage3D(target, level, internalFormat, width, height, depth, border, imageSize, data); +} + +void gl3_3compat_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSampleCoverage(value, invert); +} + +void gl3_3compat_glActiveTexture(void *_glfuncs, GLenum texture) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glActiveTexture(texture); +} + +void gl3_3compat_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteriv(pname, params); +} + +void gl3_3compat_glPointParameteri(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteri(pname, param); +} + +void gl3_3compat_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterfv(pname, params); +} + +void gl3_3compat_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterf(pname, param); +} + +void gl3_3compat_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiDrawArrays(mode, first, count, drawcount); +} + +void gl3_3compat_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); +} + +void gl3_3compat_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferParameteriv(target, pname, params); +} + +GLboolean gl3_3compat_glUnmapBuffer(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glUnmapBuffer(target); +} + +void gl3_3compat_glGetBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferSubData(target, offset, size, data); +} + +void gl3_3compat_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferSubData(target, offset, size, data); +} + +void gl3_3compat_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferData(target, size, data, usage); +} + +GLboolean gl3_3compat_glIsBuffer(void *_glfuncs, GLuint buffer) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsBuffer(buffer); +} + +void gl3_3compat_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenBuffers(n, buffers); +} + +void gl3_3compat_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteBuffers(n, buffers); +} + +void gl3_3compat_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBuffer(target, buffer); +} + +void gl3_3compat_glGetQueryObjectuiv(void *_glfuncs, GLuint id, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectuiv(id, pname, params); +} + +void gl3_3compat_glGetQueryObjectiv(void *_glfuncs, GLuint id, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectiv(id, pname, params); +} + +void gl3_3compat_glGetQueryiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryiv(target, pname, params); +} + +void gl3_3compat_glEndQuery(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndQuery(target); +} + +void gl3_3compat_glBeginQuery(void *_glfuncs, GLenum target, GLuint id) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginQuery(target, id); +} + +GLboolean gl3_3compat_glIsQuery(void *_glfuncs, GLuint id) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsQuery(id); +} + +void gl3_3compat_glDeleteQueries(void *_glfuncs, GLsizei n, const GLuint* ids) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteQueries(n, ids); +} + +void gl3_3compat_glGenQueries(void *_glfuncs, GLsizei n, GLuint* ids) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenQueries(n, ids); +} + +void gl3_3compat_glVertexAttribPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLboolean normalized, GLsizei stride, const GLvoid* offset) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribPointer(index, size, gltype, normalized, stride, offset); +} + +void gl3_3compat_glValidateProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glValidateProgram(program); +} + +void gl3_3compat_glUniformMatrix4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4fv(location, count, transpose, value); +} + +void gl3_3compat_glUniformMatrix3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3fv(location, count, transpose, value); +} + +void gl3_3compat_glUniformMatrix2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2fv(location, count, transpose, value); +} + +void gl3_3compat_glUniform4iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4iv(location, count, value); +} + +void gl3_3compat_glUniform3iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3iv(location, count, value); +} + +void gl3_3compat_glUniform2iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2iv(location, count, value); +} + +void gl3_3compat_glUniform1iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1iv(location, count, value); +} + +void gl3_3compat_glUniform4fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4fv(location, count, value); +} + +void gl3_3compat_glUniform3fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3fv(location, count, value); +} + +void gl3_3compat_glUniform2fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2fv(location, count, value); +} + +void gl3_3compat_glUniform1fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1fv(location, count, value); +} + +void gl3_3compat_glUniform4i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4i(location, v0, v1, v2, v3); +} + +void gl3_3compat_glUniform3i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3i(location, v0, v1, v2); +} + +void gl3_3compat_glUniform2i(void *_glfuncs, GLint location, GLint v0, GLint v1) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2i(location, v0, v1); +} + +void gl3_3compat_glUniform1i(void *_glfuncs, GLint location, GLint v0) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1i(location, v0); +} + +void gl3_3compat_glUniform4f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4f(location, v0, v1, v2, v3); +} + +void gl3_3compat_glUniform3f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3f(location, v0, v1, v2); +} + +void gl3_3compat_glUniform2f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2f(location, v0, v1); +} + +void gl3_3compat_glUniform1f(void *_glfuncs, GLint location, GLfloat v0) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1f(location, v0); +} + +void gl3_3compat_glUseProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUseProgram(program); +} + +void gl3_3compat_glShaderSource(void *_glfuncs, GLuint shader, GLsizei count, const GLchar** source, const GLint* length) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShaderSource(shader, count, source, length); +} + +void gl3_3compat_glLinkProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLinkProgram(program); +} + +GLboolean gl3_3compat_glIsShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsShader(shader); +} + +GLboolean gl3_3compat_glIsProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsProgram(program); +} + +void gl3_3compat_glGetVertexAttribiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribiv(index, pname, params); +} + +void gl3_3compat_glGetVertexAttribfv(void *_glfuncs, GLuint index, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribfv(index, pname, params); +} + +void gl3_3compat_glGetVertexAttribdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribdv(index, pname, params); +} + +void gl3_3compat_glGetUniformiv(void *_glfuncs, GLuint program, GLint location, GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformiv(program, location, params); +} + +void gl3_3compat_glGetUniformfv(void *_glfuncs, GLuint program, GLint location, GLfloat* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformfv(program, location, params); +} + +GLint gl3_3compat_glGetUniformLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetUniformLocation(program, name); +} + +void gl3_3compat_glGetShaderSource(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderSource(shader, bufSize, length, source); +} + +void gl3_3compat_glGetShaderInfoLog(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderInfoLog(shader, bufSize, length, infoLog); +} + +void gl3_3compat_glGetShaderiv(void *_glfuncs, GLuint shader, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderiv(shader, pname, params); +} + +void gl3_3compat_glGetProgramInfoLog(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramInfoLog(program, bufSize, length, infoLog); +} + +void gl3_3compat_glGetProgramiv(void *_glfuncs, GLuint program, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramiv(program, pname, params); +} + +GLint gl3_3compat_glGetAttribLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetAttribLocation(program, name); +} + +void gl3_3compat_glGetAttachedShaders(void *_glfuncs, GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetAttachedShaders(program, maxCount, count, obj); +} + +void gl3_3compat_glGetActiveUniform(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniform(program, index, bufSize, length, size, gltype, name); +} + +void gl3_3compat_glGetActiveAttrib(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveAttrib(program, index, bufSize, length, size, gltype, name); +} + +void gl3_3compat_glEnableVertexAttribArray(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnableVertexAttribArray(index); +} + +void gl3_3compat_glDisableVertexAttribArray(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisableVertexAttribArray(index); +} + +void gl3_3compat_glDetachShader(void *_glfuncs, GLuint program, GLuint shader) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDetachShader(program, shader); +} + +void gl3_3compat_glDeleteShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteShader(shader); +} + +void gl3_3compat_glDeleteProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteProgram(program); +} + +GLuint gl3_3compat_glCreateShader(void *_glfuncs, GLenum gltype) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCreateShader(gltype); +} + +GLuint gl3_3compat_glCreateProgram(void *_glfuncs) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCreateProgram(); +} + +void gl3_3compat_glCompileShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompileShader(shader); +} + +void gl3_3compat_glBindAttribLocation(void *_glfuncs, GLuint program, GLuint index, const GLchar* name) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindAttribLocation(program, index, name); +} + +void gl3_3compat_glAttachShader(void *_glfuncs, GLuint program, GLuint shader) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAttachShader(program, shader); +} + +void gl3_3compat_glStencilMaskSeparate(void *_glfuncs, GLenum face, GLuint mask) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMaskSeparate(face, mask); +} + +void gl3_3compat_glStencilFuncSeparate(void *_glfuncs, GLenum face, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFuncSeparate(face, glfunc, ref, mask); +} + +void gl3_3compat_glStencilOpSeparate(void *_glfuncs, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOpSeparate(face, sfail, dpfail, dppass); +} + +void gl3_3compat_glDrawBuffers(void *_glfuncs, GLsizei n, const GLenum* bufs) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffers(n, bufs); +} + +void gl3_3compat_glBlendEquationSeparate(void *_glfuncs, GLenum modeRGB, GLenum modeAlpha) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquationSeparate(modeRGB, modeAlpha); +} + +void gl3_3compat_glUniformMatrix4x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x3fv(location, count, transpose, value); +} + +void gl3_3compat_glUniformMatrix3x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x4fv(location, count, transpose, value); +} + +void gl3_3compat_glUniformMatrix4x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x2fv(location, count, transpose, value); +} + +void gl3_3compat_glUniformMatrix2x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x4fv(location, count, transpose, value); +} + +void gl3_3compat_glUniformMatrix3x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x2fv(location, count, transpose, value); +} + +void gl3_3compat_glUniformMatrix2x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x3fv(location, count, transpose, value); +} + +GLboolean gl3_3compat_glIsVertexArray(void *_glfuncs, GLuint array) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsVertexArray(array); +} + +void gl3_3compat_glGenVertexArrays(void *_glfuncs, GLsizei n, GLuint* arrays) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenVertexArrays(n, arrays); +} + +void gl3_3compat_glDeleteVertexArrays(void *_glfuncs, GLsizei n, const GLuint* arrays) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteVertexArrays(n, arrays); +} + +void gl3_3compat_glBindVertexArray(void *_glfuncs, GLuint array) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindVertexArray(array); +} + +void gl3_3compat_glFlushMappedBufferRange(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr length) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlushMappedBufferRange(target, offset, length); +} + +void gl3_3compat_glFramebufferTextureLayer(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTextureLayer(target, attachment, texture, level, layer); +} + +void gl3_3compat_glRenderbufferStorageMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRenderbufferStorageMultisample(target, samples, internalFormat, width, height); +} + +void gl3_3compat_glBlitFramebuffer(void *_glfuncs, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); +} + +void gl3_3compat_glGenerateMipmap(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenerateMipmap(target); +} + +void gl3_3compat_glGetFramebufferAttachmentParameteriv(void *_glfuncs, GLenum target, GLenum attachment, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFramebufferAttachmentParameteriv(target, attachment, pname, params); +} + +void gl3_3compat_glFramebufferRenderbuffer(void *_glfuncs, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer); +} + +void gl3_3compat_glFramebufferTexture3D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset); +} + +void gl3_3compat_glFramebufferTexture2D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture2D(target, attachment, textarget, texture, level); +} + +void gl3_3compat_glFramebufferTexture1D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture1D(target, attachment, textarget, texture, level); +} + +GLenum gl3_3compat_glCheckFramebufferStatus(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCheckFramebufferStatus(target); +} + +void gl3_3compat_glGenFramebuffers(void *_glfuncs, GLsizei n, GLuint* framebuffers) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenFramebuffers(n, framebuffers); +} + +void gl3_3compat_glDeleteFramebuffers(void *_glfuncs, GLsizei n, const GLuint* framebuffers) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteFramebuffers(n, framebuffers); +} + +void gl3_3compat_glBindFramebuffer(void *_glfuncs, GLenum target, GLuint framebuffer) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFramebuffer(target, framebuffer); +} + +GLboolean gl3_3compat_glIsFramebuffer(void *_glfuncs, GLuint framebuffer) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsFramebuffer(framebuffer); +} + +void gl3_3compat_glGetRenderbufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetRenderbufferParameteriv(target, pname, params); +} + +void gl3_3compat_glRenderbufferStorage(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRenderbufferStorage(target, internalFormat, width, height); +} + +void gl3_3compat_glGenRenderbuffers(void *_glfuncs, GLsizei n, GLuint* renderbuffers) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenRenderbuffers(n, renderbuffers); +} + +void gl3_3compat_glDeleteRenderbuffers(void *_glfuncs, GLsizei n, const GLuint* renderbuffers) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteRenderbuffers(n, renderbuffers); +} + +void gl3_3compat_glBindRenderbuffer(void *_glfuncs, GLenum target, GLuint renderbuffer) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindRenderbuffer(target, renderbuffer); +} + +GLboolean gl3_3compat_glIsRenderbuffer(void *_glfuncs, GLuint renderbuffer) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsRenderbuffer(renderbuffer); +} + +void gl3_3compat_glClearBufferfi(void *_glfuncs, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferfi(buffer, drawbuffer, depth, stencil); +} + +void gl3_3compat_glClearBufferfv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLfloat* value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferfv(buffer, drawbuffer, value); +} + +void gl3_3compat_glClearBufferuiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLuint* value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferuiv(buffer, drawbuffer, value); +} + +void gl3_3compat_glClearBufferiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLint* value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferiv(buffer, drawbuffer, value); +} + +void gl3_3compat_glGetTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterIuiv(target, pname, params); +} + +void gl3_3compat_glGetTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterIiv(target, pname, params); +} + +void gl3_3compat_glTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, const GLuint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterIuiv(target, pname, params); +} + +void gl3_3compat_glTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterIiv(target, pname, params); +} + +void gl3_3compat_glUniform4uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4uiv(location, count, value); +} + +void gl3_3compat_glUniform3uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3uiv(location, count, value); +} + +void gl3_3compat_glUniform2uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2uiv(location, count, value); +} + +void gl3_3compat_glUniform1uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1uiv(location, count, value); +} + +void gl3_3compat_glUniform4ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4ui(location, v0, v1, v2, v3); +} + +void gl3_3compat_glUniform3ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3ui(location, v0, v1, v2); +} + +void gl3_3compat_glUniform2ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2ui(location, v0, v1); +} + +void gl3_3compat_glUniform1ui(void *_glfuncs, GLint location, GLuint v0) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1ui(location, v0); +} + +GLint gl3_3compat_glGetFragDataLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetFragDataLocation(program, name); +} + +void gl3_3compat_glBindFragDataLocation(void *_glfuncs, GLuint program, GLuint color, const GLchar* name) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFragDataLocation(program, color, name); +} + +void gl3_3compat_glGetUniformuiv(void *_glfuncs, GLuint program, GLint location, GLuint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformuiv(program, location, params); +} + +void gl3_3compat_glGetVertexAttribIuiv(void *_glfuncs, GLuint index, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribIuiv(index, pname, params); +} + +void gl3_3compat_glGetVertexAttribIiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribIiv(index, pname, params); +} + +void gl3_3compat_glVertexAttribIPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribIPointer(index, size, gltype, stride, pointer); +} + +void gl3_3compat_glEndConditionalRender(void *_glfuncs) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndConditionalRender(); +} + +void gl3_3compat_glBeginConditionalRender(void *_glfuncs, GLuint id, GLenum mode) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginConditionalRender(id, mode); +} + +void gl3_3compat_glClampColor(void *_glfuncs, GLenum target, GLenum clamp) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClampColor(target, clamp); +} + +void gl3_3compat_glGetTransformFeedbackVarying(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTransformFeedbackVarying(program, index, bufSize, length, size, gltype, name); +} + +void gl3_3compat_glBindBufferBase(void *_glfuncs, GLenum target, GLuint index, GLuint buffer) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBufferBase(target, index, buffer); +} + +void gl3_3compat_glBindBufferRange(void *_glfuncs, GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBufferRange(target, index, buffer, offset, size); +} + +void gl3_3compat_glEndTransformFeedback(void *_glfuncs) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndTransformFeedback(); +} + +void gl3_3compat_glBeginTransformFeedback(void *_glfuncs, GLenum primitiveMode) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginTransformFeedback(primitiveMode); +} + +GLboolean gl3_3compat_glIsEnabledi(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabledi(target, index); +} + +void gl3_3compat_glDisablei(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisablei(target, index); +} + +void gl3_3compat_glEnablei(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnablei(target, index); +} + +void gl3_3compat_glGetIntegeri_v(void *_glfuncs, GLenum target, GLuint index, GLint* data) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegeri_v(target, index, data); +} + +void gl3_3compat_glGetBooleani_v(void *_glfuncs, GLenum target, GLuint index, GLboolean* data) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleani_v(target, index, data); +} + +void gl3_3compat_glColorMaski(void *_glfuncs, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMaski(index, r, g, b, a); +} + +void gl3_3compat_glCopyBufferSubData(void *_glfuncs, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); +} + +void gl3_3compat_glUniformBlockBinding(void *_glfuncs, GLuint program, GLuint v0, GLuint v1) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformBlockBinding(program, v0, v1); +} + +void gl3_3compat_glGetActiveUniformBlockName(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName); +} + +void gl3_3compat_glGetActiveUniformBlockiv(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params); +} + +GLuint gl3_3compat_glGetUniformBlockIndex(void *_glfuncs, GLuint program, const GLchar* uniformBlockName) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetUniformBlockIndex(program, uniformBlockName); +} + +void gl3_3compat_glGetActiveUniformName(void *_glfuncs, GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformName(program, uniformIndex, bufSize, length, uniformName); +} + +void gl3_3compat_glGetActiveUniformsiv(void *_glfuncs, GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params); +} + +void gl3_3compat_glPrimitiveRestartIndex(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPrimitiveRestartIndex(index); +} + +void gl3_3compat_glTexBuffer(void *_glfuncs, GLenum target, GLenum internalFormat, GLuint buffer) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexBuffer(target, internalFormat, buffer); +} + +void gl3_3compat_glDrawElementsInstanced(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsInstanced(mode, count, gltype, indices, instancecount); +} + +void gl3_3compat_glDrawArraysInstanced(void *_glfuncs, GLenum mode, GLint first, GLsizei count, GLsizei instancecount) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArraysInstanced(mode, first, count, instancecount); +} + +void gl3_3compat_glSampleMaski(void *_glfuncs, GLuint index, GLbitfield mask) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSampleMaski(index, mask); +} + +void gl3_3compat_glGetMultisamplefv(void *_glfuncs, GLenum pname, GLuint index, GLfloat* val) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMultisamplefv(pname, index, val); +} + +void gl3_3compat_glTexImage3DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage3DMultisample(target, samples, internalFormat, width, height, depth, fixedsamplelocations); +} + +void gl3_3compat_glTexImage2DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage2DMultisample(target, samples, internalFormat, width, height, fixedsamplelocations); +} + +void gl3_3compat_glGetSynciv(void *_glfuncs, GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSynciv(sync, pname, bufSize, length, values); +} + +void gl3_3compat_glGetInteger64v(void *_glfuncs, GLenum pname, GLint64* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetInteger64v(pname, params); +} + +void gl3_3compat_glWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWaitSync(sync, flags, timeout); +} + +GLenum gl3_3compat_glClientWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glClientWaitSync(sync, flags, timeout); +} + +void gl3_3compat_glDeleteSync(void *_glfuncs, GLsync sync) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteSync(sync); +} + +GLboolean gl3_3compat_glIsSync(void *_glfuncs, GLsync sync) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsSync(sync); +} + +GLsync gl3_3compat_glFenceSync(void *_glfuncs, GLenum condition, GLbitfield flags) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glFenceSync(condition, flags); +} + +void gl3_3compat_glProvokingVertex(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProvokingVertex(mode); +} + +void gl3_3compat_glDrawElementsInstancedBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLint basevertex) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsInstancedBaseVertex(mode, count, gltype, indices, instancecount, basevertex); +} + +void gl3_3compat_glDrawRangeElementsBaseVertex(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawRangeElementsBaseVertex(mode, start, end, count, gltype, indices, basevertex); +} + +void gl3_3compat_glDrawElementsBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsBaseVertex(mode, count, gltype, indices, basevertex); +} + +void gl3_3compat_glFramebufferTexture(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture(target, attachment, texture, level); +} + +void gl3_3compat_glGetBufferParameteri64v(void *_glfuncs, GLenum target, GLenum pname, GLint64* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferParameteri64v(target, pname, params); +} + +void gl3_3compat_glGetInteger64i_v(void *_glfuncs, GLenum target, GLuint index, GLint64* data) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetInteger64i_v(target, index, data); +} + +void gl3_3compat_glVertexAttribP4uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP4uiv(index, gltype, normalized, value); +} + +void gl3_3compat_glVertexAttribP4ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP4ui(index, gltype, normalized, value); +} + +void gl3_3compat_glVertexAttribP3uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP3uiv(index, gltype, normalized, value); +} + +void gl3_3compat_glVertexAttribP3ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP3ui(index, gltype, normalized, value); +} + +void gl3_3compat_glVertexAttribP2uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP2uiv(index, gltype, normalized, value); +} + +void gl3_3compat_glVertexAttribP2ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP2ui(index, gltype, normalized, value); +} + +void gl3_3compat_glVertexAttribP1uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP1uiv(index, gltype, normalized, value); +} + +void gl3_3compat_glVertexAttribP1ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP1ui(index, gltype, normalized, value); +} + +void gl3_3compat_glSecondaryColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColorP3uiv(gltype, color); +} + +void gl3_3compat_glSecondaryColorP3ui(void *_glfuncs, GLenum gltype, GLuint color) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColorP3ui(gltype, color); +} + +void gl3_3compat_glColorP4uiv(void *_glfuncs, GLenum gltype, const GLuint* color) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP4uiv(gltype, color); +} + +void gl3_3compat_glColorP4ui(void *_glfuncs, GLenum gltype, GLuint color) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP4ui(gltype, color); +} + +void gl3_3compat_glColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP3uiv(gltype, color); +} + +void gl3_3compat_glColorP3ui(void *_glfuncs, GLenum gltype, GLuint color) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP3ui(gltype, color); +} + +void gl3_3compat_glNormalP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormalP3uiv(gltype, coords); +} + +void gl3_3compat_glNormalP3ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormalP3ui(gltype, coords); +} + +void gl3_3compat_glMultiTexCoordP4uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP4uiv(texture, gltype, coords); +} + +void gl3_3compat_glMultiTexCoordP4ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP4ui(texture, gltype, coords); +} + +void gl3_3compat_glMultiTexCoordP3uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP3uiv(texture, gltype, coords); +} + +void gl3_3compat_glMultiTexCoordP3ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP3ui(texture, gltype, coords); +} + +void gl3_3compat_glMultiTexCoordP2uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP2uiv(texture, gltype, coords); +} + +void gl3_3compat_glMultiTexCoordP2ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP2ui(texture, gltype, coords); +} + +void gl3_3compat_glMultiTexCoordP1uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP1uiv(texture, gltype, coords); +} + +void gl3_3compat_glMultiTexCoordP1ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP1ui(texture, gltype, coords); +} + +void gl3_3compat_glTexCoordP4uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP4uiv(gltype, coords); +} + +void gl3_3compat_glTexCoordP4ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP4ui(gltype, coords); +} + +void gl3_3compat_glTexCoordP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP3uiv(gltype, coords); +} + +void gl3_3compat_glTexCoordP3ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP3ui(gltype, coords); +} + +void gl3_3compat_glTexCoordP2uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP2uiv(gltype, coords); +} + +void gl3_3compat_glTexCoordP2ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP2ui(gltype, coords); +} + +void gl3_3compat_glTexCoordP1uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP1uiv(gltype, coords); +} + +void gl3_3compat_glTexCoordP1ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP1ui(gltype, coords); +} + +void gl3_3compat_glVertexP4uiv(void *_glfuncs, GLenum gltype, const GLuint* value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP4uiv(gltype, value); +} + +void gl3_3compat_glVertexP4ui(void *_glfuncs, GLenum gltype, GLuint value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP4ui(gltype, value); +} + +void gl3_3compat_glVertexP3uiv(void *_glfuncs, GLenum gltype, const GLuint* value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP3uiv(gltype, value); +} + +void gl3_3compat_glVertexP3ui(void *_glfuncs, GLenum gltype, GLuint value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP3ui(gltype, value); +} + +void gl3_3compat_glVertexP2uiv(void *_glfuncs, GLenum gltype, const GLuint* value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP2uiv(gltype, value); +} + +void gl3_3compat_glVertexP2ui(void *_glfuncs, GLenum gltype, GLuint value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP2ui(gltype, value); +} + +void gl3_3compat_glGetQueryObjectui64v(void *_glfuncs, GLuint id, GLenum pname, GLuint64* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectui64v(id, pname, params); +} + +void gl3_3compat_glGetQueryObjecti64v(void *_glfuncs, GLuint id, GLenum pname, GLint64* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjecti64v(id, pname, params); +} + +void gl3_3compat_glQueryCounter(void *_glfuncs, GLuint id, GLenum target) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glQueryCounter(id, target); +} + +void gl3_3compat_glGetSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameterIuiv(sampler, pname, params); +} + +void gl3_3compat_glGetSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameterfv(sampler, pname, params); +} + +void gl3_3compat_glGetSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameterIiv(sampler, pname, params); +} + +void gl3_3compat_glGetSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameteriv(sampler, pname, params); +} + +void gl3_3compat_glSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLuint* param) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterIuiv(sampler, pname, param); +} + +void gl3_3compat_glSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterIiv(sampler, pname, param); +} + +void gl3_3compat_glSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, const GLfloat* param) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterfv(sampler, pname, param); +} + +void gl3_3compat_glSamplerParameterf(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterf(sampler, pname, param); +} + +void gl3_3compat_glSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameteriv(sampler, pname, param); +} + +void gl3_3compat_glSamplerParameteri(void *_glfuncs, GLuint sampler, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameteri(sampler, pname, param); +} + +void gl3_3compat_glBindSampler(void *_glfuncs, GLuint unit, GLuint sampler) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindSampler(unit, sampler); +} + +GLboolean gl3_3compat_glIsSampler(void *_glfuncs, GLuint sampler) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsSampler(sampler); +} + +void gl3_3compat_glDeleteSamplers(void *_glfuncs, GLsizei count, const GLuint* samplers) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteSamplers(count, samplers); +} + +void gl3_3compat_glGenSamplers(void *_glfuncs, GLsizei count, GLuint* samplers) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenSamplers(count, samplers); +} + +GLint gl3_3compat_glGetFragDataIndex(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetFragDataIndex(program, name); +} + +void gl3_3compat_glBindFragDataLocationIndexed(void *_glfuncs, GLuint program, GLuint colorNumber, GLuint index, const GLchar* name) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFragDataLocationIndexed(program, colorNumber, index, name); +} + +void gl3_3compat_glVertexAttribDivisor(void *_glfuncs, GLuint index, GLuint divisor) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribDivisor(index, divisor); +} + +void gl3_3compat_glTranslatef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTranslatef(x, y, z); +} + +void gl3_3compat_glTranslated(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTranslated(x, y, z); +} + +void gl3_3compat_glScalef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScalef(x, y, z); +} + +void gl3_3compat_glScaled(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScaled(x, y, z); +} + +void gl3_3compat_glRotatef(void *_glfuncs, GLfloat angle, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRotatef(angle, x, y, z); +} + +void gl3_3compat_glRotated(void *_glfuncs, GLdouble angle, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRotated(angle, x, y, z); +} + +void gl3_3compat_glPushMatrix(void *_glfuncs) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushMatrix(); +} + +void gl3_3compat_glPopMatrix(void *_glfuncs) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopMatrix(); +} + +void gl3_3compat_glOrtho(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glOrtho(left, right, bottom, top, zNear, zFar); +} + +void gl3_3compat_glMultMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultMatrixd(m); +} + +void gl3_3compat_glMultMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultMatrixf(m); +} + +void gl3_3compat_glMatrixMode(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMatrixMode(mode); +} + +void gl3_3compat_glLoadMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadMatrixd(m); +} + +void gl3_3compat_glLoadMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadMatrixf(m); +} + +void gl3_3compat_glLoadIdentity(void *_glfuncs) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadIdentity(); +} + +void gl3_3compat_glFrustum(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrustum(left, right, bottom, top, zNear, zFar); +} + +GLboolean gl3_3compat_glIsList(void *_glfuncs, GLuint list) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsList(list); +} + +void gl3_3compat_glGetTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGeniv(coord, pname, params); +} + +void gl3_3compat_glGetTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGenfv(coord, pname, params); +} + +void gl3_3compat_glGetTexGendv(void *_glfuncs, GLenum coord, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGendv(coord, pname, params); +} + +void gl3_3compat_glGetTexEnviv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexEnviv(target, pname, params); +} + +void gl3_3compat_glGetTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexEnvfv(target, pname, params); +} + +void gl3_3compat_glGetPolygonStipple(void *_glfuncs, GLubyte* mask) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPolygonStipple(mask); +} + +void gl3_3compat_glGetPixelMapusv(void *_glfuncs, GLenum glmap, GLushort* values) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapusv(glmap, values); +} + +void gl3_3compat_glGetPixelMapuiv(void *_glfuncs, GLenum glmap, GLuint* values) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapuiv(glmap, values); +} + +void gl3_3compat_glGetPixelMapfv(void *_glfuncs, GLenum glmap, GLfloat* values) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapfv(glmap, values); +} + +void gl3_3compat_glGetMaterialiv(void *_glfuncs, GLenum face, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMaterialiv(face, pname, params); +} + +void gl3_3compat_glGetMaterialfv(void *_glfuncs, GLenum face, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMaterialfv(face, pname, params); +} + +void gl3_3compat_glGetMapiv(void *_glfuncs, GLenum target, GLenum query, GLint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapiv(target, query, v); +} + +void gl3_3compat_glGetMapfv(void *_glfuncs, GLenum target, GLenum query, GLfloat* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapfv(target, query, v); +} + +void gl3_3compat_glGetMapdv(void *_glfuncs, GLenum target, GLenum query, GLdouble* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapdv(target, query, v); +} + +void gl3_3compat_glGetLightiv(void *_glfuncs, GLenum light, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetLightiv(light, pname, params); +} + +void gl3_3compat_glGetLightfv(void *_glfuncs, GLenum light, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetLightfv(light, pname, params); +} + +void gl3_3compat_glGetClipPlane(void *_glfuncs, GLenum plane, GLdouble* equation) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetClipPlane(plane, equation); +} + +void gl3_3compat_glDrawPixels(void *_glfuncs, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawPixels(width, height, format, gltype, pixels); +} + +void gl3_3compat_glCopyPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum gltype) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyPixels(x, y, width, height, gltype); +} + +void gl3_3compat_glPixelMapusv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLushort* values) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapusv(glmap, mapsize, values); +} + +void gl3_3compat_glPixelMapuiv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLuint* values) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapuiv(glmap, mapsize, values); +} + +void gl3_3compat_glPixelMapfv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLfloat* values) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapfv(glmap, mapsize, values); +} + +void gl3_3compat_glPixelTransferi(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelTransferi(pname, param); +} + +void gl3_3compat_glPixelTransferf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelTransferf(pname, param); +} + +void gl3_3compat_glPixelZoom(void *_glfuncs, GLfloat xfactor, GLfloat yfactor) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelZoom(xfactor, yfactor); +} + +void gl3_3compat_glAlphaFunc(void *_glfuncs, GLenum glfunc, GLfloat ref) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAlphaFunc(glfunc, ref); +} + +void gl3_3compat_glEvalPoint2(void *_glfuncs, GLint i, GLint j) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalPoint2(i, j); +} + +void gl3_3compat_glEvalMesh2(void *_glfuncs, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalMesh2(mode, i1, i2, j1, j2); +} + +void gl3_3compat_glEvalPoint1(void *_glfuncs, GLint i) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalPoint1(i); +} + +void gl3_3compat_glEvalMesh1(void *_glfuncs, GLenum mode, GLint i1, GLint i2) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalMesh1(mode, i1, i2); +} + +void gl3_3compat_glEvalCoord2fv(void *_glfuncs, const GLfloat* u) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2fv(u); +} + +void gl3_3compat_glEvalCoord2f(void *_glfuncs, GLfloat u, GLfloat v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2f(u, v); +} + +void gl3_3compat_glEvalCoord2dv(void *_glfuncs, const GLdouble* u) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2dv(u); +} + +void gl3_3compat_glEvalCoord2d(void *_glfuncs, GLdouble u, GLdouble v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2d(u, v); +} + +void gl3_3compat_glEvalCoord1fv(void *_glfuncs, const GLfloat* u) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1fv(u); +} + +void gl3_3compat_glEvalCoord1f(void *_glfuncs, GLfloat u) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1f(u); +} + +void gl3_3compat_glEvalCoord1dv(void *_glfuncs, const GLdouble* u) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1dv(u); +} + +void gl3_3compat_glEvalCoord1d(void *_glfuncs, GLdouble u) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1d(u); +} + +void gl3_3compat_glMapGrid2f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid2f(un, u1, u2, vn, v1, v2); +} + +void gl3_3compat_glMapGrid2d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid2d(un, u1, u2, vn, v1, v2); +} + +void gl3_3compat_glMapGrid1f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid1f(un, u1, u2); +} + +void gl3_3compat_glMapGrid1d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid1d(un, u1, u2); +} + +void gl3_3compat_glMap2f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); +} + +void gl3_3compat_glMap2d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); +} + +void gl3_3compat_glMap1f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap1f(target, u1, u2, stride, order, points); +} + +void gl3_3compat_glMap1d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap1d(target, u1, u2, stride, order, points); +} + +void gl3_3compat_glPushAttrib(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushAttrib(mask); +} + +void gl3_3compat_glPopAttrib(void *_glfuncs) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopAttrib(); +} + +void gl3_3compat_glAccum(void *_glfuncs, GLenum op, GLfloat value) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAccum(op, value); +} + +void gl3_3compat_glIndexMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexMask(mask); +} + +void gl3_3compat_glClearIndex(void *_glfuncs, GLfloat c) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearIndex(c); +} + +void gl3_3compat_glClearAccum(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearAccum(red, green, blue, alpha); +} + +void gl3_3compat_glPushName(void *_glfuncs, GLuint name) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushName(name); +} + +void gl3_3compat_glPopName(void *_glfuncs) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopName(); +} + +void gl3_3compat_glPassThrough(void *_glfuncs, GLfloat token) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPassThrough(token); +} + +void gl3_3compat_glLoadName(void *_glfuncs, GLuint name) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadName(name); +} + +void gl3_3compat_glInitNames(void *_glfuncs) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInitNames(); +} + +GLint gl3_3compat_glRenderMode(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glRenderMode(mode); +} + +void gl3_3compat_glSelectBuffer(void *_glfuncs, GLsizei size, GLuint* buffer) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSelectBuffer(size, buffer); +} + +void gl3_3compat_glFeedbackBuffer(void *_glfuncs, GLsizei size, GLenum gltype, GLfloat* buffer) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFeedbackBuffer(size, gltype, buffer); +} + +void gl3_3compat_glTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGeniv(coord, pname, params); +} + +void gl3_3compat_glTexGeni(void *_glfuncs, GLenum coord, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGeni(coord, pname, param); +} + +void gl3_3compat_glTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGenfv(coord, pname, params); +} + +void gl3_3compat_glTexGenf(void *_glfuncs, GLenum coord, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGenf(coord, pname, param); +} + +void gl3_3compat_glTexGendv(void *_glfuncs, GLenum coord, GLenum pname, const GLdouble* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGendv(coord, pname, params); +} + +void gl3_3compat_glTexGend(void *_glfuncs, GLenum coord, GLenum pname, GLdouble param) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGend(coord, pname, param); +} + +void gl3_3compat_glTexEnviv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnviv(target, pname, params); +} + +void gl3_3compat_glTexEnvi(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvi(target, pname, param); +} + +void gl3_3compat_glTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvfv(target, pname, params); +} + +void gl3_3compat_glTexEnvf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvf(target, pname, param); +} + +void gl3_3compat_glShadeModel(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShadeModel(mode); +} + +void gl3_3compat_glPolygonStipple(void *_glfuncs, const GLubyte* mask) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonStipple(mask); +} + +void gl3_3compat_glMaterialiv(void *_glfuncs, GLenum face, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialiv(face, pname, params); +} + +void gl3_3compat_glMateriali(void *_glfuncs, GLenum face, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMateriali(face, pname, param); +} + +void gl3_3compat_glMaterialfv(void *_glfuncs, GLenum face, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialfv(face, pname, params); +} + +void gl3_3compat_glMaterialf(void *_glfuncs, GLenum face, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialf(face, pname, param); +} + +void gl3_3compat_glLineStipple(void *_glfuncs, GLint factor, GLushort pattern) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineStipple(factor, pattern); +} + +void gl3_3compat_glLightModeliv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModeliv(pname, params); +} + +void gl3_3compat_glLightModeli(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModeli(pname, param); +} + +void gl3_3compat_glLightModelfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModelfv(pname, params); +} + +void gl3_3compat_glLightModelf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModelf(pname, param); +} + +void gl3_3compat_glLightiv(void *_glfuncs, GLenum light, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightiv(light, pname, params); +} + +void gl3_3compat_glLighti(void *_glfuncs, GLenum light, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLighti(light, pname, param); +} + +void gl3_3compat_glLightfv(void *_glfuncs, GLenum light, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightfv(light, pname, params); +} + +void gl3_3compat_glLightf(void *_glfuncs, GLenum light, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightf(light, pname, param); +} + +void gl3_3compat_glFogiv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogiv(pname, params); +} + +void gl3_3compat_glFogi(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogi(pname, param); +} + +void gl3_3compat_glFogfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogfv(pname, params); +} + +void gl3_3compat_glFogf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogf(pname, param); +} + +void gl3_3compat_glColorMaterial(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMaterial(face, mode); +} + +void gl3_3compat_glClipPlane(void *_glfuncs, GLenum plane, const GLdouble* equation) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClipPlane(plane, equation); +} + +void gl3_3compat_glVertex4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4sv(v); +} + +void gl3_3compat_glVertex4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4s(x, y, z, w); +} + +void gl3_3compat_glVertex4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4iv(v); +} + +void gl3_3compat_glVertex4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4i(x, y, z, w); +} + +void gl3_3compat_glVertex4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4fv(v); +} + +void gl3_3compat_glVertex4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4f(x, y, z, w); +} + +void gl3_3compat_glVertex4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4dv(v); +} + +void gl3_3compat_glVertex4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4d(x, y, z, w); +} + +void gl3_3compat_glVertex3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3sv(v); +} + +void gl3_3compat_glVertex3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3s(x, y, z); +} + +void gl3_3compat_glVertex3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3iv(v); +} + +void gl3_3compat_glVertex3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3i(x, y, z); +} + +void gl3_3compat_glVertex3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3fv(v); +} + +void gl3_3compat_glVertex3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3f(x, y, z); +} + +void gl3_3compat_glVertex3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3dv(v); +} + +void gl3_3compat_glVertex3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3d(x, y, z); +} + +void gl3_3compat_glVertex2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2sv(v); +} + +void gl3_3compat_glVertex2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2s(x, y); +} + +void gl3_3compat_glVertex2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2iv(v); +} + +void gl3_3compat_glVertex2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2i(x, y); +} + +void gl3_3compat_glVertex2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2fv(v); +} + +void gl3_3compat_glVertex2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2f(x, y); +} + +void gl3_3compat_glVertex2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2dv(v); +} + +void gl3_3compat_glVertex2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2d(x, y); +} + +void gl3_3compat_glTexCoord4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4sv(v); +} + +void gl3_3compat_glTexCoord4s(void *_glfuncs, GLshort s, GLshort t, GLshort r, GLshort q) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4s(s, t, r, q); +} + +void gl3_3compat_glTexCoord4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4iv(v); +} + +void gl3_3compat_glTexCoord4i(void *_glfuncs, GLint s, GLint t, GLint r, GLint q) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4i(s, t, r, q); +} + +void gl3_3compat_glTexCoord4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4fv(v); +} + +void gl3_3compat_glTexCoord4f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4f(s, t, r, q); +} + +void gl3_3compat_glTexCoord4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4dv(v); +} + +void gl3_3compat_glTexCoord4d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r, GLdouble q) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4d(s, t, r, q); +} + +void gl3_3compat_glTexCoord3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3sv(v); +} + +void gl3_3compat_glTexCoord3s(void *_glfuncs, GLshort s, GLshort t, GLshort r) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3s(s, t, r); +} + +void gl3_3compat_glTexCoord3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3iv(v); +} + +void gl3_3compat_glTexCoord3i(void *_glfuncs, GLint s, GLint t, GLint r) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3i(s, t, r); +} + +void gl3_3compat_glTexCoord3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3fv(v); +} + +void gl3_3compat_glTexCoord3f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3f(s, t, r); +} + +void gl3_3compat_glTexCoord3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3dv(v); +} + +void gl3_3compat_glTexCoord3d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3d(s, t, r); +} + +void gl3_3compat_glTexCoord2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2sv(v); +} + +void gl3_3compat_glTexCoord2s(void *_glfuncs, GLshort s, GLshort t) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2s(s, t); +} + +void gl3_3compat_glTexCoord2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2iv(v); +} + +void gl3_3compat_glTexCoord2i(void *_glfuncs, GLint s, GLint t) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2i(s, t); +} + +void gl3_3compat_glTexCoord2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2fv(v); +} + +void gl3_3compat_glTexCoord2f(void *_glfuncs, GLfloat s, GLfloat t) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2f(s, t); +} + +void gl3_3compat_glTexCoord2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2dv(v); +} + +void gl3_3compat_glTexCoord2d(void *_glfuncs, GLdouble s, GLdouble t) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2d(s, t); +} + +void gl3_3compat_glTexCoord1sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1sv(v); +} + +void gl3_3compat_glTexCoord1s(void *_glfuncs, GLshort s) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1s(s); +} + +void gl3_3compat_glTexCoord1iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1iv(v); +} + +void gl3_3compat_glTexCoord1i(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1i(s); +} + +void gl3_3compat_glTexCoord1fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1fv(v); +} + +void gl3_3compat_glTexCoord1f(void *_glfuncs, GLfloat s) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1f(s); +} + +void gl3_3compat_glTexCoord1dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1dv(v); +} + +void gl3_3compat_glTexCoord1d(void *_glfuncs, GLdouble s) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1d(s); +} + +void gl3_3compat_glRectsv(void *_glfuncs, const GLshort* v1, const GLshort* v2) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectsv(v1, v2); +} + +void gl3_3compat_glRects(void *_glfuncs, GLshort x1, GLshort y1, GLshort x2, GLshort y2) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRects(x1, y1, x2, y2); +} + +void gl3_3compat_glRectiv(void *_glfuncs, const GLint* v1, const GLint* v2) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectiv(v1, v2); +} + +void gl3_3compat_glRecti(void *_glfuncs, GLint x1, GLint y1, GLint x2, GLint y2) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRecti(x1, y1, x2, y2); +} + +void gl3_3compat_glRectfv(void *_glfuncs, const GLfloat* v1, const GLfloat* v2) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectfv(v1, v2); +} + +void gl3_3compat_glRectf(void *_glfuncs, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectf(x1, y1, x2, y2); +} + +void gl3_3compat_glRectdv(void *_glfuncs, const GLdouble* v1, const GLdouble* v2) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectdv(v1, v2); +} + +void gl3_3compat_glRectd(void *_glfuncs, GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectd(x1, y1, x2, y2); +} + +void gl3_3compat_glRasterPos4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4sv(v); +} + +void gl3_3compat_glRasterPos4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4s(x, y, z, w); +} + +void gl3_3compat_glRasterPos4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4iv(v); +} + +void gl3_3compat_glRasterPos4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4i(x, y, z, w); +} + +void gl3_3compat_glRasterPos4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4fv(v); +} + +void gl3_3compat_glRasterPos4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4f(x, y, z, w); +} + +void gl3_3compat_glRasterPos4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4dv(v); +} + +void gl3_3compat_glRasterPos4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4d(x, y, z, w); +} + +void gl3_3compat_glRasterPos3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3sv(v); +} + +void gl3_3compat_glRasterPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3s(x, y, z); +} + +void gl3_3compat_glRasterPos3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3iv(v); +} + +void gl3_3compat_glRasterPos3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3i(x, y, z); +} + +void gl3_3compat_glRasterPos3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3fv(v); +} + +void gl3_3compat_glRasterPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3f(x, y, z); +} + +void gl3_3compat_glRasterPos3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3dv(v); +} + +void gl3_3compat_glRasterPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3d(x, y, z); +} + +void gl3_3compat_glRasterPos2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2sv(v); +} + +void gl3_3compat_glRasterPos2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2s(x, y); +} + +void gl3_3compat_glRasterPos2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2iv(v); +} + +void gl3_3compat_glRasterPos2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2i(x, y); +} + +void gl3_3compat_glRasterPos2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2fv(v); +} + +void gl3_3compat_glRasterPos2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2f(x, y); +} + +void gl3_3compat_glRasterPos2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2dv(v); +} + +void gl3_3compat_glRasterPos2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2d(x, y); +} + +void gl3_3compat_glNormal3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3sv(v); +} + +void gl3_3compat_glNormal3s(void *_glfuncs, GLshort nx, GLshort ny, GLshort nz) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3s(nx, ny, nz); +} + +void gl3_3compat_glNormal3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3iv(v); +} + +void gl3_3compat_glNormal3i(void *_glfuncs, GLint nx, GLint ny, GLint nz) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3i(nx, ny, nz); +} + +void gl3_3compat_glNormal3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3fv(v); +} + +void gl3_3compat_glNormal3f(void *_glfuncs, GLfloat nx, GLfloat ny, GLfloat nz) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3f(nx, ny, nz); +} + +void gl3_3compat_glNormal3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3dv(v); +} + +void gl3_3compat_glNormal3d(void *_glfuncs, GLdouble nx, GLdouble ny, GLdouble nz) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3d(nx, ny, nz); +} + +void gl3_3compat_glNormal3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3bv(v); +} + +void gl3_3compat_glNormal3b(void *_glfuncs, GLbyte nx, GLbyte ny, GLbyte nz) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3b(nx, ny, nz); +} + +void gl3_3compat_glIndexsv(void *_glfuncs, const GLshort* c) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexsv(c); +} + +void gl3_3compat_glIndexs(void *_glfuncs, GLshort c) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexs(c); +} + +void gl3_3compat_glIndexiv(void *_glfuncs, const GLint* c) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexiv(c); +} + +void gl3_3compat_glIndexi(void *_glfuncs, GLint c) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexi(c); +} + +void gl3_3compat_glIndexfv(void *_glfuncs, const GLfloat* c) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexfv(c); +} + +void gl3_3compat_glIndexf(void *_glfuncs, GLfloat c) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexf(c); +} + +void gl3_3compat_glIndexdv(void *_glfuncs, const GLdouble* c) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexdv(c); +} + +void gl3_3compat_glIndexd(void *_glfuncs, GLdouble c) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexd(c); +} + +void gl3_3compat_glEnd(void *_glfuncs) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnd(); +} + +void gl3_3compat_glEdgeFlagv(void *_glfuncs, const GLboolean* flag) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlagv(flag); +} + +void gl3_3compat_glEdgeFlag(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlag(flag); +} + +void gl3_3compat_glColor4usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4usv(v); +} + +void gl3_3compat_glColor4us(void *_glfuncs, GLushort red, GLushort green, GLushort blue, GLushort alpha) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4us(red, green, blue, alpha); +} + +void gl3_3compat_glColor4uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4uiv(v); +} + +void gl3_3compat_glColor4ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue, GLuint alpha) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ui(red, green, blue, alpha); +} + +void gl3_3compat_glColor4ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ubv(v); +} + +void gl3_3compat_glColor4ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ub(red, green, blue, alpha); +} + +void gl3_3compat_glColor4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4sv(v); +} + +void gl3_3compat_glColor4s(void *_glfuncs, GLshort red, GLshort green, GLshort blue, GLshort alpha) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4s(red, green, blue, alpha); +} + +void gl3_3compat_glColor4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4iv(v); +} + +void gl3_3compat_glColor4i(void *_glfuncs, GLint red, GLint green, GLint blue, GLint alpha) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4i(red, green, blue, alpha); +} + +void gl3_3compat_glColor4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4fv(v); +} + +void gl3_3compat_glColor4f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4f(red, green, blue, alpha); +} + +void gl3_3compat_glColor4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4dv(v); +} + +void gl3_3compat_glColor4d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4d(red, green, blue, alpha); +} + +void gl3_3compat_glColor4bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4bv(v); +} + +void gl3_3compat_glColor4b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4b(red, green, blue, alpha); +} + +void gl3_3compat_glColor3usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3usv(v); +} + +void gl3_3compat_glColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3us(red, green, blue); +} + +void gl3_3compat_glColor3uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3uiv(v); +} + +void gl3_3compat_glColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ui(red, green, blue); +} + +void gl3_3compat_glColor3ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ubv(v); +} + +void gl3_3compat_glColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ub(red, green, blue); +} + +void gl3_3compat_glColor3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3sv(v); +} + +void gl3_3compat_glColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3s(red, green, blue); +} + +void gl3_3compat_glColor3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3iv(v); +} + +void gl3_3compat_glColor3i(void *_glfuncs, GLint red, GLint green, GLint blue) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3i(red, green, blue); +} + +void gl3_3compat_glColor3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3fv(v); +} + +void gl3_3compat_glColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3f(red, green, blue); +} + +void gl3_3compat_glColor3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3dv(v); +} + +void gl3_3compat_glColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3d(red, green, blue); +} + +void gl3_3compat_glColor3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3bv(v); +} + +void gl3_3compat_glColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3b(red, green, blue); +} + +void gl3_3compat_glBitmap(void *_glfuncs, GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBitmap(width, height, xorig, yorig, xmove, ymove, bitmap); +} + +void gl3_3compat_glBegin(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBegin(mode); +} + +void gl3_3compat_glListBase(void *_glfuncs, GLuint base) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glListBase(base); +} + +GLuint gl3_3compat_glGenLists(void *_glfuncs, GLsizei range_) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGenLists(range_); +} + +void gl3_3compat_glDeleteLists(void *_glfuncs, GLuint list, GLsizei range_) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteLists(list, range_); +} + +void gl3_3compat_glCallLists(void *_glfuncs, GLsizei n, GLenum gltype, const GLvoid* lists) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCallLists(n, gltype, lists); +} + +void gl3_3compat_glCallList(void *_glfuncs, GLuint list) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCallList(list); +} + +void gl3_3compat_glEndList(void *_glfuncs) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndList(); +} + +void gl3_3compat_glNewList(void *_glfuncs, GLuint list, GLenum mode) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNewList(list, mode); +} + +void gl3_3compat_glPushClientAttrib(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushClientAttrib(mask); +} + +void gl3_3compat_glPopClientAttrib(void *_glfuncs) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopClientAttrib(); +} + +void gl3_3compat_glPrioritizeTextures(void *_glfuncs, GLsizei n, const GLuint* textures, const GLfloat* priorities) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPrioritizeTextures(n, textures, priorities); +} + +GLboolean gl3_3compat_glAreTexturesResident(void *_glfuncs, GLsizei n, const GLuint* textures, GLboolean* residences) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glAreTexturesResident(n, textures, residences); +} + +void gl3_3compat_glVertexPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexPointer(size, gltype, stride, pointer); +} + +void gl3_3compat_glTexCoordPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordPointer(size, gltype, stride, pointer); +} + +void gl3_3compat_glNormalPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormalPointer(gltype, stride, pointer); +} + +void gl3_3compat_glInterleavedArrays(void *_glfuncs, GLenum format, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInterleavedArrays(format, stride, pointer); +} + +void gl3_3compat_glIndexPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexPointer(gltype, stride, pointer); +} + +void gl3_3compat_glEnableClientState(void *_glfuncs, GLenum array) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnableClientState(array); +} + +void gl3_3compat_glEdgeFlagPointer(void *_glfuncs, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlagPointer(stride, pointer); +} + +void gl3_3compat_glDisableClientState(void *_glfuncs, GLenum array) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisableClientState(array); +} + +void gl3_3compat_glColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorPointer(size, gltype, stride, pointer); +} + +void gl3_3compat_glArrayElement(void *_glfuncs, GLint i) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glArrayElement(i); +} + +void gl3_3compat_glResetMinmax(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glResetMinmax(target); +} + +void gl3_3compat_glResetHistogram(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glResetHistogram(target); +} + +void gl3_3compat_glMinmax(void *_glfuncs, GLenum target, GLenum internalFormat, GLboolean sink) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMinmax(target, internalFormat, sink); +} + +void gl3_3compat_glHistogram(void *_glfuncs, GLenum target, GLsizei width, GLenum internalFormat, GLboolean sink) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glHistogram(target, width, internalFormat, sink); +} + +void gl3_3compat_glGetMinmaxParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmaxParameteriv(target, pname, params); +} + +void gl3_3compat_glGetMinmaxParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmaxParameterfv(target, pname, params); +} + +void gl3_3compat_glGetMinmax(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmax(target, reset, format, gltype, values); +} + +void gl3_3compat_glGetHistogramParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogramParameteriv(target, pname, params); +} + +void gl3_3compat_glGetHistogramParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogramParameterfv(target, pname, params); +} + +void gl3_3compat_glGetHistogram(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogram(target, reset, format, gltype, values); +} + +void gl3_3compat_glSeparableFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* row, const GLvoid* column) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSeparableFilter2D(target, internalFormat, width, height, format, gltype, row, column); +} + +void gl3_3compat_glGetSeparableFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* row, GLvoid* column, GLvoid* span) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSeparableFilter(target, format, gltype, row, column, span); +} + +void gl3_3compat_glGetConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionParameteriv(target, pname, params); +} + +void gl3_3compat_glGetConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionParameterfv(target, pname, params); +} + +void gl3_3compat_glGetConvolutionFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* image) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionFilter(target, format, gltype, image); +} + +void gl3_3compat_glCopyConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyConvolutionFilter2D(target, internalFormat, x, y, width, height); +} + +void gl3_3compat_glCopyConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyConvolutionFilter1D(target, internalFormat, x, y, width); +} + +void gl3_3compat_glConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameteriv(target, pname, params); +} + +void gl3_3compat_glConvolutionParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameteri(target, pname, params); +} + +void gl3_3compat_glConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameterfv(target, pname, params); +} + +void gl3_3compat_glConvolutionParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameterf(target, pname, params); +} + +void gl3_3compat_glConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* image) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionFilter2D(target, internalFormat, width, height, format, gltype, image); +} + +void gl3_3compat_glConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* image) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionFilter1D(target, internalFormat, width, format, gltype, image); +} + +void gl3_3compat_glCopyColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyColorSubTable(target, start, x, y, width); +} + +void gl3_3compat_glColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum gltype, const GLvoid* data) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorSubTable(target, start, count, format, gltype, data); +} + +void gl3_3compat_glGetColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTableParameteriv(target, pname, params); +} + +void gl3_3compat_glGetColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTableParameterfv(target, pname, params); +} + +void gl3_3compat_glGetColorTable(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* table) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTable(target, format, gltype, table); +} + +void gl3_3compat_glCopyColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyColorTable(target, internalFormat, x, y, width); +} + +void gl3_3compat_glColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTableParameteriv(target, pname, params); +} + +void gl3_3compat_glColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTableParameterfv(target, pname, params); +} + +void gl3_3compat_glColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* table) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTable(target, internalFormat, width, format, gltype, table); +} + +void gl3_3compat_glMultTransposeMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultTransposeMatrixd(m); +} + +void gl3_3compat_glMultTransposeMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultTransposeMatrixf(m); +} + +void gl3_3compat_glLoadTransposeMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadTransposeMatrixd(m); +} + +void gl3_3compat_glLoadTransposeMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadTransposeMatrixf(m); +} + +void gl3_3compat_glMultiTexCoord4sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4sv(target, v); +} + +void gl3_3compat_glMultiTexCoord4s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r, GLshort q) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4s(target, s, t, r, q); +} + +void gl3_3compat_glMultiTexCoord4iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4iv(target, v); +} + +void gl3_3compat_glMultiTexCoord4i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r, GLint q) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4i(target, s, t, r, q); +} + +void gl3_3compat_glMultiTexCoord4fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4fv(target, v); +} + +void gl3_3compat_glMultiTexCoord4f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4f(target, s, t, r, q); +} + +void gl3_3compat_glMultiTexCoord4dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4dv(target, v); +} + +void gl3_3compat_glMultiTexCoord4d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4d(target, s, t, r, q); +} + +void gl3_3compat_glMultiTexCoord3sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3sv(target, v); +} + +void gl3_3compat_glMultiTexCoord3s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3s(target, s, t, r); +} + +void gl3_3compat_glMultiTexCoord3iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3iv(target, v); +} + +void gl3_3compat_glMultiTexCoord3i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3i(target, s, t, r); +} + +void gl3_3compat_glMultiTexCoord3fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3fv(target, v); +} + +void gl3_3compat_glMultiTexCoord3f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3f(target, s, t, r); +} + +void gl3_3compat_glMultiTexCoord3dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3dv(target, v); +} + +void gl3_3compat_glMultiTexCoord3d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3d(target, s, t, r); +} + +void gl3_3compat_glMultiTexCoord2sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2sv(target, v); +} + +void gl3_3compat_glMultiTexCoord2s(void *_glfuncs, GLenum target, GLshort s, GLshort t) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2s(target, s, t); +} + +void gl3_3compat_glMultiTexCoord2iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2iv(target, v); +} + +void gl3_3compat_glMultiTexCoord2i(void *_glfuncs, GLenum target, GLint s, GLint t) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2i(target, s, t); +} + +void gl3_3compat_glMultiTexCoord2fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2fv(target, v); +} + +void gl3_3compat_glMultiTexCoord2f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2f(target, s, t); +} + +void gl3_3compat_glMultiTexCoord2dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2dv(target, v); +} + +void gl3_3compat_glMultiTexCoord2d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2d(target, s, t); +} + +void gl3_3compat_glMultiTexCoord1sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1sv(target, v); +} + +void gl3_3compat_glMultiTexCoord1s(void *_glfuncs, GLenum target, GLshort s) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1s(target, s); +} + +void gl3_3compat_glMultiTexCoord1iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1iv(target, v); +} + +void gl3_3compat_glMultiTexCoord1i(void *_glfuncs, GLenum target, GLint s) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1i(target, s); +} + +void gl3_3compat_glMultiTexCoord1fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1fv(target, v); +} + +void gl3_3compat_glMultiTexCoord1f(void *_glfuncs, GLenum target, GLfloat s) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1f(target, s); +} + +void gl3_3compat_glMultiTexCoord1dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1dv(target, v); +} + +void gl3_3compat_glMultiTexCoord1d(void *_glfuncs, GLenum target, GLdouble s) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1d(target, s); +} + +void gl3_3compat_glClientActiveTexture(void *_glfuncs, GLenum texture) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClientActiveTexture(texture); +} + +void gl3_3compat_glWindowPos3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3sv(v); +} + +void gl3_3compat_glWindowPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3s(x, y, z); +} + +void gl3_3compat_glWindowPos3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3iv(v); +} + +void gl3_3compat_glWindowPos3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3i(x, y, z); +} + +void gl3_3compat_glWindowPos3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3fv(v); +} + +void gl3_3compat_glWindowPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3f(x, y, z); +} + +void gl3_3compat_glWindowPos3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3dv(v); +} + +void gl3_3compat_glWindowPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3d(x, y, z); +} + +void gl3_3compat_glWindowPos2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2sv(v); +} + +void gl3_3compat_glWindowPos2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2s(x, y); +} + +void gl3_3compat_glWindowPos2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2iv(v); +} + +void gl3_3compat_glWindowPos2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2i(x, y); +} + +void gl3_3compat_glWindowPos2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2fv(v); +} + +void gl3_3compat_glWindowPos2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2f(x, y); +} + +void gl3_3compat_glWindowPos2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2dv(v); +} + +void gl3_3compat_glWindowPos2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2d(x, y); +} + +void gl3_3compat_glSecondaryColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColorPointer(size, gltype, stride, pointer); +} + +void gl3_3compat_glSecondaryColor3usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3usv(v); +} + +void gl3_3compat_glSecondaryColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3us(red, green, blue); +} + +void gl3_3compat_glSecondaryColor3uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3uiv(v); +} + +void gl3_3compat_glSecondaryColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3ui(red, green, blue); +} + +void gl3_3compat_glSecondaryColor3ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3ubv(v); +} + +void gl3_3compat_glSecondaryColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3ub(red, green, blue); +} + +void gl3_3compat_glSecondaryColor3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3sv(v); +} + +void gl3_3compat_glSecondaryColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3s(red, green, blue); +} + +void gl3_3compat_glSecondaryColor3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3iv(v); +} + +void gl3_3compat_glSecondaryColor3i(void *_glfuncs, GLint red, GLint green, GLint blue) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3i(red, green, blue); +} + +void gl3_3compat_glSecondaryColor3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3fv(v); +} + +void gl3_3compat_glSecondaryColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3f(red, green, blue); +} + +void gl3_3compat_glSecondaryColor3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3dv(v); +} + +void gl3_3compat_glSecondaryColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3d(red, green, blue); +} + +void gl3_3compat_glSecondaryColor3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3bv(v); +} + +void gl3_3compat_glSecondaryColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3b(red, green, blue); +} + +void gl3_3compat_glFogCoordPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordPointer(gltype, stride, pointer); +} + +void gl3_3compat_glFogCoorddv(void *_glfuncs, const GLdouble* coord) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoorddv(coord); +} + +void gl3_3compat_glFogCoordd(void *_glfuncs, GLdouble coord) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordd(coord); +} + +void gl3_3compat_glFogCoordfv(void *_glfuncs, const GLfloat* coord) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordfv(coord); +} + +void gl3_3compat_glFogCoordf(void *_glfuncs, GLfloat coord) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordf(coord); +} + +void gl3_3compat_glVertexAttrib4usv(void *_glfuncs, GLuint index, const GLushort* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4usv(index, v); +} + +void gl3_3compat_glVertexAttrib4uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4uiv(index, v); +} + +void gl3_3compat_glVertexAttrib4ubv(void *_glfuncs, GLuint index, const GLubyte* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4ubv(index, v); +} + +void gl3_3compat_glVertexAttrib4sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4sv(index, v); +} + +void gl3_3compat_glVertexAttrib4s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4s(index, x, y, z, w); +} + +void gl3_3compat_glVertexAttrib4iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4iv(index, v); +} + +void gl3_3compat_glVertexAttrib4fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4fv(index, v); +} + +void gl3_3compat_glVertexAttrib4f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4f(index, x, y, z, w); +} + +void gl3_3compat_glVertexAttrib4dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4dv(index, v); +} + +void gl3_3compat_glVertexAttrib4d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4d(index, x, y, z, w); +} + +void gl3_3compat_glVertexAttrib4bv(void *_glfuncs, GLuint index, const GLbyte* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4bv(index, v); +} + +void gl3_3compat_glVertexAttrib4Nusv(void *_glfuncs, GLuint index, const GLushort* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nusv(index, v); +} + +void gl3_3compat_glVertexAttrib4Nuiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nuiv(index, v); +} + +void gl3_3compat_glVertexAttrib4Nubv(void *_glfuncs, GLuint index, const GLubyte* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nubv(index, v); +} + +void gl3_3compat_glVertexAttrib4Nub(void *_glfuncs, GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nub(index, x, y, z, w); +} + +void gl3_3compat_glVertexAttrib4Nsv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nsv(index, v); +} + +void gl3_3compat_glVertexAttrib4Niv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Niv(index, v); +} + +void gl3_3compat_glVertexAttrib4Nbv(void *_glfuncs, GLuint index, const GLbyte* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nbv(index, v); +} + +void gl3_3compat_glVertexAttrib3sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3sv(index, v); +} + +void gl3_3compat_glVertexAttrib3s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3s(index, x, y, z); +} + +void gl3_3compat_glVertexAttrib3fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3fv(index, v); +} + +void gl3_3compat_glVertexAttrib3f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3f(index, x, y, z); +} + +void gl3_3compat_glVertexAttrib3dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3dv(index, v); +} + +void gl3_3compat_glVertexAttrib3d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3d(index, x, y, z); +} + +void gl3_3compat_glVertexAttrib2sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2sv(index, v); +} + +void gl3_3compat_glVertexAttrib2s(void *_glfuncs, GLuint index, GLshort x, GLshort y) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2s(index, x, y); +} + +void gl3_3compat_glVertexAttrib2fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2fv(index, v); +} + +void gl3_3compat_glVertexAttrib2f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2f(index, x, y); +} + +void gl3_3compat_glVertexAttrib2dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2dv(index, v); +} + +void gl3_3compat_glVertexAttrib2d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2d(index, x, y); +} + +void gl3_3compat_glVertexAttrib1sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1sv(index, v); +} + +void gl3_3compat_glVertexAttrib1s(void *_glfuncs, GLuint index, GLshort x) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1s(index, x); +} + +void gl3_3compat_glVertexAttrib1fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1fv(index, v); +} + +void gl3_3compat_glVertexAttrib1f(void *_glfuncs, GLuint index, GLfloat x) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1f(index, x); +} + +void gl3_3compat_glVertexAttrib1dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1dv(index, v); +} + +void gl3_3compat_glVertexAttrib1d(void *_glfuncs, GLuint index, GLdouble x) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1d(index, x); +} + +void gl3_3compat_glVertexAttribI4usv(void *_glfuncs, GLuint index, const GLushort* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4usv(index, v); +} + +void gl3_3compat_glVertexAttribI4ubv(void *_glfuncs, GLuint index, const GLubyte* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4ubv(index, v); +} + +void gl3_3compat_glVertexAttribI4sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4sv(index, v); +} + +void gl3_3compat_glVertexAttribI4bv(void *_glfuncs, GLuint index, const GLbyte* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4bv(index, v); +} + +void gl3_3compat_glVertexAttribI4uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4uiv(index, v); +} + +void gl3_3compat_glVertexAttribI3uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI3uiv(index, v); +} + +void gl3_3compat_glVertexAttribI2uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI2uiv(index, v); +} + +void gl3_3compat_glVertexAttribI1uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI1uiv(index, v); +} + +void gl3_3compat_glVertexAttribI4iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4iv(index, v); +} + +void gl3_3compat_glVertexAttribI3iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI3iv(index, v); +} + +void gl3_3compat_glVertexAttribI2iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI2iv(index, v); +} + +void gl3_3compat_glVertexAttribI1iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI1iv(index, v); +} + +void gl3_3compat_glVertexAttribI4ui(void *_glfuncs, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4ui(index, x, y, z, w); +} + +void gl3_3compat_glVertexAttribI3ui(void *_glfuncs, GLuint index, GLuint x, GLuint y, GLuint z) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI3ui(index, x, y, z); +} + +void gl3_3compat_glVertexAttribI2ui(void *_glfuncs, GLuint index, GLuint x, GLuint y) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI2ui(index, x, y); +} + +void gl3_3compat_glVertexAttribI1ui(void *_glfuncs, GLuint index, GLuint x) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI1ui(index, x); +} + +void gl3_3compat_glVertexAttribI4i(void *_glfuncs, GLuint index, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4i(index, x, y, z, w); +} + +void gl3_3compat_glVertexAttribI3i(void *_glfuncs, GLuint index, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI3i(index, x, y, z); +} + +void gl3_3compat_glVertexAttribI2i(void *_glfuncs, GLuint index, GLint x, GLint y) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI2i(index, x, y); +} + +void gl3_3compat_glVertexAttribI1i(void *_glfuncs, GLuint index, GLint x) +{ + QOpenGLFunctions_3_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI1i(index, x); +} + diff --git a/gl/3.3compat/funcs.h b/gl/3.3compat/funcs.h new file mode 100644 index 00000000..bd774753 --- /dev/null +++ b/gl/3.3compat/funcs.h @@ -0,0 +1,787 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#ifndef __cplusplus +#include +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef char GLchar; +typedef signed char GLbyte; /* 1-byte signed */ +typedef short GLshort; /* 2-byte signed */ +typedef int GLint; /* 4-byte signed */ +typedef unsigned char GLubyte; /* 1-byte unsigned */ +typedef unsigned short GLushort; /* 2-byte unsigned */ +typedef unsigned int GLuint; /* 4-byte unsigned */ +typedef int GLsizei; /* 4-byte signed */ +typedef float GLfloat; /* single precision float */ +typedef float GLclampf; /* single precision float in [0,1] */ +typedef double GLdouble; /* double precision float */ +typedef double GLclampd; /* double precision float in [0,1] */ +typedef int64_t GLint64; +typedef uint64_t GLuint64; +typedef ptrdiff_t GLintptr; +typedef ptrdiff_t GLsizeiptr; +typedef ptrdiff_t GLintptrARB; +typedef ptrdiff_t GLsizeiptrARB; +typedef struct __GLsync *GLsync; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +void *gl3_3compat_funcs(); + +void gl3_3compat_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl3_3compat_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal); +GLboolean gl3_3compat_glIsEnabled(void *_glfuncs, GLenum cap); +void gl3_3compat_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params); +void gl3_3compat_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params); +void gl3_3compat_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_3compat_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl3_3compat_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels); +void gl3_3compat_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params); +void gl3_3compat_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params); +GLenum gl3_3compat_glGetError(void *_glfuncs); +void gl3_3compat_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params); +void gl3_3compat_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params); +void gl3_3compat_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels); +void gl3_3compat_glReadBuffer(void *_glfuncs, GLenum mode); +void gl3_3compat_glPixelStorei(void *_glfuncs, GLenum pname, GLint param); +void gl3_3compat_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param); +void gl3_3compat_glDepthFunc(void *_glfuncs, GLenum glfunc); +void gl3_3compat_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass); +void gl3_3compat_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask); +void gl3_3compat_glLogicOp(void *_glfuncs, GLenum opcode); +void gl3_3compat_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor); +void gl3_3compat_glFlush(void *_glfuncs); +void gl3_3compat_glFinish(void *_glfuncs); +void gl3_3compat_glEnable(void *_glfuncs, GLenum cap); +void gl3_3compat_glDisable(void *_glfuncs, GLenum cap); +void gl3_3compat_glDepthMask(void *_glfuncs, GLboolean flag); +void gl3_3compat_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +void gl3_3compat_glStencilMask(void *_glfuncs, GLuint mask); +void gl3_3compat_glClearDepth(void *_glfuncs, GLdouble depth); +void gl3_3compat_glClearStencil(void *_glfuncs, GLint s); +void gl3_3compat_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl3_3compat_glClear(void *_glfuncs, GLbitfield mask); +void gl3_3compat_glDrawBuffer(void *_glfuncs, GLenum mode); +void gl3_3compat_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_3compat_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_3compat_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl3_3compat_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl3_3compat_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl3_3compat_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl3_3compat_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl3_3compat_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode); +void gl3_3compat_glPointSize(void *_glfuncs, GLfloat size); +void gl3_3compat_glLineWidth(void *_glfuncs, GLfloat width); +void gl3_3compat_glHint(void *_glfuncs, GLenum target, GLenum mode); +void gl3_3compat_glFrontFace(void *_glfuncs, GLenum mode); +void gl3_3compat_glCullFace(void *_glfuncs, GLenum mode); +void gl3_3compat_glIndexubv(void *_glfuncs, const GLubyte* c); +void gl3_3compat_glIndexub(void *_glfuncs, GLubyte c); +GLboolean gl3_3compat_glIsTexture(void *_glfuncs, GLuint texture); +void gl3_3compat_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures); +void gl3_3compat_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures); +void gl3_3compat_glBindTexture(void *_glfuncs, GLenum target, GLuint texture); +void gl3_3compat_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_3compat_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_3compat_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl3_3compat_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +void gl3_3compat_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +void gl3_3compat_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border); +void gl3_3compat_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units); +void gl3_3compat_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl3_3compat_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count); +void gl3_3compat_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl3_3compat_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_3compat_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_3compat_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl3_3compat_glBlendEquation(void *_glfuncs, GLenum mode); +void gl3_3compat_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl3_3compat_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img); +void gl3_3compat_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl3_3compat_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl3_3compat_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl3_3compat_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data); +void gl3_3compat_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data); +void gl3_3compat_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data); +void gl3_3compat_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert); +void gl3_3compat_glActiveTexture(void *_glfuncs, GLenum texture); +void gl3_3compat_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params); +void gl3_3compat_glPointParameteri(void *_glfuncs, GLenum pname, GLint param); +void gl3_3compat_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl3_3compat_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param); +void gl3_3compat_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount); +void gl3_3compat_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +void gl3_3compat_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +GLboolean gl3_3compat_glUnmapBuffer(void *_glfuncs, GLenum target); +void gl3_3compat_glGetBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data); +void gl3_3compat_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data); +void gl3_3compat_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage); +GLboolean gl3_3compat_glIsBuffer(void *_glfuncs, GLuint buffer); +void gl3_3compat_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers); +void gl3_3compat_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers); +void gl3_3compat_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer); +void gl3_3compat_glGetQueryObjectuiv(void *_glfuncs, GLuint id, GLenum pname, GLuint* params); +void gl3_3compat_glGetQueryObjectiv(void *_glfuncs, GLuint id, GLenum pname, GLint* params); +void gl3_3compat_glGetQueryiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_3compat_glEndQuery(void *_glfuncs, GLenum target); +void gl3_3compat_glBeginQuery(void *_glfuncs, GLenum target, GLuint id); +GLboolean gl3_3compat_glIsQuery(void *_glfuncs, GLuint id); +void gl3_3compat_glDeleteQueries(void *_glfuncs, GLsizei n, const GLuint* ids); +void gl3_3compat_glGenQueries(void *_glfuncs, GLsizei n, GLuint* ids); +void gl3_3compat_glVertexAttribPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLboolean normalized, GLsizei stride, const GLvoid* offset); +void gl3_3compat_glValidateProgram(void *_glfuncs, GLuint program); +void gl3_3compat_glUniformMatrix4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_3compat_glUniformMatrix3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_3compat_glUniformMatrix2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_3compat_glUniform4iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl3_3compat_glUniform3iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl3_3compat_glUniform2iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl3_3compat_glUniform1iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl3_3compat_glUniform4fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl3_3compat_glUniform3fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl3_3compat_glUniform2fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl3_3compat_glUniform1fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl3_3compat_glUniform4i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +void gl3_3compat_glUniform3i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2); +void gl3_3compat_glUniform2i(void *_glfuncs, GLint location, GLint v0, GLint v1); +void gl3_3compat_glUniform1i(void *_glfuncs, GLint location, GLint v0); +void gl3_3compat_glUniform4f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +void gl3_3compat_glUniform3f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +void gl3_3compat_glUniform2f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1); +void gl3_3compat_glUniform1f(void *_glfuncs, GLint location, GLfloat v0); +void gl3_3compat_glUseProgram(void *_glfuncs, GLuint program); +void gl3_3compat_glShaderSource(void *_glfuncs, GLuint shader, GLsizei count, const GLchar** source, const GLint* length); +void gl3_3compat_glLinkProgram(void *_glfuncs, GLuint program); +GLboolean gl3_3compat_glIsShader(void *_glfuncs, GLuint shader); +GLboolean gl3_3compat_glIsProgram(void *_glfuncs, GLuint program); +void gl3_3compat_glGetVertexAttribiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params); +void gl3_3compat_glGetVertexAttribfv(void *_glfuncs, GLuint index, GLenum pname, GLfloat* params); +void gl3_3compat_glGetVertexAttribdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params); +void gl3_3compat_glGetUniformiv(void *_glfuncs, GLuint program, GLint location, GLint* params); +void gl3_3compat_glGetUniformfv(void *_glfuncs, GLuint program, GLint location, GLfloat* params); +GLint gl3_3compat_glGetUniformLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl3_3compat_glGetShaderSource(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source); +void gl3_3compat_glGetShaderInfoLog(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl3_3compat_glGetShaderiv(void *_glfuncs, GLuint shader, GLenum pname, GLint* params); +void gl3_3compat_glGetProgramInfoLog(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl3_3compat_glGetProgramiv(void *_glfuncs, GLuint program, GLenum pname, GLint* params); +GLint gl3_3compat_glGetAttribLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl3_3compat_glGetAttachedShaders(void *_glfuncs, GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj); +void gl3_3compat_glGetActiveUniform(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name); +void gl3_3compat_glGetActiveAttrib(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name); +void gl3_3compat_glEnableVertexAttribArray(void *_glfuncs, GLuint index); +void gl3_3compat_glDisableVertexAttribArray(void *_glfuncs, GLuint index); +void gl3_3compat_glDetachShader(void *_glfuncs, GLuint program, GLuint shader); +void gl3_3compat_glDeleteShader(void *_glfuncs, GLuint shader); +void gl3_3compat_glDeleteProgram(void *_glfuncs, GLuint program); +GLuint gl3_3compat_glCreateShader(void *_glfuncs, GLenum gltype); +GLuint gl3_3compat_glCreateProgram(void *_glfuncs); +void gl3_3compat_glCompileShader(void *_glfuncs, GLuint shader); +void gl3_3compat_glBindAttribLocation(void *_glfuncs, GLuint program, GLuint index, const GLchar* name); +void gl3_3compat_glAttachShader(void *_glfuncs, GLuint program, GLuint shader); +void gl3_3compat_glStencilMaskSeparate(void *_glfuncs, GLenum face, GLuint mask); +void gl3_3compat_glStencilFuncSeparate(void *_glfuncs, GLenum face, GLenum glfunc, GLint ref, GLuint mask); +void gl3_3compat_glStencilOpSeparate(void *_glfuncs, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +void gl3_3compat_glDrawBuffers(void *_glfuncs, GLsizei n, const GLenum* bufs); +void gl3_3compat_glBlendEquationSeparate(void *_glfuncs, GLenum modeRGB, GLenum modeAlpha); +void gl3_3compat_glUniformMatrix4x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_3compat_glUniformMatrix3x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_3compat_glUniformMatrix4x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_3compat_glUniformMatrix2x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_3compat_glUniformMatrix3x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_3compat_glUniformMatrix2x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +GLboolean gl3_3compat_glIsVertexArray(void *_glfuncs, GLuint array); +void gl3_3compat_glGenVertexArrays(void *_glfuncs, GLsizei n, GLuint* arrays); +void gl3_3compat_glDeleteVertexArrays(void *_glfuncs, GLsizei n, const GLuint* arrays); +void gl3_3compat_glBindVertexArray(void *_glfuncs, GLuint array); +void gl3_3compat_glFlushMappedBufferRange(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr length); +void gl3_3compat_glFramebufferTextureLayer(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +void gl3_3compat_glRenderbufferStorageMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height); +void gl3_3compat_glBlitFramebuffer(void *_glfuncs, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +void gl3_3compat_glGenerateMipmap(void *_glfuncs, GLenum target); +void gl3_3compat_glGetFramebufferAttachmentParameteriv(void *_glfuncs, GLenum target, GLenum attachment, GLenum pname, GLint* params); +void gl3_3compat_glFramebufferRenderbuffer(void *_glfuncs, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +void gl3_3compat_glFramebufferTexture3D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +void gl3_3compat_glFramebufferTexture2D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +void gl3_3compat_glFramebufferTexture1D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLenum gl3_3compat_glCheckFramebufferStatus(void *_glfuncs, GLenum target); +void gl3_3compat_glGenFramebuffers(void *_glfuncs, GLsizei n, GLuint* framebuffers); +void gl3_3compat_glDeleteFramebuffers(void *_glfuncs, GLsizei n, const GLuint* framebuffers); +void gl3_3compat_glBindFramebuffer(void *_glfuncs, GLenum target, GLuint framebuffer); +GLboolean gl3_3compat_glIsFramebuffer(void *_glfuncs, GLuint framebuffer); +void gl3_3compat_glGetRenderbufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_3compat_glRenderbufferStorage(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height); +void gl3_3compat_glGenRenderbuffers(void *_glfuncs, GLsizei n, GLuint* renderbuffers); +void gl3_3compat_glDeleteRenderbuffers(void *_glfuncs, GLsizei n, const GLuint* renderbuffers); +void gl3_3compat_glBindRenderbuffer(void *_glfuncs, GLenum target, GLuint renderbuffer); +GLboolean gl3_3compat_glIsRenderbuffer(void *_glfuncs, GLuint renderbuffer); +void gl3_3compat_glClearBufferfi(void *_glfuncs, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); +void gl3_3compat_glClearBufferfv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLfloat* value); +void gl3_3compat_glClearBufferuiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLuint* value); +void gl3_3compat_glClearBufferiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLint* value); +void gl3_3compat_glGetTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, GLuint* params); +void gl3_3compat_glGetTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_3compat_glTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, const GLuint* params); +void gl3_3compat_glTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl3_3compat_glUniform4uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl3_3compat_glUniform3uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl3_3compat_glUniform2uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl3_3compat_glUniform1uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl3_3compat_glUniform4ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +void gl3_3compat_glUniform3ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2); +void gl3_3compat_glUniform2ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1); +void gl3_3compat_glUniform1ui(void *_glfuncs, GLint location, GLuint v0); +GLint gl3_3compat_glGetFragDataLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl3_3compat_glBindFragDataLocation(void *_glfuncs, GLuint program, GLuint color, const GLchar* name); +void gl3_3compat_glGetUniformuiv(void *_glfuncs, GLuint program, GLint location, GLuint* params); +void gl3_3compat_glGetVertexAttribIuiv(void *_glfuncs, GLuint index, GLenum pname, GLuint* params); +void gl3_3compat_glGetVertexAttribIiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params); +void gl3_3compat_glVertexAttribIPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl3_3compat_glEndConditionalRender(void *_glfuncs); +void gl3_3compat_glBeginConditionalRender(void *_glfuncs, GLuint id, GLenum mode); +void gl3_3compat_glClampColor(void *_glfuncs, GLenum target, GLenum clamp); +void gl3_3compat_glGetTransformFeedbackVarying(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* gltype, GLchar* name); +void gl3_3compat_glBindBufferBase(void *_glfuncs, GLenum target, GLuint index, GLuint buffer); +void gl3_3compat_glBindBufferRange(void *_glfuncs, GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +void gl3_3compat_glEndTransformFeedback(void *_glfuncs); +void gl3_3compat_glBeginTransformFeedback(void *_glfuncs, GLenum primitiveMode); +GLboolean gl3_3compat_glIsEnabledi(void *_glfuncs, GLenum target, GLuint index); +void gl3_3compat_glDisablei(void *_glfuncs, GLenum target, GLuint index); +void gl3_3compat_glEnablei(void *_glfuncs, GLenum target, GLuint index); +void gl3_3compat_glGetIntegeri_v(void *_glfuncs, GLenum target, GLuint index, GLint* data); +void gl3_3compat_glGetBooleani_v(void *_glfuncs, GLenum target, GLuint index, GLboolean* data); +void gl3_3compat_glColorMaski(void *_glfuncs, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +void gl3_3compat_glCopyBufferSubData(void *_glfuncs, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +void gl3_3compat_glUniformBlockBinding(void *_glfuncs, GLuint program, GLuint v0, GLuint v1); +void gl3_3compat_glGetActiveUniformBlockName(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName); +void gl3_3compat_glGetActiveUniformBlockiv(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params); +GLuint gl3_3compat_glGetUniformBlockIndex(void *_glfuncs, GLuint program, const GLchar* uniformBlockName); +void gl3_3compat_glGetActiveUniformName(void *_glfuncs, GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName); +void gl3_3compat_glGetActiveUniformsiv(void *_glfuncs, GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params); +void gl3_3compat_glPrimitiveRestartIndex(void *_glfuncs, GLuint index); +void gl3_3compat_glTexBuffer(void *_glfuncs, GLenum target, GLenum internalFormat, GLuint buffer); +void gl3_3compat_glDrawElementsInstanced(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount); +void gl3_3compat_glDrawArraysInstanced(void *_glfuncs, GLenum mode, GLint first, GLsizei count, GLsizei instancecount); +void gl3_3compat_glSampleMaski(void *_glfuncs, GLuint index, GLbitfield mask); +void gl3_3compat_glGetMultisamplefv(void *_glfuncs, GLenum pname, GLuint index, GLfloat* val); +void gl3_3compat_glTexImage3DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); +void gl3_3compat_glTexImage2DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +void gl3_3compat_glGetSynciv(void *_glfuncs, GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values); +void gl3_3compat_glGetInteger64v(void *_glfuncs, GLenum pname, GLint64* params); +void gl3_3compat_glWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout); +GLenum gl3_3compat_glClientWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout); +void gl3_3compat_glDeleteSync(void *_glfuncs, GLsync sync); +GLboolean gl3_3compat_glIsSync(void *_glfuncs, GLsync sync); +GLsync gl3_3compat_glFenceSync(void *_glfuncs, GLenum condition, GLbitfield flags); +void gl3_3compat_glProvokingVertex(void *_glfuncs, GLenum mode); +void gl3_3compat_glDrawElementsInstancedBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLint basevertex); +void gl3_3compat_glDrawRangeElementsBaseVertex(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex); +void gl3_3compat_glDrawElementsBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex); +void gl3_3compat_glFramebufferTexture(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level); +void gl3_3compat_glGetBufferParameteri64v(void *_glfuncs, GLenum target, GLenum pname, GLint64* params); +void gl3_3compat_glGetInteger64i_v(void *_glfuncs, GLenum target, GLuint index, GLint64* data); +void gl3_3compat_glVertexAttribP4uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl3_3compat_glVertexAttribP4ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl3_3compat_glVertexAttribP3uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl3_3compat_glVertexAttribP3ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl3_3compat_glVertexAttribP2uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl3_3compat_glVertexAttribP2ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl3_3compat_glVertexAttribP1uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl3_3compat_glVertexAttribP1ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl3_3compat_glSecondaryColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color); +void gl3_3compat_glSecondaryColorP3ui(void *_glfuncs, GLenum gltype, GLuint color); +void gl3_3compat_glColorP4uiv(void *_glfuncs, GLenum gltype, const GLuint* color); +void gl3_3compat_glColorP4ui(void *_glfuncs, GLenum gltype, GLuint color); +void gl3_3compat_glColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color); +void gl3_3compat_glColorP3ui(void *_glfuncs, GLenum gltype, GLuint color); +void gl3_3compat_glNormalP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl3_3compat_glNormalP3ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl3_3compat_glMultiTexCoordP4uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl3_3compat_glMultiTexCoordP4ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl3_3compat_glMultiTexCoordP3uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl3_3compat_glMultiTexCoordP3ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl3_3compat_glMultiTexCoordP2uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl3_3compat_glMultiTexCoordP2ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl3_3compat_glMultiTexCoordP1uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl3_3compat_glMultiTexCoordP1ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl3_3compat_glTexCoordP4uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl3_3compat_glTexCoordP4ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl3_3compat_glTexCoordP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl3_3compat_glTexCoordP3ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl3_3compat_glTexCoordP2uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl3_3compat_glTexCoordP2ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl3_3compat_glTexCoordP1uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl3_3compat_glTexCoordP1ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl3_3compat_glVertexP4uiv(void *_glfuncs, GLenum gltype, const GLuint* value); +void gl3_3compat_glVertexP4ui(void *_glfuncs, GLenum gltype, GLuint value); +void gl3_3compat_glVertexP3uiv(void *_glfuncs, GLenum gltype, const GLuint* value); +void gl3_3compat_glVertexP3ui(void *_glfuncs, GLenum gltype, GLuint value); +void gl3_3compat_glVertexP2uiv(void *_glfuncs, GLenum gltype, const GLuint* value); +void gl3_3compat_glVertexP2ui(void *_glfuncs, GLenum gltype, GLuint value); +void gl3_3compat_glGetQueryObjectui64v(void *_glfuncs, GLuint id, GLenum pname, GLuint64* params); +void gl3_3compat_glGetQueryObjecti64v(void *_glfuncs, GLuint id, GLenum pname, GLint64* params); +void gl3_3compat_glQueryCounter(void *_glfuncs, GLuint id, GLenum target); +void gl3_3compat_glGetSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, GLuint* params); +void gl3_3compat_glGetSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat* params); +void gl3_3compat_glGetSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params); +void gl3_3compat_glGetSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params); +void gl3_3compat_glSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLuint* param); +void gl3_3compat_glSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param); +void gl3_3compat_glSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, const GLfloat* param); +void gl3_3compat_glSamplerParameterf(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat param); +void gl3_3compat_glSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param); +void gl3_3compat_glSamplerParameteri(void *_glfuncs, GLuint sampler, GLenum pname, GLint param); +void gl3_3compat_glBindSampler(void *_glfuncs, GLuint unit, GLuint sampler); +GLboolean gl3_3compat_glIsSampler(void *_glfuncs, GLuint sampler); +void gl3_3compat_glDeleteSamplers(void *_glfuncs, GLsizei count, const GLuint* samplers); +void gl3_3compat_glGenSamplers(void *_glfuncs, GLsizei count, GLuint* samplers); +GLint gl3_3compat_glGetFragDataIndex(void *_glfuncs, GLuint program, const GLchar* name); +void gl3_3compat_glBindFragDataLocationIndexed(void *_glfuncs, GLuint program, GLuint colorNumber, GLuint index, const GLchar* name); +void gl3_3compat_glVertexAttribDivisor(void *_glfuncs, GLuint index, GLuint divisor); +void gl3_3compat_glTranslatef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl3_3compat_glTranslated(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl3_3compat_glScalef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl3_3compat_glScaled(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl3_3compat_glRotatef(void *_glfuncs, GLfloat angle, GLfloat x, GLfloat y, GLfloat z); +void gl3_3compat_glRotated(void *_glfuncs, GLdouble angle, GLdouble x, GLdouble y, GLdouble z); +void gl3_3compat_glPushMatrix(void *_glfuncs); +void gl3_3compat_glPopMatrix(void *_glfuncs); +void gl3_3compat_glOrtho(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +void gl3_3compat_glMultMatrixd(void *_glfuncs, const GLdouble* m); +void gl3_3compat_glMultMatrixf(void *_glfuncs, const GLfloat* m); +void gl3_3compat_glMatrixMode(void *_glfuncs, GLenum mode); +void gl3_3compat_glLoadMatrixd(void *_glfuncs, const GLdouble* m); +void gl3_3compat_glLoadMatrixf(void *_glfuncs, const GLfloat* m); +void gl3_3compat_glLoadIdentity(void *_glfuncs); +void gl3_3compat_glFrustum(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +GLboolean gl3_3compat_glIsList(void *_glfuncs, GLuint list); +void gl3_3compat_glGetTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, GLint* params); +void gl3_3compat_glGetTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, GLfloat* params); +void gl3_3compat_glGetTexGendv(void *_glfuncs, GLenum coord, GLenum pname, GLdouble* params); +void gl3_3compat_glGetTexEnviv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_3compat_glGetTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl3_3compat_glGetPolygonStipple(void *_glfuncs, GLubyte* mask); +void gl3_3compat_glGetPixelMapusv(void *_glfuncs, GLenum glmap, GLushort* values); +void gl3_3compat_glGetPixelMapuiv(void *_glfuncs, GLenum glmap, GLuint* values); +void gl3_3compat_glGetPixelMapfv(void *_glfuncs, GLenum glmap, GLfloat* values); +void gl3_3compat_glGetMaterialiv(void *_glfuncs, GLenum face, GLenum pname, GLint* params); +void gl3_3compat_glGetMaterialfv(void *_glfuncs, GLenum face, GLenum pname, GLfloat* params); +void gl3_3compat_glGetMapiv(void *_glfuncs, GLenum target, GLenum query, GLint* v); +void gl3_3compat_glGetMapfv(void *_glfuncs, GLenum target, GLenum query, GLfloat* v); +void gl3_3compat_glGetMapdv(void *_glfuncs, GLenum target, GLenum query, GLdouble* v); +void gl3_3compat_glGetLightiv(void *_glfuncs, GLenum light, GLenum pname, GLint* params); +void gl3_3compat_glGetLightfv(void *_glfuncs, GLenum light, GLenum pname, GLfloat* params); +void gl3_3compat_glGetClipPlane(void *_glfuncs, GLenum plane, GLdouble* equation); +void gl3_3compat_glDrawPixels(void *_glfuncs, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_3compat_glCopyPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum gltype); +void gl3_3compat_glPixelMapusv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLushort* values); +void gl3_3compat_glPixelMapuiv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLuint* values); +void gl3_3compat_glPixelMapfv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLfloat* values); +void gl3_3compat_glPixelTransferi(void *_glfuncs, GLenum pname, GLint param); +void gl3_3compat_glPixelTransferf(void *_glfuncs, GLenum pname, GLfloat param); +void gl3_3compat_glPixelZoom(void *_glfuncs, GLfloat xfactor, GLfloat yfactor); +void gl3_3compat_glAlphaFunc(void *_glfuncs, GLenum glfunc, GLfloat ref); +void gl3_3compat_glEvalPoint2(void *_glfuncs, GLint i, GLint j); +void gl3_3compat_glEvalMesh2(void *_glfuncs, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); +void gl3_3compat_glEvalPoint1(void *_glfuncs, GLint i); +void gl3_3compat_glEvalMesh1(void *_glfuncs, GLenum mode, GLint i1, GLint i2); +void gl3_3compat_glEvalCoord2fv(void *_glfuncs, const GLfloat* u); +void gl3_3compat_glEvalCoord2f(void *_glfuncs, GLfloat u, GLfloat v); +void gl3_3compat_glEvalCoord2dv(void *_glfuncs, const GLdouble* u); +void gl3_3compat_glEvalCoord2d(void *_glfuncs, GLdouble u, GLdouble v); +void gl3_3compat_glEvalCoord1fv(void *_glfuncs, const GLfloat* u); +void gl3_3compat_glEvalCoord1f(void *_glfuncs, GLfloat u); +void gl3_3compat_glEvalCoord1dv(void *_glfuncs, const GLdouble* u); +void gl3_3compat_glEvalCoord1d(void *_glfuncs, GLdouble u); +void gl3_3compat_glMapGrid2f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); +void gl3_3compat_glMapGrid2d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); +void gl3_3compat_glMapGrid1f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2); +void gl3_3compat_glMapGrid1d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2); +void gl3_3compat_glMap2f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points); +void gl3_3compat_glMap2d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points); +void gl3_3compat_glMap1f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points); +void gl3_3compat_glMap1d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points); +void gl3_3compat_glPushAttrib(void *_glfuncs, GLbitfield mask); +void gl3_3compat_glPopAttrib(void *_glfuncs); +void gl3_3compat_glAccum(void *_glfuncs, GLenum op, GLfloat value); +void gl3_3compat_glIndexMask(void *_glfuncs, GLuint mask); +void gl3_3compat_glClearIndex(void *_glfuncs, GLfloat c); +void gl3_3compat_glClearAccum(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl3_3compat_glPushName(void *_glfuncs, GLuint name); +void gl3_3compat_glPopName(void *_glfuncs); +void gl3_3compat_glPassThrough(void *_glfuncs, GLfloat token); +void gl3_3compat_glLoadName(void *_glfuncs, GLuint name); +void gl3_3compat_glInitNames(void *_glfuncs); +GLint gl3_3compat_glRenderMode(void *_glfuncs, GLenum mode); +void gl3_3compat_glSelectBuffer(void *_glfuncs, GLsizei size, GLuint* buffer); +void gl3_3compat_glFeedbackBuffer(void *_glfuncs, GLsizei size, GLenum gltype, GLfloat* buffer); +void gl3_3compat_glTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, const GLint* params); +void gl3_3compat_glTexGeni(void *_glfuncs, GLenum coord, GLenum pname, GLint param); +void gl3_3compat_glTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, const GLfloat* params); +void gl3_3compat_glTexGenf(void *_glfuncs, GLenum coord, GLenum pname, GLfloat param); +void gl3_3compat_glTexGendv(void *_glfuncs, GLenum coord, GLenum pname, const GLdouble* params); +void gl3_3compat_glTexGend(void *_glfuncs, GLenum coord, GLenum pname, GLdouble param); +void gl3_3compat_glTexEnviv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl3_3compat_glTexEnvi(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl3_3compat_glTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl3_3compat_glTexEnvf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl3_3compat_glShadeModel(void *_glfuncs, GLenum mode); +void gl3_3compat_glPolygonStipple(void *_glfuncs, const GLubyte* mask); +void gl3_3compat_glMaterialiv(void *_glfuncs, GLenum face, GLenum pname, const GLint* params); +void gl3_3compat_glMateriali(void *_glfuncs, GLenum face, GLenum pname, GLint param); +void gl3_3compat_glMaterialfv(void *_glfuncs, GLenum face, GLenum pname, const GLfloat* params); +void gl3_3compat_glMaterialf(void *_glfuncs, GLenum face, GLenum pname, GLfloat param); +void gl3_3compat_glLineStipple(void *_glfuncs, GLint factor, GLushort pattern); +void gl3_3compat_glLightModeliv(void *_glfuncs, GLenum pname, const GLint* params); +void gl3_3compat_glLightModeli(void *_glfuncs, GLenum pname, GLint param); +void gl3_3compat_glLightModelfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl3_3compat_glLightModelf(void *_glfuncs, GLenum pname, GLfloat param); +void gl3_3compat_glLightiv(void *_glfuncs, GLenum light, GLenum pname, const GLint* params); +void gl3_3compat_glLighti(void *_glfuncs, GLenum light, GLenum pname, GLint param); +void gl3_3compat_glLightfv(void *_glfuncs, GLenum light, GLenum pname, const GLfloat* params); +void gl3_3compat_glLightf(void *_glfuncs, GLenum light, GLenum pname, GLfloat param); +void gl3_3compat_glFogiv(void *_glfuncs, GLenum pname, const GLint* params); +void gl3_3compat_glFogi(void *_glfuncs, GLenum pname, GLint param); +void gl3_3compat_glFogfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl3_3compat_glFogf(void *_glfuncs, GLenum pname, GLfloat param); +void gl3_3compat_glColorMaterial(void *_glfuncs, GLenum face, GLenum mode); +void gl3_3compat_glClipPlane(void *_glfuncs, GLenum plane, const GLdouble* equation); +void gl3_3compat_glVertex4sv(void *_glfuncs, const GLshort* v); +void gl3_3compat_glVertex4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w); +void gl3_3compat_glVertex4iv(void *_glfuncs, const GLint* v); +void gl3_3compat_glVertex4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w); +void gl3_3compat_glVertex4fv(void *_glfuncs, const GLfloat* v); +void gl3_3compat_glVertex4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl3_3compat_glVertex4dv(void *_glfuncs, const GLdouble* v); +void gl3_3compat_glVertex4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl3_3compat_glVertex3sv(void *_glfuncs, const GLshort* v); +void gl3_3compat_glVertex3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl3_3compat_glVertex3iv(void *_glfuncs, const GLint* v); +void gl3_3compat_glVertex3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl3_3compat_glVertex3fv(void *_glfuncs, const GLfloat* v); +void gl3_3compat_glVertex3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl3_3compat_glVertex3dv(void *_glfuncs, const GLdouble* v); +void gl3_3compat_glVertex3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl3_3compat_glVertex2sv(void *_glfuncs, const GLshort* v); +void gl3_3compat_glVertex2s(void *_glfuncs, GLshort x, GLshort y); +void gl3_3compat_glVertex2iv(void *_glfuncs, const GLint* v); +void gl3_3compat_glVertex2i(void *_glfuncs, GLint x, GLint y); +void gl3_3compat_glVertex2fv(void *_glfuncs, const GLfloat* v); +void gl3_3compat_glVertex2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl3_3compat_glVertex2dv(void *_glfuncs, const GLdouble* v); +void gl3_3compat_glVertex2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl3_3compat_glTexCoord4sv(void *_glfuncs, const GLshort* v); +void gl3_3compat_glTexCoord4s(void *_glfuncs, GLshort s, GLshort t, GLshort r, GLshort q); +void gl3_3compat_glTexCoord4iv(void *_glfuncs, const GLint* v); +void gl3_3compat_glTexCoord4i(void *_glfuncs, GLint s, GLint t, GLint r, GLint q); +void gl3_3compat_glTexCoord4fv(void *_glfuncs, const GLfloat* v); +void gl3_3compat_glTexCoord4f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +void gl3_3compat_glTexCoord4dv(void *_glfuncs, const GLdouble* v); +void gl3_3compat_glTexCoord4d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +void gl3_3compat_glTexCoord3sv(void *_glfuncs, const GLshort* v); +void gl3_3compat_glTexCoord3s(void *_glfuncs, GLshort s, GLshort t, GLshort r); +void gl3_3compat_glTexCoord3iv(void *_glfuncs, const GLint* v); +void gl3_3compat_glTexCoord3i(void *_glfuncs, GLint s, GLint t, GLint r); +void gl3_3compat_glTexCoord3fv(void *_glfuncs, const GLfloat* v); +void gl3_3compat_glTexCoord3f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r); +void gl3_3compat_glTexCoord3dv(void *_glfuncs, const GLdouble* v); +void gl3_3compat_glTexCoord3d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r); +void gl3_3compat_glTexCoord2sv(void *_glfuncs, const GLshort* v); +void gl3_3compat_glTexCoord2s(void *_glfuncs, GLshort s, GLshort t); +void gl3_3compat_glTexCoord2iv(void *_glfuncs, const GLint* v); +void gl3_3compat_glTexCoord2i(void *_glfuncs, GLint s, GLint t); +void gl3_3compat_glTexCoord2fv(void *_glfuncs, const GLfloat* v); +void gl3_3compat_glTexCoord2f(void *_glfuncs, GLfloat s, GLfloat t); +void gl3_3compat_glTexCoord2dv(void *_glfuncs, const GLdouble* v); +void gl3_3compat_glTexCoord2d(void *_glfuncs, GLdouble s, GLdouble t); +void gl3_3compat_glTexCoord1sv(void *_glfuncs, const GLshort* v); +void gl3_3compat_glTexCoord1s(void *_glfuncs, GLshort s); +void gl3_3compat_glTexCoord1iv(void *_glfuncs, const GLint* v); +void gl3_3compat_glTexCoord1i(void *_glfuncs, GLint s); +void gl3_3compat_glTexCoord1fv(void *_glfuncs, const GLfloat* v); +void gl3_3compat_glTexCoord1f(void *_glfuncs, GLfloat s); +void gl3_3compat_glTexCoord1dv(void *_glfuncs, const GLdouble* v); +void gl3_3compat_glTexCoord1d(void *_glfuncs, GLdouble s); +void gl3_3compat_glRectsv(void *_glfuncs, const GLshort* v1, const GLshort* v2); +void gl3_3compat_glRects(void *_glfuncs, GLshort x1, GLshort y1, GLshort x2, GLshort y2); +void gl3_3compat_glRectiv(void *_glfuncs, const GLint* v1, const GLint* v2); +void gl3_3compat_glRecti(void *_glfuncs, GLint x1, GLint y1, GLint x2, GLint y2); +void gl3_3compat_glRectfv(void *_glfuncs, const GLfloat* v1, const GLfloat* v2); +void gl3_3compat_glRectf(void *_glfuncs, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); +void gl3_3compat_glRectdv(void *_glfuncs, const GLdouble* v1, const GLdouble* v2); +void gl3_3compat_glRectd(void *_glfuncs, GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); +void gl3_3compat_glRasterPos4sv(void *_glfuncs, const GLshort* v); +void gl3_3compat_glRasterPos4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w); +void gl3_3compat_glRasterPos4iv(void *_glfuncs, const GLint* v); +void gl3_3compat_glRasterPos4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w); +void gl3_3compat_glRasterPos4fv(void *_glfuncs, const GLfloat* v); +void gl3_3compat_glRasterPos4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl3_3compat_glRasterPos4dv(void *_glfuncs, const GLdouble* v); +void gl3_3compat_glRasterPos4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl3_3compat_glRasterPos3sv(void *_glfuncs, const GLshort* v); +void gl3_3compat_glRasterPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl3_3compat_glRasterPos3iv(void *_glfuncs, const GLint* v); +void gl3_3compat_glRasterPos3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl3_3compat_glRasterPos3fv(void *_glfuncs, const GLfloat* v); +void gl3_3compat_glRasterPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl3_3compat_glRasterPos3dv(void *_glfuncs, const GLdouble* v); +void gl3_3compat_glRasterPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl3_3compat_glRasterPos2sv(void *_glfuncs, const GLshort* v); +void gl3_3compat_glRasterPos2s(void *_glfuncs, GLshort x, GLshort y); +void gl3_3compat_glRasterPos2iv(void *_glfuncs, const GLint* v); +void gl3_3compat_glRasterPos2i(void *_glfuncs, GLint x, GLint y); +void gl3_3compat_glRasterPos2fv(void *_glfuncs, const GLfloat* v); +void gl3_3compat_glRasterPos2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl3_3compat_glRasterPos2dv(void *_glfuncs, const GLdouble* v); +void gl3_3compat_glRasterPos2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl3_3compat_glNormal3sv(void *_glfuncs, const GLshort* v); +void gl3_3compat_glNormal3s(void *_glfuncs, GLshort nx, GLshort ny, GLshort nz); +void gl3_3compat_glNormal3iv(void *_glfuncs, const GLint* v); +void gl3_3compat_glNormal3i(void *_glfuncs, GLint nx, GLint ny, GLint nz); +void gl3_3compat_glNormal3fv(void *_glfuncs, const GLfloat* v); +void gl3_3compat_glNormal3f(void *_glfuncs, GLfloat nx, GLfloat ny, GLfloat nz); +void gl3_3compat_glNormal3dv(void *_glfuncs, const GLdouble* v); +void gl3_3compat_glNormal3d(void *_glfuncs, GLdouble nx, GLdouble ny, GLdouble nz); +void gl3_3compat_glNormal3bv(void *_glfuncs, const GLbyte* v); +void gl3_3compat_glNormal3b(void *_glfuncs, GLbyte nx, GLbyte ny, GLbyte nz); +void gl3_3compat_glIndexsv(void *_glfuncs, const GLshort* c); +void gl3_3compat_glIndexs(void *_glfuncs, GLshort c); +void gl3_3compat_glIndexiv(void *_glfuncs, const GLint* c); +void gl3_3compat_glIndexi(void *_glfuncs, GLint c); +void gl3_3compat_glIndexfv(void *_glfuncs, const GLfloat* c); +void gl3_3compat_glIndexf(void *_glfuncs, GLfloat c); +void gl3_3compat_glIndexdv(void *_glfuncs, const GLdouble* c); +void gl3_3compat_glIndexd(void *_glfuncs, GLdouble c); +void gl3_3compat_glEnd(void *_glfuncs); +void gl3_3compat_glEdgeFlagv(void *_glfuncs, const GLboolean* flag); +void gl3_3compat_glEdgeFlag(void *_glfuncs, GLboolean flag); +void gl3_3compat_glColor4usv(void *_glfuncs, const GLushort* v); +void gl3_3compat_glColor4us(void *_glfuncs, GLushort red, GLushort green, GLushort blue, GLushort alpha); +void gl3_3compat_glColor4uiv(void *_glfuncs, const GLuint* v); +void gl3_3compat_glColor4ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue, GLuint alpha); +void gl3_3compat_glColor4ubv(void *_glfuncs, const GLubyte* v); +void gl3_3compat_glColor4ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); +void gl3_3compat_glColor4sv(void *_glfuncs, const GLshort* v); +void gl3_3compat_glColor4s(void *_glfuncs, GLshort red, GLshort green, GLshort blue, GLshort alpha); +void gl3_3compat_glColor4iv(void *_glfuncs, const GLint* v); +void gl3_3compat_glColor4i(void *_glfuncs, GLint red, GLint green, GLint blue, GLint alpha); +void gl3_3compat_glColor4fv(void *_glfuncs, const GLfloat* v); +void gl3_3compat_glColor4f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl3_3compat_glColor4dv(void *_glfuncs, const GLdouble* v); +void gl3_3compat_glColor4d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); +void gl3_3compat_glColor4bv(void *_glfuncs, const GLbyte* v); +void gl3_3compat_glColor4b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); +void gl3_3compat_glColor3usv(void *_glfuncs, const GLushort* v); +void gl3_3compat_glColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue); +void gl3_3compat_glColor3uiv(void *_glfuncs, const GLuint* v); +void gl3_3compat_glColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue); +void gl3_3compat_glColor3ubv(void *_glfuncs, const GLubyte* v); +void gl3_3compat_glColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue); +void gl3_3compat_glColor3sv(void *_glfuncs, const GLshort* v); +void gl3_3compat_glColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue); +void gl3_3compat_glColor3iv(void *_glfuncs, const GLint* v); +void gl3_3compat_glColor3i(void *_glfuncs, GLint red, GLint green, GLint blue); +void gl3_3compat_glColor3fv(void *_glfuncs, const GLfloat* v); +void gl3_3compat_glColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue); +void gl3_3compat_glColor3dv(void *_glfuncs, const GLdouble* v); +void gl3_3compat_glColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue); +void gl3_3compat_glColor3bv(void *_glfuncs, const GLbyte* v); +void gl3_3compat_glColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue); +void gl3_3compat_glBitmap(void *_glfuncs, GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap); +void gl3_3compat_glBegin(void *_glfuncs, GLenum mode); +void gl3_3compat_glListBase(void *_glfuncs, GLuint base); +GLuint gl3_3compat_glGenLists(void *_glfuncs, GLsizei range_); +void gl3_3compat_glDeleteLists(void *_glfuncs, GLuint list, GLsizei range_); +void gl3_3compat_glCallLists(void *_glfuncs, GLsizei n, GLenum gltype, const GLvoid* lists); +void gl3_3compat_glCallList(void *_glfuncs, GLuint list); +void gl3_3compat_glEndList(void *_glfuncs); +void gl3_3compat_glNewList(void *_glfuncs, GLuint list, GLenum mode); +void gl3_3compat_glPushClientAttrib(void *_glfuncs, GLbitfield mask); +void gl3_3compat_glPopClientAttrib(void *_glfuncs); +void gl3_3compat_glPrioritizeTextures(void *_glfuncs, GLsizei n, const GLuint* textures, const GLfloat* priorities); +GLboolean gl3_3compat_glAreTexturesResident(void *_glfuncs, GLsizei n, const GLuint* textures, GLboolean* residences); +void gl3_3compat_glVertexPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl3_3compat_glTexCoordPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl3_3compat_glNormalPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl3_3compat_glInterleavedArrays(void *_glfuncs, GLenum format, GLsizei stride, const GLvoid* pointer); +void gl3_3compat_glIndexPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl3_3compat_glEnableClientState(void *_glfuncs, GLenum array); +void gl3_3compat_glEdgeFlagPointer(void *_glfuncs, GLsizei stride, const GLvoid* pointer); +void gl3_3compat_glDisableClientState(void *_glfuncs, GLenum array); +void gl3_3compat_glColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl3_3compat_glArrayElement(void *_glfuncs, GLint i); +void gl3_3compat_glResetMinmax(void *_glfuncs, GLenum target); +void gl3_3compat_glResetHistogram(void *_glfuncs, GLenum target); +void gl3_3compat_glMinmax(void *_glfuncs, GLenum target, GLenum internalFormat, GLboolean sink); +void gl3_3compat_glHistogram(void *_glfuncs, GLenum target, GLsizei width, GLenum internalFormat, GLboolean sink); +void gl3_3compat_glGetMinmaxParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_3compat_glGetMinmaxParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl3_3compat_glGetMinmax(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values); +void gl3_3compat_glGetHistogramParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_3compat_glGetHistogramParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl3_3compat_glGetHistogram(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values); +void gl3_3compat_glSeparableFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* row, const GLvoid* column); +void gl3_3compat_glGetSeparableFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* row, GLvoid* column, GLvoid* span); +void gl3_3compat_glGetConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_3compat_glGetConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl3_3compat_glGetConvolutionFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* image); +void gl3_3compat_glCopyConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height); +void gl3_3compat_glCopyConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width); +void gl3_3compat_glConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl3_3compat_glConvolutionParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint params); +void gl3_3compat_glConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl3_3compat_glConvolutionParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat params); +void gl3_3compat_glConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* image); +void gl3_3compat_glConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* image); +void gl3_3compat_glCopyColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); +void gl3_3compat_glColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum gltype, const GLvoid* data); +void gl3_3compat_glGetColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_3compat_glGetColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl3_3compat_glGetColorTable(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* table); +void gl3_3compat_glCopyColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width); +void gl3_3compat_glColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl3_3compat_glColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl3_3compat_glColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* table); +void gl3_3compat_glMultTransposeMatrixd(void *_glfuncs, const GLdouble* m); +void gl3_3compat_glMultTransposeMatrixf(void *_glfuncs, const GLfloat* m); +void gl3_3compat_glLoadTransposeMatrixd(void *_glfuncs, const GLdouble* m); +void gl3_3compat_glLoadTransposeMatrixf(void *_glfuncs, const GLfloat* m); +void gl3_3compat_glMultiTexCoord4sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl3_3compat_glMultiTexCoord4s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); +void gl3_3compat_glMultiTexCoord4iv(void *_glfuncs, GLenum target, const GLint* v); +void gl3_3compat_glMultiTexCoord4i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r, GLint q); +void gl3_3compat_glMultiTexCoord4fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl3_3compat_glMultiTexCoord4f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +void gl3_3compat_glMultiTexCoord4dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl3_3compat_glMultiTexCoord4d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +void gl3_3compat_glMultiTexCoord3sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl3_3compat_glMultiTexCoord3s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r); +void gl3_3compat_glMultiTexCoord3iv(void *_glfuncs, GLenum target, const GLint* v); +void gl3_3compat_glMultiTexCoord3i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r); +void gl3_3compat_glMultiTexCoord3fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl3_3compat_glMultiTexCoord3f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r); +void gl3_3compat_glMultiTexCoord3dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl3_3compat_glMultiTexCoord3d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r); +void gl3_3compat_glMultiTexCoord2sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl3_3compat_glMultiTexCoord2s(void *_glfuncs, GLenum target, GLshort s, GLshort t); +void gl3_3compat_glMultiTexCoord2iv(void *_glfuncs, GLenum target, const GLint* v); +void gl3_3compat_glMultiTexCoord2i(void *_glfuncs, GLenum target, GLint s, GLint t); +void gl3_3compat_glMultiTexCoord2fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl3_3compat_glMultiTexCoord2f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t); +void gl3_3compat_glMultiTexCoord2dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl3_3compat_glMultiTexCoord2d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t); +void gl3_3compat_glMultiTexCoord1sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl3_3compat_glMultiTexCoord1s(void *_glfuncs, GLenum target, GLshort s); +void gl3_3compat_glMultiTexCoord1iv(void *_glfuncs, GLenum target, const GLint* v); +void gl3_3compat_glMultiTexCoord1i(void *_glfuncs, GLenum target, GLint s); +void gl3_3compat_glMultiTexCoord1fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl3_3compat_glMultiTexCoord1f(void *_glfuncs, GLenum target, GLfloat s); +void gl3_3compat_glMultiTexCoord1dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl3_3compat_glMultiTexCoord1d(void *_glfuncs, GLenum target, GLdouble s); +void gl3_3compat_glClientActiveTexture(void *_glfuncs, GLenum texture); +void gl3_3compat_glWindowPos3sv(void *_glfuncs, const GLshort* v); +void gl3_3compat_glWindowPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl3_3compat_glWindowPos3iv(void *_glfuncs, const GLint* v); +void gl3_3compat_glWindowPos3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl3_3compat_glWindowPos3fv(void *_glfuncs, const GLfloat* v); +void gl3_3compat_glWindowPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl3_3compat_glWindowPos3dv(void *_glfuncs, const GLdouble* v); +void gl3_3compat_glWindowPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl3_3compat_glWindowPos2sv(void *_glfuncs, const GLshort* v); +void gl3_3compat_glWindowPos2s(void *_glfuncs, GLshort x, GLshort y); +void gl3_3compat_glWindowPos2iv(void *_glfuncs, const GLint* v); +void gl3_3compat_glWindowPos2i(void *_glfuncs, GLint x, GLint y); +void gl3_3compat_glWindowPos2fv(void *_glfuncs, const GLfloat* v); +void gl3_3compat_glWindowPos2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl3_3compat_glWindowPos2dv(void *_glfuncs, const GLdouble* v); +void gl3_3compat_glWindowPos2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl3_3compat_glSecondaryColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl3_3compat_glSecondaryColor3usv(void *_glfuncs, const GLushort* v); +void gl3_3compat_glSecondaryColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue); +void gl3_3compat_glSecondaryColor3uiv(void *_glfuncs, const GLuint* v); +void gl3_3compat_glSecondaryColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue); +void gl3_3compat_glSecondaryColor3ubv(void *_glfuncs, const GLubyte* v); +void gl3_3compat_glSecondaryColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue); +void gl3_3compat_glSecondaryColor3sv(void *_glfuncs, const GLshort* v); +void gl3_3compat_glSecondaryColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue); +void gl3_3compat_glSecondaryColor3iv(void *_glfuncs, const GLint* v); +void gl3_3compat_glSecondaryColor3i(void *_glfuncs, GLint red, GLint green, GLint blue); +void gl3_3compat_glSecondaryColor3fv(void *_glfuncs, const GLfloat* v); +void gl3_3compat_glSecondaryColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue); +void gl3_3compat_glSecondaryColor3dv(void *_glfuncs, const GLdouble* v); +void gl3_3compat_glSecondaryColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue); +void gl3_3compat_glSecondaryColor3bv(void *_glfuncs, const GLbyte* v); +void gl3_3compat_glSecondaryColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue); +void gl3_3compat_glFogCoordPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl3_3compat_glFogCoorddv(void *_glfuncs, const GLdouble* coord); +void gl3_3compat_glFogCoordd(void *_glfuncs, GLdouble coord); +void gl3_3compat_glFogCoordfv(void *_glfuncs, const GLfloat* coord); +void gl3_3compat_glFogCoordf(void *_glfuncs, GLfloat coord); +void gl3_3compat_glVertexAttrib4usv(void *_glfuncs, GLuint index, const GLushort* v); +void gl3_3compat_glVertexAttrib4uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl3_3compat_glVertexAttrib4ubv(void *_glfuncs, GLuint index, const GLubyte* v); +void gl3_3compat_glVertexAttrib4sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl3_3compat_glVertexAttrib4s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +void gl3_3compat_glVertexAttrib4iv(void *_glfuncs, GLuint index, const GLint* v); +void gl3_3compat_glVertexAttrib4fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl3_3compat_glVertexAttrib4f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl3_3compat_glVertexAttrib4dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl3_3compat_glVertexAttrib4d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl3_3compat_glVertexAttrib4bv(void *_glfuncs, GLuint index, const GLbyte* v); +void gl3_3compat_glVertexAttrib4Nusv(void *_glfuncs, GLuint index, const GLushort* v); +void gl3_3compat_glVertexAttrib4Nuiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl3_3compat_glVertexAttrib4Nubv(void *_glfuncs, GLuint index, const GLubyte* v); +void gl3_3compat_glVertexAttrib4Nub(void *_glfuncs, GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +void gl3_3compat_glVertexAttrib4Nsv(void *_glfuncs, GLuint index, const GLshort* v); +void gl3_3compat_glVertexAttrib4Niv(void *_glfuncs, GLuint index, const GLint* v); +void gl3_3compat_glVertexAttrib4Nbv(void *_glfuncs, GLuint index, const GLbyte* v); +void gl3_3compat_glVertexAttrib3sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl3_3compat_glVertexAttrib3s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z); +void gl3_3compat_glVertexAttrib3fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl3_3compat_glVertexAttrib3f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z); +void gl3_3compat_glVertexAttrib3dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl3_3compat_glVertexAttrib3d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z); +void gl3_3compat_glVertexAttrib2sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl3_3compat_glVertexAttrib2s(void *_glfuncs, GLuint index, GLshort x, GLshort y); +void gl3_3compat_glVertexAttrib2fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl3_3compat_glVertexAttrib2f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y); +void gl3_3compat_glVertexAttrib2dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl3_3compat_glVertexAttrib2d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y); +void gl3_3compat_glVertexAttrib1sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl3_3compat_glVertexAttrib1s(void *_glfuncs, GLuint index, GLshort x); +void gl3_3compat_glVertexAttrib1fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl3_3compat_glVertexAttrib1f(void *_glfuncs, GLuint index, GLfloat x); +void gl3_3compat_glVertexAttrib1dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl3_3compat_glVertexAttrib1d(void *_glfuncs, GLuint index, GLdouble x); +void gl3_3compat_glVertexAttribI4usv(void *_glfuncs, GLuint index, const GLushort* v); +void gl3_3compat_glVertexAttribI4ubv(void *_glfuncs, GLuint index, const GLubyte* v); +void gl3_3compat_glVertexAttribI4sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl3_3compat_glVertexAttribI4bv(void *_glfuncs, GLuint index, const GLbyte* v); +void gl3_3compat_glVertexAttribI4uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl3_3compat_glVertexAttribI3uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl3_3compat_glVertexAttribI2uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl3_3compat_glVertexAttribI1uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl3_3compat_glVertexAttribI4iv(void *_glfuncs, GLuint index, const GLint* v); +void gl3_3compat_glVertexAttribI3iv(void *_glfuncs, GLuint index, const GLint* v); +void gl3_3compat_glVertexAttribI2iv(void *_glfuncs, GLuint index, const GLint* v); +void gl3_3compat_glVertexAttribI1iv(void *_glfuncs, GLuint index, const GLint* v); +void gl3_3compat_glVertexAttribI4ui(void *_glfuncs, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +void gl3_3compat_glVertexAttribI3ui(void *_glfuncs, GLuint index, GLuint x, GLuint y, GLuint z); +void gl3_3compat_glVertexAttribI2ui(void *_glfuncs, GLuint index, GLuint x, GLuint y); +void gl3_3compat_glVertexAttribI1ui(void *_glfuncs, GLuint index, GLuint x); +void gl3_3compat_glVertexAttribI4i(void *_glfuncs, GLuint index, GLint x, GLint y, GLint z, GLint w); +void gl3_3compat_glVertexAttribI3i(void *_glfuncs, GLuint index, GLint x, GLint y, GLint z); +void gl3_3compat_glVertexAttribI2i(void *_glfuncs, GLuint index, GLint x, GLint y); +void gl3_3compat_glVertexAttribI1i(void *_glfuncs, GLuint index, GLint x); + + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/gl/3.3compat/gl.go b/gl/3.3compat/gl.go new file mode 100644 index 00000000..8772aa9b --- /dev/null +++ b/gl/3.3compat/gl.go @@ -0,0 +1,8281 @@ +// ** file automatically generated by glgen -- do not edit manually ** + +package GL + +// #cgo CXXFLAGS: -std=c++0x -pedantic-errors -Wall -fno-strict-aliasing +// #cgo LDFLAGS: -lstdc++ +// #cgo pkg-config: Qt5Core Qt5OpenGL +// +// #include "funcs.h" +// +// void free(void*); +// +import "C" + +import ( + "fmt" + "reflect" + "unsafe" + + "gopkg.in/qml.v1/gl/glbase" +) + +// API returns a value that offers methods matching the OpenGL version 3.3 API. +// +// The returned API must not be used after the provided OpenGL context becomes invalid. +func API(context glbase.Contexter) *GL { + gl := &GL{} + gl.funcs = C.gl3_3compat_funcs() + if gl.funcs == nil { + panic(fmt.Errorf("OpenGL version 3.3 is not available")) + } + return gl +} + +// GL implements the OpenGL version 3.3 API. Values of this +// type must be created via the API function, and it must not be used after +// the associated OpenGL context becomes invalid. +type GL struct { + funcs unsafe.Pointer +} + +const ( + FALSE = 0 + TRUE = 1 + NONE = 0 + + BYTE = 0x1400 + UNSIGNED_BYTE = 0x1401 + SHORT = 0x1402 + UNSIGNED_SHORT = 0x1403 + INT = 0x1404 + UNSIGNED_INT = 0x1405 + FLOAT = 0x1406 + N2_BYTES = 0x1407 + N3_BYTES = 0x1408 + N4_BYTES = 0x1409 + DOUBLE = 0x140A + HALF_FLOAT = 0x140B + + ACCUM = 0x0100 + LOAD = 0x0101 + RETURN = 0x0102 + MULT = 0x0103 + ADD = 0x0104 + + ACCUM_BUFFER_BIT = 0x00000200 + ALL_ATTRIB_BITS = 0xFFFFFFFF + COLOR_BUFFER_BIT = 0x00004000 + CURRENT_BIT = 0x00000001 + DEPTH_BUFFER_BIT = 0x00000100 + ENABLE_BIT = 0x00002000 + EVAL_BIT = 0x00010000 + FOG_BIT = 0x00000080 + HINT_BIT = 0x00008000 + LIGHTING_BIT = 0x00000040 + LINE_BIT = 0x00000004 + LIST_BIT = 0x00020000 + MULTISAMPLE_BIT = 0x20000000 + PIXEL_MODE_BIT = 0x00000020 + POINT_BIT = 0x00000002 + POLYGON_BIT = 0x00000008 + POLYGON_STIPPLE_BIT = 0x00000010 + SCISSOR_BIT = 0x00080000 + STENCIL_BUFFER_BIT = 0x00000400 + TEXTURE_BIT = 0x00040000 + TRANSFORM_BIT = 0x00001000 + VIEWPORT_BIT = 0x00000800 + + ALWAYS = 0x0207 + EQUAL = 0x0202 + GEQUAL = 0x0206 + GREATER = 0x0204 + LEQUAL = 0x0203 + LESS = 0x0201 + NEVER = 0x0200 + NOTEQUAL = 0x0205 + + LOGIC_OP = 0x0BF1 + + DST_ALPHA = 0x0304 + ONE = 1 + ONE_MINUS_DST_ALPHA = 0x0305 + ONE_MINUS_SRC_ALPHA = 0x0303 + ONE_MINUS_SRC_COLOR = 0x0301 + SRC_ALPHA = 0x0302 + SRC_COLOR = 0x0300 + ZERO = 0 + + DST_COLOR = 0x0306 + ONE_MINUS_DST_COLOR = 0x0307 + SRC_ALPHA_SATURATE = 0x0308 + + CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF + CLIENT_PIXEL_STORE_BIT = 0x00000001 + CLIENT_VERTEX_ARRAY_BIT = 0x00000002 + + CLIP_DISTANCE0 = 0x3000 + CLIP_DISTANCE1 = 0x3001 + CLIP_DISTANCE2 = 0x3002 + CLIP_DISTANCE3 = 0x3003 + CLIP_DISTANCE4 = 0x3004 + CLIP_DISTANCE5 = 0x3005 + CLIP_DISTANCE6 = 0x3006 + CLIP_DISTANCE7 = 0x3007 + CLIP_PLANE0 = 0x3000 + CLIP_PLANE1 = 0x3001 + CLIP_PLANE2 = 0x3002 + CLIP_PLANE3 = 0x3003 + CLIP_PLANE4 = 0x3004 + CLIP_PLANE5 = 0x3005 + + BACK = 0x0405 + FRONT = 0x0404 + FRONT_AND_BACK = 0x0408 + + AMBIENT = 0x1200 + AMBIENT_AND_DIFFUSE = 0x1602 + DIFFUSE = 0x1201 + EMISSION = 0x1600 + SPECULAR = 0x1202 + + CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x00000001 + + CONTEXT_COMPATIBILITY_PROFILE_BIT = 0x00000002 + CONTEXT_CORE_PROFILE_BIT = 0x00000001 + + AUX0 = 0x0409 + AUX1 = 0x040A + AUX2 = 0x040B + AUX3 = 0x040C + BACK_LEFT = 0x0402 + BACK_RIGHT = 0x0403 + FRONT_LEFT = 0x0400 + FRONT_RIGHT = 0x0401 + LEFT = 0x0406 + RIGHT = 0x0407 + + ALPHA_TEST = 0x0BC0 + AUTO_NORMAL = 0x0D80 + BLEND = 0x0BE2 + COLOR_ARRAY = 0x8076 + COLOR_LOGIC_OP = 0x0BF2 + COLOR_MATERIAL = 0x0B57 + CULL_FACE = 0x0B44 + DEPTH_TEST = 0x0B71 + DITHER = 0x0BD0 + EDGE_FLAG_ARRAY = 0x8079 + FOG = 0x0B60 + INDEX_ARRAY = 0x8077 + INDEX_LOGIC_OP = 0x0BF1 + LIGHT0 = 0x4000 + LIGHT1 = 0x4001 + LIGHT2 = 0x4002 + LIGHT3 = 0x4003 + LIGHT4 = 0x4004 + LIGHT5 = 0x4005 + LIGHT6 = 0x4006 + LIGHT7 = 0x4007 + LIGHTING = 0x0B50 + LINE_SMOOTH = 0x0B20 + LINE_STIPPLE = 0x0B24 + MAP1_COLOR_4 = 0x0D90 + MAP1_INDEX = 0x0D91 + MAP1_NORMAL = 0x0D92 + MAP1_TEXTURE_COORD_1 = 0x0D93 + MAP1_TEXTURE_COORD_2 = 0x0D94 + MAP1_TEXTURE_COORD_3 = 0x0D95 + MAP1_TEXTURE_COORD_4 = 0x0D96 + MAP1_VERTEX_3 = 0x0D97 + MAP1_VERTEX_4 = 0x0D98 + MAP2_COLOR_4 = 0x0DB0 + MAP2_INDEX = 0x0DB1 + MAP2_NORMAL = 0x0DB2 + MAP2_TEXTURE_COORD_1 = 0x0DB3 + MAP2_TEXTURE_COORD_2 = 0x0DB4 + MAP2_TEXTURE_COORD_3 = 0x0DB5 + MAP2_TEXTURE_COORD_4 = 0x0DB6 + MAP2_VERTEX_3 = 0x0DB7 + MAP2_VERTEX_4 = 0x0DB8 + NORMALIZE = 0x0BA1 + NORMAL_ARRAY = 0x8075 + POINT_SMOOTH = 0x0B10 + POLYGON_OFFSET_FILL = 0x8037 + POLYGON_OFFSET_LINE = 0x2A02 + POLYGON_OFFSET_POINT = 0x2A01 + POLYGON_SMOOTH = 0x0B41 + POLYGON_STIPPLE = 0x0B42 + SCISSOR_TEST = 0x0C11 + STENCIL_TEST = 0x0B90 + TEXTURE_1D = 0x0DE0 + TEXTURE_2D = 0x0DE1 + TEXTURE_COORD_ARRAY = 0x8078 + TEXTURE_GEN_Q = 0x0C63 + TEXTURE_GEN_R = 0x0C62 + TEXTURE_GEN_S = 0x0C60 + TEXTURE_GEN_T = 0x0C61 + VERTEX_ARRAY = 0x8074 + + INVALID_ENUM = 0x0500 + INVALID_FRAMEBUFFER_OPERATION = 0x0506 + INVALID_OPERATION = 0x0502 + INVALID_VALUE = 0x0501 + NO_ERROR = 0 + OUT_OF_MEMORY = 0x0505 + STACK_OVERFLOW = 0x0503 + STACK_UNDERFLOW = 0x0504 + + N2D = 0x0600 + N3D = 0x0601 + N3D_COLOR = 0x0602 + N3D_COLOR_TEXTURE = 0x0603 + N4D_COLOR_TEXTURE = 0x0604 + + BITMAP_TOKEN = 0x0704 + COPY_PIXEL_TOKEN = 0x0706 + DRAW_PIXEL_TOKEN = 0x0705 + LINE_RESET_TOKEN = 0x0707 + LINE_TOKEN = 0x0702 + PASS_THROUGH_TOKEN = 0x0700 + POINT_TOKEN = 0x0701 + POLYGON_TOKEN = 0x0703 + + EXP = 0x0800 + EXP2 = 0x0801 + LINEAR = 0x2601 + + FOG_COLOR = 0x0B66 + FOG_DENSITY = 0x0B62 + FOG_END = 0x0B64 + FOG_INDEX = 0x0B61 + FOG_MODE = 0x0B65 + FOG_START = 0x0B63 + + CCW = 0x0901 + CW = 0x0900 + + COEFF = 0x0A00 + DOMAIN = 0x0A02 + ORDER = 0x0A01 + + PIXEL_MAP_A_TO_A = 0x0C79 + PIXEL_MAP_B_TO_B = 0x0C78 + PIXEL_MAP_G_TO_G = 0x0C77 + PIXEL_MAP_I_TO_A = 0x0C75 + PIXEL_MAP_I_TO_B = 0x0C74 + PIXEL_MAP_I_TO_G = 0x0C73 + PIXEL_MAP_I_TO_I = 0x0C70 + PIXEL_MAP_I_TO_R = 0x0C72 + PIXEL_MAP_R_TO_R = 0x0C76 + PIXEL_MAP_S_TO_S = 0x0C71 + + ACCUM_ALPHA_BITS = 0x0D5B + ACCUM_BLUE_BITS = 0x0D5A + ACCUM_CLEAR_VALUE = 0x0B80 + ACCUM_GREEN_BITS = 0x0D59 + ACCUM_RED_BITS = 0x0D58 + ALIASED_LINE_WIDTH_RANGE = 0x846E + ALIASED_POINT_SIZE_RANGE = 0x846D + ALPHA_BIAS = 0x0D1D + ALPHA_BITS = 0x0D55 + ALPHA_SCALE = 0x0D1C + ALPHA_TEST_FUNC = 0x0BC1 + ALPHA_TEST_REF = 0x0BC2 + ATTRIB_STACK_DEPTH = 0x0BB0 + AUX_BUFFERS = 0x0C00 + BLEND_DST = 0x0BE0 + BLEND_SRC = 0x0BE1 + BLUE_BIAS = 0x0D1B + BLUE_BITS = 0x0D54 + BLUE_SCALE = 0x0D1A + CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1 + COLOR_ARRAY_SIZE = 0x8081 + COLOR_ARRAY_STRIDE = 0x8083 + COLOR_ARRAY_TYPE = 0x8082 + COLOR_CLEAR_VALUE = 0x0C22 + COLOR_MATERIAL_FACE = 0x0B55 + COLOR_MATERIAL_PARAMETER = 0x0B56 + COLOR_WRITEMASK = 0x0C23 + CULL_FACE_MODE = 0x0B45 + CURRENT_COLOR = 0x0B00 + CURRENT_INDEX = 0x0B01 + CURRENT_NORMAL = 0x0B02 + CURRENT_RASTER_COLOR = 0x0B04 + CURRENT_RASTER_DISTANCE = 0x0B09 + CURRENT_RASTER_INDEX = 0x0B05 + CURRENT_RASTER_POSITION = 0x0B07 + CURRENT_RASTER_POSITION_VALID = 0x0B08 + CURRENT_RASTER_TEXTURE_COORDS = 0x0B06 + CURRENT_TEXTURE_COORDS = 0x0B03 + DEPTH_BIAS = 0x0D1F + DEPTH_BITS = 0x0D56 + DEPTH_CLEAR_VALUE = 0x0B73 + DEPTH_FUNC = 0x0B74 + DEPTH_RANGE = 0x0B70 + DEPTH_SCALE = 0x0D1E + DEPTH_WRITEMASK = 0x0B72 + DOUBLEBUFFER = 0x0C32 + DRAW_BUFFER = 0x0C01 + EDGE_FLAG = 0x0B43 + EDGE_FLAG_ARRAY_STRIDE = 0x808C + FEEDBACK_BUFFER_SIZE = 0x0DF1 + FEEDBACK_BUFFER_TYPE = 0x0DF2 + FOG_HINT = 0x0C54 + FRONT_FACE = 0x0B46 + GREEN_BIAS = 0x0D19 + GREEN_BITS = 0x0D53 + GREEN_SCALE = 0x0D18 + INDEX_ARRAY_STRIDE = 0x8086 + INDEX_ARRAY_TYPE = 0x8085 + INDEX_BITS = 0x0D51 + INDEX_CLEAR_VALUE = 0x0C20 + INDEX_MODE = 0x0C30 + INDEX_OFFSET = 0x0D13 + INDEX_SHIFT = 0x0D12 + INDEX_WRITEMASK = 0x0C21 + LIGHT_MODEL_AMBIENT = 0x0B53 + LIGHT_MODEL_COLOR_CONTROL = 0x81F8 + LIGHT_MODEL_LOCAL_VIEWER = 0x0B51 + LIGHT_MODEL_TWO_SIDE = 0x0B52 + LINE_SMOOTH_HINT = 0x0C52 + LINE_STIPPLE_PATTERN = 0x0B25 + LINE_STIPPLE_REPEAT = 0x0B26 + LINE_WIDTH = 0x0B21 + LINE_WIDTH_GRANULARITY = 0x0B23 + LINE_WIDTH_RANGE = 0x0B22 + LIST_BASE = 0x0B32 + LIST_INDEX = 0x0B33 + LIST_MODE = 0x0B30 + LOGIC_OP_MODE = 0x0BF0 + MAP1_GRID_DOMAIN = 0x0DD0 + MAP1_GRID_SEGMENTS = 0x0DD1 + MAP2_GRID_DOMAIN = 0x0DD2 + MAP2_GRID_SEGMENTS = 0x0DD3 + MAP_COLOR = 0x0D10 + MAP_STENCIL = 0x0D11 + MATRIX_MODE = 0x0BA0 + MAX_ATTRIB_STACK_DEPTH = 0x0D35 + MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B + MAX_CLIP_DISTANCES = 0x0D32 + MAX_CLIP_PLANES = 0x0D32 + MAX_EVAL_ORDER = 0x0D30 + MAX_LIGHTS = 0x0D31 + MAX_LIST_NESTING = 0x0B31 + MAX_MODELVIEW_STACK_DEPTH = 0x0D36 + MAX_NAME_STACK_DEPTH = 0x0D37 + MAX_PIXEL_MAP_TABLE = 0x0D34 + MAX_PROJECTION_STACK_DEPTH = 0x0D38 + MAX_TEXTURE_SIZE = 0x0D33 + MAX_TEXTURE_STACK_DEPTH = 0x0D39 + MAX_VIEWPORT_DIMS = 0x0D3A + MODELVIEW_MATRIX = 0x0BA6 + MODELVIEW_STACK_DEPTH = 0x0BA3 + NAME_STACK_DEPTH = 0x0D70 + NORMAL_ARRAY_STRIDE = 0x807F + NORMAL_ARRAY_TYPE = 0x807E + PACK_ALIGNMENT = 0x0D05 + PACK_LSB_FIRST = 0x0D01 + PACK_ROW_LENGTH = 0x0D02 + PACK_SKIP_PIXELS = 0x0D04 + PACK_SKIP_ROWS = 0x0D03 + PACK_SWAP_BYTES = 0x0D00 + PERSPECTIVE_CORRECTION_HINT = 0x0C50 + PIXEL_MAP_A_TO_A_SIZE = 0x0CB9 + PIXEL_MAP_B_TO_B_SIZE = 0x0CB8 + PIXEL_MAP_G_TO_G_SIZE = 0x0CB7 + PIXEL_MAP_I_TO_A_SIZE = 0x0CB5 + PIXEL_MAP_I_TO_B_SIZE = 0x0CB4 + PIXEL_MAP_I_TO_G_SIZE = 0x0CB3 + PIXEL_MAP_I_TO_I_SIZE = 0x0CB0 + PIXEL_MAP_I_TO_R_SIZE = 0x0CB2 + PIXEL_MAP_R_TO_R_SIZE = 0x0CB6 + PIXEL_MAP_S_TO_S_SIZE = 0x0CB1 + POINT_SIZE = 0x0B11 + POINT_SIZE_GRANULARITY = 0x0B13 + POINT_SIZE_RANGE = 0x0B12 + POINT_SMOOTH_HINT = 0x0C51 + POLYGON_MODE = 0x0B40 + POLYGON_OFFSET_FACTOR = 0x8038 + POLYGON_OFFSET_UNITS = 0x2A00 + POLYGON_SMOOTH_HINT = 0x0C53 + PROJECTION_MATRIX = 0x0BA7 + PROJECTION_STACK_DEPTH = 0x0BA4 + READ_BUFFER = 0x0C02 + RED_BIAS = 0x0D15 + RED_BITS = 0x0D52 + RED_SCALE = 0x0D14 + RENDER_MODE = 0x0C40 + RGBA_MODE = 0x0C31 + SCISSOR_BOX = 0x0C10 + SELECTION_BUFFER_SIZE = 0x0DF4 + SHADE_MODEL = 0x0B54 + SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23 + SMOOTH_LINE_WIDTH_RANGE = 0x0B22 + SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13 + SMOOTH_POINT_SIZE_RANGE = 0x0B12 + STENCIL_BITS = 0x0D57 + STENCIL_CLEAR_VALUE = 0x0B91 + STENCIL_FAIL = 0x0B94 + STENCIL_FUNC = 0x0B92 + STENCIL_PASS_DEPTH_FAIL = 0x0B95 + STENCIL_PASS_DEPTH_PASS = 0x0B96 + STENCIL_REF = 0x0B97 + STENCIL_VALUE_MASK = 0x0B93 + STENCIL_WRITEMASK = 0x0B98 + STEREO = 0x0C33 + SUBPIXEL_BITS = 0x0D50 + TEXTURE_BINDING_1D = 0x8068 + TEXTURE_BINDING_2D = 0x8069 + TEXTURE_BINDING_3D = 0x806A + TEXTURE_COORD_ARRAY_SIZE = 0x8088 + TEXTURE_COORD_ARRAY_STRIDE = 0x808A + TEXTURE_COORD_ARRAY_TYPE = 0x8089 + TEXTURE_MATRIX = 0x0BA8 + TEXTURE_STACK_DEPTH = 0x0BA5 + UNPACK_ALIGNMENT = 0x0CF5 + UNPACK_LSB_FIRST = 0x0CF1 + UNPACK_ROW_LENGTH = 0x0CF2 + UNPACK_SKIP_PIXELS = 0x0CF4 + UNPACK_SKIP_ROWS = 0x0CF3 + UNPACK_SWAP_BYTES = 0x0CF0 + VERTEX_ARRAY_SIZE = 0x807A + VERTEX_ARRAY_STRIDE = 0x807C + VERTEX_ARRAY_TYPE = 0x807B + VIEWPORT = 0x0BA2 + ZOOM_X = 0x0D16 + ZOOM_Y = 0x0D17 + + COLOR_ARRAY_POINTER = 0x8090 + EDGE_FLAG_ARRAY_POINTER = 0x8093 + FEEDBACK_BUFFER_POINTER = 0x0DF0 + INDEX_ARRAY_POINTER = 0x8091 + NORMAL_ARRAY_POINTER = 0x808F + SELECTION_BUFFER_POINTER = 0x0DF3 + TEXTURE_COORD_ARRAY_POINTER = 0x8092 + VERTEX_ARRAY_POINTER = 0x808E + + TEXTURE_ALPHA_SIZE = 0x805F + TEXTURE_BLUE_SIZE = 0x805E + TEXTURE_BORDER = 0x1005 + TEXTURE_BORDER_COLOR = 0x1004 + TEXTURE_COMPONENTS = 0x1003 + TEXTURE_GREEN_SIZE = 0x805D + TEXTURE_HEIGHT = 0x1001 + TEXTURE_INTENSITY_SIZE = 0x8061 + TEXTURE_INTERNAL_FORMAT = 0x1003 + TEXTURE_LUMINANCE_SIZE = 0x8060 + TEXTURE_MAG_FILTER = 0x2800 + TEXTURE_MIN_FILTER = 0x2801 + TEXTURE_PRIORITY = 0x8066 + TEXTURE_RED_SIZE = 0x805C + TEXTURE_RESIDENT = 0x8067 + TEXTURE_WIDTH = 0x1000 + TEXTURE_WRAP_S = 0x2802 + TEXTURE_WRAP_T = 0x2803 + + DONT_CARE = 0x1100 + FASTEST = 0x1101 + NICEST = 0x1102 + + FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B + GENERATE_MIPMAP_HINT = 0x8192 + TEXTURE_COMPRESSION_HINT = 0x84EF + + C3F_V3F = 0x2A24 + C4F_N3F_V3F = 0x2A26 + C4UB_V2F = 0x2A22 + C4UB_V3F = 0x2A23 + N3F_V3F = 0x2A25 + T2F_C3F_V3F = 0x2A2A + T2F_C4F_N3F_V3F = 0x2A2C + T2F_C4UB_V3F = 0x2A29 + T2F_N3F_V3F = 0x2A2B + T2F_V3F = 0x2A27 + T4F_C4F_N3F_V4F = 0x2A2D + T4F_V4F = 0x2A28 + V2F = 0x2A20 + V3F = 0x2A21 + + MODULATE = 0x2100 + REPLACE = 0x1E01 + + SEPARATE_SPECULAR_COLOR = 0x81FA + SINGLE_COLOR = 0x81F9 + + CONSTANT_ATTENUATION = 0x1207 + LINEAR_ATTENUATION = 0x1208 + POSITION = 0x1203 + QUADRATIC_ATTENUATION = 0x1209 + SPOT_CUTOFF = 0x1206 + SPOT_DIRECTION = 0x1204 + SPOT_EXPONENT = 0x1205 + + COMPILE = 0x1300 + COMPILE_AND_EXECUTE = 0x1301 + + AND = 0x1501 + AND_INVERTED = 0x1504 + AND_REVERSE = 0x1502 + CLEAR = 0x1500 + COPY = 0x1503 + COPY_INVERTED = 0x150C + EQUIV = 0x1509 + INVERT = 0x150A + NAND = 0x150E + NOOP = 0x1505 + NOR = 0x1508 + OR = 0x1507 + OR_INVERTED = 0x150D + OR_REVERSE = 0x150B + SET = 0x150F + XOR = 0x1506 + + MAP_FLUSH_EXPLICIT_BIT = 0x0010 + MAP_INVALIDATE_BUFFER_BIT = 0x0008 + MAP_INVALIDATE_RANGE_BIT = 0x0004 + MAP_READ_BIT = 0x0001 + MAP_UNSYNCHRONIZED_BIT = 0x0020 + MAP_WRITE_BIT = 0x0002 + + COLOR_INDEXES = 0x1603 + SHININESS = 0x1601 + + MODELVIEW = 0x1700 + PROJECTION = 0x1701 + TEXTURE = 0x1702 + + LINE = 0x1B01 + POINT = 0x1B00 + + FILL = 0x1B02 + + COLOR = 0x1800 + DEPTH = 0x1801 + STENCIL = 0x1802 + + ALPHA = 0x1906 + BLUE = 0x1905 + COLOR_INDEX = 0x1900 + DEPTH_COMPONENT = 0x1902 + GREEN = 0x1904 + LUMINANCE = 0x1909 + LUMINANCE_ALPHA = 0x190A + RED = 0x1903 + RGB = 0x1907 + RGBA = 0x1908 + STENCIL_INDEX = 0x1901 + + ALPHA12 = 0x803D + ALPHA16 = 0x803E + ALPHA4 = 0x803B + ALPHA8 = 0x803C + INTENSITY = 0x8049 + INTENSITY12 = 0x804C + INTENSITY16 = 0x804D + INTENSITY4 = 0x804A + INTENSITY8 = 0x804B + LUMINANCE12 = 0x8041 + LUMINANCE12_ALPHA12 = 0x8047 + LUMINANCE12_ALPHA4 = 0x8046 + LUMINANCE16 = 0x8042 + LUMINANCE16_ALPHA16 = 0x8048 + LUMINANCE4 = 0x803F + LUMINANCE4_ALPHA4 = 0x8043 + LUMINANCE6_ALPHA2 = 0x8044 + LUMINANCE8 = 0x8040 + LUMINANCE8_ALPHA8 = 0x8045 + R3_G3_B2 = 0x2A10 + RGB10 = 0x8052 + RGB10_A2 = 0x8059 + RGB12 = 0x8053 + RGB16 = 0x8054 + RGB4 = 0x804F + RGB5 = 0x8050 + RGB5_A1 = 0x8057 + RGB8 = 0x8051 + RGBA12 = 0x805A + RGBA16 = 0x805B + RGBA2 = 0x8055 + RGBA4 = 0x8056 + RGBA8 = 0x8058 + + PACK_IMAGE_HEIGHT = 0x806C + PACK_SKIP_IMAGES = 0x806B + UNPACK_IMAGE_HEIGHT = 0x806E + UNPACK_SKIP_IMAGES = 0x806D + + BITMAP = 0x1A00 + UNSIGNED_BYTE_3_3_2 = 0x8032 + UNSIGNED_INT_10_10_10_2 = 0x8036 + UNSIGNED_INT_8_8_8_8 = 0x8035 + UNSIGNED_SHORT_4_4_4_4 = 0x8033 + UNSIGNED_SHORT_5_5_5_1 = 0x8034 + + POINT_DISTANCE_ATTENUATION = 0x8129 + POINT_FADE_THRESHOLD_SIZE = 0x8128 + POINT_SIZE_MAX = 0x8127 + POINT_SIZE_MIN = 0x8126 + + LINES = 0x0001 + LINES_ADJACENCY = 0x000A + LINE_LOOP = 0x0002 + LINE_STRIP = 0x0003 + LINE_STRIP_ADJACENCY = 0x000B + POINTS = 0x0000 + POLYGON = 0x0009 + QUADS = 0x0007 + QUAD_STRIP = 0x0008 + TRIANGLES = 0x0004 + TRIANGLES_ADJACENCY = 0x000C + TRIANGLE_FAN = 0x0006 + TRIANGLE_STRIP = 0x0005 + TRIANGLE_STRIP_ADJACENCY = 0x000D + + FEEDBACK = 0x1C01 + RENDER = 0x1C00 + SELECT = 0x1C02 + + FLAT = 0x1D00 + SMOOTH = 0x1D01 + + DECR = 0x1E03 + INCR = 0x1E02 + KEEP = 0x1E00 + + EXTENSIONS = 0x1F03 + RENDERER = 0x1F01 + VENDOR = 0x1F00 + VERSION = 0x1F02 + + S = 0x2000 + T = 0x2001 + R = 0x2002 + Q = 0x2003 + + DECAL = 0x2101 + + TEXTURE_ENV_COLOR = 0x2201 + TEXTURE_ENV_MODE = 0x2200 + + TEXTURE_ENV = 0x2300 + + EYE_LINEAR = 0x2400 + OBJECT_LINEAR = 0x2401 + SPHERE_MAP = 0x2402 + + EYE_PLANE = 0x2502 + OBJECT_PLANE = 0x2501 + TEXTURE_GEN_MODE = 0x2500 + + NEAREST = 0x2600 + + LINEAR_MIPMAP_LINEAR = 0x2703 + LINEAR_MIPMAP_NEAREST = 0x2701 + NEAREST_MIPMAP_LINEAR = 0x2702 + NEAREST_MIPMAP_NEAREST = 0x2700 + + GENERATE_MIPMAP = 0x8191 + TEXTURE_WRAP_R = 0x8072 + + PROXY_TEXTURE_1D = 0x8063 + PROXY_TEXTURE_2D = 0x8064 + PROXY_TEXTURE_3D = 0x8070 + TEXTURE_3D = 0x806F + TEXTURE_BASE_LEVEL = 0x813C + TEXTURE_MAX_LEVEL = 0x813D + TEXTURE_MAX_LOD = 0x813B + TEXTURE_MIN_LOD = 0x813A + + CLAMP = 0x2900 + CLAMP_TO_BORDER = 0x812D + CLAMP_TO_EDGE = 0x812F + REPEAT = 0x2901 + + SYNC_FLUSH_COMMANDS_BIT = 0x00000001 + INVALID_INDEX = 0xFFFFFFFF + TIMEOUT_IGNORED = 0xFFFFFFFFFFFFFFFF + CONSTANT_COLOR = 0x8001 + ONE_MINUS_CONSTANT_COLOR = 0x8002 + CONSTANT_ALPHA = 0x8003 + ONE_MINUS_CONSTANT_ALPHA = 0x8004 + FUNC_ADD = 0x8006 + MIN = 0x8007 + MAX = 0x8008 + BLEND_EQUATION_RGB = 0x8009 + FUNC_SUBTRACT = 0x800A + FUNC_REVERSE_SUBTRACT = 0x800B + RESCALE_NORMAL = 0x803A + TEXTURE_DEPTH = 0x8071 + MAX_3D_TEXTURE_SIZE = 0x8073 + MULTISAMPLE = 0x809D + SAMPLE_ALPHA_TO_COVERAGE = 0x809E + SAMPLE_ALPHA_TO_ONE = 0x809F + SAMPLE_COVERAGE = 0x80A0 + SAMPLE_BUFFERS = 0x80A8 + SAMPLES = 0x80A9 + SAMPLE_COVERAGE_VALUE = 0x80AA + SAMPLE_COVERAGE_INVERT = 0x80AB + BLEND_DST_RGB = 0x80C8 + BLEND_SRC_RGB = 0x80C9 + BLEND_DST_ALPHA = 0x80CA + BLEND_SRC_ALPHA = 0x80CB + BGR = 0x80E0 + BGRA = 0x80E1 + MAX_ELEMENTS_VERTICES = 0x80E8 + MAX_ELEMENTS_INDICES = 0x80E9 + DEPTH_COMPONENT16 = 0x81A5 + DEPTH_COMPONENT24 = 0x81A6 + DEPTH_COMPONENT32 = 0x81A7 + FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210 + FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211 + FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212 + FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213 + FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214 + FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215 + FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216 + FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217 + FRAMEBUFFER_DEFAULT = 0x8218 + FRAMEBUFFER_UNDEFINED = 0x8219 + DEPTH_STENCIL_ATTACHMENT = 0x821A + MAJOR_VERSION = 0x821B + MINOR_VERSION = 0x821C + NUM_EXTENSIONS = 0x821D + CONTEXT_FLAGS = 0x821E + INDEX = 0x8222 + COMPRESSED_RED = 0x8225 + COMPRESSED_RG = 0x8226 + RG = 0x8227 + RG_INTEGER = 0x8228 + R8 = 0x8229 + R16 = 0x822A + RG8 = 0x822B + RG16 = 0x822C + R16F = 0x822D + R32F = 0x822E + RG16F = 0x822F + RG32F = 0x8230 + R8I = 0x8231 + R8UI = 0x8232 + R16I = 0x8233 + R16UI = 0x8234 + R32I = 0x8235 + R32UI = 0x8236 + RG8I = 0x8237 + RG8UI = 0x8238 + RG16I = 0x8239 + RG16UI = 0x823A + RG32I = 0x823B + RG32UI = 0x823C + UNSIGNED_BYTE_2_3_3_REV = 0x8362 + UNSIGNED_SHORT_5_6_5 = 0x8363 + UNSIGNED_SHORT_5_6_5_REV = 0x8364 + UNSIGNED_SHORT_4_4_4_4_REV = 0x8365 + UNSIGNED_SHORT_1_5_5_5_REV = 0x8366 + UNSIGNED_INT_8_8_8_8_REV = 0x8367 + UNSIGNED_INT_2_10_10_10_REV = 0x8368 + MIRRORED_REPEAT = 0x8370 + FOG_COORDINATE_SOURCE = 0x8450 + FOG_COORD_SRC = 0x8450 + FOG_COORDINATE = 0x8451 + FOG_COORD = 0x8451 + FRAGMENT_DEPTH = 0x8452 + CURRENT_FOG_COORDINATE = 0x8453 + CURRENT_FOG_COORD = 0x8453 + FOG_COORDINATE_ARRAY_TYPE = 0x8454 + FOG_COORD_ARRAY_TYPE = 0x8454 + FOG_COORDINATE_ARRAY_STRIDE = 0x8455 + FOG_COORD_ARRAY_STRIDE = 0x8455 + FOG_COORDINATE_ARRAY_POINTER = 0x8456 + FOG_COORD_ARRAY_POINTER = 0x8456 + FOG_COORDINATE_ARRAY = 0x8457 + FOG_COORD_ARRAY = 0x8457 + COLOR_SUM = 0x8458 + CURRENT_SECONDARY_COLOR = 0x8459 + SECONDARY_COLOR_ARRAY_SIZE = 0x845A + SECONDARY_COLOR_ARRAY_TYPE = 0x845B + SECONDARY_COLOR_ARRAY_STRIDE = 0x845C + SECONDARY_COLOR_ARRAY_POINTER = 0x845D + SECONDARY_COLOR_ARRAY = 0x845E + CURRENT_RASTER_SECONDARY_COLOR = 0x845F + TEXTURE0 = 0x84C0 + TEXTURE1 = 0x84C1 + TEXTURE2 = 0x84C2 + TEXTURE3 = 0x84C3 + TEXTURE4 = 0x84C4 + TEXTURE5 = 0x84C5 + TEXTURE6 = 0x84C6 + TEXTURE7 = 0x84C7 + TEXTURE8 = 0x84C8 + TEXTURE9 = 0x84C9 + TEXTURE10 = 0x84CA + TEXTURE11 = 0x84CB + TEXTURE12 = 0x84CC + TEXTURE13 = 0x84CD + TEXTURE14 = 0x84CE + TEXTURE15 = 0x84CF + TEXTURE16 = 0x84D0 + TEXTURE17 = 0x84D1 + TEXTURE18 = 0x84D2 + TEXTURE19 = 0x84D3 + TEXTURE20 = 0x84D4 + TEXTURE21 = 0x84D5 + TEXTURE22 = 0x84D6 + TEXTURE23 = 0x84D7 + TEXTURE24 = 0x84D8 + TEXTURE25 = 0x84D9 + TEXTURE26 = 0x84DA + TEXTURE27 = 0x84DB + TEXTURE28 = 0x84DC + TEXTURE29 = 0x84DD + TEXTURE30 = 0x84DE + TEXTURE31 = 0x84DF + ACTIVE_TEXTURE = 0x84E0 + CLIENT_ACTIVE_TEXTURE = 0x84E1 + MAX_TEXTURE_UNITS = 0x84E2 + TRANSPOSE_MODELVIEW_MATRIX = 0x84E3 + TRANSPOSE_PROJECTION_MATRIX = 0x84E4 + TRANSPOSE_TEXTURE_MATRIX = 0x84E5 + TRANSPOSE_COLOR_MATRIX = 0x84E6 + SUBTRACT = 0x84E7 + MAX_RENDERBUFFER_SIZE = 0x84E8 + COMPRESSED_ALPHA = 0x84E9 + COMPRESSED_LUMINANCE = 0x84EA + COMPRESSED_LUMINANCE_ALPHA = 0x84EB + COMPRESSED_INTENSITY = 0x84EC + COMPRESSED_RGB = 0x84ED + COMPRESSED_RGBA = 0x84EE + TEXTURE_RECTANGLE = 0x84F5 + TEXTURE_BINDING_RECTANGLE = 0x84F6 + PROXY_TEXTURE_RECTANGLE = 0x84F7 + MAX_RECTANGLE_TEXTURE_SIZE = 0x84F8 + DEPTH_STENCIL = 0x84F9 + UNSIGNED_INT_24_8 = 0x84FA + MAX_TEXTURE_LOD_BIAS = 0x84FD + TEXTURE_FILTER_CONTROL = 0x8500 + TEXTURE_LOD_BIAS = 0x8501 + INCR_WRAP = 0x8507 + DECR_WRAP = 0x8508 + NORMAL_MAP = 0x8511 + REFLECTION_MAP = 0x8512 + TEXTURE_CUBE_MAP = 0x8513 + TEXTURE_BINDING_CUBE_MAP = 0x8514 + TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515 + TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516 + TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517 + TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518 + TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519 + TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A + PROXY_TEXTURE_CUBE_MAP = 0x851B + MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C + COMBINE = 0x8570 + COMBINE_RGB = 0x8571 + COMBINE_ALPHA = 0x8572 + RGB_SCALE = 0x8573 + ADD_SIGNED = 0x8574 + INTERPOLATE = 0x8575 + CONSTANT = 0x8576 + PRIMARY_COLOR = 0x8577 + PREVIOUS = 0x8578 + SOURCE0_RGB = 0x8580 + SRC0_RGB = 0x8580 + SOURCE1_RGB = 0x8581 + SRC1_RGB = 0x8581 + SOURCE2_RGB = 0x8582 + SRC2_RGB = 0x8582 + SOURCE0_ALPHA = 0x8588 + SRC0_ALPHA = 0x8588 + SOURCE1_ALPHA = 0x8589 + SRC1_ALPHA = 0x8589 + SOURCE2_ALPHA = 0x858A + SRC2_ALPHA = 0x858A + OPERAND0_RGB = 0x8590 + OPERAND1_RGB = 0x8591 + OPERAND2_RGB = 0x8592 + OPERAND0_ALPHA = 0x8598 + OPERAND1_ALPHA = 0x8599 + OPERAND2_ALPHA = 0x859A + VERTEX_ARRAY_BINDING = 0x85B5 + VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622 + VERTEX_ATTRIB_ARRAY_SIZE = 0x8623 + VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624 + VERTEX_ATTRIB_ARRAY_TYPE = 0x8625 + CURRENT_VERTEX_ATTRIB = 0x8626 + VERTEX_PROGRAM_POINT_SIZE = 0x8642 + PROGRAM_POINT_SIZE = 0x8642 + VERTEX_PROGRAM_TWO_SIDE = 0x8643 + VERTEX_ATTRIB_ARRAY_POINTER = 0x8645 + DEPTH_CLAMP = 0x864F + TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0 + TEXTURE_COMPRESSED = 0x86A1 + NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2 + COMPRESSED_TEXTURE_FORMATS = 0x86A3 + DOT3_RGB = 0x86AE + DOT3_RGBA = 0x86AF + BUFFER_SIZE = 0x8764 + BUFFER_USAGE = 0x8765 + STENCIL_BACK_FUNC = 0x8800 + STENCIL_BACK_FAIL = 0x8801 + STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802 + STENCIL_BACK_PASS_DEPTH_PASS = 0x8803 + RGBA32F = 0x8814 + RGB32F = 0x8815 + RGBA16F = 0x881A + RGB16F = 0x881B + MAX_DRAW_BUFFERS = 0x8824 + DRAW_BUFFER0 = 0x8825 + DRAW_BUFFER1 = 0x8826 + DRAW_BUFFER2 = 0x8827 + DRAW_BUFFER3 = 0x8828 + DRAW_BUFFER4 = 0x8829 + DRAW_BUFFER5 = 0x882A + DRAW_BUFFER6 = 0x882B + DRAW_BUFFER7 = 0x882C + DRAW_BUFFER8 = 0x882D + DRAW_BUFFER9 = 0x882E + DRAW_BUFFER10 = 0x882F + DRAW_BUFFER11 = 0x8830 + DRAW_BUFFER12 = 0x8831 + DRAW_BUFFER13 = 0x8832 + DRAW_BUFFER14 = 0x8833 + DRAW_BUFFER15 = 0x8834 + BLEND_EQUATION_ALPHA = 0x883D + TEXTURE_DEPTH_SIZE = 0x884A + DEPTH_TEXTURE_MODE = 0x884B + TEXTURE_COMPARE_MODE = 0x884C + TEXTURE_COMPARE_FUNC = 0x884D + COMPARE_R_TO_TEXTURE = 0x884E + COMPARE_REF_TO_TEXTURE = 0x884E + TEXTURE_CUBE_MAP_SEAMLESS = 0x884F + POINT_SPRITE = 0x8861 + COORD_REPLACE = 0x8862 + QUERY_COUNTER_BITS = 0x8864 + CURRENT_QUERY = 0x8865 + QUERY_RESULT = 0x8866 + QUERY_RESULT_AVAILABLE = 0x8867 + MAX_VERTEX_ATTRIBS = 0x8869 + VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A + MAX_TEXTURE_COORDS = 0x8871 + MAX_TEXTURE_IMAGE_UNITS = 0x8872 + ARRAY_BUFFER = 0x8892 + ELEMENT_ARRAY_BUFFER = 0x8893 + ARRAY_BUFFER_BINDING = 0x8894 + ELEMENT_ARRAY_BUFFER_BINDING = 0x8895 + VERTEX_ARRAY_BUFFER_BINDING = 0x8896 + NORMAL_ARRAY_BUFFER_BINDING = 0x8897 + COLOR_ARRAY_BUFFER_BINDING = 0x8898 + INDEX_ARRAY_BUFFER_BINDING = 0x8899 + TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A + EDGE_FLAG_ARRAY_BUFFER_BINDING = 0x889B + SECONDARY_COLOR_ARRAY_BUFFER_BINDING = 0x889C + FOG_COORDINATE_ARRAY_BUFFER_BINDING = 0x889D + FOG_COORD_ARRAY_BUFFER_BINDING = 0x889D + WEIGHT_ARRAY_BUFFER_BINDING = 0x889E + VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F + READ_ONLY = 0x88B8 + WRITE_ONLY = 0x88B9 + READ_WRITE = 0x88BA + BUFFER_ACCESS = 0x88BB + BUFFER_MAPPED = 0x88BC + BUFFER_MAP_POINTER = 0x88BD + TIME_ELAPSED = 0x88BF + STREAM_DRAW = 0x88E0 + STREAM_READ = 0x88E1 + STREAM_COPY = 0x88E2 + STATIC_DRAW = 0x88E4 + STATIC_READ = 0x88E5 + STATIC_COPY = 0x88E6 + DYNAMIC_DRAW = 0x88E8 + DYNAMIC_READ = 0x88E9 + DYNAMIC_COPY = 0x88EA + PIXEL_PACK_BUFFER = 0x88EB + PIXEL_UNPACK_BUFFER = 0x88EC + PIXEL_PACK_BUFFER_BINDING = 0x88ED + PIXEL_UNPACK_BUFFER_BINDING = 0x88EF + DEPTH24_STENCIL8 = 0x88F0 + TEXTURE_STENCIL_SIZE = 0x88F1 + SRC1_COLOR = 0x88F9 + ONE_MINUS_SRC1_COLOR = 0x88FA + ONE_MINUS_SRC1_ALPHA = 0x88FB + MAX_DUAL_SOURCE_DRAW_BUFFERS = 0x88FC + VERTEX_ATTRIB_ARRAY_INTEGER = 0x88FD + VERTEX_ATTRIB_ARRAY_DIVISOR = 0x88FE + MAX_ARRAY_TEXTURE_LAYERS = 0x88FF + MIN_PROGRAM_TEXEL_OFFSET = 0x8904 + MAX_PROGRAM_TEXEL_OFFSET = 0x8905 + SAMPLES_PASSED = 0x8914 + GEOMETRY_VERTICES_OUT = 0x8916 + GEOMETRY_INPUT_TYPE = 0x8917 + GEOMETRY_OUTPUT_TYPE = 0x8918 + SAMPLER_BINDING = 0x8919 + CLAMP_VERTEX_COLOR = 0x891A + CLAMP_FRAGMENT_COLOR = 0x891B + CLAMP_READ_COLOR = 0x891C + FIXED_ONLY = 0x891D + UNIFORM_BUFFER = 0x8A11 + UNIFORM_BUFFER_BINDING = 0x8A28 + UNIFORM_BUFFER_START = 0x8A29 + UNIFORM_BUFFER_SIZE = 0x8A2A + MAX_VERTEX_UNIFORM_BLOCKS = 0x8A2B + MAX_GEOMETRY_UNIFORM_BLOCKS = 0x8A2C + MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8A2D + MAX_COMBINED_UNIFORM_BLOCKS = 0x8A2E + MAX_UNIFORM_BUFFER_BINDINGS = 0x8A2F + MAX_UNIFORM_BLOCK_SIZE = 0x8A30 + MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31 + MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 0x8A32 + MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33 + UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8A34 + ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35 + ACTIVE_UNIFORM_BLOCKS = 0x8A36 + UNIFORM_TYPE = 0x8A37 + UNIFORM_SIZE = 0x8A38 + UNIFORM_NAME_LENGTH = 0x8A39 + UNIFORM_BLOCK_INDEX = 0x8A3A + UNIFORM_OFFSET = 0x8A3B + UNIFORM_ARRAY_STRIDE = 0x8A3C + UNIFORM_MATRIX_STRIDE = 0x8A3D + UNIFORM_IS_ROW_MAJOR = 0x8A3E + UNIFORM_BLOCK_BINDING = 0x8A3F + UNIFORM_BLOCK_DATA_SIZE = 0x8A40 + UNIFORM_BLOCK_NAME_LENGTH = 0x8A41 + UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8A42 + UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43 + UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44 + UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 0x8A45 + UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46 + FRAGMENT_SHADER = 0x8B30 + VERTEX_SHADER = 0x8B31 + MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49 + MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A + MAX_VARYING_FLOATS = 0x8B4B + MAX_VARYING_COMPONENTS = 0x8B4B + MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C + MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D + SHADER_TYPE = 0x8B4F + FLOAT_VEC2 = 0x8B50 + FLOAT_VEC3 = 0x8B51 + FLOAT_VEC4 = 0x8B52 + INT_VEC2 = 0x8B53 + INT_VEC3 = 0x8B54 + INT_VEC4 = 0x8B55 + BOOL = 0x8B56 + BOOL_VEC2 = 0x8B57 + BOOL_VEC3 = 0x8B58 + BOOL_VEC4 = 0x8B59 + FLOAT_MAT2 = 0x8B5A + FLOAT_MAT3 = 0x8B5B + FLOAT_MAT4 = 0x8B5C + SAMPLER_1D = 0x8B5D + SAMPLER_2D = 0x8B5E + SAMPLER_3D = 0x8B5F + SAMPLER_CUBE = 0x8B60 + SAMPLER_1D_SHADOW = 0x8B61 + SAMPLER_2D_SHADOW = 0x8B62 + SAMPLER_2D_RECT = 0x8B63 + SAMPLER_2D_RECT_SHADOW = 0x8B64 + FLOAT_MAT2x3 = 0x8B65 + FLOAT_MAT2x4 = 0x8B66 + FLOAT_MAT3x2 = 0x8B67 + FLOAT_MAT3x4 = 0x8B68 + FLOAT_MAT4x2 = 0x8B69 + FLOAT_MAT4x3 = 0x8B6A + DELETE_STATUS = 0x8B80 + COMPILE_STATUS = 0x8B81 + LINK_STATUS = 0x8B82 + VALIDATE_STATUS = 0x8B83 + INFO_LOG_LENGTH = 0x8B84 + ATTACHED_SHADERS = 0x8B85 + ACTIVE_UNIFORMS = 0x8B86 + ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87 + SHADER_SOURCE_LENGTH = 0x8B88 + ACTIVE_ATTRIBUTES = 0x8B89 + ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A + SHADING_LANGUAGE_VERSION = 0x8B8C + CURRENT_PROGRAM = 0x8B8D + TEXTURE_RED_TYPE = 0x8C10 + TEXTURE_GREEN_TYPE = 0x8C11 + TEXTURE_BLUE_TYPE = 0x8C12 + TEXTURE_ALPHA_TYPE = 0x8C13 + TEXTURE_LUMINANCE_TYPE = 0x8C14 + TEXTURE_INTENSITY_TYPE = 0x8C15 + TEXTURE_DEPTH_TYPE = 0x8C16 + UNSIGNED_NORMALIZED = 0x8C17 + TEXTURE_1D_ARRAY = 0x8C18 + PROXY_TEXTURE_1D_ARRAY = 0x8C19 + TEXTURE_2D_ARRAY = 0x8C1A + PROXY_TEXTURE_2D_ARRAY = 0x8C1B + TEXTURE_BINDING_1D_ARRAY = 0x8C1C + TEXTURE_BINDING_2D_ARRAY = 0x8C1D + MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = 0x8C29 + TEXTURE_BUFFER = 0x8C2A + MAX_TEXTURE_BUFFER_SIZE = 0x8C2B + TEXTURE_BINDING_BUFFER = 0x8C2C + TEXTURE_BUFFER_DATA_STORE_BINDING = 0x8C2D + ANY_SAMPLES_PASSED = 0x8C2F + R11F_G11F_B10F = 0x8C3A + UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B + RGB9_E5 = 0x8C3D + UNSIGNED_INT_5_9_9_9_REV = 0x8C3E + TEXTURE_SHARED_SIZE = 0x8C3F + SRGB = 0x8C40 + SRGB8 = 0x8C41 + SRGB_ALPHA = 0x8C42 + SRGB8_ALPHA8 = 0x8C43 + SLUMINANCE_ALPHA = 0x8C44 + SLUMINANCE8_ALPHA8 = 0x8C45 + SLUMINANCE = 0x8C46 + SLUMINANCE8 = 0x8C47 + COMPRESSED_SRGB = 0x8C48 + COMPRESSED_SRGB_ALPHA = 0x8C49 + COMPRESSED_SLUMINANCE = 0x8C4A + COMPRESSED_SLUMINANCE_ALPHA = 0x8C4B + TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76 + TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F + MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80 + TRANSFORM_FEEDBACK_VARYINGS = 0x8C83 + TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84 + TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85 + PRIMITIVES_GENERATED = 0x8C87 + TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88 + RASTERIZER_DISCARD = 0x8C89 + MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A + MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B + INTERLEAVED_ATTRIBS = 0x8C8C + SEPARATE_ATTRIBS = 0x8C8D + TRANSFORM_FEEDBACK_BUFFER = 0x8C8E + TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F + POINT_SPRITE_COORD_ORIGIN = 0x8CA0 + LOWER_LEFT = 0x8CA1 + UPPER_LEFT = 0x8CA2 + STENCIL_BACK_REF = 0x8CA3 + STENCIL_BACK_VALUE_MASK = 0x8CA4 + STENCIL_BACK_WRITEMASK = 0x8CA5 + DRAW_FRAMEBUFFER_BINDING = 0x8CA6 + FRAMEBUFFER_BINDING = 0x8CA6 + RENDERBUFFER_BINDING = 0x8CA7 + READ_FRAMEBUFFER = 0x8CA8 + DRAW_FRAMEBUFFER = 0x8CA9 + READ_FRAMEBUFFER_BINDING = 0x8CAA + RENDERBUFFER_SAMPLES = 0x8CAB + DEPTH_COMPONENT32F = 0x8CAC + DEPTH32F_STENCIL8 = 0x8CAD + FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0 + FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1 + FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2 + FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3 + FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4 + FRAMEBUFFER_COMPLETE = 0x8CD5 + FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6 + FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7 + FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB + FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC + FRAMEBUFFER_UNSUPPORTED = 0x8CDD + MAX_COLOR_ATTACHMENTS = 0x8CDF + COLOR_ATTACHMENT0 = 0x8CE0 + COLOR_ATTACHMENT1 = 0x8CE1 + COLOR_ATTACHMENT2 = 0x8CE2 + COLOR_ATTACHMENT3 = 0x8CE3 + COLOR_ATTACHMENT4 = 0x8CE4 + COLOR_ATTACHMENT5 = 0x8CE5 + COLOR_ATTACHMENT6 = 0x8CE6 + COLOR_ATTACHMENT7 = 0x8CE7 + COLOR_ATTACHMENT8 = 0x8CE8 + COLOR_ATTACHMENT9 = 0x8CE9 + COLOR_ATTACHMENT10 = 0x8CEA + COLOR_ATTACHMENT11 = 0x8CEB + COLOR_ATTACHMENT12 = 0x8CEC + COLOR_ATTACHMENT13 = 0x8CED + COLOR_ATTACHMENT14 = 0x8CEE + COLOR_ATTACHMENT15 = 0x8CEF + DEPTH_ATTACHMENT = 0x8D00 + STENCIL_ATTACHMENT = 0x8D20 + FRAMEBUFFER = 0x8D40 + RENDERBUFFER = 0x8D41 + RENDERBUFFER_WIDTH = 0x8D42 + RENDERBUFFER_HEIGHT = 0x8D43 + RENDERBUFFER_INTERNAL_FORMAT = 0x8D44 + STENCIL_INDEX1 = 0x8D46 + STENCIL_INDEX4 = 0x8D47 + STENCIL_INDEX8 = 0x8D48 + STENCIL_INDEX16 = 0x8D49 + RENDERBUFFER_RED_SIZE = 0x8D50 + RENDERBUFFER_GREEN_SIZE = 0x8D51 + RENDERBUFFER_BLUE_SIZE = 0x8D52 + RENDERBUFFER_ALPHA_SIZE = 0x8D53 + RENDERBUFFER_DEPTH_SIZE = 0x8D54 + RENDERBUFFER_STENCIL_SIZE = 0x8D55 + FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56 + MAX_SAMPLES = 0x8D57 + RGBA32UI = 0x8D70 + RGB32UI = 0x8D71 + RGBA16UI = 0x8D76 + RGB16UI = 0x8D77 + RGBA8UI = 0x8D7C + RGB8UI = 0x8D7D + RGBA32I = 0x8D82 + RGB32I = 0x8D83 + RGBA16I = 0x8D88 + RGB16I = 0x8D89 + RGBA8I = 0x8D8E + RGB8I = 0x8D8F + RED_INTEGER = 0x8D94 + GREEN_INTEGER = 0x8D95 + BLUE_INTEGER = 0x8D96 + ALPHA_INTEGER = 0x8D97 + RGB_INTEGER = 0x8D98 + RGBA_INTEGER = 0x8D99 + BGR_INTEGER = 0x8D9A + BGRA_INTEGER = 0x8D9B + INT_2_10_10_10_REV = 0x8D9F + FRAMEBUFFER_ATTACHMENT_LAYERED = 0x8DA7 + FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = 0x8DA8 + FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD + FRAMEBUFFER_SRGB = 0x8DB9 + COMPRESSED_RED_RGTC1 = 0x8DBB + COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC + COMPRESSED_RG_RGTC2 = 0x8DBD + COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE + SAMPLER_1D_ARRAY = 0x8DC0 + SAMPLER_2D_ARRAY = 0x8DC1 + SAMPLER_BUFFER = 0x8DC2 + SAMPLER_1D_ARRAY_SHADOW = 0x8DC3 + SAMPLER_2D_ARRAY_SHADOW = 0x8DC4 + SAMPLER_CUBE_SHADOW = 0x8DC5 + UNSIGNED_INT_VEC2 = 0x8DC6 + UNSIGNED_INT_VEC3 = 0x8DC7 + UNSIGNED_INT_VEC4 = 0x8DC8 + INT_SAMPLER_1D = 0x8DC9 + INT_SAMPLER_2D = 0x8DCA + INT_SAMPLER_3D = 0x8DCB + INT_SAMPLER_CUBE = 0x8DCC + INT_SAMPLER_2D_RECT = 0x8DCD + INT_SAMPLER_1D_ARRAY = 0x8DCE + INT_SAMPLER_2D_ARRAY = 0x8DCF + INT_SAMPLER_BUFFER = 0x8DD0 + UNSIGNED_INT_SAMPLER_1D = 0x8DD1 + UNSIGNED_INT_SAMPLER_2D = 0x8DD2 + UNSIGNED_INT_SAMPLER_3D = 0x8DD3 + UNSIGNED_INT_SAMPLER_CUBE = 0x8DD4 + UNSIGNED_INT_SAMPLER_2D_RECT = 0x8DD5 + UNSIGNED_INT_SAMPLER_1D_ARRAY = 0x8DD6 + UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8DD7 + UNSIGNED_INT_SAMPLER_BUFFER = 0x8DD8 + GEOMETRY_SHADER = 0x8DD9 + MAX_GEOMETRY_UNIFORM_COMPONENTS = 0x8DDF + MAX_GEOMETRY_OUTPUT_VERTICES = 0x8DE0 + MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = 0x8DE1 + QUERY_WAIT = 0x8E13 + QUERY_NO_WAIT = 0x8E14 + QUERY_BY_REGION_WAIT = 0x8E15 + QUERY_BY_REGION_NO_WAIT = 0x8E16 + TIMESTAMP = 0x8E28 + TEXTURE_SWIZZLE_R = 0x8E42 + TEXTURE_SWIZZLE_G = 0x8E43 + TEXTURE_SWIZZLE_B = 0x8E44 + TEXTURE_SWIZZLE_A = 0x8E45 + TEXTURE_SWIZZLE_RGBA = 0x8E46 + QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = 0x8E4C + FIRST_VERTEX_CONVENTION = 0x8E4D + LAST_VERTEX_CONVENTION = 0x8E4E + PROVOKING_VERTEX = 0x8E4F + SAMPLE_POSITION = 0x8E50 + SAMPLE_MASK = 0x8E51 + SAMPLE_MASK_VALUE = 0x8E52 + MAX_SAMPLE_MASK_WORDS = 0x8E59 + COPY_READ_BUFFER = 0x8F36 + COPY_WRITE_BUFFER = 0x8F37 + R8_SNORM = 0x8F94 + RG8_SNORM = 0x8F95 + RGB8_SNORM = 0x8F96 + RGBA8_SNORM = 0x8F97 + R16_SNORM = 0x8F98 + RG16_SNORM = 0x8F99 + RGB16_SNORM = 0x8F9A + RGBA16_SNORM = 0x8F9B + SIGNED_NORMALIZED = 0x8F9C + PRIMITIVE_RESTART = 0x8F9D + PRIMITIVE_RESTART_INDEX = 0x8F9E + RGB10_A2UI = 0x906F + TEXTURE_2D_MULTISAMPLE = 0x9100 + PROXY_TEXTURE_2D_MULTISAMPLE = 0x9101 + TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9102 + PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9103 + TEXTURE_BINDING_2D_MULTISAMPLE = 0x9104 + TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = 0x9105 + TEXTURE_SAMPLES = 0x9106 + TEXTURE_FIXED_SAMPLE_LOCATIONS = 0x9107 + SAMPLER_2D_MULTISAMPLE = 0x9108 + INT_SAMPLER_2D_MULTISAMPLE = 0x9109 + UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = 0x910A + SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910B + INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910C + UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910D + MAX_COLOR_TEXTURE_SAMPLES = 0x910E + MAX_DEPTH_TEXTURE_SAMPLES = 0x910F + MAX_INTEGER_SAMPLES = 0x9110 + MAX_SERVER_WAIT_TIMEOUT = 0x9111 + OBJECT_TYPE = 0x9112 + SYNC_CONDITION = 0x9113 + SYNC_STATUS = 0x9114 + SYNC_FLAGS = 0x9115 + SYNC_FENCE = 0x9116 + SYNC_GPU_COMMANDS_COMPLETE = 0x9117 + UNSIGNALED = 0x9118 + SIGNALED = 0x9119 + ALREADY_SIGNALED = 0x911A + TIMEOUT_EXPIRED = 0x911B + CONDITION_SATISFIED = 0x911C + WAIT_FAILED = 0x911D + BUFFER_ACCESS_FLAGS = 0x911F + BUFFER_MAP_LENGTH = 0x9120 + BUFFER_MAP_OFFSET = 0x9121 + MAX_VERTEX_OUTPUT_COMPONENTS = 0x9122 + MAX_GEOMETRY_INPUT_COMPONENTS = 0x9123 + MAX_GEOMETRY_OUTPUT_COMPONENTS = 0x9124 + MAX_FRAGMENT_INPUT_COMPONENTS = 0x9125 + CONTEXT_PROFILE_MASK = 0x9126 +) + +// https://www.opengl.org/sdk/docs/man3/xhtml/glViewport.xml +func (gl *GL) Viewport(x, y, width, height int) { + C.gl3_3compat_glViewport(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// DepthRange specifies the mapping of depth values from normalized device +// coordinates to window coordinates. +// +// Parameter nearVal specifies the mapping of the near clipping plane to window +// coordinates (defaults to 0), while farVal specifies the mapping of the far +// clipping plane to window coordinates (defaults to 1). +// +// After clipping and division by w, depth coordinates range from -1 to 1, +// corresponding to the near and far clipping planes. DepthRange specifies a +// linear mapping of the normalized depth coordinates in this range to window +// depth coordinates. Regardless of the actual depth buffer implementation, +// window coordinate depth values are treated as though they range from 0 through 1 +// (like color components). Thus, the values accepted by DepthRange are both +// clamped to this range before they are accepted. +// +// The default setting of (0, 1) maps the near plane to 0 and the far plane to 1. +// With this mapping, the depth buffer range is fully utilized. +// +// It is not necessary that nearVal be less than farVal. Reverse mappings such as +// nearVal 1, and farVal 0 are acceptable. +// +// GL.INVALID_OPERATION is generated if DepthRange is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) DepthRange(nearVal, farVal float64) { + C.gl3_3compat_glDepthRange(gl.funcs, C.GLdouble(nearVal), C.GLdouble(farVal)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsEnabled.xml +func (gl *GL) IsEnabled(cap glbase.Enum) bool { + glresult := C.gl3_3compat_glIsEnabled(gl.funcs, C.GLenum(cap)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexLevelParameteriv.xml +func (gl *GL) GetTexLevelParameteriv(target glbase.Enum, level int, pname glbase.Enum, params []int32) { + C.gl3_3compat_glGetTexLevelParameteriv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexLevelParameterfv.xml +func (gl *GL) GetTexLevelParameterfv(target glbase.Enum, level int, pname glbase.Enum, params []float32) { + C.gl3_3compat_glGetTexLevelParameterfv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexParameteriv.xml +func (gl *GL) GetTexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_3compat_glGetTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexParameterfv.xml +func (gl *GL) GetTexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl3_3compat_glGetTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexImage.xml +func (gl *GL) GetTexImage(target glbase.Enum, level int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glGetTexImage(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetIntegerv.xml +func (gl *GL) GetIntegerv(pname glbase.Enum, params []int32) { + C.gl3_3compat_glGetIntegerv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetFloatv.xml +func (gl *GL) GetFloatv(pname glbase.Enum, params []float32) { + C.gl3_3compat_glGetFloatv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetError.xml +func (gl *GL) GetError() glbase.Enum { + glresult := C.gl3_3compat_glGetError(gl.funcs) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetDoublev.xml +func (gl *GL) GetDoublev(pname glbase.Enum, params []float64) { + C.gl3_3compat_glGetDoublev(gl.funcs, C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetBooleanv.xml +func (gl *GL) GetBooleanv(pname glbase.Enum, params []bool) { + C.gl3_3compat_glGetBooleanv(gl.funcs, C.GLenum(pname), (*C.GLboolean)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glReadPixels.xml +func (gl *GL) ReadPixels(x, y, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glReadPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glReadBuffer.xml +func (gl *GL) ReadBuffer(mode glbase.Enum) { + C.gl3_3compat_glReadBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPixelStorei.xml +func (gl *GL) PixelStorei(pname glbase.Enum, param int32) { + C.gl3_3compat_glPixelStorei(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPixelStoref.xml +func (gl *GL) PixelStoref(pname glbase.Enum, param float32) { + C.gl3_3compat_glPixelStoref(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDepthFunc.xml +func (gl *GL) DepthFunc(glfunc glbase.Enum) { + C.gl3_3compat_glDepthFunc(gl.funcs, C.GLenum(glfunc)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilOp.xml +func (gl *GL) StencilOp(fail, zfail, zpass glbase.Enum) { + C.gl3_3compat_glStencilOp(gl.funcs, C.GLenum(fail), C.GLenum(zfail), C.GLenum(zpass)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilFunc.xml +func (gl *GL) StencilFunc(glfunc glbase.Enum, ref int32, mask uint32) { + C.gl3_3compat_glStencilFunc(gl.funcs, C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLogicOp.xml +func (gl *GL) LogicOp(opcode glbase.Enum) { + C.gl3_3compat_glLogicOp(gl.funcs, C.GLenum(opcode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlendFunc.xml +func (gl *GL) BlendFunc(sfactor, dfactor glbase.Enum) { + C.gl3_3compat_glBlendFunc(gl.funcs, C.GLenum(sfactor), C.GLenum(dfactor)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFlush.xml +func (gl *GL) Flush() { + C.gl3_3compat_glFlush(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFinish.xml +func (gl *GL) Finish() { + C.gl3_3compat_glFinish(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEnable.xml +func (gl *GL) Enable(cap glbase.Enum) { + C.gl3_3compat_glEnable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDisable.xml +func (gl *GL) Disable(cap glbase.Enum) { + C.gl3_3compat_glDisable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDepthMask.xml +func (gl *GL) DepthMask(flag bool) { + C.gl3_3compat_glDepthMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorMask.xml +func (gl *GL) ColorMask(red, green, blue, alpha bool) { + C.gl3_3compat_glColorMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&red)), *(*C.GLboolean)(unsafe.Pointer(&green)), *(*C.GLboolean)(unsafe.Pointer(&blue)), *(*C.GLboolean)(unsafe.Pointer(&alpha))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilMask.xml +func (gl *GL) StencilMask(mask uint32) { + C.gl3_3compat_glStencilMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearDepth.xml +func (gl *GL) ClearDepth(depth float64) { + C.gl3_3compat_glClearDepth(gl.funcs, C.GLdouble(depth)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearStencil.xml +func (gl *GL) ClearStencil(s int32) { + C.gl3_3compat_glClearStencil(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearColor.xml +func (gl *GL) ClearColor(red, green, blue, alpha float32) { + C.gl3_3compat_glClearColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClear.xml +func (gl *GL) Clear(mask glbase.Bitfield) { + C.gl3_3compat_glClear(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawBuffer.xml +func (gl *GL) DrawBuffer(mode glbase.Enum) { + C.gl3_3compat_glDrawBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexImage2D.xml +func (gl *GL) TexImage2D(target glbase.Enum, level int, internalFormat int32, width, height, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexImage1D.xml +func (gl *GL) TexImage1D(target glbase.Enum, level int, internalFormat int32, width, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameteriv.xml +func (gl *GL) TexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_3compat_glTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameteri.xml +func (gl *GL) TexParameteri(target, pname glbase.Enum, param int32) { + C.gl3_3compat_glTexParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameterfv.xml +func (gl *GL) TexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl3_3compat_glTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameterf.xml +func (gl *GL) TexParameterf(target, pname glbase.Enum, param float32) { + C.gl3_3compat_glTexParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glScissor.xml +func (gl *GL) Scissor(x, y, width, height int) { + C.gl3_3compat_glScissor(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPolygonMode.xml +func (gl *GL) PolygonMode(face, mode glbase.Enum) { + C.gl3_3compat_glPolygonMode(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPointSize.xml +func (gl *GL) PointSize(size float32) { + C.gl3_3compat_glPointSize(gl.funcs, C.GLfloat(size)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLineWidth.xml +func (gl *GL) LineWidth(width float32) { + C.gl3_3compat_glLineWidth(gl.funcs, C.GLfloat(width)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glHint.xml +func (gl *GL) Hint(target, mode glbase.Enum) { + C.gl3_3compat_glHint(gl.funcs, C.GLenum(target), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFrontFace.xml +func (gl *GL) FrontFace(mode glbase.Enum) { + C.gl3_3compat_glFrontFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCullFace.xml +func (gl *GL) CullFace(mode glbase.Enum) { + C.gl3_3compat_glCullFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexubv.xml +func (gl *GL) Indexubv(c []uint8) { + C.gl3_3compat_glIndexubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexub.xml +func (gl *GL) Indexub(c uint8) { + C.gl3_3compat_glIndexub(gl.funcs, C.GLubyte(c)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsTexture.xml +func (gl *GL) IsTexture(texture glbase.Texture) bool { + glresult := C.gl3_3compat_glIsTexture(gl.funcs, C.GLuint(texture)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenTextures returns n texture names in textures. There is no guarantee +// that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenTextures. +// +// The generated textures have no dimensionality; they assume the +// dimensionality of the texture target to which they are first bound (see +// BindTexture). +// +// Texture names returned by a call to GenTextures are not returned by +// subsequent calls, unless they are first deleted with DeleteTextures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenTextures is available in GL version 2.0 or greater. +func (gl *GL) GenTextures(n int) []glbase.Texture { + if n == 0 { + return nil + } + textures := make([]glbase.Texture, n) + C.gl3_3compat_glGenTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) + return textures +} + +// DeleteTextures deletes the textures objects whose names are stored +// in the textures slice. After a texture is deleted, it has no contents or +// dimensionality, and its name is free for reuse (for example by +// GenTextures). If a texture that is currently bound is deleted, the binding +// reverts to 0 (the default texture). +// +// DeleteTextures silently ignores 0's and names that do not correspond to +// existing textures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteTextures is available in GL version 2.0 or greater. +func (gl *GL) DeleteTextures(textures []glbase.Texture) { + n := len(textures) + if n == 0 { + return + } + C.gl3_3compat_glDeleteTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindTexture.xml +func (gl *GL) BindTexture(target glbase.Enum, texture glbase.Texture) { + C.gl3_3compat_glBindTexture(gl.funcs, C.GLenum(target), C.GLuint(texture)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexSubImage2D.xml +func (gl *GL) TexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexSubImage1D.xml +func (gl *GL) TexSubImage1D(target glbase.Enum, level, xoffset, width int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyTexSubImage2D.xml +func (gl *GL) CopyTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, x, y, width, height int) { + C.gl3_3compat_glCopyTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyTexSubImage1D.xml +func (gl *GL) CopyTexSubImage1D(target glbase.Enum, level, xoffset, x, y, width int) { + C.gl3_3compat_glCopyTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyTexImage2D.xml +func (gl *GL) CopyTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, height, border int) { + C.gl3_3compat_glCopyTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyTexImage1D.xml +func (gl *GL) CopyTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, border int) { + C.gl3_3compat_glCopyTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPolygonOffset.xml +func (gl *GL) PolygonOffset(factor, units float32) { + C.gl3_3compat_glPolygonOffset(gl.funcs, C.GLfloat(factor), C.GLfloat(units)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawElements.xml +func (gl *GL) DrawElements(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glDrawElements(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawArrays.xml +func (gl *GL) DrawArrays(mode glbase.Enum, first, count int) { + C.gl3_3compat_glDrawArrays(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyTexSubImage3D.xml +func (gl *GL) CopyTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, x, y, width, height int) { + C.gl3_3compat_glCopyTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexSubImage3D.xml +func (gl *GL) TexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexImage3D.xml +func (gl *GL) TexImage3D(target glbase.Enum, level int, internalFormat int32, width, height int, depth int32, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawRangeElements.xml +func (gl *GL) DrawRangeElements(mode glbase.Enum, start, end uint32, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glDrawRangeElements(gl.funcs, C.GLenum(mode), C.GLuint(start), C.GLuint(end), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlendEquation.xml +func (gl *GL) BlendEquation(mode glbase.Enum) { + C.gl3_3compat_glBlendEquation(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlendColor.xml +func (gl *GL) BlendColor(red, green, blue, alpha float32) { + C.gl3_3compat_glBlendColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetCompressedTexImage.xml +func (gl *GL) GetCompressedTexImage(target glbase.Enum, level int, img interface{}) { + var img_ptr unsafe.Pointer + var img_v = reflect.ValueOf(img) + if img != nil && img_v.Kind() != reflect.Slice { + panic("parameter img must be a slice") + } + if img != nil { + img_ptr = unsafe.Pointer(img_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glGetCompressedTexImage(gl.funcs, C.GLenum(target), C.GLint(level), img_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexSubImage1D.xml +func (gl *GL) CompressedTexSubImage1D(target glbase.Enum, level, xoffset, width int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glCompressedTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexSubImage2D.xml +func (gl *GL) CompressedTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glCompressedTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexSubImage3D.xml +func (gl *GL) CompressedTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glCompressedTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexImage1D.xml +func (gl *GL) CompressedTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, width, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glCompressedTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexImage2D.xml +func (gl *GL) CompressedTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glCompressedTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexImage3D.xml +func (gl *GL) CompressedTexImage3D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height int, depth int32, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glCompressedTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSampleCoverage.xml +func (gl *GL) SampleCoverage(value float32, invert bool) { + C.gl3_3compat_glSampleCoverage(gl.funcs, C.GLfloat(value), *(*C.GLboolean)(unsafe.Pointer(&invert))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glActiveTexture.xml +func (gl *GL) ActiveTexture(texture glbase.Enum) { + C.gl3_3compat_glActiveTexture(gl.funcs, C.GLenum(texture)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPointParameteriv.xml +func (gl *GL) PointParameteriv(pname glbase.Enum, params []int32) { + C.gl3_3compat_glPointParameteriv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPointParameteri.xml +func (gl *GL) PointParameteri(pname glbase.Enum, param int32) { + C.gl3_3compat_glPointParameteri(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPointParameterfv.xml +func (gl *GL) PointParameterfv(pname glbase.Enum, params []float32) { + C.gl3_3compat_glPointParameterfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPointParameterf.xml +func (gl *GL) PointParameterf(pname glbase.Enum, param float32) { + C.gl3_3compat_glPointParameterf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiDrawArrays.xml +func (gl *GL) MultiDrawArrays(mode glbase.Enum, first, count []int, drawcount int32) { + C.gl3_3compat_glMultiDrawArrays(gl.funcs, C.GLenum(mode), (*C.GLint)(unsafe.Pointer(&first[0])), (*C.GLsizei)(unsafe.Pointer(&count[0])), C.GLsizei(drawcount)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlendFuncSeparate.xml +func (gl *GL) BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha glbase.Enum) { + C.gl3_3compat_glBlendFuncSeparate(gl.funcs, C.GLenum(sfactorRGB), C.GLenum(dfactorRGB), C.GLenum(sfactorAlpha), C.GLenum(dfactorAlpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetBufferParameteriv.xml +func (gl *GL) GetBufferParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_3compat_glGetBufferParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glUnmapBuffer.xml +func (gl *GL) UnmapBuffer(target glbase.Enum) bool { + glresult := C.gl3_3compat_glUnmapBuffer(gl.funcs, C.GLenum(target)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetBufferSubData.xml +func (gl *GL) GetBufferSubData(target glbase.Enum, offset, size int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glGetBufferSubData(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(size), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBufferSubData.xml +func (gl *GL) BufferSubData(target glbase.Enum, offset, size int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glBufferSubData(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(size), data_ptr) +} + +// BufferData creates a new data store for the buffer object currently +// bound to target. Any pre-existing data store is deleted. The new data +// store is created with the specified size in bytes and usage. If data is +// not nil, it must be a slice that is used to initialize the data store. +// In that case the size parameter is ignored and the store size will match +// the slice data size. +// +// In its initial state, the new data store is not mapped, it has a NULL +// mapped pointer, and its mapped access is GL.READ_WRITE. +// +// The target constant must be one of GL.ARRAY_BUFFER, GL.COPY_READ_BUFFER, +// GL.COPY_WRITE_BUFFER, GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER, +// GL.PIXEL_UNPACK_BUFFER, GL.TEXTURE_BUFFER, GL.TRANSFORM_FEEDBACK_BUFFER, +// or GL.UNIFORM_BUFFER. +// +// The usage parameter is a hint to the GL implementation as to how a buffer +// object's data store will be accessed. This enables the GL implementation +// to make more intelligent decisions that may significantly impact buffer +// object performance. It does not, however, constrain the actual usage of +// the data store. usage can be broken down into two parts: first, the +// frequency of access (modification and usage), and second, the nature of +// that access. +// +// A usage frequency of STREAM and nature of DRAW is specified via the +// constant GL.STREAM_DRAW, for example. +// +// The usage frequency of access may be one of: +// +// STREAM +// The data store contents will be modified once and used at most a few times. +// +// STATIC +// The data store contents will be modified once and used many times. +// +// DYNAMIC +// The data store contents will be modified repeatedly and used many times. +// +// The usage nature of access may be one of: +// +// DRAW +// The data store contents are modified by the application, and used as +// the source for GL drawing and image specification commands. +// +// READ +// The data store contents are modified by reading data from the GL, +// and used to return that data when queried by the application. +// +// COPY +// The data store contents are modified by reading data from the GL, +// and used as the source for GL drawing and image specification +// commands. +// +// Clients must align data elements consistent with the requirements of the +// client platform, with an additional base-level requirement that an offset +// within a buffer to a datum comprising N bytes be a multiple of N. +// +// Error GL.INVALID_ENUM is generated if target is not one of the accepted +// buffer targets. GL.INVALID_ENUM is generated if usage is not +// GL.STREAM_DRAW, GL.STREAM_READ, GL.STREAM_COPY, GL.STATIC_DRAW, +// GL.STATIC_READ, GL.STATIC_COPY, GL.DYNAMIC_DRAW, GL.DYNAMIC_READ, or +// GL.DYNAMIC_COPY. GL.INVALID_VALUE is generated if size is negative. +// GL.INVALID_OPERATION is generated if the reserved buffer object name 0 is +// bound to target. GL.OUT_OF_MEMORY is generated if the GL is unable to +// create a data store with the specified size. +func (gl *GL) BufferData(target glbase.Enum, size int, data interface{}, usage glbase.Enum) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + if data != nil { + size = int(data_v.Type().Size()) * data_v.Len() + } + C.gl3_3compat_glBufferData(gl.funcs, C.GLenum(target), C.GLsizeiptr(size), data_ptr, C.GLenum(usage)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsBuffer.xml +func (gl *GL) IsBuffer(buffer glbase.Buffer) bool { + glresult := C.gl3_3compat_glIsBuffer(gl.funcs, C.GLuint(buffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenBuffers returns n buffer object names. There is no guarantee that +// the names form a contiguous set of integers; however, it is guaranteed +// that none of the returned names was in use immediately before the call to +// GenBuffers. +// +// Buffer object names returned by a call to GenBuffers are not returned by +// subsequent calls, unless they are first deleted with DeleteBuffers. +// +// No buffer objects are associated with the returned buffer object names +// until they are first bound by calling BindBuffer. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if GenBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// GenBuffers is available in GL version 1.5 or greater. +func (gl *GL) GenBuffers(n int) []glbase.Buffer { + if n == 0 { + return nil + } + buffers := make([]glbase.Buffer, n) + C.gl3_3compat_glGenBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) + return buffers +} + +// DeleteBuffers deletes the buffer objects whose names are stored in the +// buffers slice. +// +// After a buffer object is deleted, it has no contents, and its name is free +// for reuse (for example by GenBuffers). If a buffer object that is +// currently bound is deleted, the binding reverts to 0 (the absence of any +// buffer object, which reverts to client memory usage). +// +// DeleteBuffers silently ignores 0's and names that do not correspond to +// existing buffer objects. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if DeleteBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// DeleteBuffers is available in GL version 1.5 or greater. +func (gl *GL) DeleteBuffers(buffers []glbase.Buffer) { + n := len(buffers) + if n == 0 { + return + } + C.gl3_3compat_glDeleteBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) +} + +// BindBuffer creates or puts in use a named buffer object. +// Calling BindBuffer with target set to GL.ARRAY_BUFFER, +// GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER or GL.PIXEL_UNPACK_BUFFER +// and buffer set to the name of the new buffer object binds the buffer +// object name to the target. When a buffer object is bound to a target, the +// previous binding for that target is automatically broken. +// +// Buffer object names are unsigned integers. The value zero is reserved, but +// there is no default buffer object for each buffer object target. Instead, +// buffer set to zero effectively unbinds any buffer object previously bound, +// and restores client memory usage for that buffer object target. Buffer +// object names and the corresponding buffer object contents are local to the +// shared display-list space (see XCreateContext) of the current GL rendering +// context; two rendering contexts share buffer object names only if they +// also share display lists. +// +// GenBuffers may be called to generate a set of new buffer object names. +// +// The state of a buffer object immediately after it is first bound is an +// unmapped zero-sized memory buffer with GL.READ_WRITE access and +// GL.STATIC_DRAW usage. +// +// While a non-zero buffer object name is bound, GL operations on the target +// to which it is bound affect the bound buffer object, and queries of the +// target to which it is bound return state from the bound buffer object. +// While buffer object name zero is bound, as in the initial state, attempts +// to modify or query state on the target to which it is bound generates an +// GL.INVALID_OPERATION error. +// +// When vertex array pointer state is changed, for example by a call to +// NormalPointer, the current buffer object binding (GL.ARRAY_BUFFER_BINDING) +// is copied into the corresponding client state for the vertex array type +// being changed, for example GL.NORMAL_ARRAY_BUFFER_BINDING. While a +// non-zero buffer object is bound to the GL.ARRAY_BUFFER target, the vertex +// array pointer parameter that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.ELEMENT_ARRAY_BUFFER +// target, the indices parameter of DrawElements, DrawRangeElements, or +// MultiDrawElements that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_PACK_BUFFER +// target, the following commands are affected: GetCompressedTexImage, +// GetConvolutionFilter, GetHistogram, GetMinmax, GetPixelMap, +// GetPolygonStipple, GetSeparableFilter, GetTexImage, and ReadPixels. The +// pointer parameter that is traditionally interpreted as a pointer to +// client-side memory where the pixels are to be packed is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_UNPACK_BUFFER +// target, the following commands are affected: Bitmap, ColorSubTable, +// ColorTable, CompressedTexImage1D, CompressedTexImage2D, +// CompressedTexImage3D, CompressedTexSubImage1D, CompressedTexSubImage2D, +// CompressedTexSubImage3D, ConvolutionFilter1D, ConvolutionFilter2D, +// DrawPixels, PixelMap, PolygonStipple, SeparableFilter2D, TexImage1D, +// TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, and TexSubImage3D. +// The pointer parameter that is traditionally interpreted as a pointer to +// client-side memory from which the pixels are to be unpacked is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// A buffer object binding created with BindBuffer remains active until a +// different buffer object name is bound to the same target, or until the +// bound buffer object is deleted with DeleteBuffers. +// +// Once created, a named buffer object may be re-bound to any target as often +// as needed. However, the GL implementation may make choices about how to +// optimize the storage of a buffer object based on its initial binding +// target. +// +// Error GL.INVALID_ENUM is generated if target is not one of the allowable +// values. GL.INVALID_OPERATION is generated if BindBuffer is executed +// between the execution of Begin and the corresponding execution of End. +// +// BindBuffer is available in GL version 1.5 or greater. +func (gl *GL) BindBuffer(target glbase.Enum, buffer glbase.Buffer) { + C.gl3_3compat_glBindBuffer(gl.funcs, C.GLenum(target), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetQueryObjectuiv.xml +func (gl *GL) GetQueryObjectuiv(id uint32, pname glbase.Enum, params []uint32) { + C.gl3_3compat_glGetQueryObjectuiv(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetQueryObjectiv.xml +func (gl *GL) GetQueryObjectiv(id uint32, pname glbase.Enum, params []int32) { + C.gl3_3compat_glGetQueryObjectiv(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetQueryiv.xml +func (gl *GL) GetQueryiv(target, pname glbase.Enum, params []int32) { + C.gl3_3compat_glGetQueryiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEndQuery.xml +func (gl *GL) EndQuery(target glbase.Enum) { + C.gl3_3compat_glEndQuery(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBeginQuery.xml +func (gl *GL) BeginQuery(target glbase.Enum, id uint32) { + C.gl3_3compat_glBeginQuery(gl.funcs, C.GLenum(target), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsQuery.xml +func (gl *GL) IsQuery(id uint32) bool { + glresult := C.gl3_3compat_glIsQuery(gl.funcs, C.GLuint(id)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDeleteQueries.xml +func (gl *GL) DeleteQueries(n int, ids []uint32) { + C.gl3_3compat_glDeleteQueries(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGenQueries.xml +func (gl *GL) GenQueries(n int, ids []uint32) { + C.gl3_3compat_glGenQueries(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// VertexAttribPointer specifies the location and data format of the array +// of generic vertex attributes at index to use when rendering. size +// specifies the number of components per attribute and must be 1, 2, 3, or +// 4. type specifies the data type of each component, and stride specifies +// the byte stride from one attribute to the next, allowing vertices and +// attributes to be packed into a single array or stored in separate arrays. +// normalized indicates whether the values stored in an integer format are +// to be mapped to the range [-1,1] (for signed values) or [0,1] +// (for unsigned values) when they are accessed and converted to floating +// point; otherwise, values will be converted to floats directly without +// normalization. offset is a byte offset into the buffer object's data +// store, which must be bound to the GL.ARRAY_BUFFER target with BindBuffer. +// +// The buffer object binding (GL.ARRAY_BUFFER_BINDING) is saved as +// generic vertex attribute array client-side state +// (GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING) for the provided index. +// +// To enable and disable a generic vertex attribute array, call +// EnableVertexAttribArray and DisableVertexAttribArray with index. If +// enabled, the generic vertex attribute array is used when DrawArrays or +// DrawElements is called. Each generic vertex attribute array is initially +// disabled. +// +// VertexAttribPointer is typically implemented on the client side. +// +// Error GL.INVALID_ENUM is generated if type is not an accepted value. +// GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_VALUE is generated if size is not 1, 2, +// 3, or 4. GL.INVALID_VALUE is generated if stride is negative. +func (gl *GL) VertexAttribPointer(index glbase.Attrib, size int, gltype glbase.Enum, normalized bool, stride int, offset uintptr) { + offset_ptr := unsafe.Pointer(offset) + C.gl3_3compat_glVertexAttribPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLsizei(stride), offset_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glValidateProgram.xml +func (gl *GL) ValidateProgram(program glbase.Program) { + C.gl3_3compat_glValidateProgram(gl.funcs, C.GLuint(program)) +} + +// UniformMatrix4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*4) != 0 { + panic("invalid value length for UniformMatrix4fv") + } + count := len(value) / (4 * 4) + C.gl3_3compat_glUniformMatrix4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*3) != 0 { + panic("invalid value length for UniformMatrix3fv") + } + count := len(value) / (3 * 3) + C.gl3_3compat_glUniformMatrix3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*2) != 0 { + panic("invalid value length for UniformMatrix2fv") + } + count := len(value) / (2 * 2) + C.gl3_3compat_glUniformMatrix2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform4iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4iv") + } + count := len(value) / 4 + C.gl3_3compat_glUniform4iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform3iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3iv") + } + count := len(value) / 3 + C.gl3_3compat_glUniform3iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform2iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2iv") + } + count := len(value) / 2 + C.gl3_3compat_glUniform2iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform1iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl3_3compat_glUniform1iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4fv") + } + count := len(value) / 4 + C.gl3_3compat_glUniform4fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3fv") + } + count := len(value) / 3 + C.gl3_3compat_glUniform3fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2fv") + } + count := len(value) / 2 + C.gl3_3compat_glUniform2fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform1fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl3_3compat_glUniform1fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform4i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4i(location glbase.Uniform, v0, v1, v2, v3 int32) { + C.gl3_3compat_glUniform4i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2), C.GLint(v3)) +} + +// Uniform3i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3i(location glbase.Uniform, v0, v1, v2 int32) { + C.gl3_3compat_glUniform3i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2)) +} + +// Uniform2i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2i(location glbase.Uniform, v0, v1 int32) { + C.gl3_3compat_glUniform2i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1)) +} + +// Uniform1i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1i(location glbase.Uniform, v0 int32) { + C.gl3_3compat_glUniform1i(gl.funcs, C.GLint(location), C.GLint(v0)) +} + +// Uniform4f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4f(location glbase.Uniform, v0, v1, v2, v3 float32) { + C.gl3_3compat_glUniform4f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2), C.GLfloat(v3)) +} + +// Uniform3f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3f(location glbase.Uniform, v0, v1, v2 float32) { + C.gl3_3compat_glUniform3f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2)) +} + +// Uniform2f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2f(location glbase.Uniform, v0, v1 float32) { + C.gl3_3compat_glUniform2f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1)) +} + +// Uniform1f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1f(location glbase.Uniform, v0 float32) { + C.gl3_3compat_glUniform1f(gl.funcs, C.GLint(location), C.GLfloat(v0)) +} + +// UseProgram installs the program object specified by program as part of +// current rendering state. One or more executables are created in a program +// object by successfully attaching shader objects to it with AttachShader, +// successfully compiling the shader objects with CompileShader, and +// successfully linking the program object with LinkProgram. +// +// A program object will contain an executable that will run on the vertex +// processor if it contains one or more shader objects of type +// GL.VERTEX_SHADER that have been successfully compiled and linked. +// Similarly, a program object will contain an executable that will run on +// the fragment processor if it contains one or more shader objects of type +// GL.FRAGMENT_SHADER that have been successfully compiled and linked. +// +// Successfully installing an executable on a programmable processor will +// cause the corresponding fixed functionality of OpenGL to be disabled. +// Specifically, if an executable is installed on the vertex processor, the +// OpenGL fixed functionality will be disabled as follows. +// +// - The modelview matrix is not applied to vertex coordinates. +// +// - The projection matrix is not applied to vertex coordinates. +// +// - The texture matrices are not applied to texture coordinates. +// +// - Normals are not transformed to eye coordinates. +// +// - Normals are not rescaled or normalized. +// +// - Normalization of GL.AUTO_NORMAL evaluated normals is not performed. +// +// - Texture coordinates are not generated automatically. +// +// - Per-vertex lighting is not performed. +// +// - Color material computations are not performed. +// +// - Color index lighting is not performed. +// +// - This list also applies when setting the current raster position. +// +// The executable that is installed on the vertex processor is expected to +// implement any or all of the desired functionality from the preceding list. +// Similarly, if an executable is installed on the fragment processor, the +// OpenGL fixed functionality will be disabled as follows. +// +// - Texture environment and texture functions are not applied. +// +// - Texture application is not applied. +// +// - Color sum is not applied. +// +// - Fog is not applied. +// +// Again, the fragment shader that is installed is expected to implement any +// or all of the desired functionality from the preceding list. +// +// While a program object is in use, applications are free to modify attached +// shader objects, compile attached shader objects, attach additional shader +// objects, and detach or delete shader objects. None of these operations +// will affect the executables that are part of the current state. However, +// relinking the program object that is currently in use will install the +// program object as part of the current rendering state if the link +// operation was successful (see LinkProgram). If the program object +// currently in use is relinked unsuccessfully, its link status will be set +// to GL.FALSE, but the executables and associated state will remain part of +// the current state until a subsequent call to UseProgram removes it from +// use. After it is removed from use, it cannot be made part of current state +// until it has been successfully relinked. +// +// If program contains shader objects of type GL.VERTEX_SHADER but it does +// not contain shader objects of type GL.FRAGMENT_SHADER, an executable will +// be installed on the vertex processor, but fixed functionality will be used +// for fragment processing. Similarly, if program contains shader objects of +// type GL.FRAGMENT_SHADER but it does not contain shader objects of type +// GL.VERTEX_SHADER, an executable will be installed on the fragment +// processor, but fixed functionality will be used for vertex processing. If +// program is 0, the programmable processors will be disabled, and fixed +// functionality will be used for both vertex and fragment processing. +// +// While a program object is in use, the state that controls the disabled +// fixed functionality may also be updated using the normal OpenGL calls. +// +// Like display lists and texture objects, the name space for program objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// Applications are responsible for providing the synchronization across API +// calls when objects are accessed from different execution threads. +// +// Error GL.INVALID_VALUE is generated if program is neither 0 nor a value +// generated by OpenGL. GL.INVALID_OPERATION is generated if program is not +// a program object. GL.INVALID_OPERATION is generated if program could not +// be made part of current state. GL.INVALID_OPERATION is generated if +// UseProgram is executed between the execution of Begin and the +// corresponding execution of End. +// +// UseProgram is available in GL version 2.0 or greater. +func (gl *GL) UseProgram(program glbase.Program) { + C.gl3_3compat_glUseProgram(gl.funcs, C.GLuint(program)) +} + +// ShaderSource sets the source code in shader to the provided source code. Any source +// code previously stored in the shader object is completely replaced. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_VALUE is generated if count is less than 0. +// GL.INVALID_OPERATION is generated if ShaderSource is executed between the +// execution of Begin and the corresponding execution of End. +// +// ShaderSource is available in GL version 2.0 or greater. +func (gl *GL) ShaderSource(shader glbase.Shader, source ...string) { + count := len(source) + length := make([]int32, count) + source_c := make([]unsafe.Pointer, count) + for i, src := range source { + length[i] = int32(len(src)) + if len(src) > 0 { + source_c[i] = *(*unsafe.Pointer)(unsafe.Pointer(&src)) + } else { + source_c[i] = unsafe.Pointer(uintptr(0)) + } + } + C.gl3_3compat_glShaderSource(gl.funcs, C.GLuint(shader), C.GLsizei(count), (**C.GLchar)(unsafe.Pointer(&source_c[0])), (*C.GLint)(unsafe.Pointer(&length[0]))) +} + +// LinkProgram links the program object specified by program. If any shader +// objects of type GL.VERTEX_SHADER are attached to program, they will be +// used to create an executable that will run on the programmable vertex +// processor. If any shader objects of type GL.FRAGMENT_SHADER are attached +// to program, they will be used to create an executable that will run on the +// programmable fragment processor. +// +// The status of the link operation will be stored as part of the program +// object's state. This value will be set to GL.TRUE if the program object +// was linked without errors and is ready for use, and GL.FALSE otherwise. It +// can be queried by calling GetProgramiv with arguments program and +// GL.LINK_STATUS. +// +// As a result of a successful link operation, all active user-defined +// uniform variables belonging to program will be initialized to 0, and each +// of the program object's active uniform variables will be assigned a +// location that can be queried by calling GetUniformLocation. Also, any +// active user-defined attribute variables that have not been bound to a +// generic vertex attribute index will be bound to one at this time. +// +// Linking of a program object can fail for a number of reasons as specified +// in the OpenGL Shading Language Specification. The following lists some of +// the conditions that will cause a link error. +// +// - The number of active attribute variables supported by the +// implementation has been exceeded. +// +// - The storage limit for uniform variables has been exceeded. +// +// - The number of active uniform variables supported by the implementation +// has been exceeded. +// +// - The main function is missing for the vertex shader or the fragment +// shader. +// +// - A varying variable actually used in the fragment shader is not +// declared in the same way (or is not declared at all) in the vertex +// shader. +// +// - A reference to a function or variable name is unresolved. +// +// - A shared global is declared with two different types or two different +// initial values. +// +// - One or more of the attached shader objects has not been successfully +// compiled. +// +// - Binding a generic attribute matrix caused some rows of the matrix to +// fall outside the allowed maximum of GL.MAX_VERTEX_ATTRIBS. +// +// - Not enough contiguous vertex attribute slots could be found to bind +// attribute matrices. +// +// When a program object has been successfully linked, the program object can +// be made part of current state by calling UseProgram. Whether or not the +// link operation was successful, the program object's information log will +// be overwritten. The information log can be retrieved by calling +// GetProgramInfoLog. +// +// LinkProgram will also install the generated executables as part of the +// current rendering state if the link operation was successful and the +// specified program object is already currently in use as a result of a +// previous call to UseProgram. If the program object currently in use is +// relinked unsuccessfully, its link status will be set to GL.FALSE , but the +// executables and associated state will remain part of the current state +// until a subsequent call to UseProgram removes it from use. After it is +// removed from use, it cannot be made part of current state until it has +// been successfully relinked. +// +// If program contains shader objects of type GL.VERTEX_SHADER but does not +// contain shader objects of type GL.FRAGMENT_SHADER, the vertex shader will +// be linked against the implicit interface for fixed functionality fragment +// processing. Similarly, if program contains shader objects of type +// GL.FRAGMENT_SHADER but it does not contain shader objects of type +// GL.VERTEX_SHADER, the fragment shader will be linked against the implicit +// interface for fixed functionality vertex processing. +// +// The program object's information log is updated and the program is +// generated at the time of the link operation. After the link operation, +// applications are free to modify attached shader objects, compile attached +// shader objects, detach shader objects, delete shader objects, and attach +// additional shader objects. None of these operations affects the +// information log or the program that is part of the program object. +// +// If the link operation is unsuccessful, any information about a previous +// link operation on program is lost (a failed link does not restore the +// old state of program). Certain information can still be retrieved +// from program even after an unsuccessful link operation. See for instance +// GetActiveAttrib and GetActiveUniform. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if LinkProgram is executed +// between the execution of Begin and the corresponding execution of End. +// +// LinkProgram is available in GL version 2.0 or greater. +func (gl *GL) LinkProgram(program glbase.Program) { + C.gl3_3compat_glLinkProgram(gl.funcs, C.GLuint(program)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsShader.xml +func (gl *GL) IsShader(shader glbase.Shader) bool { + glresult := C.gl3_3compat_glIsShader(gl.funcs, C.GLuint(shader)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsProgram.xml +func (gl *GL) IsProgram(program glbase.Program) bool { + glresult := C.gl3_3compat_glIsProgram(gl.funcs, C.GLuint(program)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GetVertexAttribiv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribiv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribiv(index glbase.Attrib, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl3_3compat_glGetVertexAttribiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetVertexAttribfv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribfv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribfv(index glbase.Attrib, pname glbase.Enum, params []float32) { + var params_c [4]float32 + C.gl3_3compat_glGetVertexAttribfv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetVertexAttribdv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribdv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribdv(index glbase.Attrib, pname glbase.Enum, params []float64) { + var params_c [4]float64 + C.gl3_3compat_glGetVertexAttribdv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformiv returns in params the value of the specified uniform +// variable. The type of the uniform variable specified by location +// determines the number of values returned. If the uniform variable is +// defined in the shader as a boolean, int, or float, a single value will be +// returned. If it is defined as a vec2, ivec2, or bvec2, two values will be +// returned. If it is defined as a vec3, ivec3, or bvec3, three values will +// be returned, and so on. To query values stored in uniform variables +// declared as arrays, call GetUniformiv for each element of the array. To +// query values stored in uniform variables declared as structures, call +// GetUniformiv for each field in the structure. The values for uniform +// variables declared as a matrix will be returned in column major order. +// +// The locations assigned to uniform variables are not known until the +// program object is linked. After linking has occurred, the command +// GetUniformLocation can be used to obtain the location of a uniform +// variable. This location value can then be passed to GetUniformiv in order +// to query the current value of the uniform variable. After a program object +// has been linked successfully, the index values for uniform variables +// remain fixed until the next link command occurs. The uniform variable +// values can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if program has not been +// successfully linked. GL.INVALID_OPERATION is generated if location does +// not correspond to a valid uniform variable location for the specified +// program object. GL.INVALID_OPERATION is generated if GetUniformiv is +// executed between the execution of Begin and the corresponding execution of +// End. +// +// GetUniformiv is available in GL version 2.0 or greater. +func (gl *GL) GetUniformiv(program glbase.Program, location glbase.Uniform, params []int32) { + var params_c [4]int32 + C.gl3_3compat_glGetUniformiv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformfv returns in params the value of the specified uniform +// variable. The type of the uniform variable specified by location +// determines the number of values returned. If the uniform variable is +// defined in the shader as a boolean, int, or float, a single value will be +// returned. If it is defined as a vec2, ivec2, or bvec2, two values will be +// returned. If it is defined as a vec3, ivec3, or bvec3, three values will +// be returned, and so on. To query values stored in uniform variables +// declared as arrays, call GetUniformfv for each element of the array. To +// query values stored in uniform variables declared as structures, call +// GetUniformfv for each field in the structure. The values for uniform +// variables declared as a matrix will be returned in column major order. +// +// The locations assigned to uniform variables are not known until the +// program object is linked. After linking has occurred, the command +// GetUniformLocation can be used to obtain the location of a uniform +// variable. This location value can then be passed to GetUniformfv in order +// to query the current value of the uniform variable. After a program object +// has been linked successfully, the index values for uniform variables +// remain fixed until the next link command occurs. The uniform variable +// values can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if program has not been +// successfully linked. GL.INVALID_OPERATION is generated if location does +// not correspond to a valid uniform variable location for the specified +// program object. GL.INVALID_OPERATION is generated if GetUniformfv is +// executed between the execution of Begin and the corresponding execution of +// End. +// +// GetUniformfv is available in GL version 2.0 or greater. +func (gl *GL) GetUniformfv(program glbase.Program, location glbase.Uniform, params []float32) { + var params_c [4]float32 + C.gl3_3compat_glGetUniformfv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLfloat)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformLocation returns an integer that represents the location of a +// specific uniform variable within a program object. name must be an active +// uniform variable name in program that is not a structure, an array of +// structures, or a subcomponent of a vector or a matrix. This function +// returns -1 if name does not correspond to an active uniform variable in +// program or if name starts with the reserved prefix "gl_". +// +// Uniform variables that are structures or arrays of structures may be +// queried by calling GetUniformLocation for each field within the +// structure. The array element operator "[]" and the structure field +// operator "." may be used in name in order to select elements within an +// array or fields within a structure. The result of using these operators is +// not allowed to be another structure, an array of structures, or a +// subcomponent of a vector or a matrix. Except if the last part of name +// indicates a uniform variable array, the location of the first element of +// an array can be retrieved by using the name of the array, or by using the +// name appended by "[0]". +// +// The actual locations assigned to uniform variables are not known until the +// program object is linked successfully. After linking has occurred, the +// command GetUniformLocation can be used to obtain the location of a +// uniform variable. This location value can then be passed to Uniform to +// set the value of the uniform variable or to GetUniform in order to query +// the current value of the uniform variable. After a program object has been +// linked successfully, the index values for uniform variables remain fixed +// until the next link command occurs. Uniform variable locations and values +// can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program object. +// GL.INVALID_OPERATION is generated if program has not been successfully +// linked. GL.INVALID_OPERATION is generated if GetUniformLocation is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetUniformLocation is available in GL version 2.0 or greater. +func (gl *GL) GetUniformLocation(program glbase.Program, name string) glbase.Uniform { + name_cstr := C.CString(name) + glresult := C.gl3_3compat_glGetUniformLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) + return glbase.Uniform(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetShaderSource.xml +func (gl *GL) GetShaderSource(shader glbase.Shader, bufSize int32, length []int32, source []byte) { + C.gl3_3compat_glGetShaderSource(gl.funcs, C.GLuint(shader), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&source[0]))) +} + +// GetShaderInfoLog returns the information log for the specified shader +// object. The information log for a shader object is modified when the +// shader is compiled. +// +// The information log for a shader object is a string that may contain +// diagnostic messages, warning messages, and other information about the +// last compile operation. When a shader object is created, its information +// log will be a string of length 0, and the size of the current log can be +// obtained by calling GetShaderiv with the value GL.INFO_LOG_LENGTH. +// +// The information log for a shader object is the OpenGL implementer's +// primary mechanism for conveying information about the compilation process. +// Therefore, the information log can be helpful to application developers +// during the development process, even when compilation is successful. +// Application developers should not expect different OpenGL implementations +// to produce identical information logs. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_VALUE is generated if maxLength is less than 0. +// GL.INVALID_OPERATION is generated if GetShaderInfoLog is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetShaderInfoLog is available in GL version 2.0 or greater. +func (gl *GL) GetShaderInfoLog(shader glbase.Shader) []byte { + var params [1]int32 + var length int32 + gl.GetShaderiv(shader, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + C.gl3_3compat_glGetShaderInfoLog(gl.funcs, C.GLuint(shader), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length)), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) + return infoLog +} + +// GetShaderiv GetShader returns in params the value of a parameter for a specific +// shader object. The following parameters are defined: +// +// GL.SHADER_TYPE +// params returns GL.VERTEX_SHADER if shader is a vertex shader object, +// and GL.FRAGMENT_SHADER if shader is a fragment shader object. +// +// GL.DELETE_STATUS +// params returns GL.TRUE if shader is currently flagged for deletion, +// and GL.FALSE otherwise. +// +// GL.COMPILE_STATUS +// params returns GL.TRUE if the last compile operation on shader was +// successful, and GL.FALSE otherwise. +// +// GL.INFO_LOG_LENGTH +// params returns the number of characters in the information log for +// shader including the null termination character (the size of the +// character buffer required to store the information log). If shader has +// no information log, a value of 0 is returned. +// +// GL.SHADER_SOURCE_LENGTH +// params returns the length of the concatenation of the source strings +// that make up the shader source for the shader, including the null +// termination character. (the size of the character buffer +// required to store the shader source). If no source code exists, 0 is +// returned. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader does not refer to a +// shader object. GL.INVALID_ENUM is generated if pname is not an accepted +// value. GL.INVALID_OPERATION is generated if GetShader is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetShaderiv is available in GL version 2.0 or greater. +func (gl *GL) GetShaderiv(shader glbase.Shader, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl3_3compat_glGetShaderiv(gl.funcs, C.GLuint(shader), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetProgramInfoLog returns the information log for the specified program +// object. The information log for a program object is modified when the +// program object is linked or validated. +// +// The information log for a program object is either an empty string, or a +// string containing information about the last link operation, or a string +// containing information about the last validation operation. It may contain +// diagnostic messages, warning messages, and other information. When a +// program object is created, its information log will be a string of length +// 0, and the size of the current log can be obtained by calling GetProgramiv +// with the value GL.INFO_LOG_LENGTH. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated +// by OpenGL. GL.INVALID_OPERATION is generated if program is not a +// program object. +func (gl *GL) GetProgramInfoLog(program glbase.Program) []byte { + var params [1]int32 + var length int32 + gl.GetProgramiv(program, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + C.gl3_3compat_glGetProgramInfoLog(gl.funcs, C.GLuint(program), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length)), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) + return infoLog +} + +// GetProgramiv returns in params the value of a parameter for a specific +// program object. The following parameters are defined: +// +// GL.DELETE_STATUS +// params returns GL.TRUE if program is currently flagged for deletion, +// and GL.FALSE otherwise. +// +// GL.LINK_STATUS +// params returns GL.TRUE if the last link operation on program was +// successful, and GL.FALSE otherwise. +// +// GL.VALIDATE_STATUS +// params returns GL.TRUE or if the last validation operation on +// program was successful, and GL.FALSE otherwise. +// +// GL.INFO_LOG_LENGTH +// params returns the number of characters in the information log for +// program including the null termination character (the size of +// the character buffer required to store the information log). If +// program has no information log, a value of 0 is returned. +// +// GL.ATTACHED_SHADERS +// params returns the number of shader objects attached to program. +// +// GL.ACTIVE_ATTRIBUTES +// params returns the number of active attribute variables for program. +// +// GL.ACTIVE_ATTRIBUTE_MAX_LENGTH +// params returns the length of the longest active attribute name for +// program, including the null termination character (the size of +// the character buffer required to store the longest attribute name). +// If no active attributes exist, 0 is returned. +// +// GL.ACTIVE_UNIFORMS +// params returns the number of active uniform variables for program. +// +// GL.ACTIVE_UNIFORM_MAX_LENGTH +// params returns the length of the longest active uniform variable +// name for program, including the null termination character (i.e., +// the size of the character buffer required to store the longest +// uniform variable name). If no active uniform variables exist, 0 is +// returned. +// +// GL.TRANSFORM_FEEDBACK_BUFFER_MODE +// params returns a symbolic constant indicating the buffer mode used +// when transform feedback is active. This may be GL.SEPARATE_ATTRIBS +// or GL.INTERLEAVED_ATTRIBS. +// +// GL.TRANSFORM_FEEDBACK_VARYINGS +// params returns the number of varying variables to capture in transform +// feedback mode for the program. +// +// GL.TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH +// params returns the length of the longest variable name to be used for +// transform feedback, including the null-terminator. +// +// GL.GEOMETRY_VERTICES_OUT +// params returns the maximum number of vertices that the geometry shader in +// program will output. +// +// GL.GEOMETRY_INPUT_TYPE +// params returns a symbolic constant indicating the primitive type accepted +// as input to the geometry shader contained in program. +// +// GL.GEOMETRY_OUTPUT_TYPE +// params returns a symbolic constant indicating the primitive type that will +// be output by the geometry shader contained in program. +// +// GL.ACTIVE_UNIFORM_BLOCKS and GL.ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH are +// available only if the GL version 3.1 or greater. +// +// GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE and +// GL.GEOMETRY_OUTPUT_TYPE are accepted only if the GL version is 3.2 or +// greater. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program does not refer to a +// program object. GL.INVALID_OPERATION is generated if pname is +// GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE, or +// GL.GEOMETRY_OUTPUT_TYPE, and program does not contain a geometry shader. +// GL.INVALID_ENUM is generated if pname is not an accepted value. +func (gl *GL) GetProgramiv(program glbase.Program, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl3_3compat_glGetProgramiv(gl.funcs, C.GLuint(program), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetAttribLocation queries the previously linked program object specified +// by program for the attribute variable specified by name and returns the +// index of the generic vertex attribute that is bound to that attribute +// variable. If name is a matrix attribute variable, the index of the first +// column of the matrix is returned. If the named attribute variable is not +// an active attribute in the specified program object or if name starts with +// the reserved prefix "gl_", a value of -1 is returned. +// +// The association between an attribute variable name and a generic attribute +// index can be specified at any time by calling BindAttribLocation. +// Attribute bindings do not go into effect until LinkProgram is called. +// After a program object has been linked successfully, the index values for +// attribute variables remain fixed until the next link command occurs. The +// attribute values can only be queried after a link if the link was +// successful. GetAttribLocation returns the binding that actually went +// into effect the last time LinkProgram was called for the specified +// program object. Attribute bindings that have been specified since the last +// link operation are not returned by GetAttribLocation. +// +// Error GL_INVALID_OPERATION is generated if program is not a value +// generated by OpenGL. GL_INVALID_OPERATION is generated if program is not +// a program object. GL_INVALID_OPERATION is generated if program has not +// been successfully linked. GL_INVALID_OPERATION is generated if +// GetAttribLocation is executed between the execution of Begin and the +// corresponding execution of End. +// +// GetAttribLocation is available in GL version 2.0 or greater. +func (gl *GL) GetAttribLocation(program glbase.Program, name string) glbase.Attrib { + name_cstr := C.CString(name) + glresult := C.gl3_3compat_glGetAttribLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) + return glbase.Attrib(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetAttachedShaders.xml +func (gl *GL) GetAttachedShaders(program glbase.Program, maxCount int32, count []int, obj []uint32) { + C.gl3_3compat_glGetAttachedShaders(gl.funcs, C.GLuint(program), C.GLsizei(maxCount), (*C.GLsizei)(unsafe.Pointer(&count[0])), (*C.GLuint)(unsafe.Pointer(&obj[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetActiveUniform.xml +func (gl *GL) GetActiveUniform(program glbase.Program, index uint32, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl3_3compat_glGetActiveUniform(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetActiveAttrib.xml +func (gl *GL) GetActiveAttrib(program glbase.Program, index glbase.Attrib, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl3_3compat_glGetActiveAttrib(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEnableVertexAttribArray.xml +func (gl *GL) EnableVertexAttribArray(index glbase.Attrib) { + C.gl3_3compat_glEnableVertexAttribArray(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDisableVertexAttribArray.xml +func (gl *GL) DisableVertexAttribArray(index glbase.Attrib) { + C.gl3_3compat_glDisableVertexAttribArray(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDetachShader.xml +func (gl *GL) DetachShader(program glbase.Program, shader glbase.Shader) { + C.gl3_3compat_glDetachShader(gl.funcs, C.GLuint(program), C.GLuint(shader)) +} + +// DeleteShader frees the memory and invalidates the name associated with +// the shader object specified by shader. This command effectively undoes the +// effects of a call to CreateShader. +// +// If a shader object to be deleted is attached to a program object, it will +// be flagged for deletion, but it will not be deleted until it is no longer +// attached to any program object, for any rendering context (it must +// be detached from wherever it was attached before it will be deleted). A +// value of 0 for shader will be silently ignored. +// +// To determine whether an object has been flagged for deletion, call +// GetShader with arguments shader and GL.DELETE_STATUS. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. +// +// DeleteShader is available in GL version 2.0 or greater. +func (gl *GL) DeleteShader(shader glbase.Shader) { + C.gl3_3compat_glDeleteShader(gl.funcs, C.GLuint(shader)) +} + +// DeleteProgram frees the memory and invalidates the name associated with +// the program object specified by program. This command effectively undoes +// the effects of a call to CreateProgram. +// +// If a program object is in use as part of current rendering state, it will +// be flagged for deletion, but it will not be deleted until it is no longer +// part of current state for any rendering context. If a program object to be +// deleted has shader objects attached to it, those shader objects will be +// automatically detached but not deleted unless they have already been +// flagged for deletion by a previous call to DeleteShader. A value of 0 +// for program will be silently ignored. +// +// To determine whether a program object has been flagged for deletion, call +// GetProgram with arguments program and GL.DELETE_STATUS. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. +// +// DeleteProgram is available in GL version 2.0 or greater. +func (gl *GL) DeleteProgram(program glbase.Program) { + C.gl3_3compat_glDeleteProgram(gl.funcs, C.GLuint(program)) +} + +// CreateShader creates an empty shader object and returns a non-zero value +// by which it can be referenced. A shader object is used to maintain the +// source code strings that define a shader. shaderType indicates the type of +// shader to be created. +// +// Two types of shaders are supported. A shader of type GL.VERTEX_SHADER is a +// shader that is intended to run on the programmable vertex processor and +// replace the fixed functionality vertex processing in OpenGL. A shader of +// type GL.FRAGMENT_SHADER is a shader that is intended to run on the +// programmable fragment processor and replace the fixed functionality +// fragment processing in OpenGL. +// +// When created, a shader object's GL.SHADER_TYPE parameter is set to either +// GL.VERTEX_SHADER or GL.FRAGMENT_SHADER, depending on the value of +// shaderType. +// +// Like display lists and texture objects, the name space for shader objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// This function returns 0 if an error occurs creating the shader object. +// +// Error GL.INVALID_ENUM is generated if shaderType is not an accepted value. +// GL.INVALID_OPERATION is generated if CreateShader is executed between the +// execution of Begin and the corresponding execution of End. +// +// CreateShader is available in GL version 2.0 or greater. +func (gl *GL) CreateShader(gltype glbase.Enum) glbase.Shader { + glresult := C.gl3_3compat_glCreateShader(gl.funcs, C.GLenum(gltype)) + return glbase.Shader(glresult) +} + +// CreateProgram creates an empty program object and returns a non-zero +// value by which it can be referenced. A program object is an object to +// which shader objects can be attached. This provides a mechanism to specify +// the shader objects that will be linked to create a program. It also +// provides a means for checking the compatibility of the shaders that will +// be used to create a program (for instance, checking the compatibility +// between a vertex shader and a fragment shader). When no longer needed as +// part of a program object, shader objects can be detached. +// +// One or more executables are created in a program object by successfully +// attaching shader objects to it with AttachShader, successfully compiling +// the shader objects with CompileShader, and successfully linking the +// program object with LinkProgram. These executables are made part of +// current state when UseProgram is called. Program objects can be deleted +// by calling DeleteProgram. The memory associated with the program object +// will be deleted when it is no longer part of current rendering state for +// any context. +// +// Like display lists and texture objects, the name space for program objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// Applications are responsible for providing the synchronization across API +// calls when objects are accessed from different execution threads. +// +// This function returns 0 if an error occurs creating the program object. +// +// Error GL.INVALID_OPERATION is generated if CreateProgram is executed +// between the execution of Begin and the corresponding execution of End. +// +// CreateProgram is available in GL version 2.0 or greater. +func (gl *GL) CreateProgram() glbase.Program { + glresult := C.gl3_3compat_glCreateProgram(gl.funcs) + return glbase.Program(glresult) +} + +// CompileShader compiles the source code strings that have been stored in +// the shader object specified by shader. +// +// The compilation status will be stored as part of the shader object's +// state. This value will be set to GL.TRUE if the shader was compiled without +// errors and is ready for use, and GL.FALSE otherwise. It can be queried by +// calling GetShaderiv with arguments shader and GL.COMPILE_STATUS. +// +// Compilation of a shader can fail for a number of reasons as specified by +// the OpenGL Shading Language Specification. Whether or not the compilation +// was successful, information about the compilation can be obtained from the +// shader object's information log by calling GetShaderInfoLog. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_OPERATION is generated if CompileShader is executed +// between the execution of Begin and the corresponding execution of End. +// +// CompileShader is available in GL version 2.0 or greater. +func (gl *GL) CompileShader(shader glbase.Shader) { + C.gl3_3compat_glCompileShader(gl.funcs, C.GLuint(shader)) +} + +// BindAttribLocation associates a user-defined attribute variable in the program +// object specified by program with a generic vertex attribute index. The name +// parameter specifies the name of the vertex shader attribute variable to +// which index is to be bound. When program is made part of the current state, +// values provided via the generic vertex attribute index will modify the +// value of the user-defined attribute variable specified by name. +// +// If name refers to a matrix attribute variable, index refers to the first +// column of the matrix. Other matrix columns are then automatically bound to +// locations index+1 for a matrix of type mat2; index+1 and index+2 for a +// matrix of type mat3; and index+1, index+2, and index+3 for a matrix of +// type mat4. +// +// This command makes it possible for vertex shaders to use descriptive names +// for attribute variables rather than generic variables that are numbered +// from 0 to GL.MAX_VERTEX_ATTRIBS-1. The values sent to each generic +// attribute index are part of current state, just like standard vertex +// attributes such as color, normal, and vertex position. If a different +// program object is made current by calling UseProgram, the generic vertex +// attributes are tracked in such a way that the same values will be observed +// by attributes in the new program object that are also bound to index. +// +// Attribute variable name-to-generic attribute index bindings for a program +// object can be explicitly assigned at any time by calling +// BindAttribLocation. Attribute bindings do not go into effect until +// LinkProgram is called. After a program object has been linked +// successfully, the index values for generic attributes remain fixed (and +// their values can be queried) until the next link command occurs. +// +// Applications are not allowed to bind any of the standard OpenGL vertex +// attributes using this command, as they are bound automatically when +// needed. Any attribute binding that occurs after the program object has +// been linked will not take effect until the next time the program object is +// linked. +// +// If name was bound previously, that information is lost. Thus you cannot +// bind one user-defined attribute variable to multiple indices, but you can +// bind multiple user-defined attribute variables to the same index. +// +// Applications are allowed to bind more than one user-defined attribute +// variable to the same generic vertex attribute index. This is called +// aliasing, and it is allowed only if just one of the aliased attributes is +// active in the executable program, or if no path through the shader +// consumes more than one attribute of a set of attributes aliased to the +// same location. The compiler and linker are allowed to assume that no +// aliasing is done and are free to employ optimizations that work only in +// the absence of aliasing. OpenGL implementations are not required to do +// error checking to detect aliasing. Because there is no way to bind +// standard attributes, it is not possible to alias generic attributes with +// conventional ones (except for generic attribute 0). +// +// BindAttribLocation can be called before any vertex shader objects are +// bound to the specified program object. It is also permissible to bind a +// generic attribute index to an attribute variable name that is never used +// in a vertex shader. +// +// Active attributes that are not explicitly bound will be bound by the +// linker when LinkProgram is called. The locations assigned can be queried +// by calling GetAttribLocation. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. +// GL.INVALID_OPERATION is generated if name starts with the reserved prefix "gl_". +// GL.INVALID_VALUE is generated if program is not a value generated by OpenGL. +// GL.INVALID_OPERATION is generated if program is not a program object. +// GL.INVALID_OPERATION is generated if BindAttribLocation is executed +// between the execution of Begin and the corresponding execution of End. +// +// BindAttribLocation is available in GL version 2.0 or greater. +func (gl *GL) BindAttribLocation(program glbase.Program, index glbase.Attrib, name string) { + name_cstr := C.CString(name) + C.gl3_3compat_glBindAttribLocation(gl.funcs, C.GLuint(program), C.GLuint(index), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) +} + +// AttachShader attaches a shader object to a program object. +// +// In order to create an executable, there must be a way to specify the list +// of things that will be linked together. Program objects provide this +// mechanism. Shaders that are to be linked together in a program object must +// first be attached to that program object. This indicates that shader will +// be included in link operations that will be performed on program. +// +// All operations that can be performed on a shader object are valid whether +// or not the shader object is attached to a program object. It is +// permissible to attach a shader object to a program object before source +// code has been loaded into the shader object or before the shader object +// has been compiled. It is permissible to attach multiple shader objects of +// the same type because each may contain a portion of the complete shader. +// It is also permissible to attach a shader object to more than one program +// object. If a shader object is deleted while it is attached to a program +// object, it will be flagged for deletion, and deletion will not occur until +// DetachShader is called to detach it from all program objects to which it +// is attached. +// +// Error GL.INVALID_VALUE is generated if either program or shader is not a +// value generated by OpenGL. GL.INVALID_OPERATION is generated if program +// is not a program object. GL.INVALID_OPERATION is generated if shader is +// not a shader object. GL.INVALID_OPERATION is generated if shader is +// already attached to program. GL.INVALID_OPERATION is generated if +// AttachShader is executed between the execution of Begin and the +// corresponding execution of End. +// +// AttachShader is available in GL version 2.0 or greater. +func (gl *GL) AttachShader(program glbase.Program, shader glbase.Shader) { + C.gl3_3compat_glAttachShader(gl.funcs, C.GLuint(program), C.GLuint(shader)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilMaskSeparate.xml +func (gl *GL) StencilMaskSeparate(face glbase.Enum, mask uint32) { + C.gl3_3compat_glStencilMaskSeparate(gl.funcs, C.GLenum(face), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilFuncSeparate.xml +func (gl *GL) StencilFuncSeparate(face, glfunc glbase.Enum, ref int32, mask uint32) { + C.gl3_3compat_glStencilFuncSeparate(gl.funcs, C.GLenum(face), C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilOpSeparate.xml +func (gl *GL) StencilOpSeparate(face, sfail, dpfail, dppass glbase.Enum) { + C.gl3_3compat_glStencilOpSeparate(gl.funcs, C.GLenum(face), C.GLenum(sfail), C.GLenum(dpfail), C.GLenum(dppass)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawBuffers.xml +func (gl *GL) DrawBuffers(n int, bufs []glbase.Enum) { + C.gl3_3compat_glDrawBuffers(gl.funcs, C.GLsizei(n), (*C.GLenum)(unsafe.Pointer(&bufs[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlendEquationSeparate.xml +func (gl *GL) BlendEquationSeparate(modeRGB, modeAlpha glbase.Enum) { + C.gl3_3compat_glBlendEquationSeparate(gl.funcs, C.GLenum(modeRGB), C.GLenum(modeAlpha)) +} + +// UniformMatrix4x3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4x3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4x3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*3) != 0 { + panic("invalid value length for UniformMatrix4x3fv") + } + count := len(value) / (4 * 3) + C.gl3_3compat_glUniformMatrix4x3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3x4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3x4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3x4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*4) != 0 { + panic("invalid value length for UniformMatrix3x4fv") + } + count := len(value) / (3 * 4) + C.gl3_3compat_glUniformMatrix3x4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix4x2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4x2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4x2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*2) != 0 { + panic("invalid value length for UniformMatrix4x2fv") + } + count := len(value) / (4 * 2) + C.gl3_3compat_glUniformMatrix4x2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2x4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2x4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2x4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*4) != 0 { + panic("invalid value length for UniformMatrix2x4fv") + } + count := len(value) / (2 * 4) + C.gl3_3compat_glUniformMatrix2x4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3x2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3x2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3x2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*2) != 0 { + panic("invalid value length for UniformMatrix3x2fv") + } + count := len(value) / (3 * 2) + C.gl3_3compat_glUniformMatrix3x2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2x3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2x3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2x3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*3) != 0 { + panic("invalid value length for UniformMatrix2x3fv") + } + count := len(value) / (2 * 3) + C.gl3_3compat_glUniformMatrix2x3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsVertexArray.xml +func (gl *GL) IsVertexArray(array uint32) bool { + glresult := C.gl3_3compat_glIsVertexArray(gl.funcs, C.GLuint(array)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGenVertexArrays.xml +func (gl *GL) GenVertexArrays(n int, arrays []uint32) { + C.gl3_3compat_glGenVertexArrays(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&arrays[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDeleteVertexArrays.xml +func (gl *GL) DeleteVertexArrays(n int, arrays []uint32) { + C.gl3_3compat_glDeleteVertexArrays(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&arrays[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindVertexArray.xml +func (gl *GL) BindVertexArray(array uint32) { + C.gl3_3compat_glBindVertexArray(gl.funcs, C.GLuint(array)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFlushMappedBufferRange.xml +func (gl *GL) FlushMappedBufferRange(target glbase.Enum, offset, length int) { + C.gl3_3compat_glFlushMappedBufferRange(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(length)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFramebufferTextureLayer.xml +func (gl *GL) FramebufferTextureLayer(target, attachment glbase.Enum, texture glbase.Texture, level int, layer int32) { + C.gl3_3compat_glFramebufferTextureLayer(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLuint(texture), C.GLint(level), C.GLint(layer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRenderbufferStorageMultisample.xml +func (gl *GL) RenderbufferStorageMultisample(target glbase.Enum, samples int32, internalFormat glbase.Enum, width, height int) { + C.gl3_3compat_glRenderbufferStorageMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlitFramebuffer.xml +func (gl *GL) BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1 int32, mask glbase.Bitfield, filter glbase.Enum) { + C.gl3_3compat_glBlitFramebuffer(gl.funcs, C.GLint(srcX0), C.GLint(srcY0), C.GLint(srcX1), C.GLint(srcY1), C.GLint(dstX0), C.GLint(dstY0), C.GLint(dstX1), C.GLint(dstY1), C.GLbitfield(mask), C.GLenum(filter)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGenerateMipmap.xml +func (gl *GL) GenerateMipmap(target glbase.Enum) { + C.gl3_3compat_glGenerateMipmap(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetFramebufferAttachmentParameteriv.xml +func (gl *GL) GetFramebufferAttachmentParameteriv(target, attachment, pname glbase.Enum, params []int32) { + C.gl3_3compat_glGetFramebufferAttachmentParameteriv(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFramebufferRenderbuffer.xml +func (gl *GL) FramebufferRenderbuffer(target, attachment, renderbuffertarget glbase.Enum, renderbuffer glbase.Renderbuffer) { + C.gl3_3compat_glFramebufferRenderbuffer(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(renderbuffertarget), C.GLuint(renderbuffer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFramebufferTexture3D.xml +func (gl *GL) FramebufferTexture3D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int, zoffset int32) { + C.gl3_3compat_glFramebufferTexture3D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level), C.GLint(zoffset)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFramebufferTexture2D.xml +func (gl *GL) FramebufferTexture2D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int) { + C.gl3_3compat_glFramebufferTexture2D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFramebufferTexture1D.xml +func (gl *GL) FramebufferTexture1D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int) { + C.gl3_3compat_glFramebufferTexture1D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCheckFramebufferStatus.xml +func (gl *GL) CheckFramebufferStatus(target glbase.Enum) glbase.Enum { + glresult := C.gl3_3compat_glCheckFramebufferStatus(gl.funcs, C.GLenum(target)) + return glbase.Enum(glresult) +} + +// GenFramebuffers returns n framebuffer object names in ids. There is no +// guarantee that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenFramebuffers. +// +// Framebuffer object names returned by a call to GenFramebuffers are not +// returned by subsequent calls, unless they are first deleted with +// DeleteFramebuffers. +// +// The names returned in ids are marked as used, for the purposes of +// GenFramebuffers only, but they acquire state and type only when they are +// first bound. +// +// Error GL.INVALID_VALUE is generated if n is negative. +func (gl *GL) GenFramebuffers(n int) []glbase.Framebuffer { + if n == 0 { + return nil + } + framebuffers := make([]glbase.Framebuffer, n) + C.gl3_3compat_glGenFramebuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&framebuffers[0]))) + return framebuffers +} + +// DeleteFramebuffers deletes the framebuffer objects whose names are +// stored in the framebuffers slice. The name zero is reserved by the GL and +// is silently ignored, should it occur in framebuffers, as are other unused +// names. Once a framebuffer object is deleted, its name is again unused and +// it has no attachments. If a framebuffer that is currently bound to one or +// more of the targets GL.DRAW_FRAMEBUFFER or GL.READ_FRAMEBUFFER is deleted, +// it is as though BindFramebuffer had been executed with the corresponding +// target and framebuffer zero. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteFramebuffers is available in GL version 3.0 or greater. +func (gl *GL) DeleteFramebuffers(framebuffers []glbase.Framebuffer) { + n := len(framebuffers) + if n == 0 { + return + } + C.gl3_3compat_glDeleteFramebuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&framebuffers[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindFramebuffer.xml +func (gl *GL) BindFramebuffer(target glbase.Enum, framebuffer glbase.Framebuffer) { + C.gl3_3compat_glBindFramebuffer(gl.funcs, C.GLenum(target), C.GLuint(framebuffer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsFramebuffer.xml +func (gl *GL) IsFramebuffer(framebuffer glbase.Framebuffer) bool { + glresult := C.gl3_3compat_glIsFramebuffer(gl.funcs, C.GLuint(framebuffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetRenderbufferParameteriv.xml +func (gl *GL) GetRenderbufferParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_3compat_glGetRenderbufferParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRenderbufferStorage.xml +func (gl *GL) RenderbufferStorage(target, internalFormat glbase.Enum, width, height int) { + C.gl3_3compat_glRenderbufferStorage(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) +} + +// GenRenderbuffers returns n renderbuffer object names in renderbuffers. +// There is no guarantee that the names form a contiguous set of integers; +// however, it is guaranteed that none of the returned names was in use +// immediately before the call to GenRenderbuffers. +// +// Renderbuffer object names returned by a call to GenRenderbuffers are not +// returned by subsequent calls, unless they are first deleted with +// DeleteRenderbuffers. +// +// The names returned in renderbuffers are marked as used, for the purposes +// of GenRenderbuffers only, but they acquire state and type only when they +// are first bound. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenRenderbuffers is available in GL version 3.0 or greater. +func (gl *GL) GenRenderbuffers(n int) []glbase.Renderbuffer { + if n == 0 { + return nil + } + renderbuffers := make([]glbase.Renderbuffer, n) + C.gl3_3compat_glGenRenderbuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&renderbuffers[0]))) + return renderbuffers +} + +// DeleteRenderbuffers deletes the renderbuffer objects whose names are stored +// in the renderbuffers slice. The name zero is reserved by the GL and +// is silently ignored, should it occur in renderbuffers, as are other unused +// names. Once a renderbuffer object is deleted, its name is again unused and +// it has no contents. If a renderbuffer that is currently bound to the +// target GL.RENDERBUFFER is deleted, it is as though BindRenderbuffer had +// been executed with a target of GL.RENDERBUFFER and a name of zero. +// +// If a renderbuffer object is attached to one or more attachment points in +// the currently bound framebuffer, then it as if FramebufferRenderbuffer +// had been called, with a renderbuffer of zero for each attachment point to +// which this image was attached in the currently bound framebuffer. In other +// words, this renderbuffer object is first detached from all attachment +// ponits in the currently bound framebuffer. Note that the renderbuffer +// image is specifically not detached from any non-bound framebuffers. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteRenderbuffers is available in GL version 3.0 or greater. +func (gl *GL) DeleteRenderbuffers(renderbuffers []glbase.Renderbuffer) { + n := len(renderbuffers) + if n == 0 { + return + } + C.gl3_3compat_glDeleteRenderbuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&renderbuffers[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindRenderbuffer.xml +func (gl *GL) BindRenderbuffer(target glbase.Enum, renderbuffer glbase.Renderbuffer) { + C.gl3_3compat_glBindRenderbuffer(gl.funcs, C.GLenum(target), C.GLuint(renderbuffer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsRenderbuffer.xml +func (gl *GL) IsRenderbuffer(renderbuffer glbase.Renderbuffer) bool { + glresult := C.gl3_3compat_glIsRenderbuffer(gl.funcs, C.GLuint(renderbuffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearBufferfi.xml +func (gl *GL) ClearBufferfi(buffer glbase.Enum, drawbuffer int32, depth float32, stencil int32) { + C.gl3_3compat_glClearBufferfi(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), C.GLfloat(depth), C.GLint(stencil)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearBufferfv.xml +func (gl *GL) ClearBufferfv(buffer glbase.Enum, drawbuffer int32, value []float32) { + C.gl3_3compat_glClearBufferfv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearBufferuiv.xml +func (gl *GL) ClearBufferuiv(buffer glbase.Enum, drawbuffer int32, value []uint32) { + C.gl3_3compat_glClearBufferuiv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearBufferiv.xml +func (gl *GL) ClearBufferiv(buffer glbase.Enum, drawbuffer int32, value []int32) { + C.gl3_3compat_glClearBufferiv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexParameterIuiv.xml +func (gl *GL) GetTexParameterIuiv(target, pname glbase.Enum, params []uint32) { + C.gl3_3compat_glGetTexParameterIuiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexParameterIiv.xml +func (gl *GL) GetTexParameterIiv(target, pname glbase.Enum, params []int32) { + C.gl3_3compat_glGetTexParameterIiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameterIuiv.xml +func (gl *GL) TexParameterIuiv(target, pname glbase.Enum, params []uint32) { + C.gl3_3compat_glTexParameterIuiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameterIiv.xml +func (gl *GL) TexParameterIiv(target, pname glbase.Enum, params []int32) { + C.gl3_3compat_glTexParameterIiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// Uniform4uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4uiv") + } + count := len(value) / 4 + C.gl3_3compat_glUniform4uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform3uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3uiv") + } + count := len(value) / 3 + C.gl3_3compat_glUniform3uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform2uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2uiv") + } + count := len(value) / 2 + C.gl3_3compat_glUniform2uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform1uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl3_3compat_glUniform1uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform4ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4ui(location glbase.Uniform, v0, v1, v2, v3 uint32) { + C.gl3_3compat_glUniform4ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2), C.GLuint(v3)) +} + +// Uniform3ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3ui(location glbase.Uniform, v0, v1, v2 uint32) { + C.gl3_3compat_glUniform3ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2)) +} + +// Uniform2ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2ui(location glbase.Uniform, v0, v1 uint32) { + C.gl3_3compat_glUniform2ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1)) +} + +// Uniform1ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1ui(location glbase.Uniform, v0 uint32) { + C.gl3_3compat_glUniform1ui(gl.funcs, C.GLint(location), C.GLuint(v0)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetFragDataLocation.xml +func (gl *GL) GetFragDataLocation(program glbase.Program, name []byte) int32 { + glresult := C.gl3_3compat_glGetFragDataLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindFragDataLocation.xml +func (gl *GL) BindFragDataLocation(program glbase.Program, color uint32, name []byte) { + C.gl3_3compat_glBindFragDataLocation(gl.funcs, C.GLuint(program), C.GLuint(color), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetUniformuiv.xml +func (gl *GL) GetUniformuiv(program glbase.Program, location glbase.Uniform, params []uint32) { + C.gl3_3compat_glGetUniformuiv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetVertexAttribIuiv.xml +func (gl *GL) GetVertexAttribIuiv(index glbase.Attrib, pname glbase.Enum, params []uint32) { + C.gl3_3compat_glGetVertexAttribIuiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetVertexAttribIiv.xml +func (gl *GL) GetVertexAttribIiv(index glbase.Attrib, pname glbase.Enum, params []int32) { + C.gl3_3compat_glGetVertexAttribIiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribIPointer.xml +func (gl *GL) VertexAttribIPointer(index glbase.Attrib, size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glVertexAttribIPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEndConditionalRender.xml +func (gl *GL) EndConditionalRender() { + C.gl3_3compat_glEndConditionalRender(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBeginConditionalRender.xml +func (gl *GL) BeginConditionalRender(id uint32, mode glbase.Enum) { + C.gl3_3compat_glBeginConditionalRender(gl.funcs, C.GLuint(id), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClampColor.xml +func (gl *GL) ClampColor(target, clamp glbase.Enum) { + C.gl3_3compat_glClampColor(gl.funcs, C.GLenum(target), C.GLenum(clamp)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTransformFeedbackVarying.xml +func (gl *GL) GetTransformFeedbackVarying(program glbase.Program, index uint32, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl3_3compat_glGetTransformFeedbackVarying(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLsizei)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindBufferBase.xml +func (gl *GL) BindBufferBase(target glbase.Enum, index uint32, buffer glbase.Buffer) { + C.gl3_3compat_glBindBufferBase(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindBufferRange.xml +func (gl *GL) BindBufferRange(target glbase.Enum, index uint32, buffer glbase.Buffer, offset, size int) { + C.gl3_3compat_glBindBufferRange(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(buffer), C.GLintptr(offset), C.GLsizeiptr(size)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEndTransformFeedback.xml +func (gl *GL) EndTransformFeedback() { + C.gl3_3compat_glEndTransformFeedback(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBeginTransformFeedback.xml +func (gl *GL) BeginTransformFeedback(primitiveMode glbase.Enum) { + C.gl3_3compat_glBeginTransformFeedback(gl.funcs, C.GLenum(primitiveMode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsEnabledi.xml +func (gl *GL) IsEnabledi(target glbase.Enum, index uint32) bool { + glresult := C.gl3_3compat_glIsEnabledi(gl.funcs, C.GLenum(target), C.GLuint(index)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDisablei.xml +func (gl *GL) Disablei(target glbase.Enum, index uint32) { + C.gl3_3compat_glDisablei(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEnablei.xml +func (gl *GL) Enablei(target glbase.Enum, index uint32) { + C.gl3_3compat_glEnablei(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetIntegeri_v.xml +func (gl *GL) GetIntegeri_v(target glbase.Enum, index uint32, data []int32) { + C.gl3_3compat_glGetIntegeri_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLint)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetBooleani_v.xml +func (gl *GL) GetBooleani_v(target glbase.Enum, index uint32, data []bool) { + C.gl3_3compat_glGetBooleani_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLboolean)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorMaski.xml +func (gl *GL) ColorMaski(index uint32, r, g, b, a bool) { + C.gl3_3compat_glColorMaski(gl.funcs, C.GLuint(index), *(*C.GLboolean)(unsafe.Pointer(&r)), *(*C.GLboolean)(unsafe.Pointer(&g)), *(*C.GLboolean)(unsafe.Pointer(&b)), *(*C.GLboolean)(unsafe.Pointer(&a))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyBufferSubData.xml +func (gl *GL) CopyBufferSubData(readTarget, writeTarget glbase.Enum, readOffset, writeOffset, size int) { + C.gl3_3compat_glCopyBufferSubData(gl.funcs, C.GLenum(readTarget), C.GLenum(writeTarget), C.GLintptr(readOffset), C.GLintptr(writeOffset), C.GLsizeiptr(size)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glUniformBlockBinding.xml +func (gl *GL) UniformBlockBinding(program glbase.Program, v0, v1 uint32) { + C.gl3_3compat_glUniformBlockBinding(gl.funcs, C.GLuint(program), C.GLuint(v0), C.GLuint(v1)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetActiveUniformBlockName.xml +func (gl *GL) GetActiveUniformBlockName(program glbase.Program, uniformBlockIndex uint32, bufSize int32, length []int32, uniformBlockName []byte) { + C.gl3_3compat_glGetActiveUniformBlockName(gl.funcs, C.GLuint(program), C.GLuint(uniformBlockIndex), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&uniformBlockName[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetActiveUniformBlockiv.xml +func (gl *GL) GetActiveUniformBlockiv(program glbase.Program, uniformBlockIndex uint32, pname glbase.Enum, params []int32) { + C.gl3_3compat_glGetActiveUniformBlockiv(gl.funcs, C.GLuint(program), C.GLuint(uniformBlockIndex), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetUniformBlockIndex.xml +func (gl *GL) GetUniformBlockIndex(program glbase.Program, uniformBlockName []byte) uint32 { + glresult := C.gl3_3compat_glGetUniformBlockIndex(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&uniformBlockName[0]))) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetActiveUniformName.xml +func (gl *GL) GetActiveUniformName(program glbase.Program, uniformIndex uint32, bufSize int32, length []int32, uniformName []byte) { + C.gl3_3compat_glGetActiveUniformName(gl.funcs, C.GLuint(program), C.GLuint(uniformIndex), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&uniformName[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetActiveUniformsiv.xml +func (gl *GL) GetActiveUniformsiv(program glbase.Program, uniformCount int32, uniformIndices []uint32, pname glbase.Enum, params []int32) { + C.gl3_3compat_glGetActiveUniformsiv(gl.funcs, C.GLuint(program), C.GLsizei(uniformCount), (*C.GLuint)(unsafe.Pointer(&uniformIndices[0])), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPrimitiveRestartIndex.xml +func (gl *GL) PrimitiveRestartIndex(index uint32) { + C.gl3_3compat_glPrimitiveRestartIndex(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexBuffer.xml +func (gl *GL) TexBuffer(target, internalFormat glbase.Enum, buffer glbase.Buffer) { + C.gl3_3compat_glTexBuffer(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawElementsInstanced.xml +func (gl *GL) DrawElementsInstanced(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, instancecount int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glDrawElementsInstanced(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLsizei(instancecount)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawArraysInstanced.xml +func (gl *GL) DrawArraysInstanced(mode glbase.Enum, first, count int, instancecount int32) { + C.gl3_3compat_glDrawArraysInstanced(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count), C.GLsizei(instancecount)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSampleMaski.xml +func (gl *GL) SampleMaski(index uint32, mask glbase.Bitfield) { + C.gl3_3compat_glSampleMaski(gl.funcs, C.GLuint(index), C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetMultisamplefv.xml +func (gl *GL) GetMultisamplefv(pname glbase.Enum, index uint32, val []float32) { + C.gl3_3compat_glGetMultisamplefv(gl.funcs, C.GLenum(pname), C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&val[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexImage3DMultisample.xml +func (gl *GL) TexImage3DMultisample(target glbase.Enum, samples, internalFormat int32, width, height int, depth int32, fixedsamplelocations bool) { + C.gl3_3compat_glTexImage3DMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), *(*C.GLboolean)(unsafe.Pointer(&fixedsamplelocations))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexImage2DMultisample.xml +func (gl *GL) TexImage2DMultisample(target glbase.Enum, samples, internalFormat int32, width, height int, fixedsamplelocations bool) { + C.gl3_3compat_glTexImage2DMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), *(*C.GLboolean)(unsafe.Pointer(&fixedsamplelocations))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetSynciv.xml +func (gl *GL) GetSynciv(sync glbase.Sync, pname glbase.Enum, bufSize int32, length, values []int32) { + C.gl3_3compat_glGetSynciv(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLenum(pname), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetInteger64v.xml +func (gl *GL) GetInteger64v(pname glbase.Enum, params []int64) { + C.gl3_3compat_glGetInteger64v(gl.funcs, C.GLenum(pname), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWaitSync.xml +func (gl *GL) WaitSync(sync glbase.Sync, flags glbase.Bitfield, timeout uint64) { + C.gl3_3compat_glWaitSync(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLbitfield(flags), C.GLuint64(timeout)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClientWaitSync.xml +func (gl *GL) ClientWaitSync(sync glbase.Sync, flags glbase.Bitfield, timeout uint64) glbase.Enum { + glresult := C.gl3_3compat_glClientWaitSync(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLbitfield(flags), C.GLuint64(timeout)) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDeleteSync.xml +func (gl *GL) DeleteSync(sync glbase.Sync) { + C.gl3_3compat_glDeleteSync(gl.funcs, C.GLsync(unsafe.Pointer(sync))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsSync.xml +func (gl *GL) IsSync(sync glbase.Sync) bool { + glresult := C.gl3_3compat_glIsSync(gl.funcs, C.GLsync(unsafe.Pointer(sync))) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFenceSync.xml +func (gl *GL) FenceSync(condition glbase.Enum, flags glbase.Bitfield) glbase.Sync { + glresult := C.gl3_3compat_glFenceSync(gl.funcs, C.GLenum(condition), C.GLbitfield(flags)) + return glbase.Sync(unsafe.Pointer(glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glProvokingVertex.xml +func (gl *GL) ProvokingVertex(mode glbase.Enum) { + C.gl3_3compat_glProvokingVertex(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawElementsInstancedBaseVertex.xml +func (gl *GL) DrawElementsInstancedBaseVertex(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, instancecount, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glDrawElementsInstancedBaseVertex(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLsizei(instancecount), C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawRangeElementsBaseVertex.xml +func (gl *GL) DrawRangeElementsBaseVertex(mode glbase.Enum, start, end uint32, count int, gltype glbase.Enum, indices interface{}, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glDrawRangeElementsBaseVertex(gl.funcs, C.GLenum(mode), C.GLuint(start), C.GLuint(end), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawElementsBaseVertex.xml +func (gl *GL) DrawElementsBaseVertex(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glDrawElementsBaseVertex(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFramebufferTexture.xml +func (gl *GL) FramebufferTexture(target, attachment glbase.Enum, texture glbase.Texture, level int) { + C.gl3_3compat_glFramebufferTexture(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetBufferParameteri64v.xml +func (gl *GL) GetBufferParameteri64v(target, pname glbase.Enum, params []int64) { + C.gl3_3compat_glGetBufferParameteri64v(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetInteger64i_v.xml +func (gl *GL) GetInteger64i_v(target glbase.Enum, index uint32, data []int64) { + C.gl3_3compat_glGetInteger64i_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLint64)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribP4uiv.xml +func (gl *GL) VertexAttribP4uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl3_3compat_glVertexAttribP4uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribP4ui.xml +func (gl *GL) VertexAttribP4ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl3_3compat_glVertexAttribP4ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribP3uiv.xml +func (gl *GL) VertexAttribP3uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl3_3compat_glVertexAttribP3uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribP3ui.xml +func (gl *GL) VertexAttribP3ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl3_3compat_glVertexAttribP3ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribP2uiv.xml +func (gl *GL) VertexAttribP2uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl3_3compat_glVertexAttribP2uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribP2ui.xml +func (gl *GL) VertexAttribP2ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl3_3compat_glVertexAttribP2ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribP1uiv.xml +func (gl *GL) VertexAttribP1uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl3_3compat_glVertexAttribP1uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribP1ui.xml +func (gl *GL) VertexAttribP1ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl3_3compat_glVertexAttribP1ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColorP3uiv.xml +func (gl *GL) SecondaryColorP3uiv(gltype glbase.Enum, color []uint32) { + C.gl3_3compat_glSecondaryColorP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&color[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColorP3ui.xml +func (gl *GL) SecondaryColorP3ui(gltype glbase.Enum, color uint32) { + C.gl3_3compat_glSecondaryColorP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(color)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorP4uiv.xml +func (gl *GL) ColorP4uiv(gltype glbase.Enum, color []uint32) { + C.gl3_3compat_glColorP4uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&color[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorP4ui.xml +func (gl *GL) ColorP4ui(gltype glbase.Enum, color uint32) { + C.gl3_3compat_glColorP4ui(gl.funcs, C.GLenum(gltype), C.GLuint(color)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorP3uiv.xml +func (gl *GL) ColorP3uiv(gltype glbase.Enum, color []uint32) { + C.gl3_3compat_glColorP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&color[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorP3ui.xml +func (gl *GL) ColorP3ui(gltype glbase.Enum, color uint32) { + C.gl3_3compat_glColorP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(color)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormalP3uiv.xml +func (gl *GL) NormalP3uiv(gltype glbase.Enum, coords []uint32) { + C.gl3_3compat_glNormalP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormalP3ui.xml +func (gl *GL) NormalP3ui(gltype glbase.Enum, coords uint32) { + C.gl3_3compat_glNormalP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoordP4uiv.xml +func (gl *GL) MultiTexCoordP4uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl3_3compat_glMultiTexCoordP4uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoordP4ui.xml +func (gl *GL) MultiTexCoordP4ui(texture, gltype glbase.Enum, coords uint32) { + C.gl3_3compat_glMultiTexCoordP4ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoordP3uiv.xml +func (gl *GL) MultiTexCoordP3uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl3_3compat_glMultiTexCoordP3uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoordP3ui.xml +func (gl *GL) MultiTexCoordP3ui(texture, gltype glbase.Enum, coords uint32) { + C.gl3_3compat_glMultiTexCoordP3ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoordP2uiv.xml +func (gl *GL) MultiTexCoordP2uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl3_3compat_glMultiTexCoordP2uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoordP2ui.xml +func (gl *GL) MultiTexCoordP2ui(texture, gltype glbase.Enum, coords uint32) { + C.gl3_3compat_glMultiTexCoordP2ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoordP1uiv.xml +func (gl *GL) MultiTexCoordP1uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl3_3compat_glMultiTexCoordP1uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoordP1ui.xml +func (gl *GL) MultiTexCoordP1ui(texture, gltype glbase.Enum, coords uint32) { + C.gl3_3compat_glMultiTexCoordP1ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoordP4uiv.xml +func (gl *GL) TexCoordP4uiv(gltype glbase.Enum, coords []uint32) { + C.gl3_3compat_glTexCoordP4uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoordP4ui.xml +func (gl *GL) TexCoordP4ui(gltype glbase.Enum, coords uint32) { + C.gl3_3compat_glTexCoordP4ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoordP3uiv.xml +func (gl *GL) TexCoordP3uiv(gltype glbase.Enum, coords []uint32) { + C.gl3_3compat_glTexCoordP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoordP3ui.xml +func (gl *GL) TexCoordP3ui(gltype glbase.Enum, coords uint32) { + C.gl3_3compat_glTexCoordP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoordP2uiv.xml +func (gl *GL) TexCoordP2uiv(gltype glbase.Enum, coords []uint32) { + C.gl3_3compat_glTexCoordP2uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoordP2ui.xml +func (gl *GL) TexCoordP2ui(gltype glbase.Enum, coords uint32) { + C.gl3_3compat_glTexCoordP2ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoordP1uiv.xml +func (gl *GL) TexCoordP1uiv(gltype glbase.Enum, coords []uint32) { + C.gl3_3compat_glTexCoordP1uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoordP1ui.xml +func (gl *GL) TexCoordP1ui(gltype glbase.Enum, coords uint32) { + C.gl3_3compat_glTexCoordP1ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexP4uiv.xml +func (gl *GL) VertexP4uiv(gltype glbase.Enum, value []uint32) { + C.gl3_3compat_glVertexP4uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexP4ui.xml +func (gl *GL) VertexP4ui(gltype glbase.Enum, value uint32) { + C.gl3_3compat_glVertexP4ui(gl.funcs, C.GLenum(gltype), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexP3uiv.xml +func (gl *GL) VertexP3uiv(gltype glbase.Enum, value []uint32) { + C.gl3_3compat_glVertexP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexP3ui.xml +func (gl *GL) VertexP3ui(gltype glbase.Enum, value uint32) { + C.gl3_3compat_glVertexP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexP2uiv.xml +func (gl *GL) VertexP2uiv(gltype glbase.Enum, value []uint32) { + C.gl3_3compat_glVertexP2uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexP2ui.xml +func (gl *GL) VertexP2ui(gltype glbase.Enum, value uint32) { + C.gl3_3compat_glVertexP2ui(gl.funcs, C.GLenum(gltype), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetQueryObjectui64v.xml +func (gl *GL) GetQueryObjectui64v(id uint32, pname glbase.Enum, params []uint64) { + C.gl3_3compat_glGetQueryObjectui64v(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLuint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetQueryObjecti64v.xml +func (gl *GL) GetQueryObjecti64v(id uint32, pname glbase.Enum, params []int64) { + C.gl3_3compat_glGetQueryObjecti64v(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glQueryCounter.xml +func (gl *GL) QueryCounter(id uint32, target glbase.Enum) { + C.gl3_3compat_glQueryCounter(gl.funcs, C.GLuint(id), C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetSamplerParameterIuiv.xml +func (gl *GL) GetSamplerParameterIuiv(sampler uint32, pname glbase.Enum, params []uint32) { + C.gl3_3compat_glGetSamplerParameterIuiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetSamplerParameterfv.xml +func (gl *GL) GetSamplerParameterfv(sampler uint32, pname glbase.Enum, params []float32) { + C.gl3_3compat_glGetSamplerParameterfv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetSamplerParameterIiv.xml +func (gl *GL) GetSamplerParameterIiv(sampler uint32, pname glbase.Enum, params []int32) { + C.gl3_3compat_glGetSamplerParameterIiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetSamplerParameteriv.xml +func (gl *GL) GetSamplerParameteriv(sampler uint32, pname glbase.Enum, params []int32) { + C.gl3_3compat_glGetSamplerParameteriv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSamplerParameterIuiv.xml +func (gl *GL) SamplerParameterIuiv(sampler uint32, pname glbase.Enum, param []uint32) { + C.gl3_3compat_glSamplerParameterIuiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSamplerParameterIiv.xml +func (gl *GL) SamplerParameterIiv(sampler uint32, pname glbase.Enum, param []int32) { + C.gl3_3compat_glSamplerParameterIiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSamplerParameterfv.xml +func (gl *GL) SamplerParameterfv(sampler uint32, pname glbase.Enum, param []float32) { + C.gl3_3compat_glSamplerParameterfv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSamplerParameterf.xml +func (gl *GL) SamplerParameterf(sampler uint32, pname glbase.Enum, param float32) { + C.gl3_3compat_glSamplerParameterf(gl.funcs, C.GLuint(sampler), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSamplerParameteriv.xml +func (gl *GL) SamplerParameteriv(sampler uint32, pname glbase.Enum, param []int32) { + C.gl3_3compat_glSamplerParameteriv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSamplerParameteri.xml +func (gl *GL) SamplerParameteri(sampler uint32, pname glbase.Enum, param int32) { + C.gl3_3compat_glSamplerParameteri(gl.funcs, C.GLuint(sampler), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindSampler.xml +func (gl *GL) BindSampler(unit, sampler uint32) { + C.gl3_3compat_glBindSampler(gl.funcs, C.GLuint(unit), C.GLuint(sampler)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsSampler.xml +func (gl *GL) IsSampler(sampler uint32) bool { + glresult := C.gl3_3compat_glIsSampler(gl.funcs, C.GLuint(sampler)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDeleteSamplers.xml +func (gl *GL) DeleteSamplers(count int, samplers []uint32) { + C.gl3_3compat_glDeleteSamplers(gl.funcs, C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&samplers[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGenSamplers.xml +func (gl *GL) GenSamplers(count int, samplers []uint32) { + C.gl3_3compat_glGenSamplers(gl.funcs, C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&samplers[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetFragDataIndex.xml +func (gl *GL) GetFragDataIndex(program glbase.Program, name []byte) int32 { + glresult := C.gl3_3compat_glGetFragDataIndex(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindFragDataLocationIndexed.xml +func (gl *GL) BindFragDataLocationIndexed(program glbase.Program, colorNumber, index uint32, name []byte) { + C.gl3_3compat_glBindFragDataLocationIndexed(gl.funcs, C.GLuint(program), C.GLuint(colorNumber), C.GLuint(index), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribDivisor.xml +func (gl *GL) VertexAttribDivisor(index glbase.Attrib, divisor uint32) { + C.gl3_3compat_glVertexAttribDivisor(gl.funcs, C.GLuint(index), C.GLuint(divisor)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTranslatef.xml +func (gl *GL) Translatef(x, y, z float32) { + C.gl3_3compat_glTranslatef(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTranslated.xml +func (gl *GL) Translated(x, y, z float64) { + C.gl3_3compat_glTranslated(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glScalef.xml +func (gl *GL) Scalef(x, y, z float32) { + C.gl3_3compat_glScalef(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glScaled.xml +func (gl *GL) Scaled(x, y, z float64) { + C.gl3_3compat_glScaled(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRotatef.xml +func (gl *GL) Rotatef(angle, x, y, z float32) { + C.gl3_3compat_glRotatef(gl.funcs, C.GLfloat(angle), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRotated.xml +func (gl *GL) Rotated(angle, x, y, z float64) { + C.gl3_3compat_glRotated(gl.funcs, C.GLdouble(angle), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPushMatrix.xml +func (gl *GL) PushMatrix() { + C.gl3_3compat_glPushMatrix(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPopMatrix.xml +func (gl *GL) PopMatrix() { + C.gl3_3compat_glPopMatrix(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glOrtho.xml +func (gl *GL) Ortho(left, right, bottom, top, zNear, zFar float64) { + C.gl3_3compat_glOrtho(gl.funcs, C.GLdouble(left), C.GLdouble(right), C.GLdouble(bottom), C.GLdouble(top), C.GLdouble(zNear), C.GLdouble(zFar)) +} + +// MultMatrixd multiplies the current matrix with the provided matrix. +// +// The m parameter must hold 16 consecutive elements of a 4x4 column-major matrix. +// +// The current matrix is determined by the current matrix mode (see +// MatrixMode). It is either the projection matrix, modelview matrix, or the +// texture matrix. +// +// For example, if the current matrix is C and the coordinates to be transformed +// are v = (v[0], v[1], v[2], v[3]), then the current transformation is C × v, or +// +// c[0] c[4] c[8] c[12] v[0] +// c[1] c[5] c[9] c[13] v[1] +// c[2] c[6] c[10] c[14] X v[2] +// c[3] c[7] c[11] c[15] v[3] +// +// Calling MultMatrix with an argument of m = m[0], m[1], ..., m[15] +// replaces the current transformation with (C X M) x v, or +// +// c[0] c[4] c[8] c[12] m[0] m[4] m[8] m[12] v[0] +// c[1] c[5] c[9] c[13] m[1] m[5] m[9] m[13] v[1] +// c[2] c[6] c[10] c[14] X m[2] m[6] m[10] m[14] X v[2] +// c[3] c[7] c[11] c[15] m[3] m[7] m[11] m[15] v[3] +// +// Where 'X' denotes matrix multiplication, and v is represented as a 4x1 matrix. +// +// While the elements of the matrix may be specified with single or double +// precision, the GL may store or operate on these values in less-than-single +// precision. +// +// In many computer languages, 4×4 arrays are represented in row-major +// order. The transformations just described represent these matrices in +// column-major order. The order of the multiplication is important. For +// example, if the current transformation is a rotation, and MultMatrix is +// called with a translation matrix, the translation is done directly on the +// coordinates to be transformed, while the rotation is done on the results +// of that translation. +// +// GL.INVALID_OPERATION is generated if MultMatrix is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) MultMatrixd(m []float64) { + if len(m) != 16 { + panic("parameter m must have length 16 for the 4x4 matrix") + } + C.gl3_3compat_glMultMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// MultMatrixf multiplies the current matrix with the provided matrix. +// +// The m parameter must hold 16 consecutive elements of a 4x4 column-major matrix. +// +// The current matrix is determined by the current matrix mode (see +// MatrixMode). It is either the projection matrix, modelview matrix, or the +// texture matrix. +// +// For example, if the current matrix is C and the coordinates to be transformed +// are v = (v[0], v[1], v[2], v[3]), then the current transformation is C × v, or +// +// c[0] c[4] c[8] c[12] v[0] +// c[1] c[5] c[9] c[13] v[1] +// c[2] c[6] c[10] c[14] X v[2] +// c[3] c[7] c[11] c[15] v[3] +// +// Calling MultMatrix with an argument of m = m[0], m[1], ..., m[15] +// replaces the current transformation with (C X M) x v, or +// +// c[0] c[4] c[8] c[12] m[0] m[4] m[8] m[12] v[0] +// c[1] c[5] c[9] c[13] m[1] m[5] m[9] m[13] v[1] +// c[2] c[6] c[10] c[14] X m[2] m[6] m[10] m[14] X v[2] +// c[3] c[7] c[11] c[15] m[3] m[7] m[11] m[15] v[3] +// +// Where 'X' denotes matrix multiplication, and v is represented as a 4x1 matrix. +// +// While the elements of the matrix may be specified with single or double +// precision, the GL may store or operate on these values in less-than-single +// precision. +// +// In many computer languages, 4×4 arrays are represented in row-major +// order. The transformations just described represent these matrices in +// column-major order. The order of the multiplication is important. For +// example, if the current transformation is a rotation, and MultMatrix is +// called with a translation matrix, the translation is done directly on the +// coordinates to be transformed, while the rotation is done on the results +// of that translation. +// +// GL.INVALID_OPERATION is generated if MultMatrix is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) MultMatrixf(m []float32) { + if len(m) != 16 { + panic("parameter m must have length 16 for the 4x4 matrix") + } + C.gl3_3compat_glMultMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMatrixMode.xml +func (gl *GL) MatrixMode(mode glbase.Enum) { + C.gl3_3compat_glMatrixMode(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLoadMatrixd.xml +func (gl *GL) LoadMatrixd(m []float64) { + C.gl3_3compat_glLoadMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLoadMatrixf.xml +func (gl *GL) LoadMatrixf(m []float32) { + C.gl3_3compat_glLoadMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLoadIdentity.xml +func (gl *GL) LoadIdentity() { + C.gl3_3compat_glLoadIdentity(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFrustum.xml +func (gl *GL) Frustum(left, right, bottom, top, zNear, zFar float64) { + C.gl3_3compat_glFrustum(gl.funcs, C.GLdouble(left), C.GLdouble(right), C.GLdouble(bottom), C.GLdouble(top), C.GLdouble(zNear), C.GLdouble(zFar)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsList.xml +func (gl *GL) IsList(list uint32) bool { + glresult := C.gl3_3compat_glIsList(gl.funcs, C.GLuint(list)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexGeniv.xml +func (gl *GL) GetTexGeniv(coord, pname glbase.Enum, params []int32) { + C.gl3_3compat_glGetTexGeniv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexGenfv.xml +func (gl *GL) GetTexGenfv(coord, pname glbase.Enum, params []float32) { + C.gl3_3compat_glGetTexGenfv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexGendv.xml +func (gl *GL) GetTexGendv(coord, pname glbase.Enum, params []float64) { + C.gl3_3compat_glGetTexGendv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexEnviv.xml +func (gl *GL) GetTexEnviv(target, pname glbase.Enum, params []int32) { + C.gl3_3compat_glGetTexEnviv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexEnvfv.xml +func (gl *GL) GetTexEnvfv(target, pname glbase.Enum, params []float32) { + C.gl3_3compat_glGetTexEnvfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetPolygonStipple.xml +func (gl *GL) GetPolygonStipple(mask []uint8) { + C.gl3_3compat_glGetPolygonStipple(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&mask[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetPixelMapusv.xml +func (gl *GL) GetPixelMapusv(glmap glbase.Enum, values []uint16) { + C.gl3_3compat_glGetPixelMapusv(gl.funcs, C.GLenum(glmap), (*C.GLushort)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetPixelMapuiv.xml +func (gl *GL) GetPixelMapuiv(glmap glbase.Enum, values []uint32) { + C.gl3_3compat_glGetPixelMapuiv(gl.funcs, C.GLenum(glmap), (*C.GLuint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetPixelMapfv.xml +func (gl *GL) GetPixelMapfv(glmap glbase.Enum, values []float32) { + C.gl3_3compat_glGetPixelMapfv(gl.funcs, C.GLenum(glmap), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetMaterialiv.xml +func (gl *GL) GetMaterialiv(face, pname glbase.Enum, params []int32) { + C.gl3_3compat_glGetMaterialiv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetMaterialfv.xml +func (gl *GL) GetMaterialfv(face, pname glbase.Enum, params []float32) { + C.gl3_3compat_glGetMaterialfv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetMapiv.xml +func (gl *GL) GetMapiv(target, query glbase.Enum, v []int32) { + C.gl3_3compat_glGetMapiv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetMapfv.xml +func (gl *GL) GetMapfv(target, query glbase.Enum, v []float32) { + C.gl3_3compat_glGetMapfv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetMapdv.xml +func (gl *GL) GetMapdv(target, query glbase.Enum, v []float64) { + C.gl3_3compat_glGetMapdv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetLightiv.xml +func (gl *GL) GetLightiv(light, pname glbase.Enum, params []int32) { + C.gl3_3compat_glGetLightiv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetLightfv.xml +func (gl *GL) GetLightfv(light, pname glbase.Enum, params []float32) { + C.gl3_3compat_glGetLightfv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetClipPlane.xml +func (gl *GL) GetClipPlane(plane glbase.Enum, equation []float64) { + C.gl3_3compat_glGetClipPlane(gl.funcs, C.GLenum(plane), (*C.GLdouble)(unsafe.Pointer(&equation[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawPixels.xml +func (gl *GL) DrawPixels(width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glDrawPixels(gl.funcs, C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyPixels.xml +func (gl *GL) CopyPixels(x, y, width, height int, gltype glbase.Enum) { + C.gl3_3compat_glCopyPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(gltype)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPixelMapusv.xml +func (gl *GL) PixelMapusv(glmap glbase.Enum, mapsize int32, values []uint16) { + C.gl3_3compat_glPixelMapusv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLushort)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPixelMapuiv.xml +func (gl *GL) PixelMapuiv(glmap glbase.Enum, mapsize int32, values []uint32) { + C.gl3_3compat_glPixelMapuiv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLuint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPixelMapfv.xml +func (gl *GL) PixelMapfv(glmap glbase.Enum, mapsize int32, values []float32) { + C.gl3_3compat_glPixelMapfv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPixelTransferi.xml +func (gl *GL) PixelTransferi(pname glbase.Enum, param int32) { + C.gl3_3compat_glPixelTransferi(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPixelTransferf.xml +func (gl *GL) PixelTransferf(pname glbase.Enum, param float32) { + C.gl3_3compat_glPixelTransferf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPixelZoom.xml +func (gl *GL) PixelZoom(xfactor, yfactor float32) { + C.gl3_3compat_glPixelZoom(gl.funcs, C.GLfloat(xfactor), C.GLfloat(yfactor)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glAlphaFunc.xml +func (gl *GL) AlphaFunc(glfunc glbase.Enum, ref float32) { + C.gl3_3compat_glAlphaFunc(gl.funcs, C.GLenum(glfunc), C.GLfloat(ref)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalPoint2.xml +func (gl *GL) EvalPoint2(i, j int32) { + C.gl3_3compat_glEvalPoint2(gl.funcs, C.GLint(i), C.GLint(j)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalMesh2.xml +func (gl *GL) EvalMesh2(mode glbase.Enum, i1, i2, j1, j2 int32) { + C.gl3_3compat_glEvalMesh2(gl.funcs, C.GLenum(mode), C.GLint(i1), C.GLint(i2), C.GLint(j1), C.GLint(j2)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalPoint1.xml +func (gl *GL) EvalPoint1(i int32) { + C.gl3_3compat_glEvalPoint1(gl.funcs, C.GLint(i)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalMesh1.xml +func (gl *GL) EvalMesh1(mode glbase.Enum, i1, i2 int32) { + C.gl3_3compat_glEvalMesh1(gl.funcs, C.GLenum(mode), C.GLint(i1), C.GLint(i2)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalCoord2fv.xml +func (gl *GL) EvalCoord2fv(u []float32) { + if len(u) != 2 { + panic("parameter u has incorrect length") + } + C.gl3_3compat_glEvalCoord2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalCoord2f.xml +func (gl *GL) EvalCoord2f(u, v float32) { + C.gl3_3compat_glEvalCoord2f(gl.funcs, C.GLfloat(u), C.GLfloat(v)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalCoord2dv.xml +func (gl *GL) EvalCoord2dv(u []float64) { + if len(u) != 2 { + panic("parameter u has incorrect length") + } + C.gl3_3compat_glEvalCoord2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalCoord2d.xml +func (gl *GL) EvalCoord2d(u, v float64) { + C.gl3_3compat_glEvalCoord2d(gl.funcs, C.GLdouble(u), C.GLdouble(v)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalCoord1fv.xml +func (gl *GL) EvalCoord1fv(u []float32) { + C.gl3_3compat_glEvalCoord1fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalCoord1f.xml +func (gl *GL) EvalCoord1f(u float32) { + C.gl3_3compat_glEvalCoord1f(gl.funcs, C.GLfloat(u)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalCoord1dv.xml +func (gl *GL) EvalCoord1dv(u []float64) { + C.gl3_3compat_glEvalCoord1dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEvalCoord1d.xml +func (gl *GL) EvalCoord1d(u float64) { + C.gl3_3compat_glEvalCoord1d(gl.funcs, C.GLdouble(u)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMapGrid2f.xml +func (gl *GL) MapGrid2f(un int32, u1, u2 float32, vn int32, v1, v2 float32) { + C.gl3_3compat_glMapGrid2f(gl.funcs, C.GLint(un), C.GLfloat(u1), C.GLfloat(u2), C.GLint(vn), C.GLfloat(v1), C.GLfloat(v2)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMapGrid2d.xml +func (gl *GL) MapGrid2d(un int32, u1, u2 float64, vn int32, v1, v2 float64) { + C.gl3_3compat_glMapGrid2d(gl.funcs, C.GLint(un), C.GLdouble(u1), C.GLdouble(u2), C.GLint(vn), C.GLdouble(v1), C.GLdouble(v2)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMapGrid1f.xml +func (gl *GL) MapGrid1f(un int32, u1, u2 float32) { + C.gl3_3compat_glMapGrid1f(gl.funcs, C.GLint(un), C.GLfloat(u1), C.GLfloat(u2)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMapGrid1d.xml +func (gl *GL) MapGrid1d(un int32, u1, u2 float64) { + C.gl3_3compat_glMapGrid1d(gl.funcs, C.GLint(un), C.GLdouble(u1), C.GLdouble(u2)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMap2f.xml +func (gl *GL) Map2f(target glbase.Enum, u1, u2 float32, ustride, uorder int32, v1, v2 float32, vstride, vorder int32, points []float32) { + C.gl3_3compat_glMap2f(gl.funcs, C.GLenum(target), C.GLfloat(u1), C.GLfloat(u2), C.GLint(ustride), C.GLint(uorder), C.GLfloat(v1), C.GLfloat(v2), C.GLint(vstride), C.GLint(vorder), (*C.GLfloat)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMap2d.xml +func (gl *GL) Map2d(target glbase.Enum, u1, u2 float64, ustride, uorder int32, v1, v2 float64, vstride, vorder int32, points []float64) { + C.gl3_3compat_glMap2d(gl.funcs, C.GLenum(target), C.GLdouble(u1), C.GLdouble(u2), C.GLint(ustride), C.GLint(uorder), C.GLdouble(v1), C.GLdouble(v2), C.GLint(vstride), C.GLint(vorder), (*C.GLdouble)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMap1f.xml +func (gl *GL) Map1f(target glbase.Enum, u1, u2 float32, stride, order int, points []float32) { + C.gl3_3compat_glMap1f(gl.funcs, C.GLenum(target), C.GLfloat(u1), C.GLfloat(u2), C.GLint(stride), C.GLint(order), (*C.GLfloat)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMap1d.xml +func (gl *GL) Map1d(target glbase.Enum, u1, u2 float64, stride, order int, points []float64) { + C.gl3_3compat_glMap1d(gl.funcs, C.GLenum(target), C.GLdouble(u1), C.GLdouble(u2), C.GLint(stride), C.GLint(order), (*C.GLdouble)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPushAttrib.xml +func (gl *GL) PushAttrib(mask glbase.Bitfield) { + C.gl3_3compat_glPushAttrib(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPopAttrib.xml +func (gl *GL) PopAttrib() { + C.gl3_3compat_glPopAttrib(gl.funcs) +} + +// Accum executes an operation on the accumulation buffer. +// +// Parameter op defines the accumulation buffer operation (GL.ACCUM, GL.LOAD, +// GL.ADD, GL.MULT, or GL.RETURN) and specifies how the value parameter is +// used. +// +// The accumulation buffer is an extended-range color buffer. Images are not +// rendered into it. Rather, images rendered into one of the color buffers +// are added to the contents of the accumulation buffer after rendering. +// Effects such as antialiasing (of points, lines, and polygons), motion +// blur, and depth of field can be created by accumulating images generated +// with different transformation matrices. +// +// Each pixel in the accumulation buffer consists of red, green, blue, and +// alpha values. The number of bits per component in the accumulation buffer +// depends on the implementation. You can examine this number by calling +// GetIntegerv four times, with arguments GL.ACCUM_RED_BITS, +// GL.ACCUM_GREEN_BITS, GL.ACCUM_BLUE_BITS, and GL.ACCUM_ALPHA_BITS. +// Regardless of the number of bits per component, the range of values stored +// by each component is (-1, 1). The accumulation buffer pixels are mapped +// one-to-one with frame buffer pixels. +// +// All accumulation buffer operations are limited to the area of the current +// scissor box and applied identically to the red, green, blue, and alpha +// components of each pixel. If a Accum operation results in a value outside +// the range (-1, 1), the contents of an accumulation buffer pixel component +// are undefined. +// +// The operations are as follows: +// +// GL.ACCUM +// Obtains R, G, B, and A values from the buffer currently selected for +// reading (see ReadBuffer). Each component value is divided by 2 n - +// 1 , where n is the number of bits allocated to each color component +// in the currently selected buffer. The result is a floating-point +// value in the range 0 1 , which is multiplied by value and added to +// the corresponding pixel component in the accumulation buffer, +// thereby updating the accumulation buffer. +// +// GL.LOAD +// Similar to GL.ACCUM, except that the current value in the +// accumulation buffer is not used in the calculation of the new value. +// That is, the R, G, B, and A values from the currently selected +// buffer are divided by 2 n - 1 , multiplied by value, and then stored +// in the corresponding accumulation buffer cell, overwriting the +// current value. +// +// GL.ADD +// Adds value to each R, G, B, and A in the accumulation buffer. +// +// GL.MULT +// Multiplies each R, G, B, and A in the accumulation buffer by value +// and returns the scaled component to its corresponding accumulation +// buffer location. +// +// GL.RETURN +// Transfers accumulation buffer values to the color buffer or buffers +// currently selected for writing. Each R, G, B, and A component is +// multiplied by value, then multiplied by 2 n - 1 , clamped to the +// range 0 2 n - 1 , and stored in the corresponding display buffer +// cell. The only fragment operations that are applied to this transfer +// are pixel ownership, scissor, dithering, and color writemasks. +// +// To clear the accumulation buffer, call ClearAccum with R, G, B, and A +// values to set it to, then call Clear with the accumulation buffer +// enabled. +// +// Error GL.INVALID_ENUM is generated if op is not an accepted value. +// GL.INVALID_OPERATION is generated if there is no accumulation buffer. +// GL.INVALID_OPERATION is generated if Accum is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) Accum(op glbase.Enum, value float32) { + C.gl3_3compat_glAccum(gl.funcs, C.GLenum(op), C.GLfloat(value)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexMask.xml +func (gl *GL) IndexMask(mask uint32) { + C.gl3_3compat_glIndexMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearIndex.xml +func (gl *GL) ClearIndex(c float32) { + C.gl3_3compat_glClearIndex(gl.funcs, C.GLfloat(c)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearAccum.xml +func (gl *GL) ClearAccum(red, green, blue, alpha float32) { + C.gl3_3compat_glClearAccum(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPushName.xml +func (gl *GL) PushName(name uint32) { + C.gl3_3compat_glPushName(gl.funcs, C.GLuint(name)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPopName.xml +func (gl *GL) PopName() { + C.gl3_3compat_glPopName(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPassThrough.xml +func (gl *GL) PassThrough(token float32) { + C.gl3_3compat_glPassThrough(gl.funcs, C.GLfloat(token)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLoadName.xml +func (gl *GL) LoadName(name uint32) { + C.gl3_3compat_glLoadName(gl.funcs, C.GLuint(name)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glInitNames.xml +func (gl *GL) InitNames() { + C.gl3_3compat_glInitNames(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRenderMode.xml +func (gl *GL) RenderMode(mode glbase.Enum) int32 { + glresult := C.gl3_3compat_glRenderMode(gl.funcs, C.GLenum(mode)) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSelectBuffer.xml +func (gl *GL) SelectBuffer(size int, buffer []glbase.Buffer) { + C.gl3_3compat_glSelectBuffer(gl.funcs, C.GLsizei(size), (*C.GLuint)(unsafe.Pointer(&buffer[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFeedbackBuffer.xml +func (gl *GL) FeedbackBuffer(size int, gltype glbase.Enum, buffer []float32) { + C.gl3_3compat_glFeedbackBuffer(gl.funcs, C.GLsizei(size), C.GLenum(gltype), (*C.GLfloat)(unsafe.Pointer(&buffer[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexGeniv.xml +func (gl *GL) TexGeniv(coord, pname glbase.Enum, params []int32) { + C.gl3_3compat_glTexGeniv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexGeni.xml +func (gl *GL) TexGeni(coord, pname glbase.Enum, param int32) { + C.gl3_3compat_glTexGeni(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexGenfv.xml +func (gl *GL) TexGenfv(coord, pname glbase.Enum, params []float32) { + C.gl3_3compat_glTexGenfv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexGenf.xml +func (gl *GL) TexGenf(coord, pname glbase.Enum, param float32) { + C.gl3_3compat_glTexGenf(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexGendv.xml +func (gl *GL) TexGendv(coord, pname glbase.Enum, params []float64) { + C.gl3_3compat_glTexGendv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexGend.xml +func (gl *GL) TexGend(coord, pname glbase.Enum, param float64) { + C.gl3_3compat_glTexGend(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLdouble(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexEnviv.xml +func (gl *GL) TexEnviv(target, pname glbase.Enum, params []int32) { + C.gl3_3compat_glTexEnviv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexEnvi.xml +func (gl *GL) TexEnvi(target, pname glbase.Enum, param int32) { + C.gl3_3compat_glTexEnvi(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexEnvfv.xml +func (gl *GL) TexEnvfv(target, pname glbase.Enum, params []float32) { + C.gl3_3compat_glTexEnvfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexEnvf.xml +func (gl *GL) TexEnvf(target, pname glbase.Enum, param float32) { + C.gl3_3compat_glTexEnvf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glShadeModel.xml +func (gl *GL) ShadeModel(mode glbase.Enum) { + C.gl3_3compat_glShadeModel(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPolygonStipple.xml +func (gl *GL) PolygonStipple(mask []uint8) { + C.gl3_3compat_glPolygonStipple(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&mask[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMaterialiv.xml +func (gl *GL) Materialiv(face, pname glbase.Enum, params []int32) { + C.gl3_3compat_glMaterialiv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMateriali.xml +func (gl *GL) Materiali(face, pname glbase.Enum, param int32) { + C.gl3_3compat_glMateriali(gl.funcs, C.GLenum(face), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMaterialfv.xml +func (gl *GL) Materialfv(face, pname glbase.Enum, params []float32) { + C.gl3_3compat_glMaterialfv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMaterialf.xml +func (gl *GL) Materialf(face, pname glbase.Enum, param float32) { + C.gl3_3compat_glMaterialf(gl.funcs, C.GLenum(face), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLineStipple.xml +func (gl *GL) LineStipple(factor int32, pattern uint16) { + C.gl3_3compat_glLineStipple(gl.funcs, C.GLint(factor), C.GLushort(pattern)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLightModeliv.xml +func (gl *GL) LightModeliv(pname glbase.Enum, params []int32) { + C.gl3_3compat_glLightModeliv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLightModeli.xml +func (gl *GL) LightModeli(pname glbase.Enum, param int32) { + C.gl3_3compat_glLightModeli(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLightModelfv.xml +func (gl *GL) LightModelfv(pname glbase.Enum, params []float32) { + C.gl3_3compat_glLightModelfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLightModelf.xml +func (gl *GL) LightModelf(pname glbase.Enum, param float32) { + C.gl3_3compat_glLightModelf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLightiv.xml +func (gl *GL) Lightiv(light, pname glbase.Enum, params []int32) { + C.gl3_3compat_glLightiv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLighti.xml +func (gl *GL) Lighti(light, pname glbase.Enum, param int32) { + C.gl3_3compat_glLighti(gl.funcs, C.GLenum(light), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLightfv.xml +func (gl *GL) Lightfv(light, pname glbase.Enum, params []float32) { + C.gl3_3compat_glLightfv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLightf.xml +func (gl *GL) Lightf(light, pname glbase.Enum, param float32) { + C.gl3_3compat_glLightf(gl.funcs, C.GLenum(light), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFogiv.xml +func (gl *GL) Fogiv(pname glbase.Enum, params []int32) { + C.gl3_3compat_glFogiv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFogi.xml +func (gl *GL) Fogi(pname glbase.Enum, param int32) { + C.gl3_3compat_glFogi(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFogfv.xml +func (gl *GL) Fogfv(pname glbase.Enum, params []float32) { + C.gl3_3compat_glFogfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFogf.xml +func (gl *GL) Fogf(pname glbase.Enum, param float32) { + C.gl3_3compat_glFogf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorMaterial.xml +func (gl *GL) ColorMaterial(face, mode glbase.Enum) { + C.gl3_3compat_glColorMaterial(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClipPlane.xml +func (gl *GL) ClipPlane(plane glbase.Enum, equation []float64) { + C.gl3_3compat_glClipPlane(gl.funcs, C.GLenum(plane), (*C.GLdouble)(unsafe.Pointer(&equation[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex4sv.xml +func (gl *GL) Vertex4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glVertex4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex4s.xml +func (gl *GL) Vertex4s(x, y, z, w int16) { + C.gl3_3compat_glVertex4s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex4iv.xml +func (gl *GL) Vertex4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glVertex4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex4i.xml +func (gl *GL) Vertex4i(x, y, z, w int) { + C.gl3_3compat_glVertex4i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex4fv.xml +func (gl *GL) Vertex4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glVertex4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex4f.xml +func (gl *GL) Vertex4f(x, y, z, w float32) { + C.gl3_3compat_glVertex4f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex4dv.xml +func (gl *GL) Vertex4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glVertex4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex4d.xml +func (gl *GL) Vertex4d(x, y, z, w float64) { + C.gl3_3compat_glVertex4d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex3sv.xml +func (gl *GL) Vertex3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glVertex3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex3s.xml +func (gl *GL) Vertex3s(x, y, z int16) { + C.gl3_3compat_glVertex3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex3iv.xml +func (gl *GL) Vertex3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glVertex3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex3i.xml +func (gl *GL) Vertex3i(x, y, z int) { + C.gl3_3compat_glVertex3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex3fv.xml +func (gl *GL) Vertex3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glVertex3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex3f.xml +func (gl *GL) Vertex3f(x, y, z float32) { + C.gl3_3compat_glVertex3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex3dv.xml +func (gl *GL) Vertex3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glVertex3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex3d.xml +func (gl *GL) Vertex3d(x, y, z float64) { + C.gl3_3compat_glVertex3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex2sv.xml +func (gl *GL) Vertex2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glVertex2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex2s.xml +func (gl *GL) Vertex2s(x, y int16) { + C.gl3_3compat_glVertex2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex2iv.xml +func (gl *GL) Vertex2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glVertex2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex2i.xml +func (gl *GL) Vertex2i(x, y int) { + C.gl3_3compat_glVertex2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex2fv.xml +func (gl *GL) Vertex2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glVertex2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex2f.xml +func (gl *GL) Vertex2f(x, y float32) { + C.gl3_3compat_glVertex2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex2dv.xml +func (gl *GL) Vertex2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glVertex2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertex2d.xml +func (gl *GL) Vertex2d(x, y float64) { + C.gl3_3compat_glVertex2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord4sv.xml +func (gl *GL) TexCoord4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glTexCoord4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord4s.xml +func (gl *GL) TexCoord4s(s, t, r, q int16) { + C.gl3_3compat_glTexCoord4s(gl.funcs, C.GLshort(s), C.GLshort(t), C.GLshort(r), C.GLshort(q)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord4iv.xml +func (gl *GL) TexCoord4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glTexCoord4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord4i.xml +func (gl *GL) TexCoord4i(s, t, r, q int32) { + C.gl3_3compat_glTexCoord4i(gl.funcs, C.GLint(s), C.GLint(t), C.GLint(r), C.GLint(q)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord4fv.xml +func (gl *GL) TexCoord4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glTexCoord4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord4f.xml +func (gl *GL) TexCoord4f(s, t, r, q float32) { + C.gl3_3compat_glTexCoord4f(gl.funcs, C.GLfloat(s), C.GLfloat(t), C.GLfloat(r), C.GLfloat(q)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord4dv.xml +func (gl *GL) TexCoord4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glTexCoord4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord4d.xml +func (gl *GL) TexCoord4d(s, t, r, q float64) { + C.gl3_3compat_glTexCoord4d(gl.funcs, C.GLdouble(s), C.GLdouble(t), C.GLdouble(r), C.GLdouble(q)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord3sv.xml +func (gl *GL) TexCoord3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glTexCoord3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord3s.xml +func (gl *GL) TexCoord3s(s, t, r int16) { + C.gl3_3compat_glTexCoord3s(gl.funcs, C.GLshort(s), C.GLshort(t), C.GLshort(r)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord3iv.xml +func (gl *GL) TexCoord3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glTexCoord3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord3i.xml +func (gl *GL) TexCoord3i(s, t, r int32) { + C.gl3_3compat_glTexCoord3i(gl.funcs, C.GLint(s), C.GLint(t), C.GLint(r)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord3fv.xml +func (gl *GL) TexCoord3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glTexCoord3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord3f.xml +func (gl *GL) TexCoord3f(s, t, r float32) { + C.gl3_3compat_glTexCoord3f(gl.funcs, C.GLfloat(s), C.GLfloat(t), C.GLfloat(r)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord3dv.xml +func (gl *GL) TexCoord3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glTexCoord3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord3d.xml +func (gl *GL) TexCoord3d(s, t, r float64) { + C.gl3_3compat_glTexCoord3d(gl.funcs, C.GLdouble(s), C.GLdouble(t), C.GLdouble(r)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord2sv.xml +func (gl *GL) TexCoord2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glTexCoord2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord2s.xml +func (gl *GL) TexCoord2s(s, t int16) { + C.gl3_3compat_glTexCoord2s(gl.funcs, C.GLshort(s), C.GLshort(t)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord2iv.xml +func (gl *GL) TexCoord2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glTexCoord2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord2i.xml +func (gl *GL) TexCoord2i(s, t int32) { + C.gl3_3compat_glTexCoord2i(gl.funcs, C.GLint(s), C.GLint(t)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord2fv.xml +func (gl *GL) TexCoord2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glTexCoord2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord2f.xml +func (gl *GL) TexCoord2f(s, t float32) { + C.gl3_3compat_glTexCoord2f(gl.funcs, C.GLfloat(s), C.GLfloat(t)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord2dv.xml +func (gl *GL) TexCoord2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glTexCoord2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord2d.xml +func (gl *GL) TexCoord2d(s, t float64) { + C.gl3_3compat_glTexCoord2d(gl.funcs, C.GLdouble(s), C.GLdouble(t)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord1sv.xml +func (gl *GL) TexCoord1sv(v []int16) { + C.gl3_3compat_glTexCoord1sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord1s.xml +func (gl *GL) TexCoord1s(s int16) { + C.gl3_3compat_glTexCoord1s(gl.funcs, C.GLshort(s)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord1iv.xml +func (gl *GL) TexCoord1iv(v []int32) { + C.gl3_3compat_glTexCoord1iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord1i.xml +func (gl *GL) TexCoord1i(s int32) { + C.gl3_3compat_glTexCoord1i(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord1fv.xml +func (gl *GL) TexCoord1fv(v []float32) { + C.gl3_3compat_glTexCoord1fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord1f.xml +func (gl *GL) TexCoord1f(s float32) { + C.gl3_3compat_glTexCoord1f(gl.funcs, C.GLfloat(s)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord1dv.xml +func (gl *GL) TexCoord1dv(v []float64) { + C.gl3_3compat_glTexCoord1dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoord1d.xml +func (gl *GL) TexCoord1d(s float64) { + C.gl3_3compat_glTexCoord1d(gl.funcs, C.GLdouble(s)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRectsv.xml +func (gl *GL) Rectsv(v1, v2 []int16) { + C.gl3_3compat_glRectsv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v1[0])), (*C.GLshort)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRects.xml +func (gl *GL) Rects(x1, y1, x2, y2 int16) { + C.gl3_3compat_glRects(gl.funcs, C.GLshort(x1), C.GLshort(y1), C.GLshort(x2), C.GLshort(y2)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRectiv.xml +func (gl *GL) Rectiv(v1, v2 []int32) { + C.gl3_3compat_glRectiv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v1[0])), (*C.GLint)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRecti.xml +func (gl *GL) Recti(x1, y1, x2, y2 int32) { + C.gl3_3compat_glRecti(gl.funcs, C.GLint(x1), C.GLint(y1), C.GLint(x2), C.GLint(y2)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRectfv.xml +func (gl *GL) Rectfv(v1, v2 []float32) { + C.gl3_3compat_glRectfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v1[0])), (*C.GLfloat)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRectf.xml +func (gl *GL) Rectf(x1, y1, x2, y2 float32) { + C.gl3_3compat_glRectf(gl.funcs, C.GLfloat(x1), C.GLfloat(y1), C.GLfloat(x2), C.GLfloat(y2)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRectdv.xml +func (gl *GL) Rectdv(v1, v2 []float64) { + C.gl3_3compat_glRectdv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v1[0])), (*C.GLdouble)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRectd.xml +func (gl *GL) Rectd(x1, y1, x2, y2 float64) { + C.gl3_3compat_glRectd(gl.funcs, C.GLdouble(x1), C.GLdouble(y1), C.GLdouble(x2), C.GLdouble(y2)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos4sv.xml +func (gl *GL) RasterPos4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glRasterPos4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos4s.xml +func (gl *GL) RasterPos4s(x, y, z, w int16) { + C.gl3_3compat_glRasterPos4s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos4iv.xml +func (gl *GL) RasterPos4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glRasterPos4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos4i.xml +func (gl *GL) RasterPos4i(x, y, z, w int) { + C.gl3_3compat_glRasterPos4i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos4fv.xml +func (gl *GL) RasterPos4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glRasterPos4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos4f.xml +func (gl *GL) RasterPos4f(x, y, z, w float32) { + C.gl3_3compat_glRasterPos4f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos4dv.xml +func (gl *GL) RasterPos4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glRasterPos4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos4d.xml +func (gl *GL) RasterPos4d(x, y, z, w float64) { + C.gl3_3compat_glRasterPos4d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos3sv.xml +func (gl *GL) RasterPos3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glRasterPos3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos3s.xml +func (gl *GL) RasterPos3s(x, y, z int16) { + C.gl3_3compat_glRasterPos3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos3iv.xml +func (gl *GL) RasterPos3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glRasterPos3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos3i.xml +func (gl *GL) RasterPos3i(x, y, z int) { + C.gl3_3compat_glRasterPos3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos3fv.xml +func (gl *GL) RasterPos3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glRasterPos3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos3f.xml +func (gl *GL) RasterPos3f(x, y, z float32) { + C.gl3_3compat_glRasterPos3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos3dv.xml +func (gl *GL) RasterPos3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glRasterPos3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos3d.xml +func (gl *GL) RasterPos3d(x, y, z float64) { + C.gl3_3compat_glRasterPos3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos2sv.xml +func (gl *GL) RasterPos2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glRasterPos2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos2s.xml +func (gl *GL) RasterPos2s(x, y int16) { + C.gl3_3compat_glRasterPos2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos2iv.xml +func (gl *GL) RasterPos2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glRasterPos2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos2i.xml +func (gl *GL) RasterPos2i(x, y int) { + C.gl3_3compat_glRasterPos2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos2fv.xml +func (gl *GL) RasterPos2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glRasterPos2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos2f.xml +func (gl *GL) RasterPos2f(x, y float32) { + C.gl3_3compat_glRasterPos2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos2dv.xml +func (gl *GL) RasterPos2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glRasterPos2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRasterPos2d.xml +func (gl *GL) RasterPos2d(x, y float64) { + C.gl3_3compat_glRasterPos2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormal3sv.xml +func (gl *GL) Normal3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glNormal3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormal3s.xml +func (gl *GL) Normal3s(nx, ny, nz int16) { + C.gl3_3compat_glNormal3s(gl.funcs, C.GLshort(nx), C.GLshort(ny), C.GLshort(nz)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormal3iv.xml +func (gl *GL) Normal3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glNormal3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormal3i.xml +func (gl *GL) Normal3i(nx, ny, nz int32) { + C.gl3_3compat_glNormal3i(gl.funcs, C.GLint(nx), C.GLint(ny), C.GLint(nz)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormal3fv.xml +func (gl *GL) Normal3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glNormal3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormal3f.xml +func (gl *GL) Normal3f(nx, ny, nz float32) { + C.gl3_3compat_glNormal3f(gl.funcs, C.GLfloat(nx), C.GLfloat(ny), C.GLfloat(nz)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormal3dv.xml +func (gl *GL) Normal3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glNormal3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormal3d.xml +func (gl *GL) Normal3d(nx, ny, nz float64) { + C.gl3_3compat_glNormal3d(gl.funcs, C.GLdouble(nx), C.GLdouble(ny), C.GLdouble(nz)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormal3bv.xml +func (gl *GL) Normal3bv(v []byte) { + C.gl3_3compat_glNormal3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormal3b.xml +func (gl *GL) Normal3b(nx, ny, nz byte) { + C.gl3_3compat_glNormal3b(gl.funcs, C.GLbyte(nx), C.GLbyte(ny), C.GLbyte(nz)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexsv.xml +func (gl *GL) Indexsv(c []int16) { + C.gl3_3compat_glIndexsv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexs.xml +func (gl *GL) Indexs(c int16) { + C.gl3_3compat_glIndexs(gl.funcs, C.GLshort(c)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexiv.xml +func (gl *GL) Indexiv(c []int32) { + C.gl3_3compat_glIndexiv(gl.funcs, (*C.GLint)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexi.xml +func (gl *GL) Indexi(c int32) { + C.gl3_3compat_glIndexi(gl.funcs, C.GLint(c)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexfv.xml +func (gl *GL) Indexfv(c []float32) { + C.gl3_3compat_glIndexfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexf.xml +func (gl *GL) Indexf(c float32) { + C.gl3_3compat_glIndexf(gl.funcs, C.GLfloat(c)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexdv.xml +func (gl *GL) Indexdv(c []float64) { + C.gl3_3compat_glIndexdv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexd.xml +func (gl *GL) Indexd(c float64) { + C.gl3_3compat_glIndexd(gl.funcs, C.GLdouble(c)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEnd.xml +func (gl *GL) End() { + C.gl3_3compat_glEnd(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEdgeFlagv.xml +func (gl *GL) EdgeFlagv(flag []bool) { + C.gl3_3compat_glEdgeFlagv(gl.funcs, (*C.GLboolean)(unsafe.Pointer(&flag[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEdgeFlag.xml +func (gl *GL) EdgeFlag(flag bool) { + C.gl3_3compat_glEdgeFlag(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4usv.xml +func (gl *GL) Color4usv(v []uint16) { + C.gl3_3compat_glColor4usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4us.xml +func (gl *GL) Color4us(red, green, blue, alpha uint16) { + C.gl3_3compat_glColor4us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue), C.GLushort(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4uiv.xml +func (gl *GL) Color4uiv(v []uint32) { + C.gl3_3compat_glColor4uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4ui.xml +func (gl *GL) Color4ui(red, green, blue, alpha uint32) { + C.gl3_3compat_glColor4ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue), C.GLuint(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4ubv.xml +func (gl *GL) Color4ubv(v []uint8) { + C.gl3_3compat_glColor4ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4ub.xml +func (gl *GL) Color4ub(red, green, blue, alpha uint8) { + C.gl3_3compat_glColor4ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue), C.GLubyte(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4sv.xml +func (gl *GL) Color4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glColor4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4s.xml +func (gl *GL) Color4s(red, green, blue, alpha int16) { + C.gl3_3compat_glColor4s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue), C.GLshort(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4iv.xml +func (gl *GL) Color4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glColor4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4i.xml +func (gl *GL) Color4i(red, green, blue, alpha int32) { + C.gl3_3compat_glColor4i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue), C.GLint(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4fv.xml +func (gl *GL) Color4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glColor4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4f.xml +func (gl *GL) Color4f(red, green, blue, alpha float32) { + C.gl3_3compat_glColor4f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4dv.xml +func (gl *GL) Color4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glColor4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4d.xml +func (gl *GL) Color4d(red, green, blue, alpha float64) { + C.gl3_3compat_glColor4d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue), C.GLdouble(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4bv.xml +func (gl *GL) Color4bv(v []byte) { + C.gl3_3compat_glColor4bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor4b.xml +func (gl *GL) Color4b(red, green, blue, alpha byte) { + C.gl3_3compat_glColor4b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue), C.GLbyte(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3usv.xml +func (gl *GL) Color3usv(v []uint16) { + C.gl3_3compat_glColor3usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3us.xml +func (gl *GL) Color3us(red, green, blue uint16) { + C.gl3_3compat_glColor3us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3uiv.xml +func (gl *GL) Color3uiv(v []uint32) { + C.gl3_3compat_glColor3uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3ui.xml +func (gl *GL) Color3ui(red, green, blue uint32) { + C.gl3_3compat_glColor3ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3ubv.xml +func (gl *GL) Color3ubv(v []uint8) { + C.gl3_3compat_glColor3ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3ub.xml +func (gl *GL) Color3ub(red, green, blue uint8) { + C.gl3_3compat_glColor3ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3sv.xml +func (gl *GL) Color3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glColor3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3s.xml +func (gl *GL) Color3s(red, green, blue int16) { + C.gl3_3compat_glColor3s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3iv.xml +func (gl *GL) Color3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glColor3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3i.xml +func (gl *GL) Color3i(red, green, blue int32) { + C.gl3_3compat_glColor3i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3fv.xml +func (gl *GL) Color3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glColor3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3f.xml +func (gl *GL) Color3f(red, green, blue float32) { + C.gl3_3compat_glColor3f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3dv.xml +func (gl *GL) Color3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glColor3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3d.xml +func (gl *GL) Color3d(red, green, blue float64) { + C.gl3_3compat_glColor3d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3bv.xml +func (gl *GL) Color3bv(v []byte) { + C.gl3_3compat_glColor3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColor3b.xml +func (gl *GL) Color3b(red, green, blue byte) { + C.gl3_3compat_glColor3b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBitmap.xml +func (gl *GL) Bitmap(width, height int, xorig, yorig, xmove, ymove float32, bitmap []uint8) { + C.gl3_3compat_glBitmap(gl.funcs, C.GLsizei(width), C.GLsizei(height), C.GLfloat(xorig), C.GLfloat(yorig), C.GLfloat(xmove), C.GLfloat(ymove), (*C.GLubyte)(unsafe.Pointer(&bitmap[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBegin.xml +func (gl *GL) Begin(mode glbase.Enum) { + C.gl3_3compat_glBegin(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glListBase.xml +func (gl *GL) ListBase(base uint32) { + C.gl3_3compat_glListBase(gl.funcs, C.GLuint(base)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGenLists.xml +func (gl *GL) GenLists(range_ int32) uint32 { + glresult := C.gl3_3compat_glGenLists(gl.funcs, C.GLsizei(range_)) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDeleteLists.xml +func (gl *GL) DeleteLists(list uint32, range_ int32) { + C.gl3_3compat_glDeleteLists(gl.funcs, C.GLuint(list), C.GLsizei(range_)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCallLists.xml +func (gl *GL) CallLists(n int, gltype glbase.Enum, lists interface{}) { + var lists_ptr unsafe.Pointer + var lists_v = reflect.ValueOf(lists) + if lists != nil && lists_v.Kind() != reflect.Slice { + panic("parameter lists must be a slice") + } + if lists != nil { + lists_ptr = unsafe.Pointer(lists_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glCallLists(gl.funcs, C.GLsizei(n), C.GLenum(gltype), lists_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCallList.xml +func (gl *GL) CallList(list uint32) { + C.gl3_3compat_glCallList(gl.funcs, C.GLuint(list)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEndList.xml +func (gl *GL) EndList() { + C.gl3_3compat_glEndList(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNewList.xml +func (gl *GL) NewList(list uint32, mode glbase.Enum) { + C.gl3_3compat_glNewList(gl.funcs, C.GLuint(list), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPushClientAttrib.xml +func (gl *GL) PushClientAttrib(mask glbase.Bitfield) { + C.gl3_3compat_glPushClientAttrib(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPopClientAttrib.xml +func (gl *GL) PopClientAttrib() { + C.gl3_3compat_glPopClientAttrib(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPrioritizeTextures.xml +func (gl *GL) PrioritizeTextures(n int, textures []glbase.Texture, priorities []float32) { + C.gl3_3compat_glPrioritizeTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0])), (*C.GLfloat)(unsafe.Pointer(&priorities[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glAreTexturesResident.xml +func (gl *GL) AreTexturesResident(n int, textures []glbase.Texture, residences []bool) bool { + glresult := C.gl3_3compat_glAreTexturesResident(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0])), (*C.GLboolean)(unsafe.Pointer(&residences[0]))) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexPointer.xml +func (gl *GL) VertexPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glVertexPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoordPointer.xml +func (gl *GL) TexCoordPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glTexCoordPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormalPointer.xml +func (gl *GL) NormalPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glNormalPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glInterleavedArrays.xml +func (gl *GL) InterleavedArrays(format glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glInterleavedArrays(gl.funcs, C.GLenum(format), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexPointer.xml +func (gl *GL) IndexPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glIndexPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEnableClientState.xml +func (gl *GL) EnableClientState(array glbase.Enum) { + C.gl3_3compat_glEnableClientState(gl.funcs, C.GLenum(array)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEdgeFlagPointer.xml +func (gl *GL) EdgeFlagPointer(stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glEdgeFlagPointer(gl.funcs, C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDisableClientState.xml +func (gl *GL) DisableClientState(array glbase.Enum) { + C.gl3_3compat_glDisableClientState(gl.funcs, C.GLenum(array)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorPointer.xml +func (gl *GL) ColorPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glColorPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glArrayElement.xml +func (gl *GL) ArrayElement(i int32) { + C.gl3_3compat_glArrayElement(gl.funcs, C.GLint(i)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glResetMinmax.xml +func (gl *GL) ResetMinmax(target glbase.Enum) { + C.gl3_3compat_glResetMinmax(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glResetHistogram.xml +func (gl *GL) ResetHistogram(target glbase.Enum) { + C.gl3_3compat_glResetHistogram(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMinmax.xml +func (gl *GL) Minmax(target, internalFormat glbase.Enum, sink bool) { + C.gl3_3compat_glMinmax(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), *(*C.GLboolean)(unsafe.Pointer(&sink))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glHistogram.xml +func (gl *GL) Histogram(target glbase.Enum, width int, internalFormat glbase.Enum, sink bool) { + C.gl3_3compat_glHistogram(gl.funcs, C.GLenum(target), C.GLsizei(width), C.GLenum(internalFormat), *(*C.GLboolean)(unsafe.Pointer(&sink))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetMinmaxParameteriv.xml +func (gl *GL) GetMinmaxParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_3compat_glGetMinmaxParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetMinmaxParameterfv.xml +func (gl *GL) GetMinmaxParameterfv(target, pname glbase.Enum, params []float32) { + C.gl3_3compat_glGetMinmaxParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetMinmax.xml +func (gl *GL) GetMinmax(target glbase.Enum, reset bool, format, gltype glbase.Enum, values interface{}) { + var values_ptr unsafe.Pointer + var values_v = reflect.ValueOf(values) + if values != nil && values_v.Kind() != reflect.Slice { + panic("parameter values must be a slice") + } + if values != nil { + values_ptr = unsafe.Pointer(values_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glGetMinmax(gl.funcs, C.GLenum(target), *(*C.GLboolean)(unsafe.Pointer(&reset)), C.GLenum(format), C.GLenum(gltype), values_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetHistogramParameteriv.xml +func (gl *GL) GetHistogramParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_3compat_glGetHistogramParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetHistogramParameterfv.xml +func (gl *GL) GetHistogramParameterfv(target, pname glbase.Enum, params []float32) { + C.gl3_3compat_glGetHistogramParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetHistogram.xml +func (gl *GL) GetHistogram(target glbase.Enum, reset bool, format, gltype glbase.Enum, values interface{}) { + var values_ptr unsafe.Pointer + var values_v = reflect.ValueOf(values) + if values != nil && values_v.Kind() != reflect.Slice { + panic("parameter values must be a slice") + } + if values != nil { + values_ptr = unsafe.Pointer(values_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glGetHistogram(gl.funcs, C.GLenum(target), *(*C.GLboolean)(unsafe.Pointer(&reset)), C.GLenum(format), C.GLenum(gltype), values_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSeparableFilter2D.xml +func (gl *GL) SeparableFilter2D(target, internalFormat glbase.Enum, width, height int, format, gltype glbase.Enum, row, column interface{}) { + var row_ptr unsafe.Pointer + var row_v = reflect.ValueOf(row) + if row != nil && row_v.Kind() != reflect.Slice { + panic("parameter row must be a slice") + } + if row != nil { + row_ptr = unsafe.Pointer(row_v.Index(0).Addr().Pointer()) + } + var column_ptr unsafe.Pointer + var column_v = reflect.ValueOf(column) + if column != nil && column_v.Kind() != reflect.Slice { + panic("parameter column must be a slice") + } + if column != nil { + column_ptr = unsafe.Pointer(column_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glSeparableFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), row_ptr, column_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetSeparableFilter.xml +func (gl *GL) GetSeparableFilter(target, format, gltype glbase.Enum, row, column, span interface{}) { + var row_ptr unsafe.Pointer + var row_v = reflect.ValueOf(row) + if row != nil && row_v.Kind() != reflect.Slice { + panic("parameter row must be a slice") + } + if row != nil { + row_ptr = unsafe.Pointer(row_v.Index(0).Addr().Pointer()) + } + var column_ptr unsafe.Pointer + var column_v = reflect.ValueOf(column) + if column != nil && column_v.Kind() != reflect.Slice { + panic("parameter column must be a slice") + } + if column != nil { + column_ptr = unsafe.Pointer(column_v.Index(0).Addr().Pointer()) + } + var span_ptr unsafe.Pointer + var span_v = reflect.ValueOf(span) + if span != nil && span_v.Kind() != reflect.Slice { + panic("parameter span must be a slice") + } + if span != nil { + span_ptr = unsafe.Pointer(span_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glGetSeparableFilter(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), row_ptr, column_ptr, span_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetConvolutionParameteriv.xml +func (gl *GL) GetConvolutionParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_3compat_glGetConvolutionParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetConvolutionParameterfv.xml +func (gl *GL) GetConvolutionParameterfv(target, pname glbase.Enum, params []float32) { + C.gl3_3compat_glGetConvolutionParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetConvolutionFilter.xml +func (gl *GL) GetConvolutionFilter(target, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glGetConvolutionFilter(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyConvolutionFilter2D.xml +func (gl *GL) CopyConvolutionFilter2D(target, internalFormat glbase.Enum, x, y, width, height int) { + C.gl3_3compat_glCopyConvolutionFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyConvolutionFilter1D.xml +func (gl *GL) CopyConvolutionFilter1D(target, internalFormat glbase.Enum, x, y, width int) { + C.gl3_3compat_glCopyConvolutionFilter1D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glConvolutionParameteriv.xml +func (gl *GL) ConvolutionParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_3compat_glConvolutionParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glConvolutionParameteri.xml +func (gl *GL) ConvolutionParameteri(target, pname glbase.Enum, params int32) { + C.gl3_3compat_glConvolutionParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(params)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glConvolutionParameterfv.xml +func (gl *GL) ConvolutionParameterfv(target, pname glbase.Enum, params []float32) { + C.gl3_3compat_glConvolutionParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glConvolutionParameterf.xml +func (gl *GL) ConvolutionParameterf(target, pname glbase.Enum, params float32) { + C.gl3_3compat_glConvolutionParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(params)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glConvolutionFilter2D.xml +func (gl *GL) ConvolutionFilter2D(target, internalFormat glbase.Enum, width, height int, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glConvolutionFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glConvolutionFilter1D.xml +func (gl *GL) ConvolutionFilter1D(target, internalFormat glbase.Enum, width int, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glConvolutionFilter1D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyColorSubTable.xml +func (gl *GL) CopyColorSubTable(target glbase.Enum, start int32, x, y, width int) { + C.gl3_3compat_glCopyColorSubTable(gl.funcs, C.GLenum(target), C.GLsizei(start), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorSubTable.xml +func (gl *GL) ColorSubTable(target glbase.Enum, start int32, count int, format, gltype glbase.Enum, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glColorSubTable(gl.funcs, C.GLenum(target), C.GLsizei(start), C.GLsizei(count), C.GLenum(format), C.GLenum(gltype), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetColorTableParameteriv.xml +func (gl *GL) GetColorTableParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_3compat_glGetColorTableParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetColorTableParameterfv.xml +func (gl *GL) GetColorTableParameterfv(target, pname glbase.Enum, params []float32) { + C.gl3_3compat_glGetColorTableParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetColorTable.xml +func (gl *GL) GetColorTable(target, format, gltype glbase.Enum, table interface{}) { + var table_ptr unsafe.Pointer + var table_v = reflect.ValueOf(table) + if table != nil && table_v.Kind() != reflect.Slice { + panic("parameter table must be a slice") + } + if table != nil { + table_ptr = unsafe.Pointer(table_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glGetColorTable(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), table_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyColorTable.xml +func (gl *GL) CopyColorTable(target, internalFormat glbase.Enum, x, y, width int) { + C.gl3_3compat_glCopyColorTable(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorTableParameteriv.xml +func (gl *GL) ColorTableParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_3compat_glColorTableParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorTableParameterfv.xml +func (gl *GL) ColorTableParameterfv(target, pname glbase.Enum, params []float32) { + C.gl3_3compat_glColorTableParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorTable.xml +func (gl *GL) ColorTable(target, internalFormat glbase.Enum, width int, format, gltype glbase.Enum, table interface{}) { + var table_ptr unsafe.Pointer + var table_v = reflect.ValueOf(table) + if table != nil && table_v.Kind() != reflect.Slice { + panic("parameter table must be a slice") + } + if table != nil { + table_ptr = unsafe.Pointer(table_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glColorTable(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), table_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultTransposeMatrixd.xml +func (gl *GL) MultTransposeMatrixd(m []float64) { + C.gl3_3compat_glMultTransposeMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultTransposeMatrixf.xml +func (gl *GL) MultTransposeMatrixf(m []float32) { + C.gl3_3compat_glMultTransposeMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLoadTransposeMatrixd.xml +func (gl *GL) LoadTransposeMatrixd(m []float64) { + C.gl3_3compat_glLoadTransposeMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLoadTransposeMatrixf.xml +func (gl *GL) LoadTransposeMatrixf(m []float32) { + C.gl3_3compat_glLoadTransposeMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord4sv.xml +func (gl *GL) MultiTexCoord4sv(target glbase.Enum, v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glMultiTexCoord4sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord4s.xml +func (gl *GL) MultiTexCoord4s(target glbase.Enum, s, t, r, q int16) { + C.gl3_3compat_glMultiTexCoord4s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t), C.GLshort(r), C.GLshort(q)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord4iv.xml +func (gl *GL) MultiTexCoord4iv(target glbase.Enum, v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glMultiTexCoord4iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord4i.xml +func (gl *GL) MultiTexCoord4i(target glbase.Enum, s, t, r, q int32) { + C.gl3_3compat_glMultiTexCoord4i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t), C.GLint(r), C.GLint(q)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord4fv.xml +func (gl *GL) MultiTexCoord4fv(target glbase.Enum, v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glMultiTexCoord4fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord4f.xml +func (gl *GL) MultiTexCoord4f(target glbase.Enum, s, t, r, q float32) { + C.gl3_3compat_glMultiTexCoord4f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t), C.GLfloat(r), C.GLfloat(q)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord4dv.xml +func (gl *GL) MultiTexCoord4dv(target glbase.Enum, v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glMultiTexCoord4dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord4d.xml +func (gl *GL) MultiTexCoord4d(target glbase.Enum, s, t, r, q float64) { + C.gl3_3compat_glMultiTexCoord4d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t), C.GLdouble(r), C.GLdouble(q)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord3sv.xml +func (gl *GL) MultiTexCoord3sv(target glbase.Enum, v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glMultiTexCoord3sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord3s.xml +func (gl *GL) MultiTexCoord3s(target glbase.Enum, s, t, r int16) { + C.gl3_3compat_glMultiTexCoord3s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t), C.GLshort(r)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord3iv.xml +func (gl *GL) MultiTexCoord3iv(target glbase.Enum, v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glMultiTexCoord3iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord3i.xml +func (gl *GL) MultiTexCoord3i(target glbase.Enum, s, t, r int32) { + C.gl3_3compat_glMultiTexCoord3i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t), C.GLint(r)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord3fv.xml +func (gl *GL) MultiTexCoord3fv(target glbase.Enum, v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glMultiTexCoord3fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord3f.xml +func (gl *GL) MultiTexCoord3f(target glbase.Enum, s, t, r float32) { + C.gl3_3compat_glMultiTexCoord3f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t), C.GLfloat(r)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord3dv.xml +func (gl *GL) MultiTexCoord3dv(target glbase.Enum, v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glMultiTexCoord3dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord3d.xml +func (gl *GL) MultiTexCoord3d(target glbase.Enum, s, t, r float64) { + C.gl3_3compat_glMultiTexCoord3d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t), C.GLdouble(r)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord2sv.xml +func (gl *GL) MultiTexCoord2sv(target glbase.Enum, v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glMultiTexCoord2sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord2s.xml +func (gl *GL) MultiTexCoord2s(target glbase.Enum, s, t int16) { + C.gl3_3compat_glMultiTexCoord2s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord2iv.xml +func (gl *GL) MultiTexCoord2iv(target glbase.Enum, v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glMultiTexCoord2iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord2i.xml +func (gl *GL) MultiTexCoord2i(target glbase.Enum, s, t int32) { + C.gl3_3compat_glMultiTexCoord2i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord2fv.xml +func (gl *GL) MultiTexCoord2fv(target glbase.Enum, v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glMultiTexCoord2fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord2f.xml +func (gl *GL) MultiTexCoord2f(target glbase.Enum, s, t float32) { + C.gl3_3compat_glMultiTexCoord2f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord2dv.xml +func (gl *GL) MultiTexCoord2dv(target glbase.Enum, v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glMultiTexCoord2dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord2d.xml +func (gl *GL) MultiTexCoord2d(target glbase.Enum, s, t float64) { + C.gl3_3compat_glMultiTexCoord2d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord1sv.xml +func (gl *GL) MultiTexCoord1sv(target glbase.Enum, v []int16) { + C.gl3_3compat_glMultiTexCoord1sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord1s.xml +func (gl *GL) MultiTexCoord1s(target glbase.Enum, s int16) { + C.gl3_3compat_glMultiTexCoord1s(gl.funcs, C.GLenum(target), C.GLshort(s)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord1iv.xml +func (gl *GL) MultiTexCoord1iv(target glbase.Enum, v []int32) { + C.gl3_3compat_glMultiTexCoord1iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord1i.xml +func (gl *GL) MultiTexCoord1i(target glbase.Enum, s int32) { + C.gl3_3compat_glMultiTexCoord1i(gl.funcs, C.GLenum(target), C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord1fv.xml +func (gl *GL) MultiTexCoord1fv(target glbase.Enum, v []float32) { + C.gl3_3compat_glMultiTexCoord1fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord1f.xml +func (gl *GL) MultiTexCoord1f(target glbase.Enum, s float32) { + C.gl3_3compat_glMultiTexCoord1f(gl.funcs, C.GLenum(target), C.GLfloat(s)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord1dv.xml +func (gl *GL) MultiTexCoord1dv(target glbase.Enum, v []float64) { + C.gl3_3compat_glMultiTexCoord1dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoord1d.xml +func (gl *GL) MultiTexCoord1d(target glbase.Enum, s float64) { + C.gl3_3compat_glMultiTexCoord1d(gl.funcs, C.GLenum(target), C.GLdouble(s)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClientActiveTexture.xml +func (gl *GL) ClientActiveTexture(texture glbase.Enum) { + C.gl3_3compat_glClientActiveTexture(gl.funcs, C.GLenum(texture)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos3sv.xml +func (gl *GL) WindowPos3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glWindowPos3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos3s.xml +func (gl *GL) WindowPos3s(x, y, z int16) { + C.gl3_3compat_glWindowPos3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos3iv.xml +func (gl *GL) WindowPos3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glWindowPos3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos3i.xml +func (gl *GL) WindowPos3i(x, y, z int) { + C.gl3_3compat_glWindowPos3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos3fv.xml +func (gl *GL) WindowPos3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glWindowPos3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos3f.xml +func (gl *GL) WindowPos3f(x, y, z float32) { + C.gl3_3compat_glWindowPos3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos3dv.xml +func (gl *GL) WindowPos3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glWindowPos3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos3d.xml +func (gl *GL) WindowPos3d(x, y, z float64) { + C.gl3_3compat_glWindowPos3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos2sv.xml +func (gl *GL) WindowPos2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glWindowPos2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos2s.xml +func (gl *GL) WindowPos2s(x, y int16) { + C.gl3_3compat_glWindowPos2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos2iv.xml +func (gl *GL) WindowPos2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glWindowPos2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos2i.xml +func (gl *GL) WindowPos2i(x, y int) { + C.gl3_3compat_glWindowPos2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos2fv.xml +func (gl *GL) WindowPos2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glWindowPos2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos2f.xml +func (gl *GL) WindowPos2f(x, y float32) { + C.gl3_3compat_glWindowPos2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos2dv.xml +func (gl *GL) WindowPos2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glWindowPos2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWindowPos2d.xml +func (gl *GL) WindowPos2d(x, y float64) { + C.gl3_3compat_glWindowPos2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColorPointer.xml +func (gl *GL) SecondaryColorPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glSecondaryColorPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3usv.xml +func (gl *GL) SecondaryColor3usv(v []uint16) { + C.gl3_3compat_glSecondaryColor3usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3us.xml +func (gl *GL) SecondaryColor3us(red, green, blue uint16) { + C.gl3_3compat_glSecondaryColor3us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3uiv.xml +func (gl *GL) SecondaryColor3uiv(v []uint32) { + C.gl3_3compat_glSecondaryColor3uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3ui.xml +func (gl *GL) SecondaryColor3ui(red, green, blue uint32) { + C.gl3_3compat_glSecondaryColor3ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3ubv.xml +func (gl *GL) SecondaryColor3ubv(v []uint8) { + C.gl3_3compat_glSecondaryColor3ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3ub.xml +func (gl *GL) SecondaryColor3ub(red, green, blue uint8) { + C.gl3_3compat_glSecondaryColor3ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3sv.xml +func (gl *GL) SecondaryColor3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glSecondaryColor3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3s.xml +func (gl *GL) SecondaryColor3s(red, green, blue int16) { + C.gl3_3compat_glSecondaryColor3s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3iv.xml +func (gl *GL) SecondaryColor3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glSecondaryColor3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3i.xml +func (gl *GL) SecondaryColor3i(red, green, blue int32) { + C.gl3_3compat_glSecondaryColor3i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3fv.xml +func (gl *GL) SecondaryColor3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glSecondaryColor3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3f.xml +func (gl *GL) SecondaryColor3f(red, green, blue float32) { + C.gl3_3compat_glSecondaryColor3f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3dv.xml +func (gl *GL) SecondaryColor3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glSecondaryColor3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3d.xml +func (gl *GL) SecondaryColor3d(red, green, blue float64) { + C.gl3_3compat_glSecondaryColor3d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3bv.xml +func (gl *GL) SecondaryColor3bv(v []byte) { + C.gl3_3compat_glSecondaryColor3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColor3b.xml +func (gl *GL) SecondaryColor3b(red, green, blue byte) { + C.gl3_3compat_glSecondaryColor3b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFogCoordPointer.xml +func (gl *GL) FogCoordPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl3_3compat_glFogCoordPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFogCoorddv.xml +func (gl *GL) FogCoorddv(coord []float64) { + C.gl3_3compat_glFogCoorddv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&coord[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFogCoordd.xml +func (gl *GL) FogCoordd(coord float64) { + C.gl3_3compat_glFogCoordd(gl.funcs, C.GLdouble(coord)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFogCoordfv.xml +func (gl *GL) FogCoordfv(coord []float32) { + C.gl3_3compat_glFogCoordfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&coord[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFogCoordf.xml +func (gl *GL) FogCoordf(coord float32) { + C.gl3_3compat_glFogCoordf(gl.funcs, C.GLfloat(coord)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4usv.xml +func (gl *GL) VertexAttrib4usv(index glbase.Attrib, v []uint16) { + C.gl3_3compat_glVertexAttrib4usv(gl.funcs, C.GLuint(index), (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4uiv.xml +func (gl *GL) VertexAttrib4uiv(index glbase.Attrib, v []uint32) { + C.gl3_3compat_glVertexAttrib4uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4ubv.xml +func (gl *GL) VertexAttrib4ubv(index glbase.Attrib, v []uint8) { + C.gl3_3compat_glVertexAttrib4ubv(gl.funcs, C.GLuint(index), (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4sv.xml +func (gl *GL) VertexAttrib4sv(index glbase.Attrib, v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glVertexAttrib4sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4s.xml +func (gl *GL) VertexAttrib4s(index glbase.Attrib, x, y, z, w int16) { + C.gl3_3compat_glVertexAttrib4s(gl.funcs, C.GLuint(index), C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4iv.xml +func (gl *GL) VertexAttrib4iv(index glbase.Attrib, v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glVertexAttrib4iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4fv.xml +func (gl *GL) VertexAttrib4fv(index glbase.Attrib, v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glVertexAttrib4fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4f.xml +func (gl *GL) VertexAttrib4f(index glbase.Attrib, x, y, z, w float32) { + C.gl3_3compat_glVertexAttrib4f(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4dv.xml +func (gl *GL) VertexAttrib4dv(index glbase.Attrib, v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glVertexAttrib4dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4d.xml +func (gl *GL) VertexAttrib4d(index glbase.Attrib, x, y, z, w float64) { + C.gl3_3compat_glVertexAttrib4d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4bv.xml +func (gl *GL) VertexAttrib4bv(index glbase.Attrib, v []byte) { + C.gl3_3compat_glVertexAttrib4bv(gl.funcs, C.GLuint(index), (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4Nusv.xml +func (gl *GL) VertexAttrib4Nusv(index glbase.Attrib, v []uint16) { + C.gl3_3compat_glVertexAttrib4Nusv(gl.funcs, C.GLuint(index), (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4Nuiv.xml +func (gl *GL) VertexAttrib4Nuiv(index glbase.Attrib, v []uint32) { + C.gl3_3compat_glVertexAttrib4Nuiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4Nubv.xml +func (gl *GL) VertexAttrib4Nubv(index glbase.Attrib, v []uint8) { + C.gl3_3compat_glVertexAttrib4Nubv(gl.funcs, C.GLuint(index), (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4Nub.xml +func (gl *GL) VertexAttrib4Nub(index glbase.Attrib, x, y, z, w uint8) { + C.gl3_3compat_glVertexAttrib4Nub(gl.funcs, C.GLuint(index), C.GLubyte(x), C.GLubyte(y), C.GLubyte(z), C.GLubyte(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4Nsv.xml +func (gl *GL) VertexAttrib4Nsv(index glbase.Attrib, v []int16) { + C.gl3_3compat_glVertexAttrib4Nsv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4Niv.xml +func (gl *GL) VertexAttrib4Niv(index glbase.Attrib, v []int32) { + C.gl3_3compat_glVertexAttrib4Niv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib4Nbv.xml +func (gl *GL) VertexAttrib4Nbv(index glbase.Attrib, v []byte) { + C.gl3_3compat_glVertexAttrib4Nbv(gl.funcs, C.GLuint(index), (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib3sv.xml +func (gl *GL) VertexAttrib3sv(index glbase.Attrib, v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glVertexAttrib3sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib3s.xml +func (gl *GL) VertexAttrib3s(index glbase.Attrib, x, y, z int16) { + C.gl3_3compat_glVertexAttrib3s(gl.funcs, C.GLuint(index), C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib3fv.xml +func (gl *GL) VertexAttrib3fv(index glbase.Attrib, v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glVertexAttrib3fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib3f.xml +func (gl *GL) VertexAttrib3f(index glbase.Attrib, x, y, z float32) { + C.gl3_3compat_glVertexAttrib3f(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib3dv.xml +func (gl *GL) VertexAttrib3dv(index glbase.Attrib, v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glVertexAttrib3dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib3d.xml +func (gl *GL) VertexAttrib3d(index glbase.Attrib, x, y, z float64) { + C.gl3_3compat_glVertexAttrib3d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib2sv.xml +func (gl *GL) VertexAttrib2sv(index glbase.Attrib, v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glVertexAttrib2sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib2s.xml +func (gl *GL) VertexAttrib2s(index glbase.Attrib, x, y int16) { + C.gl3_3compat_glVertexAttrib2s(gl.funcs, C.GLuint(index), C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib2fv.xml +func (gl *GL) VertexAttrib2fv(index glbase.Attrib, v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glVertexAttrib2fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib2f.xml +func (gl *GL) VertexAttrib2f(index glbase.Attrib, x, y float32) { + C.gl3_3compat_glVertexAttrib2f(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib2dv.xml +func (gl *GL) VertexAttrib2dv(index glbase.Attrib, v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glVertexAttrib2dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib2d.xml +func (gl *GL) VertexAttrib2d(index glbase.Attrib, x, y float64) { + C.gl3_3compat_glVertexAttrib2d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib1sv.xml +func (gl *GL) VertexAttrib1sv(index glbase.Attrib, v []int16) { + C.gl3_3compat_glVertexAttrib1sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib1s.xml +func (gl *GL) VertexAttrib1s(index glbase.Attrib, x int16) { + C.gl3_3compat_glVertexAttrib1s(gl.funcs, C.GLuint(index), C.GLshort(x)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib1fv.xml +func (gl *GL) VertexAttrib1fv(index glbase.Attrib, v []float32) { + C.gl3_3compat_glVertexAttrib1fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib1f.xml +func (gl *GL) VertexAttrib1f(index glbase.Attrib, x float32) { + C.gl3_3compat_glVertexAttrib1f(gl.funcs, C.GLuint(index), C.GLfloat(x)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib1dv.xml +func (gl *GL) VertexAttrib1dv(index glbase.Attrib, v []float64) { + C.gl3_3compat_glVertexAttrib1dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib1d.xml +func (gl *GL) VertexAttrib1d(index glbase.Attrib, x float64) { + C.gl3_3compat_glVertexAttrib1d(gl.funcs, C.GLuint(index), C.GLdouble(x)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI4usv.xml +func (gl *GL) VertexAttribI4usv(index glbase.Attrib, v []uint16) { + C.gl3_3compat_glVertexAttribI4usv(gl.funcs, C.GLuint(index), (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI4ubv.xml +func (gl *GL) VertexAttribI4ubv(index glbase.Attrib, v []uint8) { + C.gl3_3compat_glVertexAttribI4ubv(gl.funcs, C.GLuint(index), (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI4sv.xml +func (gl *GL) VertexAttribI4sv(index glbase.Attrib, v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glVertexAttribI4sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI4bv.xml +func (gl *GL) VertexAttribI4bv(index glbase.Attrib, v []byte) { + C.gl3_3compat_glVertexAttribI4bv(gl.funcs, C.GLuint(index), (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI4uiv.xml +func (gl *GL) VertexAttribI4uiv(index glbase.Attrib, v []uint32) { + C.gl3_3compat_glVertexAttribI4uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI3uiv.xml +func (gl *GL) VertexAttribI3uiv(index glbase.Attrib, v []uint32) { + C.gl3_3compat_glVertexAttribI3uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI2uiv.xml +func (gl *GL) VertexAttribI2uiv(index glbase.Attrib, v []uint32) { + C.gl3_3compat_glVertexAttribI2uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI1uiv.xml +func (gl *GL) VertexAttribI1uiv(index glbase.Attrib, v []uint32) { + C.gl3_3compat_glVertexAttribI1uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI4iv.xml +func (gl *GL) VertexAttribI4iv(index glbase.Attrib, v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glVertexAttribI4iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI3iv.xml +func (gl *GL) VertexAttribI3iv(index glbase.Attrib, v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glVertexAttribI3iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI2iv.xml +func (gl *GL) VertexAttribI2iv(index glbase.Attrib, v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl3_3compat_glVertexAttribI2iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI1iv.xml +func (gl *GL) VertexAttribI1iv(index glbase.Attrib, v []int32) { + C.gl3_3compat_glVertexAttribI1iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI4ui.xml +func (gl *GL) VertexAttribI4ui(index glbase.Attrib, x, y, z, w uint32) { + C.gl3_3compat_glVertexAttribI4ui(gl.funcs, C.GLuint(index), C.GLuint(x), C.GLuint(y), C.GLuint(z), C.GLuint(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI3ui.xml +func (gl *GL) VertexAttribI3ui(index glbase.Attrib, x, y, z uint32) { + C.gl3_3compat_glVertexAttribI3ui(gl.funcs, C.GLuint(index), C.GLuint(x), C.GLuint(y), C.GLuint(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI2ui.xml +func (gl *GL) VertexAttribI2ui(index glbase.Attrib, x, y uint32) { + C.gl3_3compat_glVertexAttribI2ui(gl.funcs, C.GLuint(index), C.GLuint(x), C.GLuint(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI1ui.xml +func (gl *GL) VertexAttribI1ui(index glbase.Attrib, x uint32) { + C.gl3_3compat_glVertexAttribI1ui(gl.funcs, C.GLuint(index), C.GLuint(x)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI4i.xml +func (gl *GL) VertexAttribI4i(index glbase.Attrib, x, y, z, w int) { + C.gl3_3compat_glVertexAttribI4i(gl.funcs, C.GLuint(index), C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI3i.xml +func (gl *GL) VertexAttribI3i(index glbase.Attrib, x, y, z int) { + C.gl3_3compat_glVertexAttribI3i(gl.funcs, C.GLuint(index), C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI2i.xml +func (gl *GL) VertexAttribI2i(index glbase.Attrib, x, y int) { + C.gl3_3compat_glVertexAttribI2i(gl.funcs, C.GLuint(index), C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribI1i.xml +func (gl *GL) VertexAttribI1i(index glbase.Attrib, x int) { + C.gl3_3compat_glVertexAttribI1i(gl.funcs, C.GLuint(index), C.GLint(x)) +} diff --git a/gl/3.3core/funcs.cpp b/gl/3.3core/funcs.cpp new file mode 100644 index 00000000..b03b94ac --- /dev/null +++ b/gl/3.3core/funcs.cpp @@ -0,0 +1,1878 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#include +#include + +#include "funcs.h" + +void *gl3_3core_funcs() { + QOpenGLFunctions_3_3_Core* funcs = QOpenGLContext::currentContext()->versionFunctions(); + if (!funcs) { + return 0; + } + funcs->initializeOpenGLFunctions(); + return funcs; +} + + +void gl3_3core_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewport(x, y, width, height); +} + +void gl3_3core_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRange(nearVal, farVal); +} + +GLboolean gl3_3core_glIsEnabled(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabled(cap); +} + +void gl3_3core_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameteriv(target, level, pname, params); +} + +void gl3_3core_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameterfv(target, level, pname, params); +} + +void gl3_3core_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameteriv(target, pname, params); +} + +void gl3_3core_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterfv(target, pname, params); +} + +void gl3_3core_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexImage(target, level, format, gltype, pixels); +} + +void gl3_3core_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegerv(pname, params); +} + +void gl3_3core_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFloatv(pname, params); +} + +GLenum gl3_3core_glGetError(void *_glfuncs) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetError(); +} + +void gl3_3core_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetDoublev(pname, params); +} + +void gl3_3core_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleanv(pname, params); +} + +void gl3_3core_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadPixels(x, y, width, height, format, gltype, pixels); +} + +void gl3_3core_glReadBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadBuffer(mode); +} + +void gl3_3core_glPixelStorei(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStorei(pname, param); +} + +void gl3_3core_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStoref(pname, param); +} + +void gl3_3core_glDepthFunc(void *_glfuncs, GLenum glfunc) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthFunc(glfunc); +} + +void gl3_3core_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOp(fail, zfail, zpass); +} + +void gl3_3core_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFunc(glfunc, ref, mask); +} + +void gl3_3core_glLogicOp(void *_glfuncs, GLenum opcode) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLogicOp(opcode); +} + +void gl3_3core_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFunc(sfactor, dfactor); +} + +void gl3_3core_glFlush(void *_glfuncs) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlush(); +} + +void gl3_3core_glFinish(void *_glfuncs) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFinish(); +} + +void gl3_3core_glEnable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnable(cap); +} + +void gl3_3core_glDisable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisable(cap); +} + +void gl3_3core_glDepthMask(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthMask(flag); +} + +void gl3_3core_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMask(red, green, blue, alpha); +} + +void gl3_3core_glStencilMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMask(mask); +} + +void gl3_3core_glClearDepth(void *_glfuncs, GLdouble depth) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearDepth(depth); +} + +void gl3_3core_glClearStencil(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearStencil(s); +} + +void gl3_3core_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearColor(red, green, blue, alpha); +} + +void gl3_3core_glClear(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClear(mask); +} + +void gl3_3core_glDrawBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffer(mode); +} + +void gl3_3core_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage2D(target, level, internalFormat, width, height, border, format, gltype, pixels); +} + +void gl3_3core_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage1D(target, level, internalFormat, width, border, format, gltype, pixels); +} + +void gl3_3core_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteriv(target, pname, params); +} + +void gl3_3core_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteri(target, pname, param); +} + +void gl3_3core_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterfv(target, pname, params); +} + +void gl3_3core_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterf(target, pname, param); +} + +void gl3_3core_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissor(x, y, width, height); +} + +void gl3_3core_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonMode(face, mode); +} + +void gl3_3core_glPointSize(void *_glfuncs, GLfloat size) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointSize(size); +} + +void gl3_3core_glLineWidth(void *_glfuncs, GLfloat width) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineWidth(width); +} + +void gl3_3core_glHint(void *_glfuncs, GLenum target, GLenum mode) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glHint(target, mode); +} + +void gl3_3core_glFrontFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrontFace(mode); +} + +void gl3_3core_glCullFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCullFace(mode); +} + +void gl3_3core_glIndexubv(void *_glfuncs, const GLubyte* c) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexubv(c); +} + +void gl3_3core_glIndexub(void *_glfuncs, GLubyte c) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexub(c); +} + +GLboolean gl3_3core_glIsTexture(void *_glfuncs, GLuint texture) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsTexture(texture); +} + +void gl3_3core_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenTextures(n, textures); +} + +void gl3_3core_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteTextures(n, textures); +} + +void gl3_3core_glBindTexture(void *_glfuncs, GLenum target, GLuint texture) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindTexture(target, texture); +} + +void gl3_3core_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, gltype, pixels); +} + +void gl3_3core_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage1D(target, level, xoffset, width, format, gltype, pixels); +} + +void gl3_3core_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); +} + +void gl3_3core_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage1D(target, level, xoffset, x, y, width); +} + +void gl3_3core_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage2D(target, level, internalFormat, x, y, width, height, border); +} + +void gl3_3core_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage1D(target, level, internalFormat, x, y, width, border); +} + +void gl3_3core_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonOffset(factor, units); +} + +void gl3_3core_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElements(mode, count, gltype, indices); +} + +void gl3_3core_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArrays(mode, first, count); +} + +void gl3_3core_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); +} + +void gl3_3core_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, gltype, pixels); +} + +void gl3_3core_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage3D(target, level, internalFormat, width, height, depth, border, format, gltype, pixels); +} + +void gl3_3core_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawRangeElements(mode, start, end, count, gltype, indices); +} + +void gl3_3core_glBlendEquation(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquation(mode); +} + +void gl3_3core_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendColor(red, green, blue, alpha); +} + +void gl3_3core_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetCompressedTexImage(target, level, img); +} + +void gl3_3core_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data); +} + +void gl3_3core_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); +} + +void gl3_3core_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); +} + +void gl3_3core_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage1D(target, level, internalFormat, width, border, imageSize, data); +} + +void gl3_3core_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data); +} + +void gl3_3core_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage3D(target, level, internalFormat, width, height, depth, border, imageSize, data); +} + +void gl3_3core_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSampleCoverage(value, invert); +} + +void gl3_3core_glActiveTexture(void *_glfuncs, GLenum texture) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glActiveTexture(texture); +} + +void gl3_3core_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteriv(pname, params); +} + +void gl3_3core_glPointParameteri(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteri(pname, param); +} + +void gl3_3core_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterfv(pname, params); +} + +void gl3_3core_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterf(pname, param); +} + +void gl3_3core_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiDrawArrays(mode, first, count, drawcount); +} + +void gl3_3core_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); +} + +void gl3_3core_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferParameteriv(target, pname, params); +} + +GLboolean gl3_3core_glUnmapBuffer(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glUnmapBuffer(target); +} + +void gl3_3core_glGetBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferSubData(target, offset, size, data); +} + +void gl3_3core_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferSubData(target, offset, size, data); +} + +void gl3_3core_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferData(target, size, data, usage); +} + +GLboolean gl3_3core_glIsBuffer(void *_glfuncs, GLuint buffer) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsBuffer(buffer); +} + +void gl3_3core_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenBuffers(n, buffers); +} + +void gl3_3core_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteBuffers(n, buffers); +} + +void gl3_3core_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBuffer(target, buffer); +} + +void gl3_3core_glGetQueryObjectuiv(void *_glfuncs, GLuint id, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectuiv(id, pname, params); +} + +void gl3_3core_glGetQueryObjectiv(void *_glfuncs, GLuint id, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectiv(id, pname, params); +} + +void gl3_3core_glGetQueryiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryiv(target, pname, params); +} + +void gl3_3core_glEndQuery(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndQuery(target); +} + +void gl3_3core_glBeginQuery(void *_glfuncs, GLenum target, GLuint id) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginQuery(target, id); +} + +GLboolean gl3_3core_glIsQuery(void *_glfuncs, GLuint id) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsQuery(id); +} + +void gl3_3core_glDeleteQueries(void *_glfuncs, GLsizei n, const GLuint* ids) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteQueries(n, ids); +} + +void gl3_3core_glGenQueries(void *_glfuncs, GLsizei n, GLuint* ids) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenQueries(n, ids); +} + +void gl3_3core_glVertexAttribPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLboolean normalized, GLsizei stride, const GLvoid* offset) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribPointer(index, size, gltype, normalized, stride, offset); +} + +void gl3_3core_glValidateProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glValidateProgram(program); +} + +void gl3_3core_glUniformMatrix4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4fv(location, count, transpose, value); +} + +void gl3_3core_glUniformMatrix3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3fv(location, count, transpose, value); +} + +void gl3_3core_glUniformMatrix2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2fv(location, count, transpose, value); +} + +void gl3_3core_glUniform4iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4iv(location, count, value); +} + +void gl3_3core_glUniform3iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3iv(location, count, value); +} + +void gl3_3core_glUniform2iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2iv(location, count, value); +} + +void gl3_3core_glUniform1iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1iv(location, count, value); +} + +void gl3_3core_glUniform4fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4fv(location, count, value); +} + +void gl3_3core_glUniform3fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3fv(location, count, value); +} + +void gl3_3core_glUniform2fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2fv(location, count, value); +} + +void gl3_3core_glUniform1fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1fv(location, count, value); +} + +void gl3_3core_glUniform4i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4i(location, v0, v1, v2, v3); +} + +void gl3_3core_glUniform3i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3i(location, v0, v1, v2); +} + +void gl3_3core_glUniform2i(void *_glfuncs, GLint location, GLint v0, GLint v1) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2i(location, v0, v1); +} + +void gl3_3core_glUniform1i(void *_glfuncs, GLint location, GLint v0) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1i(location, v0); +} + +void gl3_3core_glUniform4f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4f(location, v0, v1, v2, v3); +} + +void gl3_3core_glUniform3f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3f(location, v0, v1, v2); +} + +void gl3_3core_glUniform2f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2f(location, v0, v1); +} + +void gl3_3core_glUniform1f(void *_glfuncs, GLint location, GLfloat v0) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1f(location, v0); +} + +void gl3_3core_glUseProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUseProgram(program); +} + +void gl3_3core_glShaderSource(void *_glfuncs, GLuint shader, GLsizei count, const GLchar** source, const GLint* length) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShaderSource(shader, count, source, length); +} + +void gl3_3core_glLinkProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLinkProgram(program); +} + +GLboolean gl3_3core_glIsShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsShader(shader); +} + +GLboolean gl3_3core_glIsProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsProgram(program); +} + +void gl3_3core_glGetVertexAttribiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribiv(index, pname, params); +} + +void gl3_3core_glGetVertexAttribfv(void *_glfuncs, GLuint index, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribfv(index, pname, params); +} + +void gl3_3core_glGetVertexAttribdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribdv(index, pname, params); +} + +void gl3_3core_glGetUniformiv(void *_glfuncs, GLuint program, GLint location, GLint* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformiv(program, location, params); +} + +void gl3_3core_glGetUniformfv(void *_glfuncs, GLuint program, GLint location, GLfloat* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformfv(program, location, params); +} + +GLint gl3_3core_glGetUniformLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetUniformLocation(program, name); +} + +void gl3_3core_glGetShaderSource(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderSource(shader, bufSize, length, source); +} + +void gl3_3core_glGetShaderInfoLog(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderInfoLog(shader, bufSize, length, infoLog); +} + +void gl3_3core_glGetShaderiv(void *_glfuncs, GLuint shader, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderiv(shader, pname, params); +} + +void gl3_3core_glGetProgramInfoLog(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramInfoLog(program, bufSize, length, infoLog); +} + +void gl3_3core_glGetProgramiv(void *_glfuncs, GLuint program, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramiv(program, pname, params); +} + +GLint gl3_3core_glGetAttribLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetAttribLocation(program, name); +} + +void gl3_3core_glGetAttachedShaders(void *_glfuncs, GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetAttachedShaders(program, maxCount, count, obj); +} + +void gl3_3core_glGetActiveUniform(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniform(program, index, bufSize, length, size, gltype, name); +} + +void gl3_3core_glGetActiveAttrib(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveAttrib(program, index, bufSize, length, size, gltype, name); +} + +void gl3_3core_glEnableVertexAttribArray(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnableVertexAttribArray(index); +} + +void gl3_3core_glDisableVertexAttribArray(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisableVertexAttribArray(index); +} + +void gl3_3core_glDetachShader(void *_glfuncs, GLuint program, GLuint shader) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDetachShader(program, shader); +} + +void gl3_3core_glDeleteShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteShader(shader); +} + +void gl3_3core_glDeleteProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteProgram(program); +} + +GLuint gl3_3core_glCreateShader(void *_glfuncs, GLenum gltype) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCreateShader(gltype); +} + +GLuint gl3_3core_glCreateProgram(void *_glfuncs) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCreateProgram(); +} + +void gl3_3core_glCompileShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompileShader(shader); +} + +void gl3_3core_glBindAttribLocation(void *_glfuncs, GLuint program, GLuint index, const GLchar* name) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindAttribLocation(program, index, name); +} + +void gl3_3core_glAttachShader(void *_glfuncs, GLuint program, GLuint shader) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAttachShader(program, shader); +} + +void gl3_3core_glStencilMaskSeparate(void *_glfuncs, GLenum face, GLuint mask) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMaskSeparate(face, mask); +} + +void gl3_3core_glStencilFuncSeparate(void *_glfuncs, GLenum face, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFuncSeparate(face, glfunc, ref, mask); +} + +void gl3_3core_glStencilOpSeparate(void *_glfuncs, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOpSeparate(face, sfail, dpfail, dppass); +} + +void gl3_3core_glDrawBuffers(void *_glfuncs, GLsizei n, const GLenum* bufs) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffers(n, bufs); +} + +void gl3_3core_glBlendEquationSeparate(void *_glfuncs, GLenum modeRGB, GLenum modeAlpha) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquationSeparate(modeRGB, modeAlpha); +} + +void gl3_3core_glUniformMatrix4x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x3fv(location, count, transpose, value); +} + +void gl3_3core_glUniformMatrix3x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x4fv(location, count, transpose, value); +} + +void gl3_3core_glUniformMatrix4x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x2fv(location, count, transpose, value); +} + +void gl3_3core_glUniformMatrix2x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x4fv(location, count, transpose, value); +} + +void gl3_3core_glUniformMatrix3x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x2fv(location, count, transpose, value); +} + +void gl3_3core_glUniformMatrix2x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x3fv(location, count, transpose, value); +} + +GLboolean gl3_3core_glIsVertexArray(void *_glfuncs, GLuint array) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsVertexArray(array); +} + +void gl3_3core_glGenVertexArrays(void *_glfuncs, GLsizei n, GLuint* arrays) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenVertexArrays(n, arrays); +} + +void gl3_3core_glDeleteVertexArrays(void *_glfuncs, GLsizei n, const GLuint* arrays) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteVertexArrays(n, arrays); +} + +void gl3_3core_glBindVertexArray(void *_glfuncs, GLuint array) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindVertexArray(array); +} + +void gl3_3core_glFlushMappedBufferRange(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr length) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlushMappedBufferRange(target, offset, length); +} + +void gl3_3core_glFramebufferTextureLayer(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTextureLayer(target, attachment, texture, level, layer); +} + +void gl3_3core_glRenderbufferStorageMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRenderbufferStorageMultisample(target, samples, internalFormat, width, height); +} + +void gl3_3core_glBlitFramebuffer(void *_glfuncs, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); +} + +void gl3_3core_glGenerateMipmap(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenerateMipmap(target); +} + +void gl3_3core_glGetFramebufferAttachmentParameteriv(void *_glfuncs, GLenum target, GLenum attachment, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFramebufferAttachmentParameteriv(target, attachment, pname, params); +} + +void gl3_3core_glFramebufferRenderbuffer(void *_glfuncs, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer); +} + +void gl3_3core_glFramebufferTexture3D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset); +} + +void gl3_3core_glFramebufferTexture2D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture2D(target, attachment, textarget, texture, level); +} + +void gl3_3core_glFramebufferTexture1D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture1D(target, attachment, textarget, texture, level); +} + +GLenum gl3_3core_glCheckFramebufferStatus(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCheckFramebufferStatus(target); +} + +void gl3_3core_glGenFramebuffers(void *_glfuncs, GLsizei n, GLuint* framebuffers) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenFramebuffers(n, framebuffers); +} + +void gl3_3core_glDeleteFramebuffers(void *_glfuncs, GLsizei n, const GLuint* framebuffers) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteFramebuffers(n, framebuffers); +} + +void gl3_3core_glBindFramebuffer(void *_glfuncs, GLenum target, GLuint framebuffer) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFramebuffer(target, framebuffer); +} + +GLboolean gl3_3core_glIsFramebuffer(void *_glfuncs, GLuint framebuffer) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsFramebuffer(framebuffer); +} + +void gl3_3core_glGetRenderbufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetRenderbufferParameteriv(target, pname, params); +} + +void gl3_3core_glRenderbufferStorage(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRenderbufferStorage(target, internalFormat, width, height); +} + +void gl3_3core_glGenRenderbuffers(void *_glfuncs, GLsizei n, GLuint* renderbuffers) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenRenderbuffers(n, renderbuffers); +} + +void gl3_3core_glDeleteRenderbuffers(void *_glfuncs, GLsizei n, const GLuint* renderbuffers) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteRenderbuffers(n, renderbuffers); +} + +void gl3_3core_glBindRenderbuffer(void *_glfuncs, GLenum target, GLuint renderbuffer) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindRenderbuffer(target, renderbuffer); +} + +GLboolean gl3_3core_glIsRenderbuffer(void *_glfuncs, GLuint renderbuffer) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsRenderbuffer(renderbuffer); +} + +void gl3_3core_glClearBufferfi(void *_glfuncs, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferfi(buffer, drawbuffer, depth, stencil); +} + +void gl3_3core_glClearBufferfv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLfloat* value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferfv(buffer, drawbuffer, value); +} + +void gl3_3core_glClearBufferuiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLuint* value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferuiv(buffer, drawbuffer, value); +} + +void gl3_3core_glClearBufferiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLint* value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferiv(buffer, drawbuffer, value); +} + +void gl3_3core_glGetTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterIuiv(target, pname, params); +} + +void gl3_3core_glGetTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterIiv(target, pname, params); +} + +void gl3_3core_glTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, const GLuint* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterIuiv(target, pname, params); +} + +void gl3_3core_glTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterIiv(target, pname, params); +} + +void gl3_3core_glUniform4uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4uiv(location, count, value); +} + +void gl3_3core_glUniform3uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3uiv(location, count, value); +} + +void gl3_3core_glUniform2uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2uiv(location, count, value); +} + +void gl3_3core_glUniform1uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1uiv(location, count, value); +} + +void gl3_3core_glUniform4ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4ui(location, v0, v1, v2, v3); +} + +void gl3_3core_glUniform3ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3ui(location, v0, v1, v2); +} + +void gl3_3core_glUniform2ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2ui(location, v0, v1); +} + +void gl3_3core_glUniform1ui(void *_glfuncs, GLint location, GLuint v0) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1ui(location, v0); +} + +GLint gl3_3core_glGetFragDataLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetFragDataLocation(program, name); +} + +void gl3_3core_glBindFragDataLocation(void *_glfuncs, GLuint program, GLuint color, const GLchar* name) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFragDataLocation(program, color, name); +} + +void gl3_3core_glGetUniformuiv(void *_glfuncs, GLuint program, GLint location, GLuint* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformuiv(program, location, params); +} + +void gl3_3core_glGetVertexAttribIuiv(void *_glfuncs, GLuint index, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribIuiv(index, pname, params); +} + +void gl3_3core_glGetVertexAttribIiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribIiv(index, pname, params); +} + +void gl3_3core_glVertexAttribIPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribIPointer(index, size, gltype, stride, pointer); +} + +void gl3_3core_glEndConditionalRender(void *_glfuncs) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndConditionalRender(); +} + +void gl3_3core_glBeginConditionalRender(void *_glfuncs, GLuint id, GLenum mode) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginConditionalRender(id, mode); +} + +void gl3_3core_glClampColor(void *_glfuncs, GLenum target, GLenum clamp) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClampColor(target, clamp); +} + +void gl3_3core_glGetTransformFeedbackVarying(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTransformFeedbackVarying(program, index, bufSize, length, size, gltype, name); +} + +void gl3_3core_glBindBufferBase(void *_glfuncs, GLenum target, GLuint index, GLuint buffer) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBufferBase(target, index, buffer); +} + +void gl3_3core_glBindBufferRange(void *_glfuncs, GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBufferRange(target, index, buffer, offset, size); +} + +void gl3_3core_glEndTransformFeedback(void *_glfuncs) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndTransformFeedback(); +} + +void gl3_3core_glBeginTransformFeedback(void *_glfuncs, GLenum primitiveMode) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginTransformFeedback(primitiveMode); +} + +GLboolean gl3_3core_glIsEnabledi(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabledi(target, index); +} + +void gl3_3core_glDisablei(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisablei(target, index); +} + +void gl3_3core_glEnablei(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnablei(target, index); +} + +void gl3_3core_glGetIntegeri_v(void *_glfuncs, GLenum target, GLuint index, GLint* data) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegeri_v(target, index, data); +} + +void gl3_3core_glGetBooleani_v(void *_glfuncs, GLenum target, GLuint index, GLboolean* data) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleani_v(target, index, data); +} + +void gl3_3core_glColorMaski(void *_glfuncs, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMaski(index, r, g, b, a); +} + +void gl3_3core_glCopyBufferSubData(void *_glfuncs, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); +} + +void gl3_3core_glUniformBlockBinding(void *_glfuncs, GLuint program, GLuint v0, GLuint v1) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformBlockBinding(program, v0, v1); +} + +void gl3_3core_glGetActiveUniformBlockName(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName); +} + +void gl3_3core_glGetActiveUniformBlockiv(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params); +} + +GLuint gl3_3core_glGetUniformBlockIndex(void *_glfuncs, GLuint program, const GLchar* uniformBlockName) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetUniformBlockIndex(program, uniformBlockName); +} + +void gl3_3core_glGetActiveUniformName(void *_glfuncs, GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformName(program, uniformIndex, bufSize, length, uniformName); +} + +void gl3_3core_glGetActiveUniformsiv(void *_glfuncs, GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params); +} + +void gl3_3core_glPrimitiveRestartIndex(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPrimitiveRestartIndex(index); +} + +void gl3_3core_glTexBuffer(void *_glfuncs, GLenum target, GLenum internalFormat, GLuint buffer) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexBuffer(target, internalFormat, buffer); +} + +void gl3_3core_glDrawElementsInstanced(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsInstanced(mode, count, gltype, indices, instancecount); +} + +void gl3_3core_glDrawArraysInstanced(void *_glfuncs, GLenum mode, GLint first, GLsizei count, GLsizei instancecount) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArraysInstanced(mode, first, count, instancecount); +} + +void gl3_3core_glSampleMaski(void *_glfuncs, GLuint index, GLbitfield mask) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSampleMaski(index, mask); +} + +void gl3_3core_glGetMultisamplefv(void *_glfuncs, GLenum pname, GLuint index, GLfloat* val) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMultisamplefv(pname, index, val); +} + +void gl3_3core_glTexImage3DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage3DMultisample(target, samples, internalFormat, width, height, depth, fixedsamplelocations); +} + +void gl3_3core_glTexImage2DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage2DMultisample(target, samples, internalFormat, width, height, fixedsamplelocations); +} + +void gl3_3core_glGetSynciv(void *_glfuncs, GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSynciv(sync, pname, bufSize, length, values); +} + +void gl3_3core_glGetInteger64v(void *_glfuncs, GLenum pname, GLint64* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetInteger64v(pname, params); +} + +void gl3_3core_glWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWaitSync(sync, flags, timeout); +} + +GLenum gl3_3core_glClientWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glClientWaitSync(sync, flags, timeout); +} + +void gl3_3core_glDeleteSync(void *_glfuncs, GLsync sync) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteSync(sync); +} + +GLboolean gl3_3core_glIsSync(void *_glfuncs, GLsync sync) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsSync(sync); +} + +GLsync gl3_3core_glFenceSync(void *_glfuncs, GLenum condition, GLbitfield flags) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glFenceSync(condition, flags); +} + +void gl3_3core_glProvokingVertex(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProvokingVertex(mode); +} + +void gl3_3core_glDrawElementsInstancedBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLint basevertex) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsInstancedBaseVertex(mode, count, gltype, indices, instancecount, basevertex); +} + +void gl3_3core_glDrawRangeElementsBaseVertex(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawRangeElementsBaseVertex(mode, start, end, count, gltype, indices, basevertex); +} + +void gl3_3core_glDrawElementsBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsBaseVertex(mode, count, gltype, indices, basevertex); +} + +void gl3_3core_glFramebufferTexture(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture(target, attachment, texture, level); +} + +void gl3_3core_glGetBufferParameteri64v(void *_glfuncs, GLenum target, GLenum pname, GLint64* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferParameteri64v(target, pname, params); +} + +void gl3_3core_glGetInteger64i_v(void *_glfuncs, GLenum target, GLuint index, GLint64* data) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetInteger64i_v(target, index, data); +} + +void gl3_3core_glVertexAttribP4uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP4uiv(index, gltype, normalized, value); +} + +void gl3_3core_glVertexAttribP4ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP4ui(index, gltype, normalized, value); +} + +void gl3_3core_glVertexAttribP3uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP3uiv(index, gltype, normalized, value); +} + +void gl3_3core_glVertexAttribP3ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP3ui(index, gltype, normalized, value); +} + +void gl3_3core_glVertexAttribP2uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP2uiv(index, gltype, normalized, value); +} + +void gl3_3core_glVertexAttribP2ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP2ui(index, gltype, normalized, value); +} + +void gl3_3core_glVertexAttribP1uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP1uiv(index, gltype, normalized, value); +} + +void gl3_3core_glVertexAttribP1ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP1ui(index, gltype, normalized, value); +} + +void gl3_3core_glSecondaryColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColorP3uiv(gltype, color); +} + +void gl3_3core_glSecondaryColorP3ui(void *_glfuncs, GLenum gltype, GLuint color) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColorP3ui(gltype, color); +} + +void gl3_3core_glColorP4uiv(void *_glfuncs, GLenum gltype, const GLuint* color) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP4uiv(gltype, color); +} + +void gl3_3core_glColorP4ui(void *_glfuncs, GLenum gltype, GLuint color) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP4ui(gltype, color); +} + +void gl3_3core_glColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP3uiv(gltype, color); +} + +void gl3_3core_glColorP3ui(void *_glfuncs, GLenum gltype, GLuint color) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP3ui(gltype, color); +} + +void gl3_3core_glNormalP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormalP3uiv(gltype, coords); +} + +void gl3_3core_glNormalP3ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormalP3ui(gltype, coords); +} + +void gl3_3core_glMultiTexCoordP4uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP4uiv(texture, gltype, coords); +} + +void gl3_3core_glMultiTexCoordP4ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP4ui(texture, gltype, coords); +} + +void gl3_3core_glMultiTexCoordP3uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP3uiv(texture, gltype, coords); +} + +void gl3_3core_glMultiTexCoordP3ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP3ui(texture, gltype, coords); +} + +void gl3_3core_glMultiTexCoordP2uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP2uiv(texture, gltype, coords); +} + +void gl3_3core_glMultiTexCoordP2ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP2ui(texture, gltype, coords); +} + +void gl3_3core_glMultiTexCoordP1uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP1uiv(texture, gltype, coords); +} + +void gl3_3core_glMultiTexCoordP1ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP1ui(texture, gltype, coords); +} + +void gl3_3core_glTexCoordP4uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP4uiv(gltype, coords); +} + +void gl3_3core_glTexCoordP4ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP4ui(gltype, coords); +} + +void gl3_3core_glTexCoordP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP3uiv(gltype, coords); +} + +void gl3_3core_glTexCoordP3ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP3ui(gltype, coords); +} + +void gl3_3core_glTexCoordP2uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP2uiv(gltype, coords); +} + +void gl3_3core_glTexCoordP2ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP2ui(gltype, coords); +} + +void gl3_3core_glTexCoordP1uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP1uiv(gltype, coords); +} + +void gl3_3core_glTexCoordP1ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP1ui(gltype, coords); +} + +void gl3_3core_glVertexP4uiv(void *_glfuncs, GLenum gltype, const GLuint* value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP4uiv(gltype, value); +} + +void gl3_3core_glVertexP4ui(void *_glfuncs, GLenum gltype, GLuint value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP4ui(gltype, value); +} + +void gl3_3core_glVertexP3uiv(void *_glfuncs, GLenum gltype, const GLuint* value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP3uiv(gltype, value); +} + +void gl3_3core_glVertexP3ui(void *_glfuncs, GLenum gltype, GLuint value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP3ui(gltype, value); +} + +void gl3_3core_glVertexP2uiv(void *_glfuncs, GLenum gltype, const GLuint* value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP2uiv(gltype, value); +} + +void gl3_3core_glVertexP2ui(void *_glfuncs, GLenum gltype, GLuint value) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP2ui(gltype, value); +} + +void gl3_3core_glGetQueryObjectui64v(void *_glfuncs, GLuint id, GLenum pname, GLuint64* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectui64v(id, pname, params); +} + +void gl3_3core_glGetQueryObjecti64v(void *_glfuncs, GLuint id, GLenum pname, GLint64* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjecti64v(id, pname, params); +} + +void gl3_3core_glQueryCounter(void *_glfuncs, GLuint id, GLenum target) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glQueryCounter(id, target); +} + +void gl3_3core_glGetSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameterIuiv(sampler, pname, params); +} + +void gl3_3core_glGetSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameterfv(sampler, pname, params); +} + +void gl3_3core_glGetSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameterIiv(sampler, pname, params); +} + +void gl3_3core_glGetSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameteriv(sampler, pname, params); +} + +void gl3_3core_glSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLuint* param) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterIuiv(sampler, pname, param); +} + +void gl3_3core_glSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterIiv(sampler, pname, param); +} + +void gl3_3core_glSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, const GLfloat* param) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterfv(sampler, pname, param); +} + +void gl3_3core_glSamplerParameterf(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterf(sampler, pname, param); +} + +void gl3_3core_glSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameteriv(sampler, pname, param); +} + +void gl3_3core_glSamplerParameteri(void *_glfuncs, GLuint sampler, GLenum pname, GLint param) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameteri(sampler, pname, param); +} + +void gl3_3core_glBindSampler(void *_glfuncs, GLuint unit, GLuint sampler) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindSampler(unit, sampler); +} + +GLboolean gl3_3core_glIsSampler(void *_glfuncs, GLuint sampler) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsSampler(sampler); +} + +void gl3_3core_glDeleteSamplers(void *_glfuncs, GLsizei count, const GLuint* samplers) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteSamplers(count, samplers); +} + +void gl3_3core_glGenSamplers(void *_glfuncs, GLsizei count, GLuint* samplers) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenSamplers(count, samplers); +} + +GLint gl3_3core_glGetFragDataIndex(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetFragDataIndex(program, name); +} + +void gl3_3core_glBindFragDataLocationIndexed(void *_glfuncs, GLuint program, GLuint colorNumber, GLuint index, const GLchar* name) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFragDataLocationIndexed(program, colorNumber, index, name); +} + +void gl3_3core_glVertexAttribDivisor(void *_glfuncs, GLuint index, GLuint divisor) +{ + QOpenGLFunctions_3_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribDivisor(index, divisor); +} + diff --git a/gl/3.3core/funcs.h b/gl/3.3core/funcs.h new file mode 100644 index 00000000..77017a8c --- /dev/null +++ b/gl/3.3core/funcs.h @@ -0,0 +1,352 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#ifndef __cplusplus +#include +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef char GLchar; +typedef signed char GLbyte; /* 1-byte signed */ +typedef short GLshort; /* 2-byte signed */ +typedef int GLint; /* 4-byte signed */ +typedef unsigned char GLubyte; /* 1-byte unsigned */ +typedef unsigned short GLushort; /* 2-byte unsigned */ +typedef unsigned int GLuint; /* 4-byte unsigned */ +typedef int GLsizei; /* 4-byte signed */ +typedef float GLfloat; /* single precision float */ +typedef float GLclampf; /* single precision float in [0,1] */ +typedef double GLdouble; /* double precision float */ +typedef double GLclampd; /* double precision float in [0,1] */ +typedef int64_t GLint64; +typedef uint64_t GLuint64; +typedef ptrdiff_t GLintptr; +typedef ptrdiff_t GLsizeiptr; +typedef ptrdiff_t GLintptrARB; +typedef ptrdiff_t GLsizeiptrARB; +typedef struct __GLsync *GLsync; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +void *gl3_3core_funcs(); + +void gl3_3core_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl3_3core_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal); +GLboolean gl3_3core_glIsEnabled(void *_glfuncs, GLenum cap); +void gl3_3core_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params); +void gl3_3core_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params); +void gl3_3core_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_3core_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl3_3core_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels); +void gl3_3core_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params); +void gl3_3core_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params); +GLenum gl3_3core_glGetError(void *_glfuncs); +void gl3_3core_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params); +void gl3_3core_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params); +void gl3_3core_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels); +void gl3_3core_glReadBuffer(void *_glfuncs, GLenum mode); +void gl3_3core_glPixelStorei(void *_glfuncs, GLenum pname, GLint param); +void gl3_3core_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param); +void gl3_3core_glDepthFunc(void *_glfuncs, GLenum glfunc); +void gl3_3core_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass); +void gl3_3core_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask); +void gl3_3core_glLogicOp(void *_glfuncs, GLenum opcode); +void gl3_3core_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor); +void gl3_3core_glFlush(void *_glfuncs); +void gl3_3core_glFinish(void *_glfuncs); +void gl3_3core_glEnable(void *_glfuncs, GLenum cap); +void gl3_3core_glDisable(void *_glfuncs, GLenum cap); +void gl3_3core_glDepthMask(void *_glfuncs, GLboolean flag); +void gl3_3core_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +void gl3_3core_glStencilMask(void *_glfuncs, GLuint mask); +void gl3_3core_glClearDepth(void *_glfuncs, GLdouble depth); +void gl3_3core_glClearStencil(void *_glfuncs, GLint s); +void gl3_3core_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl3_3core_glClear(void *_glfuncs, GLbitfield mask); +void gl3_3core_glDrawBuffer(void *_glfuncs, GLenum mode); +void gl3_3core_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_3core_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_3core_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl3_3core_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl3_3core_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl3_3core_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl3_3core_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl3_3core_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode); +void gl3_3core_glPointSize(void *_glfuncs, GLfloat size); +void gl3_3core_glLineWidth(void *_glfuncs, GLfloat width); +void gl3_3core_glHint(void *_glfuncs, GLenum target, GLenum mode); +void gl3_3core_glFrontFace(void *_glfuncs, GLenum mode); +void gl3_3core_glCullFace(void *_glfuncs, GLenum mode); +void gl3_3core_glIndexubv(void *_glfuncs, const GLubyte* c); +void gl3_3core_glIndexub(void *_glfuncs, GLubyte c); +GLboolean gl3_3core_glIsTexture(void *_glfuncs, GLuint texture); +void gl3_3core_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures); +void gl3_3core_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures); +void gl3_3core_glBindTexture(void *_glfuncs, GLenum target, GLuint texture); +void gl3_3core_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_3core_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_3core_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl3_3core_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +void gl3_3core_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +void gl3_3core_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border); +void gl3_3core_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units); +void gl3_3core_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl3_3core_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count); +void gl3_3core_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl3_3core_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_3core_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl3_3core_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl3_3core_glBlendEquation(void *_glfuncs, GLenum mode); +void gl3_3core_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl3_3core_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img); +void gl3_3core_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl3_3core_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl3_3core_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl3_3core_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data); +void gl3_3core_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data); +void gl3_3core_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data); +void gl3_3core_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert); +void gl3_3core_glActiveTexture(void *_glfuncs, GLenum texture); +void gl3_3core_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params); +void gl3_3core_glPointParameteri(void *_glfuncs, GLenum pname, GLint param); +void gl3_3core_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl3_3core_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param); +void gl3_3core_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount); +void gl3_3core_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +void gl3_3core_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +GLboolean gl3_3core_glUnmapBuffer(void *_glfuncs, GLenum target); +void gl3_3core_glGetBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data); +void gl3_3core_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data); +void gl3_3core_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage); +GLboolean gl3_3core_glIsBuffer(void *_glfuncs, GLuint buffer); +void gl3_3core_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers); +void gl3_3core_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers); +void gl3_3core_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer); +void gl3_3core_glGetQueryObjectuiv(void *_glfuncs, GLuint id, GLenum pname, GLuint* params); +void gl3_3core_glGetQueryObjectiv(void *_glfuncs, GLuint id, GLenum pname, GLint* params); +void gl3_3core_glGetQueryiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_3core_glEndQuery(void *_glfuncs, GLenum target); +void gl3_3core_glBeginQuery(void *_glfuncs, GLenum target, GLuint id); +GLboolean gl3_3core_glIsQuery(void *_glfuncs, GLuint id); +void gl3_3core_glDeleteQueries(void *_glfuncs, GLsizei n, const GLuint* ids); +void gl3_3core_glGenQueries(void *_glfuncs, GLsizei n, GLuint* ids); +void gl3_3core_glVertexAttribPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLboolean normalized, GLsizei stride, const GLvoid* offset); +void gl3_3core_glValidateProgram(void *_glfuncs, GLuint program); +void gl3_3core_glUniformMatrix4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_3core_glUniformMatrix3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_3core_glUniformMatrix2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_3core_glUniform4iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl3_3core_glUniform3iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl3_3core_glUniform2iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl3_3core_glUniform1iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl3_3core_glUniform4fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl3_3core_glUniform3fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl3_3core_glUniform2fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl3_3core_glUniform1fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl3_3core_glUniform4i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +void gl3_3core_glUniform3i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2); +void gl3_3core_glUniform2i(void *_glfuncs, GLint location, GLint v0, GLint v1); +void gl3_3core_glUniform1i(void *_glfuncs, GLint location, GLint v0); +void gl3_3core_glUniform4f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +void gl3_3core_glUniform3f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +void gl3_3core_glUniform2f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1); +void gl3_3core_glUniform1f(void *_glfuncs, GLint location, GLfloat v0); +void gl3_3core_glUseProgram(void *_glfuncs, GLuint program); +void gl3_3core_glShaderSource(void *_glfuncs, GLuint shader, GLsizei count, const GLchar** source, const GLint* length); +void gl3_3core_glLinkProgram(void *_glfuncs, GLuint program); +GLboolean gl3_3core_glIsShader(void *_glfuncs, GLuint shader); +GLboolean gl3_3core_glIsProgram(void *_glfuncs, GLuint program); +void gl3_3core_glGetVertexAttribiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params); +void gl3_3core_glGetVertexAttribfv(void *_glfuncs, GLuint index, GLenum pname, GLfloat* params); +void gl3_3core_glGetVertexAttribdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params); +void gl3_3core_glGetUniformiv(void *_glfuncs, GLuint program, GLint location, GLint* params); +void gl3_3core_glGetUniformfv(void *_glfuncs, GLuint program, GLint location, GLfloat* params); +GLint gl3_3core_glGetUniformLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl3_3core_glGetShaderSource(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source); +void gl3_3core_glGetShaderInfoLog(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl3_3core_glGetShaderiv(void *_glfuncs, GLuint shader, GLenum pname, GLint* params); +void gl3_3core_glGetProgramInfoLog(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl3_3core_glGetProgramiv(void *_glfuncs, GLuint program, GLenum pname, GLint* params); +GLint gl3_3core_glGetAttribLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl3_3core_glGetAttachedShaders(void *_glfuncs, GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj); +void gl3_3core_glGetActiveUniform(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name); +void gl3_3core_glGetActiveAttrib(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name); +void gl3_3core_glEnableVertexAttribArray(void *_glfuncs, GLuint index); +void gl3_3core_glDisableVertexAttribArray(void *_glfuncs, GLuint index); +void gl3_3core_glDetachShader(void *_glfuncs, GLuint program, GLuint shader); +void gl3_3core_glDeleteShader(void *_glfuncs, GLuint shader); +void gl3_3core_glDeleteProgram(void *_glfuncs, GLuint program); +GLuint gl3_3core_glCreateShader(void *_glfuncs, GLenum gltype); +GLuint gl3_3core_glCreateProgram(void *_glfuncs); +void gl3_3core_glCompileShader(void *_glfuncs, GLuint shader); +void gl3_3core_glBindAttribLocation(void *_glfuncs, GLuint program, GLuint index, const GLchar* name); +void gl3_3core_glAttachShader(void *_glfuncs, GLuint program, GLuint shader); +void gl3_3core_glStencilMaskSeparate(void *_glfuncs, GLenum face, GLuint mask); +void gl3_3core_glStencilFuncSeparate(void *_glfuncs, GLenum face, GLenum glfunc, GLint ref, GLuint mask); +void gl3_3core_glStencilOpSeparate(void *_glfuncs, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +void gl3_3core_glDrawBuffers(void *_glfuncs, GLsizei n, const GLenum* bufs); +void gl3_3core_glBlendEquationSeparate(void *_glfuncs, GLenum modeRGB, GLenum modeAlpha); +void gl3_3core_glUniformMatrix4x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_3core_glUniformMatrix3x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_3core_glUniformMatrix4x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_3core_glUniformMatrix2x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_3core_glUniformMatrix3x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl3_3core_glUniformMatrix2x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +GLboolean gl3_3core_glIsVertexArray(void *_glfuncs, GLuint array); +void gl3_3core_glGenVertexArrays(void *_glfuncs, GLsizei n, GLuint* arrays); +void gl3_3core_glDeleteVertexArrays(void *_glfuncs, GLsizei n, const GLuint* arrays); +void gl3_3core_glBindVertexArray(void *_glfuncs, GLuint array); +void gl3_3core_glFlushMappedBufferRange(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr length); +void gl3_3core_glFramebufferTextureLayer(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +void gl3_3core_glRenderbufferStorageMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height); +void gl3_3core_glBlitFramebuffer(void *_glfuncs, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +void gl3_3core_glGenerateMipmap(void *_glfuncs, GLenum target); +void gl3_3core_glGetFramebufferAttachmentParameteriv(void *_glfuncs, GLenum target, GLenum attachment, GLenum pname, GLint* params); +void gl3_3core_glFramebufferRenderbuffer(void *_glfuncs, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +void gl3_3core_glFramebufferTexture3D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +void gl3_3core_glFramebufferTexture2D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +void gl3_3core_glFramebufferTexture1D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLenum gl3_3core_glCheckFramebufferStatus(void *_glfuncs, GLenum target); +void gl3_3core_glGenFramebuffers(void *_glfuncs, GLsizei n, GLuint* framebuffers); +void gl3_3core_glDeleteFramebuffers(void *_glfuncs, GLsizei n, const GLuint* framebuffers); +void gl3_3core_glBindFramebuffer(void *_glfuncs, GLenum target, GLuint framebuffer); +GLboolean gl3_3core_glIsFramebuffer(void *_glfuncs, GLuint framebuffer); +void gl3_3core_glGetRenderbufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_3core_glRenderbufferStorage(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height); +void gl3_3core_glGenRenderbuffers(void *_glfuncs, GLsizei n, GLuint* renderbuffers); +void gl3_3core_glDeleteRenderbuffers(void *_glfuncs, GLsizei n, const GLuint* renderbuffers); +void gl3_3core_glBindRenderbuffer(void *_glfuncs, GLenum target, GLuint renderbuffer); +GLboolean gl3_3core_glIsRenderbuffer(void *_glfuncs, GLuint renderbuffer); +void gl3_3core_glClearBufferfi(void *_glfuncs, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); +void gl3_3core_glClearBufferfv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLfloat* value); +void gl3_3core_glClearBufferuiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLuint* value); +void gl3_3core_glClearBufferiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLint* value); +void gl3_3core_glGetTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, GLuint* params); +void gl3_3core_glGetTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl3_3core_glTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, const GLuint* params); +void gl3_3core_glTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl3_3core_glUniform4uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl3_3core_glUniform3uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl3_3core_glUniform2uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl3_3core_glUniform1uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl3_3core_glUniform4ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +void gl3_3core_glUniform3ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2); +void gl3_3core_glUniform2ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1); +void gl3_3core_glUniform1ui(void *_glfuncs, GLint location, GLuint v0); +GLint gl3_3core_glGetFragDataLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl3_3core_glBindFragDataLocation(void *_glfuncs, GLuint program, GLuint color, const GLchar* name); +void gl3_3core_glGetUniformuiv(void *_glfuncs, GLuint program, GLint location, GLuint* params); +void gl3_3core_glGetVertexAttribIuiv(void *_glfuncs, GLuint index, GLenum pname, GLuint* params); +void gl3_3core_glGetVertexAttribIiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params); +void gl3_3core_glVertexAttribIPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl3_3core_glEndConditionalRender(void *_glfuncs); +void gl3_3core_glBeginConditionalRender(void *_glfuncs, GLuint id, GLenum mode); +void gl3_3core_glClampColor(void *_glfuncs, GLenum target, GLenum clamp); +void gl3_3core_glGetTransformFeedbackVarying(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* gltype, GLchar* name); +void gl3_3core_glBindBufferBase(void *_glfuncs, GLenum target, GLuint index, GLuint buffer); +void gl3_3core_glBindBufferRange(void *_glfuncs, GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +void gl3_3core_glEndTransformFeedback(void *_glfuncs); +void gl3_3core_glBeginTransformFeedback(void *_glfuncs, GLenum primitiveMode); +GLboolean gl3_3core_glIsEnabledi(void *_glfuncs, GLenum target, GLuint index); +void gl3_3core_glDisablei(void *_glfuncs, GLenum target, GLuint index); +void gl3_3core_glEnablei(void *_glfuncs, GLenum target, GLuint index); +void gl3_3core_glGetIntegeri_v(void *_glfuncs, GLenum target, GLuint index, GLint* data); +void gl3_3core_glGetBooleani_v(void *_glfuncs, GLenum target, GLuint index, GLboolean* data); +void gl3_3core_glColorMaski(void *_glfuncs, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +void gl3_3core_glCopyBufferSubData(void *_glfuncs, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +void gl3_3core_glUniformBlockBinding(void *_glfuncs, GLuint program, GLuint v0, GLuint v1); +void gl3_3core_glGetActiveUniformBlockName(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName); +void gl3_3core_glGetActiveUniformBlockiv(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params); +GLuint gl3_3core_glGetUniformBlockIndex(void *_glfuncs, GLuint program, const GLchar* uniformBlockName); +void gl3_3core_glGetActiveUniformName(void *_glfuncs, GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName); +void gl3_3core_glGetActiveUniformsiv(void *_glfuncs, GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params); +void gl3_3core_glPrimitiveRestartIndex(void *_glfuncs, GLuint index); +void gl3_3core_glTexBuffer(void *_glfuncs, GLenum target, GLenum internalFormat, GLuint buffer); +void gl3_3core_glDrawElementsInstanced(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount); +void gl3_3core_glDrawArraysInstanced(void *_glfuncs, GLenum mode, GLint first, GLsizei count, GLsizei instancecount); +void gl3_3core_glSampleMaski(void *_glfuncs, GLuint index, GLbitfield mask); +void gl3_3core_glGetMultisamplefv(void *_glfuncs, GLenum pname, GLuint index, GLfloat* val); +void gl3_3core_glTexImage3DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); +void gl3_3core_glTexImage2DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +void gl3_3core_glGetSynciv(void *_glfuncs, GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values); +void gl3_3core_glGetInteger64v(void *_glfuncs, GLenum pname, GLint64* params); +void gl3_3core_glWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout); +GLenum gl3_3core_glClientWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout); +void gl3_3core_glDeleteSync(void *_glfuncs, GLsync sync); +GLboolean gl3_3core_glIsSync(void *_glfuncs, GLsync sync); +GLsync gl3_3core_glFenceSync(void *_glfuncs, GLenum condition, GLbitfield flags); +void gl3_3core_glProvokingVertex(void *_glfuncs, GLenum mode); +void gl3_3core_glDrawElementsInstancedBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLint basevertex); +void gl3_3core_glDrawRangeElementsBaseVertex(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex); +void gl3_3core_glDrawElementsBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex); +void gl3_3core_glFramebufferTexture(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level); +void gl3_3core_glGetBufferParameteri64v(void *_glfuncs, GLenum target, GLenum pname, GLint64* params); +void gl3_3core_glGetInteger64i_v(void *_glfuncs, GLenum target, GLuint index, GLint64* data); +void gl3_3core_glVertexAttribP4uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl3_3core_glVertexAttribP4ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl3_3core_glVertexAttribP3uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl3_3core_glVertexAttribP3ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl3_3core_glVertexAttribP2uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl3_3core_glVertexAttribP2ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl3_3core_glVertexAttribP1uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl3_3core_glVertexAttribP1ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl3_3core_glSecondaryColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color); +void gl3_3core_glSecondaryColorP3ui(void *_glfuncs, GLenum gltype, GLuint color); +void gl3_3core_glColorP4uiv(void *_glfuncs, GLenum gltype, const GLuint* color); +void gl3_3core_glColorP4ui(void *_glfuncs, GLenum gltype, GLuint color); +void gl3_3core_glColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color); +void gl3_3core_glColorP3ui(void *_glfuncs, GLenum gltype, GLuint color); +void gl3_3core_glNormalP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl3_3core_glNormalP3ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl3_3core_glMultiTexCoordP4uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl3_3core_glMultiTexCoordP4ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl3_3core_glMultiTexCoordP3uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl3_3core_glMultiTexCoordP3ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl3_3core_glMultiTexCoordP2uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl3_3core_glMultiTexCoordP2ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl3_3core_glMultiTexCoordP1uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl3_3core_glMultiTexCoordP1ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl3_3core_glTexCoordP4uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl3_3core_glTexCoordP4ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl3_3core_glTexCoordP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl3_3core_glTexCoordP3ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl3_3core_glTexCoordP2uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl3_3core_glTexCoordP2ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl3_3core_glTexCoordP1uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl3_3core_glTexCoordP1ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl3_3core_glVertexP4uiv(void *_glfuncs, GLenum gltype, const GLuint* value); +void gl3_3core_glVertexP4ui(void *_glfuncs, GLenum gltype, GLuint value); +void gl3_3core_glVertexP3uiv(void *_glfuncs, GLenum gltype, const GLuint* value); +void gl3_3core_glVertexP3ui(void *_glfuncs, GLenum gltype, GLuint value); +void gl3_3core_glVertexP2uiv(void *_glfuncs, GLenum gltype, const GLuint* value); +void gl3_3core_glVertexP2ui(void *_glfuncs, GLenum gltype, GLuint value); +void gl3_3core_glGetQueryObjectui64v(void *_glfuncs, GLuint id, GLenum pname, GLuint64* params); +void gl3_3core_glGetQueryObjecti64v(void *_glfuncs, GLuint id, GLenum pname, GLint64* params); +void gl3_3core_glQueryCounter(void *_glfuncs, GLuint id, GLenum target); +void gl3_3core_glGetSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, GLuint* params); +void gl3_3core_glGetSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat* params); +void gl3_3core_glGetSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params); +void gl3_3core_glGetSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params); +void gl3_3core_glSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLuint* param); +void gl3_3core_glSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param); +void gl3_3core_glSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, const GLfloat* param); +void gl3_3core_glSamplerParameterf(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat param); +void gl3_3core_glSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param); +void gl3_3core_glSamplerParameteri(void *_glfuncs, GLuint sampler, GLenum pname, GLint param); +void gl3_3core_glBindSampler(void *_glfuncs, GLuint unit, GLuint sampler); +GLboolean gl3_3core_glIsSampler(void *_glfuncs, GLuint sampler); +void gl3_3core_glDeleteSamplers(void *_glfuncs, GLsizei count, const GLuint* samplers); +void gl3_3core_glGenSamplers(void *_glfuncs, GLsizei count, GLuint* samplers); +GLint gl3_3core_glGetFragDataIndex(void *_glfuncs, GLuint program, const GLchar* name); +void gl3_3core_glBindFragDataLocationIndexed(void *_glfuncs, GLuint program, GLuint colorNumber, GLuint index, const GLchar* name); +void gl3_3core_glVertexAttribDivisor(void *_glfuncs, GLuint index, GLuint divisor); + + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/gl/3.3core/gl.go b/gl/3.3core/gl.go new file mode 100644 index 00000000..13e2a4a9 --- /dev/null +++ b/gl/3.3core/gl.go @@ -0,0 +1,5489 @@ +// ** file automatically generated by glgen -- do not edit manually ** + +package GL + +// #cgo CXXFLAGS: -std=c++0x -pedantic-errors -Wall -fno-strict-aliasing +// #cgo LDFLAGS: -lstdc++ +// #cgo pkg-config: Qt5Core Qt5OpenGL +// +// #include "funcs.h" +// +// void free(void*); +// +import "C" + +import ( + "fmt" + "reflect" + "unsafe" + + "gopkg.in/qml.v1/gl/glbase" +) + +// API returns a value that offers methods matching the OpenGL version 3.3 API. +// +// The returned API must not be used after the provided OpenGL context becomes invalid. +func API(context glbase.Contexter) *GL { + gl := &GL{} + gl.funcs = C.gl3_3core_funcs() + if gl.funcs == nil { + panic(fmt.Errorf("OpenGL version 3.3 is not available")) + } + return gl +} + +// GL implements the OpenGL version 3.3 API. Values of this +// type must be created via the API function, and it must not be used after +// the associated OpenGL context becomes invalid. +type GL struct { + funcs unsafe.Pointer +} + +const ( + FALSE = 0 + TRUE = 1 + NONE = 0 + + BYTE = 0x1400 + UNSIGNED_BYTE = 0x1401 + SHORT = 0x1402 + UNSIGNED_SHORT = 0x1403 + INT = 0x1404 + UNSIGNED_INT = 0x1405 + FLOAT = 0x1406 + N2_BYTES = 0x1407 + N3_BYTES = 0x1408 + N4_BYTES = 0x1409 + DOUBLE = 0x140A + HALF_FLOAT = 0x140B + + ACCUM = 0x0100 + LOAD = 0x0101 + RETURN = 0x0102 + MULT = 0x0103 + ADD = 0x0104 + + ACCUM_BUFFER_BIT = 0x00000200 + ALL_ATTRIB_BITS = 0xFFFFFFFF + COLOR_BUFFER_BIT = 0x00004000 + CURRENT_BIT = 0x00000001 + DEPTH_BUFFER_BIT = 0x00000100 + ENABLE_BIT = 0x00002000 + EVAL_BIT = 0x00010000 + FOG_BIT = 0x00000080 + HINT_BIT = 0x00008000 + LIGHTING_BIT = 0x00000040 + LINE_BIT = 0x00000004 + LIST_BIT = 0x00020000 + MULTISAMPLE_BIT = 0x20000000 + PIXEL_MODE_BIT = 0x00000020 + POINT_BIT = 0x00000002 + POLYGON_BIT = 0x00000008 + POLYGON_STIPPLE_BIT = 0x00000010 + SCISSOR_BIT = 0x00080000 + STENCIL_BUFFER_BIT = 0x00000400 + TEXTURE_BIT = 0x00040000 + TRANSFORM_BIT = 0x00001000 + VIEWPORT_BIT = 0x00000800 + + ALWAYS = 0x0207 + EQUAL = 0x0202 + GEQUAL = 0x0206 + GREATER = 0x0204 + LEQUAL = 0x0203 + LESS = 0x0201 + NEVER = 0x0200 + NOTEQUAL = 0x0205 + + LOGIC_OP = 0x0BF1 + + DST_ALPHA = 0x0304 + ONE = 1 + ONE_MINUS_DST_ALPHA = 0x0305 + ONE_MINUS_SRC_ALPHA = 0x0303 + ONE_MINUS_SRC_COLOR = 0x0301 + SRC_ALPHA = 0x0302 + SRC_COLOR = 0x0300 + ZERO = 0 + + DST_COLOR = 0x0306 + ONE_MINUS_DST_COLOR = 0x0307 + SRC_ALPHA_SATURATE = 0x0308 + + CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF + CLIENT_PIXEL_STORE_BIT = 0x00000001 + CLIENT_VERTEX_ARRAY_BIT = 0x00000002 + + CLIP_DISTANCE0 = 0x3000 + CLIP_DISTANCE1 = 0x3001 + CLIP_DISTANCE2 = 0x3002 + CLIP_DISTANCE3 = 0x3003 + CLIP_DISTANCE4 = 0x3004 + CLIP_DISTANCE5 = 0x3005 + CLIP_DISTANCE6 = 0x3006 + CLIP_DISTANCE7 = 0x3007 + CLIP_PLANE0 = 0x3000 + CLIP_PLANE1 = 0x3001 + CLIP_PLANE2 = 0x3002 + CLIP_PLANE3 = 0x3003 + CLIP_PLANE4 = 0x3004 + CLIP_PLANE5 = 0x3005 + + BACK = 0x0405 + FRONT = 0x0404 + FRONT_AND_BACK = 0x0408 + + AMBIENT = 0x1200 + AMBIENT_AND_DIFFUSE = 0x1602 + DIFFUSE = 0x1201 + EMISSION = 0x1600 + SPECULAR = 0x1202 + + CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x00000001 + + CONTEXT_COMPATIBILITY_PROFILE_BIT = 0x00000002 + CONTEXT_CORE_PROFILE_BIT = 0x00000001 + + AUX0 = 0x0409 + AUX1 = 0x040A + AUX2 = 0x040B + AUX3 = 0x040C + BACK_LEFT = 0x0402 + BACK_RIGHT = 0x0403 + FRONT_LEFT = 0x0400 + FRONT_RIGHT = 0x0401 + LEFT = 0x0406 + RIGHT = 0x0407 + + ALPHA_TEST = 0x0BC0 + AUTO_NORMAL = 0x0D80 + BLEND = 0x0BE2 + COLOR_ARRAY = 0x8076 + COLOR_LOGIC_OP = 0x0BF2 + COLOR_MATERIAL = 0x0B57 + CULL_FACE = 0x0B44 + DEPTH_TEST = 0x0B71 + DITHER = 0x0BD0 + EDGE_FLAG_ARRAY = 0x8079 + FOG = 0x0B60 + INDEX_ARRAY = 0x8077 + INDEX_LOGIC_OP = 0x0BF1 + LIGHT0 = 0x4000 + LIGHT1 = 0x4001 + LIGHT2 = 0x4002 + LIGHT3 = 0x4003 + LIGHT4 = 0x4004 + LIGHT5 = 0x4005 + LIGHT6 = 0x4006 + LIGHT7 = 0x4007 + LIGHTING = 0x0B50 + LINE_SMOOTH = 0x0B20 + LINE_STIPPLE = 0x0B24 + MAP1_COLOR_4 = 0x0D90 + MAP1_INDEX = 0x0D91 + MAP1_NORMAL = 0x0D92 + MAP1_TEXTURE_COORD_1 = 0x0D93 + MAP1_TEXTURE_COORD_2 = 0x0D94 + MAP1_TEXTURE_COORD_3 = 0x0D95 + MAP1_TEXTURE_COORD_4 = 0x0D96 + MAP1_VERTEX_3 = 0x0D97 + MAP1_VERTEX_4 = 0x0D98 + MAP2_COLOR_4 = 0x0DB0 + MAP2_INDEX = 0x0DB1 + MAP2_NORMAL = 0x0DB2 + MAP2_TEXTURE_COORD_1 = 0x0DB3 + MAP2_TEXTURE_COORD_2 = 0x0DB4 + MAP2_TEXTURE_COORD_3 = 0x0DB5 + MAP2_TEXTURE_COORD_4 = 0x0DB6 + MAP2_VERTEX_3 = 0x0DB7 + MAP2_VERTEX_4 = 0x0DB8 + NORMALIZE = 0x0BA1 + NORMAL_ARRAY = 0x8075 + POINT_SMOOTH = 0x0B10 + POLYGON_OFFSET_FILL = 0x8037 + POLYGON_OFFSET_LINE = 0x2A02 + POLYGON_OFFSET_POINT = 0x2A01 + POLYGON_SMOOTH = 0x0B41 + POLYGON_STIPPLE = 0x0B42 + SCISSOR_TEST = 0x0C11 + STENCIL_TEST = 0x0B90 + TEXTURE_1D = 0x0DE0 + TEXTURE_2D = 0x0DE1 + TEXTURE_COORD_ARRAY = 0x8078 + TEXTURE_GEN_Q = 0x0C63 + TEXTURE_GEN_R = 0x0C62 + TEXTURE_GEN_S = 0x0C60 + TEXTURE_GEN_T = 0x0C61 + VERTEX_ARRAY = 0x8074 + + INVALID_ENUM = 0x0500 + INVALID_FRAMEBUFFER_OPERATION = 0x0506 + INVALID_OPERATION = 0x0502 + INVALID_VALUE = 0x0501 + NO_ERROR = 0 + OUT_OF_MEMORY = 0x0505 + STACK_OVERFLOW = 0x0503 + STACK_UNDERFLOW = 0x0504 + + N2D = 0x0600 + N3D = 0x0601 + N3D_COLOR = 0x0602 + N3D_COLOR_TEXTURE = 0x0603 + N4D_COLOR_TEXTURE = 0x0604 + + BITMAP_TOKEN = 0x0704 + COPY_PIXEL_TOKEN = 0x0706 + DRAW_PIXEL_TOKEN = 0x0705 + LINE_RESET_TOKEN = 0x0707 + LINE_TOKEN = 0x0702 + PASS_THROUGH_TOKEN = 0x0700 + POINT_TOKEN = 0x0701 + POLYGON_TOKEN = 0x0703 + + EXP = 0x0800 + EXP2 = 0x0801 + LINEAR = 0x2601 + + FOG_COLOR = 0x0B66 + FOG_DENSITY = 0x0B62 + FOG_END = 0x0B64 + FOG_INDEX = 0x0B61 + FOG_MODE = 0x0B65 + FOG_START = 0x0B63 + + CCW = 0x0901 + CW = 0x0900 + + COEFF = 0x0A00 + DOMAIN = 0x0A02 + ORDER = 0x0A01 + + PIXEL_MAP_A_TO_A = 0x0C79 + PIXEL_MAP_B_TO_B = 0x0C78 + PIXEL_MAP_G_TO_G = 0x0C77 + PIXEL_MAP_I_TO_A = 0x0C75 + PIXEL_MAP_I_TO_B = 0x0C74 + PIXEL_MAP_I_TO_G = 0x0C73 + PIXEL_MAP_I_TO_I = 0x0C70 + PIXEL_MAP_I_TO_R = 0x0C72 + PIXEL_MAP_R_TO_R = 0x0C76 + PIXEL_MAP_S_TO_S = 0x0C71 + + ACCUM_ALPHA_BITS = 0x0D5B + ACCUM_BLUE_BITS = 0x0D5A + ACCUM_CLEAR_VALUE = 0x0B80 + ACCUM_GREEN_BITS = 0x0D59 + ACCUM_RED_BITS = 0x0D58 + ALIASED_LINE_WIDTH_RANGE = 0x846E + ALIASED_POINT_SIZE_RANGE = 0x846D + ALPHA_BIAS = 0x0D1D + ALPHA_BITS = 0x0D55 + ALPHA_SCALE = 0x0D1C + ALPHA_TEST_FUNC = 0x0BC1 + ALPHA_TEST_REF = 0x0BC2 + ATTRIB_STACK_DEPTH = 0x0BB0 + AUX_BUFFERS = 0x0C00 + BLEND_DST = 0x0BE0 + BLEND_SRC = 0x0BE1 + BLUE_BIAS = 0x0D1B + BLUE_BITS = 0x0D54 + BLUE_SCALE = 0x0D1A + CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1 + COLOR_ARRAY_SIZE = 0x8081 + COLOR_ARRAY_STRIDE = 0x8083 + COLOR_ARRAY_TYPE = 0x8082 + COLOR_CLEAR_VALUE = 0x0C22 + COLOR_MATERIAL_FACE = 0x0B55 + COLOR_MATERIAL_PARAMETER = 0x0B56 + COLOR_WRITEMASK = 0x0C23 + CULL_FACE_MODE = 0x0B45 + CURRENT_COLOR = 0x0B00 + CURRENT_INDEX = 0x0B01 + CURRENT_NORMAL = 0x0B02 + CURRENT_RASTER_COLOR = 0x0B04 + CURRENT_RASTER_DISTANCE = 0x0B09 + CURRENT_RASTER_INDEX = 0x0B05 + CURRENT_RASTER_POSITION = 0x0B07 + CURRENT_RASTER_POSITION_VALID = 0x0B08 + CURRENT_RASTER_TEXTURE_COORDS = 0x0B06 + CURRENT_TEXTURE_COORDS = 0x0B03 + DEPTH_BIAS = 0x0D1F + DEPTH_BITS = 0x0D56 + DEPTH_CLEAR_VALUE = 0x0B73 + DEPTH_FUNC = 0x0B74 + DEPTH_RANGE = 0x0B70 + DEPTH_SCALE = 0x0D1E + DEPTH_WRITEMASK = 0x0B72 + DOUBLEBUFFER = 0x0C32 + DRAW_BUFFER = 0x0C01 + EDGE_FLAG = 0x0B43 + EDGE_FLAG_ARRAY_STRIDE = 0x808C + FEEDBACK_BUFFER_SIZE = 0x0DF1 + FEEDBACK_BUFFER_TYPE = 0x0DF2 + FOG_HINT = 0x0C54 + FRONT_FACE = 0x0B46 + GREEN_BIAS = 0x0D19 + GREEN_BITS = 0x0D53 + GREEN_SCALE = 0x0D18 + INDEX_ARRAY_STRIDE = 0x8086 + INDEX_ARRAY_TYPE = 0x8085 + INDEX_BITS = 0x0D51 + INDEX_CLEAR_VALUE = 0x0C20 + INDEX_MODE = 0x0C30 + INDEX_OFFSET = 0x0D13 + INDEX_SHIFT = 0x0D12 + INDEX_WRITEMASK = 0x0C21 + LIGHT_MODEL_AMBIENT = 0x0B53 + LIGHT_MODEL_COLOR_CONTROL = 0x81F8 + LIGHT_MODEL_LOCAL_VIEWER = 0x0B51 + LIGHT_MODEL_TWO_SIDE = 0x0B52 + LINE_SMOOTH_HINT = 0x0C52 + LINE_STIPPLE_PATTERN = 0x0B25 + LINE_STIPPLE_REPEAT = 0x0B26 + LINE_WIDTH = 0x0B21 + LINE_WIDTH_GRANULARITY = 0x0B23 + LINE_WIDTH_RANGE = 0x0B22 + LIST_BASE = 0x0B32 + LIST_INDEX = 0x0B33 + LIST_MODE = 0x0B30 + LOGIC_OP_MODE = 0x0BF0 + MAP1_GRID_DOMAIN = 0x0DD0 + MAP1_GRID_SEGMENTS = 0x0DD1 + MAP2_GRID_DOMAIN = 0x0DD2 + MAP2_GRID_SEGMENTS = 0x0DD3 + MAP_COLOR = 0x0D10 + MAP_STENCIL = 0x0D11 + MATRIX_MODE = 0x0BA0 + MAX_ATTRIB_STACK_DEPTH = 0x0D35 + MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B + MAX_CLIP_DISTANCES = 0x0D32 + MAX_CLIP_PLANES = 0x0D32 + MAX_EVAL_ORDER = 0x0D30 + MAX_LIGHTS = 0x0D31 + MAX_LIST_NESTING = 0x0B31 + MAX_MODELVIEW_STACK_DEPTH = 0x0D36 + MAX_NAME_STACK_DEPTH = 0x0D37 + MAX_PIXEL_MAP_TABLE = 0x0D34 + MAX_PROJECTION_STACK_DEPTH = 0x0D38 + MAX_TEXTURE_SIZE = 0x0D33 + MAX_TEXTURE_STACK_DEPTH = 0x0D39 + MAX_VIEWPORT_DIMS = 0x0D3A + MODELVIEW_MATRIX = 0x0BA6 + MODELVIEW_STACK_DEPTH = 0x0BA3 + NAME_STACK_DEPTH = 0x0D70 + NORMAL_ARRAY_STRIDE = 0x807F + NORMAL_ARRAY_TYPE = 0x807E + PACK_ALIGNMENT = 0x0D05 + PACK_LSB_FIRST = 0x0D01 + PACK_ROW_LENGTH = 0x0D02 + PACK_SKIP_PIXELS = 0x0D04 + PACK_SKIP_ROWS = 0x0D03 + PACK_SWAP_BYTES = 0x0D00 + PERSPECTIVE_CORRECTION_HINT = 0x0C50 + PIXEL_MAP_A_TO_A_SIZE = 0x0CB9 + PIXEL_MAP_B_TO_B_SIZE = 0x0CB8 + PIXEL_MAP_G_TO_G_SIZE = 0x0CB7 + PIXEL_MAP_I_TO_A_SIZE = 0x0CB5 + PIXEL_MAP_I_TO_B_SIZE = 0x0CB4 + PIXEL_MAP_I_TO_G_SIZE = 0x0CB3 + PIXEL_MAP_I_TO_I_SIZE = 0x0CB0 + PIXEL_MAP_I_TO_R_SIZE = 0x0CB2 + PIXEL_MAP_R_TO_R_SIZE = 0x0CB6 + PIXEL_MAP_S_TO_S_SIZE = 0x0CB1 + POINT_SIZE = 0x0B11 + POINT_SIZE_GRANULARITY = 0x0B13 + POINT_SIZE_RANGE = 0x0B12 + POINT_SMOOTH_HINT = 0x0C51 + POLYGON_MODE = 0x0B40 + POLYGON_OFFSET_FACTOR = 0x8038 + POLYGON_OFFSET_UNITS = 0x2A00 + POLYGON_SMOOTH_HINT = 0x0C53 + PROJECTION_MATRIX = 0x0BA7 + PROJECTION_STACK_DEPTH = 0x0BA4 + READ_BUFFER = 0x0C02 + RED_BIAS = 0x0D15 + RED_BITS = 0x0D52 + RED_SCALE = 0x0D14 + RENDER_MODE = 0x0C40 + RGBA_MODE = 0x0C31 + SCISSOR_BOX = 0x0C10 + SELECTION_BUFFER_SIZE = 0x0DF4 + SHADE_MODEL = 0x0B54 + SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23 + SMOOTH_LINE_WIDTH_RANGE = 0x0B22 + SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13 + SMOOTH_POINT_SIZE_RANGE = 0x0B12 + STENCIL_BITS = 0x0D57 + STENCIL_CLEAR_VALUE = 0x0B91 + STENCIL_FAIL = 0x0B94 + STENCIL_FUNC = 0x0B92 + STENCIL_PASS_DEPTH_FAIL = 0x0B95 + STENCIL_PASS_DEPTH_PASS = 0x0B96 + STENCIL_REF = 0x0B97 + STENCIL_VALUE_MASK = 0x0B93 + STENCIL_WRITEMASK = 0x0B98 + STEREO = 0x0C33 + SUBPIXEL_BITS = 0x0D50 + TEXTURE_BINDING_1D = 0x8068 + TEXTURE_BINDING_2D = 0x8069 + TEXTURE_BINDING_3D = 0x806A + TEXTURE_COORD_ARRAY_SIZE = 0x8088 + TEXTURE_COORD_ARRAY_STRIDE = 0x808A + TEXTURE_COORD_ARRAY_TYPE = 0x8089 + TEXTURE_MATRIX = 0x0BA8 + TEXTURE_STACK_DEPTH = 0x0BA5 + UNPACK_ALIGNMENT = 0x0CF5 + UNPACK_LSB_FIRST = 0x0CF1 + UNPACK_ROW_LENGTH = 0x0CF2 + UNPACK_SKIP_PIXELS = 0x0CF4 + UNPACK_SKIP_ROWS = 0x0CF3 + UNPACK_SWAP_BYTES = 0x0CF0 + VERTEX_ARRAY_SIZE = 0x807A + VERTEX_ARRAY_STRIDE = 0x807C + VERTEX_ARRAY_TYPE = 0x807B + VIEWPORT = 0x0BA2 + ZOOM_X = 0x0D16 + ZOOM_Y = 0x0D17 + + COLOR_ARRAY_POINTER = 0x8090 + EDGE_FLAG_ARRAY_POINTER = 0x8093 + FEEDBACK_BUFFER_POINTER = 0x0DF0 + INDEX_ARRAY_POINTER = 0x8091 + NORMAL_ARRAY_POINTER = 0x808F + SELECTION_BUFFER_POINTER = 0x0DF3 + TEXTURE_COORD_ARRAY_POINTER = 0x8092 + VERTEX_ARRAY_POINTER = 0x808E + + TEXTURE_ALPHA_SIZE = 0x805F + TEXTURE_BLUE_SIZE = 0x805E + TEXTURE_BORDER = 0x1005 + TEXTURE_BORDER_COLOR = 0x1004 + TEXTURE_COMPONENTS = 0x1003 + TEXTURE_GREEN_SIZE = 0x805D + TEXTURE_HEIGHT = 0x1001 + TEXTURE_INTENSITY_SIZE = 0x8061 + TEXTURE_INTERNAL_FORMAT = 0x1003 + TEXTURE_LUMINANCE_SIZE = 0x8060 + TEXTURE_MAG_FILTER = 0x2800 + TEXTURE_MIN_FILTER = 0x2801 + TEXTURE_PRIORITY = 0x8066 + TEXTURE_RED_SIZE = 0x805C + TEXTURE_RESIDENT = 0x8067 + TEXTURE_WIDTH = 0x1000 + TEXTURE_WRAP_S = 0x2802 + TEXTURE_WRAP_T = 0x2803 + + DONT_CARE = 0x1100 + FASTEST = 0x1101 + NICEST = 0x1102 + + FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B + GENERATE_MIPMAP_HINT = 0x8192 + TEXTURE_COMPRESSION_HINT = 0x84EF + + C3F_V3F = 0x2A24 + C4F_N3F_V3F = 0x2A26 + C4UB_V2F = 0x2A22 + C4UB_V3F = 0x2A23 + N3F_V3F = 0x2A25 + T2F_C3F_V3F = 0x2A2A + T2F_C4F_N3F_V3F = 0x2A2C + T2F_C4UB_V3F = 0x2A29 + T2F_N3F_V3F = 0x2A2B + T2F_V3F = 0x2A27 + T4F_C4F_N3F_V4F = 0x2A2D + T4F_V4F = 0x2A28 + V2F = 0x2A20 + V3F = 0x2A21 + + MODULATE = 0x2100 + REPLACE = 0x1E01 + + SEPARATE_SPECULAR_COLOR = 0x81FA + SINGLE_COLOR = 0x81F9 + + CONSTANT_ATTENUATION = 0x1207 + LINEAR_ATTENUATION = 0x1208 + POSITION = 0x1203 + QUADRATIC_ATTENUATION = 0x1209 + SPOT_CUTOFF = 0x1206 + SPOT_DIRECTION = 0x1204 + SPOT_EXPONENT = 0x1205 + + COMPILE = 0x1300 + COMPILE_AND_EXECUTE = 0x1301 + + AND = 0x1501 + AND_INVERTED = 0x1504 + AND_REVERSE = 0x1502 + CLEAR = 0x1500 + COPY = 0x1503 + COPY_INVERTED = 0x150C + EQUIV = 0x1509 + INVERT = 0x150A + NAND = 0x150E + NOOP = 0x1505 + NOR = 0x1508 + OR = 0x1507 + OR_INVERTED = 0x150D + OR_REVERSE = 0x150B + SET = 0x150F + XOR = 0x1506 + + MAP_FLUSH_EXPLICIT_BIT = 0x0010 + MAP_INVALIDATE_BUFFER_BIT = 0x0008 + MAP_INVALIDATE_RANGE_BIT = 0x0004 + MAP_READ_BIT = 0x0001 + MAP_UNSYNCHRONIZED_BIT = 0x0020 + MAP_WRITE_BIT = 0x0002 + + COLOR_INDEXES = 0x1603 + SHININESS = 0x1601 + + MODELVIEW = 0x1700 + PROJECTION = 0x1701 + TEXTURE = 0x1702 + + LINE = 0x1B01 + POINT = 0x1B00 + + FILL = 0x1B02 + + COLOR = 0x1800 + DEPTH = 0x1801 + STENCIL = 0x1802 + + ALPHA = 0x1906 + BLUE = 0x1905 + COLOR_INDEX = 0x1900 + DEPTH_COMPONENT = 0x1902 + GREEN = 0x1904 + LUMINANCE = 0x1909 + LUMINANCE_ALPHA = 0x190A + RED = 0x1903 + RGB = 0x1907 + RGBA = 0x1908 + STENCIL_INDEX = 0x1901 + + ALPHA12 = 0x803D + ALPHA16 = 0x803E + ALPHA4 = 0x803B + ALPHA8 = 0x803C + INTENSITY = 0x8049 + INTENSITY12 = 0x804C + INTENSITY16 = 0x804D + INTENSITY4 = 0x804A + INTENSITY8 = 0x804B + LUMINANCE12 = 0x8041 + LUMINANCE12_ALPHA12 = 0x8047 + LUMINANCE12_ALPHA4 = 0x8046 + LUMINANCE16 = 0x8042 + LUMINANCE16_ALPHA16 = 0x8048 + LUMINANCE4 = 0x803F + LUMINANCE4_ALPHA4 = 0x8043 + LUMINANCE6_ALPHA2 = 0x8044 + LUMINANCE8 = 0x8040 + LUMINANCE8_ALPHA8 = 0x8045 + R3_G3_B2 = 0x2A10 + RGB10 = 0x8052 + RGB10_A2 = 0x8059 + RGB12 = 0x8053 + RGB16 = 0x8054 + RGB4 = 0x804F + RGB5 = 0x8050 + RGB5_A1 = 0x8057 + RGB8 = 0x8051 + RGBA12 = 0x805A + RGBA16 = 0x805B + RGBA2 = 0x8055 + RGBA4 = 0x8056 + RGBA8 = 0x8058 + + PACK_IMAGE_HEIGHT = 0x806C + PACK_SKIP_IMAGES = 0x806B + UNPACK_IMAGE_HEIGHT = 0x806E + UNPACK_SKIP_IMAGES = 0x806D + + BITMAP = 0x1A00 + UNSIGNED_BYTE_3_3_2 = 0x8032 + UNSIGNED_INT_10_10_10_2 = 0x8036 + UNSIGNED_INT_8_8_8_8 = 0x8035 + UNSIGNED_SHORT_4_4_4_4 = 0x8033 + UNSIGNED_SHORT_5_5_5_1 = 0x8034 + + POINT_DISTANCE_ATTENUATION = 0x8129 + POINT_FADE_THRESHOLD_SIZE = 0x8128 + POINT_SIZE_MAX = 0x8127 + POINT_SIZE_MIN = 0x8126 + + LINES = 0x0001 + LINES_ADJACENCY = 0x000A + LINE_LOOP = 0x0002 + LINE_STRIP = 0x0003 + LINE_STRIP_ADJACENCY = 0x000B + POINTS = 0x0000 + POLYGON = 0x0009 + QUADS = 0x0007 + QUAD_STRIP = 0x0008 + TRIANGLES = 0x0004 + TRIANGLES_ADJACENCY = 0x000C + TRIANGLE_FAN = 0x0006 + TRIANGLE_STRIP = 0x0005 + TRIANGLE_STRIP_ADJACENCY = 0x000D + + FEEDBACK = 0x1C01 + RENDER = 0x1C00 + SELECT = 0x1C02 + + FLAT = 0x1D00 + SMOOTH = 0x1D01 + + DECR = 0x1E03 + INCR = 0x1E02 + KEEP = 0x1E00 + + EXTENSIONS = 0x1F03 + RENDERER = 0x1F01 + VENDOR = 0x1F00 + VERSION = 0x1F02 + + S = 0x2000 + T = 0x2001 + R = 0x2002 + Q = 0x2003 + + DECAL = 0x2101 + + TEXTURE_ENV_COLOR = 0x2201 + TEXTURE_ENV_MODE = 0x2200 + + TEXTURE_ENV = 0x2300 + + EYE_LINEAR = 0x2400 + OBJECT_LINEAR = 0x2401 + SPHERE_MAP = 0x2402 + + EYE_PLANE = 0x2502 + OBJECT_PLANE = 0x2501 + TEXTURE_GEN_MODE = 0x2500 + + NEAREST = 0x2600 + + LINEAR_MIPMAP_LINEAR = 0x2703 + LINEAR_MIPMAP_NEAREST = 0x2701 + NEAREST_MIPMAP_LINEAR = 0x2702 + NEAREST_MIPMAP_NEAREST = 0x2700 + + GENERATE_MIPMAP = 0x8191 + TEXTURE_WRAP_R = 0x8072 + + PROXY_TEXTURE_1D = 0x8063 + PROXY_TEXTURE_2D = 0x8064 + PROXY_TEXTURE_3D = 0x8070 + TEXTURE_3D = 0x806F + TEXTURE_BASE_LEVEL = 0x813C + TEXTURE_MAX_LEVEL = 0x813D + TEXTURE_MAX_LOD = 0x813B + TEXTURE_MIN_LOD = 0x813A + + CLAMP = 0x2900 + CLAMP_TO_BORDER = 0x812D + CLAMP_TO_EDGE = 0x812F + REPEAT = 0x2901 + + SYNC_FLUSH_COMMANDS_BIT = 0x00000001 + INVALID_INDEX = 0xFFFFFFFF + TIMEOUT_IGNORED = 0xFFFFFFFFFFFFFFFF + CONSTANT_COLOR = 0x8001 + ONE_MINUS_CONSTANT_COLOR = 0x8002 + CONSTANT_ALPHA = 0x8003 + ONE_MINUS_CONSTANT_ALPHA = 0x8004 + FUNC_ADD = 0x8006 + MIN = 0x8007 + MAX = 0x8008 + BLEND_EQUATION_RGB = 0x8009 + FUNC_SUBTRACT = 0x800A + FUNC_REVERSE_SUBTRACT = 0x800B + RESCALE_NORMAL = 0x803A + TEXTURE_DEPTH = 0x8071 + MAX_3D_TEXTURE_SIZE = 0x8073 + MULTISAMPLE = 0x809D + SAMPLE_ALPHA_TO_COVERAGE = 0x809E + SAMPLE_ALPHA_TO_ONE = 0x809F + SAMPLE_COVERAGE = 0x80A0 + SAMPLE_BUFFERS = 0x80A8 + SAMPLES = 0x80A9 + SAMPLE_COVERAGE_VALUE = 0x80AA + SAMPLE_COVERAGE_INVERT = 0x80AB + BLEND_DST_RGB = 0x80C8 + BLEND_SRC_RGB = 0x80C9 + BLEND_DST_ALPHA = 0x80CA + BLEND_SRC_ALPHA = 0x80CB + BGR = 0x80E0 + BGRA = 0x80E1 + MAX_ELEMENTS_VERTICES = 0x80E8 + MAX_ELEMENTS_INDICES = 0x80E9 + DEPTH_COMPONENT16 = 0x81A5 + DEPTH_COMPONENT24 = 0x81A6 + DEPTH_COMPONENT32 = 0x81A7 + FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210 + FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211 + FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212 + FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213 + FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214 + FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215 + FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216 + FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217 + FRAMEBUFFER_DEFAULT = 0x8218 + FRAMEBUFFER_UNDEFINED = 0x8219 + DEPTH_STENCIL_ATTACHMENT = 0x821A + MAJOR_VERSION = 0x821B + MINOR_VERSION = 0x821C + NUM_EXTENSIONS = 0x821D + CONTEXT_FLAGS = 0x821E + COMPRESSED_RED = 0x8225 + COMPRESSED_RG = 0x8226 + RG = 0x8227 + RG_INTEGER = 0x8228 + R8 = 0x8229 + R16 = 0x822A + RG8 = 0x822B + RG16 = 0x822C + R16F = 0x822D + R32F = 0x822E + RG16F = 0x822F + RG32F = 0x8230 + R8I = 0x8231 + R8UI = 0x8232 + R16I = 0x8233 + R16UI = 0x8234 + R32I = 0x8235 + R32UI = 0x8236 + RG8I = 0x8237 + RG8UI = 0x8238 + RG16I = 0x8239 + RG16UI = 0x823A + RG32I = 0x823B + RG32UI = 0x823C + UNSIGNED_BYTE_2_3_3_REV = 0x8362 + UNSIGNED_SHORT_5_6_5 = 0x8363 + UNSIGNED_SHORT_5_6_5_REV = 0x8364 + UNSIGNED_SHORT_4_4_4_4_REV = 0x8365 + UNSIGNED_SHORT_1_5_5_5_REV = 0x8366 + UNSIGNED_INT_8_8_8_8_REV = 0x8367 + UNSIGNED_INT_2_10_10_10_REV = 0x8368 + MIRRORED_REPEAT = 0x8370 + FOG_COORDINATE_SOURCE = 0x8450 + FOG_COORD_SRC = 0x8450 + FOG_COORDINATE = 0x8451 + FOG_COORD = 0x8451 + FRAGMENT_DEPTH = 0x8452 + CURRENT_FOG_COORDINATE = 0x8453 + CURRENT_FOG_COORD = 0x8453 + FOG_COORDINATE_ARRAY_TYPE = 0x8454 + FOG_COORD_ARRAY_TYPE = 0x8454 + FOG_COORDINATE_ARRAY_STRIDE = 0x8455 + FOG_COORD_ARRAY_STRIDE = 0x8455 + FOG_COORDINATE_ARRAY_POINTER = 0x8456 + FOG_COORD_ARRAY_POINTER = 0x8456 + FOG_COORDINATE_ARRAY = 0x8457 + FOG_COORD_ARRAY = 0x8457 + COLOR_SUM = 0x8458 + CURRENT_SECONDARY_COLOR = 0x8459 + SECONDARY_COLOR_ARRAY_SIZE = 0x845A + SECONDARY_COLOR_ARRAY_TYPE = 0x845B + SECONDARY_COLOR_ARRAY_STRIDE = 0x845C + SECONDARY_COLOR_ARRAY_POINTER = 0x845D + SECONDARY_COLOR_ARRAY = 0x845E + CURRENT_RASTER_SECONDARY_COLOR = 0x845F + TEXTURE0 = 0x84C0 + TEXTURE1 = 0x84C1 + TEXTURE2 = 0x84C2 + TEXTURE3 = 0x84C3 + TEXTURE4 = 0x84C4 + TEXTURE5 = 0x84C5 + TEXTURE6 = 0x84C6 + TEXTURE7 = 0x84C7 + TEXTURE8 = 0x84C8 + TEXTURE9 = 0x84C9 + TEXTURE10 = 0x84CA + TEXTURE11 = 0x84CB + TEXTURE12 = 0x84CC + TEXTURE13 = 0x84CD + TEXTURE14 = 0x84CE + TEXTURE15 = 0x84CF + TEXTURE16 = 0x84D0 + TEXTURE17 = 0x84D1 + TEXTURE18 = 0x84D2 + TEXTURE19 = 0x84D3 + TEXTURE20 = 0x84D4 + TEXTURE21 = 0x84D5 + TEXTURE22 = 0x84D6 + TEXTURE23 = 0x84D7 + TEXTURE24 = 0x84D8 + TEXTURE25 = 0x84D9 + TEXTURE26 = 0x84DA + TEXTURE27 = 0x84DB + TEXTURE28 = 0x84DC + TEXTURE29 = 0x84DD + TEXTURE30 = 0x84DE + TEXTURE31 = 0x84DF + ACTIVE_TEXTURE = 0x84E0 + CLIENT_ACTIVE_TEXTURE = 0x84E1 + MAX_TEXTURE_UNITS = 0x84E2 + TRANSPOSE_MODELVIEW_MATRIX = 0x84E3 + TRANSPOSE_PROJECTION_MATRIX = 0x84E4 + TRANSPOSE_TEXTURE_MATRIX = 0x84E5 + TRANSPOSE_COLOR_MATRIX = 0x84E6 + SUBTRACT = 0x84E7 + MAX_RENDERBUFFER_SIZE = 0x84E8 + COMPRESSED_ALPHA = 0x84E9 + COMPRESSED_LUMINANCE = 0x84EA + COMPRESSED_LUMINANCE_ALPHA = 0x84EB + COMPRESSED_INTENSITY = 0x84EC + COMPRESSED_RGB = 0x84ED + COMPRESSED_RGBA = 0x84EE + TEXTURE_RECTANGLE = 0x84F5 + TEXTURE_BINDING_RECTANGLE = 0x84F6 + PROXY_TEXTURE_RECTANGLE = 0x84F7 + MAX_RECTANGLE_TEXTURE_SIZE = 0x84F8 + DEPTH_STENCIL = 0x84F9 + UNSIGNED_INT_24_8 = 0x84FA + MAX_TEXTURE_LOD_BIAS = 0x84FD + TEXTURE_FILTER_CONTROL = 0x8500 + TEXTURE_LOD_BIAS = 0x8501 + INCR_WRAP = 0x8507 + DECR_WRAP = 0x8508 + NORMAL_MAP = 0x8511 + REFLECTION_MAP = 0x8512 + TEXTURE_CUBE_MAP = 0x8513 + TEXTURE_BINDING_CUBE_MAP = 0x8514 + TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515 + TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516 + TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517 + TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518 + TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519 + TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A + PROXY_TEXTURE_CUBE_MAP = 0x851B + MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C + COMBINE = 0x8570 + COMBINE_RGB = 0x8571 + COMBINE_ALPHA = 0x8572 + RGB_SCALE = 0x8573 + ADD_SIGNED = 0x8574 + INTERPOLATE = 0x8575 + CONSTANT = 0x8576 + PRIMARY_COLOR = 0x8577 + PREVIOUS = 0x8578 + SOURCE0_RGB = 0x8580 + SRC0_RGB = 0x8580 + SOURCE1_RGB = 0x8581 + SRC1_RGB = 0x8581 + SOURCE2_RGB = 0x8582 + SRC2_RGB = 0x8582 + SOURCE0_ALPHA = 0x8588 + SRC0_ALPHA = 0x8588 + SOURCE1_ALPHA = 0x8589 + SRC1_ALPHA = 0x8589 + SOURCE2_ALPHA = 0x858A + SRC2_ALPHA = 0x858A + OPERAND0_RGB = 0x8590 + OPERAND1_RGB = 0x8591 + OPERAND2_RGB = 0x8592 + OPERAND0_ALPHA = 0x8598 + OPERAND1_ALPHA = 0x8599 + OPERAND2_ALPHA = 0x859A + VERTEX_ARRAY_BINDING = 0x85B5 + VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622 + VERTEX_ATTRIB_ARRAY_SIZE = 0x8623 + VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624 + VERTEX_ATTRIB_ARRAY_TYPE = 0x8625 + CURRENT_VERTEX_ATTRIB = 0x8626 + VERTEX_PROGRAM_POINT_SIZE = 0x8642 + PROGRAM_POINT_SIZE = 0x8642 + VERTEX_PROGRAM_TWO_SIDE = 0x8643 + VERTEX_ATTRIB_ARRAY_POINTER = 0x8645 + DEPTH_CLAMP = 0x864F + TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0 + TEXTURE_COMPRESSED = 0x86A1 + NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2 + COMPRESSED_TEXTURE_FORMATS = 0x86A3 + DOT3_RGB = 0x86AE + DOT3_RGBA = 0x86AF + BUFFER_SIZE = 0x8764 + BUFFER_USAGE = 0x8765 + STENCIL_BACK_FUNC = 0x8800 + STENCIL_BACK_FAIL = 0x8801 + STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802 + STENCIL_BACK_PASS_DEPTH_PASS = 0x8803 + RGBA32F = 0x8814 + RGB32F = 0x8815 + RGBA16F = 0x881A + RGB16F = 0x881B + MAX_DRAW_BUFFERS = 0x8824 + DRAW_BUFFER0 = 0x8825 + DRAW_BUFFER1 = 0x8826 + DRAW_BUFFER2 = 0x8827 + DRAW_BUFFER3 = 0x8828 + DRAW_BUFFER4 = 0x8829 + DRAW_BUFFER5 = 0x882A + DRAW_BUFFER6 = 0x882B + DRAW_BUFFER7 = 0x882C + DRAW_BUFFER8 = 0x882D + DRAW_BUFFER9 = 0x882E + DRAW_BUFFER10 = 0x882F + DRAW_BUFFER11 = 0x8830 + DRAW_BUFFER12 = 0x8831 + DRAW_BUFFER13 = 0x8832 + DRAW_BUFFER14 = 0x8833 + DRAW_BUFFER15 = 0x8834 + BLEND_EQUATION_ALPHA = 0x883D + TEXTURE_DEPTH_SIZE = 0x884A + DEPTH_TEXTURE_MODE = 0x884B + TEXTURE_COMPARE_MODE = 0x884C + TEXTURE_COMPARE_FUNC = 0x884D + COMPARE_R_TO_TEXTURE = 0x884E + COMPARE_REF_TO_TEXTURE = 0x884E + TEXTURE_CUBE_MAP_SEAMLESS = 0x884F + POINT_SPRITE = 0x8861 + COORD_REPLACE = 0x8862 + QUERY_COUNTER_BITS = 0x8864 + CURRENT_QUERY = 0x8865 + QUERY_RESULT = 0x8866 + QUERY_RESULT_AVAILABLE = 0x8867 + MAX_VERTEX_ATTRIBS = 0x8869 + VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A + MAX_TEXTURE_COORDS = 0x8871 + MAX_TEXTURE_IMAGE_UNITS = 0x8872 + ARRAY_BUFFER = 0x8892 + ELEMENT_ARRAY_BUFFER = 0x8893 + ARRAY_BUFFER_BINDING = 0x8894 + ELEMENT_ARRAY_BUFFER_BINDING = 0x8895 + VERTEX_ARRAY_BUFFER_BINDING = 0x8896 + NORMAL_ARRAY_BUFFER_BINDING = 0x8897 + COLOR_ARRAY_BUFFER_BINDING = 0x8898 + INDEX_ARRAY_BUFFER_BINDING = 0x8899 + TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A + EDGE_FLAG_ARRAY_BUFFER_BINDING = 0x889B + SECONDARY_COLOR_ARRAY_BUFFER_BINDING = 0x889C + FOG_COORDINATE_ARRAY_BUFFER_BINDING = 0x889D + FOG_COORD_ARRAY_BUFFER_BINDING = 0x889D + WEIGHT_ARRAY_BUFFER_BINDING = 0x889E + VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F + READ_ONLY = 0x88B8 + WRITE_ONLY = 0x88B9 + READ_WRITE = 0x88BA + BUFFER_ACCESS = 0x88BB + BUFFER_MAPPED = 0x88BC + BUFFER_MAP_POINTER = 0x88BD + TIME_ELAPSED = 0x88BF + STREAM_DRAW = 0x88E0 + STREAM_READ = 0x88E1 + STREAM_COPY = 0x88E2 + STATIC_DRAW = 0x88E4 + STATIC_READ = 0x88E5 + STATIC_COPY = 0x88E6 + DYNAMIC_DRAW = 0x88E8 + DYNAMIC_READ = 0x88E9 + DYNAMIC_COPY = 0x88EA + PIXEL_PACK_BUFFER = 0x88EB + PIXEL_UNPACK_BUFFER = 0x88EC + PIXEL_PACK_BUFFER_BINDING = 0x88ED + PIXEL_UNPACK_BUFFER_BINDING = 0x88EF + DEPTH24_STENCIL8 = 0x88F0 + TEXTURE_STENCIL_SIZE = 0x88F1 + SRC1_COLOR = 0x88F9 + ONE_MINUS_SRC1_COLOR = 0x88FA + ONE_MINUS_SRC1_ALPHA = 0x88FB + MAX_DUAL_SOURCE_DRAW_BUFFERS = 0x88FC + VERTEX_ATTRIB_ARRAY_INTEGER = 0x88FD + VERTEX_ATTRIB_ARRAY_DIVISOR = 0x88FE + MAX_ARRAY_TEXTURE_LAYERS = 0x88FF + MIN_PROGRAM_TEXEL_OFFSET = 0x8904 + MAX_PROGRAM_TEXEL_OFFSET = 0x8905 + SAMPLES_PASSED = 0x8914 + GEOMETRY_VERTICES_OUT = 0x8916 + GEOMETRY_INPUT_TYPE = 0x8917 + GEOMETRY_OUTPUT_TYPE = 0x8918 + SAMPLER_BINDING = 0x8919 + CLAMP_VERTEX_COLOR = 0x891A + CLAMP_FRAGMENT_COLOR = 0x891B + CLAMP_READ_COLOR = 0x891C + FIXED_ONLY = 0x891D + UNIFORM_BUFFER = 0x8A11 + UNIFORM_BUFFER_BINDING = 0x8A28 + UNIFORM_BUFFER_START = 0x8A29 + UNIFORM_BUFFER_SIZE = 0x8A2A + MAX_VERTEX_UNIFORM_BLOCKS = 0x8A2B + MAX_GEOMETRY_UNIFORM_BLOCKS = 0x8A2C + MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8A2D + MAX_COMBINED_UNIFORM_BLOCKS = 0x8A2E + MAX_UNIFORM_BUFFER_BINDINGS = 0x8A2F + MAX_UNIFORM_BLOCK_SIZE = 0x8A30 + MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31 + MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 0x8A32 + MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33 + UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8A34 + ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35 + ACTIVE_UNIFORM_BLOCKS = 0x8A36 + UNIFORM_TYPE = 0x8A37 + UNIFORM_SIZE = 0x8A38 + UNIFORM_NAME_LENGTH = 0x8A39 + UNIFORM_BLOCK_INDEX = 0x8A3A + UNIFORM_OFFSET = 0x8A3B + UNIFORM_ARRAY_STRIDE = 0x8A3C + UNIFORM_MATRIX_STRIDE = 0x8A3D + UNIFORM_IS_ROW_MAJOR = 0x8A3E + UNIFORM_BLOCK_BINDING = 0x8A3F + UNIFORM_BLOCK_DATA_SIZE = 0x8A40 + UNIFORM_BLOCK_NAME_LENGTH = 0x8A41 + UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8A42 + UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43 + UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44 + UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 0x8A45 + UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46 + FRAGMENT_SHADER = 0x8B30 + VERTEX_SHADER = 0x8B31 + MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49 + MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A + MAX_VARYING_FLOATS = 0x8B4B + MAX_VARYING_COMPONENTS = 0x8B4B + MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C + MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D + SHADER_TYPE = 0x8B4F + FLOAT_VEC2 = 0x8B50 + FLOAT_VEC3 = 0x8B51 + FLOAT_VEC4 = 0x8B52 + INT_VEC2 = 0x8B53 + INT_VEC3 = 0x8B54 + INT_VEC4 = 0x8B55 + BOOL = 0x8B56 + BOOL_VEC2 = 0x8B57 + BOOL_VEC3 = 0x8B58 + BOOL_VEC4 = 0x8B59 + FLOAT_MAT2 = 0x8B5A + FLOAT_MAT3 = 0x8B5B + FLOAT_MAT4 = 0x8B5C + SAMPLER_1D = 0x8B5D + SAMPLER_2D = 0x8B5E + SAMPLER_3D = 0x8B5F + SAMPLER_CUBE = 0x8B60 + SAMPLER_1D_SHADOW = 0x8B61 + SAMPLER_2D_SHADOW = 0x8B62 + SAMPLER_2D_RECT = 0x8B63 + SAMPLER_2D_RECT_SHADOW = 0x8B64 + FLOAT_MAT2x3 = 0x8B65 + FLOAT_MAT2x4 = 0x8B66 + FLOAT_MAT3x2 = 0x8B67 + FLOAT_MAT3x4 = 0x8B68 + FLOAT_MAT4x2 = 0x8B69 + FLOAT_MAT4x3 = 0x8B6A + DELETE_STATUS = 0x8B80 + COMPILE_STATUS = 0x8B81 + LINK_STATUS = 0x8B82 + VALIDATE_STATUS = 0x8B83 + INFO_LOG_LENGTH = 0x8B84 + ATTACHED_SHADERS = 0x8B85 + ACTIVE_UNIFORMS = 0x8B86 + ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87 + SHADER_SOURCE_LENGTH = 0x8B88 + ACTIVE_ATTRIBUTES = 0x8B89 + ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A + SHADING_LANGUAGE_VERSION = 0x8B8C + CURRENT_PROGRAM = 0x8B8D + TEXTURE_RED_TYPE = 0x8C10 + TEXTURE_GREEN_TYPE = 0x8C11 + TEXTURE_BLUE_TYPE = 0x8C12 + TEXTURE_ALPHA_TYPE = 0x8C13 + TEXTURE_DEPTH_TYPE = 0x8C16 + UNSIGNED_NORMALIZED = 0x8C17 + TEXTURE_1D_ARRAY = 0x8C18 + PROXY_TEXTURE_1D_ARRAY = 0x8C19 + TEXTURE_2D_ARRAY = 0x8C1A + PROXY_TEXTURE_2D_ARRAY = 0x8C1B + TEXTURE_BINDING_1D_ARRAY = 0x8C1C + TEXTURE_BINDING_2D_ARRAY = 0x8C1D + MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = 0x8C29 + TEXTURE_BUFFER = 0x8C2A + MAX_TEXTURE_BUFFER_SIZE = 0x8C2B + TEXTURE_BINDING_BUFFER = 0x8C2C + TEXTURE_BUFFER_DATA_STORE_BINDING = 0x8C2D + ANY_SAMPLES_PASSED = 0x8C2F + R11F_G11F_B10F = 0x8C3A + UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B + RGB9_E5 = 0x8C3D + UNSIGNED_INT_5_9_9_9_REV = 0x8C3E + TEXTURE_SHARED_SIZE = 0x8C3F + SRGB = 0x8C40 + SRGB8 = 0x8C41 + SRGB_ALPHA = 0x8C42 + SRGB8_ALPHA8 = 0x8C43 + SLUMINANCE_ALPHA = 0x8C44 + SLUMINANCE8_ALPHA8 = 0x8C45 + SLUMINANCE = 0x8C46 + SLUMINANCE8 = 0x8C47 + COMPRESSED_SRGB = 0x8C48 + COMPRESSED_SRGB_ALPHA = 0x8C49 + COMPRESSED_SLUMINANCE = 0x8C4A + COMPRESSED_SLUMINANCE_ALPHA = 0x8C4B + TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76 + TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F + MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80 + TRANSFORM_FEEDBACK_VARYINGS = 0x8C83 + TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84 + TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85 + PRIMITIVES_GENERATED = 0x8C87 + TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88 + RASTERIZER_DISCARD = 0x8C89 + MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A + MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B + INTERLEAVED_ATTRIBS = 0x8C8C + SEPARATE_ATTRIBS = 0x8C8D + TRANSFORM_FEEDBACK_BUFFER = 0x8C8E + TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F + POINT_SPRITE_COORD_ORIGIN = 0x8CA0 + LOWER_LEFT = 0x8CA1 + UPPER_LEFT = 0x8CA2 + STENCIL_BACK_REF = 0x8CA3 + STENCIL_BACK_VALUE_MASK = 0x8CA4 + STENCIL_BACK_WRITEMASK = 0x8CA5 + DRAW_FRAMEBUFFER_BINDING = 0x8CA6 + FRAMEBUFFER_BINDING = 0x8CA6 + RENDERBUFFER_BINDING = 0x8CA7 + READ_FRAMEBUFFER = 0x8CA8 + DRAW_FRAMEBUFFER = 0x8CA9 + READ_FRAMEBUFFER_BINDING = 0x8CAA + RENDERBUFFER_SAMPLES = 0x8CAB + DEPTH_COMPONENT32F = 0x8CAC + DEPTH32F_STENCIL8 = 0x8CAD + FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0 + FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1 + FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2 + FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3 + FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4 + FRAMEBUFFER_COMPLETE = 0x8CD5 + FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6 + FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7 + FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB + FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC + FRAMEBUFFER_UNSUPPORTED = 0x8CDD + MAX_COLOR_ATTACHMENTS = 0x8CDF + COLOR_ATTACHMENT0 = 0x8CE0 + COLOR_ATTACHMENT1 = 0x8CE1 + COLOR_ATTACHMENT2 = 0x8CE2 + COLOR_ATTACHMENT3 = 0x8CE3 + COLOR_ATTACHMENT4 = 0x8CE4 + COLOR_ATTACHMENT5 = 0x8CE5 + COLOR_ATTACHMENT6 = 0x8CE6 + COLOR_ATTACHMENT7 = 0x8CE7 + COLOR_ATTACHMENT8 = 0x8CE8 + COLOR_ATTACHMENT9 = 0x8CE9 + COLOR_ATTACHMENT10 = 0x8CEA + COLOR_ATTACHMENT11 = 0x8CEB + COLOR_ATTACHMENT12 = 0x8CEC + COLOR_ATTACHMENT13 = 0x8CED + COLOR_ATTACHMENT14 = 0x8CEE + COLOR_ATTACHMENT15 = 0x8CEF + DEPTH_ATTACHMENT = 0x8D00 + STENCIL_ATTACHMENT = 0x8D20 + FRAMEBUFFER = 0x8D40 + RENDERBUFFER = 0x8D41 + RENDERBUFFER_WIDTH = 0x8D42 + RENDERBUFFER_HEIGHT = 0x8D43 + RENDERBUFFER_INTERNAL_FORMAT = 0x8D44 + STENCIL_INDEX1 = 0x8D46 + STENCIL_INDEX4 = 0x8D47 + STENCIL_INDEX8 = 0x8D48 + STENCIL_INDEX16 = 0x8D49 + RENDERBUFFER_RED_SIZE = 0x8D50 + RENDERBUFFER_GREEN_SIZE = 0x8D51 + RENDERBUFFER_BLUE_SIZE = 0x8D52 + RENDERBUFFER_ALPHA_SIZE = 0x8D53 + RENDERBUFFER_DEPTH_SIZE = 0x8D54 + RENDERBUFFER_STENCIL_SIZE = 0x8D55 + FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56 + MAX_SAMPLES = 0x8D57 + RGBA32UI = 0x8D70 + RGB32UI = 0x8D71 + RGBA16UI = 0x8D76 + RGB16UI = 0x8D77 + RGBA8UI = 0x8D7C + RGB8UI = 0x8D7D + RGBA32I = 0x8D82 + RGB32I = 0x8D83 + RGBA16I = 0x8D88 + RGB16I = 0x8D89 + RGBA8I = 0x8D8E + RGB8I = 0x8D8F + RED_INTEGER = 0x8D94 + GREEN_INTEGER = 0x8D95 + BLUE_INTEGER = 0x8D96 + ALPHA_INTEGER = 0x8D97 + RGB_INTEGER = 0x8D98 + RGBA_INTEGER = 0x8D99 + BGR_INTEGER = 0x8D9A + BGRA_INTEGER = 0x8D9B + INT_2_10_10_10_REV = 0x8D9F + FRAMEBUFFER_ATTACHMENT_LAYERED = 0x8DA7 + FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = 0x8DA8 + FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD + FRAMEBUFFER_SRGB = 0x8DB9 + COMPRESSED_RED_RGTC1 = 0x8DBB + COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC + COMPRESSED_RG_RGTC2 = 0x8DBD + COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE + SAMPLER_1D_ARRAY = 0x8DC0 + SAMPLER_2D_ARRAY = 0x8DC1 + SAMPLER_BUFFER = 0x8DC2 + SAMPLER_1D_ARRAY_SHADOW = 0x8DC3 + SAMPLER_2D_ARRAY_SHADOW = 0x8DC4 + SAMPLER_CUBE_SHADOW = 0x8DC5 + UNSIGNED_INT_VEC2 = 0x8DC6 + UNSIGNED_INT_VEC3 = 0x8DC7 + UNSIGNED_INT_VEC4 = 0x8DC8 + INT_SAMPLER_1D = 0x8DC9 + INT_SAMPLER_2D = 0x8DCA + INT_SAMPLER_3D = 0x8DCB + INT_SAMPLER_CUBE = 0x8DCC + INT_SAMPLER_2D_RECT = 0x8DCD + INT_SAMPLER_1D_ARRAY = 0x8DCE + INT_SAMPLER_2D_ARRAY = 0x8DCF + INT_SAMPLER_BUFFER = 0x8DD0 + UNSIGNED_INT_SAMPLER_1D = 0x8DD1 + UNSIGNED_INT_SAMPLER_2D = 0x8DD2 + UNSIGNED_INT_SAMPLER_3D = 0x8DD3 + UNSIGNED_INT_SAMPLER_CUBE = 0x8DD4 + UNSIGNED_INT_SAMPLER_2D_RECT = 0x8DD5 + UNSIGNED_INT_SAMPLER_1D_ARRAY = 0x8DD6 + UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8DD7 + UNSIGNED_INT_SAMPLER_BUFFER = 0x8DD8 + GEOMETRY_SHADER = 0x8DD9 + MAX_GEOMETRY_UNIFORM_COMPONENTS = 0x8DDF + MAX_GEOMETRY_OUTPUT_VERTICES = 0x8DE0 + MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = 0x8DE1 + QUERY_WAIT = 0x8E13 + QUERY_NO_WAIT = 0x8E14 + QUERY_BY_REGION_WAIT = 0x8E15 + QUERY_BY_REGION_NO_WAIT = 0x8E16 + TIMESTAMP = 0x8E28 + TEXTURE_SWIZZLE_R = 0x8E42 + TEXTURE_SWIZZLE_G = 0x8E43 + TEXTURE_SWIZZLE_B = 0x8E44 + TEXTURE_SWIZZLE_A = 0x8E45 + TEXTURE_SWIZZLE_RGBA = 0x8E46 + QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = 0x8E4C + FIRST_VERTEX_CONVENTION = 0x8E4D + LAST_VERTEX_CONVENTION = 0x8E4E + PROVOKING_VERTEX = 0x8E4F + SAMPLE_POSITION = 0x8E50 + SAMPLE_MASK = 0x8E51 + SAMPLE_MASK_VALUE = 0x8E52 + MAX_SAMPLE_MASK_WORDS = 0x8E59 + COPY_READ_BUFFER = 0x8F36 + COPY_WRITE_BUFFER = 0x8F37 + R8_SNORM = 0x8F94 + RG8_SNORM = 0x8F95 + RGB8_SNORM = 0x8F96 + RGBA8_SNORM = 0x8F97 + R16_SNORM = 0x8F98 + RG16_SNORM = 0x8F99 + RGB16_SNORM = 0x8F9A + RGBA16_SNORM = 0x8F9B + SIGNED_NORMALIZED = 0x8F9C + PRIMITIVE_RESTART = 0x8F9D + PRIMITIVE_RESTART_INDEX = 0x8F9E + RGB10_A2UI = 0x906F + TEXTURE_2D_MULTISAMPLE = 0x9100 + PROXY_TEXTURE_2D_MULTISAMPLE = 0x9101 + TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9102 + PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9103 + TEXTURE_BINDING_2D_MULTISAMPLE = 0x9104 + TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = 0x9105 + TEXTURE_SAMPLES = 0x9106 + TEXTURE_FIXED_SAMPLE_LOCATIONS = 0x9107 + SAMPLER_2D_MULTISAMPLE = 0x9108 + INT_SAMPLER_2D_MULTISAMPLE = 0x9109 + UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = 0x910A + SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910B + INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910C + UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910D + MAX_COLOR_TEXTURE_SAMPLES = 0x910E + MAX_DEPTH_TEXTURE_SAMPLES = 0x910F + MAX_INTEGER_SAMPLES = 0x9110 + MAX_SERVER_WAIT_TIMEOUT = 0x9111 + OBJECT_TYPE = 0x9112 + SYNC_CONDITION = 0x9113 + SYNC_STATUS = 0x9114 + SYNC_FLAGS = 0x9115 + SYNC_FENCE = 0x9116 + SYNC_GPU_COMMANDS_COMPLETE = 0x9117 + UNSIGNALED = 0x9118 + SIGNALED = 0x9119 + ALREADY_SIGNALED = 0x911A + TIMEOUT_EXPIRED = 0x911B + CONDITION_SATISFIED = 0x911C + WAIT_FAILED = 0x911D + BUFFER_ACCESS_FLAGS = 0x911F + BUFFER_MAP_LENGTH = 0x9120 + BUFFER_MAP_OFFSET = 0x9121 + MAX_VERTEX_OUTPUT_COMPONENTS = 0x9122 + MAX_GEOMETRY_INPUT_COMPONENTS = 0x9123 + MAX_GEOMETRY_OUTPUT_COMPONENTS = 0x9124 + MAX_FRAGMENT_INPUT_COMPONENTS = 0x9125 + CONTEXT_PROFILE_MASK = 0x9126 +) + +// https://www.opengl.org/sdk/docs/man3/xhtml/glViewport.xml +func (gl *GL) Viewport(x, y, width, height int) { + C.gl3_3core_glViewport(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// DepthRange specifies the mapping of depth values from normalized device +// coordinates to window coordinates. +// +// Parameter nearVal specifies the mapping of the near clipping plane to window +// coordinates (defaults to 0), while farVal specifies the mapping of the far +// clipping plane to window coordinates (defaults to 1). +// +// After clipping and division by w, depth coordinates range from -1 to 1, +// corresponding to the near and far clipping planes. DepthRange specifies a +// linear mapping of the normalized depth coordinates in this range to window +// depth coordinates. Regardless of the actual depth buffer implementation, +// window coordinate depth values are treated as though they range from 0 through 1 +// (like color components). Thus, the values accepted by DepthRange are both +// clamped to this range before they are accepted. +// +// The default setting of (0, 1) maps the near plane to 0 and the far plane to 1. +// With this mapping, the depth buffer range is fully utilized. +// +// It is not necessary that nearVal be less than farVal. Reverse mappings such as +// nearVal 1, and farVal 0 are acceptable. +// +// GL.INVALID_OPERATION is generated if DepthRange is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) DepthRange(nearVal, farVal float64) { + C.gl3_3core_glDepthRange(gl.funcs, C.GLdouble(nearVal), C.GLdouble(farVal)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsEnabled.xml +func (gl *GL) IsEnabled(cap glbase.Enum) bool { + glresult := C.gl3_3core_glIsEnabled(gl.funcs, C.GLenum(cap)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexLevelParameteriv.xml +func (gl *GL) GetTexLevelParameteriv(target glbase.Enum, level int, pname glbase.Enum, params []int32) { + C.gl3_3core_glGetTexLevelParameteriv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexLevelParameterfv.xml +func (gl *GL) GetTexLevelParameterfv(target glbase.Enum, level int, pname glbase.Enum, params []float32) { + C.gl3_3core_glGetTexLevelParameterfv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexParameteriv.xml +func (gl *GL) GetTexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_3core_glGetTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexParameterfv.xml +func (gl *GL) GetTexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl3_3core_glGetTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexImage.xml +func (gl *GL) GetTexImage(target glbase.Enum, level int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_3core_glGetTexImage(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetIntegerv.xml +func (gl *GL) GetIntegerv(pname glbase.Enum, params []int32) { + C.gl3_3core_glGetIntegerv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetFloatv.xml +func (gl *GL) GetFloatv(pname glbase.Enum, params []float32) { + C.gl3_3core_glGetFloatv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetError.xml +func (gl *GL) GetError() glbase.Enum { + glresult := C.gl3_3core_glGetError(gl.funcs) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetDoublev.xml +func (gl *GL) GetDoublev(pname glbase.Enum, params []float64) { + C.gl3_3core_glGetDoublev(gl.funcs, C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetBooleanv.xml +func (gl *GL) GetBooleanv(pname glbase.Enum, params []bool) { + C.gl3_3core_glGetBooleanv(gl.funcs, C.GLenum(pname), (*C.GLboolean)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glReadPixels.xml +func (gl *GL) ReadPixels(x, y, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_3core_glReadPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glReadBuffer.xml +func (gl *GL) ReadBuffer(mode glbase.Enum) { + C.gl3_3core_glReadBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPixelStorei.xml +func (gl *GL) PixelStorei(pname glbase.Enum, param int32) { + C.gl3_3core_glPixelStorei(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPixelStoref.xml +func (gl *GL) PixelStoref(pname glbase.Enum, param float32) { + C.gl3_3core_glPixelStoref(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDepthFunc.xml +func (gl *GL) DepthFunc(glfunc glbase.Enum) { + C.gl3_3core_glDepthFunc(gl.funcs, C.GLenum(glfunc)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilOp.xml +func (gl *GL) StencilOp(fail, zfail, zpass glbase.Enum) { + C.gl3_3core_glStencilOp(gl.funcs, C.GLenum(fail), C.GLenum(zfail), C.GLenum(zpass)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilFunc.xml +func (gl *GL) StencilFunc(glfunc glbase.Enum, ref int32, mask uint32) { + C.gl3_3core_glStencilFunc(gl.funcs, C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLogicOp.xml +func (gl *GL) LogicOp(opcode glbase.Enum) { + C.gl3_3core_glLogicOp(gl.funcs, C.GLenum(opcode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlendFunc.xml +func (gl *GL) BlendFunc(sfactor, dfactor glbase.Enum) { + C.gl3_3core_glBlendFunc(gl.funcs, C.GLenum(sfactor), C.GLenum(dfactor)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFlush.xml +func (gl *GL) Flush() { + C.gl3_3core_glFlush(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFinish.xml +func (gl *GL) Finish() { + C.gl3_3core_glFinish(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEnable.xml +func (gl *GL) Enable(cap glbase.Enum) { + C.gl3_3core_glEnable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDisable.xml +func (gl *GL) Disable(cap glbase.Enum) { + C.gl3_3core_glDisable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDepthMask.xml +func (gl *GL) DepthMask(flag bool) { + C.gl3_3core_glDepthMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorMask.xml +func (gl *GL) ColorMask(red, green, blue, alpha bool) { + C.gl3_3core_glColorMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&red)), *(*C.GLboolean)(unsafe.Pointer(&green)), *(*C.GLboolean)(unsafe.Pointer(&blue)), *(*C.GLboolean)(unsafe.Pointer(&alpha))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilMask.xml +func (gl *GL) StencilMask(mask uint32) { + C.gl3_3core_glStencilMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearDepth.xml +func (gl *GL) ClearDepth(depth float64) { + C.gl3_3core_glClearDepth(gl.funcs, C.GLdouble(depth)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearStencil.xml +func (gl *GL) ClearStencil(s int32) { + C.gl3_3core_glClearStencil(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearColor.xml +func (gl *GL) ClearColor(red, green, blue, alpha float32) { + C.gl3_3core_glClearColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClear.xml +func (gl *GL) Clear(mask glbase.Bitfield) { + C.gl3_3core_glClear(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawBuffer.xml +func (gl *GL) DrawBuffer(mode glbase.Enum) { + C.gl3_3core_glDrawBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexImage2D.xml +func (gl *GL) TexImage2D(target glbase.Enum, level int, internalFormat int32, width, height, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_3core_glTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexImage1D.xml +func (gl *GL) TexImage1D(target glbase.Enum, level int, internalFormat int32, width, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_3core_glTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameteriv.xml +func (gl *GL) TexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_3core_glTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameteri.xml +func (gl *GL) TexParameteri(target, pname glbase.Enum, param int32) { + C.gl3_3core_glTexParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameterfv.xml +func (gl *GL) TexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl3_3core_glTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameterf.xml +func (gl *GL) TexParameterf(target, pname glbase.Enum, param float32) { + C.gl3_3core_glTexParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glScissor.xml +func (gl *GL) Scissor(x, y, width, height int) { + C.gl3_3core_glScissor(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPolygonMode.xml +func (gl *GL) PolygonMode(face, mode glbase.Enum) { + C.gl3_3core_glPolygonMode(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPointSize.xml +func (gl *GL) PointSize(size float32) { + C.gl3_3core_glPointSize(gl.funcs, C.GLfloat(size)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glLineWidth.xml +func (gl *GL) LineWidth(width float32) { + C.gl3_3core_glLineWidth(gl.funcs, C.GLfloat(width)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glHint.xml +func (gl *GL) Hint(target, mode glbase.Enum) { + C.gl3_3core_glHint(gl.funcs, C.GLenum(target), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFrontFace.xml +func (gl *GL) FrontFace(mode glbase.Enum) { + C.gl3_3core_glFrontFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCullFace.xml +func (gl *GL) CullFace(mode glbase.Enum) { + C.gl3_3core_glCullFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexubv.xml +func (gl *GL) Indexubv(c []uint8) { + C.gl3_3core_glIndexubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIndexub.xml +func (gl *GL) Indexub(c uint8) { + C.gl3_3core_glIndexub(gl.funcs, C.GLubyte(c)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsTexture.xml +func (gl *GL) IsTexture(texture glbase.Texture) bool { + glresult := C.gl3_3core_glIsTexture(gl.funcs, C.GLuint(texture)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenTextures returns n texture names in textures. There is no guarantee +// that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenTextures. +// +// The generated textures have no dimensionality; they assume the +// dimensionality of the texture target to which they are first bound (see +// BindTexture). +// +// Texture names returned by a call to GenTextures are not returned by +// subsequent calls, unless they are first deleted with DeleteTextures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenTextures is available in GL version 2.0 or greater. +func (gl *GL) GenTextures(n int) []glbase.Texture { + if n == 0 { + return nil + } + textures := make([]glbase.Texture, n) + C.gl3_3core_glGenTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) + return textures +} + +// DeleteTextures deletes the textures objects whose names are stored +// in the textures slice. After a texture is deleted, it has no contents or +// dimensionality, and its name is free for reuse (for example by +// GenTextures). If a texture that is currently bound is deleted, the binding +// reverts to 0 (the default texture). +// +// DeleteTextures silently ignores 0's and names that do not correspond to +// existing textures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteTextures is available in GL version 2.0 or greater. +func (gl *GL) DeleteTextures(textures []glbase.Texture) { + n := len(textures) + if n == 0 { + return + } + C.gl3_3core_glDeleteTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindTexture.xml +func (gl *GL) BindTexture(target glbase.Enum, texture glbase.Texture) { + C.gl3_3core_glBindTexture(gl.funcs, C.GLenum(target), C.GLuint(texture)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexSubImage2D.xml +func (gl *GL) TexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_3core_glTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexSubImage1D.xml +func (gl *GL) TexSubImage1D(target glbase.Enum, level, xoffset, width int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_3core_glTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyTexSubImage2D.xml +func (gl *GL) CopyTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, x, y, width, height int) { + C.gl3_3core_glCopyTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyTexSubImage1D.xml +func (gl *GL) CopyTexSubImage1D(target glbase.Enum, level, xoffset, x, y, width int) { + C.gl3_3core_glCopyTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyTexImage2D.xml +func (gl *GL) CopyTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, height, border int) { + C.gl3_3core_glCopyTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyTexImage1D.xml +func (gl *GL) CopyTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, border int) { + C.gl3_3core_glCopyTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPolygonOffset.xml +func (gl *GL) PolygonOffset(factor, units float32) { + C.gl3_3core_glPolygonOffset(gl.funcs, C.GLfloat(factor), C.GLfloat(units)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawElements.xml +func (gl *GL) DrawElements(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl3_3core_glDrawElements(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawArrays.xml +func (gl *GL) DrawArrays(mode glbase.Enum, first, count int) { + C.gl3_3core_glDrawArrays(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyTexSubImage3D.xml +func (gl *GL) CopyTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, x, y, width, height int) { + C.gl3_3core_glCopyTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexSubImage3D.xml +func (gl *GL) TexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_3core_glTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexImage3D.xml +func (gl *GL) TexImage3D(target glbase.Enum, level int, internalFormat int32, width, height int, depth int32, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl3_3core_glTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawRangeElements.xml +func (gl *GL) DrawRangeElements(mode glbase.Enum, start, end uint32, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl3_3core_glDrawRangeElements(gl.funcs, C.GLenum(mode), C.GLuint(start), C.GLuint(end), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlendEquation.xml +func (gl *GL) BlendEquation(mode glbase.Enum) { + C.gl3_3core_glBlendEquation(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlendColor.xml +func (gl *GL) BlendColor(red, green, blue, alpha float32) { + C.gl3_3core_glBlendColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetCompressedTexImage.xml +func (gl *GL) GetCompressedTexImage(target glbase.Enum, level int, img interface{}) { + var img_ptr unsafe.Pointer + var img_v = reflect.ValueOf(img) + if img != nil && img_v.Kind() != reflect.Slice { + panic("parameter img must be a slice") + } + if img != nil { + img_ptr = unsafe.Pointer(img_v.Index(0).Addr().Pointer()) + } + C.gl3_3core_glGetCompressedTexImage(gl.funcs, C.GLenum(target), C.GLint(level), img_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexSubImage1D.xml +func (gl *GL) CompressedTexSubImage1D(target glbase.Enum, level, xoffset, width int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_3core_glCompressedTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexSubImage2D.xml +func (gl *GL) CompressedTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_3core_glCompressedTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexSubImage3D.xml +func (gl *GL) CompressedTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_3core_glCompressedTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexImage1D.xml +func (gl *GL) CompressedTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, width, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_3core_glCompressedTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexImage2D.xml +func (gl *GL) CompressedTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_3core_glCompressedTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCompressedTexImage3D.xml +func (gl *GL) CompressedTexImage3D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height int, depth int32, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_3core_glCompressedTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSampleCoverage.xml +func (gl *GL) SampleCoverage(value float32, invert bool) { + C.gl3_3core_glSampleCoverage(gl.funcs, C.GLfloat(value), *(*C.GLboolean)(unsafe.Pointer(&invert))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glActiveTexture.xml +func (gl *GL) ActiveTexture(texture glbase.Enum) { + C.gl3_3core_glActiveTexture(gl.funcs, C.GLenum(texture)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPointParameteriv.xml +func (gl *GL) PointParameteriv(pname glbase.Enum, params []int32) { + C.gl3_3core_glPointParameteriv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPointParameteri.xml +func (gl *GL) PointParameteri(pname glbase.Enum, param int32) { + C.gl3_3core_glPointParameteri(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPointParameterfv.xml +func (gl *GL) PointParameterfv(pname glbase.Enum, params []float32) { + C.gl3_3core_glPointParameterfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPointParameterf.xml +func (gl *GL) PointParameterf(pname glbase.Enum, param float32) { + C.gl3_3core_glPointParameterf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiDrawArrays.xml +func (gl *GL) MultiDrawArrays(mode glbase.Enum, first, count []int, drawcount int32) { + C.gl3_3core_glMultiDrawArrays(gl.funcs, C.GLenum(mode), (*C.GLint)(unsafe.Pointer(&first[0])), (*C.GLsizei)(unsafe.Pointer(&count[0])), C.GLsizei(drawcount)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlendFuncSeparate.xml +func (gl *GL) BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha glbase.Enum) { + C.gl3_3core_glBlendFuncSeparate(gl.funcs, C.GLenum(sfactorRGB), C.GLenum(dfactorRGB), C.GLenum(sfactorAlpha), C.GLenum(dfactorAlpha)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetBufferParameteriv.xml +func (gl *GL) GetBufferParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_3core_glGetBufferParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glUnmapBuffer.xml +func (gl *GL) UnmapBuffer(target glbase.Enum) bool { + glresult := C.gl3_3core_glUnmapBuffer(gl.funcs, C.GLenum(target)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetBufferSubData.xml +func (gl *GL) GetBufferSubData(target glbase.Enum, offset, size int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_3core_glGetBufferSubData(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(size), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBufferSubData.xml +func (gl *GL) BufferSubData(target glbase.Enum, offset, size int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl3_3core_glBufferSubData(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(size), data_ptr) +} + +// BufferData creates a new data store for the buffer object currently +// bound to target. Any pre-existing data store is deleted. The new data +// store is created with the specified size in bytes and usage. If data is +// not nil, it must be a slice that is used to initialize the data store. +// In that case the size parameter is ignored and the store size will match +// the slice data size. +// +// In its initial state, the new data store is not mapped, it has a NULL +// mapped pointer, and its mapped access is GL.READ_WRITE. +// +// The target constant must be one of GL.ARRAY_BUFFER, GL.COPY_READ_BUFFER, +// GL.COPY_WRITE_BUFFER, GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER, +// GL.PIXEL_UNPACK_BUFFER, GL.TEXTURE_BUFFER, GL.TRANSFORM_FEEDBACK_BUFFER, +// or GL.UNIFORM_BUFFER. +// +// The usage parameter is a hint to the GL implementation as to how a buffer +// object's data store will be accessed. This enables the GL implementation +// to make more intelligent decisions that may significantly impact buffer +// object performance. It does not, however, constrain the actual usage of +// the data store. usage can be broken down into two parts: first, the +// frequency of access (modification and usage), and second, the nature of +// that access. +// +// A usage frequency of STREAM and nature of DRAW is specified via the +// constant GL.STREAM_DRAW, for example. +// +// The usage frequency of access may be one of: +// +// STREAM +// The data store contents will be modified once and used at most a few times. +// +// STATIC +// The data store contents will be modified once and used many times. +// +// DYNAMIC +// The data store contents will be modified repeatedly and used many times. +// +// The usage nature of access may be one of: +// +// DRAW +// The data store contents are modified by the application, and used as +// the source for GL drawing and image specification commands. +// +// READ +// The data store contents are modified by reading data from the GL, +// and used to return that data when queried by the application. +// +// COPY +// The data store contents are modified by reading data from the GL, +// and used as the source for GL drawing and image specification +// commands. +// +// Clients must align data elements consistent with the requirements of the +// client platform, with an additional base-level requirement that an offset +// within a buffer to a datum comprising N bytes be a multiple of N. +// +// Error GL.INVALID_ENUM is generated if target is not one of the accepted +// buffer targets. GL.INVALID_ENUM is generated if usage is not +// GL.STREAM_DRAW, GL.STREAM_READ, GL.STREAM_COPY, GL.STATIC_DRAW, +// GL.STATIC_READ, GL.STATIC_COPY, GL.DYNAMIC_DRAW, GL.DYNAMIC_READ, or +// GL.DYNAMIC_COPY. GL.INVALID_VALUE is generated if size is negative. +// GL.INVALID_OPERATION is generated if the reserved buffer object name 0 is +// bound to target. GL.OUT_OF_MEMORY is generated if the GL is unable to +// create a data store with the specified size. +func (gl *GL) BufferData(target glbase.Enum, size int, data interface{}, usage glbase.Enum) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + if data != nil { + size = int(data_v.Type().Size()) * data_v.Len() + } + C.gl3_3core_glBufferData(gl.funcs, C.GLenum(target), C.GLsizeiptr(size), data_ptr, C.GLenum(usage)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsBuffer.xml +func (gl *GL) IsBuffer(buffer glbase.Buffer) bool { + glresult := C.gl3_3core_glIsBuffer(gl.funcs, C.GLuint(buffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenBuffers returns n buffer object names. There is no guarantee that +// the names form a contiguous set of integers; however, it is guaranteed +// that none of the returned names was in use immediately before the call to +// GenBuffers. +// +// Buffer object names returned by a call to GenBuffers are not returned by +// subsequent calls, unless they are first deleted with DeleteBuffers. +// +// No buffer objects are associated with the returned buffer object names +// until they are first bound by calling BindBuffer. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if GenBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// GenBuffers is available in GL version 1.5 or greater. +func (gl *GL) GenBuffers(n int) []glbase.Buffer { + if n == 0 { + return nil + } + buffers := make([]glbase.Buffer, n) + C.gl3_3core_glGenBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) + return buffers +} + +// DeleteBuffers deletes the buffer objects whose names are stored in the +// buffers slice. +// +// After a buffer object is deleted, it has no contents, and its name is free +// for reuse (for example by GenBuffers). If a buffer object that is +// currently bound is deleted, the binding reverts to 0 (the absence of any +// buffer object, which reverts to client memory usage). +// +// DeleteBuffers silently ignores 0's and names that do not correspond to +// existing buffer objects. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if DeleteBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// DeleteBuffers is available in GL version 1.5 or greater. +func (gl *GL) DeleteBuffers(buffers []glbase.Buffer) { + n := len(buffers) + if n == 0 { + return + } + C.gl3_3core_glDeleteBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) +} + +// BindBuffer creates or puts in use a named buffer object. +// Calling BindBuffer with target set to GL.ARRAY_BUFFER, +// GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER or GL.PIXEL_UNPACK_BUFFER +// and buffer set to the name of the new buffer object binds the buffer +// object name to the target. When a buffer object is bound to a target, the +// previous binding for that target is automatically broken. +// +// Buffer object names are unsigned integers. The value zero is reserved, but +// there is no default buffer object for each buffer object target. Instead, +// buffer set to zero effectively unbinds any buffer object previously bound, +// and restores client memory usage for that buffer object target. Buffer +// object names and the corresponding buffer object contents are local to the +// shared display-list space (see XCreateContext) of the current GL rendering +// context; two rendering contexts share buffer object names only if they +// also share display lists. +// +// GenBuffers may be called to generate a set of new buffer object names. +// +// The state of a buffer object immediately after it is first bound is an +// unmapped zero-sized memory buffer with GL.READ_WRITE access and +// GL.STATIC_DRAW usage. +// +// While a non-zero buffer object name is bound, GL operations on the target +// to which it is bound affect the bound buffer object, and queries of the +// target to which it is bound return state from the bound buffer object. +// While buffer object name zero is bound, as in the initial state, attempts +// to modify or query state on the target to which it is bound generates an +// GL.INVALID_OPERATION error. +// +// When vertex array pointer state is changed, for example by a call to +// NormalPointer, the current buffer object binding (GL.ARRAY_BUFFER_BINDING) +// is copied into the corresponding client state for the vertex array type +// being changed, for example GL.NORMAL_ARRAY_BUFFER_BINDING. While a +// non-zero buffer object is bound to the GL.ARRAY_BUFFER target, the vertex +// array pointer parameter that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.ELEMENT_ARRAY_BUFFER +// target, the indices parameter of DrawElements, DrawRangeElements, or +// MultiDrawElements that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_PACK_BUFFER +// target, the following commands are affected: GetCompressedTexImage, +// GetConvolutionFilter, GetHistogram, GetMinmax, GetPixelMap, +// GetPolygonStipple, GetSeparableFilter, GetTexImage, and ReadPixels. The +// pointer parameter that is traditionally interpreted as a pointer to +// client-side memory where the pixels are to be packed is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_UNPACK_BUFFER +// target, the following commands are affected: Bitmap, ColorSubTable, +// ColorTable, CompressedTexImage1D, CompressedTexImage2D, +// CompressedTexImage3D, CompressedTexSubImage1D, CompressedTexSubImage2D, +// CompressedTexSubImage3D, ConvolutionFilter1D, ConvolutionFilter2D, +// DrawPixels, PixelMap, PolygonStipple, SeparableFilter2D, TexImage1D, +// TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, and TexSubImage3D. +// The pointer parameter that is traditionally interpreted as a pointer to +// client-side memory from which the pixels are to be unpacked is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// A buffer object binding created with BindBuffer remains active until a +// different buffer object name is bound to the same target, or until the +// bound buffer object is deleted with DeleteBuffers. +// +// Once created, a named buffer object may be re-bound to any target as often +// as needed. However, the GL implementation may make choices about how to +// optimize the storage of a buffer object based on its initial binding +// target. +// +// Error GL.INVALID_ENUM is generated if target is not one of the allowable +// values. GL.INVALID_OPERATION is generated if BindBuffer is executed +// between the execution of Begin and the corresponding execution of End. +// +// BindBuffer is available in GL version 1.5 or greater. +func (gl *GL) BindBuffer(target glbase.Enum, buffer glbase.Buffer) { + C.gl3_3core_glBindBuffer(gl.funcs, C.GLenum(target), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetQueryObjectuiv.xml +func (gl *GL) GetQueryObjectuiv(id uint32, pname glbase.Enum, params []uint32) { + C.gl3_3core_glGetQueryObjectuiv(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetQueryObjectiv.xml +func (gl *GL) GetQueryObjectiv(id uint32, pname glbase.Enum, params []int32) { + C.gl3_3core_glGetQueryObjectiv(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetQueryiv.xml +func (gl *GL) GetQueryiv(target, pname glbase.Enum, params []int32) { + C.gl3_3core_glGetQueryiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEndQuery.xml +func (gl *GL) EndQuery(target glbase.Enum) { + C.gl3_3core_glEndQuery(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBeginQuery.xml +func (gl *GL) BeginQuery(target glbase.Enum, id uint32) { + C.gl3_3core_glBeginQuery(gl.funcs, C.GLenum(target), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsQuery.xml +func (gl *GL) IsQuery(id uint32) bool { + glresult := C.gl3_3core_glIsQuery(gl.funcs, C.GLuint(id)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDeleteQueries.xml +func (gl *GL) DeleteQueries(n int, ids []uint32) { + C.gl3_3core_glDeleteQueries(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGenQueries.xml +func (gl *GL) GenQueries(n int, ids []uint32) { + C.gl3_3core_glGenQueries(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// VertexAttribPointer specifies the location and data format of the array +// of generic vertex attributes at index to use when rendering. size +// specifies the number of components per attribute and must be 1, 2, 3, or +// 4. type specifies the data type of each component, and stride specifies +// the byte stride from one attribute to the next, allowing vertices and +// attributes to be packed into a single array or stored in separate arrays. +// normalized indicates whether the values stored in an integer format are +// to be mapped to the range [-1,1] (for signed values) or [0,1] +// (for unsigned values) when they are accessed and converted to floating +// point; otherwise, values will be converted to floats directly without +// normalization. offset is a byte offset into the buffer object's data +// store, which must be bound to the GL.ARRAY_BUFFER target with BindBuffer. +// +// The buffer object binding (GL.ARRAY_BUFFER_BINDING) is saved as +// generic vertex attribute array client-side state +// (GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING) for the provided index. +// +// To enable and disable a generic vertex attribute array, call +// EnableVertexAttribArray and DisableVertexAttribArray with index. If +// enabled, the generic vertex attribute array is used when DrawArrays or +// DrawElements is called. Each generic vertex attribute array is initially +// disabled. +// +// VertexAttribPointer is typically implemented on the client side. +// +// Error GL.INVALID_ENUM is generated if type is not an accepted value. +// GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_VALUE is generated if size is not 1, 2, +// 3, or 4. GL.INVALID_VALUE is generated if stride is negative. +func (gl *GL) VertexAttribPointer(index glbase.Attrib, size int, gltype glbase.Enum, normalized bool, stride int, offset uintptr) { + offset_ptr := unsafe.Pointer(offset) + C.gl3_3core_glVertexAttribPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLsizei(stride), offset_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glValidateProgram.xml +func (gl *GL) ValidateProgram(program glbase.Program) { + C.gl3_3core_glValidateProgram(gl.funcs, C.GLuint(program)) +} + +// UniformMatrix4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*4) != 0 { + panic("invalid value length for UniformMatrix4fv") + } + count := len(value) / (4 * 4) + C.gl3_3core_glUniformMatrix4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*3) != 0 { + panic("invalid value length for UniformMatrix3fv") + } + count := len(value) / (3 * 3) + C.gl3_3core_glUniformMatrix3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*2) != 0 { + panic("invalid value length for UniformMatrix2fv") + } + count := len(value) / (2 * 2) + C.gl3_3core_glUniformMatrix2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform4iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4iv") + } + count := len(value) / 4 + C.gl3_3core_glUniform4iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform3iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3iv") + } + count := len(value) / 3 + C.gl3_3core_glUniform3iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform2iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2iv") + } + count := len(value) / 2 + C.gl3_3core_glUniform2iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform1iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl3_3core_glUniform1iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4fv") + } + count := len(value) / 4 + C.gl3_3core_glUniform4fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3fv") + } + count := len(value) / 3 + C.gl3_3core_glUniform3fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2fv") + } + count := len(value) / 2 + C.gl3_3core_glUniform2fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform1fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl3_3core_glUniform1fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform4i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4i(location glbase.Uniform, v0, v1, v2, v3 int32) { + C.gl3_3core_glUniform4i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2), C.GLint(v3)) +} + +// Uniform3i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3i(location glbase.Uniform, v0, v1, v2 int32) { + C.gl3_3core_glUniform3i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2)) +} + +// Uniform2i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2i(location glbase.Uniform, v0, v1 int32) { + C.gl3_3core_glUniform2i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1)) +} + +// Uniform1i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1i(location glbase.Uniform, v0 int32) { + C.gl3_3core_glUniform1i(gl.funcs, C.GLint(location), C.GLint(v0)) +} + +// Uniform4f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4f(location glbase.Uniform, v0, v1, v2, v3 float32) { + C.gl3_3core_glUniform4f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2), C.GLfloat(v3)) +} + +// Uniform3f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3f(location glbase.Uniform, v0, v1, v2 float32) { + C.gl3_3core_glUniform3f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2)) +} + +// Uniform2f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2f(location glbase.Uniform, v0, v1 float32) { + C.gl3_3core_glUniform2f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1)) +} + +// Uniform1f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1f(location glbase.Uniform, v0 float32) { + C.gl3_3core_glUniform1f(gl.funcs, C.GLint(location), C.GLfloat(v0)) +} + +// UseProgram installs the program object specified by program as part of +// current rendering state. One or more executables are created in a program +// object by successfully attaching shader objects to it with AttachShader, +// successfully compiling the shader objects with CompileShader, and +// successfully linking the program object with LinkProgram. +// +// A program object will contain an executable that will run on the vertex +// processor if it contains one or more shader objects of type +// GL.VERTEX_SHADER that have been successfully compiled and linked. +// Similarly, a program object will contain an executable that will run on +// the fragment processor if it contains one or more shader objects of type +// GL.FRAGMENT_SHADER that have been successfully compiled and linked. +// +// Successfully installing an executable on a programmable processor will +// cause the corresponding fixed functionality of OpenGL to be disabled. +// Specifically, if an executable is installed on the vertex processor, the +// OpenGL fixed functionality will be disabled as follows. +// +// - The modelview matrix is not applied to vertex coordinates. +// +// - The projection matrix is not applied to vertex coordinates. +// +// - The texture matrices are not applied to texture coordinates. +// +// - Normals are not transformed to eye coordinates. +// +// - Normals are not rescaled or normalized. +// +// - Normalization of GL.AUTO_NORMAL evaluated normals is not performed. +// +// - Texture coordinates are not generated automatically. +// +// - Per-vertex lighting is not performed. +// +// - Color material computations are not performed. +// +// - Color index lighting is not performed. +// +// - This list also applies when setting the current raster position. +// +// The executable that is installed on the vertex processor is expected to +// implement any or all of the desired functionality from the preceding list. +// Similarly, if an executable is installed on the fragment processor, the +// OpenGL fixed functionality will be disabled as follows. +// +// - Texture environment and texture functions are not applied. +// +// - Texture application is not applied. +// +// - Color sum is not applied. +// +// - Fog is not applied. +// +// Again, the fragment shader that is installed is expected to implement any +// or all of the desired functionality from the preceding list. +// +// While a program object is in use, applications are free to modify attached +// shader objects, compile attached shader objects, attach additional shader +// objects, and detach or delete shader objects. None of these operations +// will affect the executables that are part of the current state. However, +// relinking the program object that is currently in use will install the +// program object as part of the current rendering state if the link +// operation was successful (see LinkProgram). If the program object +// currently in use is relinked unsuccessfully, its link status will be set +// to GL.FALSE, but the executables and associated state will remain part of +// the current state until a subsequent call to UseProgram removes it from +// use. After it is removed from use, it cannot be made part of current state +// until it has been successfully relinked. +// +// If program contains shader objects of type GL.VERTEX_SHADER but it does +// not contain shader objects of type GL.FRAGMENT_SHADER, an executable will +// be installed on the vertex processor, but fixed functionality will be used +// for fragment processing. Similarly, if program contains shader objects of +// type GL.FRAGMENT_SHADER but it does not contain shader objects of type +// GL.VERTEX_SHADER, an executable will be installed on the fragment +// processor, but fixed functionality will be used for vertex processing. If +// program is 0, the programmable processors will be disabled, and fixed +// functionality will be used for both vertex and fragment processing. +// +// While a program object is in use, the state that controls the disabled +// fixed functionality may also be updated using the normal OpenGL calls. +// +// Like display lists and texture objects, the name space for program objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// Applications are responsible for providing the synchronization across API +// calls when objects are accessed from different execution threads. +// +// Error GL.INVALID_VALUE is generated if program is neither 0 nor a value +// generated by OpenGL. GL.INVALID_OPERATION is generated if program is not +// a program object. GL.INVALID_OPERATION is generated if program could not +// be made part of current state. GL.INVALID_OPERATION is generated if +// UseProgram is executed between the execution of Begin and the +// corresponding execution of End. +// +// UseProgram is available in GL version 2.0 or greater. +func (gl *GL) UseProgram(program glbase.Program) { + C.gl3_3core_glUseProgram(gl.funcs, C.GLuint(program)) +} + +// ShaderSource sets the source code in shader to the provided source code. Any source +// code previously stored in the shader object is completely replaced. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_VALUE is generated if count is less than 0. +// GL.INVALID_OPERATION is generated if ShaderSource is executed between the +// execution of Begin and the corresponding execution of End. +// +// ShaderSource is available in GL version 2.0 or greater. +func (gl *GL) ShaderSource(shader glbase.Shader, source ...string) { + count := len(source) + length := make([]int32, count) + source_c := make([]unsafe.Pointer, count) + for i, src := range source { + length[i] = int32(len(src)) + if len(src) > 0 { + source_c[i] = *(*unsafe.Pointer)(unsafe.Pointer(&src)) + } else { + source_c[i] = unsafe.Pointer(uintptr(0)) + } + } + C.gl3_3core_glShaderSource(gl.funcs, C.GLuint(shader), C.GLsizei(count), (**C.GLchar)(unsafe.Pointer(&source_c[0])), (*C.GLint)(unsafe.Pointer(&length[0]))) +} + +// LinkProgram links the program object specified by program. If any shader +// objects of type GL.VERTEX_SHADER are attached to program, they will be +// used to create an executable that will run on the programmable vertex +// processor. If any shader objects of type GL.FRAGMENT_SHADER are attached +// to program, they will be used to create an executable that will run on the +// programmable fragment processor. +// +// The status of the link operation will be stored as part of the program +// object's state. This value will be set to GL.TRUE if the program object +// was linked without errors and is ready for use, and GL.FALSE otherwise. It +// can be queried by calling GetProgramiv with arguments program and +// GL.LINK_STATUS. +// +// As a result of a successful link operation, all active user-defined +// uniform variables belonging to program will be initialized to 0, and each +// of the program object's active uniform variables will be assigned a +// location that can be queried by calling GetUniformLocation. Also, any +// active user-defined attribute variables that have not been bound to a +// generic vertex attribute index will be bound to one at this time. +// +// Linking of a program object can fail for a number of reasons as specified +// in the OpenGL Shading Language Specification. The following lists some of +// the conditions that will cause a link error. +// +// - The number of active attribute variables supported by the +// implementation has been exceeded. +// +// - The storage limit for uniform variables has been exceeded. +// +// - The number of active uniform variables supported by the implementation +// has been exceeded. +// +// - The main function is missing for the vertex shader or the fragment +// shader. +// +// - A varying variable actually used in the fragment shader is not +// declared in the same way (or is not declared at all) in the vertex +// shader. +// +// - A reference to a function or variable name is unresolved. +// +// - A shared global is declared with two different types or two different +// initial values. +// +// - One or more of the attached shader objects has not been successfully +// compiled. +// +// - Binding a generic attribute matrix caused some rows of the matrix to +// fall outside the allowed maximum of GL.MAX_VERTEX_ATTRIBS. +// +// - Not enough contiguous vertex attribute slots could be found to bind +// attribute matrices. +// +// When a program object has been successfully linked, the program object can +// be made part of current state by calling UseProgram. Whether or not the +// link operation was successful, the program object's information log will +// be overwritten. The information log can be retrieved by calling +// GetProgramInfoLog. +// +// LinkProgram will also install the generated executables as part of the +// current rendering state if the link operation was successful and the +// specified program object is already currently in use as a result of a +// previous call to UseProgram. If the program object currently in use is +// relinked unsuccessfully, its link status will be set to GL.FALSE , but the +// executables and associated state will remain part of the current state +// until a subsequent call to UseProgram removes it from use. After it is +// removed from use, it cannot be made part of current state until it has +// been successfully relinked. +// +// If program contains shader objects of type GL.VERTEX_SHADER but does not +// contain shader objects of type GL.FRAGMENT_SHADER, the vertex shader will +// be linked against the implicit interface for fixed functionality fragment +// processing. Similarly, if program contains shader objects of type +// GL.FRAGMENT_SHADER but it does not contain shader objects of type +// GL.VERTEX_SHADER, the fragment shader will be linked against the implicit +// interface for fixed functionality vertex processing. +// +// The program object's information log is updated and the program is +// generated at the time of the link operation. After the link operation, +// applications are free to modify attached shader objects, compile attached +// shader objects, detach shader objects, delete shader objects, and attach +// additional shader objects. None of these operations affects the +// information log or the program that is part of the program object. +// +// If the link operation is unsuccessful, any information about a previous +// link operation on program is lost (a failed link does not restore the +// old state of program). Certain information can still be retrieved +// from program even after an unsuccessful link operation. See for instance +// GetActiveAttrib and GetActiveUniform. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if LinkProgram is executed +// between the execution of Begin and the corresponding execution of End. +// +// LinkProgram is available in GL version 2.0 or greater. +func (gl *GL) LinkProgram(program glbase.Program) { + C.gl3_3core_glLinkProgram(gl.funcs, C.GLuint(program)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsShader.xml +func (gl *GL) IsShader(shader glbase.Shader) bool { + glresult := C.gl3_3core_glIsShader(gl.funcs, C.GLuint(shader)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsProgram.xml +func (gl *GL) IsProgram(program glbase.Program) bool { + glresult := C.gl3_3core_glIsProgram(gl.funcs, C.GLuint(program)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GetVertexAttribiv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribiv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribiv(index glbase.Attrib, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl3_3core_glGetVertexAttribiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetVertexAttribfv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribfv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribfv(index glbase.Attrib, pname glbase.Enum, params []float32) { + var params_c [4]float32 + C.gl3_3core_glGetVertexAttribfv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetVertexAttribdv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribdv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribdv(index glbase.Attrib, pname glbase.Enum, params []float64) { + var params_c [4]float64 + C.gl3_3core_glGetVertexAttribdv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformiv returns in params the value of the specified uniform +// variable. The type of the uniform variable specified by location +// determines the number of values returned. If the uniform variable is +// defined in the shader as a boolean, int, or float, a single value will be +// returned. If it is defined as a vec2, ivec2, or bvec2, two values will be +// returned. If it is defined as a vec3, ivec3, or bvec3, three values will +// be returned, and so on. To query values stored in uniform variables +// declared as arrays, call GetUniformiv for each element of the array. To +// query values stored in uniform variables declared as structures, call +// GetUniformiv for each field in the structure. The values for uniform +// variables declared as a matrix will be returned in column major order. +// +// The locations assigned to uniform variables are not known until the +// program object is linked. After linking has occurred, the command +// GetUniformLocation can be used to obtain the location of a uniform +// variable. This location value can then be passed to GetUniformiv in order +// to query the current value of the uniform variable. After a program object +// has been linked successfully, the index values for uniform variables +// remain fixed until the next link command occurs. The uniform variable +// values can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if program has not been +// successfully linked. GL.INVALID_OPERATION is generated if location does +// not correspond to a valid uniform variable location for the specified +// program object. GL.INVALID_OPERATION is generated if GetUniformiv is +// executed between the execution of Begin and the corresponding execution of +// End. +// +// GetUniformiv is available in GL version 2.0 or greater. +func (gl *GL) GetUniformiv(program glbase.Program, location glbase.Uniform, params []int32) { + var params_c [4]int32 + C.gl3_3core_glGetUniformiv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformfv returns in params the value of the specified uniform +// variable. The type of the uniform variable specified by location +// determines the number of values returned. If the uniform variable is +// defined in the shader as a boolean, int, or float, a single value will be +// returned. If it is defined as a vec2, ivec2, or bvec2, two values will be +// returned. If it is defined as a vec3, ivec3, or bvec3, three values will +// be returned, and so on. To query values stored in uniform variables +// declared as arrays, call GetUniformfv for each element of the array. To +// query values stored in uniform variables declared as structures, call +// GetUniformfv for each field in the structure. The values for uniform +// variables declared as a matrix will be returned in column major order. +// +// The locations assigned to uniform variables are not known until the +// program object is linked. After linking has occurred, the command +// GetUniformLocation can be used to obtain the location of a uniform +// variable. This location value can then be passed to GetUniformfv in order +// to query the current value of the uniform variable. After a program object +// has been linked successfully, the index values for uniform variables +// remain fixed until the next link command occurs. The uniform variable +// values can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if program has not been +// successfully linked. GL.INVALID_OPERATION is generated if location does +// not correspond to a valid uniform variable location for the specified +// program object. GL.INVALID_OPERATION is generated if GetUniformfv is +// executed between the execution of Begin and the corresponding execution of +// End. +// +// GetUniformfv is available in GL version 2.0 or greater. +func (gl *GL) GetUniformfv(program glbase.Program, location glbase.Uniform, params []float32) { + var params_c [4]float32 + C.gl3_3core_glGetUniformfv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLfloat)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformLocation returns an integer that represents the location of a +// specific uniform variable within a program object. name must be an active +// uniform variable name in program that is not a structure, an array of +// structures, or a subcomponent of a vector or a matrix. This function +// returns -1 if name does not correspond to an active uniform variable in +// program or if name starts with the reserved prefix "gl_". +// +// Uniform variables that are structures or arrays of structures may be +// queried by calling GetUniformLocation for each field within the +// structure. The array element operator "[]" and the structure field +// operator "." may be used in name in order to select elements within an +// array or fields within a structure. The result of using these operators is +// not allowed to be another structure, an array of structures, or a +// subcomponent of a vector or a matrix. Except if the last part of name +// indicates a uniform variable array, the location of the first element of +// an array can be retrieved by using the name of the array, or by using the +// name appended by "[0]". +// +// The actual locations assigned to uniform variables are not known until the +// program object is linked successfully. After linking has occurred, the +// command GetUniformLocation can be used to obtain the location of a +// uniform variable. This location value can then be passed to Uniform to +// set the value of the uniform variable or to GetUniform in order to query +// the current value of the uniform variable. After a program object has been +// linked successfully, the index values for uniform variables remain fixed +// until the next link command occurs. Uniform variable locations and values +// can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program object. +// GL.INVALID_OPERATION is generated if program has not been successfully +// linked. GL.INVALID_OPERATION is generated if GetUniformLocation is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetUniformLocation is available in GL version 2.0 or greater. +func (gl *GL) GetUniformLocation(program glbase.Program, name string) glbase.Uniform { + name_cstr := C.CString(name) + glresult := C.gl3_3core_glGetUniformLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) + return glbase.Uniform(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetShaderSource.xml +func (gl *GL) GetShaderSource(shader glbase.Shader, bufSize int32, length []int32, source []byte) { + C.gl3_3core_glGetShaderSource(gl.funcs, C.GLuint(shader), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&source[0]))) +} + +// GetShaderInfoLog returns the information log for the specified shader +// object. The information log for a shader object is modified when the +// shader is compiled. +// +// The information log for a shader object is a string that may contain +// diagnostic messages, warning messages, and other information about the +// last compile operation. When a shader object is created, its information +// log will be a string of length 0, and the size of the current log can be +// obtained by calling GetShaderiv with the value GL.INFO_LOG_LENGTH. +// +// The information log for a shader object is the OpenGL implementer's +// primary mechanism for conveying information about the compilation process. +// Therefore, the information log can be helpful to application developers +// during the development process, even when compilation is successful. +// Application developers should not expect different OpenGL implementations +// to produce identical information logs. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_VALUE is generated if maxLength is less than 0. +// GL.INVALID_OPERATION is generated if GetShaderInfoLog is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetShaderInfoLog is available in GL version 2.0 or greater. +func (gl *GL) GetShaderInfoLog(shader glbase.Shader) []byte { + var params [1]int32 + var length int32 + gl.GetShaderiv(shader, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + C.gl3_3core_glGetShaderInfoLog(gl.funcs, C.GLuint(shader), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length)), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) + return infoLog +} + +// GetShaderiv GetShader returns in params the value of a parameter for a specific +// shader object. The following parameters are defined: +// +// GL.SHADER_TYPE +// params returns GL.VERTEX_SHADER if shader is a vertex shader object, +// and GL.FRAGMENT_SHADER if shader is a fragment shader object. +// +// GL.DELETE_STATUS +// params returns GL.TRUE if shader is currently flagged for deletion, +// and GL.FALSE otherwise. +// +// GL.COMPILE_STATUS +// params returns GL.TRUE if the last compile operation on shader was +// successful, and GL.FALSE otherwise. +// +// GL.INFO_LOG_LENGTH +// params returns the number of characters in the information log for +// shader including the null termination character (the size of the +// character buffer required to store the information log). If shader has +// no information log, a value of 0 is returned. +// +// GL.SHADER_SOURCE_LENGTH +// params returns the length of the concatenation of the source strings +// that make up the shader source for the shader, including the null +// termination character. (the size of the character buffer +// required to store the shader source). If no source code exists, 0 is +// returned. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader does not refer to a +// shader object. GL.INVALID_ENUM is generated if pname is not an accepted +// value. GL.INVALID_OPERATION is generated if GetShader is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetShaderiv is available in GL version 2.0 or greater. +func (gl *GL) GetShaderiv(shader glbase.Shader, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl3_3core_glGetShaderiv(gl.funcs, C.GLuint(shader), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetProgramInfoLog returns the information log for the specified program +// object. The information log for a program object is modified when the +// program object is linked or validated. +// +// The information log for a program object is either an empty string, or a +// string containing information about the last link operation, or a string +// containing information about the last validation operation. It may contain +// diagnostic messages, warning messages, and other information. When a +// program object is created, its information log will be a string of length +// 0, and the size of the current log can be obtained by calling GetProgramiv +// with the value GL.INFO_LOG_LENGTH. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated +// by OpenGL. GL.INVALID_OPERATION is generated if program is not a +// program object. +func (gl *GL) GetProgramInfoLog(program glbase.Program) []byte { + var params [1]int32 + var length int32 + gl.GetProgramiv(program, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + C.gl3_3core_glGetProgramInfoLog(gl.funcs, C.GLuint(program), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length)), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) + return infoLog +} + +// GetProgramiv returns in params the value of a parameter for a specific +// program object. The following parameters are defined: +// +// GL.DELETE_STATUS +// params returns GL.TRUE if program is currently flagged for deletion, +// and GL.FALSE otherwise. +// +// GL.LINK_STATUS +// params returns GL.TRUE if the last link operation on program was +// successful, and GL.FALSE otherwise. +// +// GL.VALIDATE_STATUS +// params returns GL.TRUE or if the last validation operation on +// program was successful, and GL.FALSE otherwise. +// +// GL.INFO_LOG_LENGTH +// params returns the number of characters in the information log for +// program including the null termination character (the size of +// the character buffer required to store the information log). If +// program has no information log, a value of 0 is returned. +// +// GL.ATTACHED_SHADERS +// params returns the number of shader objects attached to program. +// +// GL.ACTIVE_ATTRIBUTES +// params returns the number of active attribute variables for program. +// +// GL.ACTIVE_ATTRIBUTE_MAX_LENGTH +// params returns the length of the longest active attribute name for +// program, including the null termination character (the size of +// the character buffer required to store the longest attribute name). +// If no active attributes exist, 0 is returned. +// +// GL.ACTIVE_UNIFORMS +// params returns the number of active uniform variables for program. +// +// GL.ACTIVE_UNIFORM_MAX_LENGTH +// params returns the length of the longest active uniform variable +// name for program, including the null termination character (i.e., +// the size of the character buffer required to store the longest +// uniform variable name). If no active uniform variables exist, 0 is +// returned. +// +// GL.TRANSFORM_FEEDBACK_BUFFER_MODE +// params returns a symbolic constant indicating the buffer mode used +// when transform feedback is active. This may be GL.SEPARATE_ATTRIBS +// or GL.INTERLEAVED_ATTRIBS. +// +// GL.TRANSFORM_FEEDBACK_VARYINGS +// params returns the number of varying variables to capture in transform +// feedback mode for the program. +// +// GL.TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH +// params returns the length of the longest variable name to be used for +// transform feedback, including the null-terminator. +// +// GL.GEOMETRY_VERTICES_OUT +// params returns the maximum number of vertices that the geometry shader in +// program will output. +// +// GL.GEOMETRY_INPUT_TYPE +// params returns a symbolic constant indicating the primitive type accepted +// as input to the geometry shader contained in program. +// +// GL.GEOMETRY_OUTPUT_TYPE +// params returns a symbolic constant indicating the primitive type that will +// be output by the geometry shader contained in program. +// +// GL.ACTIVE_UNIFORM_BLOCKS and GL.ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH are +// available only if the GL version 3.1 or greater. +// +// GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE and +// GL.GEOMETRY_OUTPUT_TYPE are accepted only if the GL version is 3.2 or +// greater. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program does not refer to a +// program object. GL.INVALID_OPERATION is generated if pname is +// GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE, or +// GL.GEOMETRY_OUTPUT_TYPE, and program does not contain a geometry shader. +// GL.INVALID_ENUM is generated if pname is not an accepted value. +func (gl *GL) GetProgramiv(program glbase.Program, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl3_3core_glGetProgramiv(gl.funcs, C.GLuint(program), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetAttribLocation queries the previously linked program object specified +// by program for the attribute variable specified by name and returns the +// index of the generic vertex attribute that is bound to that attribute +// variable. If name is a matrix attribute variable, the index of the first +// column of the matrix is returned. If the named attribute variable is not +// an active attribute in the specified program object or if name starts with +// the reserved prefix "gl_", a value of -1 is returned. +// +// The association between an attribute variable name and a generic attribute +// index can be specified at any time by calling BindAttribLocation. +// Attribute bindings do not go into effect until LinkProgram is called. +// After a program object has been linked successfully, the index values for +// attribute variables remain fixed until the next link command occurs. The +// attribute values can only be queried after a link if the link was +// successful. GetAttribLocation returns the binding that actually went +// into effect the last time LinkProgram was called for the specified +// program object. Attribute bindings that have been specified since the last +// link operation are not returned by GetAttribLocation. +// +// Error GL_INVALID_OPERATION is generated if program is not a value +// generated by OpenGL. GL_INVALID_OPERATION is generated if program is not +// a program object. GL_INVALID_OPERATION is generated if program has not +// been successfully linked. GL_INVALID_OPERATION is generated if +// GetAttribLocation is executed between the execution of Begin and the +// corresponding execution of End. +// +// GetAttribLocation is available in GL version 2.0 or greater. +func (gl *GL) GetAttribLocation(program glbase.Program, name string) glbase.Attrib { + name_cstr := C.CString(name) + glresult := C.gl3_3core_glGetAttribLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) + return glbase.Attrib(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetAttachedShaders.xml +func (gl *GL) GetAttachedShaders(program glbase.Program, maxCount int32, count []int, obj []uint32) { + C.gl3_3core_glGetAttachedShaders(gl.funcs, C.GLuint(program), C.GLsizei(maxCount), (*C.GLsizei)(unsafe.Pointer(&count[0])), (*C.GLuint)(unsafe.Pointer(&obj[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetActiveUniform.xml +func (gl *GL) GetActiveUniform(program glbase.Program, index uint32, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl3_3core_glGetActiveUniform(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetActiveAttrib.xml +func (gl *GL) GetActiveAttrib(program glbase.Program, index glbase.Attrib, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl3_3core_glGetActiveAttrib(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEnableVertexAttribArray.xml +func (gl *GL) EnableVertexAttribArray(index glbase.Attrib) { + C.gl3_3core_glEnableVertexAttribArray(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDisableVertexAttribArray.xml +func (gl *GL) DisableVertexAttribArray(index glbase.Attrib) { + C.gl3_3core_glDisableVertexAttribArray(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDetachShader.xml +func (gl *GL) DetachShader(program glbase.Program, shader glbase.Shader) { + C.gl3_3core_glDetachShader(gl.funcs, C.GLuint(program), C.GLuint(shader)) +} + +// DeleteShader frees the memory and invalidates the name associated with +// the shader object specified by shader. This command effectively undoes the +// effects of a call to CreateShader. +// +// If a shader object to be deleted is attached to a program object, it will +// be flagged for deletion, but it will not be deleted until it is no longer +// attached to any program object, for any rendering context (it must +// be detached from wherever it was attached before it will be deleted). A +// value of 0 for shader will be silently ignored. +// +// To determine whether an object has been flagged for deletion, call +// GetShader with arguments shader and GL.DELETE_STATUS. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. +// +// DeleteShader is available in GL version 2.0 or greater. +func (gl *GL) DeleteShader(shader glbase.Shader) { + C.gl3_3core_glDeleteShader(gl.funcs, C.GLuint(shader)) +} + +// DeleteProgram frees the memory and invalidates the name associated with +// the program object specified by program. This command effectively undoes +// the effects of a call to CreateProgram. +// +// If a program object is in use as part of current rendering state, it will +// be flagged for deletion, but it will not be deleted until it is no longer +// part of current state for any rendering context. If a program object to be +// deleted has shader objects attached to it, those shader objects will be +// automatically detached but not deleted unless they have already been +// flagged for deletion by a previous call to DeleteShader. A value of 0 +// for program will be silently ignored. +// +// To determine whether a program object has been flagged for deletion, call +// GetProgram with arguments program and GL.DELETE_STATUS. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. +// +// DeleteProgram is available in GL version 2.0 or greater. +func (gl *GL) DeleteProgram(program glbase.Program) { + C.gl3_3core_glDeleteProgram(gl.funcs, C.GLuint(program)) +} + +// CreateShader creates an empty shader object and returns a non-zero value +// by which it can be referenced. A shader object is used to maintain the +// source code strings that define a shader. shaderType indicates the type of +// shader to be created. +// +// Two types of shaders are supported. A shader of type GL.VERTEX_SHADER is a +// shader that is intended to run on the programmable vertex processor and +// replace the fixed functionality vertex processing in OpenGL. A shader of +// type GL.FRAGMENT_SHADER is a shader that is intended to run on the +// programmable fragment processor and replace the fixed functionality +// fragment processing in OpenGL. +// +// When created, a shader object's GL.SHADER_TYPE parameter is set to either +// GL.VERTEX_SHADER or GL.FRAGMENT_SHADER, depending on the value of +// shaderType. +// +// Like display lists and texture objects, the name space for shader objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// This function returns 0 if an error occurs creating the shader object. +// +// Error GL.INVALID_ENUM is generated if shaderType is not an accepted value. +// GL.INVALID_OPERATION is generated if CreateShader is executed between the +// execution of Begin and the corresponding execution of End. +// +// CreateShader is available in GL version 2.0 or greater. +func (gl *GL) CreateShader(gltype glbase.Enum) glbase.Shader { + glresult := C.gl3_3core_glCreateShader(gl.funcs, C.GLenum(gltype)) + return glbase.Shader(glresult) +} + +// CreateProgram creates an empty program object and returns a non-zero +// value by which it can be referenced. A program object is an object to +// which shader objects can be attached. This provides a mechanism to specify +// the shader objects that will be linked to create a program. It also +// provides a means for checking the compatibility of the shaders that will +// be used to create a program (for instance, checking the compatibility +// between a vertex shader and a fragment shader). When no longer needed as +// part of a program object, shader objects can be detached. +// +// One or more executables are created in a program object by successfully +// attaching shader objects to it with AttachShader, successfully compiling +// the shader objects with CompileShader, and successfully linking the +// program object with LinkProgram. These executables are made part of +// current state when UseProgram is called. Program objects can be deleted +// by calling DeleteProgram. The memory associated with the program object +// will be deleted when it is no longer part of current rendering state for +// any context. +// +// Like display lists and texture objects, the name space for program objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// Applications are responsible for providing the synchronization across API +// calls when objects are accessed from different execution threads. +// +// This function returns 0 if an error occurs creating the program object. +// +// Error GL.INVALID_OPERATION is generated if CreateProgram is executed +// between the execution of Begin and the corresponding execution of End. +// +// CreateProgram is available in GL version 2.0 or greater. +func (gl *GL) CreateProgram() glbase.Program { + glresult := C.gl3_3core_glCreateProgram(gl.funcs) + return glbase.Program(glresult) +} + +// CompileShader compiles the source code strings that have been stored in +// the shader object specified by shader. +// +// The compilation status will be stored as part of the shader object's +// state. This value will be set to GL.TRUE if the shader was compiled without +// errors and is ready for use, and GL.FALSE otherwise. It can be queried by +// calling GetShaderiv with arguments shader and GL.COMPILE_STATUS. +// +// Compilation of a shader can fail for a number of reasons as specified by +// the OpenGL Shading Language Specification. Whether or not the compilation +// was successful, information about the compilation can be obtained from the +// shader object's information log by calling GetShaderInfoLog. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_OPERATION is generated if CompileShader is executed +// between the execution of Begin and the corresponding execution of End. +// +// CompileShader is available in GL version 2.0 or greater. +func (gl *GL) CompileShader(shader glbase.Shader) { + C.gl3_3core_glCompileShader(gl.funcs, C.GLuint(shader)) +} + +// BindAttribLocation associates a user-defined attribute variable in the program +// object specified by program with a generic vertex attribute index. The name +// parameter specifies the name of the vertex shader attribute variable to +// which index is to be bound. When program is made part of the current state, +// values provided via the generic vertex attribute index will modify the +// value of the user-defined attribute variable specified by name. +// +// If name refers to a matrix attribute variable, index refers to the first +// column of the matrix. Other matrix columns are then automatically bound to +// locations index+1 for a matrix of type mat2; index+1 and index+2 for a +// matrix of type mat3; and index+1, index+2, and index+3 for a matrix of +// type mat4. +// +// This command makes it possible for vertex shaders to use descriptive names +// for attribute variables rather than generic variables that are numbered +// from 0 to GL.MAX_VERTEX_ATTRIBS-1. The values sent to each generic +// attribute index are part of current state, just like standard vertex +// attributes such as color, normal, and vertex position. If a different +// program object is made current by calling UseProgram, the generic vertex +// attributes are tracked in such a way that the same values will be observed +// by attributes in the new program object that are also bound to index. +// +// Attribute variable name-to-generic attribute index bindings for a program +// object can be explicitly assigned at any time by calling +// BindAttribLocation. Attribute bindings do not go into effect until +// LinkProgram is called. After a program object has been linked +// successfully, the index values for generic attributes remain fixed (and +// their values can be queried) until the next link command occurs. +// +// Applications are not allowed to bind any of the standard OpenGL vertex +// attributes using this command, as they are bound automatically when +// needed. Any attribute binding that occurs after the program object has +// been linked will not take effect until the next time the program object is +// linked. +// +// If name was bound previously, that information is lost. Thus you cannot +// bind one user-defined attribute variable to multiple indices, but you can +// bind multiple user-defined attribute variables to the same index. +// +// Applications are allowed to bind more than one user-defined attribute +// variable to the same generic vertex attribute index. This is called +// aliasing, and it is allowed only if just one of the aliased attributes is +// active in the executable program, or if no path through the shader +// consumes more than one attribute of a set of attributes aliased to the +// same location. The compiler and linker are allowed to assume that no +// aliasing is done and are free to employ optimizations that work only in +// the absence of aliasing. OpenGL implementations are not required to do +// error checking to detect aliasing. Because there is no way to bind +// standard attributes, it is not possible to alias generic attributes with +// conventional ones (except for generic attribute 0). +// +// BindAttribLocation can be called before any vertex shader objects are +// bound to the specified program object. It is also permissible to bind a +// generic attribute index to an attribute variable name that is never used +// in a vertex shader. +// +// Active attributes that are not explicitly bound will be bound by the +// linker when LinkProgram is called. The locations assigned can be queried +// by calling GetAttribLocation. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. +// GL.INVALID_OPERATION is generated if name starts with the reserved prefix "gl_". +// GL.INVALID_VALUE is generated if program is not a value generated by OpenGL. +// GL.INVALID_OPERATION is generated if program is not a program object. +// GL.INVALID_OPERATION is generated if BindAttribLocation is executed +// between the execution of Begin and the corresponding execution of End. +// +// BindAttribLocation is available in GL version 2.0 or greater. +func (gl *GL) BindAttribLocation(program glbase.Program, index glbase.Attrib, name string) { + name_cstr := C.CString(name) + C.gl3_3core_glBindAttribLocation(gl.funcs, C.GLuint(program), C.GLuint(index), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) +} + +// AttachShader attaches a shader object to a program object. +// +// In order to create an executable, there must be a way to specify the list +// of things that will be linked together. Program objects provide this +// mechanism. Shaders that are to be linked together in a program object must +// first be attached to that program object. This indicates that shader will +// be included in link operations that will be performed on program. +// +// All operations that can be performed on a shader object are valid whether +// or not the shader object is attached to a program object. It is +// permissible to attach a shader object to a program object before source +// code has been loaded into the shader object or before the shader object +// has been compiled. It is permissible to attach multiple shader objects of +// the same type because each may contain a portion of the complete shader. +// It is also permissible to attach a shader object to more than one program +// object. If a shader object is deleted while it is attached to a program +// object, it will be flagged for deletion, and deletion will not occur until +// DetachShader is called to detach it from all program objects to which it +// is attached. +// +// Error GL.INVALID_VALUE is generated if either program or shader is not a +// value generated by OpenGL. GL.INVALID_OPERATION is generated if program +// is not a program object. GL.INVALID_OPERATION is generated if shader is +// not a shader object. GL.INVALID_OPERATION is generated if shader is +// already attached to program. GL.INVALID_OPERATION is generated if +// AttachShader is executed between the execution of Begin and the +// corresponding execution of End. +// +// AttachShader is available in GL version 2.0 or greater. +func (gl *GL) AttachShader(program glbase.Program, shader glbase.Shader) { + C.gl3_3core_glAttachShader(gl.funcs, C.GLuint(program), C.GLuint(shader)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilMaskSeparate.xml +func (gl *GL) StencilMaskSeparate(face glbase.Enum, mask uint32) { + C.gl3_3core_glStencilMaskSeparate(gl.funcs, C.GLenum(face), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilFuncSeparate.xml +func (gl *GL) StencilFuncSeparate(face, glfunc glbase.Enum, ref int32, mask uint32) { + C.gl3_3core_glStencilFuncSeparate(gl.funcs, C.GLenum(face), C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glStencilOpSeparate.xml +func (gl *GL) StencilOpSeparate(face, sfail, dpfail, dppass glbase.Enum) { + C.gl3_3core_glStencilOpSeparate(gl.funcs, C.GLenum(face), C.GLenum(sfail), C.GLenum(dpfail), C.GLenum(dppass)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawBuffers.xml +func (gl *GL) DrawBuffers(n int, bufs []glbase.Enum) { + C.gl3_3core_glDrawBuffers(gl.funcs, C.GLsizei(n), (*C.GLenum)(unsafe.Pointer(&bufs[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlendEquationSeparate.xml +func (gl *GL) BlendEquationSeparate(modeRGB, modeAlpha glbase.Enum) { + C.gl3_3core_glBlendEquationSeparate(gl.funcs, C.GLenum(modeRGB), C.GLenum(modeAlpha)) +} + +// UniformMatrix4x3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4x3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4x3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*3) != 0 { + panic("invalid value length for UniformMatrix4x3fv") + } + count := len(value) / (4 * 3) + C.gl3_3core_glUniformMatrix4x3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3x4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3x4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3x4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*4) != 0 { + panic("invalid value length for UniformMatrix3x4fv") + } + count := len(value) / (3 * 4) + C.gl3_3core_glUniformMatrix3x4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix4x2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4x2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4x2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*2) != 0 { + panic("invalid value length for UniformMatrix4x2fv") + } + count := len(value) / (4 * 2) + C.gl3_3core_glUniformMatrix4x2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2x4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2x4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2x4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*4) != 0 { + panic("invalid value length for UniformMatrix2x4fv") + } + count := len(value) / (2 * 4) + C.gl3_3core_glUniformMatrix2x4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3x2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3x2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3x2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*2) != 0 { + panic("invalid value length for UniformMatrix3x2fv") + } + count := len(value) / (3 * 2) + C.gl3_3core_glUniformMatrix3x2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2x3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2x3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2x3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*3) != 0 { + panic("invalid value length for UniformMatrix2x3fv") + } + count := len(value) / (2 * 3) + C.gl3_3core_glUniformMatrix2x3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsVertexArray.xml +func (gl *GL) IsVertexArray(array uint32) bool { + glresult := C.gl3_3core_glIsVertexArray(gl.funcs, C.GLuint(array)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGenVertexArrays.xml +func (gl *GL) GenVertexArrays(n int, arrays []uint32) { + C.gl3_3core_glGenVertexArrays(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&arrays[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDeleteVertexArrays.xml +func (gl *GL) DeleteVertexArrays(n int, arrays []uint32) { + C.gl3_3core_glDeleteVertexArrays(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&arrays[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindVertexArray.xml +func (gl *GL) BindVertexArray(array uint32) { + C.gl3_3core_glBindVertexArray(gl.funcs, C.GLuint(array)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFlushMappedBufferRange.xml +func (gl *GL) FlushMappedBufferRange(target glbase.Enum, offset, length int) { + C.gl3_3core_glFlushMappedBufferRange(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(length)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFramebufferTextureLayer.xml +func (gl *GL) FramebufferTextureLayer(target, attachment glbase.Enum, texture glbase.Texture, level int, layer int32) { + C.gl3_3core_glFramebufferTextureLayer(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLuint(texture), C.GLint(level), C.GLint(layer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRenderbufferStorageMultisample.xml +func (gl *GL) RenderbufferStorageMultisample(target glbase.Enum, samples int32, internalFormat glbase.Enum, width, height int) { + C.gl3_3core_glRenderbufferStorageMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBlitFramebuffer.xml +func (gl *GL) BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1 int32, mask glbase.Bitfield, filter glbase.Enum) { + C.gl3_3core_glBlitFramebuffer(gl.funcs, C.GLint(srcX0), C.GLint(srcY0), C.GLint(srcX1), C.GLint(srcY1), C.GLint(dstX0), C.GLint(dstY0), C.GLint(dstX1), C.GLint(dstY1), C.GLbitfield(mask), C.GLenum(filter)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGenerateMipmap.xml +func (gl *GL) GenerateMipmap(target glbase.Enum) { + C.gl3_3core_glGenerateMipmap(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetFramebufferAttachmentParameteriv.xml +func (gl *GL) GetFramebufferAttachmentParameteriv(target, attachment, pname glbase.Enum, params []int32) { + C.gl3_3core_glGetFramebufferAttachmentParameteriv(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFramebufferRenderbuffer.xml +func (gl *GL) FramebufferRenderbuffer(target, attachment, renderbuffertarget glbase.Enum, renderbuffer glbase.Renderbuffer) { + C.gl3_3core_glFramebufferRenderbuffer(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(renderbuffertarget), C.GLuint(renderbuffer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFramebufferTexture3D.xml +func (gl *GL) FramebufferTexture3D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int, zoffset int32) { + C.gl3_3core_glFramebufferTexture3D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level), C.GLint(zoffset)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFramebufferTexture2D.xml +func (gl *GL) FramebufferTexture2D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int) { + C.gl3_3core_glFramebufferTexture2D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFramebufferTexture1D.xml +func (gl *GL) FramebufferTexture1D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int) { + C.gl3_3core_glFramebufferTexture1D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCheckFramebufferStatus.xml +func (gl *GL) CheckFramebufferStatus(target glbase.Enum) glbase.Enum { + glresult := C.gl3_3core_glCheckFramebufferStatus(gl.funcs, C.GLenum(target)) + return glbase.Enum(glresult) +} + +// GenFramebuffers returns n framebuffer object names in ids. There is no +// guarantee that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenFramebuffers. +// +// Framebuffer object names returned by a call to GenFramebuffers are not +// returned by subsequent calls, unless they are first deleted with +// DeleteFramebuffers. +// +// The names returned in ids are marked as used, for the purposes of +// GenFramebuffers only, but they acquire state and type only when they are +// first bound. +// +// Error GL.INVALID_VALUE is generated if n is negative. +func (gl *GL) GenFramebuffers(n int) []glbase.Framebuffer { + if n == 0 { + return nil + } + framebuffers := make([]glbase.Framebuffer, n) + C.gl3_3core_glGenFramebuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&framebuffers[0]))) + return framebuffers +} + +// DeleteFramebuffers deletes the framebuffer objects whose names are +// stored in the framebuffers slice. The name zero is reserved by the GL and +// is silently ignored, should it occur in framebuffers, as are other unused +// names. Once a framebuffer object is deleted, its name is again unused and +// it has no attachments. If a framebuffer that is currently bound to one or +// more of the targets GL.DRAW_FRAMEBUFFER or GL.READ_FRAMEBUFFER is deleted, +// it is as though BindFramebuffer had been executed with the corresponding +// target and framebuffer zero. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteFramebuffers is available in GL version 3.0 or greater. +func (gl *GL) DeleteFramebuffers(framebuffers []glbase.Framebuffer) { + n := len(framebuffers) + if n == 0 { + return + } + C.gl3_3core_glDeleteFramebuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&framebuffers[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindFramebuffer.xml +func (gl *GL) BindFramebuffer(target glbase.Enum, framebuffer glbase.Framebuffer) { + C.gl3_3core_glBindFramebuffer(gl.funcs, C.GLenum(target), C.GLuint(framebuffer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsFramebuffer.xml +func (gl *GL) IsFramebuffer(framebuffer glbase.Framebuffer) bool { + glresult := C.gl3_3core_glIsFramebuffer(gl.funcs, C.GLuint(framebuffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetRenderbufferParameteriv.xml +func (gl *GL) GetRenderbufferParameteriv(target, pname glbase.Enum, params []int32) { + C.gl3_3core_glGetRenderbufferParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glRenderbufferStorage.xml +func (gl *GL) RenderbufferStorage(target, internalFormat glbase.Enum, width, height int) { + C.gl3_3core_glRenderbufferStorage(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) +} + +// GenRenderbuffers returns n renderbuffer object names in renderbuffers. +// There is no guarantee that the names form a contiguous set of integers; +// however, it is guaranteed that none of the returned names was in use +// immediately before the call to GenRenderbuffers. +// +// Renderbuffer object names returned by a call to GenRenderbuffers are not +// returned by subsequent calls, unless they are first deleted with +// DeleteRenderbuffers. +// +// The names returned in renderbuffers are marked as used, for the purposes +// of GenRenderbuffers only, but they acquire state and type only when they +// are first bound. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenRenderbuffers is available in GL version 3.0 or greater. +func (gl *GL) GenRenderbuffers(n int) []glbase.Renderbuffer { + if n == 0 { + return nil + } + renderbuffers := make([]glbase.Renderbuffer, n) + C.gl3_3core_glGenRenderbuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&renderbuffers[0]))) + return renderbuffers +} + +// DeleteRenderbuffers deletes the renderbuffer objects whose names are stored +// in the renderbuffers slice. The name zero is reserved by the GL and +// is silently ignored, should it occur in renderbuffers, as are other unused +// names. Once a renderbuffer object is deleted, its name is again unused and +// it has no contents. If a renderbuffer that is currently bound to the +// target GL.RENDERBUFFER is deleted, it is as though BindRenderbuffer had +// been executed with a target of GL.RENDERBUFFER and a name of zero. +// +// If a renderbuffer object is attached to one or more attachment points in +// the currently bound framebuffer, then it as if FramebufferRenderbuffer +// had been called, with a renderbuffer of zero for each attachment point to +// which this image was attached in the currently bound framebuffer. In other +// words, this renderbuffer object is first detached from all attachment +// ponits in the currently bound framebuffer. Note that the renderbuffer +// image is specifically not detached from any non-bound framebuffers. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteRenderbuffers is available in GL version 3.0 or greater. +func (gl *GL) DeleteRenderbuffers(renderbuffers []glbase.Renderbuffer) { + n := len(renderbuffers) + if n == 0 { + return + } + C.gl3_3core_glDeleteRenderbuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&renderbuffers[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindRenderbuffer.xml +func (gl *GL) BindRenderbuffer(target glbase.Enum, renderbuffer glbase.Renderbuffer) { + C.gl3_3core_glBindRenderbuffer(gl.funcs, C.GLenum(target), C.GLuint(renderbuffer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsRenderbuffer.xml +func (gl *GL) IsRenderbuffer(renderbuffer glbase.Renderbuffer) bool { + glresult := C.gl3_3core_glIsRenderbuffer(gl.funcs, C.GLuint(renderbuffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearBufferfi.xml +func (gl *GL) ClearBufferfi(buffer glbase.Enum, drawbuffer int32, depth float32, stencil int32) { + C.gl3_3core_glClearBufferfi(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), C.GLfloat(depth), C.GLint(stencil)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearBufferfv.xml +func (gl *GL) ClearBufferfv(buffer glbase.Enum, drawbuffer int32, value []float32) { + C.gl3_3core_glClearBufferfv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearBufferuiv.xml +func (gl *GL) ClearBufferuiv(buffer glbase.Enum, drawbuffer int32, value []uint32) { + C.gl3_3core_glClearBufferuiv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClearBufferiv.xml +func (gl *GL) ClearBufferiv(buffer glbase.Enum, drawbuffer int32, value []int32) { + C.gl3_3core_glClearBufferiv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexParameterIuiv.xml +func (gl *GL) GetTexParameterIuiv(target, pname glbase.Enum, params []uint32) { + C.gl3_3core_glGetTexParameterIuiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTexParameterIiv.xml +func (gl *GL) GetTexParameterIiv(target, pname glbase.Enum, params []int32) { + C.gl3_3core_glGetTexParameterIiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameterIuiv.xml +func (gl *GL) TexParameterIuiv(target, pname glbase.Enum, params []uint32) { + C.gl3_3core_glTexParameterIuiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexParameterIiv.xml +func (gl *GL) TexParameterIiv(target, pname glbase.Enum, params []int32) { + C.gl3_3core_glTexParameterIiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// Uniform4uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4uiv") + } + count := len(value) / 4 + C.gl3_3core_glUniform4uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform3uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3uiv") + } + count := len(value) / 3 + C.gl3_3core_glUniform3uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform2uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2uiv") + } + count := len(value) / 2 + C.gl3_3core_glUniform2uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform1uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl3_3core_glUniform1uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform4ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4ui(location glbase.Uniform, v0, v1, v2, v3 uint32) { + C.gl3_3core_glUniform4ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2), C.GLuint(v3)) +} + +// Uniform3ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3ui(location glbase.Uniform, v0, v1, v2 uint32) { + C.gl3_3core_glUniform3ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2)) +} + +// Uniform2ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2ui(location glbase.Uniform, v0, v1 uint32) { + C.gl3_3core_glUniform2ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1)) +} + +// Uniform1ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1ui(location glbase.Uniform, v0 uint32) { + C.gl3_3core_glUniform1ui(gl.funcs, C.GLint(location), C.GLuint(v0)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetFragDataLocation.xml +func (gl *GL) GetFragDataLocation(program glbase.Program, name []byte) int32 { + glresult := C.gl3_3core_glGetFragDataLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindFragDataLocation.xml +func (gl *GL) BindFragDataLocation(program glbase.Program, color uint32, name []byte) { + C.gl3_3core_glBindFragDataLocation(gl.funcs, C.GLuint(program), C.GLuint(color), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetUniformuiv.xml +func (gl *GL) GetUniformuiv(program glbase.Program, location glbase.Uniform, params []uint32) { + C.gl3_3core_glGetUniformuiv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetVertexAttribIuiv.xml +func (gl *GL) GetVertexAttribIuiv(index glbase.Attrib, pname glbase.Enum, params []uint32) { + C.gl3_3core_glGetVertexAttribIuiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetVertexAttribIiv.xml +func (gl *GL) GetVertexAttribIiv(index glbase.Attrib, pname glbase.Enum, params []int32) { + C.gl3_3core_glGetVertexAttribIiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribIPointer.xml +func (gl *GL) VertexAttribIPointer(index glbase.Attrib, size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl3_3core_glVertexAttribIPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEndConditionalRender.xml +func (gl *GL) EndConditionalRender() { + C.gl3_3core_glEndConditionalRender(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBeginConditionalRender.xml +func (gl *GL) BeginConditionalRender(id uint32, mode glbase.Enum) { + C.gl3_3core_glBeginConditionalRender(gl.funcs, C.GLuint(id), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClampColor.xml +func (gl *GL) ClampColor(target, clamp glbase.Enum) { + C.gl3_3core_glClampColor(gl.funcs, C.GLenum(target), C.GLenum(clamp)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetTransformFeedbackVarying.xml +func (gl *GL) GetTransformFeedbackVarying(program glbase.Program, index uint32, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl3_3core_glGetTransformFeedbackVarying(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLsizei)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindBufferBase.xml +func (gl *GL) BindBufferBase(target glbase.Enum, index uint32, buffer glbase.Buffer) { + C.gl3_3core_glBindBufferBase(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindBufferRange.xml +func (gl *GL) BindBufferRange(target glbase.Enum, index uint32, buffer glbase.Buffer, offset, size int) { + C.gl3_3core_glBindBufferRange(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(buffer), C.GLintptr(offset), C.GLsizeiptr(size)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEndTransformFeedback.xml +func (gl *GL) EndTransformFeedback() { + C.gl3_3core_glEndTransformFeedback(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBeginTransformFeedback.xml +func (gl *GL) BeginTransformFeedback(primitiveMode glbase.Enum) { + C.gl3_3core_glBeginTransformFeedback(gl.funcs, C.GLenum(primitiveMode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsEnabledi.xml +func (gl *GL) IsEnabledi(target glbase.Enum, index uint32) bool { + glresult := C.gl3_3core_glIsEnabledi(gl.funcs, C.GLenum(target), C.GLuint(index)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDisablei.xml +func (gl *GL) Disablei(target glbase.Enum, index uint32) { + C.gl3_3core_glDisablei(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glEnablei.xml +func (gl *GL) Enablei(target glbase.Enum, index uint32) { + C.gl3_3core_glEnablei(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetIntegeri_v.xml +func (gl *GL) GetIntegeri_v(target glbase.Enum, index uint32, data []int32) { + C.gl3_3core_glGetIntegeri_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLint)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetBooleani_v.xml +func (gl *GL) GetBooleani_v(target glbase.Enum, index uint32, data []bool) { + C.gl3_3core_glGetBooleani_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLboolean)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorMaski.xml +func (gl *GL) ColorMaski(index uint32, r, g, b, a bool) { + C.gl3_3core_glColorMaski(gl.funcs, C.GLuint(index), *(*C.GLboolean)(unsafe.Pointer(&r)), *(*C.GLboolean)(unsafe.Pointer(&g)), *(*C.GLboolean)(unsafe.Pointer(&b)), *(*C.GLboolean)(unsafe.Pointer(&a))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glCopyBufferSubData.xml +func (gl *GL) CopyBufferSubData(readTarget, writeTarget glbase.Enum, readOffset, writeOffset, size int) { + C.gl3_3core_glCopyBufferSubData(gl.funcs, C.GLenum(readTarget), C.GLenum(writeTarget), C.GLintptr(readOffset), C.GLintptr(writeOffset), C.GLsizeiptr(size)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glUniformBlockBinding.xml +func (gl *GL) UniformBlockBinding(program glbase.Program, v0, v1 uint32) { + C.gl3_3core_glUniformBlockBinding(gl.funcs, C.GLuint(program), C.GLuint(v0), C.GLuint(v1)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetActiveUniformBlockName.xml +func (gl *GL) GetActiveUniformBlockName(program glbase.Program, uniformBlockIndex uint32, bufSize int32, length []int32, uniformBlockName []byte) { + C.gl3_3core_glGetActiveUniformBlockName(gl.funcs, C.GLuint(program), C.GLuint(uniformBlockIndex), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&uniformBlockName[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetActiveUniformBlockiv.xml +func (gl *GL) GetActiveUniformBlockiv(program glbase.Program, uniformBlockIndex uint32, pname glbase.Enum, params []int32) { + C.gl3_3core_glGetActiveUniformBlockiv(gl.funcs, C.GLuint(program), C.GLuint(uniformBlockIndex), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetUniformBlockIndex.xml +func (gl *GL) GetUniformBlockIndex(program glbase.Program, uniformBlockName []byte) uint32 { + glresult := C.gl3_3core_glGetUniformBlockIndex(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&uniformBlockName[0]))) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetActiveUniformName.xml +func (gl *GL) GetActiveUniformName(program glbase.Program, uniformIndex uint32, bufSize int32, length []int32, uniformName []byte) { + C.gl3_3core_glGetActiveUniformName(gl.funcs, C.GLuint(program), C.GLuint(uniformIndex), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&uniformName[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetActiveUniformsiv.xml +func (gl *GL) GetActiveUniformsiv(program glbase.Program, uniformCount int32, uniformIndices []uint32, pname glbase.Enum, params []int32) { + C.gl3_3core_glGetActiveUniformsiv(gl.funcs, C.GLuint(program), C.GLsizei(uniformCount), (*C.GLuint)(unsafe.Pointer(&uniformIndices[0])), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glPrimitiveRestartIndex.xml +func (gl *GL) PrimitiveRestartIndex(index uint32) { + C.gl3_3core_glPrimitiveRestartIndex(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexBuffer.xml +func (gl *GL) TexBuffer(target, internalFormat glbase.Enum, buffer glbase.Buffer) { + C.gl3_3core_glTexBuffer(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawElementsInstanced.xml +func (gl *GL) DrawElementsInstanced(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, instancecount int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl3_3core_glDrawElementsInstanced(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLsizei(instancecount)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawArraysInstanced.xml +func (gl *GL) DrawArraysInstanced(mode glbase.Enum, first, count int, instancecount int32) { + C.gl3_3core_glDrawArraysInstanced(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count), C.GLsizei(instancecount)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSampleMaski.xml +func (gl *GL) SampleMaski(index uint32, mask glbase.Bitfield) { + C.gl3_3core_glSampleMaski(gl.funcs, C.GLuint(index), C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetMultisamplefv.xml +func (gl *GL) GetMultisamplefv(pname glbase.Enum, index uint32, val []float32) { + C.gl3_3core_glGetMultisamplefv(gl.funcs, C.GLenum(pname), C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&val[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexImage3DMultisample.xml +func (gl *GL) TexImage3DMultisample(target glbase.Enum, samples, internalFormat int32, width, height int, depth int32, fixedsamplelocations bool) { + C.gl3_3core_glTexImage3DMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), *(*C.GLboolean)(unsafe.Pointer(&fixedsamplelocations))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexImage2DMultisample.xml +func (gl *GL) TexImage2DMultisample(target glbase.Enum, samples, internalFormat int32, width, height int, fixedsamplelocations bool) { + C.gl3_3core_glTexImage2DMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), *(*C.GLboolean)(unsafe.Pointer(&fixedsamplelocations))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetSynciv.xml +func (gl *GL) GetSynciv(sync glbase.Sync, pname glbase.Enum, bufSize int32, length, values []int32) { + C.gl3_3core_glGetSynciv(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLenum(pname), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetInteger64v.xml +func (gl *GL) GetInteger64v(pname glbase.Enum, params []int64) { + C.gl3_3core_glGetInteger64v(gl.funcs, C.GLenum(pname), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glWaitSync.xml +func (gl *GL) WaitSync(sync glbase.Sync, flags glbase.Bitfield, timeout uint64) { + C.gl3_3core_glWaitSync(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLbitfield(flags), C.GLuint64(timeout)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glClientWaitSync.xml +func (gl *GL) ClientWaitSync(sync glbase.Sync, flags glbase.Bitfield, timeout uint64) glbase.Enum { + glresult := C.gl3_3core_glClientWaitSync(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLbitfield(flags), C.GLuint64(timeout)) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDeleteSync.xml +func (gl *GL) DeleteSync(sync glbase.Sync) { + C.gl3_3core_glDeleteSync(gl.funcs, C.GLsync(unsafe.Pointer(sync))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsSync.xml +func (gl *GL) IsSync(sync glbase.Sync) bool { + glresult := C.gl3_3core_glIsSync(gl.funcs, C.GLsync(unsafe.Pointer(sync))) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFenceSync.xml +func (gl *GL) FenceSync(condition glbase.Enum, flags glbase.Bitfield) glbase.Sync { + glresult := C.gl3_3core_glFenceSync(gl.funcs, C.GLenum(condition), C.GLbitfield(flags)) + return glbase.Sync(unsafe.Pointer(glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glProvokingVertex.xml +func (gl *GL) ProvokingVertex(mode glbase.Enum) { + C.gl3_3core_glProvokingVertex(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawElementsInstancedBaseVertex.xml +func (gl *GL) DrawElementsInstancedBaseVertex(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, instancecount, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl3_3core_glDrawElementsInstancedBaseVertex(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLsizei(instancecount), C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawRangeElementsBaseVertex.xml +func (gl *GL) DrawRangeElementsBaseVertex(mode glbase.Enum, start, end uint32, count int, gltype glbase.Enum, indices interface{}, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl3_3core_glDrawRangeElementsBaseVertex(gl.funcs, C.GLenum(mode), C.GLuint(start), C.GLuint(end), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDrawElementsBaseVertex.xml +func (gl *GL) DrawElementsBaseVertex(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl3_3core_glDrawElementsBaseVertex(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glFramebufferTexture.xml +func (gl *GL) FramebufferTexture(target, attachment glbase.Enum, texture glbase.Texture, level int) { + C.gl3_3core_glFramebufferTexture(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetBufferParameteri64v.xml +func (gl *GL) GetBufferParameteri64v(target, pname glbase.Enum, params []int64) { + C.gl3_3core_glGetBufferParameteri64v(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetInteger64i_v.xml +func (gl *GL) GetInteger64i_v(target glbase.Enum, index uint32, data []int64) { + C.gl3_3core_glGetInteger64i_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLint64)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribP4uiv.xml +func (gl *GL) VertexAttribP4uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl3_3core_glVertexAttribP4uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribP4ui.xml +func (gl *GL) VertexAttribP4ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl3_3core_glVertexAttribP4ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribP3uiv.xml +func (gl *GL) VertexAttribP3uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl3_3core_glVertexAttribP3uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribP3ui.xml +func (gl *GL) VertexAttribP3ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl3_3core_glVertexAttribP3ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribP2uiv.xml +func (gl *GL) VertexAttribP2uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl3_3core_glVertexAttribP2uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribP2ui.xml +func (gl *GL) VertexAttribP2ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl3_3core_glVertexAttribP2ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribP1uiv.xml +func (gl *GL) VertexAttribP1uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl3_3core_glVertexAttribP1uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribP1ui.xml +func (gl *GL) VertexAttribP1ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl3_3core_glVertexAttribP1ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColorP3uiv.xml +func (gl *GL) SecondaryColorP3uiv(gltype glbase.Enum, color []uint32) { + C.gl3_3core_glSecondaryColorP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&color[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSecondaryColorP3ui.xml +func (gl *GL) SecondaryColorP3ui(gltype glbase.Enum, color uint32) { + C.gl3_3core_glSecondaryColorP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(color)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorP4uiv.xml +func (gl *GL) ColorP4uiv(gltype glbase.Enum, color []uint32) { + C.gl3_3core_glColorP4uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&color[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorP4ui.xml +func (gl *GL) ColorP4ui(gltype glbase.Enum, color uint32) { + C.gl3_3core_glColorP4ui(gl.funcs, C.GLenum(gltype), C.GLuint(color)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorP3uiv.xml +func (gl *GL) ColorP3uiv(gltype glbase.Enum, color []uint32) { + C.gl3_3core_glColorP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&color[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glColorP3ui.xml +func (gl *GL) ColorP3ui(gltype glbase.Enum, color uint32) { + C.gl3_3core_glColorP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(color)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormalP3uiv.xml +func (gl *GL) NormalP3uiv(gltype glbase.Enum, coords []uint32) { + C.gl3_3core_glNormalP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glNormalP3ui.xml +func (gl *GL) NormalP3ui(gltype glbase.Enum, coords uint32) { + C.gl3_3core_glNormalP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoordP4uiv.xml +func (gl *GL) MultiTexCoordP4uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl3_3core_glMultiTexCoordP4uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoordP4ui.xml +func (gl *GL) MultiTexCoordP4ui(texture, gltype glbase.Enum, coords uint32) { + C.gl3_3core_glMultiTexCoordP4ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoordP3uiv.xml +func (gl *GL) MultiTexCoordP3uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl3_3core_glMultiTexCoordP3uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoordP3ui.xml +func (gl *GL) MultiTexCoordP3ui(texture, gltype glbase.Enum, coords uint32) { + C.gl3_3core_glMultiTexCoordP3ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoordP2uiv.xml +func (gl *GL) MultiTexCoordP2uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl3_3core_glMultiTexCoordP2uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoordP2ui.xml +func (gl *GL) MultiTexCoordP2ui(texture, gltype glbase.Enum, coords uint32) { + C.gl3_3core_glMultiTexCoordP2ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoordP1uiv.xml +func (gl *GL) MultiTexCoordP1uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl3_3core_glMultiTexCoordP1uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glMultiTexCoordP1ui.xml +func (gl *GL) MultiTexCoordP1ui(texture, gltype glbase.Enum, coords uint32) { + C.gl3_3core_glMultiTexCoordP1ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoordP4uiv.xml +func (gl *GL) TexCoordP4uiv(gltype glbase.Enum, coords []uint32) { + C.gl3_3core_glTexCoordP4uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoordP4ui.xml +func (gl *GL) TexCoordP4ui(gltype glbase.Enum, coords uint32) { + C.gl3_3core_glTexCoordP4ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoordP3uiv.xml +func (gl *GL) TexCoordP3uiv(gltype glbase.Enum, coords []uint32) { + C.gl3_3core_glTexCoordP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoordP3ui.xml +func (gl *GL) TexCoordP3ui(gltype glbase.Enum, coords uint32) { + C.gl3_3core_glTexCoordP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoordP2uiv.xml +func (gl *GL) TexCoordP2uiv(gltype glbase.Enum, coords []uint32) { + C.gl3_3core_glTexCoordP2uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoordP2ui.xml +func (gl *GL) TexCoordP2ui(gltype glbase.Enum, coords uint32) { + C.gl3_3core_glTexCoordP2ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoordP1uiv.xml +func (gl *GL) TexCoordP1uiv(gltype glbase.Enum, coords []uint32) { + C.gl3_3core_glTexCoordP1uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glTexCoordP1ui.xml +func (gl *GL) TexCoordP1ui(gltype glbase.Enum, coords uint32) { + C.gl3_3core_glTexCoordP1ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexP4uiv.xml +func (gl *GL) VertexP4uiv(gltype glbase.Enum, value []uint32) { + C.gl3_3core_glVertexP4uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexP4ui.xml +func (gl *GL) VertexP4ui(gltype glbase.Enum, value uint32) { + C.gl3_3core_glVertexP4ui(gl.funcs, C.GLenum(gltype), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexP3uiv.xml +func (gl *GL) VertexP3uiv(gltype glbase.Enum, value []uint32) { + C.gl3_3core_glVertexP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexP3ui.xml +func (gl *GL) VertexP3ui(gltype glbase.Enum, value uint32) { + C.gl3_3core_glVertexP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexP2uiv.xml +func (gl *GL) VertexP2uiv(gltype glbase.Enum, value []uint32) { + C.gl3_3core_glVertexP2uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexP2ui.xml +func (gl *GL) VertexP2ui(gltype glbase.Enum, value uint32) { + C.gl3_3core_glVertexP2ui(gl.funcs, C.GLenum(gltype), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetQueryObjectui64v.xml +func (gl *GL) GetQueryObjectui64v(id uint32, pname glbase.Enum, params []uint64) { + C.gl3_3core_glGetQueryObjectui64v(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLuint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetQueryObjecti64v.xml +func (gl *GL) GetQueryObjecti64v(id uint32, pname glbase.Enum, params []int64) { + C.gl3_3core_glGetQueryObjecti64v(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glQueryCounter.xml +func (gl *GL) QueryCounter(id uint32, target glbase.Enum) { + C.gl3_3core_glQueryCounter(gl.funcs, C.GLuint(id), C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetSamplerParameterIuiv.xml +func (gl *GL) GetSamplerParameterIuiv(sampler uint32, pname glbase.Enum, params []uint32) { + C.gl3_3core_glGetSamplerParameterIuiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetSamplerParameterfv.xml +func (gl *GL) GetSamplerParameterfv(sampler uint32, pname glbase.Enum, params []float32) { + C.gl3_3core_glGetSamplerParameterfv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetSamplerParameterIiv.xml +func (gl *GL) GetSamplerParameterIiv(sampler uint32, pname glbase.Enum, params []int32) { + C.gl3_3core_glGetSamplerParameterIiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetSamplerParameteriv.xml +func (gl *GL) GetSamplerParameteriv(sampler uint32, pname glbase.Enum, params []int32) { + C.gl3_3core_glGetSamplerParameteriv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSamplerParameterIuiv.xml +func (gl *GL) SamplerParameterIuiv(sampler uint32, pname glbase.Enum, param []uint32) { + C.gl3_3core_glSamplerParameterIuiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSamplerParameterIiv.xml +func (gl *GL) SamplerParameterIiv(sampler uint32, pname glbase.Enum, param []int32) { + C.gl3_3core_glSamplerParameterIiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSamplerParameterfv.xml +func (gl *GL) SamplerParameterfv(sampler uint32, pname glbase.Enum, param []float32) { + C.gl3_3core_glSamplerParameterfv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSamplerParameterf.xml +func (gl *GL) SamplerParameterf(sampler uint32, pname glbase.Enum, param float32) { + C.gl3_3core_glSamplerParameterf(gl.funcs, C.GLuint(sampler), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSamplerParameteriv.xml +func (gl *GL) SamplerParameteriv(sampler uint32, pname glbase.Enum, param []int32) { + C.gl3_3core_glSamplerParameteriv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glSamplerParameteri.xml +func (gl *GL) SamplerParameteri(sampler uint32, pname glbase.Enum, param int32) { + C.gl3_3core_glSamplerParameteri(gl.funcs, C.GLuint(sampler), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindSampler.xml +func (gl *GL) BindSampler(unit, sampler uint32) { + C.gl3_3core_glBindSampler(gl.funcs, C.GLuint(unit), C.GLuint(sampler)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glIsSampler.xml +func (gl *GL) IsSampler(sampler uint32) bool { + glresult := C.gl3_3core_glIsSampler(gl.funcs, C.GLuint(sampler)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glDeleteSamplers.xml +func (gl *GL) DeleteSamplers(count int, samplers []uint32) { + C.gl3_3core_glDeleteSamplers(gl.funcs, C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&samplers[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGenSamplers.xml +func (gl *GL) GenSamplers(count int, samplers []uint32) { + C.gl3_3core_glGenSamplers(gl.funcs, C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&samplers[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glGetFragDataIndex.xml +func (gl *GL) GetFragDataIndex(program glbase.Program, name []byte) int32 { + glresult := C.gl3_3core_glGetFragDataIndex(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glBindFragDataLocationIndexed.xml +func (gl *GL) BindFragDataLocationIndexed(program glbase.Program, colorNumber, index uint32, name []byte) { + C.gl3_3core_glBindFragDataLocationIndexed(gl.funcs, C.GLuint(program), C.GLuint(colorNumber), C.GLuint(index), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribDivisor.xml +func (gl *GL) VertexAttribDivisor(index glbase.Attrib, divisor uint32) { + C.gl3_3core_glVertexAttribDivisor(gl.funcs, C.GLuint(index), C.GLuint(divisor)) +} diff --git a/gl/4.0compat/funcs.cpp b/gl/4.0compat/funcs.cpp new file mode 100644 index 00000000..1dfaf3f0 --- /dev/null +++ b/gl/4.0compat/funcs.cpp @@ -0,0 +1,4764 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#include +#include + +#include "funcs.h" + +void *gl4_0compat_funcs() { + QOpenGLFunctions_4_0_Compatibility* funcs = QOpenGLContext::currentContext()->versionFunctions(); + if (!funcs) { + return 0; + } + funcs->initializeOpenGLFunctions(); + return funcs; +} + + +void gl4_0compat_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewport(x, y, width, height); +} + +void gl4_0compat_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRange(nearVal, farVal); +} + +GLboolean gl4_0compat_glIsEnabled(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabled(cap); +} + +void gl4_0compat_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameteriv(target, level, pname, params); +} + +void gl4_0compat_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameterfv(target, level, pname, params); +} + +void gl4_0compat_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameteriv(target, pname, params); +} + +void gl4_0compat_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterfv(target, pname, params); +} + +void gl4_0compat_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexImage(target, level, format, gltype, pixels); +} + +void gl4_0compat_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegerv(pname, params); +} + +void gl4_0compat_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFloatv(pname, params); +} + +GLenum gl4_0compat_glGetError(void *_glfuncs) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetError(); +} + +void gl4_0compat_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetDoublev(pname, params); +} + +void gl4_0compat_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleanv(pname, params); +} + +void gl4_0compat_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadPixels(x, y, width, height, format, gltype, pixels); +} + +void gl4_0compat_glReadBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadBuffer(mode); +} + +void gl4_0compat_glPixelStorei(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStorei(pname, param); +} + +void gl4_0compat_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStoref(pname, param); +} + +void gl4_0compat_glDepthFunc(void *_glfuncs, GLenum glfunc) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthFunc(glfunc); +} + +void gl4_0compat_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOp(fail, zfail, zpass); +} + +void gl4_0compat_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFunc(glfunc, ref, mask); +} + +void gl4_0compat_glLogicOp(void *_glfuncs, GLenum opcode) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLogicOp(opcode); +} + +void gl4_0compat_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFunc(sfactor, dfactor); +} + +void gl4_0compat_glFlush(void *_glfuncs) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlush(); +} + +void gl4_0compat_glFinish(void *_glfuncs) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFinish(); +} + +void gl4_0compat_glEnable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnable(cap); +} + +void gl4_0compat_glDisable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisable(cap); +} + +void gl4_0compat_glDepthMask(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthMask(flag); +} + +void gl4_0compat_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMask(red, green, blue, alpha); +} + +void gl4_0compat_glStencilMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMask(mask); +} + +void gl4_0compat_glClearDepth(void *_glfuncs, GLdouble depth) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearDepth(depth); +} + +void gl4_0compat_glClearStencil(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearStencil(s); +} + +void gl4_0compat_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearColor(red, green, blue, alpha); +} + +void gl4_0compat_glClear(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClear(mask); +} + +void gl4_0compat_glDrawBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffer(mode); +} + +void gl4_0compat_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage2D(target, level, internalFormat, width, height, border, format, gltype, pixels); +} + +void gl4_0compat_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage1D(target, level, internalFormat, width, border, format, gltype, pixels); +} + +void gl4_0compat_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteriv(target, pname, params); +} + +void gl4_0compat_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteri(target, pname, param); +} + +void gl4_0compat_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterfv(target, pname, params); +} + +void gl4_0compat_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterf(target, pname, param); +} + +void gl4_0compat_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissor(x, y, width, height); +} + +void gl4_0compat_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonMode(face, mode); +} + +void gl4_0compat_glPointSize(void *_glfuncs, GLfloat size) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointSize(size); +} + +void gl4_0compat_glLineWidth(void *_glfuncs, GLfloat width) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineWidth(width); +} + +void gl4_0compat_glHint(void *_glfuncs, GLenum target, GLenum mode) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glHint(target, mode); +} + +void gl4_0compat_glFrontFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrontFace(mode); +} + +void gl4_0compat_glCullFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCullFace(mode); +} + +void gl4_0compat_glIndexubv(void *_glfuncs, const GLubyte* c) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexubv(c); +} + +void gl4_0compat_glIndexub(void *_glfuncs, GLubyte c) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexub(c); +} + +GLboolean gl4_0compat_glIsTexture(void *_glfuncs, GLuint texture) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsTexture(texture); +} + +void gl4_0compat_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenTextures(n, textures); +} + +void gl4_0compat_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteTextures(n, textures); +} + +void gl4_0compat_glBindTexture(void *_glfuncs, GLenum target, GLuint texture) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindTexture(target, texture); +} + +void gl4_0compat_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, gltype, pixels); +} + +void gl4_0compat_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage1D(target, level, xoffset, width, format, gltype, pixels); +} + +void gl4_0compat_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); +} + +void gl4_0compat_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage1D(target, level, xoffset, x, y, width); +} + +void gl4_0compat_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage2D(target, level, internalFormat, x, y, width, height, border); +} + +void gl4_0compat_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage1D(target, level, internalFormat, x, y, width, border); +} + +void gl4_0compat_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonOffset(factor, units); +} + +void gl4_0compat_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElements(mode, count, gltype, indices); +} + +void gl4_0compat_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArrays(mode, first, count); +} + +void gl4_0compat_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); +} + +void gl4_0compat_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, gltype, pixels); +} + +void gl4_0compat_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage3D(target, level, internalFormat, width, height, depth, border, format, gltype, pixels); +} + +void gl4_0compat_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawRangeElements(mode, start, end, count, gltype, indices); +} + +void gl4_0compat_glBlendEquation(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquation(mode); +} + +void gl4_0compat_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendColor(red, green, blue, alpha); +} + +void gl4_0compat_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetCompressedTexImage(target, level, img); +} + +void gl4_0compat_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data); +} + +void gl4_0compat_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); +} + +void gl4_0compat_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); +} + +void gl4_0compat_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage1D(target, level, internalFormat, width, border, imageSize, data); +} + +void gl4_0compat_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data); +} + +void gl4_0compat_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage3D(target, level, internalFormat, width, height, depth, border, imageSize, data); +} + +void gl4_0compat_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSampleCoverage(value, invert); +} + +void gl4_0compat_glActiveTexture(void *_glfuncs, GLenum texture) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glActiveTexture(texture); +} + +void gl4_0compat_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteriv(pname, params); +} + +void gl4_0compat_glPointParameteri(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteri(pname, param); +} + +void gl4_0compat_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterfv(pname, params); +} + +void gl4_0compat_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterf(pname, param); +} + +void gl4_0compat_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiDrawArrays(mode, first, count, drawcount); +} + +void gl4_0compat_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); +} + +void gl4_0compat_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferParameteriv(target, pname, params); +} + +GLboolean gl4_0compat_glUnmapBuffer(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glUnmapBuffer(target); +} + +void gl4_0compat_glGetBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferSubData(target, offset, size, data); +} + +void gl4_0compat_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferSubData(target, offset, size, data); +} + +void gl4_0compat_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferData(target, size, data, usage); +} + +GLboolean gl4_0compat_glIsBuffer(void *_glfuncs, GLuint buffer) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsBuffer(buffer); +} + +void gl4_0compat_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenBuffers(n, buffers); +} + +void gl4_0compat_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteBuffers(n, buffers); +} + +void gl4_0compat_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBuffer(target, buffer); +} + +void gl4_0compat_glGetQueryObjectuiv(void *_glfuncs, GLuint id, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectuiv(id, pname, params); +} + +void gl4_0compat_glGetQueryObjectiv(void *_glfuncs, GLuint id, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectiv(id, pname, params); +} + +void gl4_0compat_glGetQueryiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryiv(target, pname, params); +} + +void gl4_0compat_glEndQuery(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndQuery(target); +} + +void gl4_0compat_glBeginQuery(void *_glfuncs, GLenum target, GLuint id) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginQuery(target, id); +} + +GLboolean gl4_0compat_glIsQuery(void *_glfuncs, GLuint id) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsQuery(id); +} + +void gl4_0compat_glDeleteQueries(void *_glfuncs, GLsizei n, const GLuint* ids) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteQueries(n, ids); +} + +void gl4_0compat_glGenQueries(void *_glfuncs, GLsizei n, GLuint* ids) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenQueries(n, ids); +} + +void gl4_0compat_glVertexAttribPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLboolean normalized, GLsizei stride, const GLvoid* offset) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribPointer(index, size, gltype, normalized, stride, offset); +} + +void gl4_0compat_glValidateProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glValidateProgram(program); +} + +void gl4_0compat_glUniformMatrix4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4fv(location, count, transpose, value); +} + +void gl4_0compat_glUniformMatrix3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3fv(location, count, transpose, value); +} + +void gl4_0compat_glUniformMatrix2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2fv(location, count, transpose, value); +} + +void gl4_0compat_glUniform4iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4iv(location, count, value); +} + +void gl4_0compat_glUniform3iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3iv(location, count, value); +} + +void gl4_0compat_glUniform2iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2iv(location, count, value); +} + +void gl4_0compat_glUniform1iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1iv(location, count, value); +} + +void gl4_0compat_glUniform4fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4fv(location, count, value); +} + +void gl4_0compat_glUniform3fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3fv(location, count, value); +} + +void gl4_0compat_glUniform2fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2fv(location, count, value); +} + +void gl4_0compat_glUniform1fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1fv(location, count, value); +} + +void gl4_0compat_glUniform4i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4i(location, v0, v1, v2, v3); +} + +void gl4_0compat_glUniform3i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3i(location, v0, v1, v2); +} + +void gl4_0compat_glUniform2i(void *_glfuncs, GLint location, GLint v0, GLint v1) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2i(location, v0, v1); +} + +void gl4_0compat_glUniform1i(void *_glfuncs, GLint location, GLint v0) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1i(location, v0); +} + +void gl4_0compat_glUniform4f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4f(location, v0, v1, v2, v3); +} + +void gl4_0compat_glUniform3f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3f(location, v0, v1, v2); +} + +void gl4_0compat_glUniform2f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2f(location, v0, v1); +} + +void gl4_0compat_glUniform1f(void *_glfuncs, GLint location, GLfloat v0) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1f(location, v0); +} + +void gl4_0compat_glUseProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUseProgram(program); +} + +void gl4_0compat_glShaderSource(void *_glfuncs, GLuint shader, GLsizei count, const GLchar** source, const GLint* length) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShaderSource(shader, count, source, length); +} + +void gl4_0compat_glLinkProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLinkProgram(program); +} + +GLboolean gl4_0compat_glIsShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsShader(shader); +} + +GLboolean gl4_0compat_glIsProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsProgram(program); +} + +void gl4_0compat_glGetVertexAttribiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribiv(index, pname, params); +} + +void gl4_0compat_glGetVertexAttribfv(void *_glfuncs, GLuint index, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribfv(index, pname, params); +} + +void gl4_0compat_glGetVertexAttribdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribdv(index, pname, params); +} + +void gl4_0compat_glGetUniformiv(void *_glfuncs, GLuint program, GLint location, GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformiv(program, location, params); +} + +void gl4_0compat_glGetUniformfv(void *_glfuncs, GLuint program, GLint location, GLfloat* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformfv(program, location, params); +} + +GLint gl4_0compat_glGetUniformLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetUniformLocation(program, name); +} + +void gl4_0compat_glGetShaderSource(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderSource(shader, bufSize, length, source); +} + +void gl4_0compat_glGetShaderInfoLog(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderInfoLog(shader, bufSize, length, infoLog); +} + +void gl4_0compat_glGetShaderiv(void *_glfuncs, GLuint shader, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderiv(shader, pname, params); +} + +void gl4_0compat_glGetProgramInfoLog(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramInfoLog(program, bufSize, length, infoLog); +} + +void gl4_0compat_glGetProgramiv(void *_glfuncs, GLuint program, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramiv(program, pname, params); +} + +GLint gl4_0compat_glGetAttribLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetAttribLocation(program, name); +} + +void gl4_0compat_glGetAttachedShaders(void *_glfuncs, GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetAttachedShaders(program, maxCount, count, obj); +} + +void gl4_0compat_glGetActiveUniform(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniform(program, index, bufSize, length, size, gltype, name); +} + +void gl4_0compat_glGetActiveAttrib(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveAttrib(program, index, bufSize, length, size, gltype, name); +} + +void gl4_0compat_glEnableVertexAttribArray(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnableVertexAttribArray(index); +} + +void gl4_0compat_glDisableVertexAttribArray(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisableVertexAttribArray(index); +} + +void gl4_0compat_glDetachShader(void *_glfuncs, GLuint program, GLuint shader) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDetachShader(program, shader); +} + +void gl4_0compat_glDeleteShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteShader(shader); +} + +void gl4_0compat_glDeleteProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteProgram(program); +} + +GLuint gl4_0compat_glCreateShader(void *_glfuncs, GLenum gltype) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCreateShader(gltype); +} + +GLuint gl4_0compat_glCreateProgram(void *_glfuncs) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCreateProgram(); +} + +void gl4_0compat_glCompileShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompileShader(shader); +} + +void gl4_0compat_glBindAttribLocation(void *_glfuncs, GLuint program, GLuint index, const GLchar* name) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindAttribLocation(program, index, name); +} + +void gl4_0compat_glAttachShader(void *_glfuncs, GLuint program, GLuint shader) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAttachShader(program, shader); +} + +void gl4_0compat_glStencilMaskSeparate(void *_glfuncs, GLenum face, GLuint mask) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMaskSeparate(face, mask); +} + +void gl4_0compat_glStencilFuncSeparate(void *_glfuncs, GLenum face, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFuncSeparate(face, glfunc, ref, mask); +} + +void gl4_0compat_glStencilOpSeparate(void *_glfuncs, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOpSeparate(face, sfail, dpfail, dppass); +} + +void gl4_0compat_glDrawBuffers(void *_glfuncs, GLsizei n, const GLenum* bufs) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffers(n, bufs); +} + +void gl4_0compat_glBlendEquationSeparate(void *_glfuncs, GLenum modeRGB, GLenum modeAlpha) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquationSeparate(modeRGB, modeAlpha); +} + +void gl4_0compat_glUniformMatrix4x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x3fv(location, count, transpose, value); +} + +void gl4_0compat_glUniformMatrix3x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x4fv(location, count, transpose, value); +} + +void gl4_0compat_glUniformMatrix4x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x2fv(location, count, transpose, value); +} + +void gl4_0compat_glUniformMatrix2x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x4fv(location, count, transpose, value); +} + +void gl4_0compat_glUniformMatrix3x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x2fv(location, count, transpose, value); +} + +void gl4_0compat_glUniformMatrix2x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x3fv(location, count, transpose, value); +} + +GLboolean gl4_0compat_glIsVertexArray(void *_glfuncs, GLuint array) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsVertexArray(array); +} + +void gl4_0compat_glGenVertexArrays(void *_glfuncs, GLsizei n, GLuint* arrays) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenVertexArrays(n, arrays); +} + +void gl4_0compat_glDeleteVertexArrays(void *_glfuncs, GLsizei n, const GLuint* arrays) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteVertexArrays(n, arrays); +} + +void gl4_0compat_glBindVertexArray(void *_glfuncs, GLuint array) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindVertexArray(array); +} + +void gl4_0compat_glFlushMappedBufferRange(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr length) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlushMappedBufferRange(target, offset, length); +} + +void gl4_0compat_glFramebufferTextureLayer(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTextureLayer(target, attachment, texture, level, layer); +} + +void gl4_0compat_glRenderbufferStorageMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRenderbufferStorageMultisample(target, samples, internalFormat, width, height); +} + +void gl4_0compat_glBlitFramebuffer(void *_glfuncs, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); +} + +void gl4_0compat_glGenerateMipmap(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenerateMipmap(target); +} + +void gl4_0compat_glGetFramebufferAttachmentParameteriv(void *_glfuncs, GLenum target, GLenum attachment, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFramebufferAttachmentParameteriv(target, attachment, pname, params); +} + +void gl4_0compat_glFramebufferRenderbuffer(void *_glfuncs, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer); +} + +void gl4_0compat_glFramebufferTexture3D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset); +} + +void gl4_0compat_glFramebufferTexture2D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture2D(target, attachment, textarget, texture, level); +} + +void gl4_0compat_glFramebufferTexture1D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture1D(target, attachment, textarget, texture, level); +} + +GLenum gl4_0compat_glCheckFramebufferStatus(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCheckFramebufferStatus(target); +} + +void gl4_0compat_glGenFramebuffers(void *_glfuncs, GLsizei n, GLuint* framebuffers) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenFramebuffers(n, framebuffers); +} + +void gl4_0compat_glDeleteFramebuffers(void *_glfuncs, GLsizei n, const GLuint* framebuffers) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteFramebuffers(n, framebuffers); +} + +void gl4_0compat_glBindFramebuffer(void *_glfuncs, GLenum target, GLuint framebuffer) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFramebuffer(target, framebuffer); +} + +GLboolean gl4_0compat_glIsFramebuffer(void *_glfuncs, GLuint framebuffer) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsFramebuffer(framebuffer); +} + +void gl4_0compat_glGetRenderbufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetRenderbufferParameteriv(target, pname, params); +} + +void gl4_0compat_glRenderbufferStorage(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRenderbufferStorage(target, internalFormat, width, height); +} + +void gl4_0compat_glGenRenderbuffers(void *_glfuncs, GLsizei n, GLuint* renderbuffers) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenRenderbuffers(n, renderbuffers); +} + +void gl4_0compat_glDeleteRenderbuffers(void *_glfuncs, GLsizei n, const GLuint* renderbuffers) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteRenderbuffers(n, renderbuffers); +} + +void gl4_0compat_glBindRenderbuffer(void *_glfuncs, GLenum target, GLuint renderbuffer) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindRenderbuffer(target, renderbuffer); +} + +GLboolean gl4_0compat_glIsRenderbuffer(void *_glfuncs, GLuint renderbuffer) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsRenderbuffer(renderbuffer); +} + +void gl4_0compat_glClearBufferfi(void *_glfuncs, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferfi(buffer, drawbuffer, depth, stencil); +} + +void gl4_0compat_glClearBufferfv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLfloat* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferfv(buffer, drawbuffer, value); +} + +void gl4_0compat_glClearBufferuiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLuint* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferuiv(buffer, drawbuffer, value); +} + +void gl4_0compat_glClearBufferiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLint* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferiv(buffer, drawbuffer, value); +} + +void gl4_0compat_glGetTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterIuiv(target, pname, params); +} + +void gl4_0compat_glGetTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterIiv(target, pname, params); +} + +void gl4_0compat_glTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, const GLuint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterIuiv(target, pname, params); +} + +void gl4_0compat_glTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterIiv(target, pname, params); +} + +void gl4_0compat_glUniform4uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4uiv(location, count, value); +} + +void gl4_0compat_glUniform3uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3uiv(location, count, value); +} + +void gl4_0compat_glUniform2uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2uiv(location, count, value); +} + +void gl4_0compat_glUniform1uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1uiv(location, count, value); +} + +void gl4_0compat_glUniform4ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4ui(location, v0, v1, v2, v3); +} + +void gl4_0compat_glUniform3ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3ui(location, v0, v1, v2); +} + +void gl4_0compat_glUniform2ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2ui(location, v0, v1); +} + +void gl4_0compat_glUniform1ui(void *_glfuncs, GLint location, GLuint v0) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1ui(location, v0); +} + +GLint gl4_0compat_glGetFragDataLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetFragDataLocation(program, name); +} + +void gl4_0compat_glBindFragDataLocation(void *_glfuncs, GLuint program, GLuint color, const GLchar* name) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFragDataLocation(program, color, name); +} + +void gl4_0compat_glGetUniformuiv(void *_glfuncs, GLuint program, GLint location, GLuint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformuiv(program, location, params); +} + +void gl4_0compat_glGetVertexAttribIuiv(void *_glfuncs, GLuint index, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribIuiv(index, pname, params); +} + +void gl4_0compat_glGetVertexAttribIiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribIiv(index, pname, params); +} + +void gl4_0compat_glVertexAttribIPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribIPointer(index, size, gltype, stride, pointer); +} + +void gl4_0compat_glEndConditionalRender(void *_glfuncs) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndConditionalRender(); +} + +void gl4_0compat_glBeginConditionalRender(void *_glfuncs, GLuint id, GLenum mode) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginConditionalRender(id, mode); +} + +void gl4_0compat_glClampColor(void *_glfuncs, GLenum target, GLenum clamp) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClampColor(target, clamp); +} + +void gl4_0compat_glGetTransformFeedbackVarying(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTransformFeedbackVarying(program, index, bufSize, length, size, gltype, name); +} + +void gl4_0compat_glBindBufferBase(void *_glfuncs, GLenum target, GLuint index, GLuint buffer) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBufferBase(target, index, buffer); +} + +void gl4_0compat_glBindBufferRange(void *_glfuncs, GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBufferRange(target, index, buffer, offset, size); +} + +void gl4_0compat_glEndTransformFeedback(void *_glfuncs) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndTransformFeedback(); +} + +void gl4_0compat_glBeginTransformFeedback(void *_glfuncs, GLenum primitiveMode) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginTransformFeedback(primitiveMode); +} + +GLboolean gl4_0compat_glIsEnabledi(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabledi(target, index); +} + +void gl4_0compat_glDisablei(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisablei(target, index); +} + +void gl4_0compat_glEnablei(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnablei(target, index); +} + +void gl4_0compat_glGetIntegeri_v(void *_glfuncs, GLenum target, GLuint index, GLint* data) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegeri_v(target, index, data); +} + +void gl4_0compat_glGetBooleani_v(void *_glfuncs, GLenum target, GLuint index, GLboolean* data) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleani_v(target, index, data); +} + +void gl4_0compat_glColorMaski(void *_glfuncs, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMaski(index, r, g, b, a); +} + +void gl4_0compat_glCopyBufferSubData(void *_glfuncs, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); +} + +void gl4_0compat_glUniformBlockBinding(void *_glfuncs, GLuint program, GLuint v0, GLuint v1) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformBlockBinding(program, v0, v1); +} + +void gl4_0compat_glGetActiveUniformBlockName(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName); +} + +void gl4_0compat_glGetActiveUniformBlockiv(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params); +} + +GLuint gl4_0compat_glGetUniformBlockIndex(void *_glfuncs, GLuint program, const GLchar* uniformBlockName) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetUniformBlockIndex(program, uniformBlockName); +} + +void gl4_0compat_glGetActiveUniformName(void *_glfuncs, GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformName(program, uniformIndex, bufSize, length, uniformName); +} + +void gl4_0compat_glGetActiveUniformsiv(void *_glfuncs, GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params); +} + +void gl4_0compat_glPrimitiveRestartIndex(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPrimitiveRestartIndex(index); +} + +void gl4_0compat_glTexBuffer(void *_glfuncs, GLenum target, GLenum internalFormat, GLuint buffer) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexBuffer(target, internalFormat, buffer); +} + +void gl4_0compat_glDrawElementsInstanced(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsInstanced(mode, count, gltype, indices, instancecount); +} + +void gl4_0compat_glDrawArraysInstanced(void *_glfuncs, GLenum mode, GLint first, GLsizei count, GLsizei instancecount) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArraysInstanced(mode, first, count, instancecount); +} + +void gl4_0compat_glSampleMaski(void *_glfuncs, GLuint index, GLbitfield mask) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSampleMaski(index, mask); +} + +void gl4_0compat_glGetMultisamplefv(void *_glfuncs, GLenum pname, GLuint index, GLfloat* val) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMultisamplefv(pname, index, val); +} + +void gl4_0compat_glTexImage3DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage3DMultisample(target, samples, internalFormat, width, height, depth, fixedsamplelocations); +} + +void gl4_0compat_glTexImage2DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage2DMultisample(target, samples, internalFormat, width, height, fixedsamplelocations); +} + +void gl4_0compat_glGetSynciv(void *_glfuncs, GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSynciv(sync, pname, bufSize, length, values); +} + +void gl4_0compat_glGetInteger64v(void *_glfuncs, GLenum pname, GLint64* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetInteger64v(pname, params); +} + +void gl4_0compat_glWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWaitSync(sync, flags, timeout); +} + +GLenum gl4_0compat_glClientWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glClientWaitSync(sync, flags, timeout); +} + +void gl4_0compat_glDeleteSync(void *_glfuncs, GLsync sync) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteSync(sync); +} + +GLboolean gl4_0compat_glIsSync(void *_glfuncs, GLsync sync) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsSync(sync); +} + +GLsync gl4_0compat_glFenceSync(void *_glfuncs, GLenum condition, GLbitfield flags) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glFenceSync(condition, flags); +} + +void gl4_0compat_glProvokingVertex(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProvokingVertex(mode); +} + +void gl4_0compat_glDrawElementsInstancedBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLint basevertex) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsInstancedBaseVertex(mode, count, gltype, indices, instancecount, basevertex); +} + +void gl4_0compat_glDrawRangeElementsBaseVertex(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawRangeElementsBaseVertex(mode, start, end, count, gltype, indices, basevertex); +} + +void gl4_0compat_glDrawElementsBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsBaseVertex(mode, count, gltype, indices, basevertex); +} + +void gl4_0compat_glFramebufferTexture(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture(target, attachment, texture, level); +} + +void gl4_0compat_glGetBufferParameteri64v(void *_glfuncs, GLenum target, GLenum pname, GLint64* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferParameteri64v(target, pname, params); +} + +void gl4_0compat_glGetInteger64i_v(void *_glfuncs, GLenum target, GLuint index, GLint64* data) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetInteger64i_v(target, index, data); +} + +void gl4_0compat_glVertexAttribP4uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP4uiv(index, gltype, normalized, value); +} + +void gl4_0compat_glVertexAttribP4ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP4ui(index, gltype, normalized, value); +} + +void gl4_0compat_glVertexAttribP3uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP3uiv(index, gltype, normalized, value); +} + +void gl4_0compat_glVertexAttribP3ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP3ui(index, gltype, normalized, value); +} + +void gl4_0compat_glVertexAttribP2uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP2uiv(index, gltype, normalized, value); +} + +void gl4_0compat_glVertexAttribP2ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP2ui(index, gltype, normalized, value); +} + +void gl4_0compat_glVertexAttribP1uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP1uiv(index, gltype, normalized, value); +} + +void gl4_0compat_glVertexAttribP1ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP1ui(index, gltype, normalized, value); +} + +void gl4_0compat_glSecondaryColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColorP3uiv(gltype, color); +} + +void gl4_0compat_glSecondaryColorP3ui(void *_glfuncs, GLenum gltype, GLuint color) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColorP3ui(gltype, color); +} + +void gl4_0compat_glColorP4uiv(void *_glfuncs, GLenum gltype, const GLuint* color) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP4uiv(gltype, color); +} + +void gl4_0compat_glColorP4ui(void *_glfuncs, GLenum gltype, GLuint color) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP4ui(gltype, color); +} + +void gl4_0compat_glColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP3uiv(gltype, color); +} + +void gl4_0compat_glColorP3ui(void *_glfuncs, GLenum gltype, GLuint color) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP3ui(gltype, color); +} + +void gl4_0compat_glNormalP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormalP3uiv(gltype, coords); +} + +void gl4_0compat_glNormalP3ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormalP3ui(gltype, coords); +} + +void gl4_0compat_glMultiTexCoordP4uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP4uiv(texture, gltype, coords); +} + +void gl4_0compat_glMultiTexCoordP4ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP4ui(texture, gltype, coords); +} + +void gl4_0compat_glMultiTexCoordP3uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP3uiv(texture, gltype, coords); +} + +void gl4_0compat_glMultiTexCoordP3ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP3ui(texture, gltype, coords); +} + +void gl4_0compat_glMultiTexCoordP2uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP2uiv(texture, gltype, coords); +} + +void gl4_0compat_glMultiTexCoordP2ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP2ui(texture, gltype, coords); +} + +void gl4_0compat_glMultiTexCoordP1uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP1uiv(texture, gltype, coords); +} + +void gl4_0compat_glMultiTexCoordP1ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP1ui(texture, gltype, coords); +} + +void gl4_0compat_glTexCoordP4uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP4uiv(gltype, coords); +} + +void gl4_0compat_glTexCoordP4ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP4ui(gltype, coords); +} + +void gl4_0compat_glTexCoordP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP3uiv(gltype, coords); +} + +void gl4_0compat_glTexCoordP3ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP3ui(gltype, coords); +} + +void gl4_0compat_glTexCoordP2uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP2uiv(gltype, coords); +} + +void gl4_0compat_glTexCoordP2ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP2ui(gltype, coords); +} + +void gl4_0compat_glTexCoordP1uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP1uiv(gltype, coords); +} + +void gl4_0compat_glTexCoordP1ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP1ui(gltype, coords); +} + +void gl4_0compat_glVertexP4uiv(void *_glfuncs, GLenum gltype, const GLuint* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP4uiv(gltype, value); +} + +void gl4_0compat_glVertexP4ui(void *_glfuncs, GLenum gltype, GLuint value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP4ui(gltype, value); +} + +void gl4_0compat_glVertexP3uiv(void *_glfuncs, GLenum gltype, const GLuint* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP3uiv(gltype, value); +} + +void gl4_0compat_glVertexP3ui(void *_glfuncs, GLenum gltype, GLuint value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP3ui(gltype, value); +} + +void gl4_0compat_glVertexP2uiv(void *_glfuncs, GLenum gltype, const GLuint* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP2uiv(gltype, value); +} + +void gl4_0compat_glVertexP2ui(void *_glfuncs, GLenum gltype, GLuint value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP2ui(gltype, value); +} + +void gl4_0compat_glGetQueryObjectui64v(void *_glfuncs, GLuint id, GLenum pname, GLuint64* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectui64v(id, pname, params); +} + +void gl4_0compat_glGetQueryObjecti64v(void *_glfuncs, GLuint id, GLenum pname, GLint64* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjecti64v(id, pname, params); +} + +void gl4_0compat_glQueryCounter(void *_glfuncs, GLuint id, GLenum target) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glQueryCounter(id, target); +} + +void gl4_0compat_glGetSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameterIuiv(sampler, pname, params); +} + +void gl4_0compat_glGetSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameterfv(sampler, pname, params); +} + +void gl4_0compat_glGetSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameterIiv(sampler, pname, params); +} + +void gl4_0compat_glGetSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameteriv(sampler, pname, params); +} + +void gl4_0compat_glSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLuint* param) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterIuiv(sampler, pname, param); +} + +void gl4_0compat_glSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterIiv(sampler, pname, param); +} + +void gl4_0compat_glSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, const GLfloat* param) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterfv(sampler, pname, param); +} + +void gl4_0compat_glSamplerParameterf(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterf(sampler, pname, param); +} + +void gl4_0compat_glSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameteriv(sampler, pname, param); +} + +void gl4_0compat_glSamplerParameteri(void *_glfuncs, GLuint sampler, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameteri(sampler, pname, param); +} + +void gl4_0compat_glBindSampler(void *_glfuncs, GLuint unit, GLuint sampler) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindSampler(unit, sampler); +} + +GLboolean gl4_0compat_glIsSampler(void *_glfuncs, GLuint sampler) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsSampler(sampler); +} + +void gl4_0compat_glDeleteSamplers(void *_glfuncs, GLsizei count, const GLuint* samplers) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteSamplers(count, samplers); +} + +void gl4_0compat_glGenSamplers(void *_glfuncs, GLsizei count, GLuint* samplers) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenSamplers(count, samplers); +} + +GLint gl4_0compat_glGetFragDataIndex(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetFragDataIndex(program, name); +} + +void gl4_0compat_glBindFragDataLocationIndexed(void *_glfuncs, GLuint program, GLuint colorNumber, GLuint index, const GLchar* name) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFragDataLocationIndexed(program, colorNumber, index, name); +} + +void gl4_0compat_glVertexAttribDivisor(void *_glfuncs, GLuint index, GLuint divisor) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribDivisor(index, divisor); +} + +void gl4_0compat_glGetQueryIndexediv(void *_glfuncs, GLenum target, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryIndexediv(target, index, pname, params); +} + +void gl4_0compat_glEndQueryIndexed(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndQueryIndexed(target, index); +} + +void gl4_0compat_glBeginQueryIndexed(void *_glfuncs, GLenum target, GLuint index, GLuint id) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginQueryIndexed(target, index, id); +} + +void gl4_0compat_glDrawTransformFeedbackStream(void *_glfuncs, GLenum mode, GLuint id, GLuint stream) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawTransformFeedbackStream(mode, id, stream); +} + +void gl4_0compat_glDrawTransformFeedback(void *_glfuncs, GLenum mode, GLuint id) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawTransformFeedback(mode, id); +} + +void gl4_0compat_glResumeTransformFeedback(void *_glfuncs) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glResumeTransformFeedback(); +} + +void gl4_0compat_glPauseTransformFeedback(void *_glfuncs) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPauseTransformFeedback(); +} + +GLboolean gl4_0compat_glIsTransformFeedback(void *_glfuncs, GLuint id) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsTransformFeedback(id); +} + +void gl4_0compat_glGenTransformFeedbacks(void *_glfuncs, GLsizei n, GLuint* ids) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenTransformFeedbacks(n, ids); +} + +void gl4_0compat_glDeleteTransformFeedbacks(void *_glfuncs, GLsizei n, const GLuint* ids) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteTransformFeedbacks(n, ids); +} + +void gl4_0compat_glBindTransformFeedback(void *_glfuncs, GLenum target, GLuint id) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindTransformFeedback(target, id); +} + +void gl4_0compat_glPatchParameterfv(void *_glfuncs, GLenum pname, const GLfloat* values) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPatchParameterfv(pname, values); +} + +void gl4_0compat_glPatchParameteri(void *_glfuncs, GLenum pname, GLint value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPatchParameteri(pname, value); +} + +void gl4_0compat_glGetProgramStageiv(void *_glfuncs, GLuint program, GLenum shadertype, GLenum pname, GLint* values) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramStageiv(program, shadertype, pname, values); +} + +void gl4_0compat_glGetUniformSubroutineuiv(void *_glfuncs, GLenum shadertype, GLint location, GLuint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformSubroutineuiv(shadertype, location, params); +} + +void gl4_0compat_glUniformSubroutinesuiv(void *_glfuncs, GLenum shadertype, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformSubroutinesuiv(shadertype, count, value); +} + +void gl4_0compat_glGetActiveSubroutineName(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveSubroutineName(program, shadertype, index, bufSize, length, name); +} + +void gl4_0compat_glGetActiveSubroutineUniformName(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveSubroutineUniformName(program, shadertype, index, bufSize, length, name); +} + +void gl4_0compat_glGetActiveSubroutineUniformiv(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint* values) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveSubroutineUniformiv(program, shadertype, index, pname, values); +} + +GLuint gl4_0compat_glGetSubroutineIndex(void *_glfuncs, GLuint program, GLenum shadertype, const GLchar* name) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetSubroutineIndex(program, shadertype, name); +} + +GLint gl4_0compat_glGetSubroutineUniformLocation(void *_glfuncs, GLuint program, GLenum shadertype, const GLchar* name) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetSubroutineUniformLocation(program, shadertype, name); +} + +void gl4_0compat_glGetUniformdv(void *_glfuncs, GLuint program, GLint location, GLdouble* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformdv(program, location, params); +} + +void gl4_0compat_glUniformMatrix4x3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x3dv(location, count, transpose, value); +} + +void gl4_0compat_glUniformMatrix4x2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x2dv(location, count, transpose, value); +} + +void gl4_0compat_glUniformMatrix3x4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x4dv(location, count, transpose, value); +} + +void gl4_0compat_glUniformMatrix3x2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x2dv(location, count, transpose, value); +} + +void gl4_0compat_glUniformMatrix2x4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x4dv(location, count, transpose, value); +} + +void gl4_0compat_glUniformMatrix2x3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x3dv(location, count, transpose, value); +} + +void gl4_0compat_glUniformMatrix4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4dv(location, count, transpose, value); +} + +void gl4_0compat_glUniformMatrix3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3dv(location, count, transpose, value); +} + +void gl4_0compat_glUniformMatrix2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2dv(location, count, transpose, value); +} + +void gl4_0compat_glUniform4dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4dv(location, count, value); +} + +void gl4_0compat_glUniform3dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3dv(location, count, value); +} + +void gl4_0compat_glUniform2dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2dv(location, count, value); +} + +void gl4_0compat_glUniform1dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1dv(location, count, value); +} + +void gl4_0compat_glUniform4d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4d(location, v0, v1, v2, v3); +} + +void gl4_0compat_glUniform3d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1, GLdouble v2) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3d(location, v0, v1, v2); +} + +void gl4_0compat_glUniform2d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2d(location, v0, v1); +} + +void gl4_0compat_glUniform1d(void *_glfuncs, GLint location, GLdouble v0) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1d(location, v0); +} + +void gl4_0compat_glDrawElementsIndirect(void *_glfuncs, GLenum mode, GLenum gltype, const GLvoid* indirect) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsIndirect(mode, gltype, indirect); +} + +void gl4_0compat_glDrawArraysIndirect(void *_glfuncs, GLenum mode, const GLvoid* indirect) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArraysIndirect(mode, indirect); +} + +void gl4_0compat_glBlendFuncSeparatei(void *_glfuncs, GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha); +} + +void gl4_0compat_glBlendFunci(void *_glfuncs, GLuint buf, GLenum src, GLenum dst) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFunci(buf, src, dst); +} + +void gl4_0compat_glBlendEquationSeparatei(void *_glfuncs, GLuint buf, GLenum modeRGB, GLenum modeAlpha) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquationSeparatei(buf, modeRGB, modeAlpha); +} + +void gl4_0compat_glBlendEquationi(void *_glfuncs, GLuint buf, GLenum mode) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquationi(buf, mode); +} + +void gl4_0compat_glMinSampleShading(void *_glfuncs, GLfloat value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMinSampleShading(value); +} + +void gl4_0compat_glTranslatef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTranslatef(x, y, z); +} + +void gl4_0compat_glTranslated(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTranslated(x, y, z); +} + +void gl4_0compat_glScalef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScalef(x, y, z); +} + +void gl4_0compat_glScaled(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScaled(x, y, z); +} + +void gl4_0compat_glRotatef(void *_glfuncs, GLfloat angle, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRotatef(angle, x, y, z); +} + +void gl4_0compat_glRotated(void *_glfuncs, GLdouble angle, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRotated(angle, x, y, z); +} + +void gl4_0compat_glPushMatrix(void *_glfuncs) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushMatrix(); +} + +void gl4_0compat_glPopMatrix(void *_glfuncs) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopMatrix(); +} + +void gl4_0compat_glOrtho(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glOrtho(left, right, bottom, top, zNear, zFar); +} + +void gl4_0compat_glMultMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultMatrixd(m); +} + +void gl4_0compat_glMultMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultMatrixf(m); +} + +void gl4_0compat_glMatrixMode(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMatrixMode(mode); +} + +void gl4_0compat_glLoadMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadMatrixd(m); +} + +void gl4_0compat_glLoadMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadMatrixf(m); +} + +void gl4_0compat_glLoadIdentity(void *_glfuncs) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadIdentity(); +} + +void gl4_0compat_glFrustum(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrustum(left, right, bottom, top, zNear, zFar); +} + +GLboolean gl4_0compat_glIsList(void *_glfuncs, GLuint list) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsList(list); +} + +void gl4_0compat_glGetTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGeniv(coord, pname, params); +} + +void gl4_0compat_glGetTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGenfv(coord, pname, params); +} + +void gl4_0compat_glGetTexGendv(void *_glfuncs, GLenum coord, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGendv(coord, pname, params); +} + +void gl4_0compat_glGetTexEnviv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexEnviv(target, pname, params); +} + +void gl4_0compat_glGetTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexEnvfv(target, pname, params); +} + +void gl4_0compat_glGetPolygonStipple(void *_glfuncs, GLubyte* mask) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPolygonStipple(mask); +} + +void gl4_0compat_glGetPixelMapusv(void *_glfuncs, GLenum glmap, GLushort* values) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapusv(glmap, values); +} + +void gl4_0compat_glGetPixelMapuiv(void *_glfuncs, GLenum glmap, GLuint* values) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapuiv(glmap, values); +} + +void gl4_0compat_glGetPixelMapfv(void *_glfuncs, GLenum glmap, GLfloat* values) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapfv(glmap, values); +} + +void gl4_0compat_glGetMaterialiv(void *_glfuncs, GLenum face, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMaterialiv(face, pname, params); +} + +void gl4_0compat_glGetMaterialfv(void *_glfuncs, GLenum face, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMaterialfv(face, pname, params); +} + +void gl4_0compat_glGetMapiv(void *_glfuncs, GLenum target, GLenum query, GLint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapiv(target, query, v); +} + +void gl4_0compat_glGetMapfv(void *_glfuncs, GLenum target, GLenum query, GLfloat* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapfv(target, query, v); +} + +void gl4_0compat_glGetMapdv(void *_glfuncs, GLenum target, GLenum query, GLdouble* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapdv(target, query, v); +} + +void gl4_0compat_glGetLightiv(void *_glfuncs, GLenum light, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetLightiv(light, pname, params); +} + +void gl4_0compat_glGetLightfv(void *_glfuncs, GLenum light, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetLightfv(light, pname, params); +} + +void gl4_0compat_glGetClipPlane(void *_glfuncs, GLenum plane, GLdouble* equation) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetClipPlane(plane, equation); +} + +void gl4_0compat_glDrawPixels(void *_glfuncs, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawPixels(width, height, format, gltype, pixels); +} + +void gl4_0compat_glCopyPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum gltype) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyPixels(x, y, width, height, gltype); +} + +void gl4_0compat_glPixelMapusv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLushort* values) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapusv(glmap, mapsize, values); +} + +void gl4_0compat_glPixelMapuiv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLuint* values) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapuiv(glmap, mapsize, values); +} + +void gl4_0compat_glPixelMapfv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLfloat* values) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapfv(glmap, mapsize, values); +} + +void gl4_0compat_glPixelTransferi(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelTransferi(pname, param); +} + +void gl4_0compat_glPixelTransferf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelTransferf(pname, param); +} + +void gl4_0compat_glPixelZoom(void *_glfuncs, GLfloat xfactor, GLfloat yfactor) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelZoom(xfactor, yfactor); +} + +void gl4_0compat_glAlphaFunc(void *_glfuncs, GLenum glfunc, GLfloat ref) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAlphaFunc(glfunc, ref); +} + +void gl4_0compat_glEvalPoint2(void *_glfuncs, GLint i, GLint j) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalPoint2(i, j); +} + +void gl4_0compat_glEvalMesh2(void *_glfuncs, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalMesh2(mode, i1, i2, j1, j2); +} + +void gl4_0compat_glEvalPoint1(void *_glfuncs, GLint i) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalPoint1(i); +} + +void gl4_0compat_glEvalMesh1(void *_glfuncs, GLenum mode, GLint i1, GLint i2) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalMesh1(mode, i1, i2); +} + +void gl4_0compat_glEvalCoord2fv(void *_glfuncs, const GLfloat* u) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2fv(u); +} + +void gl4_0compat_glEvalCoord2f(void *_glfuncs, GLfloat u, GLfloat v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2f(u, v); +} + +void gl4_0compat_glEvalCoord2dv(void *_glfuncs, const GLdouble* u) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2dv(u); +} + +void gl4_0compat_glEvalCoord2d(void *_glfuncs, GLdouble u, GLdouble v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2d(u, v); +} + +void gl4_0compat_glEvalCoord1fv(void *_glfuncs, const GLfloat* u) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1fv(u); +} + +void gl4_0compat_glEvalCoord1f(void *_glfuncs, GLfloat u) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1f(u); +} + +void gl4_0compat_glEvalCoord1dv(void *_glfuncs, const GLdouble* u) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1dv(u); +} + +void gl4_0compat_glEvalCoord1d(void *_glfuncs, GLdouble u) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1d(u); +} + +void gl4_0compat_glMapGrid2f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid2f(un, u1, u2, vn, v1, v2); +} + +void gl4_0compat_glMapGrid2d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid2d(un, u1, u2, vn, v1, v2); +} + +void gl4_0compat_glMapGrid1f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid1f(un, u1, u2); +} + +void gl4_0compat_glMapGrid1d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid1d(un, u1, u2); +} + +void gl4_0compat_glMap2f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); +} + +void gl4_0compat_glMap2d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); +} + +void gl4_0compat_glMap1f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap1f(target, u1, u2, stride, order, points); +} + +void gl4_0compat_glMap1d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap1d(target, u1, u2, stride, order, points); +} + +void gl4_0compat_glPushAttrib(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushAttrib(mask); +} + +void gl4_0compat_glPopAttrib(void *_glfuncs) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopAttrib(); +} + +void gl4_0compat_glAccum(void *_glfuncs, GLenum op, GLfloat value) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAccum(op, value); +} + +void gl4_0compat_glIndexMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexMask(mask); +} + +void gl4_0compat_glClearIndex(void *_glfuncs, GLfloat c) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearIndex(c); +} + +void gl4_0compat_glClearAccum(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearAccum(red, green, blue, alpha); +} + +void gl4_0compat_glPushName(void *_glfuncs, GLuint name) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushName(name); +} + +void gl4_0compat_glPopName(void *_glfuncs) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopName(); +} + +void gl4_0compat_glPassThrough(void *_glfuncs, GLfloat token) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPassThrough(token); +} + +void gl4_0compat_glLoadName(void *_glfuncs, GLuint name) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadName(name); +} + +void gl4_0compat_glInitNames(void *_glfuncs) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInitNames(); +} + +GLint gl4_0compat_glRenderMode(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glRenderMode(mode); +} + +void gl4_0compat_glSelectBuffer(void *_glfuncs, GLsizei size, GLuint* buffer) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSelectBuffer(size, buffer); +} + +void gl4_0compat_glFeedbackBuffer(void *_glfuncs, GLsizei size, GLenum gltype, GLfloat* buffer) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFeedbackBuffer(size, gltype, buffer); +} + +void gl4_0compat_glTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGeniv(coord, pname, params); +} + +void gl4_0compat_glTexGeni(void *_glfuncs, GLenum coord, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGeni(coord, pname, param); +} + +void gl4_0compat_glTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGenfv(coord, pname, params); +} + +void gl4_0compat_glTexGenf(void *_glfuncs, GLenum coord, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGenf(coord, pname, param); +} + +void gl4_0compat_glTexGendv(void *_glfuncs, GLenum coord, GLenum pname, const GLdouble* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGendv(coord, pname, params); +} + +void gl4_0compat_glTexGend(void *_glfuncs, GLenum coord, GLenum pname, GLdouble param) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGend(coord, pname, param); +} + +void gl4_0compat_glTexEnviv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnviv(target, pname, params); +} + +void gl4_0compat_glTexEnvi(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvi(target, pname, param); +} + +void gl4_0compat_glTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvfv(target, pname, params); +} + +void gl4_0compat_glTexEnvf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvf(target, pname, param); +} + +void gl4_0compat_glShadeModel(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShadeModel(mode); +} + +void gl4_0compat_glPolygonStipple(void *_glfuncs, const GLubyte* mask) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonStipple(mask); +} + +void gl4_0compat_glMaterialiv(void *_glfuncs, GLenum face, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialiv(face, pname, params); +} + +void gl4_0compat_glMateriali(void *_glfuncs, GLenum face, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMateriali(face, pname, param); +} + +void gl4_0compat_glMaterialfv(void *_glfuncs, GLenum face, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialfv(face, pname, params); +} + +void gl4_0compat_glMaterialf(void *_glfuncs, GLenum face, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialf(face, pname, param); +} + +void gl4_0compat_glLineStipple(void *_glfuncs, GLint factor, GLushort pattern) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineStipple(factor, pattern); +} + +void gl4_0compat_glLightModeliv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModeliv(pname, params); +} + +void gl4_0compat_glLightModeli(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModeli(pname, param); +} + +void gl4_0compat_glLightModelfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModelfv(pname, params); +} + +void gl4_0compat_glLightModelf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModelf(pname, param); +} + +void gl4_0compat_glLightiv(void *_glfuncs, GLenum light, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightiv(light, pname, params); +} + +void gl4_0compat_glLighti(void *_glfuncs, GLenum light, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLighti(light, pname, param); +} + +void gl4_0compat_glLightfv(void *_glfuncs, GLenum light, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightfv(light, pname, params); +} + +void gl4_0compat_glLightf(void *_glfuncs, GLenum light, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightf(light, pname, param); +} + +void gl4_0compat_glFogiv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogiv(pname, params); +} + +void gl4_0compat_glFogi(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogi(pname, param); +} + +void gl4_0compat_glFogfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogfv(pname, params); +} + +void gl4_0compat_glFogf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogf(pname, param); +} + +void gl4_0compat_glColorMaterial(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMaterial(face, mode); +} + +void gl4_0compat_glClipPlane(void *_glfuncs, GLenum plane, const GLdouble* equation) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClipPlane(plane, equation); +} + +void gl4_0compat_glVertex4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4sv(v); +} + +void gl4_0compat_glVertex4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4s(x, y, z, w); +} + +void gl4_0compat_glVertex4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4iv(v); +} + +void gl4_0compat_glVertex4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4i(x, y, z, w); +} + +void gl4_0compat_glVertex4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4fv(v); +} + +void gl4_0compat_glVertex4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4f(x, y, z, w); +} + +void gl4_0compat_glVertex4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4dv(v); +} + +void gl4_0compat_glVertex4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4d(x, y, z, w); +} + +void gl4_0compat_glVertex3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3sv(v); +} + +void gl4_0compat_glVertex3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3s(x, y, z); +} + +void gl4_0compat_glVertex3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3iv(v); +} + +void gl4_0compat_glVertex3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3i(x, y, z); +} + +void gl4_0compat_glVertex3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3fv(v); +} + +void gl4_0compat_glVertex3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3f(x, y, z); +} + +void gl4_0compat_glVertex3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3dv(v); +} + +void gl4_0compat_glVertex3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3d(x, y, z); +} + +void gl4_0compat_glVertex2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2sv(v); +} + +void gl4_0compat_glVertex2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2s(x, y); +} + +void gl4_0compat_glVertex2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2iv(v); +} + +void gl4_0compat_glVertex2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2i(x, y); +} + +void gl4_0compat_glVertex2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2fv(v); +} + +void gl4_0compat_glVertex2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2f(x, y); +} + +void gl4_0compat_glVertex2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2dv(v); +} + +void gl4_0compat_glVertex2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2d(x, y); +} + +void gl4_0compat_glTexCoord4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4sv(v); +} + +void gl4_0compat_glTexCoord4s(void *_glfuncs, GLshort s, GLshort t, GLshort r, GLshort q) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4s(s, t, r, q); +} + +void gl4_0compat_glTexCoord4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4iv(v); +} + +void gl4_0compat_glTexCoord4i(void *_glfuncs, GLint s, GLint t, GLint r, GLint q) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4i(s, t, r, q); +} + +void gl4_0compat_glTexCoord4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4fv(v); +} + +void gl4_0compat_glTexCoord4f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4f(s, t, r, q); +} + +void gl4_0compat_glTexCoord4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4dv(v); +} + +void gl4_0compat_glTexCoord4d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r, GLdouble q) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4d(s, t, r, q); +} + +void gl4_0compat_glTexCoord3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3sv(v); +} + +void gl4_0compat_glTexCoord3s(void *_glfuncs, GLshort s, GLshort t, GLshort r) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3s(s, t, r); +} + +void gl4_0compat_glTexCoord3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3iv(v); +} + +void gl4_0compat_glTexCoord3i(void *_glfuncs, GLint s, GLint t, GLint r) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3i(s, t, r); +} + +void gl4_0compat_glTexCoord3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3fv(v); +} + +void gl4_0compat_glTexCoord3f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3f(s, t, r); +} + +void gl4_0compat_glTexCoord3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3dv(v); +} + +void gl4_0compat_glTexCoord3d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3d(s, t, r); +} + +void gl4_0compat_glTexCoord2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2sv(v); +} + +void gl4_0compat_glTexCoord2s(void *_glfuncs, GLshort s, GLshort t) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2s(s, t); +} + +void gl4_0compat_glTexCoord2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2iv(v); +} + +void gl4_0compat_glTexCoord2i(void *_glfuncs, GLint s, GLint t) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2i(s, t); +} + +void gl4_0compat_glTexCoord2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2fv(v); +} + +void gl4_0compat_glTexCoord2f(void *_glfuncs, GLfloat s, GLfloat t) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2f(s, t); +} + +void gl4_0compat_glTexCoord2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2dv(v); +} + +void gl4_0compat_glTexCoord2d(void *_glfuncs, GLdouble s, GLdouble t) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2d(s, t); +} + +void gl4_0compat_glTexCoord1sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1sv(v); +} + +void gl4_0compat_glTexCoord1s(void *_glfuncs, GLshort s) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1s(s); +} + +void gl4_0compat_glTexCoord1iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1iv(v); +} + +void gl4_0compat_glTexCoord1i(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1i(s); +} + +void gl4_0compat_glTexCoord1fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1fv(v); +} + +void gl4_0compat_glTexCoord1f(void *_glfuncs, GLfloat s) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1f(s); +} + +void gl4_0compat_glTexCoord1dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1dv(v); +} + +void gl4_0compat_glTexCoord1d(void *_glfuncs, GLdouble s) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1d(s); +} + +void gl4_0compat_glRectsv(void *_glfuncs, const GLshort* v1, const GLshort* v2) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectsv(v1, v2); +} + +void gl4_0compat_glRects(void *_glfuncs, GLshort x1, GLshort y1, GLshort x2, GLshort y2) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRects(x1, y1, x2, y2); +} + +void gl4_0compat_glRectiv(void *_glfuncs, const GLint* v1, const GLint* v2) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectiv(v1, v2); +} + +void gl4_0compat_glRecti(void *_glfuncs, GLint x1, GLint y1, GLint x2, GLint y2) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRecti(x1, y1, x2, y2); +} + +void gl4_0compat_glRectfv(void *_glfuncs, const GLfloat* v1, const GLfloat* v2) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectfv(v1, v2); +} + +void gl4_0compat_glRectf(void *_glfuncs, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectf(x1, y1, x2, y2); +} + +void gl4_0compat_glRectdv(void *_glfuncs, const GLdouble* v1, const GLdouble* v2) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectdv(v1, v2); +} + +void gl4_0compat_glRectd(void *_glfuncs, GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectd(x1, y1, x2, y2); +} + +void gl4_0compat_glRasterPos4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4sv(v); +} + +void gl4_0compat_glRasterPos4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4s(x, y, z, w); +} + +void gl4_0compat_glRasterPos4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4iv(v); +} + +void gl4_0compat_glRasterPos4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4i(x, y, z, w); +} + +void gl4_0compat_glRasterPos4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4fv(v); +} + +void gl4_0compat_glRasterPos4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4f(x, y, z, w); +} + +void gl4_0compat_glRasterPos4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4dv(v); +} + +void gl4_0compat_glRasterPos4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4d(x, y, z, w); +} + +void gl4_0compat_glRasterPos3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3sv(v); +} + +void gl4_0compat_glRasterPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3s(x, y, z); +} + +void gl4_0compat_glRasterPos3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3iv(v); +} + +void gl4_0compat_glRasterPos3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3i(x, y, z); +} + +void gl4_0compat_glRasterPos3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3fv(v); +} + +void gl4_0compat_glRasterPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3f(x, y, z); +} + +void gl4_0compat_glRasterPos3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3dv(v); +} + +void gl4_0compat_glRasterPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3d(x, y, z); +} + +void gl4_0compat_glRasterPos2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2sv(v); +} + +void gl4_0compat_glRasterPos2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2s(x, y); +} + +void gl4_0compat_glRasterPos2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2iv(v); +} + +void gl4_0compat_glRasterPos2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2i(x, y); +} + +void gl4_0compat_glRasterPos2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2fv(v); +} + +void gl4_0compat_glRasterPos2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2f(x, y); +} + +void gl4_0compat_glRasterPos2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2dv(v); +} + +void gl4_0compat_glRasterPos2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2d(x, y); +} + +void gl4_0compat_glNormal3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3sv(v); +} + +void gl4_0compat_glNormal3s(void *_glfuncs, GLshort nx, GLshort ny, GLshort nz) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3s(nx, ny, nz); +} + +void gl4_0compat_glNormal3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3iv(v); +} + +void gl4_0compat_glNormal3i(void *_glfuncs, GLint nx, GLint ny, GLint nz) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3i(nx, ny, nz); +} + +void gl4_0compat_glNormal3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3fv(v); +} + +void gl4_0compat_glNormal3f(void *_glfuncs, GLfloat nx, GLfloat ny, GLfloat nz) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3f(nx, ny, nz); +} + +void gl4_0compat_glNormal3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3dv(v); +} + +void gl4_0compat_glNormal3d(void *_glfuncs, GLdouble nx, GLdouble ny, GLdouble nz) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3d(nx, ny, nz); +} + +void gl4_0compat_glNormal3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3bv(v); +} + +void gl4_0compat_glNormal3b(void *_glfuncs, GLbyte nx, GLbyte ny, GLbyte nz) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3b(nx, ny, nz); +} + +void gl4_0compat_glIndexsv(void *_glfuncs, const GLshort* c) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexsv(c); +} + +void gl4_0compat_glIndexs(void *_glfuncs, GLshort c) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexs(c); +} + +void gl4_0compat_glIndexiv(void *_glfuncs, const GLint* c) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexiv(c); +} + +void gl4_0compat_glIndexi(void *_glfuncs, GLint c) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexi(c); +} + +void gl4_0compat_glIndexfv(void *_glfuncs, const GLfloat* c) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexfv(c); +} + +void gl4_0compat_glIndexf(void *_glfuncs, GLfloat c) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexf(c); +} + +void gl4_0compat_glIndexdv(void *_glfuncs, const GLdouble* c) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexdv(c); +} + +void gl4_0compat_glIndexd(void *_glfuncs, GLdouble c) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexd(c); +} + +void gl4_0compat_glEnd(void *_glfuncs) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnd(); +} + +void gl4_0compat_glEdgeFlagv(void *_glfuncs, const GLboolean* flag) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlagv(flag); +} + +void gl4_0compat_glEdgeFlag(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlag(flag); +} + +void gl4_0compat_glColor4usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4usv(v); +} + +void gl4_0compat_glColor4us(void *_glfuncs, GLushort red, GLushort green, GLushort blue, GLushort alpha) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4us(red, green, blue, alpha); +} + +void gl4_0compat_glColor4uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4uiv(v); +} + +void gl4_0compat_glColor4ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue, GLuint alpha) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ui(red, green, blue, alpha); +} + +void gl4_0compat_glColor4ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ubv(v); +} + +void gl4_0compat_glColor4ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ub(red, green, blue, alpha); +} + +void gl4_0compat_glColor4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4sv(v); +} + +void gl4_0compat_glColor4s(void *_glfuncs, GLshort red, GLshort green, GLshort blue, GLshort alpha) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4s(red, green, blue, alpha); +} + +void gl4_0compat_glColor4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4iv(v); +} + +void gl4_0compat_glColor4i(void *_glfuncs, GLint red, GLint green, GLint blue, GLint alpha) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4i(red, green, blue, alpha); +} + +void gl4_0compat_glColor4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4fv(v); +} + +void gl4_0compat_glColor4f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4f(red, green, blue, alpha); +} + +void gl4_0compat_glColor4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4dv(v); +} + +void gl4_0compat_glColor4d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4d(red, green, blue, alpha); +} + +void gl4_0compat_glColor4bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4bv(v); +} + +void gl4_0compat_glColor4b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4b(red, green, blue, alpha); +} + +void gl4_0compat_glColor3usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3usv(v); +} + +void gl4_0compat_glColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3us(red, green, blue); +} + +void gl4_0compat_glColor3uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3uiv(v); +} + +void gl4_0compat_glColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ui(red, green, blue); +} + +void gl4_0compat_glColor3ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ubv(v); +} + +void gl4_0compat_glColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ub(red, green, blue); +} + +void gl4_0compat_glColor3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3sv(v); +} + +void gl4_0compat_glColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3s(red, green, blue); +} + +void gl4_0compat_glColor3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3iv(v); +} + +void gl4_0compat_glColor3i(void *_glfuncs, GLint red, GLint green, GLint blue) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3i(red, green, blue); +} + +void gl4_0compat_glColor3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3fv(v); +} + +void gl4_0compat_glColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3f(red, green, blue); +} + +void gl4_0compat_glColor3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3dv(v); +} + +void gl4_0compat_glColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3d(red, green, blue); +} + +void gl4_0compat_glColor3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3bv(v); +} + +void gl4_0compat_glColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3b(red, green, blue); +} + +void gl4_0compat_glBitmap(void *_glfuncs, GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBitmap(width, height, xorig, yorig, xmove, ymove, bitmap); +} + +void gl4_0compat_glBegin(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBegin(mode); +} + +void gl4_0compat_glListBase(void *_glfuncs, GLuint base) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glListBase(base); +} + +GLuint gl4_0compat_glGenLists(void *_glfuncs, GLsizei range_) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGenLists(range_); +} + +void gl4_0compat_glDeleteLists(void *_glfuncs, GLuint list, GLsizei range_) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteLists(list, range_); +} + +void gl4_0compat_glCallLists(void *_glfuncs, GLsizei n, GLenum gltype, const GLvoid* lists) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCallLists(n, gltype, lists); +} + +void gl4_0compat_glCallList(void *_glfuncs, GLuint list) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCallList(list); +} + +void gl4_0compat_glEndList(void *_glfuncs) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndList(); +} + +void gl4_0compat_glNewList(void *_glfuncs, GLuint list, GLenum mode) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNewList(list, mode); +} + +void gl4_0compat_glPushClientAttrib(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushClientAttrib(mask); +} + +void gl4_0compat_glPopClientAttrib(void *_glfuncs) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopClientAttrib(); +} + +void gl4_0compat_glPrioritizeTextures(void *_glfuncs, GLsizei n, const GLuint* textures, const GLfloat* priorities) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPrioritizeTextures(n, textures, priorities); +} + +GLboolean gl4_0compat_glAreTexturesResident(void *_glfuncs, GLsizei n, const GLuint* textures, GLboolean* residences) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glAreTexturesResident(n, textures, residences); +} + +void gl4_0compat_glVertexPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexPointer(size, gltype, stride, pointer); +} + +void gl4_0compat_glTexCoordPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordPointer(size, gltype, stride, pointer); +} + +void gl4_0compat_glNormalPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormalPointer(gltype, stride, pointer); +} + +void gl4_0compat_glInterleavedArrays(void *_glfuncs, GLenum format, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInterleavedArrays(format, stride, pointer); +} + +void gl4_0compat_glIndexPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexPointer(gltype, stride, pointer); +} + +void gl4_0compat_glEnableClientState(void *_glfuncs, GLenum array) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnableClientState(array); +} + +void gl4_0compat_glEdgeFlagPointer(void *_glfuncs, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlagPointer(stride, pointer); +} + +void gl4_0compat_glDisableClientState(void *_glfuncs, GLenum array) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisableClientState(array); +} + +void gl4_0compat_glColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorPointer(size, gltype, stride, pointer); +} + +void gl4_0compat_glArrayElement(void *_glfuncs, GLint i) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glArrayElement(i); +} + +void gl4_0compat_glResetMinmax(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glResetMinmax(target); +} + +void gl4_0compat_glResetHistogram(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glResetHistogram(target); +} + +void gl4_0compat_glMinmax(void *_glfuncs, GLenum target, GLenum internalFormat, GLboolean sink) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMinmax(target, internalFormat, sink); +} + +void gl4_0compat_glHistogram(void *_glfuncs, GLenum target, GLsizei width, GLenum internalFormat, GLboolean sink) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glHistogram(target, width, internalFormat, sink); +} + +void gl4_0compat_glGetMinmaxParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmaxParameteriv(target, pname, params); +} + +void gl4_0compat_glGetMinmaxParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmaxParameterfv(target, pname, params); +} + +void gl4_0compat_glGetMinmax(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmax(target, reset, format, gltype, values); +} + +void gl4_0compat_glGetHistogramParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogramParameteriv(target, pname, params); +} + +void gl4_0compat_glGetHistogramParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogramParameterfv(target, pname, params); +} + +void gl4_0compat_glGetHistogram(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogram(target, reset, format, gltype, values); +} + +void gl4_0compat_glSeparableFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* row, const GLvoid* column) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSeparableFilter2D(target, internalFormat, width, height, format, gltype, row, column); +} + +void gl4_0compat_glGetSeparableFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* row, GLvoid* column, GLvoid* span) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSeparableFilter(target, format, gltype, row, column, span); +} + +void gl4_0compat_glGetConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionParameteriv(target, pname, params); +} + +void gl4_0compat_glGetConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionParameterfv(target, pname, params); +} + +void gl4_0compat_glGetConvolutionFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* image) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionFilter(target, format, gltype, image); +} + +void gl4_0compat_glCopyConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyConvolutionFilter2D(target, internalFormat, x, y, width, height); +} + +void gl4_0compat_glCopyConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyConvolutionFilter1D(target, internalFormat, x, y, width); +} + +void gl4_0compat_glConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameteriv(target, pname, params); +} + +void gl4_0compat_glConvolutionParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameteri(target, pname, params); +} + +void gl4_0compat_glConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameterfv(target, pname, params); +} + +void gl4_0compat_glConvolutionParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameterf(target, pname, params); +} + +void gl4_0compat_glConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* image) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionFilter2D(target, internalFormat, width, height, format, gltype, image); +} + +void gl4_0compat_glConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* image) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionFilter1D(target, internalFormat, width, format, gltype, image); +} + +void gl4_0compat_glCopyColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyColorSubTable(target, start, x, y, width); +} + +void gl4_0compat_glColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum gltype, const GLvoid* data) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorSubTable(target, start, count, format, gltype, data); +} + +void gl4_0compat_glGetColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTableParameteriv(target, pname, params); +} + +void gl4_0compat_glGetColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTableParameterfv(target, pname, params); +} + +void gl4_0compat_glGetColorTable(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* table) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTable(target, format, gltype, table); +} + +void gl4_0compat_glCopyColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyColorTable(target, internalFormat, x, y, width); +} + +void gl4_0compat_glColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTableParameteriv(target, pname, params); +} + +void gl4_0compat_glColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTableParameterfv(target, pname, params); +} + +void gl4_0compat_glColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* table) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTable(target, internalFormat, width, format, gltype, table); +} + +void gl4_0compat_glMultTransposeMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultTransposeMatrixd(m); +} + +void gl4_0compat_glMultTransposeMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultTransposeMatrixf(m); +} + +void gl4_0compat_glLoadTransposeMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadTransposeMatrixd(m); +} + +void gl4_0compat_glLoadTransposeMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadTransposeMatrixf(m); +} + +void gl4_0compat_glMultiTexCoord4sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4sv(target, v); +} + +void gl4_0compat_glMultiTexCoord4s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r, GLshort q) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4s(target, s, t, r, q); +} + +void gl4_0compat_glMultiTexCoord4iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4iv(target, v); +} + +void gl4_0compat_glMultiTexCoord4i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r, GLint q) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4i(target, s, t, r, q); +} + +void gl4_0compat_glMultiTexCoord4fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4fv(target, v); +} + +void gl4_0compat_glMultiTexCoord4f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4f(target, s, t, r, q); +} + +void gl4_0compat_glMultiTexCoord4dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4dv(target, v); +} + +void gl4_0compat_glMultiTexCoord4d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4d(target, s, t, r, q); +} + +void gl4_0compat_glMultiTexCoord3sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3sv(target, v); +} + +void gl4_0compat_glMultiTexCoord3s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3s(target, s, t, r); +} + +void gl4_0compat_glMultiTexCoord3iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3iv(target, v); +} + +void gl4_0compat_glMultiTexCoord3i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3i(target, s, t, r); +} + +void gl4_0compat_glMultiTexCoord3fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3fv(target, v); +} + +void gl4_0compat_glMultiTexCoord3f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3f(target, s, t, r); +} + +void gl4_0compat_glMultiTexCoord3dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3dv(target, v); +} + +void gl4_0compat_glMultiTexCoord3d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3d(target, s, t, r); +} + +void gl4_0compat_glMultiTexCoord2sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2sv(target, v); +} + +void gl4_0compat_glMultiTexCoord2s(void *_glfuncs, GLenum target, GLshort s, GLshort t) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2s(target, s, t); +} + +void gl4_0compat_glMultiTexCoord2iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2iv(target, v); +} + +void gl4_0compat_glMultiTexCoord2i(void *_glfuncs, GLenum target, GLint s, GLint t) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2i(target, s, t); +} + +void gl4_0compat_glMultiTexCoord2fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2fv(target, v); +} + +void gl4_0compat_glMultiTexCoord2f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2f(target, s, t); +} + +void gl4_0compat_glMultiTexCoord2dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2dv(target, v); +} + +void gl4_0compat_glMultiTexCoord2d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2d(target, s, t); +} + +void gl4_0compat_glMultiTexCoord1sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1sv(target, v); +} + +void gl4_0compat_glMultiTexCoord1s(void *_glfuncs, GLenum target, GLshort s) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1s(target, s); +} + +void gl4_0compat_glMultiTexCoord1iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1iv(target, v); +} + +void gl4_0compat_glMultiTexCoord1i(void *_glfuncs, GLenum target, GLint s) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1i(target, s); +} + +void gl4_0compat_glMultiTexCoord1fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1fv(target, v); +} + +void gl4_0compat_glMultiTexCoord1f(void *_glfuncs, GLenum target, GLfloat s) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1f(target, s); +} + +void gl4_0compat_glMultiTexCoord1dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1dv(target, v); +} + +void gl4_0compat_glMultiTexCoord1d(void *_glfuncs, GLenum target, GLdouble s) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1d(target, s); +} + +void gl4_0compat_glClientActiveTexture(void *_glfuncs, GLenum texture) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClientActiveTexture(texture); +} + +void gl4_0compat_glWindowPos3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3sv(v); +} + +void gl4_0compat_glWindowPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3s(x, y, z); +} + +void gl4_0compat_glWindowPos3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3iv(v); +} + +void gl4_0compat_glWindowPos3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3i(x, y, z); +} + +void gl4_0compat_glWindowPos3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3fv(v); +} + +void gl4_0compat_glWindowPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3f(x, y, z); +} + +void gl4_0compat_glWindowPos3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3dv(v); +} + +void gl4_0compat_glWindowPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3d(x, y, z); +} + +void gl4_0compat_glWindowPos2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2sv(v); +} + +void gl4_0compat_glWindowPos2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2s(x, y); +} + +void gl4_0compat_glWindowPos2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2iv(v); +} + +void gl4_0compat_glWindowPos2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2i(x, y); +} + +void gl4_0compat_glWindowPos2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2fv(v); +} + +void gl4_0compat_glWindowPos2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2f(x, y); +} + +void gl4_0compat_glWindowPos2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2dv(v); +} + +void gl4_0compat_glWindowPos2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2d(x, y); +} + +void gl4_0compat_glSecondaryColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColorPointer(size, gltype, stride, pointer); +} + +void gl4_0compat_glSecondaryColor3usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3usv(v); +} + +void gl4_0compat_glSecondaryColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3us(red, green, blue); +} + +void gl4_0compat_glSecondaryColor3uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3uiv(v); +} + +void gl4_0compat_glSecondaryColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3ui(red, green, blue); +} + +void gl4_0compat_glSecondaryColor3ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3ubv(v); +} + +void gl4_0compat_glSecondaryColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3ub(red, green, blue); +} + +void gl4_0compat_glSecondaryColor3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3sv(v); +} + +void gl4_0compat_glSecondaryColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3s(red, green, blue); +} + +void gl4_0compat_glSecondaryColor3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3iv(v); +} + +void gl4_0compat_glSecondaryColor3i(void *_glfuncs, GLint red, GLint green, GLint blue) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3i(red, green, blue); +} + +void gl4_0compat_glSecondaryColor3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3fv(v); +} + +void gl4_0compat_glSecondaryColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3f(red, green, blue); +} + +void gl4_0compat_glSecondaryColor3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3dv(v); +} + +void gl4_0compat_glSecondaryColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3d(red, green, blue); +} + +void gl4_0compat_glSecondaryColor3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3bv(v); +} + +void gl4_0compat_glSecondaryColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3b(red, green, blue); +} + +void gl4_0compat_glFogCoordPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordPointer(gltype, stride, pointer); +} + +void gl4_0compat_glFogCoorddv(void *_glfuncs, const GLdouble* coord) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoorddv(coord); +} + +void gl4_0compat_glFogCoordd(void *_glfuncs, GLdouble coord) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordd(coord); +} + +void gl4_0compat_glFogCoordfv(void *_glfuncs, const GLfloat* coord) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordfv(coord); +} + +void gl4_0compat_glFogCoordf(void *_glfuncs, GLfloat coord) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordf(coord); +} + +void gl4_0compat_glVertexAttrib4usv(void *_glfuncs, GLuint index, const GLushort* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4usv(index, v); +} + +void gl4_0compat_glVertexAttrib4uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4uiv(index, v); +} + +void gl4_0compat_glVertexAttrib4ubv(void *_glfuncs, GLuint index, const GLubyte* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4ubv(index, v); +} + +void gl4_0compat_glVertexAttrib4sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4sv(index, v); +} + +void gl4_0compat_glVertexAttrib4s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4s(index, x, y, z, w); +} + +void gl4_0compat_glVertexAttrib4iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4iv(index, v); +} + +void gl4_0compat_glVertexAttrib4fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4fv(index, v); +} + +void gl4_0compat_glVertexAttrib4f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4f(index, x, y, z, w); +} + +void gl4_0compat_glVertexAttrib4dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4dv(index, v); +} + +void gl4_0compat_glVertexAttrib4d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4d(index, x, y, z, w); +} + +void gl4_0compat_glVertexAttrib4bv(void *_glfuncs, GLuint index, const GLbyte* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4bv(index, v); +} + +void gl4_0compat_glVertexAttrib4Nusv(void *_glfuncs, GLuint index, const GLushort* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nusv(index, v); +} + +void gl4_0compat_glVertexAttrib4Nuiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nuiv(index, v); +} + +void gl4_0compat_glVertexAttrib4Nubv(void *_glfuncs, GLuint index, const GLubyte* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nubv(index, v); +} + +void gl4_0compat_glVertexAttrib4Nub(void *_glfuncs, GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nub(index, x, y, z, w); +} + +void gl4_0compat_glVertexAttrib4Nsv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nsv(index, v); +} + +void gl4_0compat_glVertexAttrib4Niv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Niv(index, v); +} + +void gl4_0compat_glVertexAttrib4Nbv(void *_glfuncs, GLuint index, const GLbyte* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nbv(index, v); +} + +void gl4_0compat_glVertexAttrib3sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3sv(index, v); +} + +void gl4_0compat_glVertexAttrib3s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3s(index, x, y, z); +} + +void gl4_0compat_glVertexAttrib3fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3fv(index, v); +} + +void gl4_0compat_glVertexAttrib3f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3f(index, x, y, z); +} + +void gl4_0compat_glVertexAttrib3dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3dv(index, v); +} + +void gl4_0compat_glVertexAttrib3d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3d(index, x, y, z); +} + +void gl4_0compat_glVertexAttrib2sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2sv(index, v); +} + +void gl4_0compat_glVertexAttrib2s(void *_glfuncs, GLuint index, GLshort x, GLshort y) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2s(index, x, y); +} + +void gl4_0compat_glVertexAttrib2fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2fv(index, v); +} + +void gl4_0compat_glVertexAttrib2f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2f(index, x, y); +} + +void gl4_0compat_glVertexAttrib2dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2dv(index, v); +} + +void gl4_0compat_glVertexAttrib2d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2d(index, x, y); +} + +void gl4_0compat_glVertexAttrib1sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1sv(index, v); +} + +void gl4_0compat_glVertexAttrib1s(void *_glfuncs, GLuint index, GLshort x) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1s(index, x); +} + +void gl4_0compat_glVertexAttrib1fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1fv(index, v); +} + +void gl4_0compat_glVertexAttrib1f(void *_glfuncs, GLuint index, GLfloat x) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1f(index, x); +} + +void gl4_0compat_glVertexAttrib1dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1dv(index, v); +} + +void gl4_0compat_glVertexAttrib1d(void *_glfuncs, GLuint index, GLdouble x) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1d(index, x); +} + +void gl4_0compat_glVertexAttribI4usv(void *_glfuncs, GLuint index, const GLushort* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4usv(index, v); +} + +void gl4_0compat_glVertexAttribI4ubv(void *_glfuncs, GLuint index, const GLubyte* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4ubv(index, v); +} + +void gl4_0compat_glVertexAttribI4sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4sv(index, v); +} + +void gl4_0compat_glVertexAttribI4bv(void *_glfuncs, GLuint index, const GLbyte* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4bv(index, v); +} + +void gl4_0compat_glVertexAttribI4uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4uiv(index, v); +} + +void gl4_0compat_glVertexAttribI3uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI3uiv(index, v); +} + +void gl4_0compat_glVertexAttribI2uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI2uiv(index, v); +} + +void gl4_0compat_glVertexAttribI1uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI1uiv(index, v); +} + +void gl4_0compat_glVertexAttribI4iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4iv(index, v); +} + +void gl4_0compat_glVertexAttribI3iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI3iv(index, v); +} + +void gl4_0compat_glVertexAttribI2iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI2iv(index, v); +} + +void gl4_0compat_glVertexAttribI1iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI1iv(index, v); +} + +void gl4_0compat_glVertexAttribI4ui(void *_glfuncs, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4ui(index, x, y, z, w); +} + +void gl4_0compat_glVertexAttribI3ui(void *_glfuncs, GLuint index, GLuint x, GLuint y, GLuint z) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI3ui(index, x, y, z); +} + +void gl4_0compat_glVertexAttribI2ui(void *_glfuncs, GLuint index, GLuint x, GLuint y) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI2ui(index, x, y); +} + +void gl4_0compat_glVertexAttribI1ui(void *_glfuncs, GLuint index, GLuint x) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI1ui(index, x); +} + +void gl4_0compat_glVertexAttribI4i(void *_glfuncs, GLuint index, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4i(index, x, y, z, w); +} + +void gl4_0compat_glVertexAttribI3i(void *_glfuncs, GLuint index, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI3i(index, x, y, z); +} + +void gl4_0compat_glVertexAttribI2i(void *_glfuncs, GLuint index, GLint x, GLint y) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI2i(index, x, y); +} + +void gl4_0compat_glVertexAttribI1i(void *_glfuncs, GLuint index, GLint x) +{ + QOpenGLFunctions_4_0_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI1i(index, x); +} + diff --git a/gl/4.0compat/funcs.h b/gl/4.0compat/funcs.h new file mode 100644 index 00000000..e556b735 --- /dev/null +++ b/gl/4.0compat/funcs.h @@ -0,0 +1,833 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#ifndef __cplusplus +#include +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef char GLchar; +typedef signed char GLbyte; /* 1-byte signed */ +typedef short GLshort; /* 2-byte signed */ +typedef int GLint; /* 4-byte signed */ +typedef unsigned char GLubyte; /* 1-byte unsigned */ +typedef unsigned short GLushort; /* 2-byte unsigned */ +typedef unsigned int GLuint; /* 4-byte unsigned */ +typedef int GLsizei; /* 4-byte signed */ +typedef float GLfloat; /* single precision float */ +typedef float GLclampf; /* single precision float in [0,1] */ +typedef double GLdouble; /* double precision float */ +typedef double GLclampd; /* double precision float in [0,1] */ +typedef int64_t GLint64; +typedef uint64_t GLuint64; +typedef ptrdiff_t GLintptr; +typedef ptrdiff_t GLsizeiptr; +typedef ptrdiff_t GLintptrARB; +typedef ptrdiff_t GLsizeiptrARB; +typedef struct __GLsync *GLsync; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +void *gl4_0compat_funcs(); + +void gl4_0compat_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_0compat_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal); +GLboolean gl4_0compat_glIsEnabled(void *_glfuncs, GLenum cap); +void gl4_0compat_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params); +void gl4_0compat_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params); +void gl4_0compat_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_0compat_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl4_0compat_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels); +void gl4_0compat_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params); +void gl4_0compat_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params); +GLenum gl4_0compat_glGetError(void *_glfuncs); +void gl4_0compat_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params); +void gl4_0compat_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params); +void gl4_0compat_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels); +void gl4_0compat_glReadBuffer(void *_glfuncs, GLenum mode); +void gl4_0compat_glPixelStorei(void *_glfuncs, GLenum pname, GLint param); +void gl4_0compat_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param); +void gl4_0compat_glDepthFunc(void *_glfuncs, GLenum glfunc); +void gl4_0compat_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass); +void gl4_0compat_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask); +void gl4_0compat_glLogicOp(void *_glfuncs, GLenum opcode); +void gl4_0compat_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor); +void gl4_0compat_glFlush(void *_glfuncs); +void gl4_0compat_glFinish(void *_glfuncs); +void gl4_0compat_glEnable(void *_glfuncs, GLenum cap); +void gl4_0compat_glDisable(void *_glfuncs, GLenum cap); +void gl4_0compat_glDepthMask(void *_glfuncs, GLboolean flag); +void gl4_0compat_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +void gl4_0compat_glStencilMask(void *_glfuncs, GLuint mask); +void gl4_0compat_glClearDepth(void *_glfuncs, GLdouble depth); +void gl4_0compat_glClearStencil(void *_glfuncs, GLint s); +void gl4_0compat_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl4_0compat_glClear(void *_glfuncs, GLbitfield mask); +void gl4_0compat_glDrawBuffer(void *_glfuncs, GLenum mode); +void gl4_0compat_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_0compat_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_0compat_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl4_0compat_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl4_0compat_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl4_0compat_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl4_0compat_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_0compat_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode); +void gl4_0compat_glPointSize(void *_glfuncs, GLfloat size); +void gl4_0compat_glLineWidth(void *_glfuncs, GLfloat width); +void gl4_0compat_glHint(void *_glfuncs, GLenum target, GLenum mode); +void gl4_0compat_glFrontFace(void *_glfuncs, GLenum mode); +void gl4_0compat_glCullFace(void *_glfuncs, GLenum mode); +void gl4_0compat_glIndexubv(void *_glfuncs, const GLubyte* c); +void gl4_0compat_glIndexub(void *_glfuncs, GLubyte c); +GLboolean gl4_0compat_glIsTexture(void *_glfuncs, GLuint texture); +void gl4_0compat_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures); +void gl4_0compat_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures); +void gl4_0compat_glBindTexture(void *_glfuncs, GLenum target, GLuint texture); +void gl4_0compat_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_0compat_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_0compat_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_0compat_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +void gl4_0compat_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +void gl4_0compat_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border); +void gl4_0compat_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units); +void gl4_0compat_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl4_0compat_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count); +void gl4_0compat_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_0compat_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_0compat_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_0compat_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl4_0compat_glBlendEquation(void *_glfuncs, GLenum mode); +void gl4_0compat_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl4_0compat_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img); +void gl4_0compat_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl4_0compat_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl4_0compat_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl4_0compat_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data); +void gl4_0compat_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data); +void gl4_0compat_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data); +void gl4_0compat_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert); +void gl4_0compat_glActiveTexture(void *_glfuncs, GLenum texture); +void gl4_0compat_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params); +void gl4_0compat_glPointParameteri(void *_glfuncs, GLenum pname, GLint param); +void gl4_0compat_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl4_0compat_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param); +void gl4_0compat_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount); +void gl4_0compat_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +void gl4_0compat_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +GLboolean gl4_0compat_glUnmapBuffer(void *_glfuncs, GLenum target); +void gl4_0compat_glGetBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data); +void gl4_0compat_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data); +void gl4_0compat_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage); +GLboolean gl4_0compat_glIsBuffer(void *_glfuncs, GLuint buffer); +void gl4_0compat_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers); +void gl4_0compat_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers); +void gl4_0compat_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer); +void gl4_0compat_glGetQueryObjectuiv(void *_glfuncs, GLuint id, GLenum pname, GLuint* params); +void gl4_0compat_glGetQueryObjectiv(void *_glfuncs, GLuint id, GLenum pname, GLint* params); +void gl4_0compat_glGetQueryiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_0compat_glEndQuery(void *_glfuncs, GLenum target); +void gl4_0compat_glBeginQuery(void *_glfuncs, GLenum target, GLuint id); +GLboolean gl4_0compat_glIsQuery(void *_glfuncs, GLuint id); +void gl4_0compat_glDeleteQueries(void *_glfuncs, GLsizei n, const GLuint* ids); +void gl4_0compat_glGenQueries(void *_glfuncs, GLsizei n, GLuint* ids); +void gl4_0compat_glVertexAttribPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLboolean normalized, GLsizei stride, const GLvoid* offset); +void gl4_0compat_glValidateProgram(void *_glfuncs, GLuint program); +void gl4_0compat_glUniformMatrix4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_0compat_glUniformMatrix3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_0compat_glUniformMatrix2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_0compat_glUniform4iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl4_0compat_glUniform3iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl4_0compat_glUniform2iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl4_0compat_glUniform1iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl4_0compat_glUniform4fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl4_0compat_glUniform3fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl4_0compat_glUniform2fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl4_0compat_glUniform1fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl4_0compat_glUniform4i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +void gl4_0compat_glUniform3i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2); +void gl4_0compat_glUniform2i(void *_glfuncs, GLint location, GLint v0, GLint v1); +void gl4_0compat_glUniform1i(void *_glfuncs, GLint location, GLint v0); +void gl4_0compat_glUniform4f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +void gl4_0compat_glUniform3f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +void gl4_0compat_glUniform2f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1); +void gl4_0compat_glUniform1f(void *_glfuncs, GLint location, GLfloat v0); +void gl4_0compat_glUseProgram(void *_glfuncs, GLuint program); +void gl4_0compat_glShaderSource(void *_glfuncs, GLuint shader, GLsizei count, const GLchar** source, const GLint* length); +void gl4_0compat_glLinkProgram(void *_glfuncs, GLuint program); +GLboolean gl4_0compat_glIsShader(void *_glfuncs, GLuint shader); +GLboolean gl4_0compat_glIsProgram(void *_glfuncs, GLuint program); +void gl4_0compat_glGetVertexAttribiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params); +void gl4_0compat_glGetVertexAttribfv(void *_glfuncs, GLuint index, GLenum pname, GLfloat* params); +void gl4_0compat_glGetVertexAttribdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params); +void gl4_0compat_glGetUniformiv(void *_glfuncs, GLuint program, GLint location, GLint* params); +void gl4_0compat_glGetUniformfv(void *_glfuncs, GLuint program, GLint location, GLfloat* params); +GLint gl4_0compat_glGetUniformLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl4_0compat_glGetShaderSource(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source); +void gl4_0compat_glGetShaderInfoLog(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl4_0compat_glGetShaderiv(void *_glfuncs, GLuint shader, GLenum pname, GLint* params); +void gl4_0compat_glGetProgramInfoLog(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl4_0compat_glGetProgramiv(void *_glfuncs, GLuint program, GLenum pname, GLint* params); +GLint gl4_0compat_glGetAttribLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl4_0compat_glGetAttachedShaders(void *_glfuncs, GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj); +void gl4_0compat_glGetActiveUniform(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name); +void gl4_0compat_glGetActiveAttrib(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name); +void gl4_0compat_glEnableVertexAttribArray(void *_glfuncs, GLuint index); +void gl4_0compat_glDisableVertexAttribArray(void *_glfuncs, GLuint index); +void gl4_0compat_glDetachShader(void *_glfuncs, GLuint program, GLuint shader); +void gl4_0compat_glDeleteShader(void *_glfuncs, GLuint shader); +void gl4_0compat_glDeleteProgram(void *_glfuncs, GLuint program); +GLuint gl4_0compat_glCreateShader(void *_glfuncs, GLenum gltype); +GLuint gl4_0compat_glCreateProgram(void *_glfuncs); +void gl4_0compat_glCompileShader(void *_glfuncs, GLuint shader); +void gl4_0compat_glBindAttribLocation(void *_glfuncs, GLuint program, GLuint index, const GLchar* name); +void gl4_0compat_glAttachShader(void *_glfuncs, GLuint program, GLuint shader); +void gl4_0compat_glStencilMaskSeparate(void *_glfuncs, GLenum face, GLuint mask); +void gl4_0compat_glStencilFuncSeparate(void *_glfuncs, GLenum face, GLenum glfunc, GLint ref, GLuint mask); +void gl4_0compat_glStencilOpSeparate(void *_glfuncs, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +void gl4_0compat_glDrawBuffers(void *_glfuncs, GLsizei n, const GLenum* bufs); +void gl4_0compat_glBlendEquationSeparate(void *_glfuncs, GLenum modeRGB, GLenum modeAlpha); +void gl4_0compat_glUniformMatrix4x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_0compat_glUniformMatrix3x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_0compat_glUniformMatrix4x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_0compat_glUniformMatrix2x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_0compat_glUniformMatrix3x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_0compat_glUniformMatrix2x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +GLboolean gl4_0compat_glIsVertexArray(void *_glfuncs, GLuint array); +void gl4_0compat_glGenVertexArrays(void *_glfuncs, GLsizei n, GLuint* arrays); +void gl4_0compat_glDeleteVertexArrays(void *_glfuncs, GLsizei n, const GLuint* arrays); +void gl4_0compat_glBindVertexArray(void *_glfuncs, GLuint array); +void gl4_0compat_glFlushMappedBufferRange(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr length); +void gl4_0compat_glFramebufferTextureLayer(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +void gl4_0compat_glRenderbufferStorageMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height); +void gl4_0compat_glBlitFramebuffer(void *_glfuncs, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +void gl4_0compat_glGenerateMipmap(void *_glfuncs, GLenum target); +void gl4_0compat_glGetFramebufferAttachmentParameteriv(void *_glfuncs, GLenum target, GLenum attachment, GLenum pname, GLint* params); +void gl4_0compat_glFramebufferRenderbuffer(void *_glfuncs, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +void gl4_0compat_glFramebufferTexture3D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +void gl4_0compat_glFramebufferTexture2D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +void gl4_0compat_glFramebufferTexture1D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLenum gl4_0compat_glCheckFramebufferStatus(void *_glfuncs, GLenum target); +void gl4_0compat_glGenFramebuffers(void *_glfuncs, GLsizei n, GLuint* framebuffers); +void gl4_0compat_glDeleteFramebuffers(void *_glfuncs, GLsizei n, const GLuint* framebuffers); +void gl4_0compat_glBindFramebuffer(void *_glfuncs, GLenum target, GLuint framebuffer); +GLboolean gl4_0compat_glIsFramebuffer(void *_glfuncs, GLuint framebuffer); +void gl4_0compat_glGetRenderbufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_0compat_glRenderbufferStorage(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height); +void gl4_0compat_glGenRenderbuffers(void *_glfuncs, GLsizei n, GLuint* renderbuffers); +void gl4_0compat_glDeleteRenderbuffers(void *_glfuncs, GLsizei n, const GLuint* renderbuffers); +void gl4_0compat_glBindRenderbuffer(void *_glfuncs, GLenum target, GLuint renderbuffer); +GLboolean gl4_0compat_glIsRenderbuffer(void *_glfuncs, GLuint renderbuffer); +void gl4_0compat_glClearBufferfi(void *_glfuncs, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); +void gl4_0compat_glClearBufferfv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLfloat* value); +void gl4_0compat_glClearBufferuiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLuint* value); +void gl4_0compat_glClearBufferiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLint* value); +void gl4_0compat_glGetTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, GLuint* params); +void gl4_0compat_glGetTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_0compat_glTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, const GLuint* params); +void gl4_0compat_glTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl4_0compat_glUniform4uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl4_0compat_glUniform3uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl4_0compat_glUniform2uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl4_0compat_glUniform1uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl4_0compat_glUniform4ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +void gl4_0compat_glUniform3ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2); +void gl4_0compat_glUniform2ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1); +void gl4_0compat_glUniform1ui(void *_glfuncs, GLint location, GLuint v0); +GLint gl4_0compat_glGetFragDataLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl4_0compat_glBindFragDataLocation(void *_glfuncs, GLuint program, GLuint color, const GLchar* name); +void gl4_0compat_glGetUniformuiv(void *_glfuncs, GLuint program, GLint location, GLuint* params); +void gl4_0compat_glGetVertexAttribIuiv(void *_glfuncs, GLuint index, GLenum pname, GLuint* params); +void gl4_0compat_glGetVertexAttribIiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params); +void gl4_0compat_glVertexAttribIPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_0compat_glEndConditionalRender(void *_glfuncs); +void gl4_0compat_glBeginConditionalRender(void *_glfuncs, GLuint id, GLenum mode); +void gl4_0compat_glClampColor(void *_glfuncs, GLenum target, GLenum clamp); +void gl4_0compat_glGetTransformFeedbackVarying(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* gltype, GLchar* name); +void gl4_0compat_glBindBufferBase(void *_glfuncs, GLenum target, GLuint index, GLuint buffer); +void gl4_0compat_glBindBufferRange(void *_glfuncs, GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +void gl4_0compat_glEndTransformFeedback(void *_glfuncs); +void gl4_0compat_glBeginTransformFeedback(void *_glfuncs, GLenum primitiveMode); +GLboolean gl4_0compat_glIsEnabledi(void *_glfuncs, GLenum target, GLuint index); +void gl4_0compat_glDisablei(void *_glfuncs, GLenum target, GLuint index); +void gl4_0compat_glEnablei(void *_glfuncs, GLenum target, GLuint index); +void gl4_0compat_glGetIntegeri_v(void *_glfuncs, GLenum target, GLuint index, GLint* data); +void gl4_0compat_glGetBooleani_v(void *_glfuncs, GLenum target, GLuint index, GLboolean* data); +void gl4_0compat_glColorMaski(void *_glfuncs, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +void gl4_0compat_glCopyBufferSubData(void *_glfuncs, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +void gl4_0compat_glUniformBlockBinding(void *_glfuncs, GLuint program, GLuint v0, GLuint v1); +void gl4_0compat_glGetActiveUniformBlockName(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName); +void gl4_0compat_glGetActiveUniformBlockiv(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params); +GLuint gl4_0compat_glGetUniformBlockIndex(void *_glfuncs, GLuint program, const GLchar* uniformBlockName); +void gl4_0compat_glGetActiveUniformName(void *_glfuncs, GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName); +void gl4_0compat_glGetActiveUniformsiv(void *_glfuncs, GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params); +void gl4_0compat_glPrimitiveRestartIndex(void *_glfuncs, GLuint index); +void gl4_0compat_glTexBuffer(void *_glfuncs, GLenum target, GLenum internalFormat, GLuint buffer); +void gl4_0compat_glDrawElementsInstanced(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount); +void gl4_0compat_glDrawArraysInstanced(void *_glfuncs, GLenum mode, GLint first, GLsizei count, GLsizei instancecount); +void gl4_0compat_glSampleMaski(void *_glfuncs, GLuint index, GLbitfield mask); +void gl4_0compat_glGetMultisamplefv(void *_glfuncs, GLenum pname, GLuint index, GLfloat* val); +void gl4_0compat_glTexImage3DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); +void gl4_0compat_glTexImage2DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +void gl4_0compat_glGetSynciv(void *_glfuncs, GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values); +void gl4_0compat_glGetInteger64v(void *_glfuncs, GLenum pname, GLint64* params); +void gl4_0compat_glWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout); +GLenum gl4_0compat_glClientWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout); +void gl4_0compat_glDeleteSync(void *_glfuncs, GLsync sync); +GLboolean gl4_0compat_glIsSync(void *_glfuncs, GLsync sync); +GLsync gl4_0compat_glFenceSync(void *_glfuncs, GLenum condition, GLbitfield flags); +void gl4_0compat_glProvokingVertex(void *_glfuncs, GLenum mode); +void gl4_0compat_glDrawElementsInstancedBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLint basevertex); +void gl4_0compat_glDrawRangeElementsBaseVertex(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex); +void gl4_0compat_glDrawElementsBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex); +void gl4_0compat_glFramebufferTexture(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level); +void gl4_0compat_glGetBufferParameteri64v(void *_glfuncs, GLenum target, GLenum pname, GLint64* params); +void gl4_0compat_glGetInteger64i_v(void *_glfuncs, GLenum target, GLuint index, GLint64* data); +void gl4_0compat_glVertexAttribP4uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl4_0compat_glVertexAttribP4ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl4_0compat_glVertexAttribP3uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl4_0compat_glVertexAttribP3ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl4_0compat_glVertexAttribP2uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl4_0compat_glVertexAttribP2ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl4_0compat_glVertexAttribP1uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl4_0compat_glVertexAttribP1ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl4_0compat_glSecondaryColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color); +void gl4_0compat_glSecondaryColorP3ui(void *_glfuncs, GLenum gltype, GLuint color); +void gl4_0compat_glColorP4uiv(void *_glfuncs, GLenum gltype, const GLuint* color); +void gl4_0compat_glColorP4ui(void *_glfuncs, GLenum gltype, GLuint color); +void gl4_0compat_glColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color); +void gl4_0compat_glColorP3ui(void *_glfuncs, GLenum gltype, GLuint color); +void gl4_0compat_glNormalP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_0compat_glNormalP3ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_0compat_glMultiTexCoordP4uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl4_0compat_glMultiTexCoordP4ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl4_0compat_glMultiTexCoordP3uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl4_0compat_glMultiTexCoordP3ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl4_0compat_glMultiTexCoordP2uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl4_0compat_glMultiTexCoordP2ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl4_0compat_glMultiTexCoordP1uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl4_0compat_glMultiTexCoordP1ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl4_0compat_glTexCoordP4uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_0compat_glTexCoordP4ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_0compat_glTexCoordP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_0compat_glTexCoordP3ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_0compat_glTexCoordP2uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_0compat_glTexCoordP2ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_0compat_glTexCoordP1uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_0compat_glTexCoordP1ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_0compat_glVertexP4uiv(void *_glfuncs, GLenum gltype, const GLuint* value); +void gl4_0compat_glVertexP4ui(void *_glfuncs, GLenum gltype, GLuint value); +void gl4_0compat_glVertexP3uiv(void *_glfuncs, GLenum gltype, const GLuint* value); +void gl4_0compat_glVertexP3ui(void *_glfuncs, GLenum gltype, GLuint value); +void gl4_0compat_glVertexP2uiv(void *_glfuncs, GLenum gltype, const GLuint* value); +void gl4_0compat_glVertexP2ui(void *_glfuncs, GLenum gltype, GLuint value); +void gl4_0compat_glGetQueryObjectui64v(void *_glfuncs, GLuint id, GLenum pname, GLuint64* params); +void gl4_0compat_glGetQueryObjecti64v(void *_glfuncs, GLuint id, GLenum pname, GLint64* params); +void gl4_0compat_glQueryCounter(void *_glfuncs, GLuint id, GLenum target); +void gl4_0compat_glGetSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, GLuint* params); +void gl4_0compat_glGetSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat* params); +void gl4_0compat_glGetSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params); +void gl4_0compat_glGetSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params); +void gl4_0compat_glSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLuint* param); +void gl4_0compat_glSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param); +void gl4_0compat_glSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, const GLfloat* param); +void gl4_0compat_glSamplerParameterf(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat param); +void gl4_0compat_glSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param); +void gl4_0compat_glSamplerParameteri(void *_glfuncs, GLuint sampler, GLenum pname, GLint param); +void gl4_0compat_glBindSampler(void *_glfuncs, GLuint unit, GLuint sampler); +GLboolean gl4_0compat_glIsSampler(void *_glfuncs, GLuint sampler); +void gl4_0compat_glDeleteSamplers(void *_glfuncs, GLsizei count, const GLuint* samplers); +void gl4_0compat_glGenSamplers(void *_glfuncs, GLsizei count, GLuint* samplers); +GLint gl4_0compat_glGetFragDataIndex(void *_glfuncs, GLuint program, const GLchar* name); +void gl4_0compat_glBindFragDataLocationIndexed(void *_glfuncs, GLuint program, GLuint colorNumber, GLuint index, const GLchar* name); +void gl4_0compat_glVertexAttribDivisor(void *_glfuncs, GLuint index, GLuint divisor); +void gl4_0compat_glGetQueryIndexediv(void *_glfuncs, GLenum target, GLuint index, GLenum pname, GLint* params); +void gl4_0compat_glEndQueryIndexed(void *_glfuncs, GLenum target, GLuint index); +void gl4_0compat_glBeginQueryIndexed(void *_glfuncs, GLenum target, GLuint index, GLuint id); +void gl4_0compat_glDrawTransformFeedbackStream(void *_glfuncs, GLenum mode, GLuint id, GLuint stream); +void gl4_0compat_glDrawTransformFeedback(void *_glfuncs, GLenum mode, GLuint id); +void gl4_0compat_glResumeTransformFeedback(void *_glfuncs); +void gl4_0compat_glPauseTransformFeedback(void *_glfuncs); +GLboolean gl4_0compat_glIsTransformFeedback(void *_glfuncs, GLuint id); +void gl4_0compat_glGenTransformFeedbacks(void *_glfuncs, GLsizei n, GLuint* ids); +void gl4_0compat_glDeleteTransformFeedbacks(void *_glfuncs, GLsizei n, const GLuint* ids); +void gl4_0compat_glBindTransformFeedback(void *_glfuncs, GLenum target, GLuint id); +void gl4_0compat_glPatchParameterfv(void *_glfuncs, GLenum pname, const GLfloat* values); +void gl4_0compat_glPatchParameteri(void *_glfuncs, GLenum pname, GLint value); +void gl4_0compat_glGetProgramStageiv(void *_glfuncs, GLuint program, GLenum shadertype, GLenum pname, GLint* values); +void gl4_0compat_glGetUniformSubroutineuiv(void *_glfuncs, GLenum shadertype, GLint location, GLuint* params); +void gl4_0compat_glUniformSubroutinesuiv(void *_glfuncs, GLenum shadertype, GLsizei count, const GLuint* value); +void gl4_0compat_glGetActiveSubroutineName(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name); +void gl4_0compat_glGetActiveSubroutineUniformName(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name); +void gl4_0compat_glGetActiveSubroutineUniformiv(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint* values); +GLuint gl4_0compat_glGetSubroutineIndex(void *_glfuncs, GLuint program, GLenum shadertype, const GLchar* name); +GLint gl4_0compat_glGetSubroutineUniformLocation(void *_glfuncs, GLuint program, GLenum shadertype, const GLchar* name); +void gl4_0compat_glGetUniformdv(void *_glfuncs, GLuint program, GLint location, GLdouble* params); +void gl4_0compat_glUniformMatrix4x3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_0compat_glUniformMatrix4x2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_0compat_glUniformMatrix3x4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_0compat_glUniformMatrix3x2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_0compat_glUniformMatrix2x4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_0compat_glUniformMatrix2x3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_0compat_glUniformMatrix4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_0compat_glUniformMatrix3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_0compat_glUniformMatrix2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_0compat_glUniform4dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value); +void gl4_0compat_glUniform3dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value); +void gl4_0compat_glUniform2dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value); +void gl4_0compat_glUniform1dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value); +void gl4_0compat_glUniform4d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3); +void gl4_0compat_glUniform3d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1, GLdouble v2); +void gl4_0compat_glUniform2d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1); +void gl4_0compat_glUniform1d(void *_glfuncs, GLint location, GLdouble v0); +void gl4_0compat_glDrawElementsIndirect(void *_glfuncs, GLenum mode, GLenum gltype, const GLvoid* indirect); +void gl4_0compat_glDrawArraysIndirect(void *_glfuncs, GLenum mode, const GLvoid* indirect); +void gl4_0compat_glBlendFuncSeparatei(void *_glfuncs, GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); +void gl4_0compat_glBlendFunci(void *_glfuncs, GLuint buf, GLenum src, GLenum dst); +void gl4_0compat_glBlendEquationSeparatei(void *_glfuncs, GLuint buf, GLenum modeRGB, GLenum modeAlpha); +void gl4_0compat_glBlendEquationi(void *_glfuncs, GLuint buf, GLenum mode); +void gl4_0compat_glMinSampleShading(void *_glfuncs, GLfloat value); +void gl4_0compat_glTranslatef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl4_0compat_glTranslated(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl4_0compat_glScalef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl4_0compat_glScaled(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl4_0compat_glRotatef(void *_glfuncs, GLfloat angle, GLfloat x, GLfloat y, GLfloat z); +void gl4_0compat_glRotated(void *_glfuncs, GLdouble angle, GLdouble x, GLdouble y, GLdouble z); +void gl4_0compat_glPushMatrix(void *_glfuncs); +void gl4_0compat_glPopMatrix(void *_glfuncs); +void gl4_0compat_glOrtho(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +void gl4_0compat_glMultMatrixd(void *_glfuncs, const GLdouble* m); +void gl4_0compat_glMultMatrixf(void *_glfuncs, const GLfloat* m); +void gl4_0compat_glMatrixMode(void *_glfuncs, GLenum mode); +void gl4_0compat_glLoadMatrixd(void *_glfuncs, const GLdouble* m); +void gl4_0compat_glLoadMatrixf(void *_glfuncs, const GLfloat* m); +void gl4_0compat_glLoadIdentity(void *_glfuncs); +void gl4_0compat_glFrustum(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +GLboolean gl4_0compat_glIsList(void *_glfuncs, GLuint list); +void gl4_0compat_glGetTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, GLint* params); +void gl4_0compat_glGetTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, GLfloat* params); +void gl4_0compat_glGetTexGendv(void *_glfuncs, GLenum coord, GLenum pname, GLdouble* params); +void gl4_0compat_glGetTexEnviv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_0compat_glGetTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl4_0compat_glGetPolygonStipple(void *_glfuncs, GLubyte* mask); +void gl4_0compat_glGetPixelMapusv(void *_glfuncs, GLenum glmap, GLushort* values); +void gl4_0compat_glGetPixelMapuiv(void *_glfuncs, GLenum glmap, GLuint* values); +void gl4_0compat_glGetPixelMapfv(void *_glfuncs, GLenum glmap, GLfloat* values); +void gl4_0compat_glGetMaterialiv(void *_glfuncs, GLenum face, GLenum pname, GLint* params); +void gl4_0compat_glGetMaterialfv(void *_glfuncs, GLenum face, GLenum pname, GLfloat* params); +void gl4_0compat_glGetMapiv(void *_glfuncs, GLenum target, GLenum query, GLint* v); +void gl4_0compat_glGetMapfv(void *_glfuncs, GLenum target, GLenum query, GLfloat* v); +void gl4_0compat_glGetMapdv(void *_glfuncs, GLenum target, GLenum query, GLdouble* v); +void gl4_0compat_glGetLightiv(void *_glfuncs, GLenum light, GLenum pname, GLint* params); +void gl4_0compat_glGetLightfv(void *_glfuncs, GLenum light, GLenum pname, GLfloat* params); +void gl4_0compat_glGetClipPlane(void *_glfuncs, GLenum plane, GLdouble* equation); +void gl4_0compat_glDrawPixels(void *_glfuncs, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_0compat_glCopyPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum gltype); +void gl4_0compat_glPixelMapusv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLushort* values); +void gl4_0compat_glPixelMapuiv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLuint* values); +void gl4_0compat_glPixelMapfv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLfloat* values); +void gl4_0compat_glPixelTransferi(void *_glfuncs, GLenum pname, GLint param); +void gl4_0compat_glPixelTransferf(void *_glfuncs, GLenum pname, GLfloat param); +void gl4_0compat_glPixelZoom(void *_glfuncs, GLfloat xfactor, GLfloat yfactor); +void gl4_0compat_glAlphaFunc(void *_glfuncs, GLenum glfunc, GLfloat ref); +void gl4_0compat_glEvalPoint2(void *_glfuncs, GLint i, GLint j); +void gl4_0compat_glEvalMesh2(void *_glfuncs, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); +void gl4_0compat_glEvalPoint1(void *_glfuncs, GLint i); +void gl4_0compat_glEvalMesh1(void *_glfuncs, GLenum mode, GLint i1, GLint i2); +void gl4_0compat_glEvalCoord2fv(void *_glfuncs, const GLfloat* u); +void gl4_0compat_glEvalCoord2f(void *_glfuncs, GLfloat u, GLfloat v); +void gl4_0compat_glEvalCoord2dv(void *_glfuncs, const GLdouble* u); +void gl4_0compat_glEvalCoord2d(void *_glfuncs, GLdouble u, GLdouble v); +void gl4_0compat_glEvalCoord1fv(void *_glfuncs, const GLfloat* u); +void gl4_0compat_glEvalCoord1f(void *_glfuncs, GLfloat u); +void gl4_0compat_glEvalCoord1dv(void *_glfuncs, const GLdouble* u); +void gl4_0compat_glEvalCoord1d(void *_glfuncs, GLdouble u); +void gl4_0compat_glMapGrid2f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); +void gl4_0compat_glMapGrid2d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); +void gl4_0compat_glMapGrid1f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2); +void gl4_0compat_glMapGrid1d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2); +void gl4_0compat_glMap2f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points); +void gl4_0compat_glMap2d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points); +void gl4_0compat_glMap1f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points); +void gl4_0compat_glMap1d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points); +void gl4_0compat_glPushAttrib(void *_glfuncs, GLbitfield mask); +void gl4_0compat_glPopAttrib(void *_glfuncs); +void gl4_0compat_glAccum(void *_glfuncs, GLenum op, GLfloat value); +void gl4_0compat_glIndexMask(void *_glfuncs, GLuint mask); +void gl4_0compat_glClearIndex(void *_glfuncs, GLfloat c); +void gl4_0compat_glClearAccum(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl4_0compat_glPushName(void *_glfuncs, GLuint name); +void gl4_0compat_glPopName(void *_glfuncs); +void gl4_0compat_glPassThrough(void *_glfuncs, GLfloat token); +void gl4_0compat_glLoadName(void *_glfuncs, GLuint name); +void gl4_0compat_glInitNames(void *_glfuncs); +GLint gl4_0compat_glRenderMode(void *_glfuncs, GLenum mode); +void gl4_0compat_glSelectBuffer(void *_glfuncs, GLsizei size, GLuint* buffer); +void gl4_0compat_glFeedbackBuffer(void *_glfuncs, GLsizei size, GLenum gltype, GLfloat* buffer); +void gl4_0compat_glTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, const GLint* params); +void gl4_0compat_glTexGeni(void *_glfuncs, GLenum coord, GLenum pname, GLint param); +void gl4_0compat_glTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, const GLfloat* params); +void gl4_0compat_glTexGenf(void *_glfuncs, GLenum coord, GLenum pname, GLfloat param); +void gl4_0compat_glTexGendv(void *_glfuncs, GLenum coord, GLenum pname, const GLdouble* params); +void gl4_0compat_glTexGend(void *_glfuncs, GLenum coord, GLenum pname, GLdouble param); +void gl4_0compat_glTexEnviv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl4_0compat_glTexEnvi(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl4_0compat_glTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl4_0compat_glTexEnvf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl4_0compat_glShadeModel(void *_glfuncs, GLenum mode); +void gl4_0compat_glPolygonStipple(void *_glfuncs, const GLubyte* mask); +void gl4_0compat_glMaterialiv(void *_glfuncs, GLenum face, GLenum pname, const GLint* params); +void gl4_0compat_glMateriali(void *_glfuncs, GLenum face, GLenum pname, GLint param); +void gl4_0compat_glMaterialfv(void *_glfuncs, GLenum face, GLenum pname, const GLfloat* params); +void gl4_0compat_glMaterialf(void *_glfuncs, GLenum face, GLenum pname, GLfloat param); +void gl4_0compat_glLineStipple(void *_glfuncs, GLint factor, GLushort pattern); +void gl4_0compat_glLightModeliv(void *_glfuncs, GLenum pname, const GLint* params); +void gl4_0compat_glLightModeli(void *_glfuncs, GLenum pname, GLint param); +void gl4_0compat_glLightModelfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl4_0compat_glLightModelf(void *_glfuncs, GLenum pname, GLfloat param); +void gl4_0compat_glLightiv(void *_glfuncs, GLenum light, GLenum pname, const GLint* params); +void gl4_0compat_glLighti(void *_glfuncs, GLenum light, GLenum pname, GLint param); +void gl4_0compat_glLightfv(void *_glfuncs, GLenum light, GLenum pname, const GLfloat* params); +void gl4_0compat_glLightf(void *_glfuncs, GLenum light, GLenum pname, GLfloat param); +void gl4_0compat_glFogiv(void *_glfuncs, GLenum pname, const GLint* params); +void gl4_0compat_glFogi(void *_glfuncs, GLenum pname, GLint param); +void gl4_0compat_glFogfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl4_0compat_glFogf(void *_glfuncs, GLenum pname, GLfloat param); +void gl4_0compat_glColorMaterial(void *_glfuncs, GLenum face, GLenum mode); +void gl4_0compat_glClipPlane(void *_glfuncs, GLenum plane, const GLdouble* equation); +void gl4_0compat_glVertex4sv(void *_glfuncs, const GLshort* v); +void gl4_0compat_glVertex4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w); +void gl4_0compat_glVertex4iv(void *_glfuncs, const GLint* v); +void gl4_0compat_glVertex4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w); +void gl4_0compat_glVertex4fv(void *_glfuncs, const GLfloat* v); +void gl4_0compat_glVertex4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl4_0compat_glVertex4dv(void *_glfuncs, const GLdouble* v); +void gl4_0compat_glVertex4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl4_0compat_glVertex3sv(void *_glfuncs, const GLshort* v); +void gl4_0compat_glVertex3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl4_0compat_glVertex3iv(void *_glfuncs, const GLint* v); +void gl4_0compat_glVertex3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl4_0compat_glVertex3fv(void *_glfuncs, const GLfloat* v); +void gl4_0compat_glVertex3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl4_0compat_glVertex3dv(void *_glfuncs, const GLdouble* v); +void gl4_0compat_glVertex3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl4_0compat_glVertex2sv(void *_glfuncs, const GLshort* v); +void gl4_0compat_glVertex2s(void *_glfuncs, GLshort x, GLshort y); +void gl4_0compat_glVertex2iv(void *_glfuncs, const GLint* v); +void gl4_0compat_glVertex2i(void *_glfuncs, GLint x, GLint y); +void gl4_0compat_glVertex2fv(void *_glfuncs, const GLfloat* v); +void gl4_0compat_glVertex2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl4_0compat_glVertex2dv(void *_glfuncs, const GLdouble* v); +void gl4_0compat_glVertex2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl4_0compat_glTexCoord4sv(void *_glfuncs, const GLshort* v); +void gl4_0compat_glTexCoord4s(void *_glfuncs, GLshort s, GLshort t, GLshort r, GLshort q); +void gl4_0compat_glTexCoord4iv(void *_glfuncs, const GLint* v); +void gl4_0compat_glTexCoord4i(void *_glfuncs, GLint s, GLint t, GLint r, GLint q); +void gl4_0compat_glTexCoord4fv(void *_glfuncs, const GLfloat* v); +void gl4_0compat_glTexCoord4f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +void gl4_0compat_glTexCoord4dv(void *_glfuncs, const GLdouble* v); +void gl4_0compat_glTexCoord4d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +void gl4_0compat_glTexCoord3sv(void *_glfuncs, const GLshort* v); +void gl4_0compat_glTexCoord3s(void *_glfuncs, GLshort s, GLshort t, GLshort r); +void gl4_0compat_glTexCoord3iv(void *_glfuncs, const GLint* v); +void gl4_0compat_glTexCoord3i(void *_glfuncs, GLint s, GLint t, GLint r); +void gl4_0compat_glTexCoord3fv(void *_glfuncs, const GLfloat* v); +void gl4_0compat_glTexCoord3f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r); +void gl4_0compat_glTexCoord3dv(void *_glfuncs, const GLdouble* v); +void gl4_0compat_glTexCoord3d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r); +void gl4_0compat_glTexCoord2sv(void *_glfuncs, const GLshort* v); +void gl4_0compat_glTexCoord2s(void *_glfuncs, GLshort s, GLshort t); +void gl4_0compat_glTexCoord2iv(void *_glfuncs, const GLint* v); +void gl4_0compat_glTexCoord2i(void *_glfuncs, GLint s, GLint t); +void gl4_0compat_glTexCoord2fv(void *_glfuncs, const GLfloat* v); +void gl4_0compat_glTexCoord2f(void *_glfuncs, GLfloat s, GLfloat t); +void gl4_0compat_glTexCoord2dv(void *_glfuncs, const GLdouble* v); +void gl4_0compat_glTexCoord2d(void *_glfuncs, GLdouble s, GLdouble t); +void gl4_0compat_glTexCoord1sv(void *_glfuncs, const GLshort* v); +void gl4_0compat_glTexCoord1s(void *_glfuncs, GLshort s); +void gl4_0compat_glTexCoord1iv(void *_glfuncs, const GLint* v); +void gl4_0compat_glTexCoord1i(void *_glfuncs, GLint s); +void gl4_0compat_glTexCoord1fv(void *_glfuncs, const GLfloat* v); +void gl4_0compat_glTexCoord1f(void *_glfuncs, GLfloat s); +void gl4_0compat_glTexCoord1dv(void *_glfuncs, const GLdouble* v); +void gl4_0compat_glTexCoord1d(void *_glfuncs, GLdouble s); +void gl4_0compat_glRectsv(void *_glfuncs, const GLshort* v1, const GLshort* v2); +void gl4_0compat_glRects(void *_glfuncs, GLshort x1, GLshort y1, GLshort x2, GLshort y2); +void gl4_0compat_glRectiv(void *_glfuncs, const GLint* v1, const GLint* v2); +void gl4_0compat_glRecti(void *_glfuncs, GLint x1, GLint y1, GLint x2, GLint y2); +void gl4_0compat_glRectfv(void *_glfuncs, const GLfloat* v1, const GLfloat* v2); +void gl4_0compat_glRectf(void *_glfuncs, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); +void gl4_0compat_glRectdv(void *_glfuncs, const GLdouble* v1, const GLdouble* v2); +void gl4_0compat_glRectd(void *_glfuncs, GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); +void gl4_0compat_glRasterPos4sv(void *_glfuncs, const GLshort* v); +void gl4_0compat_glRasterPos4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w); +void gl4_0compat_glRasterPos4iv(void *_glfuncs, const GLint* v); +void gl4_0compat_glRasterPos4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w); +void gl4_0compat_glRasterPos4fv(void *_glfuncs, const GLfloat* v); +void gl4_0compat_glRasterPos4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl4_0compat_glRasterPos4dv(void *_glfuncs, const GLdouble* v); +void gl4_0compat_glRasterPos4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl4_0compat_glRasterPos3sv(void *_glfuncs, const GLshort* v); +void gl4_0compat_glRasterPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl4_0compat_glRasterPos3iv(void *_glfuncs, const GLint* v); +void gl4_0compat_glRasterPos3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl4_0compat_glRasterPos3fv(void *_glfuncs, const GLfloat* v); +void gl4_0compat_glRasterPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl4_0compat_glRasterPos3dv(void *_glfuncs, const GLdouble* v); +void gl4_0compat_glRasterPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl4_0compat_glRasterPos2sv(void *_glfuncs, const GLshort* v); +void gl4_0compat_glRasterPos2s(void *_glfuncs, GLshort x, GLshort y); +void gl4_0compat_glRasterPos2iv(void *_glfuncs, const GLint* v); +void gl4_0compat_glRasterPos2i(void *_glfuncs, GLint x, GLint y); +void gl4_0compat_glRasterPos2fv(void *_glfuncs, const GLfloat* v); +void gl4_0compat_glRasterPos2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl4_0compat_glRasterPos2dv(void *_glfuncs, const GLdouble* v); +void gl4_0compat_glRasterPos2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl4_0compat_glNormal3sv(void *_glfuncs, const GLshort* v); +void gl4_0compat_glNormal3s(void *_glfuncs, GLshort nx, GLshort ny, GLshort nz); +void gl4_0compat_glNormal3iv(void *_glfuncs, const GLint* v); +void gl4_0compat_glNormal3i(void *_glfuncs, GLint nx, GLint ny, GLint nz); +void gl4_0compat_glNormal3fv(void *_glfuncs, const GLfloat* v); +void gl4_0compat_glNormal3f(void *_glfuncs, GLfloat nx, GLfloat ny, GLfloat nz); +void gl4_0compat_glNormal3dv(void *_glfuncs, const GLdouble* v); +void gl4_0compat_glNormal3d(void *_glfuncs, GLdouble nx, GLdouble ny, GLdouble nz); +void gl4_0compat_glNormal3bv(void *_glfuncs, const GLbyte* v); +void gl4_0compat_glNormal3b(void *_glfuncs, GLbyte nx, GLbyte ny, GLbyte nz); +void gl4_0compat_glIndexsv(void *_glfuncs, const GLshort* c); +void gl4_0compat_glIndexs(void *_glfuncs, GLshort c); +void gl4_0compat_glIndexiv(void *_glfuncs, const GLint* c); +void gl4_0compat_glIndexi(void *_glfuncs, GLint c); +void gl4_0compat_glIndexfv(void *_glfuncs, const GLfloat* c); +void gl4_0compat_glIndexf(void *_glfuncs, GLfloat c); +void gl4_0compat_glIndexdv(void *_glfuncs, const GLdouble* c); +void gl4_0compat_glIndexd(void *_glfuncs, GLdouble c); +void gl4_0compat_glEnd(void *_glfuncs); +void gl4_0compat_glEdgeFlagv(void *_glfuncs, const GLboolean* flag); +void gl4_0compat_glEdgeFlag(void *_glfuncs, GLboolean flag); +void gl4_0compat_glColor4usv(void *_glfuncs, const GLushort* v); +void gl4_0compat_glColor4us(void *_glfuncs, GLushort red, GLushort green, GLushort blue, GLushort alpha); +void gl4_0compat_glColor4uiv(void *_glfuncs, const GLuint* v); +void gl4_0compat_glColor4ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue, GLuint alpha); +void gl4_0compat_glColor4ubv(void *_glfuncs, const GLubyte* v); +void gl4_0compat_glColor4ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); +void gl4_0compat_glColor4sv(void *_glfuncs, const GLshort* v); +void gl4_0compat_glColor4s(void *_glfuncs, GLshort red, GLshort green, GLshort blue, GLshort alpha); +void gl4_0compat_glColor4iv(void *_glfuncs, const GLint* v); +void gl4_0compat_glColor4i(void *_glfuncs, GLint red, GLint green, GLint blue, GLint alpha); +void gl4_0compat_glColor4fv(void *_glfuncs, const GLfloat* v); +void gl4_0compat_glColor4f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl4_0compat_glColor4dv(void *_glfuncs, const GLdouble* v); +void gl4_0compat_glColor4d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); +void gl4_0compat_glColor4bv(void *_glfuncs, const GLbyte* v); +void gl4_0compat_glColor4b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); +void gl4_0compat_glColor3usv(void *_glfuncs, const GLushort* v); +void gl4_0compat_glColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue); +void gl4_0compat_glColor3uiv(void *_glfuncs, const GLuint* v); +void gl4_0compat_glColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue); +void gl4_0compat_glColor3ubv(void *_glfuncs, const GLubyte* v); +void gl4_0compat_glColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue); +void gl4_0compat_glColor3sv(void *_glfuncs, const GLshort* v); +void gl4_0compat_glColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue); +void gl4_0compat_glColor3iv(void *_glfuncs, const GLint* v); +void gl4_0compat_glColor3i(void *_glfuncs, GLint red, GLint green, GLint blue); +void gl4_0compat_glColor3fv(void *_glfuncs, const GLfloat* v); +void gl4_0compat_glColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue); +void gl4_0compat_glColor3dv(void *_glfuncs, const GLdouble* v); +void gl4_0compat_glColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue); +void gl4_0compat_glColor3bv(void *_glfuncs, const GLbyte* v); +void gl4_0compat_glColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue); +void gl4_0compat_glBitmap(void *_glfuncs, GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap); +void gl4_0compat_glBegin(void *_glfuncs, GLenum mode); +void gl4_0compat_glListBase(void *_glfuncs, GLuint base); +GLuint gl4_0compat_glGenLists(void *_glfuncs, GLsizei range_); +void gl4_0compat_glDeleteLists(void *_glfuncs, GLuint list, GLsizei range_); +void gl4_0compat_glCallLists(void *_glfuncs, GLsizei n, GLenum gltype, const GLvoid* lists); +void gl4_0compat_glCallList(void *_glfuncs, GLuint list); +void gl4_0compat_glEndList(void *_glfuncs); +void gl4_0compat_glNewList(void *_glfuncs, GLuint list, GLenum mode); +void gl4_0compat_glPushClientAttrib(void *_glfuncs, GLbitfield mask); +void gl4_0compat_glPopClientAttrib(void *_glfuncs); +void gl4_0compat_glPrioritizeTextures(void *_glfuncs, GLsizei n, const GLuint* textures, const GLfloat* priorities); +GLboolean gl4_0compat_glAreTexturesResident(void *_glfuncs, GLsizei n, const GLuint* textures, GLboolean* residences); +void gl4_0compat_glVertexPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_0compat_glTexCoordPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_0compat_glNormalPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_0compat_glInterleavedArrays(void *_glfuncs, GLenum format, GLsizei stride, const GLvoid* pointer); +void gl4_0compat_glIndexPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_0compat_glEnableClientState(void *_glfuncs, GLenum array); +void gl4_0compat_glEdgeFlagPointer(void *_glfuncs, GLsizei stride, const GLvoid* pointer); +void gl4_0compat_glDisableClientState(void *_glfuncs, GLenum array); +void gl4_0compat_glColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_0compat_glArrayElement(void *_glfuncs, GLint i); +void gl4_0compat_glResetMinmax(void *_glfuncs, GLenum target); +void gl4_0compat_glResetHistogram(void *_glfuncs, GLenum target); +void gl4_0compat_glMinmax(void *_glfuncs, GLenum target, GLenum internalFormat, GLboolean sink); +void gl4_0compat_glHistogram(void *_glfuncs, GLenum target, GLsizei width, GLenum internalFormat, GLboolean sink); +void gl4_0compat_glGetMinmaxParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_0compat_glGetMinmaxParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl4_0compat_glGetMinmax(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values); +void gl4_0compat_glGetHistogramParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_0compat_glGetHistogramParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl4_0compat_glGetHistogram(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values); +void gl4_0compat_glSeparableFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* row, const GLvoid* column); +void gl4_0compat_glGetSeparableFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* row, GLvoid* column, GLvoid* span); +void gl4_0compat_glGetConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_0compat_glGetConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl4_0compat_glGetConvolutionFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* image); +void gl4_0compat_glCopyConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_0compat_glCopyConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width); +void gl4_0compat_glConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl4_0compat_glConvolutionParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint params); +void gl4_0compat_glConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl4_0compat_glConvolutionParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat params); +void gl4_0compat_glConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* image); +void gl4_0compat_glConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* image); +void gl4_0compat_glCopyColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); +void gl4_0compat_glColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum gltype, const GLvoid* data); +void gl4_0compat_glGetColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_0compat_glGetColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl4_0compat_glGetColorTable(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* table); +void gl4_0compat_glCopyColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width); +void gl4_0compat_glColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl4_0compat_glColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl4_0compat_glColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* table); +void gl4_0compat_glMultTransposeMatrixd(void *_glfuncs, const GLdouble* m); +void gl4_0compat_glMultTransposeMatrixf(void *_glfuncs, const GLfloat* m); +void gl4_0compat_glLoadTransposeMatrixd(void *_glfuncs, const GLdouble* m); +void gl4_0compat_glLoadTransposeMatrixf(void *_glfuncs, const GLfloat* m); +void gl4_0compat_glMultiTexCoord4sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl4_0compat_glMultiTexCoord4s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); +void gl4_0compat_glMultiTexCoord4iv(void *_glfuncs, GLenum target, const GLint* v); +void gl4_0compat_glMultiTexCoord4i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r, GLint q); +void gl4_0compat_glMultiTexCoord4fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl4_0compat_glMultiTexCoord4f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +void gl4_0compat_glMultiTexCoord4dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl4_0compat_glMultiTexCoord4d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +void gl4_0compat_glMultiTexCoord3sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl4_0compat_glMultiTexCoord3s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r); +void gl4_0compat_glMultiTexCoord3iv(void *_glfuncs, GLenum target, const GLint* v); +void gl4_0compat_glMultiTexCoord3i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r); +void gl4_0compat_glMultiTexCoord3fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl4_0compat_glMultiTexCoord3f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r); +void gl4_0compat_glMultiTexCoord3dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl4_0compat_glMultiTexCoord3d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r); +void gl4_0compat_glMultiTexCoord2sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl4_0compat_glMultiTexCoord2s(void *_glfuncs, GLenum target, GLshort s, GLshort t); +void gl4_0compat_glMultiTexCoord2iv(void *_glfuncs, GLenum target, const GLint* v); +void gl4_0compat_glMultiTexCoord2i(void *_glfuncs, GLenum target, GLint s, GLint t); +void gl4_0compat_glMultiTexCoord2fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl4_0compat_glMultiTexCoord2f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t); +void gl4_0compat_glMultiTexCoord2dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl4_0compat_glMultiTexCoord2d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t); +void gl4_0compat_glMultiTexCoord1sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl4_0compat_glMultiTexCoord1s(void *_glfuncs, GLenum target, GLshort s); +void gl4_0compat_glMultiTexCoord1iv(void *_glfuncs, GLenum target, const GLint* v); +void gl4_0compat_glMultiTexCoord1i(void *_glfuncs, GLenum target, GLint s); +void gl4_0compat_glMultiTexCoord1fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl4_0compat_glMultiTexCoord1f(void *_glfuncs, GLenum target, GLfloat s); +void gl4_0compat_glMultiTexCoord1dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl4_0compat_glMultiTexCoord1d(void *_glfuncs, GLenum target, GLdouble s); +void gl4_0compat_glClientActiveTexture(void *_glfuncs, GLenum texture); +void gl4_0compat_glWindowPos3sv(void *_glfuncs, const GLshort* v); +void gl4_0compat_glWindowPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl4_0compat_glWindowPos3iv(void *_glfuncs, const GLint* v); +void gl4_0compat_glWindowPos3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl4_0compat_glWindowPos3fv(void *_glfuncs, const GLfloat* v); +void gl4_0compat_glWindowPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl4_0compat_glWindowPos3dv(void *_glfuncs, const GLdouble* v); +void gl4_0compat_glWindowPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl4_0compat_glWindowPos2sv(void *_glfuncs, const GLshort* v); +void gl4_0compat_glWindowPos2s(void *_glfuncs, GLshort x, GLshort y); +void gl4_0compat_glWindowPos2iv(void *_glfuncs, const GLint* v); +void gl4_0compat_glWindowPos2i(void *_glfuncs, GLint x, GLint y); +void gl4_0compat_glWindowPos2fv(void *_glfuncs, const GLfloat* v); +void gl4_0compat_glWindowPos2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl4_0compat_glWindowPos2dv(void *_glfuncs, const GLdouble* v); +void gl4_0compat_glWindowPos2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl4_0compat_glSecondaryColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_0compat_glSecondaryColor3usv(void *_glfuncs, const GLushort* v); +void gl4_0compat_glSecondaryColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue); +void gl4_0compat_glSecondaryColor3uiv(void *_glfuncs, const GLuint* v); +void gl4_0compat_glSecondaryColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue); +void gl4_0compat_glSecondaryColor3ubv(void *_glfuncs, const GLubyte* v); +void gl4_0compat_glSecondaryColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue); +void gl4_0compat_glSecondaryColor3sv(void *_glfuncs, const GLshort* v); +void gl4_0compat_glSecondaryColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue); +void gl4_0compat_glSecondaryColor3iv(void *_glfuncs, const GLint* v); +void gl4_0compat_glSecondaryColor3i(void *_glfuncs, GLint red, GLint green, GLint blue); +void gl4_0compat_glSecondaryColor3fv(void *_glfuncs, const GLfloat* v); +void gl4_0compat_glSecondaryColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue); +void gl4_0compat_glSecondaryColor3dv(void *_glfuncs, const GLdouble* v); +void gl4_0compat_glSecondaryColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue); +void gl4_0compat_glSecondaryColor3bv(void *_glfuncs, const GLbyte* v); +void gl4_0compat_glSecondaryColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue); +void gl4_0compat_glFogCoordPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_0compat_glFogCoorddv(void *_glfuncs, const GLdouble* coord); +void gl4_0compat_glFogCoordd(void *_glfuncs, GLdouble coord); +void gl4_0compat_glFogCoordfv(void *_glfuncs, const GLfloat* coord); +void gl4_0compat_glFogCoordf(void *_glfuncs, GLfloat coord); +void gl4_0compat_glVertexAttrib4usv(void *_glfuncs, GLuint index, const GLushort* v); +void gl4_0compat_glVertexAttrib4uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl4_0compat_glVertexAttrib4ubv(void *_glfuncs, GLuint index, const GLubyte* v); +void gl4_0compat_glVertexAttrib4sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl4_0compat_glVertexAttrib4s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +void gl4_0compat_glVertexAttrib4iv(void *_glfuncs, GLuint index, const GLint* v); +void gl4_0compat_glVertexAttrib4fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl4_0compat_glVertexAttrib4f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl4_0compat_glVertexAttrib4dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_0compat_glVertexAttrib4d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl4_0compat_glVertexAttrib4bv(void *_glfuncs, GLuint index, const GLbyte* v); +void gl4_0compat_glVertexAttrib4Nusv(void *_glfuncs, GLuint index, const GLushort* v); +void gl4_0compat_glVertexAttrib4Nuiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl4_0compat_glVertexAttrib4Nubv(void *_glfuncs, GLuint index, const GLubyte* v); +void gl4_0compat_glVertexAttrib4Nub(void *_glfuncs, GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +void gl4_0compat_glVertexAttrib4Nsv(void *_glfuncs, GLuint index, const GLshort* v); +void gl4_0compat_glVertexAttrib4Niv(void *_glfuncs, GLuint index, const GLint* v); +void gl4_0compat_glVertexAttrib4Nbv(void *_glfuncs, GLuint index, const GLbyte* v); +void gl4_0compat_glVertexAttrib3sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl4_0compat_glVertexAttrib3s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z); +void gl4_0compat_glVertexAttrib3fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl4_0compat_glVertexAttrib3f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z); +void gl4_0compat_glVertexAttrib3dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_0compat_glVertexAttrib3d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z); +void gl4_0compat_glVertexAttrib2sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl4_0compat_glVertexAttrib2s(void *_glfuncs, GLuint index, GLshort x, GLshort y); +void gl4_0compat_glVertexAttrib2fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl4_0compat_glVertexAttrib2f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y); +void gl4_0compat_glVertexAttrib2dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_0compat_glVertexAttrib2d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y); +void gl4_0compat_glVertexAttrib1sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl4_0compat_glVertexAttrib1s(void *_glfuncs, GLuint index, GLshort x); +void gl4_0compat_glVertexAttrib1fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl4_0compat_glVertexAttrib1f(void *_glfuncs, GLuint index, GLfloat x); +void gl4_0compat_glVertexAttrib1dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_0compat_glVertexAttrib1d(void *_glfuncs, GLuint index, GLdouble x); +void gl4_0compat_glVertexAttribI4usv(void *_glfuncs, GLuint index, const GLushort* v); +void gl4_0compat_glVertexAttribI4ubv(void *_glfuncs, GLuint index, const GLubyte* v); +void gl4_0compat_glVertexAttribI4sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl4_0compat_glVertexAttribI4bv(void *_glfuncs, GLuint index, const GLbyte* v); +void gl4_0compat_glVertexAttribI4uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl4_0compat_glVertexAttribI3uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl4_0compat_glVertexAttribI2uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl4_0compat_glVertexAttribI1uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl4_0compat_glVertexAttribI4iv(void *_glfuncs, GLuint index, const GLint* v); +void gl4_0compat_glVertexAttribI3iv(void *_glfuncs, GLuint index, const GLint* v); +void gl4_0compat_glVertexAttribI2iv(void *_glfuncs, GLuint index, const GLint* v); +void gl4_0compat_glVertexAttribI1iv(void *_glfuncs, GLuint index, const GLint* v); +void gl4_0compat_glVertexAttribI4ui(void *_glfuncs, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +void gl4_0compat_glVertexAttribI3ui(void *_glfuncs, GLuint index, GLuint x, GLuint y, GLuint z); +void gl4_0compat_glVertexAttribI2ui(void *_glfuncs, GLuint index, GLuint x, GLuint y); +void gl4_0compat_glVertexAttribI1ui(void *_glfuncs, GLuint index, GLuint x); +void gl4_0compat_glVertexAttribI4i(void *_glfuncs, GLuint index, GLint x, GLint y, GLint z, GLint w); +void gl4_0compat_glVertexAttribI3i(void *_glfuncs, GLuint index, GLint x, GLint y, GLint z); +void gl4_0compat_glVertexAttribI2i(void *_glfuncs, GLuint index, GLint x, GLint y); +void gl4_0compat_glVertexAttribI1i(void *_glfuncs, GLuint index, GLint x); + + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/gl/4.0compat/gl.go b/gl/4.0compat/gl.go new file mode 100644 index 00000000..246afb06 --- /dev/null +++ b/gl/4.0compat/gl.go @@ -0,0 +1,8607 @@ +// ** file automatically generated by glgen -- do not edit manually ** + +package GL + +// #cgo CXXFLAGS: -std=c++0x -pedantic-errors -Wall -fno-strict-aliasing +// #cgo LDFLAGS: -lstdc++ +// #cgo pkg-config: Qt5Core Qt5OpenGL +// +// #include "funcs.h" +// +// void free(void*); +// +import "C" + +import ( + "fmt" + "reflect" + "unsafe" + + "gopkg.in/qml.v1/gl/glbase" +) + +// API returns a value that offers methods matching the OpenGL version 4.0 API. +// +// The returned API must not be used after the provided OpenGL context becomes invalid. +func API(context glbase.Contexter) *GL { + gl := &GL{} + gl.funcs = C.gl4_0compat_funcs() + if gl.funcs == nil { + panic(fmt.Errorf("OpenGL version 4.0 is not available")) + } + return gl +} + +// GL implements the OpenGL version 4.0 API. Values of this +// type must be created via the API function, and it must not be used after +// the associated OpenGL context becomes invalid. +type GL struct { + funcs unsafe.Pointer +} + +const ( + FALSE = 0 + TRUE = 1 + NONE = 0 + + BYTE = 0x1400 + UNSIGNED_BYTE = 0x1401 + SHORT = 0x1402 + UNSIGNED_SHORT = 0x1403 + INT = 0x1404 + UNSIGNED_INT = 0x1405 + FLOAT = 0x1406 + N2_BYTES = 0x1407 + N3_BYTES = 0x1408 + N4_BYTES = 0x1409 + DOUBLE = 0x140A + HALF_FLOAT = 0x140B + + ACCUM = 0x0100 + LOAD = 0x0101 + RETURN = 0x0102 + MULT = 0x0103 + ADD = 0x0104 + + ACCUM_BUFFER_BIT = 0x00000200 + ALL_ATTRIB_BITS = 0xFFFFFFFF + COLOR_BUFFER_BIT = 0x00004000 + CURRENT_BIT = 0x00000001 + DEPTH_BUFFER_BIT = 0x00000100 + ENABLE_BIT = 0x00002000 + EVAL_BIT = 0x00010000 + FOG_BIT = 0x00000080 + HINT_BIT = 0x00008000 + LIGHTING_BIT = 0x00000040 + LINE_BIT = 0x00000004 + LIST_BIT = 0x00020000 + MULTISAMPLE_BIT = 0x20000000 + PIXEL_MODE_BIT = 0x00000020 + POINT_BIT = 0x00000002 + POLYGON_BIT = 0x00000008 + POLYGON_STIPPLE_BIT = 0x00000010 + SCISSOR_BIT = 0x00080000 + STENCIL_BUFFER_BIT = 0x00000400 + TEXTURE_BIT = 0x00040000 + TRANSFORM_BIT = 0x00001000 + VIEWPORT_BIT = 0x00000800 + + ALWAYS = 0x0207 + EQUAL = 0x0202 + GEQUAL = 0x0206 + GREATER = 0x0204 + LEQUAL = 0x0203 + LESS = 0x0201 + NEVER = 0x0200 + NOTEQUAL = 0x0205 + + LOGIC_OP = 0x0BF1 + + DST_ALPHA = 0x0304 + ONE = 1 + ONE_MINUS_DST_ALPHA = 0x0305 + ONE_MINUS_SRC_ALPHA = 0x0303 + ONE_MINUS_SRC_COLOR = 0x0301 + SRC_ALPHA = 0x0302 + SRC_COLOR = 0x0300 + ZERO = 0 + + DST_COLOR = 0x0306 + ONE_MINUS_DST_COLOR = 0x0307 + SRC_ALPHA_SATURATE = 0x0308 + + CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF + CLIENT_PIXEL_STORE_BIT = 0x00000001 + CLIENT_VERTEX_ARRAY_BIT = 0x00000002 + + CLIP_DISTANCE0 = 0x3000 + CLIP_DISTANCE1 = 0x3001 + CLIP_DISTANCE2 = 0x3002 + CLIP_DISTANCE3 = 0x3003 + CLIP_DISTANCE4 = 0x3004 + CLIP_DISTANCE5 = 0x3005 + CLIP_DISTANCE6 = 0x3006 + CLIP_DISTANCE7 = 0x3007 + CLIP_PLANE0 = 0x3000 + CLIP_PLANE1 = 0x3001 + CLIP_PLANE2 = 0x3002 + CLIP_PLANE3 = 0x3003 + CLIP_PLANE4 = 0x3004 + CLIP_PLANE5 = 0x3005 + + BACK = 0x0405 + FRONT = 0x0404 + FRONT_AND_BACK = 0x0408 + + AMBIENT = 0x1200 + AMBIENT_AND_DIFFUSE = 0x1602 + DIFFUSE = 0x1201 + EMISSION = 0x1600 + SPECULAR = 0x1202 + + CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x00000001 + + CONTEXT_COMPATIBILITY_PROFILE_BIT = 0x00000002 + CONTEXT_CORE_PROFILE_BIT = 0x00000001 + + AUX0 = 0x0409 + AUX1 = 0x040A + AUX2 = 0x040B + AUX3 = 0x040C + BACK_LEFT = 0x0402 + BACK_RIGHT = 0x0403 + FRONT_LEFT = 0x0400 + FRONT_RIGHT = 0x0401 + LEFT = 0x0406 + RIGHT = 0x0407 + + ALPHA_TEST = 0x0BC0 + AUTO_NORMAL = 0x0D80 + BLEND = 0x0BE2 + COLOR_ARRAY = 0x8076 + COLOR_LOGIC_OP = 0x0BF2 + COLOR_MATERIAL = 0x0B57 + CULL_FACE = 0x0B44 + DEPTH_TEST = 0x0B71 + DITHER = 0x0BD0 + EDGE_FLAG_ARRAY = 0x8079 + FOG = 0x0B60 + INDEX_ARRAY = 0x8077 + INDEX_LOGIC_OP = 0x0BF1 + LIGHT0 = 0x4000 + LIGHT1 = 0x4001 + LIGHT2 = 0x4002 + LIGHT3 = 0x4003 + LIGHT4 = 0x4004 + LIGHT5 = 0x4005 + LIGHT6 = 0x4006 + LIGHT7 = 0x4007 + LIGHTING = 0x0B50 + LINE_SMOOTH = 0x0B20 + LINE_STIPPLE = 0x0B24 + MAP1_COLOR_4 = 0x0D90 + MAP1_INDEX = 0x0D91 + MAP1_NORMAL = 0x0D92 + MAP1_TEXTURE_COORD_1 = 0x0D93 + MAP1_TEXTURE_COORD_2 = 0x0D94 + MAP1_TEXTURE_COORD_3 = 0x0D95 + MAP1_TEXTURE_COORD_4 = 0x0D96 + MAP1_VERTEX_3 = 0x0D97 + MAP1_VERTEX_4 = 0x0D98 + MAP2_COLOR_4 = 0x0DB0 + MAP2_INDEX = 0x0DB1 + MAP2_NORMAL = 0x0DB2 + MAP2_TEXTURE_COORD_1 = 0x0DB3 + MAP2_TEXTURE_COORD_2 = 0x0DB4 + MAP2_TEXTURE_COORD_3 = 0x0DB5 + MAP2_TEXTURE_COORD_4 = 0x0DB6 + MAP2_VERTEX_3 = 0x0DB7 + MAP2_VERTEX_4 = 0x0DB8 + NORMALIZE = 0x0BA1 + NORMAL_ARRAY = 0x8075 + POINT_SMOOTH = 0x0B10 + POLYGON_OFFSET_FILL = 0x8037 + POLYGON_OFFSET_LINE = 0x2A02 + POLYGON_OFFSET_POINT = 0x2A01 + POLYGON_SMOOTH = 0x0B41 + POLYGON_STIPPLE = 0x0B42 + SCISSOR_TEST = 0x0C11 + STENCIL_TEST = 0x0B90 + TEXTURE_1D = 0x0DE0 + TEXTURE_2D = 0x0DE1 + TEXTURE_COORD_ARRAY = 0x8078 + TEXTURE_GEN_Q = 0x0C63 + TEXTURE_GEN_R = 0x0C62 + TEXTURE_GEN_S = 0x0C60 + TEXTURE_GEN_T = 0x0C61 + VERTEX_ARRAY = 0x8074 + + INVALID_ENUM = 0x0500 + INVALID_FRAMEBUFFER_OPERATION = 0x0506 + INVALID_OPERATION = 0x0502 + INVALID_VALUE = 0x0501 + NO_ERROR = 0 + OUT_OF_MEMORY = 0x0505 + STACK_OVERFLOW = 0x0503 + STACK_UNDERFLOW = 0x0504 + + N2D = 0x0600 + N3D = 0x0601 + N3D_COLOR = 0x0602 + N3D_COLOR_TEXTURE = 0x0603 + N4D_COLOR_TEXTURE = 0x0604 + + BITMAP_TOKEN = 0x0704 + COPY_PIXEL_TOKEN = 0x0706 + DRAW_PIXEL_TOKEN = 0x0705 + LINE_RESET_TOKEN = 0x0707 + LINE_TOKEN = 0x0702 + PASS_THROUGH_TOKEN = 0x0700 + POINT_TOKEN = 0x0701 + POLYGON_TOKEN = 0x0703 + + EXP = 0x0800 + EXP2 = 0x0801 + LINEAR = 0x2601 + + FOG_COLOR = 0x0B66 + FOG_DENSITY = 0x0B62 + FOG_END = 0x0B64 + FOG_INDEX = 0x0B61 + FOG_MODE = 0x0B65 + FOG_START = 0x0B63 + + CCW = 0x0901 + CW = 0x0900 + + COEFF = 0x0A00 + DOMAIN = 0x0A02 + ORDER = 0x0A01 + + PIXEL_MAP_A_TO_A = 0x0C79 + PIXEL_MAP_B_TO_B = 0x0C78 + PIXEL_MAP_G_TO_G = 0x0C77 + PIXEL_MAP_I_TO_A = 0x0C75 + PIXEL_MAP_I_TO_B = 0x0C74 + PIXEL_MAP_I_TO_G = 0x0C73 + PIXEL_MAP_I_TO_I = 0x0C70 + PIXEL_MAP_I_TO_R = 0x0C72 + PIXEL_MAP_R_TO_R = 0x0C76 + PIXEL_MAP_S_TO_S = 0x0C71 + + ACCUM_ALPHA_BITS = 0x0D5B + ACCUM_BLUE_BITS = 0x0D5A + ACCUM_CLEAR_VALUE = 0x0B80 + ACCUM_GREEN_BITS = 0x0D59 + ACCUM_RED_BITS = 0x0D58 + ALIASED_LINE_WIDTH_RANGE = 0x846E + ALIASED_POINT_SIZE_RANGE = 0x846D + ALPHA_BIAS = 0x0D1D + ALPHA_BITS = 0x0D55 + ALPHA_SCALE = 0x0D1C + ALPHA_TEST_FUNC = 0x0BC1 + ALPHA_TEST_REF = 0x0BC2 + ATTRIB_STACK_DEPTH = 0x0BB0 + AUX_BUFFERS = 0x0C00 + BLEND_DST = 0x0BE0 + BLEND_SRC = 0x0BE1 + BLUE_BIAS = 0x0D1B + BLUE_BITS = 0x0D54 + BLUE_SCALE = 0x0D1A + CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1 + COLOR_ARRAY_SIZE = 0x8081 + COLOR_ARRAY_STRIDE = 0x8083 + COLOR_ARRAY_TYPE = 0x8082 + COLOR_CLEAR_VALUE = 0x0C22 + COLOR_MATERIAL_FACE = 0x0B55 + COLOR_MATERIAL_PARAMETER = 0x0B56 + COLOR_WRITEMASK = 0x0C23 + CULL_FACE_MODE = 0x0B45 + CURRENT_COLOR = 0x0B00 + CURRENT_INDEX = 0x0B01 + CURRENT_NORMAL = 0x0B02 + CURRENT_RASTER_COLOR = 0x0B04 + CURRENT_RASTER_DISTANCE = 0x0B09 + CURRENT_RASTER_INDEX = 0x0B05 + CURRENT_RASTER_POSITION = 0x0B07 + CURRENT_RASTER_POSITION_VALID = 0x0B08 + CURRENT_RASTER_TEXTURE_COORDS = 0x0B06 + CURRENT_TEXTURE_COORDS = 0x0B03 + DEPTH_BIAS = 0x0D1F + DEPTH_BITS = 0x0D56 + DEPTH_CLEAR_VALUE = 0x0B73 + DEPTH_FUNC = 0x0B74 + DEPTH_RANGE = 0x0B70 + DEPTH_SCALE = 0x0D1E + DEPTH_WRITEMASK = 0x0B72 + DOUBLEBUFFER = 0x0C32 + DRAW_BUFFER = 0x0C01 + EDGE_FLAG = 0x0B43 + EDGE_FLAG_ARRAY_STRIDE = 0x808C + FEEDBACK_BUFFER_SIZE = 0x0DF1 + FEEDBACK_BUFFER_TYPE = 0x0DF2 + FOG_HINT = 0x0C54 + FRONT_FACE = 0x0B46 + GREEN_BIAS = 0x0D19 + GREEN_BITS = 0x0D53 + GREEN_SCALE = 0x0D18 + INDEX_ARRAY_STRIDE = 0x8086 + INDEX_ARRAY_TYPE = 0x8085 + INDEX_BITS = 0x0D51 + INDEX_CLEAR_VALUE = 0x0C20 + INDEX_MODE = 0x0C30 + INDEX_OFFSET = 0x0D13 + INDEX_SHIFT = 0x0D12 + INDEX_WRITEMASK = 0x0C21 + LIGHT_MODEL_AMBIENT = 0x0B53 + LIGHT_MODEL_COLOR_CONTROL = 0x81F8 + LIGHT_MODEL_LOCAL_VIEWER = 0x0B51 + LIGHT_MODEL_TWO_SIDE = 0x0B52 + LINE_SMOOTH_HINT = 0x0C52 + LINE_STIPPLE_PATTERN = 0x0B25 + LINE_STIPPLE_REPEAT = 0x0B26 + LINE_WIDTH = 0x0B21 + LINE_WIDTH_GRANULARITY = 0x0B23 + LINE_WIDTH_RANGE = 0x0B22 + LIST_BASE = 0x0B32 + LIST_INDEX = 0x0B33 + LIST_MODE = 0x0B30 + LOGIC_OP_MODE = 0x0BF0 + MAP1_GRID_DOMAIN = 0x0DD0 + MAP1_GRID_SEGMENTS = 0x0DD1 + MAP2_GRID_DOMAIN = 0x0DD2 + MAP2_GRID_SEGMENTS = 0x0DD3 + MAP_COLOR = 0x0D10 + MAP_STENCIL = 0x0D11 + MATRIX_MODE = 0x0BA0 + MAX_ATTRIB_STACK_DEPTH = 0x0D35 + MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B + MAX_CLIP_DISTANCES = 0x0D32 + MAX_CLIP_PLANES = 0x0D32 + MAX_EVAL_ORDER = 0x0D30 + MAX_LIGHTS = 0x0D31 + MAX_LIST_NESTING = 0x0B31 + MAX_MODELVIEW_STACK_DEPTH = 0x0D36 + MAX_NAME_STACK_DEPTH = 0x0D37 + MAX_PIXEL_MAP_TABLE = 0x0D34 + MAX_PROJECTION_STACK_DEPTH = 0x0D38 + MAX_TEXTURE_SIZE = 0x0D33 + MAX_TEXTURE_STACK_DEPTH = 0x0D39 + MAX_VIEWPORT_DIMS = 0x0D3A + MODELVIEW_MATRIX = 0x0BA6 + MODELVIEW_STACK_DEPTH = 0x0BA3 + NAME_STACK_DEPTH = 0x0D70 + NORMAL_ARRAY_STRIDE = 0x807F + NORMAL_ARRAY_TYPE = 0x807E + PACK_ALIGNMENT = 0x0D05 + PACK_LSB_FIRST = 0x0D01 + PACK_ROW_LENGTH = 0x0D02 + PACK_SKIP_PIXELS = 0x0D04 + PACK_SKIP_ROWS = 0x0D03 + PACK_SWAP_BYTES = 0x0D00 + PERSPECTIVE_CORRECTION_HINT = 0x0C50 + PIXEL_MAP_A_TO_A_SIZE = 0x0CB9 + PIXEL_MAP_B_TO_B_SIZE = 0x0CB8 + PIXEL_MAP_G_TO_G_SIZE = 0x0CB7 + PIXEL_MAP_I_TO_A_SIZE = 0x0CB5 + PIXEL_MAP_I_TO_B_SIZE = 0x0CB4 + PIXEL_MAP_I_TO_G_SIZE = 0x0CB3 + PIXEL_MAP_I_TO_I_SIZE = 0x0CB0 + PIXEL_MAP_I_TO_R_SIZE = 0x0CB2 + PIXEL_MAP_R_TO_R_SIZE = 0x0CB6 + PIXEL_MAP_S_TO_S_SIZE = 0x0CB1 + POINT_SIZE = 0x0B11 + POINT_SIZE_GRANULARITY = 0x0B13 + POINT_SIZE_RANGE = 0x0B12 + POINT_SMOOTH_HINT = 0x0C51 + POLYGON_MODE = 0x0B40 + POLYGON_OFFSET_FACTOR = 0x8038 + POLYGON_OFFSET_UNITS = 0x2A00 + POLYGON_SMOOTH_HINT = 0x0C53 + PROJECTION_MATRIX = 0x0BA7 + PROJECTION_STACK_DEPTH = 0x0BA4 + READ_BUFFER = 0x0C02 + RED_BIAS = 0x0D15 + RED_BITS = 0x0D52 + RED_SCALE = 0x0D14 + RENDER_MODE = 0x0C40 + RGBA_MODE = 0x0C31 + SCISSOR_BOX = 0x0C10 + SELECTION_BUFFER_SIZE = 0x0DF4 + SHADE_MODEL = 0x0B54 + SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23 + SMOOTH_LINE_WIDTH_RANGE = 0x0B22 + SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13 + SMOOTH_POINT_SIZE_RANGE = 0x0B12 + STENCIL_BITS = 0x0D57 + STENCIL_CLEAR_VALUE = 0x0B91 + STENCIL_FAIL = 0x0B94 + STENCIL_FUNC = 0x0B92 + STENCIL_PASS_DEPTH_FAIL = 0x0B95 + STENCIL_PASS_DEPTH_PASS = 0x0B96 + STENCIL_REF = 0x0B97 + STENCIL_VALUE_MASK = 0x0B93 + STENCIL_WRITEMASK = 0x0B98 + STEREO = 0x0C33 + SUBPIXEL_BITS = 0x0D50 + TEXTURE_BINDING_1D = 0x8068 + TEXTURE_BINDING_2D = 0x8069 + TEXTURE_BINDING_3D = 0x806A + TEXTURE_COORD_ARRAY_SIZE = 0x8088 + TEXTURE_COORD_ARRAY_STRIDE = 0x808A + TEXTURE_COORD_ARRAY_TYPE = 0x8089 + TEXTURE_MATRIX = 0x0BA8 + TEXTURE_STACK_DEPTH = 0x0BA5 + UNPACK_ALIGNMENT = 0x0CF5 + UNPACK_LSB_FIRST = 0x0CF1 + UNPACK_ROW_LENGTH = 0x0CF2 + UNPACK_SKIP_PIXELS = 0x0CF4 + UNPACK_SKIP_ROWS = 0x0CF3 + UNPACK_SWAP_BYTES = 0x0CF0 + VERTEX_ARRAY_SIZE = 0x807A + VERTEX_ARRAY_STRIDE = 0x807C + VERTEX_ARRAY_TYPE = 0x807B + VIEWPORT = 0x0BA2 + ZOOM_X = 0x0D16 + ZOOM_Y = 0x0D17 + + COLOR_ARRAY_POINTER = 0x8090 + EDGE_FLAG_ARRAY_POINTER = 0x8093 + FEEDBACK_BUFFER_POINTER = 0x0DF0 + INDEX_ARRAY_POINTER = 0x8091 + NORMAL_ARRAY_POINTER = 0x808F + SELECTION_BUFFER_POINTER = 0x0DF3 + TEXTURE_COORD_ARRAY_POINTER = 0x8092 + VERTEX_ARRAY_POINTER = 0x808E + + TEXTURE_ALPHA_SIZE = 0x805F + TEXTURE_BLUE_SIZE = 0x805E + TEXTURE_BORDER = 0x1005 + TEXTURE_BORDER_COLOR = 0x1004 + TEXTURE_COMPONENTS = 0x1003 + TEXTURE_GREEN_SIZE = 0x805D + TEXTURE_HEIGHT = 0x1001 + TEXTURE_INTENSITY_SIZE = 0x8061 + TEXTURE_INTERNAL_FORMAT = 0x1003 + TEXTURE_LUMINANCE_SIZE = 0x8060 + TEXTURE_MAG_FILTER = 0x2800 + TEXTURE_MIN_FILTER = 0x2801 + TEXTURE_PRIORITY = 0x8066 + TEXTURE_RED_SIZE = 0x805C + TEXTURE_RESIDENT = 0x8067 + TEXTURE_WIDTH = 0x1000 + TEXTURE_WRAP_S = 0x2802 + TEXTURE_WRAP_T = 0x2803 + + DONT_CARE = 0x1100 + FASTEST = 0x1101 + NICEST = 0x1102 + + FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B + GENERATE_MIPMAP_HINT = 0x8192 + TEXTURE_COMPRESSION_HINT = 0x84EF + + C3F_V3F = 0x2A24 + C4F_N3F_V3F = 0x2A26 + C4UB_V2F = 0x2A22 + C4UB_V3F = 0x2A23 + N3F_V3F = 0x2A25 + T2F_C3F_V3F = 0x2A2A + T2F_C4F_N3F_V3F = 0x2A2C + T2F_C4UB_V3F = 0x2A29 + T2F_N3F_V3F = 0x2A2B + T2F_V3F = 0x2A27 + T4F_C4F_N3F_V4F = 0x2A2D + T4F_V4F = 0x2A28 + V2F = 0x2A20 + V3F = 0x2A21 + + MODULATE = 0x2100 + REPLACE = 0x1E01 + + SEPARATE_SPECULAR_COLOR = 0x81FA + SINGLE_COLOR = 0x81F9 + + CONSTANT_ATTENUATION = 0x1207 + LINEAR_ATTENUATION = 0x1208 + POSITION = 0x1203 + QUADRATIC_ATTENUATION = 0x1209 + SPOT_CUTOFF = 0x1206 + SPOT_DIRECTION = 0x1204 + SPOT_EXPONENT = 0x1205 + + COMPILE = 0x1300 + COMPILE_AND_EXECUTE = 0x1301 + + AND = 0x1501 + AND_INVERTED = 0x1504 + AND_REVERSE = 0x1502 + CLEAR = 0x1500 + COPY = 0x1503 + COPY_INVERTED = 0x150C + EQUIV = 0x1509 + INVERT = 0x150A + NAND = 0x150E + NOOP = 0x1505 + NOR = 0x1508 + OR = 0x1507 + OR_INVERTED = 0x150D + OR_REVERSE = 0x150B + SET = 0x150F + XOR = 0x1506 + + MAP_FLUSH_EXPLICIT_BIT = 0x0010 + MAP_INVALIDATE_BUFFER_BIT = 0x0008 + MAP_INVALIDATE_RANGE_BIT = 0x0004 + MAP_READ_BIT = 0x0001 + MAP_UNSYNCHRONIZED_BIT = 0x0020 + MAP_WRITE_BIT = 0x0002 + + COLOR_INDEXES = 0x1603 + SHININESS = 0x1601 + + MODELVIEW = 0x1700 + PROJECTION = 0x1701 + TEXTURE = 0x1702 + + LINE = 0x1B01 + POINT = 0x1B00 + + FILL = 0x1B02 + + COLOR = 0x1800 + DEPTH = 0x1801 + STENCIL = 0x1802 + + ALPHA = 0x1906 + BLUE = 0x1905 + COLOR_INDEX = 0x1900 + DEPTH_COMPONENT = 0x1902 + GREEN = 0x1904 + LUMINANCE = 0x1909 + LUMINANCE_ALPHA = 0x190A + RED = 0x1903 + RGB = 0x1907 + RGBA = 0x1908 + STENCIL_INDEX = 0x1901 + + ALPHA12 = 0x803D + ALPHA16 = 0x803E + ALPHA4 = 0x803B + ALPHA8 = 0x803C + INTENSITY = 0x8049 + INTENSITY12 = 0x804C + INTENSITY16 = 0x804D + INTENSITY4 = 0x804A + INTENSITY8 = 0x804B + LUMINANCE12 = 0x8041 + LUMINANCE12_ALPHA12 = 0x8047 + LUMINANCE12_ALPHA4 = 0x8046 + LUMINANCE16 = 0x8042 + LUMINANCE16_ALPHA16 = 0x8048 + LUMINANCE4 = 0x803F + LUMINANCE4_ALPHA4 = 0x8043 + LUMINANCE6_ALPHA2 = 0x8044 + LUMINANCE8 = 0x8040 + LUMINANCE8_ALPHA8 = 0x8045 + R3_G3_B2 = 0x2A10 + RGB10 = 0x8052 + RGB10_A2 = 0x8059 + RGB12 = 0x8053 + RGB16 = 0x8054 + RGB4 = 0x804F + RGB5 = 0x8050 + RGB5_A1 = 0x8057 + RGB8 = 0x8051 + RGBA12 = 0x805A + RGBA16 = 0x805B + RGBA2 = 0x8055 + RGBA4 = 0x8056 + RGBA8 = 0x8058 + + PACK_IMAGE_HEIGHT = 0x806C + PACK_SKIP_IMAGES = 0x806B + UNPACK_IMAGE_HEIGHT = 0x806E + UNPACK_SKIP_IMAGES = 0x806D + + BITMAP = 0x1A00 + UNSIGNED_BYTE_3_3_2 = 0x8032 + UNSIGNED_INT_10_10_10_2 = 0x8036 + UNSIGNED_INT_8_8_8_8 = 0x8035 + UNSIGNED_SHORT_4_4_4_4 = 0x8033 + UNSIGNED_SHORT_5_5_5_1 = 0x8034 + + POINT_DISTANCE_ATTENUATION = 0x8129 + POINT_FADE_THRESHOLD_SIZE = 0x8128 + POINT_SIZE_MAX = 0x8127 + POINT_SIZE_MIN = 0x8126 + + LINES = 0x0001 + LINES_ADJACENCY = 0x000A + LINE_LOOP = 0x0002 + LINE_STRIP = 0x0003 + LINE_STRIP_ADJACENCY = 0x000B + PATCHES = 0x000E + POINTS = 0x0000 + POLYGON = 0x0009 + QUADS = 0x0007 + QUAD_STRIP = 0x0008 + TRIANGLES = 0x0004 + TRIANGLES_ADJACENCY = 0x000C + TRIANGLE_FAN = 0x0006 + TRIANGLE_STRIP = 0x0005 + TRIANGLE_STRIP_ADJACENCY = 0x000D + + FEEDBACK = 0x1C01 + RENDER = 0x1C00 + SELECT = 0x1C02 + + FLAT = 0x1D00 + SMOOTH = 0x1D01 + + DECR = 0x1E03 + INCR = 0x1E02 + KEEP = 0x1E00 + + EXTENSIONS = 0x1F03 + RENDERER = 0x1F01 + VENDOR = 0x1F00 + VERSION = 0x1F02 + + S = 0x2000 + T = 0x2001 + R = 0x2002 + Q = 0x2003 + + DECAL = 0x2101 + + TEXTURE_ENV_COLOR = 0x2201 + TEXTURE_ENV_MODE = 0x2200 + + TEXTURE_ENV = 0x2300 + + EYE_LINEAR = 0x2400 + OBJECT_LINEAR = 0x2401 + SPHERE_MAP = 0x2402 + + EYE_PLANE = 0x2502 + OBJECT_PLANE = 0x2501 + TEXTURE_GEN_MODE = 0x2500 + + NEAREST = 0x2600 + + LINEAR_MIPMAP_LINEAR = 0x2703 + LINEAR_MIPMAP_NEAREST = 0x2701 + NEAREST_MIPMAP_LINEAR = 0x2702 + NEAREST_MIPMAP_NEAREST = 0x2700 + + GENERATE_MIPMAP = 0x8191 + TEXTURE_WRAP_R = 0x8072 + + PROXY_TEXTURE_1D = 0x8063 + PROXY_TEXTURE_2D = 0x8064 + PROXY_TEXTURE_3D = 0x8070 + TEXTURE_3D = 0x806F + TEXTURE_BASE_LEVEL = 0x813C + TEXTURE_MAX_LEVEL = 0x813D + TEXTURE_MAX_LOD = 0x813B + TEXTURE_MIN_LOD = 0x813A + + CLAMP = 0x2900 + CLAMP_TO_BORDER = 0x812D + CLAMP_TO_EDGE = 0x812F + REPEAT = 0x2901 + + SYNC_FLUSH_COMMANDS_BIT = 0x00000001 + INVALID_INDEX = 0xFFFFFFFF + TIMEOUT_IGNORED = 0xFFFFFFFFFFFFFFFF + CONSTANT_COLOR = 0x8001 + ONE_MINUS_CONSTANT_COLOR = 0x8002 + CONSTANT_ALPHA = 0x8003 + ONE_MINUS_CONSTANT_ALPHA = 0x8004 + FUNC_ADD = 0x8006 + MIN = 0x8007 + MAX = 0x8008 + BLEND_EQUATION_RGB = 0x8009 + FUNC_SUBTRACT = 0x800A + FUNC_REVERSE_SUBTRACT = 0x800B + RESCALE_NORMAL = 0x803A + TEXTURE_DEPTH = 0x8071 + MAX_3D_TEXTURE_SIZE = 0x8073 + MULTISAMPLE = 0x809D + SAMPLE_ALPHA_TO_COVERAGE = 0x809E + SAMPLE_ALPHA_TO_ONE = 0x809F + SAMPLE_COVERAGE = 0x80A0 + SAMPLE_BUFFERS = 0x80A8 + SAMPLES = 0x80A9 + SAMPLE_COVERAGE_VALUE = 0x80AA + SAMPLE_COVERAGE_INVERT = 0x80AB + BLEND_DST_RGB = 0x80C8 + BLEND_SRC_RGB = 0x80C9 + BLEND_DST_ALPHA = 0x80CA + BLEND_SRC_ALPHA = 0x80CB + BGR = 0x80E0 + BGRA = 0x80E1 + MAX_ELEMENTS_VERTICES = 0x80E8 + MAX_ELEMENTS_INDICES = 0x80E9 + DEPTH_COMPONENT16 = 0x81A5 + DEPTH_COMPONENT24 = 0x81A6 + DEPTH_COMPONENT32 = 0x81A7 + FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210 + FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211 + FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212 + FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213 + FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214 + FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215 + FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216 + FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217 + FRAMEBUFFER_DEFAULT = 0x8218 + FRAMEBUFFER_UNDEFINED = 0x8219 + DEPTH_STENCIL_ATTACHMENT = 0x821A + MAJOR_VERSION = 0x821B + MINOR_VERSION = 0x821C + NUM_EXTENSIONS = 0x821D + CONTEXT_FLAGS = 0x821E + INDEX = 0x8222 + COMPRESSED_RED = 0x8225 + COMPRESSED_RG = 0x8226 + RG = 0x8227 + RG_INTEGER = 0x8228 + R8 = 0x8229 + R16 = 0x822A + RG8 = 0x822B + RG16 = 0x822C + R16F = 0x822D + R32F = 0x822E + RG16F = 0x822F + RG32F = 0x8230 + R8I = 0x8231 + R8UI = 0x8232 + R16I = 0x8233 + R16UI = 0x8234 + R32I = 0x8235 + R32UI = 0x8236 + RG8I = 0x8237 + RG8UI = 0x8238 + RG16I = 0x8239 + RG16UI = 0x823A + RG32I = 0x823B + RG32UI = 0x823C + UNSIGNED_BYTE_2_3_3_REV = 0x8362 + UNSIGNED_SHORT_5_6_5 = 0x8363 + UNSIGNED_SHORT_5_6_5_REV = 0x8364 + UNSIGNED_SHORT_4_4_4_4_REV = 0x8365 + UNSIGNED_SHORT_1_5_5_5_REV = 0x8366 + UNSIGNED_INT_8_8_8_8_REV = 0x8367 + UNSIGNED_INT_2_10_10_10_REV = 0x8368 + MIRRORED_REPEAT = 0x8370 + FOG_COORDINATE_SOURCE = 0x8450 + FOG_COORD_SRC = 0x8450 + FOG_COORDINATE = 0x8451 + FOG_COORD = 0x8451 + FRAGMENT_DEPTH = 0x8452 + CURRENT_FOG_COORDINATE = 0x8453 + CURRENT_FOG_COORD = 0x8453 + FOG_COORDINATE_ARRAY_TYPE = 0x8454 + FOG_COORD_ARRAY_TYPE = 0x8454 + FOG_COORDINATE_ARRAY_STRIDE = 0x8455 + FOG_COORD_ARRAY_STRIDE = 0x8455 + FOG_COORDINATE_ARRAY_POINTER = 0x8456 + FOG_COORD_ARRAY_POINTER = 0x8456 + FOG_COORDINATE_ARRAY = 0x8457 + FOG_COORD_ARRAY = 0x8457 + COLOR_SUM = 0x8458 + CURRENT_SECONDARY_COLOR = 0x8459 + SECONDARY_COLOR_ARRAY_SIZE = 0x845A + SECONDARY_COLOR_ARRAY_TYPE = 0x845B + SECONDARY_COLOR_ARRAY_STRIDE = 0x845C + SECONDARY_COLOR_ARRAY_POINTER = 0x845D + SECONDARY_COLOR_ARRAY = 0x845E + CURRENT_RASTER_SECONDARY_COLOR = 0x845F + TEXTURE0 = 0x84C0 + TEXTURE1 = 0x84C1 + TEXTURE2 = 0x84C2 + TEXTURE3 = 0x84C3 + TEXTURE4 = 0x84C4 + TEXTURE5 = 0x84C5 + TEXTURE6 = 0x84C6 + TEXTURE7 = 0x84C7 + TEXTURE8 = 0x84C8 + TEXTURE9 = 0x84C9 + TEXTURE10 = 0x84CA + TEXTURE11 = 0x84CB + TEXTURE12 = 0x84CC + TEXTURE13 = 0x84CD + TEXTURE14 = 0x84CE + TEXTURE15 = 0x84CF + TEXTURE16 = 0x84D0 + TEXTURE17 = 0x84D1 + TEXTURE18 = 0x84D2 + TEXTURE19 = 0x84D3 + TEXTURE20 = 0x84D4 + TEXTURE21 = 0x84D5 + TEXTURE22 = 0x84D6 + TEXTURE23 = 0x84D7 + TEXTURE24 = 0x84D8 + TEXTURE25 = 0x84D9 + TEXTURE26 = 0x84DA + TEXTURE27 = 0x84DB + TEXTURE28 = 0x84DC + TEXTURE29 = 0x84DD + TEXTURE30 = 0x84DE + TEXTURE31 = 0x84DF + ACTIVE_TEXTURE = 0x84E0 + CLIENT_ACTIVE_TEXTURE = 0x84E1 + MAX_TEXTURE_UNITS = 0x84E2 + TRANSPOSE_MODELVIEW_MATRIX = 0x84E3 + TRANSPOSE_PROJECTION_MATRIX = 0x84E4 + TRANSPOSE_TEXTURE_MATRIX = 0x84E5 + TRANSPOSE_COLOR_MATRIX = 0x84E6 + SUBTRACT = 0x84E7 + MAX_RENDERBUFFER_SIZE = 0x84E8 + COMPRESSED_ALPHA = 0x84E9 + COMPRESSED_LUMINANCE = 0x84EA + COMPRESSED_LUMINANCE_ALPHA = 0x84EB + COMPRESSED_INTENSITY = 0x84EC + COMPRESSED_RGB = 0x84ED + COMPRESSED_RGBA = 0x84EE + UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER = 0x84F0 + UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x84F1 + TEXTURE_RECTANGLE = 0x84F5 + TEXTURE_BINDING_RECTANGLE = 0x84F6 + PROXY_TEXTURE_RECTANGLE = 0x84F7 + MAX_RECTANGLE_TEXTURE_SIZE = 0x84F8 + DEPTH_STENCIL = 0x84F9 + UNSIGNED_INT_24_8 = 0x84FA + MAX_TEXTURE_LOD_BIAS = 0x84FD + TEXTURE_FILTER_CONTROL = 0x8500 + TEXTURE_LOD_BIAS = 0x8501 + INCR_WRAP = 0x8507 + DECR_WRAP = 0x8508 + NORMAL_MAP = 0x8511 + REFLECTION_MAP = 0x8512 + TEXTURE_CUBE_MAP = 0x8513 + TEXTURE_BINDING_CUBE_MAP = 0x8514 + TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515 + TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516 + TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517 + TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518 + TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519 + TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A + PROXY_TEXTURE_CUBE_MAP = 0x851B + MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C + COMBINE = 0x8570 + COMBINE_RGB = 0x8571 + COMBINE_ALPHA = 0x8572 + RGB_SCALE = 0x8573 + ADD_SIGNED = 0x8574 + INTERPOLATE = 0x8575 + CONSTANT = 0x8576 + PRIMARY_COLOR = 0x8577 + PREVIOUS = 0x8578 + SOURCE0_RGB = 0x8580 + SRC0_RGB = 0x8580 + SOURCE1_RGB = 0x8581 + SRC1_RGB = 0x8581 + SOURCE2_RGB = 0x8582 + SRC2_RGB = 0x8582 + SOURCE0_ALPHA = 0x8588 + SRC0_ALPHA = 0x8588 + SOURCE1_ALPHA = 0x8589 + SRC1_ALPHA = 0x8589 + SOURCE2_ALPHA = 0x858A + SRC2_ALPHA = 0x858A + OPERAND0_RGB = 0x8590 + OPERAND1_RGB = 0x8591 + OPERAND2_RGB = 0x8592 + OPERAND0_ALPHA = 0x8598 + OPERAND1_ALPHA = 0x8599 + OPERAND2_ALPHA = 0x859A + VERTEX_ARRAY_BINDING = 0x85B5 + VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622 + VERTEX_ATTRIB_ARRAY_SIZE = 0x8623 + VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624 + VERTEX_ATTRIB_ARRAY_TYPE = 0x8625 + CURRENT_VERTEX_ATTRIB = 0x8626 + VERTEX_PROGRAM_POINT_SIZE = 0x8642 + PROGRAM_POINT_SIZE = 0x8642 + VERTEX_PROGRAM_TWO_SIDE = 0x8643 + VERTEX_ATTRIB_ARRAY_POINTER = 0x8645 + DEPTH_CLAMP = 0x864F + TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0 + TEXTURE_COMPRESSED = 0x86A1 + NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2 + COMPRESSED_TEXTURE_FORMATS = 0x86A3 + DOT3_RGB = 0x86AE + DOT3_RGBA = 0x86AF + BUFFER_SIZE = 0x8764 + BUFFER_USAGE = 0x8765 + STENCIL_BACK_FUNC = 0x8800 + STENCIL_BACK_FAIL = 0x8801 + STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802 + STENCIL_BACK_PASS_DEPTH_PASS = 0x8803 + RGBA32F = 0x8814 + RGB32F = 0x8815 + RGBA16F = 0x881A + RGB16F = 0x881B + MAX_DRAW_BUFFERS = 0x8824 + DRAW_BUFFER0 = 0x8825 + DRAW_BUFFER1 = 0x8826 + DRAW_BUFFER2 = 0x8827 + DRAW_BUFFER3 = 0x8828 + DRAW_BUFFER4 = 0x8829 + DRAW_BUFFER5 = 0x882A + DRAW_BUFFER6 = 0x882B + DRAW_BUFFER7 = 0x882C + DRAW_BUFFER8 = 0x882D + DRAW_BUFFER9 = 0x882E + DRAW_BUFFER10 = 0x882F + DRAW_BUFFER11 = 0x8830 + DRAW_BUFFER12 = 0x8831 + DRAW_BUFFER13 = 0x8832 + DRAW_BUFFER14 = 0x8833 + DRAW_BUFFER15 = 0x8834 + BLEND_EQUATION_ALPHA = 0x883D + TEXTURE_DEPTH_SIZE = 0x884A + DEPTH_TEXTURE_MODE = 0x884B + TEXTURE_COMPARE_MODE = 0x884C + TEXTURE_COMPARE_FUNC = 0x884D + COMPARE_R_TO_TEXTURE = 0x884E + COMPARE_REF_TO_TEXTURE = 0x884E + TEXTURE_CUBE_MAP_SEAMLESS = 0x884F + POINT_SPRITE = 0x8861 + COORD_REPLACE = 0x8862 + QUERY_COUNTER_BITS = 0x8864 + CURRENT_QUERY = 0x8865 + QUERY_RESULT = 0x8866 + QUERY_RESULT_AVAILABLE = 0x8867 + MAX_VERTEX_ATTRIBS = 0x8869 + VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A + MAX_TESS_CONTROL_INPUT_COMPONENTS = 0x886C + MAX_TESS_EVALUATION_INPUT_COMPONENTS = 0x886D + MAX_TEXTURE_COORDS = 0x8871 + MAX_TEXTURE_IMAGE_UNITS = 0x8872 + GEOMETRY_SHADER_INVOCATIONS = 0x887F + ARRAY_BUFFER = 0x8892 + ELEMENT_ARRAY_BUFFER = 0x8893 + ARRAY_BUFFER_BINDING = 0x8894 + ELEMENT_ARRAY_BUFFER_BINDING = 0x8895 + VERTEX_ARRAY_BUFFER_BINDING = 0x8896 + NORMAL_ARRAY_BUFFER_BINDING = 0x8897 + COLOR_ARRAY_BUFFER_BINDING = 0x8898 + INDEX_ARRAY_BUFFER_BINDING = 0x8899 + TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A + EDGE_FLAG_ARRAY_BUFFER_BINDING = 0x889B + SECONDARY_COLOR_ARRAY_BUFFER_BINDING = 0x889C + FOG_COORDINATE_ARRAY_BUFFER_BINDING = 0x889D + FOG_COORD_ARRAY_BUFFER_BINDING = 0x889D + WEIGHT_ARRAY_BUFFER_BINDING = 0x889E + VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F + READ_ONLY = 0x88B8 + WRITE_ONLY = 0x88B9 + READ_WRITE = 0x88BA + BUFFER_ACCESS = 0x88BB + BUFFER_MAPPED = 0x88BC + BUFFER_MAP_POINTER = 0x88BD + TIME_ELAPSED = 0x88BF + STREAM_DRAW = 0x88E0 + STREAM_READ = 0x88E1 + STREAM_COPY = 0x88E2 + STATIC_DRAW = 0x88E4 + STATIC_READ = 0x88E5 + STATIC_COPY = 0x88E6 + DYNAMIC_DRAW = 0x88E8 + DYNAMIC_READ = 0x88E9 + DYNAMIC_COPY = 0x88EA + PIXEL_PACK_BUFFER = 0x88EB + PIXEL_UNPACK_BUFFER = 0x88EC + PIXEL_PACK_BUFFER_BINDING = 0x88ED + PIXEL_UNPACK_BUFFER_BINDING = 0x88EF + DEPTH24_STENCIL8 = 0x88F0 + TEXTURE_STENCIL_SIZE = 0x88F1 + SRC1_COLOR = 0x88F9 + ONE_MINUS_SRC1_COLOR = 0x88FA + ONE_MINUS_SRC1_ALPHA = 0x88FB + MAX_DUAL_SOURCE_DRAW_BUFFERS = 0x88FC + VERTEX_ATTRIB_ARRAY_INTEGER = 0x88FD + VERTEX_ATTRIB_ARRAY_DIVISOR = 0x88FE + MAX_ARRAY_TEXTURE_LAYERS = 0x88FF + MIN_PROGRAM_TEXEL_OFFSET = 0x8904 + MAX_PROGRAM_TEXEL_OFFSET = 0x8905 + SAMPLES_PASSED = 0x8914 + GEOMETRY_VERTICES_OUT = 0x8916 + GEOMETRY_INPUT_TYPE = 0x8917 + GEOMETRY_OUTPUT_TYPE = 0x8918 + SAMPLER_BINDING = 0x8919 + CLAMP_VERTEX_COLOR = 0x891A + CLAMP_FRAGMENT_COLOR = 0x891B + CLAMP_READ_COLOR = 0x891C + FIXED_ONLY = 0x891D + UNIFORM_BUFFER = 0x8A11 + UNIFORM_BUFFER_BINDING = 0x8A28 + UNIFORM_BUFFER_START = 0x8A29 + UNIFORM_BUFFER_SIZE = 0x8A2A + MAX_VERTEX_UNIFORM_BLOCKS = 0x8A2B + MAX_GEOMETRY_UNIFORM_BLOCKS = 0x8A2C + MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8A2D + MAX_COMBINED_UNIFORM_BLOCKS = 0x8A2E + MAX_UNIFORM_BUFFER_BINDINGS = 0x8A2F + MAX_UNIFORM_BLOCK_SIZE = 0x8A30 + MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31 + MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 0x8A32 + MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33 + UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8A34 + ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35 + ACTIVE_UNIFORM_BLOCKS = 0x8A36 + UNIFORM_TYPE = 0x8A37 + UNIFORM_SIZE = 0x8A38 + UNIFORM_NAME_LENGTH = 0x8A39 + UNIFORM_BLOCK_INDEX = 0x8A3A + UNIFORM_OFFSET = 0x8A3B + UNIFORM_ARRAY_STRIDE = 0x8A3C + UNIFORM_MATRIX_STRIDE = 0x8A3D + UNIFORM_IS_ROW_MAJOR = 0x8A3E + UNIFORM_BLOCK_BINDING = 0x8A3F + UNIFORM_BLOCK_DATA_SIZE = 0x8A40 + UNIFORM_BLOCK_NAME_LENGTH = 0x8A41 + UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8A42 + UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43 + UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44 + UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 0x8A45 + UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46 + FRAGMENT_SHADER = 0x8B30 + VERTEX_SHADER = 0x8B31 + MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49 + MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A + MAX_VARYING_FLOATS = 0x8B4B + MAX_VARYING_COMPONENTS = 0x8B4B + MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C + MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D + SHADER_TYPE = 0x8B4F + FLOAT_VEC2 = 0x8B50 + FLOAT_VEC3 = 0x8B51 + FLOAT_VEC4 = 0x8B52 + INT_VEC2 = 0x8B53 + INT_VEC3 = 0x8B54 + INT_VEC4 = 0x8B55 + BOOL = 0x8B56 + BOOL_VEC2 = 0x8B57 + BOOL_VEC3 = 0x8B58 + BOOL_VEC4 = 0x8B59 + FLOAT_MAT2 = 0x8B5A + FLOAT_MAT3 = 0x8B5B + FLOAT_MAT4 = 0x8B5C + SAMPLER_1D = 0x8B5D + SAMPLER_2D = 0x8B5E + SAMPLER_3D = 0x8B5F + SAMPLER_CUBE = 0x8B60 + SAMPLER_1D_SHADOW = 0x8B61 + SAMPLER_2D_SHADOW = 0x8B62 + SAMPLER_2D_RECT = 0x8B63 + SAMPLER_2D_RECT_SHADOW = 0x8B64 + FLOAT_MAT2x3 = 0x8B65 + FLOAT_MAT2x4 = 0x8B66 + FLOAT_MAT3x2 = 0x8B67 + FLOAT_MAT3x4 = 0x8B68 + FLOAT_MAT4x2 = 0x8B69 + FLOAT_MAT4x3 = 0x8B6A + DELETE_STATUS = 0x8B80 + COMPILE_STATUS = 0x8B81 + LINK_STATUS = 0x8B82 + VALIDATE_STATUS = 0x8B83 + INFO_LOG_LENGTH = 0x8B84 + ATTACHED_SHADERS = 0x8B85 + ACTIVE_UNIFORMS = 0x8B86 + ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87 + SHADER_SOURCE_LENGTH = 0x8B88 + ACTIVE_ATTRIBUTES = 0x8B89 + ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A + SHADING_LANGUAGE_VERSION = 0x8B8C + CURRENT_PROGRAM = 0x8B8D + TEXTURE_RED_TYPE = 0x8C10 + TEXTURE_GREEN_TYPE = 0x8C11 + TEXTURE_BLUE_TYPE = 0x8C12 + TEXTURE_ALPHA_TYPE = 0x8C13 + TEXTURE_LUMINANCE_TYPE = 0x8C14 + TEXTURE_INTENSITY_TYPE = 0x8C15 + TEXTURE_DEPTH_TYPE = 0x8C16 + UNSIGNED_NORMALIZED = 0x8C17 + TEXTURE_1D_ARRAY = 0x8C18 + PROXY_TEXTURE_1D_ARRAY = 0x8C19 + TEXTURE_2D_ARRAY = 0x8C1A + PROXY_TEXTURE_2D_ARRAY = 0x8C1B + TEXTURE_BINDING_1D_ARRAY = 0x8C1C + TEXTURE_BINDING_2D_ARRAY = 0x8C1D + MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = 0x8C29 + TEXTURE_BUFFER = 0x8C2A + MAX_TEXTURE_BUFFER_SIZE = 0x8C2B + TEXTURE_BINDING_BUFFER = 0x8C2C + TEXTURE_BUFFER_DATA_STORE_BINDING = 0x8C2D + ANY_SAMPLES_PASSED = 0x8C2F + SAMPLE_SHADING = 0x8C36 + MIN_SAMPLE_SHADING_VALUE = 0x8C37 + R11F_G11F_B10F = 0x8C3A + UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B + RGB9_E5 = 0x8C3D + UNSIGNED_INT_5_9_9_9_REV = 0x8C3E + TEXTURE_SHARED_SIZE = 0x8C3F + SRGB = 0x8C40 + SRGB8 = 0x8C41 + SRGB_ALPHA = 0x8C42 + SRGB8_ALPHA8 = 0x8C43 + SLUMINANCE_ALPHA = 0x8C44 + SLUMINANCE8_ALPHA8 = 0x8C45 + SLUMINANCE = 0x8C46 + SLUMINANCE8 = 0x8C47 + COMPRESSED_SRGB = 0x8C48 + COMPRESSED_SRGB_ALPHA = 0x8C49 + COMPRESSED_SLUMINANCE = 0x8C4A + COMPRESSED_SLUMINANCE_ALPHA = 0x8C4B + TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76 + TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F + MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80 + TRANSFORM_FEEDBACK_VARYINGS = 0x8C83 + TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84 + TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85 + PRIMITIVES_GENERATED = 0x8C87 + TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88 + RASTERIZER_DISCARD = 0x8C89 + MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A + MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B + INTERLEAVED_ATTRIBS = 0x8C8C + SEPARATE_ATTRIBS = 0x8C8D + TRANSFORM_FEEDBACK_BUFFER = 0x8C8E + TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F + POINT_SPRITE_COORD_ORIGIN = 0x8CA0 + LOWER_LEFT = 0x8CA1 + UPPER_LEFT = 0x8CA2 + STENCIL_BACK_REF = 0x8CA3 + STENCIL_BACK_VALUE_MASK = 0x8CA4 + STENCIL_BACK_WRITEMASK = 0x8CA5 + DRAW_FRAMEBUFFER_BINDING = 0x8CA6 + FRAMEBUFFER_BINDING = 0x8CA6 + RENDERBUFFER_BINDING = 0x8CA7 + READ_FRAMEBUFFER = 0x8CA8 + DRAW_FRAMEBUFFER = 0x8CA9 + READ_FRAMEBUFFER_BINDING = 0x8CAA + RENDERBUFFER_SAMPLES = 0x8CAB + DEPTH_COMPONENT32F = 0x8CAC + DEPTH32F_STENCIL8 = 0x8CAD + FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0 + FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1 + FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2 + FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3 + FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4 + FRAMEBUFFER_COMPLETE = 0x8CD5 + FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6 + FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7 + FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB + FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC + FRAMEBUFFER_UNSUPPORTED = 0x8CDD + MAX_COLOR_ATTACHMENTS = 0x8CDF + COLOR_ATTACHMENT0 = 0x8CE0 + COLOR_ATTACHMENT1 = 0x8CE1 + COLOR_ATTACHMENT2 = 0x8CE2 + COLOR_ATTACHMENT3 = 0x8CE3 + COLOR_ATTACHMENT4 = 0x8CE4 + COLOR_ATTACHMENT5 = 0x8CE5 + COLOR_ATTACHMENT6 = 0x8CE6 + COLOR_ATTACHMENT7 = 0x8CE7 + COLOR_ATTACHMENT8 = 0x8CE8 + COLOR_ATTACHMENT9 = 0x8CE9 + COLOR_ATTACHMENT10 = 0x8CEA + COLOR_ATTACHMENT11 = 0x8CEB + COLOR_ATTACHMENT12 = 0x8CEC + COLOR_ATTACHMENT13 = 0x8CED + COLOR_ATTACHMENT14 = 0x8CEE + COLOR_ATTACHMENT15 = 0x8CEF + DEPTH_ATTACHMENT = 0x8D00 + STENCIL_ATTACHMENT = 0x8D20 + FRAMEBUFFER = 0x8D40 + RENDERBUFFER = 0x8D41 + RENDERBUFFER_WIDTH = 0x8D42 + RENDERBUFFER_HEIGHT = 0x8D43 + RENDERBUFFER_INTERNAL_FORMAT = 0x8D44 + STENCIL_INDEX1 = 0x8D46 + STENCIL_INDEX4 = 0x8D47 + STENCIL_INDEX8 = 0x8D48 + STENCIL_INDEX16 = 0x8D49 + RENDERBUFFER_RED_SIZE = 0x8D50 + RENDERBUFFER_GREEN_SIZE = 0x8D51 + RENDERBUFFER_BLUE_SIZE = 0x8D52 + RENDERBUFFER_ALPHA_SIZE = 0x8D53 + RENDERBUFFER_DEPTH_SIZE = 0x8D54 + RENDERBUFFER_STENCIL_SIZE = 0x8D55 + FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56 + MAX_SAMPLES = 0x8D57 + RGBA32UI = 0x8D70 + RGB32UI = 0x8D71 + RGBA16UI = 0x8D76 + RGB16UI = 0x8D77 + RGBA8UI = 0x8D7C + RGB8UI = 0x8D7D + RGBA32I = 0x8D82 + RGB32I = 0x8D83 + RGBA16I = 0x8D88 + RGB16I = 0x8D89 + RGBA8I = 0x8D8E + RGB8I = 0x8D8F + RED_INTEGER = 0x8D94 + GREEN_INTEGER = 0x8D95 + BLUE_INTEGER = 0x8D96 + ALPHA_INTEGER = 0x8D97 + RGB_INTEGER = 0x8D98 + RGBA_INTEGER = 0x8D99 + BGR_INTEGER = 0x8D9A + BGRA_INTEGER = 0x8D9B + INT_2_10_10_10_REV = 0x8D9F + FRAMEBUFFER_ATTACHMENT_LAYERED = 0x8DA7 + FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = 0x8DA8 + FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD + FRAMEBUFFER_SRGB = 0x8DB9 + COMPRESSED_RED_RGTC1 = 0x8DBB + COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC + COMPRESSED_RG_RGTC2 = 0x8DBD + COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE + SAMPLER_1D_ARRAY = 0x8DC0 + SAMPLER_2D_ARRAY = 0x8DC1 + SAMPLER_BUFFER = 0x8DC2 + SAMPLER_1D_ARRAY_SHADOW = 0x8DC3 + SAMPLER_2D_ARRAY_SHADOW = 0x8DC4 + SAMPLER_CUBE_SHADOW = 0x8DC5 + UNSIGNED_INT_VEC2 = 0x8DC6 + UNSIGNED_INT_VEC3 = 0x8DC7 + UNSIGNED_INT_VEC4 = 0x8DC8 + INT_SAMPLER_1D = 0x8DC9 + INT_SAMPLER_2D = 0x8DCA + INT_SAMPLER_3D = 0x8DCB + INT_SAMPLER_CUBE = 0x8DCC + INT_SAMPLER_2D_RECT = 0x8DCD + INT_SAMPLER_1D_ARRAY = 0x8DCE + INT_SAMPLER_2D_ARRAY = 0x8DCF + INT_SAMPLER_BUFFER = 0x8DD0 + UNSIGNED_INT_SAMPLER_1D = 0x8DD1 + UNSIGNED_INT_SAMPLER_2D = 0x8DD2 + UNSIGNED_INT_SAMPLER_3D = 0x8DD3 + UNSIGNED_INT_SAMPLER_CUBE = 0x8DD4 + UNSIGNED_INT_SAMPLER_2D_RECT = 0x8DD5 + UNSIGNED_INT_SAMPLER_1D_ARRAY = 0x8DD6 + UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8DD7 + UNSIGNED_INT_SAMPLER_BUFFER = 0x8DD8 + GEOMETRY_SHADER = 0x8DD9 + MAX_GEOMETRY_UNIFORM_COMPONENTS = 0x8DDF + MAX_GEOMETRY_OUTPUT_VERTICES = 0x8DE0 + MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = 0x8DE1 + ACTIVE_SUBROUTINES = 0x8DE5 + ACTIVE_SUBROUTINE_UNIFORMS = 0x8DE6 + MAX_SUBROUTINES = 0x8DE7 + MAX_SUBROUTINE_UNIFORM_LOCATIONS = 0x8DE8 + QUERY_WAIT = 0x8E13 + QUERY_NO_WAIT = 0x8E14 + QUERY_BY_REGION_WAIT = 0x8E15 + QUERY_BY_REGION_NO_WAIT = 0x8E16 + MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E1E + MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E1F + TRANSFORM_FEEDBACK = 0x8E22 + TRANSFORM_FEEDBACK_BUFFER_PAUSED = 0x8E23 + TRANSFORM_FEEDBACK_BUFFER_ACTIVE = 0x8E24 + TRANSFORM_FEEDBACK_BINDING = 0x8E25 + TIMESTAMP = 0x8E28 + TEXTURE_SWIZZLE_R = 0x8E42 + TEXTURE_SWIZZLE_G = 0x8E43 + TEXTURE_SWIZZLE_B = 0x8E44 + TEXTURE_SWIZZLE_A = 0x8E45 + TEXTURE_SWIZZLE_RGBA = 0x8E46 + ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS = 0x8E47 + ACTIVE_SUBROUTINE_MAX_LENGTH = 0x8E48 + ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH = 0x8E49 + NUM_COMPATIBLE_SUBROUTINES = 0x8E4A + COMPATIBLE_SUBROUTINES = 0x8E4B + QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = 0x8E4C + FIRST_VERTEX_CONVENTION = 0x8E4D + LAST_VERTEX_CONVENTION = 0x8E4E + PROVOKING_VERTEX = 0x8E4F + SAMPLE_POSITION = 0x8E50 + SAMPLE_MASK = 0x8E51 + SAMPLE_MASK_VALUE = 0x8E52 + MAX_SAMPLE_MASK_WORDS = 0x8E59 + MAX_GEOMETRY_SHADER_INVOCATIONS = 0x8E5A + MIN_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5B + MAX_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5C + FRAGMENT_INTERPOLATION_OFFSET_BITS = 0x8E5D + MIN_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5E + MAX_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5F + MAX_TRANSFORM_FEEDBACK_BUFFERS = 0x8E70 + MAX_VERTEX_STREAMS = 0x8E71 + PATCH_VERTICES = 0x8E72 + PATCH_DEFAULT_INNER_LEVEL = 0x8E73 + PATCH_DEFAULT_OUTER_LEVEL = 0x8E74 + TESS_CONTROL_OUTPUT_VERTICES = 0x8E75 + TESS_GEN_MODE = 0x8E76 + TESS_GEN_SPACING = 0x8E77 + TESS_GEN_VERTEX_ORDER = 0x8E78 + TESS_GEN_POINT_MODE = 0x8E79 + ISOLINES = 0x8E7A + FRACTIONAL_ODD = 0x8E7B + FRACTIONAL_EVEN = 0x8E7C + MAX_PATCH_VERTICES = 0x8E7D + MAX_TESS_GEN_LEVEL = 0x8E7E + MAX_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E7F + MAX_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E80 + MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS = 0x8E81 + MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS = 0x8E82 + MAX_TESS_CONTROL_OUTPUT_COMPONENTS = 0x8E83 + MAX_TESS_PATCH_COMPONENTS = 0x8E84 + MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS = 0x8E85 + MAX_TESS_EVALUATION_OUTPUT_COMPONENTS = 0x8E86 + TESS_EVALUATION_SHADER = 0x8E87 + TESS_CONTROL_SHADER = 0x8E88 + MAX_TESS_CONTROL_UNIFORM_BLOCKS = 0x8E89 + MAX_TESS_EVALUATION_UNIFORM_BLOCKS = 0x8E8A + COPY_READ_BUFFER = 0x8F36 + COPY_WRITE_BUFFER = 0x8F37 + DRAW_INDIRECT_BUFFER = 0x8F3F + DRAW_INDIRECT_BUFFER_BINDING = 0x8F43 + DOUBLE_MAT2 = 0x8F46 + DOUBLE_MAT3 = 0x8F47 + DOUBLE_MAT4 = 0x8F48 + DOUBLE_MAT2x3 = 0x8F49 + DOUBLE_MAT2x4 = 0x8F4A + DOUBLE_MAT3x2 = 0x8F4B + DOUBLE_MAT3x4 = 0x8F4C + DOUBLE_MAT4x2 = 0x8F4D + DOUBLE_MAT4x3 = 0x8F4E + R8_SNORM = 0x8F94 + RG8_SNORM = 0x8F95 + RGB8_SNORM = 0x8F96 + RGBA8_SNORM = 0x8F97 + R16_SNORM = 0x8F98 + RG16_SNORM = 0x8F99 + RGB16_SNORM = 0x8F9A + RGBA16_SNORM = 0x8F9B + SIGNED_NORMALIZED = 0x8F9C + PRIMITIVE_RESTART = 0x8F9D + PRIMITIVE_RESTART_INDEX = 0x8F9E + DOUBLE_VEC2 = 0x8FFC + DOUBLE_VEC3 = 0x8FFD + DOUBLE_VEC4 = 0x8FFE + TEXTURE_CUBE_MAP_ARRAY = 0x9009 + TEXTURE_BINDING_CUBE_MAP_ARRAY = 0x900A + PROXY_TEXTURE_CUBE_MAP_ARRAY = 0x900B + SAMPLER_CUBE_MAP_ARRAY = 0x900C + SAMPLER_CUBE_MAP_ARRAY_SHADOW = 0x900D + INT_SAMPLER_CUBE_MAP_ARRAY = 0x900E + UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY = 0x900F + RGB10_A2UI = 0x906F + TEXTURE_2D_MULTISAMPLE = 0x9100 + PROXY_TEXTURE_2D_MULTISAMPLE = 0x9101 + TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9102 + PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9103 + TEXTURE_BINDING_2D_MULTISAMPLE = 0x9104 + TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = 0x9105 + TEXTURE_SAMPLES = 0x9106 + TEXTURE_FIXED_SAMPLE_LOCATIONS = 0x9107 + SAMPLER_2D_MULTISAMPLE = 0x9108 + INT_SAMPLER_2D_MULTISAMPLE = 0x9109 + UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = 0x910A + SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910B + INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910C + UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910D + MAX_COLOR_TEXTURE_SAMPLES = 0x910E + MAX_DEPTH_TEXTURE_SAMPLES = 0x910F + MAX_INTEGER_SAMPLES = 0x9110 + MAX_SERVER_WAIT_TIMEOUT = 0x9111 + OBJECT_TYPE = 0x9112 + SYNC_CONDITION = 0x9113 + SYNC_STATUS = 0x9114 + SYNC_FLAGS = 0x9115 + SYNC_FENCE = 0x9116 + SYNC_GPU_COMMANDS_COMPLETE = 0x9117 + UNSIGNALED = 0x9118 + SIGNALED = 0x9119 + ALREADY_SIGNALED = 0x911A + TIMEOUT_EXPIRED = 0x911B + CONDITION_SATISFIED = 0x911C + WAIT_FAILED = 0x911D + BUFFER_ACCESS_FLAGS = 0x911F + BUFFER_MAP_LENGTH = 0x9120 + BUFFER_MAP_OFFSET = 0x9121 + MAX_VERTEX_OUTPUT_COMPONENTS = 0x9122 + MAX_GEOMETRY_INPUT_COMPONENTS = 0x9123 + MAX_GEOMETRY_OUTPUT_COMPONENTS = 0x9124 + MAX_FRAGMENT_INPUT_COMPONENTS = 0x9125 + CONTEXT_PROFILE_MASK = 0x9126 +) + +// https://www.opengl.org/sdk/docs/man4/xhtml/glViewport.xml +func (gl *GL) Viewport(x, y, width, height int) { + C.gl4_0compat_glViewport(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// DepthRange specifies the mapping of depth values from normalized device +// coordinates to window coordinates. +// +// Parameter nearVal specifies the mapping of the near clipping plane to window +// coordinates (defaults to 0), while farVal specifies the mapping of the far +// clipping plane to window coordinates (defaults to 1). +// +// After clipping and division by w, depth coordinates range from -1 to 1, +// corresponding to the near and far clipping planes. DepthRange specifies a +// linear mapping of the normalized depth coordinates in this range to window +// depth coordinates. Regardless of the actual depth buffer implementation, +// window coordinate depth values are treated as though they range from 0 through 1 +// (like color components). Thus, the values accepted by DepthRange are both +// clamped to this range before they are accepted. +// +// The default setting of (0, 1) maps the near plane to 0 and the far plane to 1. +// With this mapping, the depth buffer range is fully utilized. +// +// It is not necessary that nearVal be less than farVal. Reverse mappings such as +// nearVal 1, and farVal 0 are acceptable. +// +// GL.INVALID_OPERATION is generated if DepthRange is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) DepthRange(nearVal, farVal float64) { + C.gl4_0compat_glDepthRange(gl.funcs, C.GLdouble(nearVal), C.GLdouble(farVal)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsEnabled.xml +func (gl *GL) IsEnabled(cap glbase.Enum) bool { + glresult := C.gl4_0compat_glIsEnabled(gl.funcs, C.GLenum(cap)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexLevelParameteriv.xml +func (gl *GL) GetTexLevelParameteriv(target glbase.Enum, level int, pname glbase.Enum, params []int32) { + C.gl4_0compat_glGetTexLevelParameteriv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexLevelParameterfv.xml +func (gl *GL) GetTexLevelParameterfv(target glbase.Enum, level int, pname glbase.Enum, params []float32) { + C.gl4_0compat_glGetTexLevelParameterfv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameteriv.xml +func (gl *GL) GetTexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_0compat_glGetTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameterfv.xml +func (gl *GL) GetTexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_0compat_glGetTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexImage.xml +func (gl *GL) GetTexImage(target glbase.Enum, level int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glGetTexImage(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetIntegerv.xml +func (gl *GL) GetIntegerv(pname glbase.Enum, params []int32) { + C.gl4_0compat_glGetIntegerv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFloatv.xml +func (gl *GL) GetFloatv(pname glbase.Enum, params []float32) { + C.gl4_0compat_glGetFloatv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetError.xml +func (gl *GL) GetError() glbase.Enum { + glresult := C.gl4_0compat_glGetError(gl.funcs) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetDoublev.xml +func (gl *GL) GetDoublev(pname glbase.Enum, params []float64) { + C.gl4_0compat_glGetDoublev(gl.funcs, C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBooleanv.xml +func (gl *GL) GetBooleanv(pname glbase.Enum, params []bool) { + C.gl4_0compat_glGetBooleanv(gl.funcs, C.GLenum(pname), (*C.GLboolean)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glReadPixels.xml +func (gl *GL) ReadPixels(x, y, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glReadPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glReadBuffer.xml +func (gl *GL) ReadBuffer(mode glbase.Enum) { + C.gl4_0compat_glReadBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelStorei.xml +func (gl *GL) PixelStorei(pname glbase.Enum, param int32) { + C.gl4_0compat_glPixelStorei(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelStoref.xml +func (gl *GL) PixelStoref(pname glbase.Enum, param float32) { + C.gl4_0compat_glPixelStoref(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDepthFunc.xml +func (gl *GL) DepthFunc(glfunc glbase.Enum) { + C.gl4_0compat_glDepthFunc(gl.funcs, C.GLenum(glfunc)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilOp.xml +func (gl *GL) StencilOp(fail, zfail, zpass glbase.Enum) { + C.gl4_0compat_glStencilOp(gl.funcs, C.GLenum(fail), C.GLenum(zfail), C.GLenum(zpass)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilFunc.xml +func (gl *GL) StencilFunc(glfunc glbase.Enum, ref int32, mask uint32) { + C.gl4_0compat_glStencilFunc(gl.funcs, C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLogicOp.xml +func (gl *GL) LogicOp(opcode glbase.Enum) { + C.gl4_0compat_glLogicOp(gl.funcs, C.GLenum(opcode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFunc.xml +func (gl *GL) BlendFunc(sfactor, dfactor glbase.Enum) { + C.gl4_0compat_glBlendFunc(gl.funcs, C.GLenum(sfactor), C.GLenum(dfactor)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFlush.xml +func (gl *GL) Flush() { + C.gl4_0compat_glFlush(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFinish.xml +func (gl *GL) Finish() { + C.gl4_0compat_glFinish(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEnable.xml +func (gl *GL) Enable(cap glbase.Enum) { + C.gl4_0compat_glEnable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDisable.xml +func (gl *GL) Disable(cap glbase.Enum) { + C.gl4_0compat_glDisable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDepthMask.xml +func (gl *GL) DepthMask(flag bool) { + C.gl4_0compat_glDepthMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorMask.xml +func (gl *GL) ColorMask(red, green, blue, alpha bool) { + C.gl4_0compat_glColorMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&red)), *(*C.GLboolean)(unsafe.Pointer(&green)), *(*C.GLboolean)(unsafe.Pointer(&blue)), *(*C.GLboolean)(unsafe.Pointer(&alpha))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilMask.xml +func (gl *GL) StencilMask(mask uint32) { + C.gl4_0compat_glStencilMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearDepth.xml +func (gl *GL) ClearDepth(depth float64) { + C.gl4_0compat_glClearDepth(gl.funcs, C.GLdouble(depth)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearStencil.xml +func (gl *GL) ClearStencil(s int32) { + C.gl4_0compat_glClearStencil(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearColor.xml +func (gl *GL) ClearColor(red, green, blue, alpha float32) { + C.gl4_0compat_glClearColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClear.xml +func (gl *GL) Clear(mask glbase.Bitfield) { + C.gl4_0compat_glClear(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawBuffer.xml +func (gl *GL) DrawBuffer(mode glbase.Enum) { + C.gl4_0compat_glDrawBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage2D.xml +func (gl *GL) TexImage2D(target glbase.Enum, level int, internalFormat int32, width, height, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage1D.xml +func (gl *GL) TexImage1D(target glbase.Enum, level int, internalFormat int32, width, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameteriv.xml +func (gl *GL) TexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_0compat_glTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameteri.xml +func (gl *GL) TexParameteri(target, pname glbase.Enum, param int32) { + C.gl4_0compat_glTexParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterfv.xml +func (gl *GL) TexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_0compat_glTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterf.xml +func (gl *GL) TexParameterf(target, pname glbase.Enum, param float32) { + C.gl4_0compat_glTexParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glScissor.xml +func (gl *GL) Scissor(x, y, width, height int) { + C.gl4_0compat_glScissor(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPolygonMode.xml +func (gl *GL) PolygonMode(face, mode glbase.Enum) { + C.gl4_0compat_glPolygonMode(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointSize.xml +func (gl *GL) PointSize(size float32) { + C.gl4_0compat_glPointSize(gl.funcs, C.GLfloat(size)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLineWidth.xml +func (gl *GL) LineWidth(width float32) { + C.gl4_0compat_glLineWidth(gl.funcs, C.GLfloat(width)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glHint.xml +func (gl *GL) Hint(target, mode glbase.Enum) { + C.gl4_0compat_glHint(gl.funcs, C.GLenum(target), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFrontFace.xml +func (gl *GL) FrontFace(mode glbase.Enum) { + C.gl4_0compat_glFrontFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCullFace.xml +func (gl *GL) CullFace(mode glbase.Enum) { + C.gl4_0compat_glCullFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexubv.xml +func (gl *GL) Indexubv(c []uint8) { + C.gl4_0compat_glIndexubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexub.xml +func (gl *GL) Indexub(c uint8) { + C.gl4_0compat_glIndexub(gl.funcs, C.GLubyte(c)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsTexture.xml +func (gl *GL) IsTexture(texture glbase.Texture) bool { + glresult := C.gl4_0compat_glIsTexture(gl.funcs, C.GLuint(texture)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenTextures returns n texture names in textures. There is no guarantee +// that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenTextures. +// +// The generated textures have no dimensionality; they assume the +// dimensionality of the texture target to which they are first bound (see +// BindTexture). +// +// Texture names returned by a call to GenTextures are not returned by +// subsequent calls, unless they are first deleted with DeleteTextures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenTextures is available in GL version 2.0 or greater. +func (gl *GL) GenTextures(n int) []glbase.Texture { + if n == 0 { + return nil + } + textures := make([]glbase.Texture, n) + C.gl4_0compat_glGenTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) + return textures +} + +// DeleteTextures deletes the textures objects whose names are stored +// in the textures slice. After a texture is deleted, it has no contents or +// dimensionality, and its name is free for reuse (for example by +// GenTextures). If a texture that is currently bound is deleted, the binding +// reverts to 0 (the default texture). +// +// DeleteTextures silently ignores 0's and names that do not correspond to +// existing textures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteTextures is available in GL version 2.0 or greater. +func (gl *GL) DeleteTextures(textures []glbase.Texture) { + n := len(textures) + if n == 0 { + return + } + C.gl4_0compat_glDeleteTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindTexture.xml +func (gl *GL) BindTexture(target glbase.Enum, texture glbase.Texture) { + C.gl4_0compat_glBindTexture(gl.funcs, C.GLenum(target), C.GLuint(texture)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexSubImage2D.xml +func (gl *GL) TexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexSubImage1D.xml +func (gl *GL) TexSubImage1D(target glbase.Enum, level, xoffset, width int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexSubImage2D.xml +func (gl *GL) CopyTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, x, y, width, height int) { + C.gl4_0compat_glCopyTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexSubImage1D.xml +func (gl *GL) CopyTexSubImage1D(target glbase.Enum, level, xoffset, x, y, width int) { + C.gl4_0compat_glCopyTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexImage2D.xml +func (gl *GL) CopyTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, height, border int) { + C.gl4_0compat_glCopyTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexImage1D.xml +func (gl *GL) CopyTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, border int) { + C.gl4_0compat_glCopyTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPolygonOffset.xml +func (gl *GL) PolygonOffset(factor, units float32) { + C.gl4_0compat_glPolygonOffset(gl.funcs, C.GLfloat(factor), C.GLfloat(units)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElements.xml +func (gl *GL) DrawElements(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glDrawElements(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawArrays.xml +func (gl *GL) DrawArrays(mode glbase.Enum, first, count int) { + C.gl4_0compat_glDrawArrays(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexSubImage3D.xml +func (gl *GL) CopyTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, x, y, width, height int) { + C.gl4_0compat_glCopyTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexSubImage3D.xml +func (gl *GL) TexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage3D.xml +func (gl *GL) TexImage3D(target glbase.Enum, level int, internalFormat int32, width, height int, depth int32, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawRangeElements.xml +func (gl *GL) DrawRangeElements(mode glbase.Enum, start, end uint32, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glDrawRangeElements(gl.funcs, C.GLenum(mode), C.GLuint(start), C.GLuint(end), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendEquation.xml +func (gl *GL) BlendEquation(mode glbase.Enum) { + C.gl4_0compat_glBlendEquation(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendColor.xml +func (gl *GL) BlendColor(red, green, blue, alpha float32) { + C.gl4_0compat_glBlendColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetCompressedTexImage.xml +func (gl *GL) GetCompressedTexImage(target glbase.Enum, level int, img interface{}) { + var img_ptr unsafe.Pointer + var img_v = reflect.ValueOf(img) + if img != nil && img_v.Kind() != reflect.Slice { + panic("parameter img must be a slice") + } + if img != nil { + img_ptr = unsafe.Pointer(img_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glGetCompressedTexImage(gl.funcs, C.GLenum(target), C.GLint(level), img_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexSubImage1D.xml +func (gl *GL) CompressedTexSubImage1D(target glbase.Enum, level, xoffset, width int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glCompressedTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexSubImage2D.xml +func (gl *GL) CompressedTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glCompressedTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexSubImage3D.xml +func (gl *GL) CompressedTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glCompressedTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexImage1D.xml +func (gl *GL) CompressedTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, width, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glCompressedTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexImage2D.xml +func (gl *GL) CompressedTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glCompressedTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexImage3D.xml +func (gl *GL) CompressedTexImage3D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height int, depth int32, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glCompressedTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSampleCoverage.xml +func (gl *GL) SampleCoverage(value float32, invert bool) { + C.gl4_0compat_glSampleCoverage(gl.funcs, C.GLfloat(value), *(*C.GLboolean)(unsafe.Pointer(&invert))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glActiveTexture.xml +func (gl *GL) ActiveTexture(texture glbase.Enum) { + C.gl4_0compat_glActiveTexture(gl.funcs, C.GLenum(texture)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointParameteriv.xml +func (gl *GL) PointParameteriv(pname glbase.Enum, params []int32) { + C.gl4_0compat_glPointParameteriv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointParameteri.xml +func (gl *GL) PointParameteri(pname glbase.Enum, param int32) { + C.gl4_0compat_glPointParameteri(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointParameterfv.xml +func (gl *GL) PointParameterfv(pname glbase.Enum, params []float32) { + C.gl4_0compat_glPointParameterfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointParameterf.xml +func (gl *GL) PointParameterf(pname glbase.Enum, param float32) { + C.gl4_0compat_glPointParameterf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiDrawArrays.xml +func (gl *GL) MultiDrawArrays(mode glbase.Enum, first, count []int, drawcount int32) { + C.gl4_0compat_glMultiDrawArrays(gl.funcs, C.GLenum(mode), (*C.GLint)(unsafe.Pointer(&first[0])), (*C.GLsizei)(unsafe.Pointer(&count[0])), C.GLsizei(drawcount)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFuncSeparate.xml +func (gl *GL) BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha glbase.Enum) { + C.gl4_0compat_glBlendFuncSeparate(gl.funcs, C.GLenum(sfactorRGB), C.GLenum(dfactorRGB), C.GLenum(sfactorAlpha), C.GLenum(dfactorAlpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBufferParameteriv.xml +func (gl *GL) GetBufferParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_0compat_glGetBufferParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUnmapBuffer.xml +func (gl *GL) UnmapBuffer(target glbase.Enum) bool { + glresult := C.gl4_0compat_glUnmapBuffer(gl.funcs, C.GLenum(target)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBufferSubData.xml +func (gl *GL) GetBufferSubData(target glbase.Enum, offset, size int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glGetBufferSubData(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(size), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBufferSubData.xml +func (gl *GL) BufferSubData(target glbase.Enum, offset, size int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glBufferSubData(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(size), data_ptr) +} + +// BufferData creates a new data store for the buffer object currently +// bound to target. Any pre-existing data store is deleted. The new data +// store is created with the specified size in bytes and usage. If data is +// not nil, it must be a slice that is used to initialize the data store. +// In that case the size parameter is ignored and the store size will match +// the slice data size. +// +// In its initial state, the new data store is not mapped, it has a NULL +// mapped pointer, and its mapped access is GL.READ_WRITE. +// +// The target constant must be one of GL.ARRAY_BUFFER, GL.COPY_READ_BUFFER, +// GL.COPY_WRITE_BUFFER, GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER, +// GL.PIXEL_UNPACK_BUFFER, GL.TEXTURE_BUFFER, GL.TRANSFORM_FEEDBACK_BUFFER, +// or GL.UNIFORM_BUFFER. +// +// The usage parameter is a hint to the GL implementation as to how a buffer +// object's data store will be accessed. This enables the GL implementation +// to make more intelligent decisions that may significantly impact buffer +// object performance. It does not, however, constrain the actual usage of +// the data store. usage can be broken down into two parts: first, the +// frequency of access (modification and usage), and second, the nature of +// that access. +// +// A usage frequency of STREAM and nature of DRAW is specified via the +// constant GL.STREAM_DRAW, for example. +// +// The usage frequency of access may be one of: +// +// STREAM +// The data store contents will be modified once and used at most a few times. +// +// STATIC +// The data store contents will be modified once and used many times. +// +// DYNAMIC +// The data store contents will be modified repeatedly and used many times. +// +// The usage nature of access may be one of: +// +// DRAW +// The data store contents are modified by the application, and used as +// the source for GL drawing and image specification commands. +// +// READ +// The data store contents are modified by reading data from the GL, +// and used to return that data when queried by the application. +// +// COPY +// The data store contents are modified by reading data from the GL, +// and used as the source for GL drawing and image specification +// commands. +// +// Clients must align data elements consistent with the requirements of the +// client platform, with an additional base-level requirement that an offset +// within a buffer to a datum comprising N bytes be a multiple of N. +// +// Error GL.INVALID_ENUM is generated if target is not one of the accepted +// buffer targets. GL.INVALID_ENUM is generated if usage is not +// GL.STREAM_DRAW, GL.STREAM_READ, GL.STREAM_COPY, GL.STATIC_DRAW, +// GL.STATIC_READ, GL.STATIC_COPY, GL.DYNAMIC_DRAW, GL.DYNAMIC_READ, or +// GL.DYNAMIC_COPY. GL.INVALID_VALUE is generated if size is negative. +// GL.INVALID_OPERATION is generated if the reserved buffer object name 0 is +// bound to target. GL.OUT_OF_MEMORY is generated if the GL is unable to +// create a data store with the specified size. +func (gl *GL) BufferData(target glbase.Enum, size int, data interface{}, usage glbase.Enum) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + if data != nil { + size = int(data_v.Type().Size()) * data_v.Len() + } + C.gl4_0compat_glBufferData(gl.funcs, C.GLenum(target), C.GLsizeiptr(size), data_ptr, C.GLenum(usage)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsBuffer.xml +func (gl *GL) IsBuffer(buffer glbase.Buffer) bool { + glresult := C.gl4_0compat_glIsBuffer(gl.funcs, C.GLuint(buffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenBuffers returns n buffer object names. There is no guarantee that +// the names form a contiguous set of integers; however, it is guaranteed +// that none of the returned names was in use immediately before the call to +// GenBuffers. +// +// Buffer object names returned by a call to GenBuffers are not returned by +// subsequent calls, unless they are first deleted with DeleteBuffers. +// +// No buffer objects are associated with the returned buffer object names +// until they are first bound by calling BindBuffer. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if GenBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// GenBuffers is available in GL version 1.5 or greater. +func (gl *GL) GenBuffers(n int) []glbase.Buffer { + if n == 0 { + return nil + } + buffers := make([]glbase.Buffer, n) + C.gl4_0compat_glGenBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) + return buffers +} + +// DeleteBuffers deletes the buffer objects whose names are stored in the +// buffers slice. +// +// After a buffer object is deleted, it has no contents, and its name is free +// for reuse (for example by GenBuffers). If a buffer object that is +// currently bound is deleted, the binding reverts to 0 (the absence of any +// buffer object, which reverts to client memory usage). +// +// DeleteBuffers silently ignores 0's and names that do not correspond to +// existing buffer objects. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if DeleteBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// DeleteBuffers is available in GL version 1.5 or greater. +func (gl *GL) DeleteBuffers(buffers []glbase.Buffer) { + n := len(buffers) + if n == 0 { + return + } + C.gl4_0compat_glDeleteBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) +} + +// BindBuffer creates or puts in use a named buffer object. +// Calling BindBuffer with target set to GL.ARRAY_BUFFER, +// GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER or GL.PIXEL_UNPACK_BUFFER +// and buffer set to the name of the new buffer object binds the buffer +// object name to the target. When a buffer object is bound to a target, the +// previous binding for that target is automatically broken. +// +// Buffer object names are unsigned integers. The value zero is reserved, but +// there is no default buffer object for each buffer object target. Instead, +// buffer set to zero effectively unbinds any buffer object previously bound, +// and restores client memory usage for that buffer object target. Buffer +// object names and the corresponding buffer object contents are local to the +// shared display-list space (see XCreateContext) of the current GL rendering +// context; two rendering contexts share buffer object names only if they +// also share display lists. +// +// GenBuffers may be called to generate a set of new buffer object names. +// +// The state of a buffer object immediately after it is first bound is an +// unmapped zero-sized memory buffer with GL.READ_WRITE access and +// GL.STATIC_DRAW usage. +// +// While a non-zero buffer object name is bound, GL operations on the target +// to which it is bound affect the bound buffer object, and queries of the +// target to which it is bound return state from the bound buffer object. +// While buffer object name zero is bound, as in the initial state, attempts +// to modify or query state on the target to which it is bound generates an +// GL.INVALID_OPERATION error. +// +// When vertex array pointer state is changed, for example by a call to +// NormalPointer, the current buffer object binding (GL.ARRAY_BUFFER_BINDING) +// is copied into the corresponding client state for the vertex array type +// being changed, for example GL.NORMAL_ARRAY_BUFFER_BINDING. While a +// non-zero buffer object is bound to the GL.ARRAY_BUFFER target, the vertex +// array pointer parameter that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.ELEMENT_ARRAY_BUFFER +// target, the indices parameter of DrawElements, DrawRangeElements, or +// MultiDrawElements that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_PACK_BUFFER +// target, the following commands are affected: GetCompressedTexImage, +// GetConvolutionFilter, GetHistogram, GetMinmax, GetPixelMap, +// GetPolygonStipple, GetSeparableFilter, GetTexImage, and ReadPixels. The +// pointer parameter that is traditionally interpreted as a pointer to +// client-side memory where the pixels are to be packed is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_UNPACK_BUFFER +// target, the following commands are affected: Bitmap, ColorSubTable, +// ColorTable, CompressedTexImage1D, CompressedTexImage2D, +// CompressedTexImage3D, CompressedTexSubImage1D, CompressedTexSubImage2D, +// CompressedTexSubImage3D, ConvolutionFilter1D, ConvolutionFilter2D, +// DrawPixels, PixelMap, PolygonStipple, SeparableFilter2D, TexImage1D, +// TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, and TexSubImage3D. +// The pointer parameter that is traditionally interpreted as a pointer to +// client-side memory from which the pixels are to be unpacked is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// A buffer object binding created with BindBuffer remains active until a +// different buffer object name is bound to the same target, or until the +// bound buffer object is deleted with DeleteBuffers. +// +// Once created, a named buffer object may be re-bound to any target as often +// as needed. However, the GL implementation may make choices about how to +// optimize the storage of a buffer object based on its initial binding +// target. +// +// Error GL.INVALID_ENUM is generated if target is not one of the allowable +// values. GL.INVALID_OPERATION is generated if BindBuffer is executed +// between the execution of Begin and the corresponding execution of End. +// +// BindBuffer is available in GL version 1.5 or greater. +func (gl *GL) BindBuffer(target glbase.Enum, buffer glbase.Buffer) { + C.gl4_0compat_glBindBuffer(gl.funcs, C.GLenum(target), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryObjectuiv.xml +func (gl *GL) GetQueryObjectuiv(id uint32, pname glbase.Enum, params []uint32) { + C.gl4_0compat_glGetQueryObjectuiv(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryObjectiv.xml +func (gl *GL) GetQueryObjectiv(id uint32, pname glbase.Enum, params []int32) { + C.gl4_0compat_glGetQueryObjectiv(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryiv.xml +func (gl *GL) GetQueryiv(target, pname glbase.Enum, params []int32) { + C.gl4_0compat_glGetQueryiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndQuery.xml +func (gl *GL) EndQuery(target glbase.Enum) { + C.gl4_0compat_glEndQuery(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBeginQuery.xml +func (gl *GL) BeginQuery(target glbase.Enum, id uint32) { + C.gl4_0compat_glBeginQuery(gl.funcs, C.GLenum(target), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsQuery.xml +func (gl *GL) IsQuery(id uint32) bool { + glresult := C.gl4_0compat_glIsQuery(gl.funcs, C.GLuint(id)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteQueries.xml +func (gl *GL) DeleteQueries(n int, ids []uint32) { + C.gl4_0compat_glDeleteQueries(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenQueries.xml +func (gl *GL) GenQueries(n int, ids []uint32) { + C.gl4_0compat_glGenQueries(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// VertexAttribPointer specifies the location and data format of the array +// of generic vertex attributes at index to use when rendering. size +// specifies the number of components per attribute and must be 1, 2, 3, or +// 4. type specifies the data type of each component, and stride specifies +// the byte stride from one attribute to the next, allowing vertices and +// attributes to be packed into a single array or stored in separate arrays. +// normalized indicates whether the values stored in an integer format are +// to be mapped to the range [-1,1] (for signed values) or [0,1] +// (for unsigned values) when they are accessed and converted to floating +// point; otherwise, values will be converted to floats directly without +// normalization. offset is a byte offset into the buffer object's data +// store, which must be bound to the GL.ARRAY_BUFFER target with BindBuffer. +// +// The buffer object binding (GL.ARRAY_BUFFER_BINDING) is saved as +// generic vertex attribute array client-side state +// (GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING) for the provided index. +// +// To enable and disable a generic vertex attribute array, call +// EnableVertexAttribArray and DisableVertexAttribArray with index. If +// enabled, the generic vertex attribute array is used when DrawArrays or +// DrawElements is called. Each generic vertex attribute array is initially +// disabled. +// +// VertexAttribPointer is typically implemented on the client side. +// +// Error GL.INVALID_ENUM is generated if type is not an accepted value. +// GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_VALUE is generated if size is not 1, 2, +// 3, or 4. GL.INVALID_VALUE is generated if stride is negative. +func (gl *GL) VertexAttribPointer(index glbase.Attrib, size int, gltype glbase.Enum, normalized bool, stride int, offset uintptr) { + offset_ptr := unsafe.Pointer(offset) + C.gl4_0compat_glVertexAttribPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLsizei(stride), offset_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glValidateProgram.xml +func (gl *GL) ValidateProgram(program glbase.Program) { + C.gl4_0compat_glValidateProgram(gl.funcs, C.GLuint(program)) +} + +// UniformMatrix4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*4) != 0 { + panic("invalid value length for UniformMatrix4fv") + } + count := len(value) / (4 * 4) + C.gl4_0compat_glUniformMatrix4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*3) != 0 { + panic("invalid value length for UniformMatrix3fv") + } + count := len(value) / (3 * 3) + C.gl4_0compat_glUniformMatrix3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*2) != 0 { + panic("invalid value length for UniformMatrix2fv") + } + count := len(value) / (2 * 2) + C.gl4_0compat_glUniformMatrix2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform4iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4iv") + } + count := len(value) / 4 + C.gl4_0compat_glUniform4iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform3iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3iv") + } + count := len(value) / 3 + C.gl4_0compat_glUniform3iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform2iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2iv") + } + count := len(value) / 2 + C.gl4_0compat_glUniform2iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform1iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl4_0compat_glUniform1iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4fv") + } + count := len(value) / 4 + C.gl4_0compat_glUniform4fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3fv") + } + count := len(value) / 3 + C.gl4_0compat_glUniform3fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2fv") + } + count := len(value) / 2 + C.gl4_0compat_glUniform2fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform1fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl4_0compat_glUniform1fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform4i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4i(location glbase.Uniform, v0, v1, v2, v3 int32) { + C.gl4_0compat_glUniform4i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2), C.GLint(v3)) +} + +// Uniform3i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3i(location glbase.Uniform, v0, v1, v2 int32) { + C.gl4_0compat_glUniform3i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2)) +} + +// Uniform2i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2i(location glbase.Uniform, v0, v1 int32) { + C.gl4_0compat_glUniform2i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1)) +} + +// Uniform1i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1i(location glbase.Uniform, v0 int32) { + C.gl4_0compat_glUniform1i(gl.funcs, C.GLint(location), C.GLint(v0)) +} + +// Uniform4f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4f(location glbase.Uniform, v0, v1, v2, v3 float32) { + C.gl4_0compat_glUniform4f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2), C.GLfloat(v3)) +} + +// Uniform3f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3f(location glbase.Uniform, v0, v1, v2 float32) { + C.gl4_0compat_glUniform3f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2)) +} + +// Uniform2f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2f(location glbase.Uniform, v0, v1 float32) { + C.gl4_0compat_glUniform2f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1)) +} + +// Uniform1f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1f(location glbase.Uniform, v0 float32) { + C.gl4_0compat_glUniform1f(gl.funcs, C.GLint(location), C.GLfloat(v0)) +} + +// UseProgram installs the program object specified by program as part of +// current rendering state. One or more executables are created in a program +// object by successfully attaching shader objects to it with AttachShader, +// successfully compiling the shader objects with CompileShader, and +// successfully linking the program object with LinkProgram. +// +// A program object will contain an executable that will run on the vertex +// processor if it contains one or more shader objects of type +// GL.VERTEX_SHADER that have been successfully compiled and linked. +// Similarly, a program object will contain an executable that will run on +// the fragment processor if it contains one or more shader objects of type +// GL.FRAGMENT_SHADER that have been successfully compiled and linked. +// +// Successfully installing an executable on a programmable processor will +// cause the corresponding fixed functionality of OpenGL to be disabled. +// Specifically, if an executable is installed on the vertex processor, the +// OpenGL fixed functionality will be disabled as follows. +// +// - The modelview matrix is not applied to vertex coordinates. +// +// - The projection matrix is not applied to vertex coordinates. +// +// - The texture matrices are not applied to texture coordinates. +// +// - Normals are not transformed to eye coordinates. +// +// - Normals are not rescaled or normalized. +// +// - Normalization of GL.AUTO_NORMAL evaluated normals is not performed. +// +// - Texture coordinates are not generated automatically. +// +// - Per-vertex lighting is not performed. +// +// - Color material computations are not performed. +// +// - Color index lighting is not performed. +// +// - This list also applies when setting the current raster position. +// +// The executable that is installed on the vertex processor is expected to +// implement any or all of the desired functionality from the preceding list. +// Similarly, if an executable is installed on the fragment processor, the +// OpenGL fixed functionality will be disabled as follows. +// +// - Texture environment and texture functions are not applied. +// +// - Texture application is not applied. +// +// - Color sum is not applied. +// +// - Fog is not applied. +// +// Again, the fragment shader that is installed is expected to implement any +// or all of the desired functionality from the preceding list. +// +// While a program object is in use, applications are free to modify attached +// shader objects, compile attached shader objects, attach additional shader +// objects, and detach or delete shader objects. None of these operations +// will affect the executables that are part of the current state. However, +// relinking the program object that is currently in use will install the +// program object as part of the current rendering state if the link +// operation was successful (see LinkProgram). If the program object +// currently in use is relinked unsuccessfully, its link status will be set +// to GL.FALSE, but the executables and associated state will remain part of +// the current state until a subsequent call to UseProgram removes it from +// use. After it is removed from use, it cannot be made part of current state +// until it has been successfully relinked. +// +// If program contains shader objects of type GL.VERTEX_SHADER but it does +// not contain shader objects of type GL.FRAGMENT_SHADER, an executable will +// be installed on the vertex processor, but fixed functionality will be used +// for fragment processing. Similarly, if program contains shader objects of +// type GL.FRAGMENT_SHADER but it does not contain shader objects of type +// GL.VERTEX_SHADER, an executable will be installed on the fragment +// processor, but fixed functionality will be used for vertex processing. If +// program is 0, the programmable processors will be disabled, and fixed +// functionality will be used for both vertex and fragment processing. +// +// While a program object is in use, the state that controls the disabled +// fixed functionality may also be updated using the normal OpenGL calls. +// +// Like display lists and texture objects, the name space for program objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// Applications are responsible for providing the synchronization across API +// calls when objects are accessed from different execution threads. +// +// Error GL.INVALID_VALUE is generated if program is neither 0 nor a value +// generated by OpenGL. GL.INVALID_OPERATION is generated if program is not +// a program object. GL.INVALID_OPERATION is generated if program could not +// be made part of current state. GL.INVALID_OPERATION is generated if +// UseProgram is executed between the execution of Begin and the +// corresponding execution of End. +// +// UseProgram is available in GL version 2.0 or greater. +func (gl *GL) UseProgram(program glbase.Program) { + C.gl4_0compat_glUseProgram(gl.funcs, C.GLuint(program)) +} + +// ShaderSource sets the source code in shader to the provided source code. Any source +// code previously stored in the shader object is completely replaced. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_VALUE is generated if count is less than 0. +// GL.INVALID_OPERATION is generated if ShaderSource is executed between the +// execution of Begin and the corresponding execution of End. +// +// ShaderSource is available in GL version 2.0 or greater. +func (gl *GL) ShaderSource(shader glbase.Shader, source ...string) { + count := len(source) + length := make([]int32, count) + source_c := make([]unsafe.Pointer, count) + for i, src := range source { + length[i] = int32(len(src)) + if len(src) > 0 { + source_c[i] = *(*unsafe.Pointer)(unsafe.Pointer(&src)) + } else { + source_c[i] = unsafe.Pointer(uintptr(0)) + } + } + C.gl4_0compat_glShaderSource(gl.funcs, C.GLuint(shader), C.GLsizei(count), (**C.GLchar)(unsafe.Pointer(&source_c[0])), (*C.GLint)(unsafe.Pointer(&length[0]))) +} + +// LinkProgram links the program object specified by program. If any shader +// objects of type GL.VERTEX_SHADER are attached to program, they will be +// used to create an executable that will run on the programmable vertex +// processor. If any shader objects of type GL.FRAGMENT_SHADER are attached +// to program, they will be used to create an executable that will run on the +// programmable fragment processor. +// +// The status of the link operation will be stored as part of the program +// object's state. This value will be set to GL.TRUE if the program object +// was linked without errors and is ready for use, and GL.FALSE otherwise. It +// can be queried by calling GetProgramiv with arguments program and +// GL.LINK_STATUS. +// +// As a result of a successful link operation, all active user-defined +// uniform variables belonging to program will be initialized to 0, and each +// of the program object's active uniform variables will be assigned a +// location that can be queried by calling GetUniformLocation. Also, any +// active user-defined attribute variables that have not been bound to a +// generic vertex attribute index will be bound to one at this time. +// +// Linking of a program object can fail for a number of reasons as specified +// in the OpenGL Shading Language Specification. The following lists some of +// the conditions that will cause a link error. +// +// - The number of active attribute variables supported by the +// implementation has been exceeded. +// +// - The storage limit for uniform variables has been exceeded. +// +// - The number of active uniform variables supported by the implementation +// has been exceeded. +// +// - The main function is missing for the vertex shader or the fragment +// shader. +// +// - A varying variable actually used in the fragment shader is not +// declared in the same way (or is not declared at all) in the vertex +// shader. +// +// - A reference to a function or variable name is unresolved. +// +// - A shared global is declared with two different types or two different +// initial values. +// +// - One or more of the attached shader objects has not been successfully +// compiled. +// +// - Binding a generic attribute matrix caused some rows of the matrix to +// fall outside the allowed maximum of GL.MAX_VERTEX_ATTRIBS. +// +// - Not enough contiguous vertex attribute slots could be found to bind +// attribute matrices. +// +// When a program object has been successfully linked, the program object can +// be made part of current state by calling UseProgram. Whether or not the +// link operation was successful, the program object's information log will +// be overwritten. The information log can be retrieved by calling +// GetProgramInfoLog. +// +// LinkProgram will also install the generated executables as part of the +// current rendering state if the link operation was successful and the +// specified program object is already currently in use as a result of a +// previous call to UseProgram. If the program object currently in use is +// relinked unsuccessfully, its link status will be set to GL.FALSE , but the +// executables and associated state will remain part of the current state +// until a subsequent call to UseProgram removes it from use. After it is +// removed from use, it cannot be made part of current state until it has +// been successfully relinked. +// +// If program contains shader objects of type GL.VERTEX_SHADER but does not +// contain shader objects of type GL.FRAGMENT_SHADER, the vertex shader will +// be linked against the implicit interface for fixed functionality fragment +// processing. Similarly, if program contains shader objects of type +// GL.FRAGMENT_SHADER but it does not contain shader objects of type +// GL.VERTEX_SHADER, the fragment shader will be linked against the implicit +// interface for fixed functionality vertex processing. +// +// The program object's information log is updated and the program is +// generated at the time of the link operation. After the link operation, +// applications are free to modify attached shader objects, compile attached +// shader objects, detach shader objects, delete shader objects, and attach +// additional shader objects. None of these operations affects the +// information log or the program that is part of the program object. +// +// If the link operation is unsuccessful, any information about a previous +// link operation on program is lost (a failed link does not restore the +// old state of program). Certain information can still be retrieved +// from program even after an unsuccessful link operation. See for instance +// GetActiveAttrib and GetActiveUniform. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if LinkProgram is executed +// between the execution of Begin and the corresponding execution of End. +// +// LinkProgram is available in GL version 2.0 or greater. +func (gl *GL) LinkProgram(program glbase.Program) { + C.gl4_0compat_glLinkProgram(gl.funcs, C.GLuint(program)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsShader.xml +func (gl *GL) IsShader(shader glbase.Shader) bool { + glresult := C.gl4_0compat_glIsShader(gl.funcs, C.GLuint(shader)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsProgram.xml +func (gl *GL) IsProgram(program glbase.Program) bool { + glresult := C.gl4_0compat_glIsProgram(gl.funcs, C.GLuint(program)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GetVertexAttribiv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribiv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribiv(index glbase.Attrib, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl4_0compat_glGetVertexAttribiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetVertexAttribfv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribfv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribfv(index glbase.Attrib, pname glbase.Enum, params []float32) { + var params_c [4]float32 + C.gl4_0compat_glGetVertexAttribfv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetVertexAttribdv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribdv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribdv(index glbase.Attrib, pname glbase.Enum, params []float64) { + var params_c [4]float64 + C.gl4_0compat_glGetVertexAttribdv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformiv returns in params the value of the specified uniform +// variable. The type of the uniform variable specified by location +// determines the number of values returned. If the uniform variable is +// defined in the shader as a boolean, int, or float, a single value will be +// returned. If it is defined as a vec2, ivec2, or bvec2, two values will be +// returned. If it is defined as a vec3, ivec3, or bvec3, three values will +// be returned, and so on. To query values stored in uniform variables +// declared as arrays, call GetUniformiv for each element of the array. To +// query values stored in uniform variables declared as structures, call +// GetUniformiv for each field in the structure. The values for uniform +// variables declared as a matrix will be returned in column major order. +// +// The locations assigned to uniform variables are not known until the +// program object is linked. After linking has occurred, the command +// GetUniformLocation can be used to obtain the location of a uniform +// variable. This location value can then be passed to GetUniformiv in order +// to query the current value of the uniform variable. After a program object +// has been linked successfully, the index values for uniform variables +// remain fixed until the next link command occurs. The uniform variable +// values can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if program has not been +// successfully linked. GL.INVALID_OPERATION is generated if location does +// not correspond to a valid uniform variable location for the specified +// program object. GL.INVALID_OPERATION is generated if GetUniformiv is +// executed between the execution of Begin and the corresponding execution of +// End. +// +// GetUniformiv is available in GL version 2.0 or greater. +func (gl *GL) GetUniformiv(program glbase.Program, location glbase.Uniform, params []int32) { + var params_c [4]int32 + C.gl4_0compat_glGetUniformiv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformfv returns in params the value of the specified uniform +// variable. The type of the uniform variable specified by location +// determines the number of values returned. If the uniform variable is +// defined in the shader as a boolean, int, or float, a single value will be +// returned. If it is defined as a vec2, ivec2, or bvec2, two values will be +// returned. If it is defined as a vec3, ivec3, or bvec3, three values will +// be returned, and so on. To query values stored in uniform variables +// declared as arrays, call GetUniformfv for each element of the array. To +// query values stored in uniform variables declared as structures, call +// GetUniformfv for each field in the structure. The values for uniform +// variables declared as a matrix will be returned in column major order. +// +// The locations assigned to uniform variables are not known until the +// program object is linked. After linking has occurred, the command +// GetUniformLocation can be used to obtain the location of a uniform +// variable. This location value can then be passed to GetUniformfv in order +// to query the current value of the uniform variable. After a program object +// has been linked successfully, the index values for uniform variables +// remain fixed until the next link command occurs. The uniform variable +// values can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if program has not been +// successfully linked. GL.INVALID_OPERATION is generated if location does +// not correspond to a valid uniform variable location for the specified +// program object. GL.INVALID_OPERATION is generated if GetUniformfv is +// executed between the execution of Begin and the corresponding execution of +// End. +// +// GetUniformfv is available in GL version 2.0 or greater. +func (gl *GL) GetUniformfv(program glbase.Program, location glbase.Uniform, params []float32) { + var params_c [4]float32 + C.gl4_0compat_glGetUniformfv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLfloat)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformLocation returns an integer that represents the location of a +// specific uniform variable within a program object. name must be an active +// uniform variable name in program that is not a structure, an array of +// structures, or a subcomponent of a vector or a matrix. This function +// returns -1 if name does not correspond to an active uniform variable in +// program or if name starts with the reserved prefix "gl_". +// +// Uniform variables that are structures or arrays of structures may be +// queried by calling GetUniformLocation for each field within the +// structure. The array element operator "[]" and the structure field +// operator "." may be used in name in order to select elements within an +// array or fields within a structure. The result of using these operators is +// not allowed to be another structure, an array of structures, or a +// subcomponent of a vector or a matrix. Except if the last part of name +// indicates a uniform variable array, the location of the first element of +// an array can be retrieved by using the name of the array, or by using the +// name appended by "[0]". +// +// The actual locations assigned to uniform variables are not known until the +// program object is linked successfully. After linking has occurred, the +// command GetUniformLocation can be used to obtain the location of a +// uniform variable. This location value can then be passed to Uniform to +// set the value of the uniform variable or to GetUniform in order to query +// the current value of the uniform variable. After a program object has been +// linked successfully, the index values for uniform variables remain fixed +// until the next link command occurs. Uniform variable locations and values +// can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program object. +// GL.INVALID_OPERATION is generated if program has not been successfully +// linked. GL.INVALID_OPERATION is generated if GetUniformLocation is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetUniformLocation is available in GL version 2.0 or greater. +func (gl *GL) GetUniformLocation(program glbase.Program, name string) glbase.Uniform { + name_cstr := C.CString(name) + glresult := C.gl4_0compat_glGetUniformLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) + return glbase.Uniform(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetShaderSource.xml +func (gl *GL) GetShaderSource(shader glbase.Shader, bufSize int32, length []int32, source []byte) { + C.gl4_0compat_glGetShaderSource(gl.funcs, C.GLuint(shader), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&source[0]))) +} + +// GetShaderInfoLog returns the information log for the specified shader +// object. The information log for a shader object is modified when the +// shader is compiled. +// +// The information log for a shader object is a string that may contain +// diagnostic messages, warning messages, and other information about the +// last compile operation. When a shader object is created, its information +// log will be a string of length 0, and the size of the current log can be +// obtained by calling GetShaderiv with the value GL.INFO_LOG_LENGTH. +// +// The information log for a shader object is the OpenGL implementer's +// primary mechanism for conveying information about the compilation process. +// Therefore, the information log can be helpful to application developers +// during the development process, even when compilation is successful. +// Application developers should not expect different OpenGL implementations +// to produce identical information logs. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_VALUE is generated if maxLength is less than 0. +// GL.INVALID_OPERATION is generated if GetShaderInfoLog is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetShaderInfoLog is available in GL version 2.0 or greater. +func (gl *GL) GetShaderInfoLog(shader glbase.Shader) []byte { + var params [1]int32 + var length int32 + gl.GetShaderiv(shader, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + C.gl4_0compat_glGetShaderInfoLog(gl.funcs, C.GLuint(shader), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length)), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) + return infoLog +} + +// GetShaderiv GetShader returns in params the value of a parameter for a specific +// shader object. The following parameters are defined: +// +// GL.SHADER_TYPE +// params returns GL.VERTEX_SHADER if shader is a vertex shader object, +// and GL.FRAGMENT_SHADER if shader is a fragment shader object. +// +// GL.DELETE_STATUS +// params returns GL.TRUE if shader is currently flagged for deletion, +// and GL.FALSE otherwise. +// +// GL.COMPILE_STATUS +// params returns GL.TRUE if the last compile operation on shader was +// successful, and GL.FALSE otherwise. +// +// GL.INFO_LOG_LENGTH +// params returns the number of characters in the information log for +// shader including the null termination character (the size of the +// character buffer required to store the information log). If shader has +// no information log, a value of 0 is returned. +// +// GL.SHADER_SOURCE_LENGTH +// params returns the length of the concatenation of the source strings +// that make up the shader source for the shader, including the null +// termination character. (the size of the character buffer +// required to store the shader source). If no source code exists, 0 is +// returned. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader does not refer to a +// shader object. GL.INVALID_ENUM is generated if pname is not an accepted +// value. GL.INVALID_OPERATION is generated if GetShader is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetShaderiv is available in GL version 2.0 or greater. +func (gl *GL) GetShaderiv(shader glbase.Shader, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl4_0compat_glGetShaderiv(gl.funcs, C.GLuint(shader), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetProgramInfoLog returns the information log for the specified program +// object. The information log for a program object is modified when the +// program object is linked or validated. +// +// The information log for a program object is either an empty string, or a +// string containing information about the last link operation, or a string +// containing information about the last validation operation. It may contain +// diagnostic messages, warning messages, and other information. When a +// program object is created, its information log will be a string of length +// 0, and the size of the current log can be obtained by calling GetProgramiv +// with the value GL.INFO_LOG_LENGTH. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated +// by OpenGL. GL.INVALID_OPERATION is generated if program is not a +// program object. +func (gl *GL) GetProgramInfoLog(program glbase.Program) []byte { + var params [1]int32 + var length int32 + gl.GetProgramiv(program, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + C.gl4_0compat_glGetProgramInfoLog(gl.funcs, C.GLuint(program), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length)), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) + return infoLog +} + +// GetProgramiv returns in params the value of a parameter for a specific +// program object. The following parameters are defined: +// +// GL.DELETE_STATUS +// params returns GL.TRUE if program is currently flagged for deletion, +// and GL.FALSE otherwise. +// +// GL.LINK_STATUS +// params returns GL.TRUE if the last link operation on program was +// successful, and GL.FALSE otherwise. +// +// GL.VALIDATE_STATUS +// params returns GL.TRUE or if the last validation operation on +// program was successful, and GL.FALSE otherwise. +// +// GL.INFO_LOG_LENGTH +// params returns the number of characters in the information log for +// program including the null termination character (the size of +// the character buffer required to store the information log). If +// program has no information log, a value of 0 is returned. +// +// GL.ATTACHED_SHADERS +// params returns the number of shader objects attached to program. +// +// GL.ACTIVE_ATTRIBUTES +// params returns the number of active attribute variables for program. +// +// GL.ACTIVE_ATTRIBUTE_MAX_LENGTH +// params returns the length of the longest active attribute name for +// program, including the null termination character (the size of +// the character buffer required to store the longest attribute name). +// If no active attributes exist, 0 is returned. +// +// GL.ACTIVE_UNIFORMS +// params returns the number of active uniform variables for program. +// +// GL.ACTIVE_UNIFORM_MAX_LENGTH +// params returns the length of the longest active uniform variable +// name for program, including the null termination character (i.e., +// the size of the character buffer required to store the longest +// uniform variable name). If no active uniform variables exist, 0 is +// returned. +// +// GL.TRANSFORM_FEEDBACK_BUFFER_MODE +// params returns a symbolic constant indicating the buffer mode used +// when transform feedback is active. This may be GL.SEPARATE_ATTRIBS +// or GL.INTERLEAVED_ATTRIBS. +// +// GL.TRANSFORM_FEEDBACK_VARYINGS +// params returns the number of varying variables to capture in transform +// feedback mode for the program. +// +// GL.TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH +// params returns the length of the longest variable name to be used for +// transform feedback, including the null-terminator. +// +// GL.GEOMETRY_VERTICES_OUT +// params returns the maximum number of vertices that the geometry shader in +// program will output. +// +// GL.GEOMETRY_INPUT_TYPE +// params returns a symbolic constant indicating the primitive type accepted +// as input to the geometry shader contained in program. +// +// GL.GEOMETRY_OUTPUT_TYPE +// params returns a symbolic constant indicating the primitive type that will +// be output by the geometry shader contained in program. +// +// GL.ACTIVE_UNIFORM_BLOCKS and GL.ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH are +// available only if the GL version 3.1 or greater. +// +// GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE and +// GL.GEOMETRY_OUTPUT_TYPE are accepted only if the GL version is 3.2 or +// greater. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program does not refer to a +// program object. GL.INVALID_OPERATION is generated if pname is +// GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE, or +// GL.GEOMETRY_OUTPUT_TYPE, and program does not contain a geometry shader. +// GL.INVALID_ENUM is generated if pname is not an accepted value. +func (gl *GL) GetProgramiv(program glbase.Program, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl4_0compat_glGetProgramiv(gl.funcs, C.GLuint(program), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetAttribLocation queries the previously linked program object specified +// by program for the attribute variable specified by name and returns the +// index of the generic vertex attribute that is bound to that attribute +// variable. If name is a matrix attribute variable, the index of the first +// column of the matrix is returned. If the named attribute variable is not +// an active attribute in the specified program object or if name starts with +// the reserved prefix "gl_", a value of -1 is returned. +// +// The association between an attribute variable name and a generic attribute +// index can be specified at any time by calling BindAttribLocation. +// Attribute bindings do not go into effect until LinkProgram is called. +// After a program object has been linked successfully, the index values for +// attribute variables remain fixed until the next link command occurs. The +// attribute values can only be queried after a link if the link was +// successful. GetAttribLocation returns the binding that actually went +// into effect the last time LinkProgram was called for the specified +// program object. Attribute bindings that have been specified since the last +// link operation are not returned by GetAttribLocation. +// +// Error GL_INVALID_OPERATION is generated if program is not a value +// generated by OpenGL. GL_INVALID_OPERATION is generated if program is not +// a program object. GL_INVALID_OPERATION is generated if program has not +// been successfully linked. GL_INVALID_OPERATION is generated if +// GetAttribLocation is executed between the execution of Begin and the +// corresponding execution of End. +// +// GetAttribLocation is available in GL version 2.0 or greater. +func (gl *GL) GetAttribLocation(program glbase.Program, name string) glbase.Attrib { + name_cstr := C.CString(name) + glresult := C.gl4_0compat_glGetAttribLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) + return glbase.Attrib(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetAttachedShaders.xml +func (gl *GL) GetAttachedShaders(program glbase.Program, maxCount int32, count []int, obj []uint32) { + C.gl4_0compat_glGetAttachedShaders(gl.funcs, C.GLuint(program), C.GLsizei(maxCount), (*C.GLsizei)(unsafe.Pointer(&count[0])), (*C.GLuint)(unsafe.Pointer(&obj[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniform.xml +func (gl *GL) GetActiveUniform(program glbase.Program, index uint32, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl4_0compat_glGetActiveUniform(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveAttrib.xml +func (gl *GL) GetActiveAttrib(program glbase.Program, index glbase.Attrib, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl4_0compat_glGetActiveAttrib(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEnableVertexAttribArray.xml +func (gl *GL) EnableVertexAttribArray(index glbase.Attrib) { + C.gl4_0compat_glEnableVertexAttribArray(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDisableVertexAttribArray.xml +func (gl *GL) DisableVertexAttribArray(index glbase.Attrib) { + C.gl4_0compat_glDisableVertexAttribArray(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDetachShader.xml +func (gl *GL) DetachShader(program glbase.Program, shader glbase.Shader) { + C.gl4_0compat_glDetachShader(gl.funcs, C.GLuint(program), C.GLuint(shader)) +} + +// DeleteShader frees the memory and invalidates the name associated with +// the shader object specified by shader. This command effectively undoes the +// effects of a call to CreateShader. +// +// If a shader object to be deleted is attached to a program object, it will +// be flagged for deletion, but it will not be deleted until it is no longer +// attached to any program object, for any rendering context (it must +// be detached from wherever it was attached before it will be deleted). A +// value of 0 for shader will be silently ignored. +// +// To determine whether an object has been flagged for deletion, call +// GetShader with arguments shader and GL.DELETE_STATUS. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. +// +// DeleteShader is available in GL version 2.0 or greater. +func (gl *GL) DeleteShader(shader glbase.Shader) { + C.gl4_0compat_glDeleteShader(gl.funcs, C.GLuint(shader)) +} + +// DeleteProgram frees the memory and invalidates the name associated with +// the program object specified by program. This command effectively undoes +// the effects of a call to CreateProgram. +// +// If a program object is in use as part of current rendering state, it will +// be flagged for deletion, but it will not be deleted until it is no longer +// part of current state for any rendering context. If a program object to be +// deleted has shader objects attached to it, those shader objects will be +// automatically detached but not deleted unless they have already been +// flagged for deletion by a previous call to DeleteShader. A value of 0 +// for program will be silently ignored. +// +// To determine whether a program object has been flagged for deletion, call +// GetProgram with arguments program and GL.DELETE_STATUS. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. +// +// DeleteProgram is available in GL version 2.0 or greater. +func (gl *GL) DeleteProgram(program glbase.Program) { + C.gl4_0compat_glDeleteProgram(gl.funcs, C.GLuint(program)) +} + +// CreateShader creates an empty shader object and returns a non-zero value +// by which it can be referenced. A shader object is used to maintain the +// source code strings that define a shader. shaderType indicates the type of +// shader to be created. +// +// Two types of shaders are supported. A shader of type GL.VERTEX_SHADER is a +// shader that is intended to run on the programmable vertex processor and +// replace the fixed functionality vertex processing in OpenGL. A shader of +// type GL.FRAGMENT_SHADER is a shader that is intended to run on the +// programmable fragment processor and replace the fixed functionality +// fragment processing in OpenGL. +// +// When created, a shader object's GL.SHADER_TYPE parameter is set to either +// GL.VERTEX_SHADER or GL.FRAGMENT_SHADER, depending on the value of +// shaderType. +// +// Like display lists and texture objects, the name space for shader objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// This function returns 0 if an error occurs creating the shader object. +// +// Error GL.INVALID_ENUM is generated if shaderType is not an accepted value. +// GL.INVALID_OPERATION is generated if CreateShader is executed between the +// execution of Begin and the corresponding execution of End. +// +// CreateShader is available in GL version 2.0 or greater. +func (gl *GL) CreateShader(gltype glbase.Enum) glbase.Shader { + glresult := C.gl4_0compat_glCreateShader(gl.funcs, C.GLenum(gltype)) + return glbase.Shader(glresult) +} + +// CreateProgram creates an empty program object and returns a non-zero +// value by which it can be referenced. A program object is an object to +// which shader objects can be attached. This provides a mechanism to specify +// the shader objects that will be linked to create a program. It also +// provides a means for checking the compatibility of the shaders that will +// be used to create a program (for instance, checking the compatibility +// between a vertex shader and a fragment shader). When no longer needed as +// part of a program object, shader objects can be detached. +// +// One or more executables are created in a program object by successfully +// attaching shader objects to it with AttachShader, successfully compiling +// the shader objects with CompileShader, and successfully linking the +// program object with LinkProgram. These executables are made part of +// current state when UseProgram is called. Program objects can be deleted +// by calling DeleteProgram. The memory associated with the program object +// will be deleted when it is no longer part of current rendering state for +// any context. +// +// Like display lists and texture objects, the name space for program objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// Applications are responsible for providing the synchronization across API +// calls when objects are accessed from different execution threads. +// +// This function returns 0 if an error occurs creating the program object. +// +// Error GL.INVALID_OPERATION is generated if CreateProgram is executed +// between the execution of Begin and the corresponding execution of End. +// +// CreateProgram is available in GL version 2.0 or greater. +func (gl *GL) CreateProgram() glbase.Program { + glresult := C.gl4_0compat_glCreateProgram(gl.funcs) + return glbase.Program(glresult) +} + +// CompileShader compiles the source code strings that have been stored in +// the shader object specified by shader. +// +// The compilation status will be stored as part of the shader object's +// state. This value will be set to GL.TRUE if the shader was compiled without +// errors and is ready for use, and GL.FALSE otherwise. It can be queried by +// calling GetShaderiv with arguments shader and GL.COMPILE_STATUS. +// +// Compilation of a shader can fail for a number of reasons as specified by +// the OpenGL Shading Language Specification. Whether or not the compilation +// was successful, information about the compilation can be obtained from the +// shader object's information log by calling GetShaderInfoLog. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_OPERATION is generated if CompileShader is executed +// between the execution of Begin and the corresponding execution of End. +// +// CompileShader is available in GL version 2.0 or greater. +func (gl *GL) CompileShader(shader glbase.Shader) { + C.gl4_0compat_glCompileShader(gl.funcs, C.GLuint(shader)) +} + +// BindAttribLocation associates a user-defined attribute variable in the program +// object specified by program with a generic vertex attribute index. The name +// parameter specifies the name of the vertex shader attribute variable to +// which index is to be bound. When program is made part of the current state, +// values provided via the generic vertex attribute index will modify the +// value of the user-defined attribute variable specified by name. +// +// If name refers to a matrix attribute variable, index refers to the first +// column of the matrix. Other matrix columns are then automatically bound to +// locations index+1 for a matrix of type mat2; index+1 and index+2 for a +// matrix of type mat3; and index+1, index+2, and index+3 for a matrix of +// type mat4. +// +// This command makes it possible for vertex shaders to use descriptive names +// for attribute variables rather than generic variables that are numbered +// from 0 to GL.MAX_VERTEX_ATTRIBS-1. The values sent to each generic +// attribute index are part of current state, just like standard vertex +// attributes such as color, normal, and vertex position. If a different +// program object is made current by calling UseProgram, the generic vertex +// attributes are tracked in such a way that the same values will be observed +// by attributes in the new program object that are also bound to index. +// +// Attribute variable name-to-generic attribute index bindings for a program +// object can be explicitly assigned at any time by calling +// BindAttribLocation. Attribute bindings do not go into effect until +// LinkProgram is called. After a program object has been linked +// successfully, the index values for generic attributes remain fixed (and +// their values can be queried) until the next link command occurs. +// +// Applications are not allowed to bind any of the standard OpenGL vertex +// attributes using this command, as they are bound automatically when +// needed. Any attribute binding that occurs after the program object has +// been linked will not take effect until the next time the program object is +// linked. +// +// If name was bound previously, that information is lost. Thus you cannot +// bind one user-defined attribute variable to multiple indices, but you can +// bind multiple user-defined attribute variables to the same index. +// +// Applications are allowed to bind more than one user-defined attribute +// variable to the same generic vertex attribute index. This is called +// aliasing, and it is allowed only if just one of the aliased attributes is +// active in the executable program, or if no path through the shader +// consumes more than one attribute of a set of attributes aliased to the +// same location. The compiler and linker are allowed to assume that no +// aliasing is done and are free to employ optimizations that work only in +// the absence of aliasing. OpenGL implementations are not required to do +// error checking to detect aliasing. Because there is no way to bind +// standard attributes, it is not possible to alias generic attributes with +// conventional ones (except for generic attribute 0). +// +// BindAttribLocation can be called before any vertex shader objects are +// bound to the specified program object. It is also permissible to bind a +// generic attribute index to an attribute variable name that is never used +// in a vertex shader. +// +// Active attributes that are not explicitly bound will be bound by the +// linker when LinkProgram is called. The locations assigned can be queried +// by calling GetAttribLocation. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. +// GL.INVALID_OPERATION is generated if name starts with the reserved prefix "gl_". +// GL.INVALID_VALUE is generated if program is not a value generated by OpenGL. +// GL.INVALID_OPERATION is generated if program is not a program object. +// GL.INVALID_OPERATION is generated if BindAttribLocation is executed +// between the execution of Begin and the corresponding execution of End. +// +// BindAttribLocation is available in GL version 2.0 or greater. +func (gl *GL) BindAttribLocation(program glbase.Program, index glbase.Attrib, name string) { + name_cstr := C.CString(name) + C.gl4_0compat_glBindAttribLocation(gl.funcs, C.GLuint(program), C.GLuint(index), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) +} + +// AttachShader attaches a shader object to a program object. +// +// In order to create an executable, there must be a way to specify the list +// of things that will be linked together. Program objects provide this +// mechanism. Shaders that are to be linked together in a program object must +// first be attached to that program object. This indicates that shader will +// be included in link operations that will be performed on program. +// +// All operations that can be performed on a shader object are valid whether +// or not the shader object is attached to a program object. It is +// permissible to attach a shader object to a program object before source +// code has been loaded into the shader object or before the shader object +// has been compiled. It is permissible to attach multiple shader objects of +// the same type because each may contain a portion of the complete shader. +// It is also permissible to attach a shader object to more than one program +// object. If a shader object is deleted while it is attached to a program +// object, it will be flagged for deletion, and deletion will not occur until +// DetachShader is called to detach it from all program objects to which it +// is attached. +// +// Error GL.INVALID_VALUE is generated if either program or shader is not a +// value generated by OpenGL. GL.INVALID_OPERATION is generated if program +// is not a program object. GL.INVALID_OPERATION is generated if shader is +// not a shader object. GL.INVALID_OPERATION is generated if shader is +// already attached to program. GL.INVALID_OPERATION is generated if +// AttachShader is executed between the execution of Begin and the +// corresponding execution of End. +// +// AttachShader is available in GL version 2.0 or greater. +func (gl *GL) AttachShader(program glbase.Program, shader glbase.Shader) { + C.gl4_0compat_glAttachShader(gl.funcs, C.GLuint(program), C.GLuint(shader)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilMaskSeparate.xml +func (gl *GL) StencilMaskSeparate(face glbase.Enum, mask uint32) { + C.gl4_0compat_glStencilMaskSeparate(gl.funcs, C.GLenum(face), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilFuncSeparate.xml +func (gl *GL) StencilFuncSeparate(face, glfunc glbase.Enum, ref int32, mask uint32) { + C.gl4_0compat_glStencilFuncSeparate(gl.funcs, C.GLenum(face), C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilOpSeparate.xml +func (gl *GL) StencilOpSeparate(face, sfail, dpfail, dppass glbase.Enum) { + C.gl4_0compat_glStencilOpSeparate(gl.funcs, C.GLenum(face), C.GLenum(sfail), C.GLenum(dpfail), C.GLenum(dppass)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawBuffers.xml +func (gl *GL) DrawBuffers(n int, bufs []glbase.Enum) { + C.gl4_0compat_glDrawBuffers(gl.funcs, C.GLsizei(n), (*C.GLenum)(unsafe.Pointer(&bufs[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendEquationSeparate.xml +func (gl *GL) BlendEquationSeparate(modeRGB, modeAlpha glbase.Enum) { + C.gl4_0compat_glBlendEquationSeparate(gl.funcs, C.GLenum(modeRGB), C.GLenum(modeAlpha)) +} + +// UniformMatrix4x3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4x3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4x3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*3) != 0 { + panic("invalid value length for UniformMatrix4x3fv") + } + count := len(value) / (4 * 3) + C.gl4_0compat_glUniformMatrix4x3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3x4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3x4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3x4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*4) != 0 { + panic("invalid value length for UniformMatrix3x4fv") + } + count := len(value) / (3 * 4) + C.gl4_0compat_glUniformMatrix3x4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix4x2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4x2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4x2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*2) != 0 { + panic("invalid value length for UniformMatrix4x2fv") + } + count := len(value) / (4 * 2) + C.gl4_0compat_glUniformMatrix4x2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2x4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2x4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2x4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*4) != 0 { + panic("invalid value length for UniformMatrix2x4fv") + } + count := len(value) / (2 * 4) + C.gl4_0compat_glUniformMatrix2x4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3x2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3x2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3x2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*2) != 0 { + panic("invalid value length for UniformMatrix3x2fv") + } + count := len(value) / (3 * 2) + C.gl4_0compat_glUniformMatrix3x2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2x3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2x3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2x3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*3) != 0 { + panic("invalid value length for UniformMatrix2x3fv") + } + count := len(value) / (2 * 3) + C.gl4_0compat_glUniformMatrix2x3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsVertexArray.xml +func (gl *GL) IsVertexArray(array uint32) bool { + glresult := C.gl4_0compat_glIsVertexArray(gl.funcs, C.GLuint(array)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenVertexArrays.xml +func (gl *GL) GenVertexArrays(n int, arrays []uint32) { + C.gl4_0compat_glGenVertexArrays(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&arrays[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteVertexArrays.xml +func (gl *GL) DeleteVertexArrays(n int, arrays []uint32) { + C.gl4_0compat_glDeleteVertexArrays(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&arrays[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindVertexArray.xml +func (gl *GL) BindVertexArray(array uint32) { + C.gl4_0compat_glBindVertexArray(gl.funcs, C.GLuint(array)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFlushMappedBufferRange.xml +func (gl *GL) FlushMappedBufferRange(target glbase.Enum, offset, length int) { + C.gl4_0compat_glFlushMappedBufferRange(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(length)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTextureLayer.xml +func (gl *GL) FramebufferTextureLayer(target, attachment glbase.Enum, texture glbase.Texture, level int, layer int32) { + C.gl4_0compat_glFramebufferTextureLayer(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLuint(texture), C.GLint(level), C.GLint(layer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRenderbufferStorageMultisample.xml +func (gl *GL) RenderbufferStorageMultisample(target glbase.Enum, samples int32, internalFormat glbase.Enum, width, height int) { + C.gl4_0compat_glRenderbufferStorageMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlitFramebuffer.xml +func (gl *GL) BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1 int32, mask glbase.Bitfield, filter glbase.Enum) { + C.gl4_0compat_glBlitFramebuffer(gl.funcs, C.GLint(srcX0), C.GLint(srcY0), C.GLint(srcX1), C.GLint(srcY1), C.GLint(dstX0), C.GLint(dstY0), C.GLint(dstX1), C.GLint(dstY1), C.GLbitfield(mask), C.GLenum(filter)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenerateMipmap.xml +func (gl *GL) GenerateMipmap(target glbase.Enum) { + C.gl4_0compat_glGenerateMipmap(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFramebufferAttachmentParameteriv.xml +func (gl *GL) GetFramebufferAttachmentParameteriv(target, attachment, pname glbase.Enum, params []int32) { + C.gl4_0compat_glGetFramebufferAttachmentParameteriv(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferRenderbuffer.xml +func (gl *GL) FramebufferRenderbuffer(target, attachment, renderbuffertarget glbase.Enum, renderbuffer glbase.Renderbuffer) { + C.gl4_0compat_glFramebufferRenderbuffer(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(renderbuffertarget), C.GLuint(renderbuffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture3D.xml +func (gl *GL) FramebufferTexture3D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int, zoffset int32) { + C.gl4_0compat_glFramebufferTexture3D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level), C.GLint(zoffset)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture2D.xml +func (gl *GL) FramebufferTexture2D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int) { + C.gl4_0compat_glFramebufferTexture2D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture1D.xml +func (gl *GL) FramebufferTexture1D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int) { + C.gl4_0compat_glFramebufferTexture1D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCheckFramebufferStatus.xml +func (gl *GL) CheckFramebufferStatus(target glbase.Enum) glbase.Enum { + glresult := C.gl4_0compat_glCheckFramebufferStatus(gl.funcs, C.GLenum(target)) + return glbase.Enum(glresult) +} + +// GenFramebuffers returns n framebuffer object names in ids. There is no +// guarantee that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenFramebuffers. +// +// Framebuffer object names returned by a call to GenFramebuffers are not +// returned by subsequent calls, unless they are first deleted with +// DeleteFramebuffers. +// +// The names returned in ids are marked as used, for the purposes of +// GenFramebuffers only, but they acquire state and type only when they are +// first bound. +// +// Error GL.INVALID_VALUE is generated if n is negative. +func (gl *GL) GenFramebuffers(n int) []glbase.Framebuffer { + if n == 0 { + return nil + } + framebuffers := make([]glbase.Framebuffer, n) + C.gl4_0compat_glGenFramebuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&framebuffers[0]))) + return framebuffers +} + +// DeleteFramebuffers deletes the framebuffer objects whose names are +// stored in the framebuffers slice. The name zero is reserved by the GL and +// is silently ignored, should it occur in framebuffers, as are other unused +// names. Once a framebuffer object is deleted, its name is again unused and +// it has no attachments. If a framebuffer that is currently bound to one or +// more of the targets GL.DRAW_FRAMEBUFFER or GL.READ_FRAMEBUFFER is deleted, +// it is as though BindFramebuffer had been executed with the corresponding +// target and framebuffer zero. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteFramebuffers is available in GL version 3.0 or greater. +func (gl *GL) DeleteFramebuffers(framebuffers []glbase.Framebuffer) { + n := len(framebuffers) + if n == 0 { + return + } + C.gl4_0compat_glDeleteFramebuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&framebuffers[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindFramebuffer.xml +func (gl *GL) BindFramebuffer(target glbase.Enum, framebuffer glbase.Framebuffer) { + C.gl4_0compat_glBindFramebuffer(gl.funcs, C.GLenum(target), C.GLuint(framebuffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsFramebuffer.xml +func (gl *GL) IsFramebuffer(framebuffer glbase.Framebuffer) bool { + glresult := C.gl4_0compat_glIsFramebuffer(gl.funcs, C.GLuint(framebuffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetRenderbufferParameteriv.xml +func (gl *GL) GetRenderbufferParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_0compat_glGetRenderbufferParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRenderbufferStorage.xml +func (gl *GL) RenderbufferStorage(target, internalFormat glbase.Enum, width, height int) { + C.gl4_0compat_glRenderbufferStorage(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) +} + +// GenRenderbuffers returns n renderbuffer object names in renderbuffers. +// There is no guarantee that the names form a contiguous set of integers; +// however, it is guaranteed that none of the returned names was in use +// immediately before the call to GenRenderbuffers. +// +// Renderbuffer object names returned by a call to GenRenderbuffers are not +// returned by subsequent calls, unless they are first deleted with +// DeleteRenderbuffers. +// +// The names returned in renderbuffers are marked as used, for the purposes +// of GenRenderbuffers only, but they acquire state and type only when they +// are first bound. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenRenderbuffers is available in GL version 3.0 or greater. +func (gl *GL) GenRenderbuffers(n int) []glbase.Renderbuffer { + if n == 0 { + return nil + } + renderbuffers := make([]glbase.Renderbuffer, n) + C.gl4_0compat_glGenRenderbuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&renderbuffers[0]))) + return renderbuffers +} + +// DeleteRenderbuffers deletes the renderbuffer objects whose names are stored +// in the renderbuffers slice. The name zero is reserved by the GL and +// is silently ignored, should it occur in renderbuffers, as are other unused +// names. Once a renderbuffer object is deleted, its name is again unused and +// it has no contents. If a renderbuffer that is currently bound to the +// target GL.RENDERBUFFER is deleted, it is as though BindRenderbuffer had +// been executed with a target of GL.RENDERBUFFER and a name of zero. +// +// If a renderbuffer object is attached to one or more attachment points in +// the currently bound framebuffer, then it as if FramebufferRenderbuffer +// had been called, with a renderbuffer of zero for each attachment point to +// which this image was attached in the currently bound framebuffer. In other +// words, this renderbuffer object is first detached from all attachment +// ponits in the currently bound framebuffer. Note that the renderbuffer +// image is specifically not detached from any non-bound framebuffers. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteRenderbuffers is available in GL version 3.0 or greater. +func (gl *GL) DeleteRenderbuffers(renderbuffers []glbase.Renderbuffer) { + n := len(renderbuffers) + if n == 0 { + return + } + C.gl4_0compat_glDeleteRenderbuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&renderbuffers[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindRenderbuffer.xml +func (gl *GL) BindRenderbuffer(target glbase.Enum, renderbuffer glbase.Renderbuffer) { + C.gl4_0compat_glBindRenderbuffer(gl.funcs, C.GLenum(target), C.GLuint(renderbuffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsRenderbuffer.xml +func (gl *GL) IsRenderbuffer(renderbuffer glbase.Renderbuffer) bool { + glresult := C.gl4_0compat_glIsRenderbuffer(gl.funcs, C.GLuint(renderbuffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferfi.xml +func (gl *GL) ClearBufferfi(buffer glbase.Enum, drawbuffer int32, depth float32, stencil int32) { + C.gl4_0compat_glClearBufferfi(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), C.GLfloat(depth), C.GLint(stencil)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferfv.xml +func (gl *GL) ClearBufferfv(buffer glbase.Enum, drawbuffer int32, value []float32) { + C.gl4_0compat_glClearBufferfv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferuiv.xml +func (gl *GL) ClearBufferuiv(buffer glbase.Enum, drawbuffer int32, value []uint32) { + C.gl4_0compat_glClearBufferuiv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferiv.xml +func (gl *GL) ClearBufferiv(buffer glbase.Enum, drawbuffer int32, value []int32) { + C.gl4_0compat_glClearBufferiv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameterIuiv.xml +func (gl *GL) GetTexParameterIuiv(target, pname glbase.Enum, params []uint32) { + C.gl4_0compat_glGetTexParameterIuiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameterIiv.xml +func (gl *GL) GetTexParameterIiv(target, pname glbase.Enum, params []int32) { + C.gl4_0compat_glGetTexParameterIiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterIuiv.xml +func (gl *GL) TexParameterIuiv(target, pname glbase.Enum, params []uint32) { + C.gl4_0compat_glTexParameterIuiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterIiv.xml +func (gl *GL) TexParameterIiv(target, pname glbase.Enum, params []int32) { + C.gl4_0compat_glTexParameterIiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// Uniform4uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4uiv") + } + count := len(value) / 4 + C.gl4_0compat_glUniform4uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform3uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3uiv") + } + count := len(value) / 3 + C.gl4_0compat_glUniform3uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform2uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2uiv") + } + count := len(value) / 2 + C.gl4_0compat_glUniform2uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform1uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl4_0compat_glUniform1uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform4ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4ui(location glbase.Uniform, v0, v1, v2, v3 uint32) { + C.gl4_0compat_glUniform4ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2), C.GLuint(v3)) +} + +// Uniform3ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3ui(location glbase.Uniform, v0, v1, v2 uint32) { + C.gl4_0compat_glUniform3ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2)) +} + +// Uniform2ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2ui(location glbase.Uniform, v0, v1 uint32) { + C.gl4_0compat_glUniform2ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1)) +} + +// Uniform1ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1ui(location glbase.Uniform, v0 uint32) { + C.gl4_0compat_glUniform1ui(gl.funcs, C.GLint(location), C.GLuint(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFragDataLocation.xml +func (gl *GL) GetFragDataLocation(program glbase.Program, name []byte) int32 { + glresult := C.gl4_0compat_glGetFragDataLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindFragDataLocation.xml +func (gl *GL) BindFragDataLocation(program glbase.Program, color uint32, name []byte) { + C.gl4_0compat_glBindFragDataLocation(gl.funcs, C.GLuint(program), C.GLuint(color), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetUniformuiv.xml +func (gl *GL) GetUniformuiv(program glbase.Program, location glbase.Uniform, params []uint32) { + C.gl4_0compat_glGetUniformuiv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetVertexAttribIuiv.xml +func (gl *GL) GetVertexAttribIuiv(index glbase.Attrib, pname glbase.Enum, params []uint32) { + C.gl4_0compat_glGetVertexAttribIuiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetVertexAttribIiv.xml +func (gl *GL) GetVertexAttribIiv(index glbase.Attrib, pname glbase.Enum, params []int32) { + C.gl4_0compat_glGetVertexAttribIiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribIPointer.xml +func (gl *GL) VertexAttribIPointer(index glbase.Attrib, size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glVertexAttribIPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndConditionalRender.xml +func (gl *GL) EndConditionalRender() { + C.gl4_0compat_glEndConditionalRender(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBeginConditionalRender.xml +func (gl *GL) BeginConditionalRender(id uint32, mode glbase.Enum) { + C.gl4_0compat_glBeginConditionalRender(gl.funcs, C.GLuint(id), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClampColor.xml +func (gl *GL) ClampColor(target, clamp glbase.Enum) { + C.gl4_0compat_glClampColor(gl.funcs, C.GLenum(target), C.GLenum(clamp)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTransformFeedbackVarying.xml +func (gl *GL) GetTransformFeedbackVarying(program glbase.Program, index uint32, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl4_0compat_glGetTransformFeedbackVarying(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLsizei)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindBufferBase.xml +func (gl *GL) BindBufferBase(target glbase.Enum, index uint32, buffer glbase.Buffer) { + C.gl4_0compat_glBindBufferBase(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindBufferRange.xml +func (gl *GL) BindBufferRange(target glbase.Enum, index uint32, buffer glbase.Buffer, offset, size int) { + C.gl4_0compat_glBindBufferRange(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(buffer), C.GLintptr(offset), C.GLsizeiptr(size)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndTransformFeedback.xml +func (gl *GL) EndTransformFeedback() { + C.gl4_0compat_glEndTransformFeedback(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBeginTransformFeedback.xml +func (gl *GL) BeginTransformFeedback(primitiveMode glbase.Enum) { + C.gl4_0compat_glBeginTransformFeedback(gl.funcs, C.GLenum(primitiveMode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsEnabledi.xml +func (gl *GL) IsEnabledi(target glbase.Enum, index uint32) bool { + glresult := C.gl4_0compat_glIsEnabledi(gl.funcs, C.GLenum(target), C.GLuint(index)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDisablei.xml +func (gl *GL) Disablei(target glbase.Enum, index uint32) { + C.gl4_0compat_glDisablei(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEnablei.xml +func (gl *GL) Enablei(target glbase.Enum, index uint32) { + C.gl4_0compat_glEnablei(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetIntegeri_v.xml +func (gl *GL) GetIntegeri_v(target glbase.Enum, index uint32, data []int32) { + C.gl4_0compat_glGetIntegeri_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLint)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBooleani_v.xml +func (gl *GL) GetBooleani_v(target glbase.Enum, index uint32, data []bool) { + C.gl4_0compat_glGetBooleani_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLboolean)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorMaski.xml +func (gl *GL) ColorMaski(index uint32, r, g, b, a bool) { + C.gl4_0compat_glColorMaski(gl.funcs, C.GLuint(index), *(*C.GLboolean)(unsafe.Pointer(&r)), *(*C.GLboolean)(unsafe.Pointer(&g)), *(*C.GLboolean)(unsafe.Pointer(&b)), *(*C.GLboolean)(unsafe.Pointer(&a))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyBufferSubData.xml +func (gl *GL) CopyBufferSubData(readTarget, writeTarget glbase.Enum, readOffset, writeOffset, size int) { + C.gl4_0compat_glCopyBufferSubData(gl.funcs, C.GLenum(readTarget), C.GLenum(writeTarget), C.GLintptr(readOffset), C.GLintptr(writeOffset), C.GLsizeiptr(size)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformBlockBinding.xml +func (gl *GL) UniformBlockBinding(program glbase.Program, v0, v1 uint32) { + C.gl4_0compat_glUniformBlockBinding(gl.funcs, C.GLuint(program), C.GLuint(v0), C.GLuint(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformBlockName.xml +func (gl *GL) GetActiveUniformBlockName(program glbase.Program, uniformBlockIndex uint32, bufSize int32, length []int32, uniformBlockName []byte) { + C.gl4_0compat_glGetActiveUniformBlockName(gl.funcs, C.GLuint(program), C.GLuint(uniformBlockIndex), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&uniformBlockName[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformBlockiv.xml +func (gl *GL) GetActiveUniformBlockiv(program glbase.Program, uniformBlockIndex uint32, pname glbase.Enum, params []int32) { + C.gl4_0compat_glGetActiveUniformBlockiv(gl.funcs, C.GLuint(program), C.GLuint(uniformBlockIndex), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetUniformBlockIndex.xml +func (gl *GL) GetUniformBlockIndex(program glbase.Program, uniformBlockName []byte) uint32 { + glresult := C.gl4_0compat_glGetUniformBlockIndex(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&uniformBlockName[0]))) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformName.xml +func (gl *GL) GetActiveUniformName(program glbase.Program, uniformIndex uint32, bufSize int32, length []int32, uniformName []byte) { + C.gl4_0compat_glGetActiveUniformName(gl.funcs, C.GLuint(program), C.GLuint(uniformIndex), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&uniformName[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformsiv.xml +func (gl *GL) GetActiveUniformsiv(program glbase.Program, uniformCount int32, uniformIndices []uint32, pname glbase.Enum, params []int32) { + C.gl4_0compat_glGetActiveUniformsiv(gl.funcs, C.GLuint(program), C.GLsizei(uniformCount), (*C.GLuint)(unsafe.Pointer(&uniformIndices[0])), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPrimitiveRestartIndex.xml +func (gl *GL) PrimitiveRestartIndex(index uint32) { + C.gl4_0compat_glPrimitiveRestartIndex(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexBuffer.xml +func (gl *GL) TexBuffer(target, internalFormat glbase.Enum, buffer glbase.Buffer) { + C.gl4_0compat_glTexBuffer(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsInstanced.xml +func (gl *GL) DrawElementsInstanced(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, instancecount int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glDrawElementsInstanced(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLsizei(instancecount)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawArraysInstanced.xml +func (gl *GL) DrawArraysInstanced(mode glbase.Enum, first, count int, instancecount int32) { + C.gl4_0compat_glDrawArraysInstanced(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count), C.GLsizei(instancecount)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSampleMaski.xml +func (gl *GL) SampleMaski(index uint32, mask glbase.Bitfield) { + C.gl4_0compat_glSampleMaski(gl.funcs, C.GLuint(index), C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMultisamplefv.xml +func (gl *GL) GetMultisamplefv(pname glbase.Enum, index uint32, val []float32) { + C.gl4_0compat_glGetMultisamplefv(gl.funcs, C.GLenum(pname), C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&val[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage3DMultisample.xml +func (gl *GL) TexImage3DMultisample(target glbase.Enum, samples, internalFormat int32, width, height int, depth int32, fixedsamplelocations bool) { + C.gl4_0compat_glTexImage3DMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), *(*C.GLboolean)(unsafe.Pointer(&fixedsamplelocations))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage2DMultisample.xml +func (gl *GL) TexImage2DMultisample(target glbase.Enum, samples, internalFormat int32, width, height int, fixedsamplelocations bool) { + C.gl4_0compat_glTexImage2DMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), *(*C.GLboolean)(unsafe.Pointer(&fixedsamplelocations))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSynciv.xml +func (gl *GL) GetSynciv(sync glbase.Sync, pname glbase.Enum, bufSize int32, length, values []int32) { + C.gl4_0compat_glGetSynciv(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLenum(pname), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetInteger64v.xml +func (gl *GL) GetInteger64v(pname glbase.Enum, params []int64) { + C.gl4_0compat_glGetInteger64v(gl.funcs, C.GLenum(pname), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWaitSync.xml +func (gl *GL) WaitSync(sync glbase.Sync, flags glbase.Bitfield, timeout uint64) { + C.gl4_0compat_glWaitSync(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLbitfield(flags), C.GLuint64(timeout)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClientWaitSync.xml +func (gl *GL) ClientWaitSync(sync glbase.Sync, flags glbase.Bitfield, timeout uint64) glbase.Enum { + glresult := C.gl4_0compat_glClientWaitSync(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLbitfield(flags), C.GLuint64(timeout)) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteSync.xml +func (gl *GL) DeleteSync(sync glbase.Sync) { + C.gl4_0compat_glDeleteSync(gl.funcs, C.GLsync(unsafe.Pointer(sync))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsSync.xml +func (gl *GL) IsSync(sync glbase.Sync) bool { + glresult := C.gl4_0compat_glIsSync(gl.funcs, C.GLsync(unsafe.Pointer(sync))) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFenceSync.xml +func (gl *GL) FenceSync(condition glbase.Enum, flags glbase.Bitfield) glbase.Sync { + glresult := C.gl4_0compat_glFenceSync(gl.funcs, C.GLenum(condition), C.GLbitfield(flags)) + return glbase.Sync(unsafe.Pointer(glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProvokingVertex.xml +func (gl *GL) ProvokingVertex(mode glbase.Enum) { + C.gl4_0compat_glProvokingVertex(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsInstancedBaseVertex.xml +func (gl *GL) DrawElementsInstancedBaseVertex(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, instancecount, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glDrawElementsInstancedBaseVertex(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLsizei(instancecount), C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawRangeElementsBaseVertex.xml +func (gl *GL) DrawRangeElementsBaseVertex(mode glbase.Enum, start, end uint32, count int, gltype glbase.Enum, indices interface{}, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glDrawRangeElementsBaseVertex(gl.funcs, C.GLenum(mode), C.GLuint(start), C.GLuint(end), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsBaseVertex.xml +func (gl *GL) DrawElementsBaseVertex(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glDrawElementsBaseVertex(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture.xml +func (gl *GL) FramebufferTexture(target, attachment glbase.Enum, texture glbase.Texture, level int) { + C.gl4_0compat_glFramebufferTexture(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBufferParameteri64v.xml +func (gl *GL) GetBufferParameteri64v(target, pname glbase.Enum, params []int64) { + C.gl4_0compat_glGetBufferParameteri64v(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetInteger64i_v.xml +func (gl *GL) GetInteger64i_v(target glbase.Enum, index uint32, data []int64) { + C.gl4_0compat_glGetInteger64i_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLint64)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP4uiv.xml +func (gl *GL) VertexAttribP4uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl4_0compat_glVertexAttribP4uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP4ui.xml +func (gl *GL) VertexAttribP4ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl4_0compat_glVertexAttribP4ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP3uiv.xml +func (gl *GL) VertexAttribP3uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl4_0compat_glVertexAttribP3uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP3ui.xml +func (gl *GL) VertexAttribP3ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl4_0compat_glVertexAttribP3ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP2uiv.xml +func (gl *GL) VertexAttribP2uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl4_0compat_glVertexAttribP2uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP2ui.xml +func (gl *GL) VertexAttribP2ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl4_0compat_glVertexAttribP2ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP1uiv.xml +func (gl *GL) VertexAttribP1uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl4_0compat_glVertexAttribP1uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP1ui.xml +func (gl *GL) VertexAttribP1ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl4_0compat_glVertexAttribP1ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColorP3uiv.xml +func (gl *GL) SecondaryColorP3uiv(gltype glbase.Enum, color []uint32) { + C.gl4_0compat_glSecondaryColorP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&color[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColorP3ui.xml +func (gl *GL) SecondaryColorP3ui(gltype glbase.Enum, color uint32) { + C.gl4_0compat_glSecondaryColorP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(color)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorP4uiv.xml +func (gl *GL) ColorP4uiv(gltype glbase.Enum, color []uint32) { + C.gl4_0compat_glColorP4uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&color[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorP4ui.xml +func (gl *GL) ColorP4ui(gltype glbase.Enum, color uint32) { + C.gl4_0compat_glColorP4ui(gl.funcs, C.GLenum(gltype), C.GLuint(color)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorP3uiv.xml +func (gl *GL) ColorP3uiv(gltype glbase.Enum, color []uint32) { + C.gl4_0compat_glColorP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&color[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorP3ui.xml +func (gl *GL) ColorP3ui(gltype glbase.Enum, color uint32) { + C.gl4_0compat_glColorP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(color)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormalP3uiv.xml +func (gl *GL) NormalP3uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_0compat_glNormalP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormalP3ui.xml +func (gl *GL) NormalP3ui(gltype glbase.Enum, coords uint32) { + C.gl4_0compat_glNormalP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP4uiv.xml +func (gl *GL) MultiTexCoordP4uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl4_0compat_glMultiTexCoordP4uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP4ui.xml +func (gl *GL) MultiTexCoordP4ui(texture, gltype glbase.Enum, coords uint32) { + C.gl4_0compat_glMultiTexCoordP4ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP3uiv.xml +func (gl *GL) MultiTexCoordP3uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl4_0compat_glMultiTexCoordP3uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP3ui.xml +func (gl *GL) MultiTexCoordP3ui(texture, gltype glbase.Enum, coords uint32) { + C.gl4_0compat_glMultiTexCoordP3ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP2uiv.xml +func (gl *GL) MultiTexCoordP2uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl4_0compat_glMultiTexCoordP2uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP2ui.xml +func (gl *GL) MultiTexCoordP2ui(texture, gltype glbase.Enum, coords uint32) { + C.gl4_0compat_glMultiTexCoordP2ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP1uiv.xml +func (gl *GL) MultiTexCoordP1uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl4_0compat_glMultiTexCoordP1uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP1ui.xml +func (gl *GL) MultiTexCoordP1ui(texture, gltype glbase.Enum, coords uint32) { + C.gl4_0compat_glMultiTexCoordP1ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP4uiv.xml +func (gl *GL) TexCoordP4uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_0compat_glTexCoordP4uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP4ui.xml +func (gl *GL) TexCoordP4ui(gltype glbase.Enum, coords uint32) { + C.gl4_0compat_glTexCoordP4ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP3uiv.xml +func (gl *GL) TexCoordP3uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_0compat_glTexCoordP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP3ui.xml +func (gl *GL) TexCoordP3ui(gltype glbase.Enum, coords uint32) { + C.gl4_0compat_glTexCoordP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP2uiv.xml +func (gl *GL) TexCoordP2uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_0compat_glTexCoordP2uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP2ui.xml +func (gl *GL) TexCoordP2ui(gltype glbase.Enum, coords uint32) { + C.gl4_0compat_glTexCoordP2ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP1uiv.xml +func (gl *GL) TexCoordP1uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_0compat_glTexCoordP1uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP1ui.xml +func (gl *GL) TexCoordP1ui(gltype glbase.Enum, coords uint32) { + C.gl4_0compat_glTexCoordP1ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP4uiv.xml +func (gl *GL) VertexP4uiv(gltype glbase.Enum, value []uint32) { + C.gl4_0compat_glVertexP4uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP4ui.xml +func (gl *GL) VertexP4ui(gltype glbase.Enum, value uint32) { + C.gl4_0compat_glVertexP4ui(gl.funcs, C.GLenum(gltype), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP3uiv.xml +func (gl *GL) VertexP3uiv(gltype glbase.Enum, value []uint32) { + C.gl4_0compat_glVertexP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP3ui.xml +func (gl *GL) VertexP3ui(gltype glbase.Enum, value uint32) { + C.gl4_0compat_glVertexP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP2uiv.xml +func (gl *GL) VertexP2uiv(gltype glbase.Enum, value []uint32) { + C.gl4_0compat_glVertexP2uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP2ui.xml +func (gl *GL) VertexP2ui(gltype glbase.Enum, value uint32) { + C.gl4_0compat_glVertexP2ui(gl.funcs, C.GLenum(gltype), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryObjectui64v.xml +func (gl *GL) GetQueryObjectui64v(id uint32, pname glbase.Enum, params []uint64) { + C.gl4_0compat_glGetQueryObjectui64v(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLuint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryObjecti64v.xml +func (gl *GL) GetQueryObjecti64v(id uint32, pname glbase.Enum, params []int64) { + C.gl4_0compat_glGetQueryObjecti64v(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glQueryCounter.xml +func (gl *GL) QueryCounter(id uint32, target glbase.Enum) { + C.gl4_0compat_glQueryCounter(gl.funcs, C.GLuint(id), C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSamplerParameterIuiv.xml +func (gl *GL) GetSamplerParameterIuiv(sampler uint32, pname glbase.Enum, params []uint32) { + C.gl4_0compat_glGetSamplerParameterIuiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSamplerParameterfv.xml +func (gl *GL) GetSamplerParameterfv(sampler uint32, pname glbase.Enum, params []float32) { + C.gl4_0compat_glGetSamplerParameterfv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSamplerParameterIiv.xml +func (gl *GL) GetSamplerParameterIiv(sampler uint32, pname glbase.Enum, params []int32) { + C.gl4_0compat_glGetSamplerParameterIiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSamplerParameteriv.xml +func (gl *GL) GetSamplerParameteriv(sampler uint32, pname glbase.Enum, params []int32) { + C.gl4_0compat_glGetSamplerParameteriv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameterIuiv.xml +func (gl *GL) SamplerParameterIuiv(sampler uint32, pname glbase.Enum, param []uint32) { + C.gl4_0compat_glSamplerParameterIuiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameterIiv.xml +func (gl *GL) SamplerParameterIiv(sampler uint32, pname glbase.Enum, param []int32) { + C.gl4_0compat_glSamplerParameterIiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameterfv.xml +func (gl *GL) SamplerParameterfv(sampler uint32, pname glbase.Enum, param []float32) { + C.gl4_0compat_glSamplerParameterfv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameterf.xml +func (gl *GL) SamplerParameterf(sampler uint32, pname glbase.Enum, param float32) { + C.gl4_0compat_glSamplerParameterf(gl.funcs, C.GLuint(sampler), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameteriv.xml +func (gl *GL) SamplerParameteriv(sampler uint32, pname glbase.Enum, param []int32) { + C.gl4_0compat_glSamplerParameteriv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameteri.xml +func (gl *GL) SamplerParameteri(sampler uint32, pname glbase.Enum, param int32) { + C.gl4_0compat_glSamplerParameteri(gl.funcs, C.GLuint(sampler), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindSampler.xml +func (gl *GL) BindSampler(unit, sampler uint32) { + C.gl4_0compat_glBindSampler(gl.funcs, C.GLuint(unit), C.GLuint(sampler)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsSampler.xml +func (gl *GL) IsSampler(sampler uint32) bool { + glresult := C.gl4_0compat_glIsSampler(gl.funcs, C.GLuint(sampler)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteSamplers.xml +func (gl *GL) DeleteSamplers(count int, samplers []uint32) { + C.gl4_0compat_glDeleteSamplers(gl.funcs, C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&samplers[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenSamplers.xml +func (gl *GL) GenSamplers(count int, samplers []uint32) { + C.gl4_0compat_glGenSamplers(gl.funcs, C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&samplers[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFragDataIndex.xml +func (gl *GL) GetFragDataIndex(program glbase.Program, name []byte) int32 { + glresult := C.gl4_0compat_glGetFragDataIndex(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindFragDataLocationIndexed.xml +func (gl *GL) BindFragDataLocationIndexed(program glbase.Program, colorNumber, index uint32, name []byte) { + C.gl4_0compat_glBindFragDataLocationIndexed(gl.funcs, C.GLuint(program), C.GLuint(colorNumber), C.GLuint(index), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribDivisor.xml +func (gl *GL) VertexAttribDivisor(index glbase.Attrib, divisor uint32) { + C.gl4_0compat_glVertexAttribDivisor(gl.funcs, C.GLuint(index), C.GLuint(divisor)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryIndexediv.xml +func (gl *GL) GetQueryIndexediv(target glbase.Enum, index uint32, pname glbase.Enum, params []int32) { + C.gl4_0compat_glGetQueryIndexediv(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndQueryIndexed.xml +func (gl *GL) EndQueryIndexed(target glbase.Enum, index uint32) { + C.gl4_0compat_glEndQueryIndexed(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBeginQueryIndexed.xml +func (gl *GL) BeginQueryIndexed(target glbase.Enum, index, id uint32) { + C.gl4_0compat_glBeginQueryIndexed(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawTransformFeedbackStream.xml +func (gl *GL) DrawTransformFeedbackStream(mode glbase.Enum, id, stream uint32) { + C.gl4_0compat_glDrawTransformFeedbackStream(gl.funcs, C.GLenum(mode), C.GLuint(id), C.GLuint(stream)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawTransformFeedback.xml +func (gl *GL) DrawTransformFeedback(mode glbase.Enum, id uint32) { + C.gl4_0compat_glDrawTransformFeedback(gl.funcs, C.GLenum(mode), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glResumeTransformFeedback.xml +func (gl *GL) ResumeTransformFeedback() { + C.gl4_0compat_glResumeTransformFeedback(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPauseTransformFeedback.xml +func (gl *GL) PauseTransformFeedback() { + C.gl4_0compat_glPauseTransformFeedback(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsTransformFeedback.xml +func (gl *GL) IsTransformFeedback(id uint32) bool { + glresult := C.gl4_0compat_glIsTransformFeedback(gl.funcs, C.GLuint(id)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenTransformFeedbacks.xml +func (gl *GL) GenTransformFeedbacks(n int, ids []uint32) { + C.gl4_0compat_glGenTransformFeedbacks(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteTransformFeedbacks.xml +func (gl *GL) DeleteTransformFeedbacks(n int, ids []uint32) { + C.gl4_0compat_glDeleteTransformFeedbacks(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindTransformFeedback.xml +func (gl *GL) BindTransformFeedback(target glbase.Enum, id uint32) { + C.gl4_0compat_glBindTransformFeedback(gl.funcs, C.GLenum(target), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPatchParameterfv.xml +func (gl *GL) PatchParameterfv(pname glbase.Enum, values []float32) { + C.gl4_0compat_glPatchParameterfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPatchParameteri.xml +func (gl *GL) PatchParameteri(pname glbase.Enum, value int32) { + C.gl4_0compat_glPatchParameteri(gl.funcs, C.GLenum(pname), C.GLint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramStageiv.xml +func (gl *GL) GetProgramStageiv(program glbase.Program, shadertype, pname glbase.Enum, values []int32) { + C.gl4_0compat_glGetProgramStageiv(gl.funcs, C.GLuint(program), C.GLenum(shadertype), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetUniformSubroutineuiv.xml +func (gl *GL) GetUniformSubroutineuiv(shadertype glbase.Enum, location glbase.Uniform, params []uint32) { + C.gl4_0compat_glGetUniformSubroutineuiv(gl.funcs, C.GLenum(shadertype), C.GLint(location), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformSubroutinesuiv.xml +func (gl *GL) UniformSubroutinesuiv(shadertype glbase.Enum, count int, value []uint32) { + C.gl4_0compat_glUniformSubroutinesuiv(gl.funcs, C.GLenum(shadertype), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveSubroutineName.xml +func (gl *GL) GetActiveSubroutineName(program glbase.Program, shadertype glbase.Enum, index uint32, bufSize int32, length []int32, name []byte) { + C.gl4_0compat_glGetActiveSubroutineName(gl.funcs, C.GLuint(program), C.GLenum(shadertype), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveSubroutineUniformName.xml +func (gl *GL) GetActiveSubroutineUniformName(program glbase.Program, shadertype glbase.Enum, index uint32, bufSize int32, length []int32, name []byte) { + C.gl4_0compat_glGetActiveSubroutineUniformName(gl.funcs, C.GLuint(program), C.GLenum(shadertype), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveSubroutineUniformiv.xml +func (gl *GL) GetActiveSubroutineUniformiv(program glbase.Program, shadertype glbase.Enum, index uint32, pname glbase.Enum, values []int32) { + C.gl4_0compat_glGetActiveSubroutineUniformiv(gl.funcs, C.GLuint(program), C.GLenum(shadertype), C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSubroutineIndex.xml +func (gl *GL) GetSubroutineIndex(program glbase.Program, shadertype glbase.Enum, name []byte) uint32 { + glresult := C.gl4_0compat_glGetSubroutineIndex(gl.funcs, C.GLuint(program), C.GLenum(shadertype), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSubroutineUniformLocation.xml +func (gl *GL) GetSubroutineUniformLocation(program glbase.Program, shadertype glbase.Enum, name []byte) int32 { + glresult := C.gl4_0compat_glGetSubroutineUniformLocation(gl.funcs, C.GLuint(program), C.GLenum(shadertype), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetUniformdv.xml +func (gl *GL) GetUniformdv(program glbase.Program, location glbase.Uniform, params []float64) { + C.gl4_0compat_glGetUniformdv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix4x3dv.xml +func (gl *GL) UniformMatrix4x3dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_0compat_glUniformMatrix4x3dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix4x2dv.xml +func (gl *GL) UniformMatrix4x2dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_0compat_glUniformMatrix4x2dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix3x4dv.xml +func (gl *GL) UniformMatrix3x4dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_0compat_glUniformMatrix3x4dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix3x2dv.xml +func (gl *GL) UniformMatrix3x2dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_0compat_glUniformMatrix3x2dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix2x4dv.xml +func (gl *GL) UniformMatrix2x4dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_0compat_glUniformMatrix2x4dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix2x3dv.xml +func (gl *GL) UniformMatrix2x3dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_0compat_glUniformMatrix2x3dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix4dv.xml +func (gl *GL) UniformMatrix4dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_0compat_glUniformMatrix4dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix3dv.xml +func (gl *GL) UniformMatrix3dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_0compat_glUniformMatrix3dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix2dv.xml +func (gl *GL) UniformMatrix2dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_0compat_glUniformMatrix2dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform4dv.xml +func (gl *GL) Uniform4dv(location glbase.Uniform, count int, value []float64) { + C.gl4_0compat_glUniform4dv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform3dv.xml +func (gl *GL) Uniform3dv(location glbase.Uniform, count int, value []float64) { + C.gl4_0compat_glUniform3dv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform2dv.xml +func (gl *GL) Uniform2dv(location glbase.Uniform, count int, value []float64) { + C.gl4_0compat_glUniform2dv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform1dv.xml +func (gl *GL) Uniform1dv(location glbase.Uniform, count int, value []float64) { + C.gl4_0compat_glUniform1dv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform4d.xml +func (gl *GL) Uniform4d(location glbase.Uniform, v0, v1, v2, v3 float64) { + C.gl4_0compat_glUniform4d(gl.funcs, C.GLint(location), C.GLdouble(v0), C.GLdouble(v1), C.GLdouble(v2), C.GLdouble(v3)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform3d.xml +func (gl *GL) Uniform3d(location glbase.Uniform, v0, v1, v2 float64) { + C.gl4_0compat_glUniform3d(gl.funcs, C.GLint(location), C.GLdouble(v0), C.GLdouble(v1), C.GLdouble(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform2d.xml +func (gl *GL) Uniform2d(location glbase.Uniform, v0, v1 float64) { + C.gl4_0compat_glUniform2d(gl.funcs, C.GLint(location), C.GLdouble(v0), C.GLdouble(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform1d.xml +func (gl *GL) Uniform1d(location glbase.Uniform, v0 float64) { + C.gl4_0compat_glUniform1d(gl.funcs, C.GLint(location), C.GLdouble(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsIndirect.xml +func (gl *GL) DrawElementsIndirect(mode, gltype glbase.Enum, indirect interface{}) { + var indirect_ptr unsafe.Pointer + var indirect_v = reflect.ValueOf(indirect) + if indirect != nil && indirect_v.Kind() != reflect.Slice { + panic("parameter indirect must be a slice") + } + if indirect != nil { + indirect_ptr = unsafe.Pointer(indirect_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glDrawElementsIndirect(gl.funcs, C.GLenum(mode), C.GLenum(gltype), indirect_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawArraysIndirect.xml +func (gl *GL) DrawArraysIndirect(mode glbase.Enum, indirect interface{}) { + var indirect_ptr unsafe.Pointer + var indirect_v = reflect.ValueOf(indirect) + if indirect != nil && indirect_v.Kind() != reflect.Slice { + panic("parameter indirect must be a slice") + } + if indirect != nil { + indirect_ptr = unsafe.Pointer(indirect_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glDrawArraysIndirect(gl.funcs, C.GLenum(mode), indirect_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFuncSeparatei.xml +func (gl *GL) BlendFuncSeparatei(buf uint32, srcRGB, dstRGB, srcAlpha, dstAlpha glbase.Enum) { + C.gl4_0compat_glBlendFuncSeparatei(gl.funcs, C.GLuint(buf), C.GLenum(srcRGB), C.GLenum(dstRGB), C.GLenum(srcAlpha), C.GLenum(dstAlpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFunci.xml +func (gl *GL) BlendFunci(buf uint32, src, dst glbase.Enum) { + C.gl4_0compat_glBlendFunci(gl.funcs, C.GLuint(buf), C.GLenum(src), C.GLenum(dst)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendEquationSeparatei.xml +func (gl *GL) BlendEquationSeparatei(buf uint32, modeRGB, modeAlpha glbase.Enum) { + C.gl4_0compat_glBlendEquationSeparatei(gl.funcs, C.GLuint(buf), C.GLenum(modeRGB), C.GLenum(modeAlpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendEquationi.xml +func (gl *GL) BlendEquationi(buf uint32, mode glbase.Enum) { + C.gl4_0compat_glBlendEquationi(gl.funcs, C.GLuint(buf), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMinSampleShading.xml +func (gl *GL) MinSampleShading(value float32) { + C.gl4_0compat_glMinSampleShading(gl.funcs, C.GLfloat(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTranslatef.xml +func (gl *GL) Translatef(x, y, z float32) { + C.gl4_0compat_glTranslatef(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTranslated.xml +func (gl *GL) Translated(x, y, z float64) { + C.gl4_0compat_glTranslated(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glScalef.xml +func (gl *GL) Scalef(x, y, z float32) { + C.gl4_0compat_glScalef(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glScaled.xml +func (gl *GL) Scaled(x, y, z float64) { + C.gl4_0compat_glScaled(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRotatef.xml +func (gl *GL) Rotatef(angle, x, y, z float32) { + C.gl4_0compat_glRotatef(gl.funcs, C.GLfloat(angle), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRotated.xml +func (gl *GL) Rotated(angle, x, y, z float64) { + C.gl4_0compat_glRotated(gl.funcs, C.GLdouble(angle), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPushMatrix.xml +func (gl *GL) PushMatrix() { + C.gl4_0compat_glPushMatrix(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPopMatrix.xml +func (gl *GL) PopMatrix() { + C.gl4_0compat_glPopMatrix(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glOrtho.xml +func (gl *GL) Ortho(left, right, bottom, top, zNear, zFar float64) { + C.gl4_0compat_glOrtho(gl.funcs, C.GLdouble(left), C.GLdouble(right), C.GLdouble(bottom), C.GLdouble(top), C.GLdouble(zNear), C.GLdouble(zFar)) +} + +// MultMatrixd multiplies the current matrix with the provided matrix. +// +// The m parameter must hold 16 consecutive elements of a 4x4 column-major matrix. +// +// The current matrix is determined by the current matrix mode (see +// MatrixMode). It is either the projection matrix, modelview matrix, or the +// texture matrix. +// +// For example, if the current matrix is C and the coordinates to be transformed +// are v = (v[0], v[1], v[2], v[3]), then the current transformation is C × v, or +// +// c[0] c[4] c[8] c[12] v[0] +// c[1] c[5] c[9] c[13] v[1] +// c[2] c[6] c[10] c[14] X v[2] +// c[3] c[7] c[11] c[15] v[3] +// +// Calling MultMatrix with an argument of m = m[0], m[1], ..., m[15] +// replaces the current transformation with (C X M) x v, or +// +// c[0] c[4] c[8] c[12] m[0] m[4] m[8] m[12] v[0] +// c[1] c[5] c[9] c[13] m[1] m[5] m[9] m[13] v[1] +// c[2] c[6] c[10] c[14] X m[2] m[6] m[10] m[14] X v[2] +// c[3] c[7] c[11] c[15] m[3] m[7] m[11] m[15] v[3] +// +// Where 'X' denotes matrix multiplication, and v is represented as a 4x1 matrix. +// +// While the elements of the matrix may be specified with single or double +// precision, the GL may store or operate on these values in less-than-single +// precision. +// +// In many computer languages, 4×4 arrays are represented in row-major +// order. The transformations just described represent these matrices in +// column-major order. The order of the multiplication is important. For +// example, if the current transformation is a rotation, and MultMatrix is +// called with a translation matrix, the translation is done directly on the +// coordinates to be transformed, while the rotation is done on the results +// of that translation. +// +// GL.INVALID_OPERATION is generated if MultMatrix is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) MultMatrixd(m []float64) { + if len(m) != 16 { + panic("parameter m must have length 16 for the 4x4 matrix") + } + C.gl4_0compat_glMultMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// MultMatrixf multiplies the current matrix with the provided matrix. +// +// The m parameter must hold 16 consecutive elements of a 4x4 column-major matrix. +// +// The current matrix is determined by the current matrix mode (see +// MatrixMode). It is either the projection matrix, modelview matrix, or the +// texture matrix. +// +// For example, if the current matrix is C and the coordinates to be transformed +// are v = (v[0], v[1], v[2], v[3]), then the current transformation is C × v, or +// +// c[0] c[4] c[8] c[12] v[0] +// c[1] c[5] c[9] c[13] v[1] +// c[2] c[6] c[10] c[14] X v[2] +// c[3] c[7] c[11] c[15] v[3] +// +// Calling MultMatrix with an argument of m = m[0], m[1], ..., m[15] +// replaces the current transformation with (C X M) x v, or +// +// c[0] c[4] c[8] c[12] m[0] m[4] m[8] m[12] v[0] +// c[1] c[5] c[9] c[13] m[1] m[5] m[9] m[13] v[1] +// c[2] c[6] c[10] c[14] X m[2] m[6] m[10] m[14] X v[2] +// c[3] c[7] c[11] c[15] m[3] m[7] m[11] m[15] v[3] +// +// Where 'X' denotes matrix multiplication, and v is represented as a 4x1 matrix. +// +// While the elements of the matrix may be specified with single or double +// precision, the GL may store or operate on these values in less-than-single +// precision. +// +// In many computer languages, 4×4 arrays are represented in row-major +// order. The transformations just described represent these matrices in +// column-major order. The order of the multiplication is important. For +// example, if the current transformation is a rotation, and MultMatrix is +// called with a translation matrix, the translation is done directly on the +// coordinates to be transformed, while the rotation is done on the results +// of that translation. +// +// GL.INVALID_OPERATION is generated if MultMatrix is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) MultMatrixf(m []float32) { + if len(m) != 16 { + panic("parameter m must have length 16 for the 4x4 matrix") + } + C.gl4_0compat_glMultMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMatrixMode.xml +func (gl *GL) MatrixMode(mode glbase.Enum) { + C.gl4_0compat_glMatrixMode(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLoadMatrixd.xml +func (gl *GL) LoadMatrixd(m []float64) { + C.gl4_0compat_glLoadMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLoadMatrixf.xml +func (gl *GL) LoadMatrixf(m []float32) { + C.gl4_0compat_glLoadMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLoadIdentity.xml +func (gl *GL) LoadIdentity() { + C.gl4_0compat_glLoadIdentity(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFrustum.xml +func (gl *GL) Frustum(left, right, bottom, top, zNear, zFar float64) { + C.gl4_0compat_glFrustum(gl.funcs, C.GLdouble(left), C.GLdouble(right), C.GLdouble(bottom), C.GLdouble(top), C.GLdouble(zNear), C.GLdouble(zFar)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsList.xml +func (gl *GL) IsList(list uint32) bool { + glresult := C.gl4_0compat_glIsList(gl.funcs, C.GLuint(list)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexGeniv.xml +func (gl *GL) GetTexGeniv(coord, pname glbase.Enum, params []int32) { + C.gl4_0compat_glGetTexGeniv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexGenfv.xml +func (gl *GL) GetTexGenfv(coord, pname glbase.Enum, params []float32) { + C.gl4_0compat_glGetTexGenfv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexGendv.xml +func (gl *GL) GetTexGendv(coord, pname glbase.Enum, params []float64) { + C.gl4_0compat_glGetTexGendv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexEnviv.xml +func (gl *GL) GetTexEnviv(target, pname glbase.Enum, params []int32) { + C.gl4_0compat_glGetTexEnviv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexEnvfv.xml +func (gl *GL) GetTexEnvfv(target, pname glbase.Enum, params []float32) { + C.gl4_0compat_glGetTexEnvfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetPolygonStipple.xml +func (gl *GL) GetPolygonStipple(mask []uint8) { + C.gl4_0compat_glGetPolygonStipple(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&mask[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetPixelMapusv.xml +func (gl *GL) GetPixelMapusv(glmap glbase.Enum, values []uint16) { + C.gl4_0compat_glGetPixelMapusv(gl.funcs, C.GLenum(glmap), (*C.GLushort)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetPixelMapuiv.xml +func (gl *GL) GetPixelMapuiv(glmap glbase.Enum, values []uint32) { + C.gl4_0compat_glGetPixelMapuiv(gl.funcs, C.GLenum(glmap), (*C.GLuint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetPixelMapfv.xml +func (gl *GL) GetPixelMapfv(glmap glbase.Enum, values []float32) { + C.gl4_0compat_glGetPixelMapfv(gl.funcs, C.GLenum(glmap), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMaterialiv.xml +func (gl *GL) GetMaterialiv(face, pname glbase.Enum, params []int32) { + C.gl4_0compat_glGetMaterialiv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMaterialfv.xml +func (gl *GL) GetMaterialfv(face, pname glbase.Enum, params []float32) { + C.gl4_0compat_glGetMaterialfv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMapiv.xml +func (gl *GL) GetMapiv(target, query glbase.Enum, v []int32) { + C.gl4_0compat_glGetMapiv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMapfv.xml +func (gl *GL) GetMapfv(target, query glbase.Enum, v []float32) { + C.gl4_0compat_glGetMapfv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMapdv.xml +func (gl *GL) GetMapdv(target, query glbase.Enum, v []float64) { + C.gl4_0compat_glGetMapdv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetLightiv.xml +func (gl *GL) GetLightiv(light, pname glbase.Enum, params []int32) { + C.gl4_0compat_glGetLightiv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetLightfv.xml +func (gl *GL) GetLightfv(light, pname glbase.Enum, params []float32) { + C.gl4_0compat_glGetLightfv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetClipPlane.xml +func (gl *GL) GetClipPlane(plane glbase.Enum, equation []float64) { + C.gl4_0compat_glGetClipPlane(gl.funcs, C.GLenum(plane), (*C.GLdouble)(unsafe.Pointer(&equation[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawPixels.xml +func (gl *GL) DrawPixels(width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glDrawPixels(gl.funcs, C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyPixels.xml +func (gl *GL) CopyPixels(x, y, width, height int, gltype glbase.Enum) { + C.gl4_0compat_glCopyPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(gltype)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelMapusv.xml +func (gl *GL) PixelMapusv(glmap glbase.Enum, mapsize int32, values []uint16) { + C.gl4_0compat_glPixelMapusv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLushort)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelMapuiv.xml +func (gl *GL) PixelMapuiv(glmap glbase.Enum, mapsize int32, values []uint32) { + C.gl4_0compat_glPixelMapuiv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLuint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelMapfv.xml +func (gl *GL) PixelMapfv(glmap glbase.Enum, mapsize int32, values []float32) { + C.gl4_0compat_glPixelMapfv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelTransferi.xml +func (gl *GL) PixelTransferi(pname glbase.Enum, param int32) { + C.gl4_0compat_glPixelTransferi(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelTransferf.xml +func (gl *GL) PixelTransferf(pname glbase.Enum, param float32) { + C.gl4_0compat_glPixelTransferf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelZoom.xml +func (gl *GL) PixelZoom(xfactor, yfactor float32) { + C.gl4_0compat_glPixelZoom(gl.funcs, C.GLfloat(xfactor), C.GLfloat(yfactor)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glAlphaFunc.xml +func (gl *GL) AlphaFunc(glfunc glbase.Enum, ref float32) { + C.gl4_0compat_glAlphaFunc(gl.funcs, C.GLenum(glfunc), C.GLfloat(ref)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalPoint2.xml +func (gl *GL) EvalPoint2(i, j int32) { + C.gl4_0compat_glEvalPoint2(gl.funcs, C.GLint(i), C.GLint(j)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalMesh2.xml +func (gl *GL) EvalMesh2(mode glbase.Enum, i1, i2, j1, j2 int32) { + C.gl4_0compat_glEvalMesh2(gl.funcs, C.GLenum(mode), C.GLint(i1), C.GLint(i2), C.GLint(j1), C.GLint(j2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalPoint1.xml +func (gl *GL) EvalPoint1(i int32) { + C.gl4_0compat_glEvalPoint1(gl.funcs, C.GLint(i)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalMesh1.xml +func (gl *GL) EvalMesh1(mode glbase.Enum, i1, i2 int32) { + C.gl4_0compat_glEvalMesh1(gl.funcs, C.GLenum(mode), C.GLint(i1), C.GLint(i2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalCoord2fv.xml +func (gl *GL) EvalCoord2fv(u []float32) { + if len(u) != 2 { + panic("parameter u has incorrect length") + } + C.gl4_0compat_glEvalCoord2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalCoord2f.xml +func (gl *GL) EvalCoord2f(u, v float32) { + C.gl4_0compat_glEvalCoord2f(gl.funcs, C.GLfloat(u), C.GLfloat(v)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalCoord2dv.xml +func (gl *GL) EvalCoord2dv(u []float64) { + if len(u) != 2 { + panic("parameter u has incorrect length") + } + C.gl4_0compat_glEvalCoord2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalCoord2d.xml +func (gl *GL) EvalCoord2d(u, v float64) { + C.gl4_0compat_glEvalCoord2d(gl.funcs, C.GLdouble(u), C.GLdouble(v)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalCoord1fv.xml +func (gl *GL) EvalCoord1fv(u []float32) { + C.gl4_0compat_glEvalCoord1fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalCoord1f.xml +func (gl *GL) EvalCoord1f(u float32) { + C.gl4_0compat_glEvalCoord1f(gl.funcs, C.GLfloat(u)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalCoord1dv.xml +func (gl *GL) EvalCoord1dv(u []float64) { + C.gl4_0compat_glEvalCoord1dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalCoord1d.xml +func (gl *GL) EvalCoord1d(u float64) { + C.gl4_0compat_glEvalCoord1d(gl.funcs, C.GLdouble(u)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMapGrid2f.xml +func (gl *GL) MapGrid2f(un int32, u1, u2 float32, vn int32, v1, v2 float32) { + C.gl4_0compat_glMapGrid2f(gl.funcs, C.GLint(un), C.GLfloat(u1), C.GLfloat(u2), C.GLint(vn), C.GLfloat(v1), C.GLfloat(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMapGrid2d.xml +func (gl *GL) MapGrid2d(un int32, u1, u2 float64, vn int32, v1, v2 float64) { + C.gl4_0compat_glMapGrid2d(gl.funcs, C.GLint(un), C.GLdouble(u1), C.GLdouble(u2), C.GLint(vn), C.GLdouble(v1), C.GLdouble(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMapGrid1f.xml +func (gl *GL) MapGrid1f(un int32, u1, u2 float32) { + C.gl4_0compat_glMapGrid1f(gl.funcs, C.GLint(un), C.GLfloat(u1), C.GLfloat(u2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMapGrid1d.xml +func (gl *GL) MapGrid1d(un int32, u1, u2 float64) { + C.gl4_0compat_glMapGrid1d(gl.funcs, C.GLint(un), C.GLdouble(u1), C.GLdouble(u2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMap2f.xml +func (gl *GL) Map2f(target glbase.Enum, u1, u2 float32, ustride, uorder int32, v1, v2 float32, vstride, vorder int32, points []float32) { + C.gl4_0compat_glMap2f(gl.funcs, C.GLenum(target), C.GLfloat(u1), C.GLfloat(u2), C.GLint(ustride), C.GLint(uorder), C.GLfloat(v1), C.GLfloat(v2), C.GLint(vstride), C.GLint(vorder), (*C.GLfloat)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMap2d.xml +func (gl *GL) Map2d(target glbase.Enum, u1, u2 float64, ustride, uorder int32, v1, v2 float64, vstride, vorder int32, points []float64) { + C.gl4_0compat_glMap2d(gl.funcs, C.GLenum(target), C.GLdouble(u1), C.GLdouble(u2), C.GLint(ustride), C.GLint(uorder), C.GLdouble(v1), C.GLdouble(v2), C.GLint(vstride), C.GLint(vorder), (*C.GLdouble)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMap1f.xml +func (gl *GL) Map1f(target glbase.Enum, u1, u2 float32, stride, order int, points []float32) { + C.gl4_0compat_glMap1f(gl.funcs, C.GLenum(target), C.GLfloat(u1), C.GLfloat(u2), C.GLint(stride), C.GLint(order), (*C.GLfloat)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMap1d.xml +func (gl *GL) Map1d(target glbase.Enum, u1, u2 float64, stride, order int, points []float64) { + C.gl4_0compat_glMap1d(gl.funcs, C.GLenum(target), C.GLdouble(u1), C.GLdouble(u2), C.GLint(stride), C.GLint(order), (*C.GLdouble)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPushAttrib.xml +func (gl *GL) PushAttrib(mask glbase.Bitfield) { + C.gl4_0compat_glPushAttrib(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPopAttrib.xml +func (gl *GL) PopAttrib() { + C.gl4_0compat_glPopAttrib(gl.funcs) +} + +// Accum executes an operation on the accumulation buffer. +// +// Parameter op defines the accumulation buffer operation (GL.ACCUM, GL.LOAD, +// GL.ADD, GL.MULT, or GL.RETURN) and specifies how the value parameter is +// used. +// +// The accumulation buffer is an extended-range color buffer. Images are not +// rendered into it. Rather, images rendered into one of the color buffers +// are added to the contents of the accumulation buffer after rendering. +// Effects such as antialiasing (of points, lines, and polygons), motion +// blur, and depth of field can be created by accumulating images generated +// with different transformation matrices. +// +// Each pixel in the accumulation buffer consists of red, green, blue, and +// alpha values. The number of bits per component in the accumulation buffer +// depends on the implementation. You can examine this number by calling +// GetIntegerv four times, with arguments GL.ACCUM_RED_BITS, +// GL.ACCUM_GREEN_BITS, GL.ACCUM_BLUE_BITS, and GL.ACCUM_ALPHA_BITS. +// Regardless of the number of bits per component, the range of values stored +// by each component is (-1, 1). The accumulation buffer pixels are mapped +// one-to-one with frame buffer pixels. +// +// All accumulation buffer operations are limited to the area of the current +// scissor box and applied identically to the red, green, blue, and alpha +// components of each pixel. If a Accum operation results in a value outside +// the range (-1, 1), the contents of an accumulation buffer pixel component +// are undefined. +// +// The operations are as follows: +// +// GL.ACCUM +// Obtains R, G, B, and A values from the buffer currently selected for +// reading (see ReadBuffer). Each component value is divided by 2 n - +// 1 , where n is the number of bits allocated to each color component +// in the currently selected buffer. The result is a floating-point +// value in the range 0 1 , which is multiplied by value and added to +// the corresponding pixel component in the accumulation buffer, +// thereby updating the accumulation buffer. +// +// GL.LOAD +// Similar to GL.ACCUM, except that the current value in the +// accumulation buffer is not used in the calculation of the new value. +// That is, the R, G, B, and A values from the currently selected +// buffer are divided by 2 n - 1 , multiplied by value, and then stored +// in the corresponding accumulation buffer cell, overwriting the +// current value. +// +// GL.ADD +// Adds value to each R, G, B, and A in the accumulation buffer. +// +// GL.MULT +// Multiplies each R, G, B, and A in the accumulation buffer by value +// and returns the scaled component to its corresponding accumulation +// buffer location. +// +// GL.RETURN +// Transfers accumulation buffer values to the color buffer or buffers +// currently selected for writing. Each R, G, B, and A component is +// multiplied by value, then multiplied by 2 n - 1 , clamped to the +// range 0 2 n - 1 , and stored in the corresponding display buffer +// cell. The only fragment operations that are applied to this transfer +// are pixel ownership, scissor, dithering, and color writemasks. +// +// To clear the accumulation buffer, call ClearAccum with R, G, B, and A +// values to set it to, then call Clear with the accumulation buffer +// enabled. +// +// Error GL.INVALID_ENUM is generated if op is not an accepted value. +// GL.INVALID_OPERATION is generated if there is no accumulation buffer. +// GL.INVALID_OPERATION is generated if Accum is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) Accum(op glbase.Enum, value float32) { + C.gl4_0compat_glAccum(gl.funcs, C.GLenum(op), C.GLfloat(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexMask.xml +func (gl *GL) IndexMask(mask uint32) { + C.gl4_0compat_glIndexMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearIndex.xml +func (gl *GL) ClearIndex(c float32) { + C.gl4_0compat_glClearIndex(gl.funcs, C.GLfloat(c)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearAccum.xml +func (gl *GL) ClearAccum(red, green, blue, alpha float32) { + C.gl4_0compat_glClearAccum(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPushName.xml +func (gl *GL) PushName(name uint32) { + C.gl4_0compat_glPushName(gl.funcs, C.GLuint(name)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPopName.xml +func (gl *GL) PopName() { + C.gl4_0compat_glPopName(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPassThrough.xml +func (gl *GL) PassThrough(token float32) { + C.gl4_0compat_glPassThrough(gl.funcs, C.GLfloat(token)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLoadName.xml +func (gl *GL) LoadName(name uint32) { + C.gl4_0compat_glLoadName(gl.funcs, C.GLuint(name)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glInitNames.xml +func (gl *GL) InitNames() { + C.gl4_0compat_glInitNames(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRenderMode.xml +func (gl *GL) RenderMode(mode glbase.Enum) int32 { + glresult := C.gl4_0compat_glRenderMode(gl.funcs, C.GLenum(mode)) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSelectBuffer.xml +func (gl *GL) SelectBuffer(size int, buffer []glbase.Buffer) { + C.gl4_0compat_glSelectBuffer(gl.funcs, C.GLsizei(size), (*C.GLuint)(unsafe.Pointer(&buffer[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFeedbackBuffer.xml +func (gl *GL) FeedbackBuffer(size int, gltype glbase.Enum, buffer []float32) { + C.gl4_0compat_glFeedbackBuffer(gl.funcs, C.GLsizei(size), C.GLenum(gltype), (*C.GLfloat)(unsafe.Pointer(&buffer[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexGeniv.xml +func (gl *GL) TexGeniv(coord, pname glbase.Enum, params []int32) { + C.gl4_0compat_glTexGeniv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexGeni.xml +func (gl *GL) TexGeni(coord, pname glbase.Enum, param int32) { + C.gl4_0compat_glTexGeni(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexGenfv.xml +func (gl *GL) TexGenfv(coord, pname glbase.Enum, params []float32) { + C.gl4_0compat_glTexGenfv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexGenf.xml +func (gl *GL) TexGenf(coord, pname glbase.Enum, param float32) { + C.gl4_0compat_glTexGenf(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexGendv.xml +func (gl *GL) TexGendv(coord, pname glbase.Enum, params []float64) { + C.gl4_0compat_glTexGendv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexGend.xml +func (gl *GL) TexGend(coord, pname glbase.Enum, param float64) { + C.gl4_0compat_glTexGend(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLdouble(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexEnviv.xml +func (gl *GL) TexEnviv(target, pname glbase.Enum, params []int32) { + C.gl4_0compat_glTexEnviv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexEnvi.xml +func (gl *GL) TexEnvi(target, pname glbase.Enum, param int32) { + C.gl4_0compat_glTexEnvi(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexEnvfv.xml +func (gl *GL) TexEnvfv(target, pname glbase.Enum, params []float32) { + C.gl4_0compat_glTexEnvfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexEnvf.xml +func (gl *GL) TexEnvf(target, pname glbase.Enum, param float32) { + C.gl4_0compat_glTexEnvf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glShadeModel.xml +func (gl *GL) ShadeModel(mode glbase.Enum) { + C.gl4_0compat_glShadeModel(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPolygonStipple.xml +func (gl *GL) PolygonStipple(mask []uint8) { + C.gl4_0compat_glPolygonStipple(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&mask[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMaterialiv.xml +func (gl *GL) Materialiv(face, pname glbase.Enum, params []int32) { + C.gl4_0compat_glMaterialiv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMateriali.xml +func (gl *GL) Materiali(face, pname glbase.Enum, param int32) { + C.gl4_0compat_glMateriali(gl.funcs, C.GLenum(face), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMaterialfv.xml +func (gl *GL) Materialfv(face, pname glbase.Enum, params []float32) { + C.gl4_0compat_glMaterialfv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMaterialf.xml +func (gl *GL) Materialf(face, pname glbase.Enum, param float32) { + C.gl4_0compat_glMaterialf(gl.funcs, C.GLenum(face), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLineStipple.xml +func (gl *GL) LineStipple(factor int32, pattern uint16) { + C.gl4_0compat_glLineStipple(gl.funcs, C.GLint(factor), C.GLushort(pattern)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLightModeliv.xml +func (gl *GL) LightModeliv(pname glbase.Enum, params []int32) { + C.gl4_0compat_glLightModeliv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLightModeli.xml +func (gl *GL) LightModeli(pname glbase.Enum, param int32) { + C.gl4_0compat_glLightModeli(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLightModelfv.xml +func (gl *GL) LightModelfv(pname glbase.Enum, params []float32) { + C.gl4_0compat_glLightModelfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLightModelf.xml +func (gl *GL) LightModelf(pname glbase.Enum, param float32) { + C.gl4_0compat_glLightModelf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLightiv.xml +func (gl *GL) Lightiv(light, pname glbase.Enum, params []int32) { + C.gl4_0compat_glLightiv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLighti.xml +func (gl *GL) Lighti(light, pname glbase.Enum, param int32) { + C.gl4_0compat_glLighti(gl.funcs, C.GLenum(light), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLightfv.xml +func (gl *GL) Lightfv(light, pname glbase.Enum, params []float32) { + C.gl4_0compat_glLightfv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLightf.xml +func (gl *GL) Lightf(light, pname glbase.Enum, param float32) { + C.gl4_0compat_glLightf(gl.funcs, C.GLenum(light), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogiv.xml +func (gl *GL) Fogiv(pname glbase.Enum, params []int32) { + C.gl4_0compat_glFogiv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogi.xml +func (gl *GL) Fogi(pname glbase.Enum, param int32) { + C.gl4_0compat_glFogi(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogfv.xml +func (gl *GL) Fogfv(pname glbase.Enum, params []float32) { + C.gl4_0compat_glFogfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogf.xml +func (gl *GL) Fogf(pname glbase.Enum, param float32) { + C.gl4_0compat_glFogf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorMaterial.xml +func (gl *GL) ColorMaterial(face, mode glbase.Enum) { + C.gl4_0compat_glColorMaterial(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClipPlane.xml +func (gl *GL) ClipPlane(plane glbase.Enum, equation []float64) { + C.gl4_0compat_glClipPlane(gl.funcs, C.GLenum(plane), (*C.GLdouble)(unsafe.Pointer(&equation[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex4sv.xml +func (gl *GL) Vertex4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glVertex4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex4s.xml +func (gl *GL) Vertex4s(x, y, z, w int16) { + C.gl4_0compat_glVertex4s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex4iv.xml +func (gl *GL) Vertex4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glVertex4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex4i.xml +func (gl *GL) Vertex4i(x, y, z, w int) { + C.gl4_0compat_glVertex4i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex4fv.xml +func (gl *GL) Vertex4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glVertex4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex4f.xml +func (gl *GL) Vertex4f(x, y, z, w float32) { + C.gl4_0compat_glVertex4f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex4dv.xml +func (gl *GL) Vertex4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glVertex4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex4d.xml +func (gl *GL) Vertex4d(x, y, z, w float64) { + C.gl4_0compat_glVertex4d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex3sv.xml +func (gl *GL) Vertex3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glVertex3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex3s.xml +func (gl *GL) Vertex3s(x, y, z int16) { + C.gl4_0compat_glVertex3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex3iv.xml +func (gl *GL) Vertex3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glVertex3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex3i.xml +func (gl *GL) Vertex3i(x, y, z int) { + C.gl4_0compat_glVertex3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex3fv.xml +func (gl *GL) Vertex3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glVertex3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex3f.xml +func (gl *GL) Vertex3f(x, y, z float32) { + C.gl4_0compat_glVertex3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex3dv.xml +func (gl *GL) Vertex3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glVertex3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex3d.xml +func (gl *GL) Vertex3d(x, y, z float64) { + C.gl4_0compat_glVertex3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex2sv.xml +func (gl *GL) Vertex2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glVertex2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex2s.xml +func (gl *GL) Vertex2s(x, y int16) { + C.gl4_0compat_glVertex2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex2iv.xml +func (gl *GL) Vertex2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glVertex2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex2i.xml +func (gl *GL) Vertex2i(x, y int) { + C.gl4_0compat_glVertex2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex2fv.xml +func (gl *GL) Vertex2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glVertex2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex2f.xml +func (gl *GL) Vertex2f(x, y float32) { + C.gl4_0compat_glVertex2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex2dv.xml +func (gl *GL) Vertex2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glVertex2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex2d.xml +func (gl *GL) Vertex2d(x, y float64) { + C.gl4_0compat_glVertex2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord4sv.xml +func (gl *GL) TexCoord4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glTexCoord4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord4s.xml +func (gl *GL) TexCoord4s(s, t, r, q int16) { + C.gl4_0compat_glTexCoord4s(gl.funcs, C.GLshort(s), C.GLshort(t), C.GLshort(r), C.GLshort(q)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord4iv.xml +func (gl *GL) TexCoord4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glTexCoord4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord4i.xml +func (gl *GL) TexCoord4i(s, t, r, q int32) { + C.gl4_0compat_glTexCoord4i(gl.funcs, C.GLint(s), C.GLint(t), C.GLint(r), C.GLint(q)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord4fv.xml +func (gl *GL) TexCoord4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glTexCoord4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord4f.xml +func (gl *GL) TexCoord4f(s, t, r, q float32) { + C.gl4_0compat_glTexCoord4f(gl.funcs, C.GLfloat(s), C.GLfloat(t), C.GLfloat(r), C.GLfloat(q)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord4dv.xml +func (gl *GL) TexCoord4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glTexCoord4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord4d.xml +func (gl *GL) TexCoord4d(s, t, r, q float64) { + C.gl4_0compat_glTexCoord4d(gl.funcs, C.GLdouble(s), C.GLdouble(t), C.GLdouble(r), C.GLdouble(q)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord3sv.xml +func (gl *GL) TexCoord3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glTexCoord3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord3s.xml +func (gl *GL) TexCoord3s(s, t, r int16) { + C.gl4_0compat_glTexCoord3s(gl.funcs, C.GLshort(s), C.GLshort(t), C.GLshort(r)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord3iv.xml +func (gl *GL) TexCoord3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glTexCoord3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord3i.xml +func (gl *GL) TexCoord3i(s, t, r int32) { + C.gl4_0compat_glTexCoord3i(gl.funcs, C.GLint(s), C.GLint(t), C.GLint(r)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord3fv.xml +func (gl *GL) TexCoord3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glTexCoord3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord3f.xml +func (gl *GL) TexCoord3f(s, t, r float32) { + C.gl4_0compat_glTexCoord3f(gl.funcs, C.GLfloat(s), C.GLfloat(t), C.GLfloat(r)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord3dv.xml +func (gl *GL) TexCoord3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glTexCoord3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord3d.xml +func (gl *GL) TexCoord3d(s, t, r float64) { + C.gl4_0compat_glTexCoord3d(gl.funcs, C.GLdouble(s), C.GLdouble(t), C.GLdouble(r)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord2sv.xml +func (gl *GL) TexCoord2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glTexCoord2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord2s.xml +func (gl *GL) TexCoord2s(s, t int16) { + C.gl4_0compat_glTexCoord2s(gl.funcs, C.GLshort(s), C.GLshort(t)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord2iv.xml +func (gl *GL) TexCoord2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glTexCoord2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord2i.xml +func (gl *GL) TexCoord2i(s, t int32) { + C.gl4_0compat_glTexCoord2i(gl.funcs, C.GLint(s), C.GLint(t)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord2fv.xml +func (gl *GL) TexCoord2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glTexCoord2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord2f.xml +func (gl *GL) TexCoord2f(s, t float32) { + C.gl4_0compat_glTexCoord2f(gl.funcs, C.GLfloat(s), C.GLfloat(t)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord2dv.xml +func (gl *GL) TexCoord2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glTexCoord2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord2d.xml +func (gl *GL) TexCoord2d(s, t float64) { + C.gl4_0compat_glTexCoord2d(gl.funcs, C.GLdouble(s), C.GLdouble(t)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord1sv.xml +func (gl *GL) TexCoord1sv(v []int16) { + C.gl4_0compat_glTexCoord1sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord1s.xml +func (gl *GL) TexCoord1s(s int16) { + C.gl4_0compat_glTexCoord1s(gl.funcs, C.GLshort(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord1iv.xml +func (gl *GL) TexCoord1iv(v []int32) { + C.gl4_0compat_glTexCoord1iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord1i.xml +func (gl *GL) TexCoord1i(s int32) { + C.gl4_0compat_glTexCoord1i(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord1fv.xml +func (gl *GL) TexCoord1fv(v []float32) { + C.gl4_0compat_glTexCoord1fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord1f.xml +func (gl *GL) TexCoord1f(s float32) { + C.gl4_0compat_glTexCoord1f(gl.funcs, C.GLfloat(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord1dv.xml +func (gl *GL) TexCoord1dv(v []float64) { + C.gl4_0compat_glTexCoord1dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord1d.xml +func (gl *GL) TexCoord1d(s float64) { + C.gl4_0compat_glTexCoord1d(gl.funcs, C.GLdouble(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRectsv.xml +func (gl *GL) Rectsv(v1, v2 []int16) { + C.gl4_0compat_glRectsv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v1[0])), (*C.GLshort)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRects.xml +func (gl *GL) Rects(x1, y1, x2, y2 int16) { + C.gl4_0compat_glRects(gl.funcs, C.GLshort(x1), C.GLshort(y1), C.GLshort(x2), C.GLshort(y2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRectiv.xml +func (gl *GL) Rectiv(v1, v2 []int32) { + C.gl4_0compat_glRectiv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v1[0])), (*C.GLint)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRecti.xml +func (gl *GL) Recti(x1, y1, x2, y2 int32) { + C.gl4_0compat_glRecti(gl.funcs, C.GLint(x1), C.GLint(y1), C.GLint(x2), C.GLint(y2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRectfv.xml +func (gl *GL) Rectfv(v1, v2 []float32) { + C.gl4_0compat_glRectfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v1[0])), (*C.GLfloat)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRectf.xml +func (gl *GL) Rectf(x1, y1, x2, y2 float32) { + C.gl4_0compat_glRectf(gl.funcs, C.GLfloat(x1), C.GLfloat(y1), C.GLfloat(x2), C.GLfloat(y2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRectdv.xml +func (gl *GL) Rectdv(v1, v2 []float64) { + C.gl4_0compat_glRectdv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v1[0])), (*C.GLdouble)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRectd.xml +func (gl *GL) Rectd(x1, y1, x2, y2 float64) { + C.gl4_0compat_glRectd(gl.funcs, C.GLdouble(x1), C.GLdouble(y1), C.GLdouble(x2), C.GLdouble(y2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos4sv.xml +func (gl *GL) RasterPos4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glRasterPos4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos4s.xml +func (gl *GL) RasterPos4s(x, y, z, w int16) { + C.gl4_0compat_glRasterPos4s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos4iv.xml +func (gl *GL) RasterPos4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glRasterPos4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos4i.xml +func (gl *GL) RasterPos4i(x, y, z, w int) { + C.gl4_0compat_glRasterPos4i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos4fv.xml +func (gl *GL) RasterPos4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glRasterPos4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos4f.xml +func (gl *GL) RasterPos4f(x, y, z, w float32) { + C.gl4_0compat_glRasterPos4f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos4dv.xml +func (gl *GL) RasterPos4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glRasterPos4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos4d.xml +func (gl *GL) RasterPos4d(x, y, z, w float64) { + C.gl4_0compat_glRasterPos4d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos3sv.xml +func (gl *GL) RasterPos3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glRasterPos3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos3s.xml +func (gl *GL) RasterPos3s(x, y, z int16) { + C.gl4_0compat_glRasterPos3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos3iv.xml +func (gl *GL) RasterPos3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glRasterPos3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos3i.xml +func (gl *GL) RasterPos3i(x, y, z int) { + C.gl4_0compat_glRasterPos3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos3fv.xml +func (gl *GL) RasterPos3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glRasterPos3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos3f.xml +func (gl *GL) RasterPos3f(x, y, z float32) { + C.gl4_0compat_glRasterPos3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos3dv.xml +func (gl *GL) RasterPos3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glRasterPos3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos3d.xml +func (gl *GL) RasterPos3d(x, y, z float64) { + C.gl4_0compat_glRasterPos3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos2sv.xml +func (gl *GL) RasterPos2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glRasterPos2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos2s.xml +func (gl *GL) RasterPos2s(x, y int16) { + C.gl4_0compat_glRasterPos2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos2iv.xml +func (gl *GL) RasterPos2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glRasterPos2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos2i.xml +func (gl *GL) RasterPos2i(x, y int) { + C.gl4_0compat_glRasterPos2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos2fv.xml +func (gl *GL) RasterPos2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glRasterPos2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos2f.xml +func (gl *GL) RasterPos2f(x, y float32) { + C.gl4_0compat_glRasterPos2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos2dv.xml +func (gl *GL) RasterPos2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glRasterPos2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos2d.xml +func (gl *GL) RasterPos2d(x, y float64) { + C.gl4_0compat_glRasterPos2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3sv.xml +func (gl *GL) Normal3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glNormal3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3s.xml +func (gl *GL) Normal3s(nx, ny, nz int16) { + C.gl4_0compat_glNormal3s(gl.funcs, C.GLshort(nx), C.GLshort(ny), C.GLshort(nz)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3iv.xml +func (gl *GL) Normal3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glNormal3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3i.xml +func (gl *GL) Normal3i(nx, ny, nz int32) { + C.gl4_0compat_glNormal3i(gl.funcs, C.GLint(nx), C.GLint(ny), C.GLint(nz)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3fv.xml +func (gl *GL) Normal3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glNormal3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3f.xml +func (gl *GL) Normal3f(nx, ny, nz float32) { + C.gl4_0compat_glNormal3f(gl.funcs, C.GLfloat(nx), C.GLfloat(ny), C.GLfloat(nz)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3dv.xml +func (gl *GL) Normal3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glNormal3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3d.xml +func (gl *GL) Normal3d(nx, ny, nz float64) { + C.gl4_0compat_glNormal3d(gl.funcs, C.GLdouble(nx), C.GLdouble(ny), C.GLdouble(nz)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3bv.xml +func (gl *GL) Normal3bv(v []byte) { + C.gl4_0compat_glNormal3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3b.xml +func (gl *GL) Normal3b(nx, ny, nz byte) { + C.gl4_0compat_glNormal3b(gl.funcs, C.GLbyte(nx), C.GLbyte(ny), C.GLbyte(nz)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexsv.xml +func (gl *GL) Indexsv(c []int16) { + C.gl4_0compat_glIndexsv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexs.xml +func (gl *GL) Indexs(c int16) { + C.gl4_0compat_glIndexs(gl.funcs, C.GLshort(c)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexiv.xml +func (gl *GL) Indexiv(c []int32) { + C.gl4_0compat_glIndexiv(gl.funcs, (*C.GLint)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexi.xml +func (gl *GL) Indexi(c int32) { + C.gl4_0compat_glIndexi(gl.funcs, C.GLint(c)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexfv.xml +func (gl *GL) Indexfv(c []float32) { + C.gl4_0compat_glIndexfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexf.xml +func (gl *GL) Indexf(c float32) { + C.gl4_0compat_glIndexf(gl.funcs, C.GLfloat(c)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexdv.xml +func (gl *GL) Indexdv(c []float64) { + C.gl4_0compat_glIndexdv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexd.xml +func (gl *GL) Indexd(c float64) { + C.gl4_0compat_glIndexd(gl.funcs, C.GLdouble(c)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEnd.xml +func (gl *GL) End() { + C.gl4_0compat_glEnd(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEdgeFlagv.xml +func (gl *GL) EdgeFlagv(flag []bool) { + C.gl4_0compat_glEdgeFlagv(gl.funcs, (*C.GLboolean)(unsafe.Pointer(&flag[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEdgeFlag.xml +func (gl *GL) EdgeFlag(flag bool) { + C.gl4_0compat_glEdgeFlag(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4usv.xml +func (gl *GL) Color4usv(v []uint16) { + C.gl4_0compat_glColor4usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4us.xml +func (gl *GL) Color4us(red, green, blue, alpha uint16) { + C.gl4_0compat_glColor4us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue), C.GLushort(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4uiv.xml +func (gl *GL) Color4uiv(v []uint32) { + C.gl4_0compat_glColor4uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4ui.xml +func (gl *GL) Color4ui(red, green, blue, alpha uint32) { + C.gl4_0compat_glColor4ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue), C.GLuint(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4ubv.xml +func (gl *GL) Color4ubv(v []uint8) { + C.gl4_0compat_glColor4ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4ub.xml +func (gl *GL) Color4ub(red, green, blue, alpha uint8) { + C.gl4_0compat_glColor4ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue), C.GLubyte(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4sv.xml +func (gl *GL) Color4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glColor4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4s.xml +func (gl *GL) Color4s(red, green, blue, alpha int16) { + C.gl4_0compat_glColor4s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue), C.GLshort(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4iv.xml +func (gl *GL) Color4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glColor4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4i.xml +func (gl *GL) Color4i(red, green, blue, alpha int32) { + C.gl4_0compat_glColor4i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue), C.GLint(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4fv.xml +func (gl *GL) Color4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glColor4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4f.xml +func (gl *GL) Color4f(red, green, blue, alpha float32) { + C.gl4_0compat_glColor4f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4dv.xml +func (gl *GL) Color4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glColor4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4d.xml +func (gl *GL) Color4d(red, green, blue, alpha float64) { + C.gl4_0compat_glColor4d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue), C.GLdouble(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4bv.xml +func (gl *GL) Color4bv(v []byte) { + C.gl4_0compat_glColor4bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4b.xml +func (gl *GL) Color4b(red, green, blue, alpha byte) { + C.gl4_0compat_glColor4b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue), C.GLbyte(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3usv.xml +func (gl *GL) Color3usv(v []uint16) { + C.gl4_0compat_glColor3usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3us.xml +func (gl *GL) Color3us(red, green, blue uint16) { + C.gl4_0compat_glColor3us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3uiv.xml +func (gl *GL) Color3uiv(v []uint32) { + C.gl4_0compat_glColor3uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3ui.xml +func (gl *GL) Color3ui(red, green, blue uint32) { + C.gl4_0compat_glColor3ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3ubv.xml +func (gl *GL) Color3ubv(v []uint8) { + C.gl4_0compat_glColor3ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3ub.xml +func (gl *GL) Color3ub(red, green, blue uint8) { + C.gl4_0compat_glColor3ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3sv.xml +func (gl *GL) Color3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glColor3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3s.xml +func (gl *GL) Color3s(red, green, blue int16) { + C.gl4_0compat_glColor3s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3iv.xml +func (gl *GL) Color3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glColor3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3i.xml +func (gl *GL) Color3i(red, green, blue int32) { + C.gl4_0compat_glColor3i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3fv.xml +func (gl *GL) Color3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glColor3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3f.xml +func (gl *GL) Color3f(red, green, blue float32) { + C.gl4_0compat_glColor3f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3dv.xml +func (gl *GL) Color3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glColor3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3d.xml +func (gl *GL) Color3d(red, green, blue float64) { + C.gl4_0compat_glColor3d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3bv.xml +func (gl *GL) Color3bv(v []byte) { + C.gl4_0compat_glColor3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3b.xml +func (gl *GL) Color3b(red, green, blue byte) { + C.gl4_0compat_glColor3b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBitmap.xml +func (gl *GL) Bitmap(width, height int, xorig, yorig, xmove, ymove float32, bitmap []uint8) { + C.gl4_0compat_glBitmap(gl.funcs, C.GLsizei(width), C.GLsizei(height), C.GLfloat(xorig), C.GLfloat(yorig), C.GLfloat(xmove), C.GLfloat(ymove), (*C.GLubyte)(unsafe.Pointer(&bitmap[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBegin.xml +func (gl *GL) Begin(mode glbase.Enum) { + C.gl4_0compat_glBegin(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glListBase.xml +func (gl *GL) ListBase(base uint32) { + C.gl4_0compat_glListBase(gl.funcs, C.GLuint(base)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenLists.xml +func (gl *GL) GenLists(range_ int32) uint32 { + glresult := C.gl4_0compat_glGenLists(gl.funcs, C.GLsizei(range_)) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteLists.xml +func (gl *GL) DeleteLists(list uint32, range_ int32) { + C.gl4_0compat_glDeleteLists(gl.funcs, C.GLuint(list), C.GLsizei(range_)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCallLists.xml +func (gl *GL) CallLists(n int, gltype glbase.Enum, lists interface{}) { + var lists_ptr unsafe.Pointer + var lists_v = reflect.ValueOf(lists) + if lists != nil && lists_v.Kind() != reflect.Slice { + panic("parameter lists must be a slice") + } + if lists != nil { + lists_ptr = unsafe.Pointer(lists_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glCallLists(gl.funcs, C.GLsizei(n), C.GLenum(gltype), lists_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCallList.xml +func (gl *GL) CallList(list uint32) { + C.gl4_0compat_glCallList(gl.funcs, C.GLuint(list)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndList.xml +func (gl *GL) EndList() { + C.gl4_0compat_glEndList(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNewList.xml +func (gl *GL) NewList(list uint32, mode glbase.Enum) { + C.gl4_0compat_glNewList(gl.funcs, C.GLuint(list), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPushClientAttrib.xml +func (gl *GL) PushClientAttrib(mask glbase.Bitfield) { + C.gl4_0compat_glPushClientAttrib(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPopClientAttrib.xml +func (gl *GL) PopClientAttrib() { + C.gl4_0compat_glPopClientAttrib(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPrioritizeTextures.xml +func (gl *GL) PrioritizeTextures(n int, textures []glbase.Texture, priorities []float32) { + C.gl4_0compat_glPrioritizeTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0])), (*C.GLfloat)(unsafe.Pointer(&priorities[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glAreTexturesResident.xml +func (gl *GL) AreTexturesResident(n int, textures []glbase.Texture, residences []bool) bool { + glresult := C.gl4_0compat_glAreTexturesResident(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0])), (*C.GLboolean)(unsafe.Pointer(&residences[0]))) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexPointer.xml +func (gl *GL) VertexPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glVertexPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordPointer.xml +func (gl *GL) TexCoordPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glTexCoordPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormalPointer.xml +func (gl *GL) NormalPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glNormalPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glInterleavedArrays.xml +func (gl *GL) InterleavedArrays(format glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glInterleavedArrays(gl.funcs, C.GLenum(format), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexPointer.xml +func (gl *GL) IndexPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glIndexPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEnableClientState.xml +func (gl *GL) EnableClientState(array glbase.Enum) { + C.gl4_0compat_glEnableClientState(gl.funcs, C.GLenum(array)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEdgeFlagPointer.xml +func (gl *GL) EdgeFlagPointer(stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glEdgeFlagPointer(gl.funcs, C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDisableClientState.xml +func (gl *GL) DisableClientState(array glbase.Enum) { + C.gl4_0compat_glDisableClientState(gl.funcs, C.GLenum(array)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorPointer.xml +func (gl *GL) ColorPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glColorPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glArrayElement.xml +func (gl *GL) ArrayElement(i int32) { + C.gl4_0compat_glArrayElement(gl.funcs, C.GLint(i)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glResetMinmax.xml +func (gl *GL) ResetMinmax(target glbase.Enum) { + C.gl4_0compat_glResetMinmax(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glResetHistogram.xml +func (gl *GL) ResetHistogram(target glbase.Enum) { + C.gl4_0compat_glResetHistogram(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMinmax.xml +func (gl *GL) Minmax(target, internalFormat glbase.Enum, sink bool) { + C.gl4_0compat_glMinmax(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), *(*C.GLboolean)(unsafe.Pointer(&sink))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glHistogram.xml +func (gl *GL) Histogram(target glbase.Enum, width int, internalFormat glbase.Enum, sink bool) { + C.gl4_0compat_glHistogram(gl.funcs, C.GLenum(target), C.GLsizei(width), C.GLenum(internalFormat), *(*C.GLboolean)(unsafe.Pointer(&sink))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMinmaxParameteriv.xml +func (gl *GL) GetMinmaxParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_0compat_glGetMinmaxParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMinmaxParameterfv.xml +func (gl *GL) GetMinmaxParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_0compat_glGetMinmaxParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMinmax.xml +func (gl *GL) GetMinmax(target glbase.Enum, reset bool, format, gltype glbase.Enum, values interface{}) { + var values_ptr unsafe.Pointer + var values_v = reflect.ValueOf(values) + if values != nil && values_v.Kind() != reflect.Slice { + panic("parameter values must be a slice") + } + if values != nil { + values_ptr = unsafe.Pointer(values_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glGetMinmax(gl.funcs, C.GLenum(target), *(*C.GLboolean)(unsafe.Pointer(&reset)), C.GLenum(format), C.GLenum(gltype), values_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetHistogramParameteriv.xml +func (gl *GL) GetHistogramParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_0compat_glGetHistogramParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetHistogramParameterfv.xml +func (gl *GL) GetHistogramParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_0compat_glGetHistogramParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetHistogram.xml +func (gl *GL) GetHistogram(target glbase.Enum, reset bool, format, gltype glbase.Enum, values interface{}) { + var values_ptr unsafe.Pointer + var values_v = reflect.ValueOf(values) + if values != nil && values_v.Kind() != reflect.Slice { + panic("parameter values must be a slice") + } + if values != nil { + values_ptr = unsafe.Pointer(values_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glGetHistogram(gl.funcs, C.GLenum(target), *(*C.GLboolean)(unsafe.Pointer(&reset)), C.GLenum(format), C.GLenum(gltype), values_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSeparableFilter2D.xml +func (gl *GL) SeparableFilter2D(target, internalFormat glbase.Enum, width, height int, format, gltype glbase.Enum, row, column interface{}) { + var row_ptr unsafe.Pointer + var row_v = reflect.ValueOf(row) + if row != nil && row_v.Kind() != reflect.Slice { + panic("parameter row must be a slice") + } + if row != nil { + row_ptr = unsafe.Pointer(row_v.Index(0).Addr().Pointer()) + } + var column_ptr unsafe.Pointer + var column_v = reflect.ValueOf(column) + if column != nil && column_v.Kind() != reflect.Slice { + panic("parameter column must be a slice") + } + if column != nil { + column_ptr = unsafe.Pointer(column_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glSeparableFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), row_ptr, column_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSeparableFilter.xml +func (gl *GL) GetSeparableFilter(target, format, gltype glbase.Enum, row, column, span interface{}) { + var row_ptr unsafe.Pointer + var row_v = reflect.ValueOf(row) + if row != nil && row_v.Kind() != reflect.Slice { + panic("parameter row must be a slice") + } + if row != nil { + row_ptr = unsafe.Pointer(row_v.Index(0).Addr().Pointer()) + } + var column_ptr unsafe.Pointer + var column_v = reflect.ValueOf(column) + if column != nil && column_v.Kind() != reflect.Slice { + panic("parameter column must be a slice") + } + if column != nil { + column_ptr = unsafe.Pointer(column_v.Index(0).Addr().Pointer()) + } + var span_ptr unsafe.Pointer + var span_v = reflect.ValueOf(span) + if span != nil && span_v.Kind() != reflect.Slice { + panic("parameter span must be a slice") + } + if span != nil { + span_ptr = unsafe.Pointer(span_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glGetSeparableFilter(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), row_ptr, column_ptr, span_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetConvolutionParameteriv.xml +func (gl *GL) GetConvolutionParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_0compat_glGetConvolutionParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetConvolutionParameterfv.xml +func (gl *GL) GetConvolutionParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_0compat_glGetConvolutionParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetConvolutionFilter.xml +func (gl *GL) GetConvolutionFilter(target, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glGetConvolutionFilter(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyConvolutionFilter2D.xml +func (gl *GL) CopyConvolutionFilter2D(target, internalFormat glbase.Enum, x, y, width, height int) { + C.gl4_0compat_glCopyConvolutionFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyConvolutionFilter1D.xml +func (gl *GL) CopyConvolutionFilter1D(target, internalFormat glbase.Enum, x, y, width int) { + C.gl4_0compat_glCopyConvolutionFilter1D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glConvolutionParameteriv.xml +func (gl *GL) ConvolutionParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_0compat_glConvolutionParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glConvolutionParameteri.xml +func (gl *GL) ConvolutionParameteri(target, pname glbase.Enum, params int32) { + C.gl4_0compat_glConvolutionParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(params)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glConvolutionParameterfv.xml +func (gl *GL) ConvolutionParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_0compat_glConvolutionParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glConvolutionParameterf.xml +func (gl *GL) ConvolutionParameterf(target, pname glbase.Enum, params float32) { + C.gl4_0compat_glConvolutionParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(params)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glConvolutionFilter2D.xml +func (gl *GL) ConvolutionFilter2D(target, internalFormat glbase.Enum, width, height int, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glConvolutionFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glConvolutionFilter1D.xml +func (gl *GL) ConvolutionFilter1D(target, internalFormat glbase.Enum, width int, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glConvolutionFilter1D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyColorSubTable.xml +func (gl *GL) CopyColorSubTable(target glbase.Enum, start int32, x, y, width int) { + C.gl4_0compat_glCopyColorSubTable(gl.funcs, C.GLenum(target), C.GLsizei(start), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorSubTable.xml +func (gl *GL) ColorSubTable(target glbase.Enum, start int32, count int, format, gltype glbase.Enum, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glColorSubTable(gl.funcs, C.GLenum(target), C.GLsizei(start), C.GLsizei(count), C.GLenum(format), C.GLenum(gltype), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetColorTableParameteriv.xml +func (gl *GL) GetColorTableParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_0compat_glGetColorTableParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetColorTableParameterfv.xml +func (gl *GL) GetColorTableParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_0compat_glGetColorTableParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetColorTable.xml +func (gl *GL) GetColorTable(target, format, gltype glbase.Enum, table interface{}) { + var table_ptr unsafe.Pointer + var table_v = reflect.ValueOf(table) + if table != nil && table_v.Kind() != reflect.Slice { + panic("parameter table must be a slice") + } + if table != nil { + table_ptr = unsafe.Pointer(table_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glGetColorTable(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), table_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyColorTable.xml +func (gl *GL) CopyColorTable(target, internalFormat glbase.Enum, x, y, width int) { + C.gl4_0compat_glCopyColorTable(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorTableParameteriv.xml +func (gl *GL) ColorTableParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_0compat_glColorTableParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorTableParameterfv.xml +func (gl *GL) ColorTableParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_0compat_glColorTableParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorTable.xml +func (gl *GL) ColorTable(target, internalFormat glbase.Enum, width int, format, gltype glbase.Enum, table interface{}) { + var table_ptr unsafe.Pointer + var table_v = reflect.ValueOf(table) + if table != nil && table_v.Kind() != reflect.Slice { + panic("parameter table must be a slice") + } + if table != nil { + table_ptr = unsafe.Pointer(table_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glColorTable(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), table_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultTransposeMatrixd.xml +func (gl *GL) MultTransposeMatrixd(m []float64) { + C.gl4_0compat_glMultTransposeMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultTransposeMatrixf.xml +func (gl *GL) MultTransposeMatrixf(m []float32) { + C.gl4_0compat_glMultTransposeMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLoadTransposeMatrixd.xml +func (gl *GL) LoadTransposeMatrixd(m []float64) { + C.gl4_0compat_glLoadTransposeMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLoadTransposeMatrixf.xml +func (gl *GL) LoadTransposeMatrixf(m []float32) { + C.gl4_0compat_glLoadTransposeMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord4sv.xml +func (gl *GL) MultiTexCoord4sv(target glbase.Enum, v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glMultiTexCoord4sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord4s.xml +func (gl *GL) MultiTexCoord4s(target glbase.Enum, s, t, r, q int16) { + C.gl4_0compat_glMultiTexCoord4s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t), C.GLshort(r), C.GLshort(q)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord4iv.xml +func (gl *GL) MultiTexCoord4iv(target glbase.Enum, v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glMultiTexCoord4iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord4i.xml +func (gl *GL) MultiTexCoord4i(target glbase.Enum, s, t, r, q int32) { + C.gl4_0compat_glMultiTexCoord4i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t), C.GLint(r), C.GLint(q)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord4fv.xml +func (gl *GL) MultiTexCoord4fv(target glbase.Enum, v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glMultiTexCoord4fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord4f.xml +func (gl *GL) MultiTexCoord4f(target glbase.Enum, s, t, r, q float32) { + C.gl4_0compat_glMultiTexCoord4f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t), C.GLfloat(r), C.GLfloat(q)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord4dv.xml +func (gl *GL) MultiTexCoord4dv(target glbase.Enum, v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glMultiTexCoord4dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord4d.xml +func (gl *GL) MultiTexCoord4d(target glbase.Enum, s, t, r, q float64) { + C.gl4_0compat_glMultiTexCoord4d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t), C.GLdouble(r), C.GLdouble(q)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord3sv.xml +func (gl *GL) MultiTexCoord3sv(target glbase.Enum, v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glMultiTexCoord3sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord3s.xml +func (gl *GL) MultiTexCoord3s(target glbase.Enum, s, t, r int16) { + C.gl4_0compat_glMultiTexCoord3s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t), C.GLshort(r)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord3iv.xml +func (gl *GL) MultiTexCoord3iv(target glbase.Enum, v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glMultiTexCoord3iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord3i.xml +func (gl *GL) MultiTexCoord3i(target glbase.Enum, s, t, r int32) { + C.gl4_0compat_glMultiTexCoord3i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t), C.GLint(r)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord3fv.xml +func (gl *GL) MultiTexCoord3fv(target glbase.Enum, v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glMultiTexCoord3fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord3f.xml +func (gl *GL) MultiTexCoord3f(target glbase.Enum, s, t, r float32) { + C.gl4_0compat_glMultiTexCoord3f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t), C.GLfloat(r)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord3dv.xml +func (gl *GL) MultiTexCoord3dv(target glbase.Enum, v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glMultiTexCoord3dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord3d.xml +func (gl *GL) MultiTexCoord3d(target glbase.Enum, s, t, r float64) { + C.gl4_0compat_glMultiTexCoord3d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t), C.GLdouble(r)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord2sv.xml +func (gl *GL) MultiTexCoord2sv(target glbase.Enum, v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glMultiTexCoord2sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord2s.xml +func (gl *GL) MultiTexCoord2s(target glbase.Enum, s, t int16) { + C.gl4_0compat_glMultiTexCoord2s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord2iv.xml +func (gl *GL) MultiTexCoord2iv(target glbase.Enum, v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glMultiTexCoord2iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord2i.xml +func (gl *GL) MultiTexCoord2i(target glbase.Enum, s, t int32) { + C.gl4_0compat_glMultiTexCoord2i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord2fv.xml +func (gl *GL) MultiTexCoord2fv(target glbase.Enum, v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glMultiTexCoord2fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord2f.xml +func (gl *GL) MultiTexCoord2f(target glbase.Enum, s, t float32) { + C.gl4_0compat_glMultiTexCoord2f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord2dv.xml +func (gl *GL) MultiTexCoord2dv(target glbase.Enum, v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glMultiTexCoord2dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord2d.xml +func (gl *GL) MultiTexCoord2d(target glbase.Enum, s, t float64) { + C.gl4_0compat_glMultiTexCoord2d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord1sv.xml +func (gl *GL) MultiTexCoord1sv(target glbase.Enum, v []int16) { + C.gl4_0compat_glMultiTexCoord1sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord1s.xml +func (gl *GL) MultiTexCoord1s(target glbase.Enum, s int16) { + C.gl4_0compat_glMultiTexCoord1s(gl.funcs, C.GLenum(target), C.GLshort(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord1iv.xml +func (gl *GL) MultiTexCoord1iv(target glbase.Enum, v []int32) { + C.gl4_0compat_glMultiTexCoord1iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord1i.xml +func (gl *GL) MultiTexCoord1i(target glbase.Enum, s int32) { + C.gl4_0compat_glMultiTexCoord1i(gl.funcs, C.GLenum(target), C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord1fv.xml +func (gl *GL) MultiTexCoord1fv(target glbase.Enum, v []float32) { + C.gl4_0compat_glMultiTexCoord1fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord1f.xml +func (gl *GL) MultiTexCoord1f(target glbase.Enum, s float32) { + C.gl4_0compat_glMultiTexCoord1f(gl.funcs, C.GLenum(target), C.GLfloat(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord1dv.xml +func (gl *GL) MultiTexCoord1dv(target glbase.Enum, v []float64) { + C.gl4_0compat_glMultiTexCoord1dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord1d.xml +func (gl *GL) MultiTexCoord1d(target glbase.Enum, s float64) { + C.gl4_0compat_glMultiTexCoord1d(gl.funcs, C.GLenum(target), C.GLdouble(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClientActiveTexture.xml +func (gl *GL) ClientActiveTexture(texture glbase.Enum) { + C.gl4_0compat_glClientActiveTexture(gl.funcs, C.GLenum(texture)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos3sv.xml +func (gl *GL) WindowPos3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glWindowPos3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos3s.xml +func (gl *GL) WindowPos3s(x, y, z int16) { + C.gl4_0compat_glWindowPos3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos3iv.xml +func (gl *GL) WindowPos3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glWindowPos3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos3i.xml +func (gl *GL) WindowPos3i(x, y, z int) { + C.gl4_0compat_glWindowPos3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos3fv.xml +func (gl *GL) WindowPos3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glWindowPos3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos3f.xml +func (gl *GL) WindowPos3f(x, y, z float32) { + C.gl4_0compat_glWindowPos3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos3dv.xml +func (gl *GL) WindowPos3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glWindowPos3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos3d.xml +func (gl *GL) WindowPos3d(x, y, z float64) { + C.gl4_0compat_glWindowPos3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos2sv.xml +func (gl *GL) WindowPos2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glWindowPos2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos2s.xml +func (gl *GL) WindowPos2s(x, y int16) { + C.gl4_0compat_glWindowPos2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos2iv.xml +func (gl *GL) WindowPos2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glWindowPos2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos2i.xml +func (gl *GL) WindowPos2i(x, y int) { + C.gl4_0compat_glWindowPos2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos2fv.xml +func (gl *GL) WindowPos2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glWindowPos2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos2f.xml +func (gl *GL) WindowPos2f(x, y float32) { + C.gl4_0compat_glWindowPos2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos2dv.xml +func (gl *GL) WindowPos2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glWindowPos2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos2d.xml +func (gl *GL) WindowPos2d(x, y float64) { + C.gl4_0compat_glWindowPos2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColorPointer.xml +func (gl *GL) SecondaryColorPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glSecondaryColorPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3usv.xml +func (gl *GL) SecondaryColor3usv(v []uint16) { + C.gl4_0compat_glSecondaryColor3usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3us.xml +func (gl *GL) SecondaryColor3us(red, green, blue uint16) { + C.gl4_0compat_glSecondaryColor3us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3uiv.xml +func (gl *GL) SecondaryColor3uiv(v []uint32) { + C.gl4_0compat_glSecondaryColor3uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3ui.xml +func (gl *GL) SecondaryColor3ui(red, green, blue uint32) { + C.gl4_0compat_glSecondaryColor3ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3ubv.xml +func (gl *GL) SecondaryColor3ubv(v []uint8) { + C.gl4_0compat_glSecondaryColor3ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3ub.xml +func (gl *GL) SecondaryColor3ub(red, green, blue uint8) { + C.gl4_0compat_glSecondaryColor3ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3sv.xml +func (gl *GL) SecondaryColor3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glSecondaryColor3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3s.xml +func (gl *GL) SecondaryColor3s(red, green, blue int16) { + C.gl4_0compat_glSecondaryColor3s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3iv.xml +func (gl *GL) SecondaryColor3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glSecondaryColor3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3i.xml +func (gl *GL) SecondaryColor3i(red, green, blue int32) { + C.gl4_0compat_glSecondaryColor3i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3fv.xml +func (gl *GL) SecondaryColor3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glSecondaryColor3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3f.xml +func (gl *GL) SecondaryColor3f(red, green, blue float32) { + C.gl4_0compat_glSecondaryColor3f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3dv.xml +func (gl *GL) SecondaryColor3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glSecondaryColor3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3d.xml +func (gl *GL) SecondaryColor3d(red, green, blue float64) { + C.gl4_0compat_glSecondaryColor3d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3bv.xml +func (gl *GL) SecondaryColor3bv(v []byte) { + C.gl4_0compat_glSecondaryColor3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3b.xml +func (gl *GL) SecondaryColor3b(red, green, blue byte) { + C.gl4_0compat_glSecondaryColor3b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogCoordPointer.xml +func (gl *GL) FogCoordPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_0compat_glFogCoordPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogCoorddv.xml +func (gl *GL) FogCoorddv(coord []float64) { + C.gl4_0compat_glFogCoorddv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&coord[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogCoordd.xml +func (gl *GL) FogCoordd(coord float64) { + C.gl4_0compat_glFogCoordd(gl.funcs, C.GLdouble(coord)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogCoordfv.xml +func (gl *GL) FogCoordfv(coord []float32) { + C.gl4_0compat_glFogCoordfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&coord[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogCoordf.xml +func (gl *GL) FogCoordf(coord float32) { + C.gl4_0compat_glFogCoordf(gl.funcs, C.GLfloat(coord)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4usv.xml +func (gl *GL) VertexAttrib4usv(index glbase.Attrib, v []uint16) { + C.gl4_0compat_glVertexAttrib4usv(gl.funcs, C.GLuint(index), (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4uiv.xml +func (gl *GL) VertexAttrib4uiv(index glbase.Attrib, v []uint32) { + C.gl4_0compat_glVertexAttrib4uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4ubv.xml +func (gl *GL) VertexAttrib4ubv(index glbase.Attrib, v []uint8) { + C.gl4_0compat_glVertexAttrib4ubv(gl.funcs, C.GLuint(index), (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4sv.xml +func (gl *GL) VertexAttrib4sv(index glbase.Attrib, v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glVertexAttrib4sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4s.xml +func (gl *GL) VertexAttrib4s(index glbase.Attrib, x, y, z, w int16) { + C.gl4_0compat_glVertexAttrib4s(gl.funcs, C.GLuint(index), C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4iv.xml +func (gl *GL) VertexAttrib4iv(index glbase.Attrib, v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glVertexAttrib4iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4fv.xml +func (gl *GL) VertexAttrib4fv(index glbase.Attrib, v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glVertexAttrib4fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4f.xml +func (gl *GL) VertexAttrib4f(index glbase.Attrib, x, y, z, w float32) { + C.gl4_0compat_glVertexAttrib4f(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4dv.xml +func (gl *GL) VertexAttrib4dv(index glbase.Attrib, v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glVertexAttrib4dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4d.xml +func (gl *GL) VertexAttrib4d(index glbase.Attrib, x, y, z, w float64) { + C.gl4_0compat_glVertexAttrib4d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4bv.xml +func (gl *GL) VertexAttrib4bv(index glbase.Attrib, v []byte) { + C.gl4_0compat_glVertexAttrib4bv(gl.funcs, C.GLuint(index), (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4Nusv.xml +func (gl *GL) VertexAttrib4Nusv(index glbase.Attrib, v []uint16) { + C.gl4_0compat_glVertexAttrib4Nusv(gl.funcs, C.GLuint(index), (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4Nuiv.xml +func (gl *GL) VertexAttrib4Nuiv(index glbase.Attrib, v []uint32) { + C.gl4_0compat_glVertexAttrib4Nuiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4Nubv.xml +func (gl *GL) VertexAttrib4Nubv(index glbase.Attrib, v []uint8) { + C.gl4_0compat_glVertexAttrib4Nubv(gl.funcs, C.GLuint(index), (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4Nub.xml +func (gl *GL) VertexAttrib4Nub(index glbase.Attrib, x, y, z, w uint8) { + C.gl4_0compat_glVertexAttrib4Nub(gl.funcs, C.GLuint(index), C.GLubyte(x), C.GLubyte(y), C.GLubyte(z), C.GLubyte(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4Nsv.xml +func (gl *GL) VertexAttrib4Nsv(index glbase.Attrib, v []int16) { + C.gl4_0compat_glVertexAttrib4Nsv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4Niv.xml +func (gl *GL) VertexAttrib4Niv(index glbase.Attrib, v []int32) { + C.gl4_0compat_glVertexAttrib4Niv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4Nbv.xml +func (gl *GL) VertexAttrib4Nbv(index glbase.Attrib, v []byte) { + C.gl4_0compat_glVertexAttrib4Nbv(gl.funcs, C.GLuint(index), (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib3sv.xml +func (gl *GL) VertexAttrib3sv(index glbase.Attrib, v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glVertexAttrib3sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib3s.xml +func (gl *GL) VertexAttrib3s(index glbase.Attrib, x, y, z int16) { + C.gl4_0compat_glVertexAttrib3s(gl.funcs, C.GLuint(index), C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib3fv.xml +func (gl *GL) VertexAttrib3fv(index glbase.Attrib, v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glVertexAttrib3fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib3f.xml +func (gl *GL) VertexAttrib3f(index glbase.Attrib, x, y, z float32) { + C.gl4_0compat_glVertexAttrib3f(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib3dv.xml +func (gl *GL) VertexAttrib3dv(index glbase.Attrib, v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glVertexAttrib3dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib3d.xml +func (gl *GL) VertexAttrib3d(index glbase.Attrib, x, y, z float64) { + C.gl4_0compat_glVertexAttrib3d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib2sv.xml +func (gl *GL) VertexAttrib2sv(index glbase.Attrib, v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glVertexAttrib2sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib2s.xml +func (gl *GL) VertexAttrib2s(index glbase.Attrib, x, y int16) { + C.gl4_0compat_glVertexAttrib2s(gl.funcs, C.GLuint(index), C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib2fv.xml +func (gl *GL) VertexAttrib2fv(index glbase.Attrib, v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glVertexAttrib2fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib2f.xml +func (gl *GL) VertexAttrib2f(index glbase.Attrib, x, y float32) { + C.gl4_0compat_glVertexAttrib2f(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib2dv.xml +func (gl *GL) VertexAttrib2dv(index glbase.Attrib, v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glVertexAttrib2dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib2d.xml +func (gl *GL) VertexAttrib2d(index glbase.Attrib, x, y float64) { + C.gl4_0compat_glVertexAttrib2d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib1sv.xml +func (gl *GL) VertexAttrib1sv(index glbase.Attrib, v []int16) { + C.gl4_0compat_glVertexAttrib1sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib1s.xml +func (gl *GL) VertexAttrib1s(index glbase.Attrib, x int16) { + C.gl4_0compat_glVertexAttrib1s(gl.funcs, C.GLuint(index), C.GLshort(x)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib1fv.xml +func (gl *GL) VertexAttrib1fv(index glbase.Attrib, v []float32) { + C.gl4_0compat_glVertexAttrib1fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib1f.xml +func (gl *GL) VertexAttrib1f(index glbase.Attrib, x float32) { + C.gl4_0compat_glVertexAttrib1f(gl.funcs, C.GLuint(index), C.GLfloat(x)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib1dv.xml +func (gl *GL) VertexAttrib1dv(index glbase.Attrib, v []float64) { + C.gl4_0compat_glVertexAttrib1dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib1d.xml +func (gl *GL) VertexAttrib1d(index glbase.Attrib, x float64) { + C.gl4_0compat_glVertexAttrib1d(gl.funcs, C.GLuint(index), C.GLdouble(x)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI4usv.xml +func (gl *GL) VertexAttribI4usv(index glbase.Attrib, v []uint16) { + C.gl4_0compat_glVertexAttribI4usv(gl.funcs, C.GLuint(index), (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI4ubv.xml +func (gl *GL) VertexAttribI4ubv(index glbase.Attrib, v []uint8) { + C.gl4_0compat_glVertexAttribI4ubv(gl.funcs, C.GLuint(index), (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI4sv.xml +func (gl *GL) VertexAttribI4sv(index glbase.Attrib, v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glVertexAttribI4sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI4bv.xml +func (gl *GL) VertexAttribI4bv(index glbase.Attrib, v []byte) { + C.gl4_0compat_glVertexAttribI4bv(gl.funcs, C.GLuint(index), (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI4uiv.xml +func (gl *GL) VertexAttribI4uiv(index glbase.Attrib, v []uint32) { + C.gl4_0compat_glVertexAttribI4uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI3uiv.xml +func (gl *GL) VertexAttribI3uiv(index glbase.Attrib, v []uint32) { + C.gl4_0compat_glVertexAttribI3uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI2uiv.xml +func (gl *GL) VertexAttribI2uiv(index glbase.Attrib, v []uint32) { + C.gl4_0compat_glVertexAttribI2uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI1uiv.xml +func (gl *GL) VertexAttribI1uiv(index glbase.Attrib, v []uint32) { + C.gl4_0compat_glVertexAttribI1uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI4iv.xml +func (gl *GL) VertexAttribI4iv(index glbase.Attrib, v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glVertexAttribI4iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI3iv.xml +func (gl *GL) VertexAttribI3iv(index glbase.Attrib, v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glVertexAttribI3iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI2iv.xml +func (gl *GL) VertexAttribI2iv(index glbase.Attrib, v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_0compat_glVertexAttribI2iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI1iv.xml +func (gl *GL) VertexAttribI1iv(index glbase.Attrib, v []int32) { + C.gl4_0compat_glVertexAttribI1iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI4ui.xml +func (gl *GL) VertexAttribI4ui(index glbase.Attrib, x, y, z, w uint32) { + C.gl4_0compat_glVertexAttribI4ui(gl.funcs, C.GLuint(index), C.GLuint(x), C.GLuint(y), C.GLuint(z), C.GLuint(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI3ui.xml +func (gl *GL) VertexAttribI3ui(index glbase.Attrib, x, y, z uint32) { + C.gl4_0compat_glVertexAttribI3ui(gl.funcs, C.GLuint(index), C.GLuint(x), C.GLuint(y), C.GLuint(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI2ui.xml +func (gl *GL) VertexAttribI2ui(index glbase.Attrib, x, y uint32) { + C.gl4_0compat_glVertexAttribI2ui(gl.funcs, C.GLuint(index), C.GLuint(x), C.GLuint(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI1ui.xml +func (gl *GL) VertexAttribI1ui(index glbase.Attrib, x uint32) { + C.gl4_0compat_glVertexAttribI1ui(gl.funcs, C.GLuint(index), C.GLuint(x)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI4i.xml +func (gl *GL) VertexAttribI4i(index glbase.Attrib, x, y, z, w int) { + C.gl4_0compat_glVertexAttribI4i(gl.funcs, C.GLuint(index), C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI3i.xml +func (gl *GL) VertexAttribI3i(index glbase.Attrib, x, y, z int) { + C.gl4_0compat_glVertexAttribI3i(gl.funcs, C.GLuint(index), C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI2i.xml +func (gl *GL) VertexAttribI2i(index glbase.Attrib, x, y int) { + C.gl4_0compat_glVertexAttribI2i(gl.funcs, C.GLuint(index), C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI1i.xml +func (gl *GL) VertexAttribI1i(index glbase.Attrib, x int) { + C.gl4_0compat_glVertexAttribI1i(gl.funcs, C.GLuint(index), C.GLint(x)) +} diff --git a/gl/4.0core/funcs.cpp b/gl/4.0core/funcs.cpp new file mode 100644 index 00000000..1be157d6 --- /dev/null +++ b/gl/4.0core/funcs.cpp @@ -0,0 +1,2154 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#include +#include + +#include "funcs.h" + +void *gl4_0core_funcs() { + QOpenGLFunctions_4_0_Core* funcs = QOpenGLContext::currentContext()->versionFunctions(); + if (!funcs) { + return 0; + } + funcs->initializeOpenGLFunctions(); + return funcs; +} + + +void gl4_0core_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewport(x, y, width, height); +} + +void gl4_0core_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRange(nearVal, farVal); +} + +GLboolean gl4_0core_glIsEnabled(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabled(cap); +} + +void gl4_0core_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameteriv(target, level, pname, params); +} + +void gl4_0core_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameterfv(target, level, pname, params); +} + +void gl4_0core_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameteriv(target, pname, params); +} + +void gl4_0core_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterfv(target, pname, params); +} + +void gl4_0core_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexImage(target, level, format, gltype, pixels); +} + +void gl4_0core_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegerv(pname, params); +} + +void gl4_0core_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFloatv(pname, params); +} + +GLenum gl4_0core_glGetError(void *_glfuncs) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetError(); +} + +void gl4_0core_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetDoublev(pname, params); +} + +void gl4_0core_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleanv(pname, params); +} + +void gl4_0core_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadPixels(x, y, width, height, format, gltype, pixels); +} + +void gl4_0core_glReadBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadBuffer(mode); +} + +void gl4_0core_glPixelStorei(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStorei(pname, param); +} + +void gl4_0core_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStoref(pname, param); +} + +void gl4_0core_glDepthFunc(void *_glfuncs, GLenum glfunc) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthFunc(glfunc); +} + +void gl4_0core_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOp(fail, zfail, zpass); +} + +void gl4_0core_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFunc(glfunc, ref, mask); +} + +void gl4_0core_glLogicOp(void *_glfuncs, GLenum opcode) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLogicOp(opcode); +} + +void gl4_0core_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFunc(sfactor, dfactor); +} + +void gl4_0core_glFlush(void *_glfuncs) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlush(); +} + +void gl4_0core_glFinish(void *_glfuncs) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFinish(); +} + +void gl4_0core_glEnable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnable(cap); +} + +void gl4_0core_glDisable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisable(cap); +} + +void gl4_0core_glDepthMask(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthMask(flag); +} + +void gl4_0core_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMask(red, green, blue, alpha); +} + +void gl4_0core_glStencilMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMask(mask); +} + +void gl4_0core_glClearDepth(void *_glfuncs, GLdouble depth) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearDepth(depth); +} + +void gl4_0core_glClearStencil(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearStencil(s); +} + +void gl4_0core_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearColor(red, green, blue, alpha); +} + +void gl4_0core_glClear(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClear(mask); +} + +void gl4_0core_glDrawBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffer(mode); +} + +void gl4_0core_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage2D(target, level, internalFormat, width, height, border, format, gltype, pixels); +} + +void gl4_0core_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage1D(target, level, internalFormat, width, border, format, gltype, pixels); +} + +void gl4_0core_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteriv(target, pname, params); +} + +void gl4_0core_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteri(target, pname, param); +} + +void gl4_0core_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterfv(target, pname, params); +} + +void gl4_0core_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterf(target, pname, param); +} + +void gl4_0core_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissor(x, y, width, height); +} + +void gl4_0core_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonMode(face, mode); +} + +void gl4_0core_glPointSize(void *_glfuncs, GLfloat size) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointSize(size); +} + +void gl4_0core_glLineWidth(void *_glfuncs, GLfloat width) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineWidth(width); +} + +void gl4_0core_glHint(void *_glfuncs, GLenum target, GLenum mode) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glHint(target, mode); +} + +void gl4_0core_glFrontFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrontFace(mode); +} + +void gl4_0core_glCullFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCullFace(mode); +} + +void gl4_0core_glIndexubv(void *_glfuncs, const GLubyte* c) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexubv(c); +} + +void gl4_0core_glIndexub(void *_glfuncs, GLubyte c) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexub(c); +} + +GLboolean gl4_0core_glIsTexture(void *_glfuncs, GLuint texture) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsTexture(texture); +} + +void gl4_0core_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenTextures(n, textures); +} + +void gl4_0core_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteTextures(n, textures); +} + +void gl4_0core_glBindTexture(void *_glfuncs, GLenum target, GLuint texture) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindTexture(target, texture); +} + +void gl4_0core_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, gltype, pixels); +} + +void gl4_0core_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage1D(target, level, xoffset, width, format, gltype, pixels); +} + +void gl4_0core_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); +} + +void gl4_0core_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage1D(target, level, xoffset, x, y, width); +} + +void gl4_0core_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage2D(target, level, internalFormat, x, y, width, height, border); +} + +void gl4_0core_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage1D(target, level, internalFormat, x, y, width, border); +} + +void gl4_0core_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonOffset(factor, units); +} + +void gl4_0core_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElements(mode, count, gltype, indices); +} + +void gl4_0core_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArrays(mode, first, count); +} + +void gl4_0core_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); +} + +void gl4_0core_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, gltype, pixels); +} + +void gl4_0core_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage3D(target, level, internalFormat, width, height, depth, border, format, gltype, pixels); +} + +void gl4_0core_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawRangeElements(mode, start, end, count, gltype, indices); +} + +void gl4_0core_glBlendEquation(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquation(mode); +} + +void gl4_0core_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendColor(red, green, blue, alpha); +} + +void gl4_0core_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetCompressedTexImage(target, level, img); +} + +void gl4_0core_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data); +} + +void gl4_0core_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); +} + +void gl4_0core_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); +} + +void gl4_0core_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage1D(target, level, internalFormat, width, border, imageSize, data); +} + +void gl4_0core_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data); +} + +void gl4_0core_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage3D(target, level, internalFormat, width, height, depth, border, imageSize, data); +} + +void gl4_0core_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSampleCoverage(value, invert); +} + +void gl4_0core_glActiveTexture(void *_glfuncs, GLenum texture) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glActiveTexture(texture); +} + +void gl4_0core_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteriv(pname, params); +} + +void gl4_0core_glPointParameteri(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteri(pname, param); +} + +void gl4_0core_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterfv(pname, params); +} + +void gl4_0core_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterf(pname, param); +} + +void gl4_0core_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiDrawArrays(mode, first, count, drawcount); +} + +void gl4_0core_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); +} + +void gl4_0core_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferParameteriv(target, pname, params); +} + +GLboolean gl4_0core_glUnmapBuffer(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glUnmapBuffer(target); +} + +void gl4_0core_glGetBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferSubData(target, offset, size, data); +} + +void gl4_0core_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferSubData(target, offset, size, data); +} + +void gl4_0core_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferData(target, size, data, usage); +} + +GLboolean gl4_0core_glIsBuffer(void *_glfuncs, GLuint buffer) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsBuffer(buffer); +} + +void gl4_0core_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenBuffers(n, buffers); +} + +void gl4_0core_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteBuffers(n, buffers); +} + +void gl4_0core_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBuffer(target, buffer); +} + +void gl4_0core_glGetQueryObjectuiv(void *_glfuncs, GLuint id, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectuiv(id, pname, params); +} + +void gl4_0core_glGetQueryObjectiv(void *_glfuncs, GLuint id, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectiv(id, pname, params); +} + +void gl4_0core_glGetQueryiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryiv(target, pname, params); +} + +void gl4_0core_glEndQuery(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndQuery(target); +} + +void gl4_0core_glBeginQuery(void *_glfuncs, GLenum target, GLuint id) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginQuery(target, id); +} + +GLboolean gl4_0core_glIsQuery(void *_glfuncs, GLuint id) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsQuery(id); +} + +void gl4_0core_glDeleteQueries(void *_glfuncs, GLsizei n, const GLuint* ids) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteQueries(n, ids); +} + +void gl4_0core_glGenQueries(void *_glfuncs, GLsizei n, GLuint* ids) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenQueries(n, ids); +} + +void gl4_0core_glVertexAttribPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLboolean normalized, GLsizei stride, const GLvoid* offset) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribPointer(index, size, gltype, normalized, stride, offset); +} + +void gl4_0core_glValidateProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glValidateProgram(program); +} + +void gl4_0core_glUniformMatrix4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4fv(location, count, transpose, value); +} + +void gl4_0core_glUniformMatrix3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3fv(location, count, transpose, value); +} + +void gl4_0core_glUniformMatrix2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2fv(location, count, transpose, value); +} + +void gl4_0core_glUniform4iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4iv(location, count, value); +} + +void gl4_0core_glUniform3iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3iv(location, count, value); +} + +void gl4_0core_glUniform2iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2iv(location, count, value); +} + +void gl4_0core_glUniform1iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1iv(location, count, value); +} + +void gl4_0core_glUniform4fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4fv(location, count, value); +} + +void gl4_0core_glUniform3fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3fv(location, count, value); +} + +void gl4_0core_glUniform2fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2fv(location, count, value); +} + +void gl4_0core_glUniform1fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1fv(location, count, value); +} + +void gl4_0core_glUniform4i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4i(location, v0, v1, v2, v3); +} + +void gl4_0core_glUniform3i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3i(location, v0, v1, v2); +} + +void gl4_0core_glUniform2i(void *_glfuncs, GLint location, GLint v0, GLint v1) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2i(location, v0, v1); +} + +void gl4_0core_glUniform1i(void *_glfuncs, GLint location, GLint v0) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1i(location, v0); +} + +void gl4_0core_glUniform4f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4f(location, v0, v1, v2, v3); +} + +void gl4_0core_glUniform3f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3f(location, v0, v1, v2); +} + +void gl4_0core_glUniform2f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2f(location, v0, v1); +} + +void gl4_0core_glUniform1f(void *_glfuncs, GLint location, GLfloat v0) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1f(location, v0); +} + +void gl4_0core_glUseProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUseProgram(program); +} + +void gl4_0core_glShaderSource(void *_glfuncs, GLuint shader, GLsizei count, const GLchar** source, const GLint* length) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShaderSource(shader, count, source, length); +} + +void gl4_0core_glLinkProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLinkProgram(program); +} + +GLboolean gl4_0core_glIsShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsShader(shader); +} + +GLboolean gl4_0core_glIsProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsProgram(program); +} + +void gl4_0core_glGetVertexAttribiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribiv(index, pname, params); +} + +void gl4_0core_glGetVertexAttribfv(void *_glfuncs, GLuint index, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribfv(index, pname, params); +} + +void gl4_0core_glGetVertexAttribdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribdv(index, pname, params); +} + +void gl4_0core_glGetUniformiv(void *_glfuncs, GLuint program, GLint location, GLint* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformiv(program, location, params); +} + +void gl4_0core_glGetUniformfv(void *_glfuncs, GLuint program, GLint location, GLfloat* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformfv(program, location, params); +} + +GLint gl4_0core_glGetUniformLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetUniformLocation(program, name); +} + +void gl4_0core_glGetShaderSource(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderSource(shader, bufSize, length, source); +} + +void gl4_0core_glGetShaderInfoLog(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderInfoLog(shader, bufSize, length, infoLog); +} + +void gl4_0core_glGetShaderiv(void *_glfuncs, GLuint shader, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderiv(shader, pname, params); +} + +void gl4_0core_glGetProgramInfoLog(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramInfoLog(program, bufSize, length, infoLog); +} + +void gl4_0core_glGetProgramiv(void *_glfuncs, GLuint program, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramiv(program, pname, params); +} + +GLint gl4_0core_glGetAttribLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetAttribLocation(program, name); +} + +void gl4_0core_glGetAttachedShaders(void *_glfuncs, GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetAttachedShaders(program, maxCount, count, obj); +} + +void gl4_0core_glGetActiveUniform(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniform(program, index, bufSize, length, size, gltype, name); +} + +void gl4_0core_glGetActiveAttrib(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveAttrib(program, index, bufSize, length, size, gltype, name); +} + +void gl4_0core_glEnableVertexAttribArray(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnableVertexAttribArray(index); +} + +void gl4_0core_glDisableVertexAttribArray(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisableVertexAttribArray(index); +} + +void gl4_0core_glDetachShader(void *_glfuncs, GLuint program, GLuint shader) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDetachShader(program, shader); +} + +void gl4_0core_glDeleteShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteShader(shader); +} + +void gl4_0core_glDeleteProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteProgram(program); +} + +GLuint gl4_0core_glCreateShader(void *_glfuncs, GLenum gltype) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCreateShader(gltype); +} + +GLuint gl4_0core_glCreateProgram(void *_glfuncs) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCreateProgram(); +} + +void gl4_0core_glCompileShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompileShader(shader); +} + +void gl4_0core_glBindAttribLocation(void *_glfuncs, GLuint program, GLuint index, const GLchar* name) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindAttribLocation(program, index, name); +} + +void gl4_0core_glAttachShader(void *_glfuncs, GLuint program, GLuint shader) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAttachShader(program, shader); +} + +void gl4_0core_glStencilMaskSeparate(void *_glfuncs, GLenum face, GLuint mask) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMaskSeparate(face, mask); +} + +void gl4_0core_glStencilFuncSeparate(void *_glfuncs, GLenum face, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFuncSeparate(face, glfunc, ref, mask); +} + +void gl4_0core_glStencilOpSeparate(void *_glfuncs, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOpSeparate(face, sfail, dpfail, dppass); +} + +void gl4_0core_glDrawBuffers(void *_glfuncs, GLsizei n, const GLenum* bufs) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffers(n, bufs); +} + +void gl4_0core_glBlendEquationSeparate(void *_glfuncs, GLenum modeRGB, GLenum modeAlpha) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquationSeparate(modeRGB, modeAlpha); +} + +void gl4_0core_glUniformMatrix4x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x3fv(location, count, transpose, value); +} + +void gl4_0core_glUniformMatrix3x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x4fv(location, count, transpose, value); +} + +void gl4_0core_glUniformMatrix4x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x2fv(location, count, transpose, value); +} + +void gl4_0core_glUniformMatrix2x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x4fv(location, count, transpose, value); +} + +void gl4_0core_glUniformMatrix3x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x2fv(location, count, transpose, value); +} + +void gl4_0core_glUniformMatrix2x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x3fv(location, count, transpose, value); +} + +GLboolean gl4_0core_glIsVertexArray(void *_glfuncs, GLuint array) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsVertexArray(array); +} + +void gl4_0core_glGenVertexArrays(void *_glfuncs, GLsizei n, GLuint* arrays) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenVertexArrays(n, arrays); +} + +void gl4_0core_glDeleteVertexArrays(void *_glfuncs, GLsizei n, const GLuint* arrays) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteVertexArrays(n, arrays); +} + +void gl4_0core_glBindVertexArray(void *_glfuncs, GLuint array) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindVertexArray(array); +} + +void gl4_0core_glFlushMappedBufferRange(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr length) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlushMappedBufferRange(target, offset, length); +} + +void gl4_0core_glFramebufferTextureLayer(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTextureLayer(target, attachment, texture, level, layer); +} + +void gl4_0core_glRenderbufferStorageMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRenderbufferStorageMultisample(target, samples, internalFormat, width, height); +} + +void gl4_0core_glBlitFramebuffer(void *_glfuncs, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); +} + +void gl4_0core_glGenerateMipmap(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenerateMipmap(target); +} + +void gl4_0core_glGetFramebufferAttachmentParameteriv(void *_glfuncs, GLenum target, GLenum attachment, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFramebufferAttachmentParameteriv(target, attachment, pname, params); +} + +void gl4_0core_glFramebufferRenderbuffer(void *_glfuncs, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer); +} + +void gl4_0core_glFramebufferTexture3D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset); +} + +void gl4_0core_glFramebufferTexture2D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture2D(target, attachment, textarget, texture, level); +} + +void gl4_0core_glFramebufferTexture1D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture1D(target, attachment, textarget, texture, level); +} + +GLenum gl4_0core_glCheckFramebufferStatus(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCheckFramebufferStatus(target); +} + +void gl4_0core_glGenFramebuffers(void *_glfuncs, GLsizei n, GLuint* framebuffers) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenFramebuffers(n, framebuffers); +} + +void gl4_0core_glDeleteFramebuffers(void *_glfuncs, GLsizei n, const GLuint* framebuffers) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteFramebuffers(n, framebuffers); +} + +void gl4_0core_glBindFramebuffer(void *_glfuncs, GLenum target, GLuint framebuffer) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFramebuffer(target, framebuffer); +} + +GLboolean gl4_0core_glIsFramebuffer(void *_glfuncs, GLuint framebuffer) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsFramebuffer(framebuffer); +} + +void gl4_0core_glGetRenderbufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetRenderbufferParameteriv(target, pname, params); +} + +void gl4_0core_glRenderbufferStorage(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRenderbufferStorage(target, internalFormat, width, height); +} + +void gl4_0core_glGenRenderbuffers(void *_glfuncs, GLsizei n, GLuint* renderbuffers) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenRenderbuffers(n, renderbuffers); +} + +void gl4_0core_glDeleteRenderbuffers(void *_glfuncs, GLsizei n, const GLuint* renderbuffers) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteRenderbuffers(n, renderbuffers); +} + +void gl4_0core_glBindRenderbuffer(void *_glfuncs, GLenum target, GLuint renderbuffer) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindRenderbuffer(target, renderbuffer); +} + +GLboolean gl4_0core_glIsRenderbuffer(void *_glfuncs, GLuint renderbuffer) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsRenderbuffer(renderbuffer); +} + +void gl4_0core_glClearBufferfi(void *_glfuncs, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferfi(buffer, drawbuffer, depth, stencil); +} + +void gl4_0core_glClearBufferfv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLfloat* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferfv(buffer, drawbuffer, value); +} + +void gl4_0core_glClearBufferuiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLuint* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferuiv(buffer, drawbuffer, value); +} + +void gl4_0core_glClearBufferiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLint* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferiv(buffer, drawbuffer, value); +} + +void gl4_0core_glGetTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterIuiv(target, pname, params); +} + +void gl4_0core_glGetTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterIiv(target, pname, params); +} + +void gl4_0core_glTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, const GLuint* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterIuiv(target, pname, params); +} + +void gl4_0core_glTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterIiv(target, pname, params); +} + +void gl4_0core_glUniform4uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4uiv(location, count, value); +} + +void gl4_0core_glUniform3uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3uiv(location, count, value); +} + +void gl4_0core_glUniform2uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2uiv(location, count, value); +} + +void gl4_0core_glUniform1uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1uiv(location, count, value); +} + +void gl4_0core_glUniform4ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4ui(location, v0, v1, v2, v3); +} + +void gl4_0core_glUniform3ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3ui(location, v0, v1, v2); +} + +void gl4_0core_glUniform2ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2ui(location, v0, v1); +} + +void gl4_0core_glUniform1ui(void *_glfuncs, GLint location, GLuint v0) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1ui(location, v0); +} + +GLint gl4_0core_glGetFragDataLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetFragDataLocation(program, name); +} + +void gl4_0core_glBindFragDataLocation(void *_glfuncs, GLuint program, GLuint color, const GLchar* name) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFragDataLocation(program, color, name); +} + +void gl4_0core_glGetUniformuiv(void *_glfuncs, GLuint program, GLint location, GLuint* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformuiv(program, location, params); +} + +void gl4_0core_glGetVertexAttribIuiv(void *_glfuncs, GLuint index, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribIuiv(index, pname, params); +} + +void gl4_0core_glGetVertexAttribIiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribIiv(index, pname, params); +} + +void gl4_0core_glVertexAttribIPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribIPointer(index, size, gltype, stride, pointer); +} + +void gl4_0core_glEndConditionalRender(void *_glfuncs) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndConditionalRender(); +} + +void gl4_0core_glBeginConditionalRender(void *_glfuncs, GLuint id, GLenum mode) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginConditionalRender(id, mode); +} + +void gl4_0core_glClampColor(void *_glfuncs, GLenum target, GLenum clamp) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClampColor(target, clamp); +} + +void gl4_0core_glGetTransformFeedbackVarying(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTransformFeedbackVarying(program, index, bufSize, length, size, gltype, name); +} + +void gl4_0core_glBindBufferBase(void *_glfuncs, GLenum target, GLuint index, GLuint buffer) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBufferBase(target, index, buffer); +} + +void gl4_0core_glBindBufferRange(void *_glfuncs, GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBufferRange(target, index, buffer, offset, size); +} + +void gl4_0core_glEndTransformFeedback(void *_glfuncs) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndTransformFeedback(); +} + +void gl4_0core_glBeginTransformFeedback(void *_glfuncs, GLenum primitiveMode) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginTransformFeedback(primitiveMode); +} + +GLboolean gl4_0core_glIsEnabledi(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabledi(target, index); +} + +void gl4_0core_glDisablei(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisablei(target, index); +} + +void gl4_0core_glEnablei(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnablei(target, index); +} + +void gl4_0core_glGetIntegeri_v(void *_glfuncs, GLenum target, GLuint index, GLint* data) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegeri_v(target, index, data); +} + +void gl4_0core_glGetBooleani_v(void *_glfuncs, GLenum target, GLuint index, GLboolean* data) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleani_v(target, index, data); +} + +void gl4_0core_glColorMaski(void *_glfuncs, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMaski(index, r, g, b, a); +} + +void gl4_0core_glCopyBufferSubData(void *_glfuncs, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); +} + +void gl4_0core_glUniformBlockBinding(void *_glfuncs, GLuint program, GLuint v0, GLuint v1) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformBlockBinding(program, v0, v1); +} + +void gl4_0core_glGetActiveUniformBlockName(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName); +} + +void gl4_0core_glGetActiveUniformBlockiv(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params); +} + +GLuint gl4_0core_glGetUniformBlockIndex(void *_glfuncs, GLuint program, const GLchar* uniformBlockName) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetUniformBlockIndex(program, uniformBlockName); +} + +void gl4_0core_glGetActiveUniformName(void *_glfuncs, GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformName(program, uniformIndex, bufSize, length, uniformName); +} + +void gl4_0core_glGetActiveUniformsiv(void *_glfuncs, GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params); +} + +void gl4_0core_glPrimitiveRestartIndex(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPrimitiveRestartIndex(index); +} + +void gl4_0core_glTexBuffer(void *_glfuncs, GLenum target, GLenum internalFormat, GLuint buffer) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexBuffer(target, internalFormat, buffer); +} + +void gl4_0core_glDrawElementsInstanced(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsInstanced(mode, count, gltype, indices, instancecount); +} + +void gl4_0core_glDrawArraysInstanced(void *_glfuncs, GLenum mode, GLint first, GLsizei count, GLsizei instancecount) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArraysInstanced(mode, first, count, instancecount); +} + +void gl4_0core_glSampleMaski(void *_glfuncs, GLuint index, GLbitfield mask) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSampleMaski(index, mask); +} + +void gl4_0core_glGetMultisamplefv(void *_glfuncs, GLenum pname, GLuint index, GLfloat* val) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMultisamplefv(pname, index, val); +} + +void gl4_0core_glTexImage3DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage3DMultisample(target, samples, internalFormat, width, height, depth, fixedsamplelocations); +} + +void gl4_0core_glTexImage2DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage2DMultisample(target, samples, internalFormat, width, height, fixedsamplelocations); +} + +void gl4_0core_glGetSynciv(void *_glfuncs, GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSynciv(sync, pname, bufSize, length, values); +} + +void gl4_0core_glGetInteger64v(void *_glfuncs, GLenum pname, GLint64* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetInteger64v(pname, params); +} + +void gl4_0core_glWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWaitSync(sync, flags, timeout); +} + +GLenum gl4_0core_glClientWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glClientWaitSync(sync, flags, timeout); +} + +void gl4_0core_glDeleteSync(void *_glfuncs, GLsync sync) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteSync(sync); +} + +GLboolean gl4_0core_glIsSync(void *_glfuncs, GLsync sync) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsSync(sync); +} + +GLsync gl4_0core_glFenceSync(void *_glfuncs, GLenum condition, GLbitfield flags) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glFenceSync(condition, flags); +} + +void gl4_0core_glProvokingVertex(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProvokingVertex(mode); +} + +void gl4_0core_glDrawElementsInstancedBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLint basevertex) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsInstancedBaseVertex(mode, count, gltype, indices, instancecount, basevertex); +} + +void gl4_0core_glDrawRangeElementsBaseVertex(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawRangeElementsBaseVertex(mode, start, end, count, gltype, indices, basevertex); +} + +void gl4_0core_glDrawElementsBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsBaseVertex(mode, count, gltype, indices, basevertex); +} + +void gl4_0core_glFramebufferTexture(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture(target, attachment, texture, level); +} + +void gl4_0core_glGetBufferParameteri64v(void *_glfuncs, GLenum target, GLenum pname, GLint64* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferParameteri64v(target, pname, params); +} + +void gl4_0core_glGetInteger64i_v(void *_glfuncs, GLenum target, GLuint index, GLint64* data) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetInteger64i_v(target, index, data); +} + +void gl4_0core_glVertexAttribP4uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP4uiv(index, gltype, normalized, value); +} + +void gl4_0core_glVertexAttribP4ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP4ui(index, gltype, normalized, value); +} + +void gl4_0core_glVertexAttribP3uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP3uiv(index, gltype, normalized, value); +} + +void gl4_0core_glVertexAttribP3ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP3ui(index, gltype, normalized, value); +} + +void gl4_0core_glVertexAttribP2uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP2uiv(index, gltype, normalized, value); +} + +void gl4_0core_glVertexAttribP2ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP2ui(index, gltype, normalized, value); +} + +void gl4_0core_glVertexAttribP1uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP1uiv(index, gltype, normalized, value); +} + +void gl4_0core_glVertexAttribP1ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP1ui(index, gltype, normalized, value); +} + +void gl4_0core_glSecondaryColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColorP3uiv(gltype, color); +} + +void gl4_0core_glSecondaryColorP3ui(void *_glfuncs, GLenum gltype, GLuint color) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColorP3ui(gltype, color); +} + +void gl4_0core_glColorP4uiv(void *_glfuncs, GLenum gltype, const GLuint* color) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP4uiv(gltype, color); +} + +void gl4_0core_glColorP4ui(void *_glfuncs, GLenum gltype, GLuint color) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP4ui(gltype, color); +} + +void gl4_0core_glColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP3uiv(gltype, color); +} + +void gl4_0core_glColorP3ui(void *_glfuncs, GLenum gltype, GLuint color) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP3ui(gltype, color); +} + +void gl4_0core_glNormalP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormalP3uiv(gltype, coords); +} + +void gl4_0core_glNormalP3ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormalP3ui(gltype, coords); +} + +void gl4_0core_glMultiTexCoordP4uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP4uiv(texture, gltype, coords); +} + +void gl4_0core_glMultiTexCoordP4ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP4ui(texture, gltype, coords); +} + +void gl4_0core_glMultiTexCoordP3uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP3uiv(texture, gltype, coords); +} + +void gl4_0core_glMultiTexCoordP3ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP3ui(texture, gltype, coords); +} + +void gl4_0core_glMultiTexCoordP2uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP2uiv(texture, gltype, coords); +} + +void gl4_0core_glMultiTexCoordP2ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP2ui(texture, gltype, coords); +} + +void gl4_0core_glMultiTexCoordP1uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP1uiv(texture, gltype, coords); +} + +void gl4_0core_glMultiTexCoordP1ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP1ui(texture, gltype, coords); +} + +void gl4_0core_glTexCoordP4uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP4uiv(gltype, coords); +} + +void gl4_0core_glTexCoordP4ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP4ui(gltype, coords); +} + +void gl4_0core_glTexCoordP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP3uiv(gltype, coords); +} + +void gl4_0core_glTexCoordP3ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP3ui(gltype, coords); +} + +void gl4_0core_glTexCoordP2uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP2uiv(gltype, coords); +} + +void gl4_0core_glTexCoordP2ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP2ui(gltype, coords); +} + +void gl4_0core_glTexCoordP1uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP1uiv(gltype, coords); +} + +void gl4_0core_glTexCoordP1ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP1ui(gltype, coords); +} + +void gl4_0core_glVertexP4uiv(void *_glfuncs, GLenum gltype, const GLuint* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP4uiv(gltype, value); +} + +void gl4_0core_glVertexP4ui(void *_glfuncs, GLenum gltype, GLuint value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP4ui(gltype, value); +} + +void gl4_0core_glVertexP3uiv(void *_glfuncs, GLenum gltype, const GLuint* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP3uiv(gltype, value); +} + +void gl4_0core_glVertexP3ui(void *_glfuncs, GLenum gltype, GLuint value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP3ui(gltype, value); +} + +void gl4_0core_glVertexP2uiv(void *_glfuncs, GLenum gltype, const GLuint* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP2uiv(gltype, value); +} + +void gl4_0core_glVertexP2ui(void *_glfuncs, GLenum gltype, GLuint value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP2ui(gltype, value); +} + +void gl4_0core_glGetQueryObjectui64v(void *_glfuncs, GLuint id, GLenum pname, GLuint64* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectui64v(id, pname, params); +} + +void gl4_0core_glGetQueryObjecti64v(void *_glfuncs, GLuint id, GLenum pname, GLint64* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjecti64v(id, pname, params); +} + +void gl4_0core_glQueryCounter(void *_glfuncs, GLuint id, GLenum target) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glQueryCounter(id, target); +} + +void gl4_0core_glGetSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameterIuiv(sampler, pname, params); +} + +void gl4_0core_glGetSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameterfv(sampler, pname, params); +} + +void gl4_0core_glGetSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameterIiv(sampler, pname, params); +} + +void gl4_0core_glGetSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameteriv(sampler, pname, params); +} + +void gl4_0core_glSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLuint* param) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterIuiv(sampler, pname, param); +} + +void gl4_0core_glSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterIiv(sampler, pname, param); +} + +void gl4_0core_glSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, const GLfloat* param) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterfv(sampler, pname, param); +} + +void gl4_0core_glSamplerParameterf(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterf(sampler, pname, param); +} + +void gl4_0core_glSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameteriv(sampler, pname, param); +} + +void gl4_0core_glSamplerParameteri(void *_glfuncs, GLuint sampler, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameteri(sampler, pname, param); +} + +void gl4_0core_glBindSampler(void *_glfuncs, GLuint unit, GLuint sampler) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindSampler(unit, sampler); +} + +GLboolean gl4_0core_glIsSampler(void *_glfuncs, GLuint sampler) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsSampler(sampler); +} + +void gl4_0core_glDeleteSamplers(void *_glfuncs, GLsizei count, const GLuint* samplers) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteSamplers(count, samplers); +} + +void gl4_0core_glGenSamplers(void *_glfuncs, GLsizei count, GLuint* samplers) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenSamplers(count, samplers); +} + +GLint gl4_0core_glGetFragDataIndex(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetFragDataIndex(program, name); +} + +void gl4_0core_glBindFragDataLocationIndexed(void *_glfuncs, GLuint program, GLuint colorNumber, GLuint index, const GLchar* name) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFragDataLocationIndexed(program, colorNumber, index, name); +} + +void gl4_0core_glVertexAttribDivisor(void *_glfuncs, GLuint index, GLuint divisor) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribDivisor(index, divisor); +} + +void gl4_0core_glGetQueryIndexediv(void *_glfuncs, GLenum target, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryIndexediv(target, index, pname, params); +} + +void gl4_0core_glEndQueryIndexed(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndQueryIndexed(target, index); +} + +void gl4_0core_glBeginQueryIndexed(void *_glfuncs, GLenum target, GLuint index, GLuint id) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginQueryIndexed(target, index, id); +} + +void gl4_0core_glDrawTransformFeedbackStream(void *_glfuncs, GLenum mode, GLuint id, GLuint stream) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawTransformFeedbackStream(mode, id, stream); +} + +void gl4_0core_glDrawTransformFeedback(void *_glfuncs, GLenum mode, GLuint id) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawTransformFeedback(mode, id); +} + +void gl4_0core_glResumeTransformFeedback(void *_glfuncs) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glResumeTransformFeedback(); +} + +void gl4_0core_glPauseTransformFeedback(void *_glfuncs) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPauseTransformFeedback(); +} + +GLboolean gl4_0core_glIsTransformFeedback(void *_glfuncs, GLuint id) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsTransformFeedback(id); +} + +void gl4_0core_glGenTransformFeedbacks(void *_glfuncs, GLsizei n, GLuint* ids) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenTransformFeedbacks(n, ids); +} + +void gl4_0core_glDeleteTransformFeedbacks(void *_glfuncs, GLsizei n, const GLuint* ids) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteTransformFeedbacks(n, ids); +} + +void gl4_0core_glBindTransformFeedback(void *_glfuncs, GLenum target, GLuint id) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindTransformFeedback(target, id); +} + +void gl4_0core_glPatchParameterfv(void *_glfuncs, GLenum pname, const GLfloat* values) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPatchParameterfv(pname, values); +} + +void gl4_0core_glPatchParameteri(void *_glfuncs, GLenum pname, GLint value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPatchParameteri(pname, value); +} + +void gl4_0core_glGetProgramStageiv(void *_glfuncs, GLuint program, GLenum shadertype, GLenum pname, GLint* values) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramStageiv(program, shadertype, pname, values); +} + +void gl4_0core_glGetUniformSubroutineuiv(void *_glfuncs, GLenum shadertype, GLint location, GLuint* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformSubroutineuiv(shadertype, location, params); +} + +void gl4_0core_glUniformSubroutinesuiv(void *_glfuncs, GLenum shadertype, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformSubroutinesuiv(shadertype, count, value); +} + +void gl4_0core_glGetActiveSubroutineName(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveSubroutineName(program, shadertype, index, bufSize, length, name); +} + +void gl4_0core_glGetActiveSubroutineUniformName(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveSubroutineUniformName(program, shadertype, index, bufSize, length, name); +} + +void gl4_0core_glGetActiveSubroutineUniformiv(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint* values) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveSubroutineUniformiv(program, shadertype, index, pname, values); +} + +GLuint gl4_0core_glGetSubroutineIndex(void *_glfuncs, GLuint program, GLenum shadertype, const GLchar* name) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetSubroutineIndex(program, shadertype, name); +} + +GLint gl4_0core_glGetSubroutineUniformLocation(void *_glfuncs, GLuint program, GLenum shadertype, const GLchar* name) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetSubroutineUniformLocation(program, shadertype, name); +} + +void gl4_0core_glGetUniformdv(void *_glfuncs, GLuint program, GLint location, GLdouble* params) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformdv(program, location, params); +} + +void gl4_0core_glUniformMatrix4x3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x3dv(location, count, transpose, value); +} + +void gl4_0core_glUniformMatrix4x2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x2dv(location, count, transpose, value); +} + +void gl4_0core_glUniformMatrix3x4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x4dv(location, count, transpose, value); +} + +void gl4_0core_glUniformMatrix3x2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x2dv(location, count, transpose, value); +} + +void gl4_0core_glUniformMatrix2x4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x4dv(location, count, transpose, value); +} + +void gl4_0core_glUniformMatrix2x3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x3dv(location, count, transpose, value); +} + +void gl4_0core_glUniformMatrix4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4dv(location, count, transpose, value); +} + +void gl4_0core_glUniformMatrix3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3dv(location, count, transpose, value); +} + +void gl4_0core_glUniformMatrix2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2dv(location, count, transpose, value); +} + +void gl4_0core_glUniform4dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4dv(location, count, value); +} + +void gl4_0core_glUniform3dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3dv(location, count, value); +} + +void gl4_0core_glUniform2dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2dv(location, count, value); +} + +void gl4_0core_glUniform1dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1dv(location, count, value); +} + +void gl4_0core_glUniform4d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4d(location, v0, v1, v2, v3); +} + +void gl4_0core_glUniform3d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1, GLdouble v2) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3d(location, v0, v1, v2); +} + +void gl4_0core_glUniform2d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2d(location, v0, v1); +} + +void gl4_0core_glUniform1d(void *_glfuncs, GLint location, GLdouble v0) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1d(location, v0); +} + +void gl4_0core_glDrawElementsIndirect(void *_glfuncs, GLenum mode, GLenum gltype, const GLvoid* indirect) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsIndirect(mode, gltype, indirect); +} + +void gl4_0core_glDrawArraysIndirect(void *_glfuncs, GLenum mode, const GLvoid* indirect) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArraysIndirect(mode, indirect); +} + +void gl4_0core_glBlendFuncSeparatei(void *_glfuncs, GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha); +} + +void gl4_0core_glBlendFunci(void *_glfuncs, GLuint buf, GLenum src, GLenum dst) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFunci(buf, src, dst); +} + +void gl4_0core_glBlendEquationSeparatei(void *_glfuncs, GLuint buf, GLenum modeRGB, GLenum modeAlpha) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquationSeparatei(buf, modeRGB, modeAlpha); +} + +void gl4_0core_glBlendEquationi(void *_glfuncs, GLuint buf, GLenum mode) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquationi(buf, mode); +} + +void gl4_0core_glMinSampleShading(void *_glfuncs, GLfloat value) +{ + QOpenGLFunctions_4_0_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMinSampleShading(value); +} + diff --git a/gl/4.0core/funcs.h b/gl/4.0core/funcs.h new file mode 100644 index 00000000..55af051d --- /dev/null +++ b/gl/4.0core/funcs.h @@ -0,0 +1,398 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#ifndef __cplusplus +#include +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef char GLchar; +typedef signed char GLbyte; /* 1-byte signed */ +typedef short GLshort; /* 2-byte signed */ +typedef int GLint; /* 4-byte signed */ +typedef unsigned char GLubyte; /* 1-byte unsigned */ +typedef unsigned short GLushort; /* 2-byte unsigned */ +typedef unsigned int GLuint; /* 4-byte unsigned */ +typedef int GLsizei; /* 4-byte signed */ +typedef float GLfloat; /* single precision float */ +typedef float GLclampf; /* single precision float in [0,1] */ +typedef double GLdouble; /* double precision float */ +typedef double GLclampd; /* double precision float in [0,1] */ +typedef int64_t GLint64; +typedef uint64_t GLuint64; +typedef ptrdiff_t GLintptr; +typedef ptrdiff_t GLsizeiptr; +typedef ptrdiff_t GLintptrARB; +typedef ptrdiff_t GLsizeiptrARB; +typedef struct __GLsync *GLsync; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +void *gl4_0core_funcs(); + +void gl4_0core_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_0core_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal); +GLboolean gl4_0core_glIsEnabled(void *_glfuncs, GLenum cap); +void gl4_0core_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params); +void gl4_0core_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params); +void gl4_0core_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_0core_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl4_0core_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels); +void gl4_0core_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params); +void gl4_0core_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params); +GLenum gl4_0core_glGetError(void *_glfuncs); +void gl4_0core_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params); +void gl4_0core_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params); +void gl4_0core_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels); +void gl4_0core_glReadBuffer(void *_glfuncs, GLenum mode); +void gl4_0core_glPixelStorei(void *_glfuncs, GLenum pname, GLint param); +void gl4_0core_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param); +void gl4_0core_glDepthFunc(void *_glfuncs, GLenum glfunc); +void gl4_0core_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass); +void gl4_0core_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask); +void gl4_0core_glLogicOp(void *_glfuncs, GLenum opcode); +void gl4_0core_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor); +void gl4_0core_glFlush(void *_glfuncs); +void gl4_0core_glFinish(void *_glfuncs); +void gl4_0core_glEnable(void *_glfuncs, GLenum cap); +void gl4_0core_glDisable(void *_glfuncs, GLenum cap); +void gl4_0core_glDepthMask(void *_glfuncs, GLboolean flag); +void gl4_0core_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +void gl4_0core_glStencilMask(void *_glfuncs, GLuint mask); +void gl4_0core_glClearDepth(void *_glfuncs, GLdouble depth); +void gl4_0core_glClearStencil(void *_glfuncs, GLint s); +void gl4_0core_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl4_0core_glClear(void *_glfuncs, GLbitfield mask); +void gl4_0core_glDrawBuffer(void *_glfuncs, GLenum mode); +void gl4_0core_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_0core_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_0core_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl4_0core_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl4_0core_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl4_0core_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl4_0core_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_0core_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode); +void gl4_0core_glPointSize(void *_glfuncs, GLfloat size); +void gl4_0core_glLineWidth(void *_glfuncs, GLfloat width); +void gl4_0core_glHint(void *_glfuncs, GLenum target, GLenum mode); +void gl4_0core_glFrontFace(void *_glfuncs, GLenum mode); +void gl4_0core_glCullFace(void *_glfuncs, GLenum mode); +void gl4_0core_glIndexubv(void *_glfuncs, const GLubyte* c); +void gl4_0core_glIndexub(void *_glfuncs, GLubyte c); +GLboolean gl4_0core_glIsTexture(void *_glfuncs, GLuint texture); +void gl4_0core_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures); +void gl4_0core_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures); +void gl4_0core_glBindTexture(void *_glfuncs, GLenum target, GLuint texture); +void gl4_0core_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_0core_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_0core_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_0core_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +void gl4_0core_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +void gl4_0core_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border); +void gl4_0core_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units); +void gl4_0core_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl4_0core_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count); +void gl4_0core_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_0core_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_0core_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_0core_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl4_0core_glBlendEquation(void *_glfuncs, GLenum mode); +void gl4_0core_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl4_0core_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img); +void gl4_0core_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl4_0core_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl4_0core_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl4_0core_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data); +void gl4_0core_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data); +void gl4_0core_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data); +void gl4_0core_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert); +void gl4_0core_glActiveTexture(void *_glfuncs, GLenum texture); +void gl4_0core_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params); +void gl4_0core_glPointParameteri(void *_glfuncs, GLenum pname, GLint param); +void gl4_0core_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl4_0core_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param); +void gl4_0core_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount); +void gl4_0core_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +void gl4_0core_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +GLboolean gl4_0core_glUnmapBuffer(void *_glfuncs, GLenum target); +void gl4_0core_glGetBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data); +void gl4_0core_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data); +void gl4_0core_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage); +GLboolean gl4_0core_glIsBuffer(void *_glfuncs, GLuint buffer); +void gl4_0core_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers); +void gl4_0core_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers); +void gl4_0core_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer); +void gl4_0core_glGetQueryObjectuiv(void *_glfuncs, GLuint id, GLenum pname, GLuint* params); +void gl4_0core_glGetQueryObjectiv(void *_glfuncs, GLuint id, GLenum pname, GLint* params); +void gl4_0core_glGetQueryiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_0core_glEndQuery(void *_glfuncs, GLenum target); +void gl4_0core_glBeginQuery(void *_glfuncs, GLenum target, GLuint id); +GLboolean gl4_0core_glIsQuery(void *_glfuncs, GLuint id); +void gl4_0core_glDeleteQueries(void *_glfuncs, GLsizei n, const GLuint* ids); +void gl4_0core_glGenQueries(void *_glfuncs, GLsizei n, GLuint* ids); +void gl4_0core_glVertexAttribPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLboolean normalized, GLsizei stride, const GLvoid* offset); +void gl4_0core_glValidateProgram(void *_glfuncs, GLuint program); +void gl4_0core_glUniformMatrix4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_0core_glUniformMatrix3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_0core_glUniformMatrix2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_0core_glUniform4iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl4_0core_glUniform3iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl4_0core_glUniform2iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl4_0core_glUniform1iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl4_0core_glUniform4fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl4_0core_glUniform3fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl4_0core_glUniform2fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl4_0core_glUniform1fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl4_0core_glUniform4i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +void gl4_0core_glUniform3i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2); +void gl4_0core_glUniform2i(void *_glfuncs, GLint location, GLint v0, GLint v1); +void gl4_0core_glUniform1i(void *_glfuncs, GLint location, GLint v0); +void gl4_0core_glUniform4f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +void gl4_0core_glUniform3f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +void gl4_0core_glUniform2f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1); +void gl4_0core_glUniform1f(void *_glfuncs, GLint location, GLfloat v0); +void gl4_0core_glUseProgram(void *_glfuncs, GLuint program); +void gl4_0core_glShaderSource(void *_glfuncs, GLuint shader, GLsizei count, const GLchar** source, const GLint* length); +void gl4_0core_glLinkProgram(void *_glfuncs, GLuint program); +GLboolean gl4_0core_glIsShader(void *_glfuncs, GLuint shader); +GLboolean gl4_0core_glIsProgram(void *_glfuncs, GLuint program); +void gl4_0core_glGetVertexAttribiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params); +void gl4_0core_glGetVertexAttribfv(void *_glfuncs, GLuint index, GLenum pname, GLfloat* params); +void gl4_0core_glGetVertexAttribdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params); +void gl4_0core_glGetUniformiv(void *_glfuncs, GLuint program, GLint location, GLint* params); +void gl4_0core_glGetUniformfv(void *_glfuncs, GLuint program, GLint location, GLfloat* params); +GLint gl4_0core_glGetUniformLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl4_0core_glGetShaderSource(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source); +void gl4_0core_glGetShaderInfoLog(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl4_0core_glGetShaderiv(void *_glfuncs, GLuint shader, GLenum pname, GLint* params); +void gl4_0core_glGetProgramInfoLog(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl4_0core_glGetProgramiv(void *_glfuncs, GLuint program, GLenum pname, GLint* params); +GLint gl4_0core_glGetAttribLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl4_0core_glGetAttachedShaders(void *_glfuncs, GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj); +void gl4_0core_glGetActiveUniform(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name); +void gl4_0core_glGetActiveAttrib(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name); +void gl4_0core_glEnableVertexAttribArray(void *_glfuncs, GLuint index); +void gl4_0core_glDisableVertexAttribArray(void *_glfuncs, GLuint index); +void gl4_0core_glDetachShader(void *_glfuncs, GLuint program, GLuint shader); +void gl4_0core_glDeleteShader(void *_glfuncs, GLuint shader); +void gl4_0core_glDeleteProgram(void *_glfuncs, GLuint program); +GLuint gl4_0core_glCreateShader(void *_glfuncs, GLenum gltype); +GLuint gl4_0core_glCreateProgram(void *_glfuncs); +void gl4_0core_glCompileShader(void *_glfuncs, GLuint shader); +void gl4_0core_glBindAttribLocation(void *_glfuncs, GLuint program, GLuint index, const GLchar* name); +void gl4_0core_glAttachShader(void *_glfuncs, GLuint program, GLuint shader); +void gl4_0core_glStencilMaskSeparate(void *_glfuncs, GLenum face, GLuint mask); +void gl4_0core_glStencilFuncSeparate(void *_glfuncs, GLenum face, GLenum glfunc, GLint ref, GLuint mask); +void gl4_0core_glStencilOpSeparate(void *_glfuncs, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +void gl4_0core_glDrawBuffers(void *_glfuncs, GLsizei n, const GLenum* bufs); +void gl4_0core_glBlendEquationSeparate(void *_glfuncs, GLenum modeRGB, GLenum modeAlpha); +void gl4_0core_glUniformMatrix4x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_0core_glUniformMatrix3x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_0core_glUniformMatrix4x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_0core_glUniformMatrix2x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_0core_glUniformMatrix3x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_0core_glUniformMatrix2x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +GLboolean gl4_0core_glIsVertexArray(void *_glfuncs, GLuint array); +void gl4_0core_glGenVertexArrays(void *_glfuncs, GLsizei n, GLuint* arrays); +void gl4_0core_glDeleteVertexArrays(void *_glfuncs, GLsizei n, const GLuint* arrays); +void gl4_0core_glBindVertexArray(void *_glfuncs, GLuint array); +void gl4_0core_glFlushMappedBufferRange(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr length); +void gl4_0core_glFramebufferTextureLayer(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +void gl4_0core_glRenderbufferStorageMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height); +void gl4_0core_glBlitFramebuffer(void *_glfuncs, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +void gl4_0core_glGenerateMipmap(void *_glfuncs, GLenum target); +void gl4_0core_glGetFramebufferAttachmentParameteriv(void *_glfuncs, GLenum target, GLenum attachment, GLenum pname, GLint* params); +void gl4_0core_glFramebufferRenderbuffer(void *_glfuncs, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +void gl4_0core_glFramebufferTexture3D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +void gl4_0core_glFramebufferTexture2D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +void gl4_0core_glFramebufferTexture1D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLenum gl4_0core_glCheckFramebufferStatus(void *_glfuncs, GLenum target); +void gl4_0core_glGenFramebuffers(void *_glfuncs, GLsizei n, GLuint* framebuffers); +void gl4_0core_glDeleteFramebuffers(void *_glfuncs, GLsizei n, const GLuint* framebuffers); +void gl4_0core_glBindFramebuffer(void *_glfuncs, GLenum target, GLuint framebuffer); +GLboolean gl4_0core_glIsFramebuffer(void *_glfuncs, GLuint framebuffer); +void gl4_0core_glGetRenderbufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_0core_glRenderbufferStorage(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height); +void gl4_0core_glGenRenderbuffers(void *_glfuncs, GLsizei n, GLuint* renderbuffers); +void gl4_0core_glDeleteRenderbuffers(void *_glfuncs, GLsizei n, const GLuint* renderbuffers); +void gl4_0core_glBindRenderbuffer(void *_glfuncs, GLenum target, GLuint renderbuffer); +GLboolean gl4_0core_glIsRenderbuffer(void *_glfuncs, GLuint renderbuffer); +void gl4_0core_glClearBufferfi(void *_glfuncs, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); +void gl4_0core_glClearBufferfv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLfloat* value); +void gl4_0core_glClearBufferuiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLuint* value); +void gl4_0core_glClearBufferiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLint* value); +void gl4_0core_glGetTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, GLuint* params); +void gl4_0core_glGetTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_0core_glTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, const GLuint* params); +void gl4_0core_glTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl4_0core_glUniform4uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl4_0core_glUniform3uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl4_0core_glUniform2uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl4_0core_glUniform1uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl4_0core_glUniform4ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +void gl4_0core_glUniform3ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2); +void gl4_0core_glUniform2ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1); +void gl4_0core_glUniform1ui(void *_glfuncs, GLint location, GLuint v0); +GLint gl4_0core_glGetFragDataLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl4_0core_glBindFragDataLocation(void *_glfuncs, GLuint program, GLuint color, const GLchar* name); +void gl4_0core_glGetUniformuiv(void *_glfuncs, GLuint program, GLint location, GLuint* params); +void gl4_0core_glGetVertexAttribIuiv(void *_glfuncs, GLuint index, GLenum pname, GLuint* params); +void gl4_0core_glGetVertexAttribIiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params); +void gl4_0core_glVertexAttribIPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_0core_glEndConditionalRender(void *_glfuncs); +void gl4_0core_glBeginConditionalRender(void *_glfuncs, GLuint id, GLenum mode); +void gl4_0core_glClampColor(void *_glfuncs, GLenum target, GLenum clamp); +void gl4_0core_glGetTransformFeedbackVarying(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* gltype, GLchar* name); +void gl4_0core_glBindBufferBase(void *_glfuncs, GLenum target, GLuint index, GLuint buffer); +void gl4_0core_glBindBufferRange(void *_glfuncs, GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +void gl4_0core_glEndTransformFeedback(void *_glfuncs); +void gl4_0core_glBeginTransformFeedback(void *_glfuncs, GLenum primitiveMode); +GLboolean gl4_0core_glIsEnabledi(void *_glfuncs, GLenum target, GLuint index); +void gl4_0core_glDisablei(void *_glfuncs, GLenum target, GLuint index); +void gl4_0core_glEnablei(void *_glfuncs, GLenum target, GLuint index); +void gl4_0core_glGetIntegeri_v(void *_glfuncs, GLenum target, GLuint index, GLint* data); +void gl4_0core_glGetBooleani_v(void *_glfuncs, GLenum target, GLuint index, GLboolean* data); +void gl4_0core_glColorMaski(void *_glfuncs, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +void gl4_0core_glCopyBufferSubData(void *_glfuncs, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +void gl4_0core_glUniformBlockBinding(void *_glfuncs, GLuint program, GLuint v0, GLuint v1); +void gl4_0core_glGetActiveUniformBlockName(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName); +void gl4_0core_glGetActiveUniformBlockiv(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params); +GLuint gl4_0core_glGetUniformBlockIndex(void *_glfuncs, GLuint program, const GLchar* uniformBlockName); +void gl4_0core_glGetActiveUniformName(void *_glfuncs, GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName); +void gl4_0core_glGetActiveUniformsiv(void *_glfuncs, GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params); +void gl4_0core_glPrimitiveRestartIndex(void *_glfuncs, GLuint index); +void gl4_0core_glTexBuffer(void *_glfuncs, GLenum target, GLenum internalFormat, GLuint buffer); +void gl4_0core_glDrawElementsInstanced(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount); +void gl4_0core_glDrawArraysInstanced(void *_glfuncs, GLenum mode, GLint first, GLsizei count, GLsizei instancecount); +void gl4_0core_glSampleMaski(void *_glfuncs, GLuint index, GLbitfield mask); +void gl4_0core_glGetMultisamplefv(void *_glfuncs, GLenum pname, GLuint index, GLfloat* val); +void gl4_0core_glTexImage3DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); +void gl4_0core_glTexImage2DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +void gl4_0core_glGetSynciv(void *_glfuncs, GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values); +void gl4_0core_glGetInteger64v(void *_glfuncs, GLenum pname, GLint64* params); +void gl4_0core_glWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout); +GLenum gl4_0core_glClientWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout); +void gl4_0core_glDeleteSync(void *_glfuncs, GLsync sync); +GLboolean gl4_0core_glIsSync(void *_glfuncs, GLsync sync); +GLsync gl4_0core_glFenceSync(void *_glfuncs, GLenum condition, GLbitfield flags); +void gl4_0core_glProvokingVertex(void *_glfuncs, GLenum mode); +void gl4_0core_glDrawElementsInstancedBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLint basevertex); +void gl4_0core_glDrawRangeElementsBaseVertex(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex); +void gl4_0core_glDrawElementsBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex); +void gl4_0core_glFramebufferTexture(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level); +void gl4_0core_glGetBufferParameteri64v(void *_glfuncs, GLenum target, GLenum pname, GLint64* params); +void gl4_0core_glGetInteger64i_v(void *_glfuncs, GLenum target, GLuint index, GLint64* data); +void gl4_0core_glVertexAttribP4uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl4_0core_glVertexAttribP4ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl4_0core_glVertexAttribP3uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl4_0core_glVertexAttribP3ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl4_0core_glVertexAttribP2uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl4_0core_glVertexAttribP2ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl4_0core_glVertexAttribP1uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl4_0core_glVertexAttribP1ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl4_0core_glSecondaryColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color); +void gl4_0core_glSecondaryColorP3ui(void *_glfuncs, GLenum gltype, GLuint color); +void gl4_0core_glColorP4uiv(void *_glfuncs, GLenum gltype, const GLuint* color); +void gl4_0core_glColorP4ui(void *_glfuncs, GLenum gltype, GLuint color); +void gl4_0core_glColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color); +void gl4_0core_glColorP3ui(void *_glfuncs, GLenum gltype, GLuint color); +void gl4_0core_glNormalP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_0core_glNormalP3ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_0core_glMultiTexCoordP4uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl4_0core_glMultiTexCoordP4ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl4_0core_glMultiTexCoordP3uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl4_0core_glMultiTexCoordP3ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl4_0core_glMultiTexCoordP2uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl4_0core_glMultiTexCoordP2ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl4_0core_glMultiTexCoordP1uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl4_0core_glMultiTexCoordP1ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl4_0core_glTexCoordP4uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_0core_glTexCoordP4ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_0core_glTexCoordP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_0core_glTexCoordP3ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_0core_glTexCoordP2uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_0core_glTexCoordP2ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_0core_glTexCoordP1uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_0core_glTexCoordP1ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_0core_glVertexP4uiv(void *_glfuncs, GLenum gltype, const GLuint* value); +void gl4_0core_glVertexP4ui(void *_glfuncs, GLenum gltype, GLuint value); +void gl4_0core_glVertexP3uiv(void *_glfuncs, GLenum gltype, const GLuint* value); +void gl4_0core_glVertexP3ui(void *_glfuncs, GLenum gltype, GLuint value); +void gl4_0core_glVertexP2uiv(void *_glfuncs, GLenum gltype, const GLuint* value); +void gl4_0core_glVertexP2ui(void *_glfuncs, GLenum gltype, GLuint value); +void gl4_0core_glGetQueryObjectui64v(void *_glfuncs, GLuint id, GLenum pname, GLuint64* params); +void gl4_0core_glGetQueryObjecti64v(void *_glfuncs, GLuint id, GLenum pname, GLint64* params); +void gl4_0core_glQueryCounter(void *_glfuncs, GLuint id, GLenum target); +void gl4_0core_glGetSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, GLuint* params); +void gl4_0core_glGetSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat* params); +void gl4_0core_glGetSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params); +void gl4_0core_glGetSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params); +void gl4_0core_glSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLuint* param); +void gl4_0core_glSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param); +void gl4_0core_glSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, const GLfloat* param); +void gl4_0core_glSamplerParameterf(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat param); +void gl4_0core_glSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param); +void gl4_0core_glSamplerParameteri(void *_glfuncs, GLuint sampler, GLenum pname, GLint param); +void gl4_0core_glBindSampler(void *_glfuncs, GLuint unit, GLuint sampler); +GLboolean gl4_0core_glIsSampler(void *_glfuncs, GLuint sampler); +void gl4_0core_glDeleteSamplers(void *_glfuncs, GLsizei count, const GLuint* samplers); +void gl4_0core_glGenSamplers(void *_glfuncs, GLsizei count, GLuint* samplers); +GLint gl4_0core_glGetFragDataIndex(void *_glfuncs, GLuint program, const GLchar* name); +void gl4_0core_glBindFragDataLocationIndexed(void *_glfuncs, GLuint program, GLuint colorNumber, GLuint index, const GLchar* name); +void gl4_0core_glVertexAttribDivisor(void *_glfuncs, GLuint index, GLuint divisor); +void gl4_0core_glGetQueryIndexediv(void *_glfuncs, GLenum target, GLuint index, GLenum pname, GLint* params); +void gl4_0core_glEndQueryIndexed(void *_glfuncs, GLenum target, GLuint index); +void gl4_0core_glBeginQueryIndexed(void *_glfuncs, GLenum target, GLuint index, GLuint id); +void gl4_0core_glDrawTransformFeedbackStream(void *_glfuncs, GLenum mode, GLuint id, GLuint stream); +void gl4_0core_glDrawTransformFeedback(void *_glfuncs, GLenum mode, GLuint id); +void gl4_0core_glResumeTransformFeedback(void *_glfuncs); +void gl4_0core_glPauseTransformFeedback(void *_glfuncs); +GLboolean gl4_0core_glIsTransformFeedback(void *_glfuncs, GLuint id); +void gl4_0core_glGenTransformFeedbacks(void *_glfuncs, GLsizei n, GLuint* ids); +void gl4_0core_glDeleteTransformFeedbacks(void *_glfuncs, GLsizei n, const GLuint* ids); +void gl4_0core_glBindTransformFeedback(void *_glfuncs, GLenum target, GLuint id); +void gl4_0core_glPatchParameterfv(void *_glfuncs, GLenum pname, const GLfloat* values); +void gl4_0core_glPatchParameteri(void *_glfuncs, GLenum pname, GLint value); +void gl4_0core_glGetProgramStageiv(void *_glfuncs, GLuint program, GLenum shadertype, GLenum pname, GLint* values); +void gl4_0core_glGetUniformSubroutineuiv(void *_glfuncs, GLenum shadertype, GLint location, GLuint* params); +void gl4_0core_glUniformSubroutinesuiv(void *_glfuncs, GLenum shadertype, GLsizei count, const GLuint* value); +void gl4_0core_glGetActiveSubroutineName(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name); +void gl4_0core_glGetActiveSubroutineUniformName(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name); +void gl4_0core_glGetActiveSubroutineUniformiv(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint* values); +GLuint gl4_0core_glGetSubroutineIndex(void *_glfuncs, GLuint program, GLenum shadertype, const GLchar* name); +GLint gl4_0core_glGetSubroutineUniformLocation(void *_glfuncs, GLuint program, GLenum shadertype, const GLchar* name); +void gl4_0core_glGetUniformdv(void *_glfuncs, GLuint program, GLint location, GLdouble* params); +void gl4_0core_glUniformMatrix4x3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_0core_glUniformMatrix4x2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_0core_glUniformMatrix3x4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_0core_glUniformMatrix3x2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_0core_glUniformMatrix2x4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_0core_glUniformMatrix2x3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_0core_glUniformMatrix4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_0core_glUniformMatrix3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_0core_glUniformMatrix2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_0core_glUniform4dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value); +void gl4_0core_glUniform3dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value); +void gl4_0core_glUniform2dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value); +void gl4_0core_glUniform1dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value); +void gl4_0core_glUniform4d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3); +void gl4_0core_glUniform3d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1, GLdouble v2); +void gl4_0core_glUniform2d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1); +void gl4_0core_glUniform1d(void *_glfuncs, GLint location, GLdouble v0); +void gl4_0core_glDrawElementsIndirect(void *_glfuncs, GLenum mode, GLenum gltype, const GLvoid* indirect); +void gl4_0core_glDrawArraysIndirect(void *_glfuncs, GLenum mode, const GLvoid* indirect); +void gl4_0core_glBlendFuncSeparatei(void *_glfuncs, GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); +void gl4_0core_glBlendFunci(void *_glfuncs, GLuint buf, GLenum src, GLenum dst); +void gl4_0core_glBlendEquationSeparatei(void *_glfuncs, GLuint buf, GLenum modeRGB, GLenum modeAlpha); +void gl4_0core_glBlendEquationi(void *_glfuncs, GLuint buf, GLenum mode); +void gl4_0core_glMinSampleShading(void *_glfuncs, GLfloat value); + + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/gl/4.0core/gl.go b/gl/4.0core/gl.go new file mode 100644 index 00000000..ddfef931 --- /dev/null +++ b/gl/4.0core/gl.go @@ -0,0 +1,5815 @@ +// ** file automatically generated by glgen -- do not edit manually ** + +package GL + +// #cgo CXXFLAGS: -std=c++0x -pedantic-errors -Wall -fno-strict-aliasing +// #cgo LDFLAGS: -lstdc++ +// #cgo pkg-config: Qt5Core Qt5OpenGL +// +// #include "funcs.h" +// +// void free(void*); +// +import "C" + +import ( + "fmt" + "reflect" + "unsafe" + + "gopkg.in/qml.v1/gl/glbase" +) + +// API returns a value that offers methods matching the OpenGL version 4.0 API. +// +// The returned API must not be used after the provided OpenGL context becomes invalid. +func API(context glbase.Contexter) *GL { + gl := &GL{} + gl.funcs = C.gl4_0core_funcs() + if gl.funcs == nil { + panic(fmt.Errorf("OpenGL version 4.0 is not available")) + } + return gl +} + +// GL implements the OpenGL version 4.0 API. Values of this +// type must be created via the API function, and it must not be used after +// the associated OpenGL context becomes invalid. +type GL struct { + funcs unsafe.Pointer +} + +const ( + FALSE = 0 + TRUE = 1 + NONE = 0 + + BYTE = 0x1400 + UNSIGNED_BYTE = 0x1401 + SHORT = 0x1402 + UNSIGNED_SHORT = 0x1403 + INT = 0x1404 + UNSIGNED_INT = 0x1405 + FLOAT = 0x1406 + N2_BYTES = 0x1407 + N3_BYTES = 0x1408 + N4_BYTES = 0x1409 + DOUBLE = 0x140A + HALF_FLOAT = 0x140B + + ACCUM = 0x0100 + LOAD = 0x0101 + RETURN = 0x0102 + MULT = 0x0103 + ADD = 0x0104 + + ACCUM_BUFFER_BIT = 0x00000200 + ALL_ATTRIB_BITS = 0xFFFFFFFF + COLOR_BUFFER_BIT = 0x00004000 + CURRENT_BIT = 0x00000001 + DEPTH_BUFFER_BIT = 0x00000100 + ENABLE_BIT = 0x00002000 + EVAL_BIT = 0x00010000 + FOG_BIT = 0x00000080 + HINT_BIT = 0x00008000 + LIGHTING_BIT = 0x00000040 + LINE_BIT = 0x00000004 + LIST_BIT = 0x00020000 + MULTISAMPLE_BIT = 0x20000000 + PIXEL_MODE_BIT = 0x00000020 + POINT_BIT = 0x00000002 + POLYGON_BIT = 0x00000008 + POLYGON_STIPPLE_BIT = 0x00000010 + SCISSOR_BIT = 0x00080000 + STENCIL_BUFFER_BIT = 0x00000400 + TEXTURE_BIT = 0x00040000 + TRANSFORM_BIT = 0x00001000 + VIEWPORT_BIT = 0x00000800 + + ALWAYS = 0x0207 + EQUAL = 0x0202 + GEQUAL = 0x0206 + GREATER = 0x0204 + LEQUAL = 0x0203 + LESS = 0x0201 + NEVER = 0x0200 + NOTEQUAL = 0x0205 + + LOGIC_OP = 0x0BF1 + + DST_ALPHA = 0x0304 + ONE = 1 + ONE_MINUS_DST_ALPHA = 0x0305 + ONE_MINUS_SRC_ALPHA = 0x0303 + ONE_MINUS_SRC_COLOR = 0x0301 + SRC_ALPHA = 0x0302 + SRC_COLOR = 0x0300 + ZERO = 0 + + DST_COLOR = 0x0306 + ONE_MINUS_DST_COLOR = 0x0307 + SRC_ALPHA_SATURATE = 0x0308 + + CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF + CLIENT_PIXEL_STORE_BIT = 0x00000001 + CLIENT_VERTEX_ARRAY_BIT = 0x00000002 + + CLIP_DISTANCE0 = 0x3000 + CLIP_DISTANCE1 = 0x3001 + CLIP_DISTANCE2 = 0x3002 + CLIP_DISTANCE3 = 0x3003 + CLIP_DISTANCE4 = 0x3004 + CLIP_DISTANCE5 = 0x3005 + CLIP_DISTANCE6 = 0x3006 + CLIP_DISTANCE7 = 0x3007 + CLIP_PLANE0 = 0x3000 + CLIP_PLANE1 = 0x3001 + CLIP_PLANE2 = 0x3002 + CLIP_PLANE3 = 0x3003 + CLIP_PLANE4 = 0x3004 + CLIP_PLANE5 = 0x3005 + + BACK = 0x0405 + FRONT = 0x0404 + FRONT_AND_BACK = 0x0408 + + AMBIENT = 0x1200 + AMBIENT_AND_DIFFUSE = 0x1602 + DIFFUSE = 0x1201 + EMISSION = 0x1600 + SPECULAR = 0x1202 + + CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x00000001 + + CONTEXT_COMPATIBILITY_PROFILE_BIT = 0x00000002 + CONTEXT_CORE_PROFILE_BIT = 0x00000001 + + AUX0 = 0x0409 + AUX1 = 0x040A + AUX2 = 0x040B + AUX3 = 0x040C + BACK_LEFT = 0x0402 + BACK_RIGHT = 0x0403 + FRONT_LEFT = 0x0400 + FRONT_RIGHT = 0x0401 + LEFT = 0x0406 + RIGHT = 0x0407 + + ALPHA_TEST = 0x0BC0 + AUTO_NORMAL = 0x0D80 + BLEND = 0x0BE2 + COLOR_ARRAY = 0x8076 + COLOR_LOGIC_OP = 0x0BF2 + COLOR_MATERIAL = 0x0B57 + CULL_FACE = 0x0B44 + DEPTH_TEST = 0x0B71 + DITHER = 0x0BD0 + EDGE_FLAG_ARRAY = 0x8079 + FOG = 0x0B60 + INDEX_ARRAY = 0x8077 + INDEX_LOGIC_OP = 0x0BF1 + LIGHT0 = 0x4000 + LIGHT1 = 0x4001 + LIGHT2 = 0x4002 + LIGHT3 = 0x4003 + LIGHT4 = 0x4004 + LIGHT5 = 0x4005 + LIGHT6 = 0x4006 + LIGHT7 = 0x4007 + LIGHTING = 0x0B50 + LINE_SMOOTH = 0x0B20 + LINE_STIPPLE = 0x0B24 + MAP1_COLOR_4 = 0x0D90 + MAP1_INDEX = 0x0D91 + MAP1_NORMAL = 0x0D92 + MAP1_TEXTURE_COORD_1 = 0x0D93 + MAP1_TEXTURE_COORD_2 = 0x0D94 + MAP1_TEXTURE_COORD_3 = 0x0D95 + MAP1_TEXTURE_COORD_4 = 0x0D96 + MAP1_VERTEX_3 = 0x0D97 + MAP1_VERTEX_4 = 0x0D98 + MAP2_COLOR_4 = 0x0DB0 + MAP2_INDEX = 0x0DB1 + MAP2_NORMAL = 0x0DB2 + MAP2_TEXTURE_COORD_1 = 0x0DB3 + MAP2_TEXTURE_COORD_2 = 0x0DB4 + MAP2_TEXTURE_COORD_3 = 0x0DB5 + MAP2_TEXTURE_COORD_4 = 0x0DB6 + MAP2_VERTEX_3 = 0x0DB7 + MAP2_VERTEX_4 = 0x0DB8 + NORMALIZE = 0x0BA1 + NORMAL_ARRAY = 0x8075 + POINT_SMOOTH = 0x0B10 + POLYGON_OFFSET_FILL = 0x8037 + POLYGON_OFFSET_LINE = 0x2A02 + POLYGON_OFFSET_POINT = 0x2A01 + POLYGON_SMOOTH = 0x0B41 + POLYGON_STIPPLE = 0x0B42 + SCISSOR_TEST = 0x0C11 + STENCIL_TEST = 0x0B90 + TEXTURE_1D = 0x0DE0 + TEXTURE_2D = 0x0DE1 + TEXTURE_COORD_ARRAY = 0x8078 + TEXTURE_GEN_Q = 0x0C63 + TEXTURE_GEN_R = 0x0C62 + TEXTURE_GEN_S = 0x0C60 + TEXTURE_GEN_T = 0x0C61 + VERTEX_ARRAY = 0x8074 + + INVALID_ENUM = 0x0500 + INVALID_FRAMEBUFFER_OPERATION = 0x0506 + INVALID_OPERATION = 0x0502 + INVALID_VALUE = 0x0501 + NO_ERROR = 0 + OUT_OF_MEMORY = 0x0505 + STACK_OVERFLOW = 0x0503 + STACK_UNDERFLOW = 0x0504 + + N2D = 0x0600 + N3D = 0x0601 + N3D_COLOR = 0x0602 + N3D_COLOR_TEXTURE = 0x0603 + N4D_COLOR_TEXTURE = 0x0604 + + BITMAP_TOKEN = 0x0704 + COPY_PIXEL_TOKEN = 0x0706 + DRAW_PIXEL_TOKEN = 0x0705 + LINE_RESET_TOKEN = 0x0707 + LINE_TOKEN = 0x0702 + PASS_THROUGH_TOKEN = 0x0700 + POINT_TOKEN = 0x0701 + POLYGON_TOKEN = 0x0703 + + EXP = 0x0800 + EXP2 = 0x0801 + LINEAR = 0x2601 + + FOG_COLOR = 0x0B66 + FOG_DENSITY = 0x0B62 + FOG_END = 0x0B64 + FOG_INDEX = 0x0B61 + FOG_MODE = 0x0B65 + FOG_START = 0x0B63 + + CCW = 0x0901 + CW = 0x0900 + + COEFF = 0x0A00 + DOMAIN = 0x0A02 + ORDER = 0x0A01 + + PIXEL_MAP_A_TO_A = 0x0C79 + PIXEL_MAP_B_TO_B = 0x0C78 + PIXEL_MAP_G_TO_G = 0x0C77 + PIXEL_MAP_I_TO_A = 0x0C75 + PIXEL_MAP_I_TO_B = 0x0C74 + PIXEL_MAP_I_TO_G = 0x0C73 + PIXEL_MAP_I_TO_I = 0x0C70 + PIXEL_MAP_I_TO_R = 0x0C72 + PIXEL_MAP_R_TO_R = 0x0C76 + PIXEL_MAP_S_TO_S = 0x0C71 + + ACCUM_ALPHA_BITS = 0x0D5B + ACCUM_BLUE_BITS = 0x0D5A + ACCUM_CLEAR_VALUE = 0x0B80 + ACCUM_GREEN_BITS = 0x0D59 + ACCUM_RED_BITS = 0x0D58 + ALIASED_LINE_WIDTH_RANGE = 0x846E + ALIASED_POINT_SIZE_RANGE = 0x846D + ALPHA_BIAS = 0x0D1D + ALPHA_BITS = 0x0D55 + ALPHA_SCALE = 0x0D1C + ALPHA_TEST_FUNC = 0x0BC1 + ALPHA_TEST_REF = 0x0BC2 + ATTRIB_STACK_DEPTH = 0x0BB0 + AUX_BUFFERS = 0x0C00 + BLEND_DST = 0x0BE0 + BLEND_SRC = 0x0BE1 + BLUE_BIAS = 0x0D1B + BLUE_BITS = 0x0D54 + BLUE_SCALE = 0x0D1A + CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1 + COLOR_ARRAY_SIZE = 0x8081 + COLOR_ARRAY_STRIDE = 0x8083 + COLOR_ARRAY_TYPE = 0x8082 + COLOR_CLEAR_VALUE = 0x0C22 + COLOR_MATERIAL_FACE = 0x0B55 + COLOR_MATERIAL_PARAMETER = 0x0B56 + COLOR_WRITEMASK = 0x0C23 + CULL_FACE_MODE = 0x0B45 + CURRENT_COLOR = 0x0B00 + CURRENT_INDEX = 0x0B01 + CURRENT_NORMAL = 0x0B02 + CURRENT_RASTER_COLOR = 0x0B04 + CURRENT_RASTER_DISTANCE = 0x0B09 + CURRENT_RASTER_INDEX = 0x0B05 + CURRENT_RASTER_POSITION = 0x0B07 + CURRENT_RASTER_POSITION_VALID = 0x0B08 + CURRENT_RASTER_TEXTURE_COORDS = 0x0B06 + CURRENT_TEXTURE_COORDS = 0x0B03 + DEPTH_BIAS = 0x0D1F + DEPTH_BITS = 0x0D56 + DEPTH_CLEAR_VALUE = 0x0B73 + DEPTH_FUNC = 0x0B74 + DEPTH_RANGE = 0x0B70 + DEPTH_SCALE = 0x0D1E + DEPTH_WRITEMASK = 0x0B72 + DOUBLEBUFFER = 0x0C32 + DRAW_BUFFER = 0x0C01 + EDGE_FLAG = 0x0B43 + EDGE_FLAG_ARRAY_STRIDE = 0x808C + FEEDBACK_BUFFER_SIZE = 0x0DF1 + FEEDBACK_BUFFER_TYPE = 0x0DF2 + FOG_HINT = 0x0C54 + FRONT_FACE = 0x0B46 + GREEN_BIAS = 0x0D19 + GREEN_BITS = 0x0D53 + GREEN_SCALE = 0x0D18 + INDEX_ARRAY_STRIDE = 0x8086 + INDEX_ARRAY_TYPE = 0x8085 + INDEX_BITS = 0x0D51 + INDEX_CLEAR_VALUE = 0x0C20 + INDEX_MODE = 0x0C30 + INDEX_OFFSET = 0x0D13 + INDEX_SHIFT = 0x0D12 + INDEX_WRITEMASK = 0x0C21 + LIGHT_MODEL_AMBIENT = 0x0B53 + LIGHT_MODEL_COLOR_CONTROL = 0x81F8 + LIGHT_MODEL_LOCAL_VIEWER = 0x0B51 + LIGHT_MODEL_TWO_SIDE = 0x0B52 + LINE_SMOOTH_HINT = 0x0C52 + LINE_STIPPLE_PATTERN = 0x0B25 + LINE_STIPPLE_REPEAT = 0x0B26 + LINE_WIDTH = 0x0B21 + LINE_WIDTH_GRANULARITY = 0x0B23 + LINE_WIDTH_RANGE = 0x0B22 + LIST_BASE = 0x0B32 + LIST_INDEX = 0x0B33 + LIST_MODE = 0x0B30 + LOGIC_OP_MODE = 0x0BF0 + MAP1_GRID_DOMAIN = 0x0DD0 + MAP1_GRID_SEGMENTS = 0x0DD1 + MAP2_GRID_DOMAIN = 0x0DD2 + MAP2_GRID_SEGMENTS = 0x0DD3 + MAP_COLOR = 0x0D10 + MAP_STENCIL = 0x0D11 + MATRIX_MODE = 0x0BA0 + MAX_ATTRIB_STACK_DEPTH = 0x0D35 + MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B + MAX_CLIP_DISTANCES = 0x0D32 + MAX_CLIP_PLANES = 0x0D32 + MAX_EVAL_ORDER = 0x0D30 + MAX_LIGHTS = 0x0D31 + MAX_LIST_NESTING = 0x0B31 + MAX_MODELVIEW_STACK_DEPTH = 0x0D36 + MAX_NAME_STACK_DEPTH = 0x0D37 + MAX_PIXEL_MAP_TABLE = 0x0D34 + MAX_PROJECTION_STACK_DEPTH = 0x0D38 + MAX_TEXTURE_SIZE = 0x0D33 + MAX_TEXTURE_STACK_DEPTH = 0x0D39 + MAX_VIEWPORT_DIMS = 0x0D3A + MODELVIEW_MATRIX = 0x0BA6 + MODELVIEW_STACK_DEPTH = 0x0BA3 + NAME_STACK_DEPTH = 0x0D70 + NORMAL_ARRAY_STRIDE = 0x807F + NORMAL_ARRAY_TYPE = 0x807E + PACK_ALIGNMENT = 0x0D05 + PACK_LSB_FIRST = 0x0D01 + PACK_ROW_LENGTH = 0x0D02 + PACK_SKIP_PIXELS = 0x0D04 + PACK_SKIP_ROWS = 0x0D03 + PACK_SWAP_BYTES = 0x0D00 + PERSPECTIVE_CORRECTION_HINT = 0x0C50 + PIXEL_MAP_A_TO_A_SIZE = 0x0CB9 + PIXEL_MAP_B_TO_B_SIZE = 0x0CB8 + PIXEL_MAP_G_TO_G_SIZE = 0x0CB7 + PIXEL_MAP_I_TO_A_SIZE = 0x0CB5 + PIXEL_MAP_I_TO_B_SIZE = 0x0CB4 + PIXEL_MAP_I_TO_G_SIZE = 0x0CB3 + PIXEL_MAP_I_TO_I_SIZE = 0x0CB0 + PIXEL_MAP_I_TO_R_SIZE = 0x0CB2 + PIXEL_MAP_R_TO_R_SIZE = 0x0CB6 + PIXEL_MAP_S_TO_S_SIZE = 0x0CB1 + POINT_SIZE = 0x0B11 + POINT_SIZE_GRANULARITY = 0x0B13 + POINT_SIZE_RANGE = 0x0B12 + POINT_SMOOTH_HINT = 0x0C51 + POLYGON_MODE = 0x0B40 + POLYGON_OFFSET_FACTOR = 0x8038 + POLYGON_OFFSET_UNITS = 0x2A00 + POLYGON_SMOOTH_HINT = 0x0C53 + PROJECTION_MATRIX = 0x0BA7 + PROJECTION_STACK_DEPTH = 0x0BA4 + READ_BUFFER = 0x0C02 + RED_BIAS = 0x0D15 + RED_BITS = 0x0D52 + RED_SCALE = 0x0D14 + RENDER_MODE = 0x0C40 + RGBA_MODE = 0x0C31 + SCISSOR_BOX = 0x0C10 + SELECTION_BUFFER_SIZE = 0x0DF4 + SHADE_MODEL = 0x0B54 + SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23 + SMOOTH_LINE_WIDTH_RANGE = 0x0B22 + SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13 + SMOOTH_POINT_SIZE_RANGE = 0x0B12 + STENCIL_BITS = 0x0D57 + STENCIL_CLEAR_VALUE = 0x0B91 + STENCIL_FAIL = 0x0B94 + STENCIL_FUNC = 0x0B92 + STENCIL_PASS_DEPTH_FAIL = 0x0B95 + STENCIL_PASS_DEPTH_PASS = 0x0B96 + STENCIL_REF = 0x0B97 + STENCIL_VALUE_MASK = 0x0B93 + STENCIL_WRITEMASK = 0x0B98 + STEREO = 0x0C33 + SUBPIXEL_BITS = 0x0D50 + TEXTURE_BINDING_1D = 0x8068 + TEXTURE_BINDING_2D = 0x8069 + TEXTURE_BINDING_3D = 0x806A + TEXTURE_COORD_ARRAY_SIZE = 0x8088 + TEXTURE_COORD_ARRAY_STRIDE = 0x808A + TEXTURE_COORD_ARRAY_TYPE = 0x8089 + TEXTURE_MATRIX = 0x0BA8 + TEXTURE_STACK_DEPTH = 0x0BA5 + UNPACK_ALIGNMENT = 0x0CF5 + UNPACK_LSB_FIRST = 0x0CF1 + UNPACK_ROW_LENGTH = 0x0CF2 + UNPACK_SKIP_PIXELS = 0x0CF4 + UNPACK_SKIP_ROWS = 0x0CF3 + UNPACK_SWAP_BYTES = 0x0CF0 + VERTEX_ARRAY_SIZE = 0x807A + VERTEX_ARRAY_STRIDE = 0x807C + VERTEX_ARRAY_TYPE = 0x807B + VIEWPORT = 0x0BA2 + ZOOM_X = 0x0D16 + ZOOM_Y = 0x0D17 + + COLOR_ARRAY_POINTER = 0x8090 + EDGE_FLAG_ARRAY_POINTER = 0x8093 + FEEDBACK_BUFFER_POINTER = 0x0DF0 + INDEX_ARRAY_POINTER = 0x8091 + NORMAL_ARRAY_POINTER = 0x808F + SELECTION_BUFFER_POINTER = 0x0DF3 + TEXTURE_COORD_ARRAY_POINTER = 0x8092 + VERTEX_ARRAY_POINTER = 0x808E + + TEXTURE_ALPHA_SIZE = 0x805F + TEXTURE_BLUE_SIZE = 0x805E + TEXTURE_BORDER = 0x1005 + TEXTURE_BORDER_COLOR = 0x1004 + TEXTURE_COMPONENTS = 0x1003 + TEXTURE_GREEN_SIZE = 0x805D + TEXTURE_HEIGHT = 0x1001 + TEXTURE_INTENSITY_SIZE = 0x8061 + TEXTURE_INTERNAL_FORMAT = 0x1003 + TEXTURE_LUMINANCE_SIZE = 0x8060 + TEXTURE_MAG_FILTER = 0x2800 + TEXTURE_MIN_FILTER = 0x2801 + TEXTURE_PRIORITY = 0x8066 + TEXTURE_RED_SIZE = 0x805C + TEXTURE_RESIDENT = 0x8067 + TEXTURE_WIDTH = 0x1000 + TEXTURE_WRAP_S = 0x2802 + TEXTURE_WRAP_T = 0x2803 + + DONT_CARE = 0x1100 + FASTEST = 0x1101 + NICEST = 0x1102 + + FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B + GENERATE_MIPMAP_HINT = 0x8192 + TEXTURE_COMPRESSION_HINT = 0x84EF + + C3F_V3F = 0x2A24 + C4F_N3F_V3F = 0x2A26 + C4UB_V2F = 0x2A22 + C4UB_V3F = 0x2A23 + N3F_V3F = 0x2A25 + T2F_C3F_V3F = 0x2A2A + T2F_C4F_N3F_V3F = 0x2A2C + T2F_C4UB_V3F = 0x2A29 + T2F_N3F_V3F = 0x2A2B + T2F_V3F = 0x2A27 + T4F_C4F_N3F_V4F = 0x2A2D + T4F_V4F = 0x2A28 + V2F = 0x2A20 + V3F = 0x2A21 + + MODULATE = 0x2100 + REPLACE = 0x1E01 + + SEPARATE_SPECULAR_COLOR = 0x81FA + SINGLE_COLOR = 0x81F9 + + CONSTANT_ATTENUATION = 0x1207 + LINEAR_ATTENUATION = 0x1208 + POSITION = 0x1203 + QUADRATIC_ATTENUATION = 0x1209 + SPOT_CUTOFF = 0x1206 + SPOT_DIRECTION = 0x1204 + SPOT_EXPONENT = 0x1205 + + COMPILE = 0x1300 + COMPILE_AND_EXECUTE = 0x1301 + + AND = 0x1501 + AND_INVERTED = 0x1504 + AND_REVERSE = 0x1502 + CLEAR = 0x1500 + COPY = 0x1503 + COPY_INVERTED = 0x150C + EQUIV = 0x1509 + INVERT = 0x150A + NAND = 0x150E + NOOP = 0x1505 + NOR = 0x1508 + OR = 0x1507 + OR_INVERTED = 0x150D + OR_REVERSE = 0x150B + SET = 0x150F + XOR = 0x1506 + + MAP_FLUSH_EXPLICIT_BIT = 0x0010 + MAP_INVALIDATE_BUFFER_BIT = 0x0008 + MAP_INVALIDATE_RANGE_BIT = 0x0004 + MAP_READ_BIT = 0x0001 + MAP_UNSYNCHRONIZED_BIT = 0x0020 + MAP_WRITE_BIT = 0x0002 + + COLOR_INDEXES = 0x1603 + SHININESS = 0x1601 + + MODELVIEW = 0x1700 + PROJECTION = 0x1701 + TEXTURE = 0x1702 + + LINE = 0x1B01 + POINT = 0x1B00 + + FILL = 0x1B02 + + COLOR = 0x1800 + DEPTH = 0x1801 + STENCIL = 0x1802 + + ALPHA = 0x1906 + BLUE = 0x1905 + COLOR_INDEX = 0x1900 + DEPTH_COMPONENT = 0x1902 + GREEN = 0x1904 + LUMINANCE = 0x1909 + LUMINANCE_ALPHA = 0x190A + RED = 0x1903 + RGB = 0x1907 + RGBA = 0x1908 + STENCIL_INDEX = 0x1901 + + ALPHA12 = 0x803D + ALPHA16 = 0x803E + ALPHA4 = 0x803B + ALPHA8 = 0x803C + INTENSITY = 0x8049 + INTENSITY12 = 0x804C + INTENSITY16 = 0x804D + INTENSITY4 = 0x804A + INTENSITY8 = 0x804B + LUMINANCE12 = 0x8041 + LUMINANCE12_ALPHA12 = 0x8047 + LUMINANCE12_ALPHA4 = 0x8046 + LUMINANCE16 = 0x8042 + LUMINANCE16_ALPHA16 = 0x8048 + LUMINANCE4 = 0x803F + LUMINANCE4_ALPHA4 = 0x8043 + LUMINANCE6_ALPHA2 = 0x8044 + LUMINANCE8 = 0x8040 + LUMINANCE8_ALPHA8 = 0x8045 + R3_G3_B2 = 0x2A10 + RGB10 = 0x8052 + RGB10_A2 = 0x8059 + RGB12 = 0x8053 + RGB16 = 0x8054 + RGB4 = 0x804F + RGB5 = 0x8050 + RGB5_A1 = 0x8057 + RGB8 = 0x8051 + RGBA12 = 0x805A + RGBA16 = 0x805B + RGBA2 = 0x8055 + RGBA4 = 0x8056 + RGBA8 = 0x8058 + + PACK_IMAGE_HEIGHT = 0x806C + PACK_SKIP_IMAGES = 0x806B + UNPACK_IMAGE_HEIGHT = 0x806E + UNPACK_SKIP_IMAGES = 0x806D + + BITMAP = 0x1A00 + UNSIGNED_BYTE_3_3_2 = 0x8032 + UNSIGNED_INT_10_10_10_2 = 0x8036 + UNSIGNED_INT_8_8_8_8 = 0x8035 + UNSIGNED_SHORT_4_4_4_4 = 0x8033 + UNSIGNED_SHORT_5_5_5_1 = 0x8034 + + POINT_DISTANCE_ATTENUATION = 0x8129 + POINT_FADE_THRESHOLD_SIZE = 0x8128 + POINT_SIZE_MAX = 0x8127 + POINT_SIZE_MIN = 0x8126 + + LINES = 0x0001 + LINES_ADJACENCY = 0x000A + LINE_LOOP = 0x0002 + LINE_STRIP = 0x0003 + LINE_STRIP_ADJACENCY = 0x000B + PATCHES = 0x000E + POINTS = 0x0000 + POLYGON = 0x0009 + QUADS = 0x0007 + QUAD_STRIP = 0x0008 + TRIANGLES = 0x0004 + TRIANGLES_ADJACENCY = 0x000C + TRIANGLE_FAN = 0x0006 + TRIANGLE_STRIP = 0x0005 + TRIANGLE_STRIP_ADJACENCY = 0x000D + + FEEDBACK = 0x1C01 + RENDER = 0x1C00 + SELECT = 0x1C02 + + FLAT = 0x1D00 + SMOOTH = 0x1D01 + + DECR = 0x1E03 + INCR = 0x1E02 + KEEP = 0x1E00 + + EXTENSIONS = 0x1F03 + RENDERER = 0x1F01 + VENDOR = 0x1F00 + VERSION = 0x1F02 + + S = 0x2000 + T = 0x2001 + R = 0x2002 + Q = 0x2003 + + DECAL = 0x2101 + + TEXTURE_ENV_COLOR = 0x2201 + TEXTURE_ENV_MODE = 0x2200 + + TEXTURE_ENV = 0x2300 + + EYE_LINEAR = 0x2400 + OBJECT_LINEAR = 0x2401 + SPHERE_MAP = 0x2402 + + EYE_PLANE = 0x2502 + OBJECT_PLANE = 0x2501 + TEXTURE_GEN_MODE = 0x2500 + + NEAREST = 0x2600 + + LINEAR_MIPMAP_LINEAR = 0x2703 + LINEAR_MIPMAP_NEAREST = 0x2701 + NEAREST_MIPMAP_LINEAR = 0x2702 + NEAREST_MIPMAP_NEAREST = 0x2700 + + GENERATE_MIPMAP = 0x8191 + TEXTURE_WRAP_R = 0x8072 + + PROXY_TEXTURE_1D = 0x8063 + PROXY_TEXTURE_2D = 0x8064 + PROXY_TEXTURE_3D = 0x8070 + TEXTURE_3D = 0x806F + TEXTURE_BASE_LEVEL = 0x813C + TEXTURE_MAX_LEVEL = 0x813D + TEXTURE_MAX_LOD = 0x813B + TEXTURE_MIN_LOD = 0x813A + + CLAMP = 0x2900 + CLAMP_TO_BORDER = 0x812D + CLAMP_TO_EDGE = 0x812F + REPEAT = 0x2901 + + SYNC_FLUSH_COMMANDS_BIT = 0x00000001 + INVALID_INDEX = 0xFFFFFFFF + TIMEOUT_IGNORED = 0xFFFFFFFFFFFFFFFF + CONSTANT_COLOR = 0x8001 + ONE_MINUS_CONSTANT_COLOR = 0x8002 + CONSTANT_ALPHA = 0x8003 + ONE_MINUS_CONSTANT_ALPHA = 0x8004 + FUNC_ADD = 0x8006 + MIN = 0x8007 + MAX = 0x8008 + BLEND_EQUATION_RGB = 0x8009 + FUNC_SUBTRACT = 0x800A + FUNC_REVERSE_SUBTRACT = 0x800B + RESCALE_NORMAL = 0x803A + TEXTURE_DEPTH = 0x8071 + MAX_3D_TEXTURE_SIZE = 0x8073 + MULTISAMPLE = 0x809D + SAMPLE_ALPHA_TO_COVERAGE = 0x809E + SAMPLE_ALPHA_TO_ONE = 0x809F + SAMPLE_COVERAGE = 0x80A0 + SAMPLE_BUFFERS = 0x80A8 + SAMPLES = 0x80A9 + SAMPLE_COVERAGE_VALUE = 0x80AA + SAMPLE_COVERAGE_INVERT = 0x80AB + BLEND_DST_RGB = 0x80C8 + BLEND_SRC_RGB = 0x80C9 + BLEND_DST_ALPHA = 0x80CA + BLEND_SRC_ALPHA = 0x80CB + BGR = 0x80E0 + BGRA = 0x80E1 + MAX_ELEMENTS_VERTICES = 0x80E8 + MAX_ELEMENTS_INDICES = 0x80E9 + DEPTH_COMPONENT16 = 0x81A5 + DEPTH_COMPONENT24 = 0x81A6 + DEPTH_COMPONENT32 = 0x81A7 + FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210 + FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211 + FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212 + FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213 + FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214 + FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215 + FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216 + FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217 + FRAMEBUFFER_DEFAULT = 0x8218 + FRAMEBUFFER_UNDEFINED = 0x8219 + DEPTH_STENCIL_ATTACHMENT = 0x821A + MAJOR_VERSION = 0x821B + MINOR_VERSION = 0x821C + NUM_EXTENSIONS = 0x821D + CONTEXT_FLAGS = 0x821E + COMPRESSED_RED = 0x8225 + COMPRESSED_RG = 0x8226 + RG = 0x8227 + RG_INTEGER = 0x8228 + R8 = 0x8229 + R16 = 0x822A + RG8 = 0x822B + RG16 = 0x822C + R16F = 0x822D + R32F = 0x822E + RG16F = 0x822F + RG32F = 0x8230 + R8I = 0x8231 + R8UI = 0x8232 + R16I = 0x8233 + R16UI = 0x8234 + R32I = 0x8235 + R32UI = 0x8236 + RG8I = 0x8237 + RG8UI = 0x8238 + RG16I = 0x8239 + RG16UI = 0x823A + RG32I = 0x823B + RG32UI = 0x823C + UNSIGNED_BYTE_2_3_3_REV = 0x8362 + UNSIGNED_SHORT_5_6_5 = 0x8363 + UNSIGNED_SHORT_5_6_5_REV = 0x8364 + UNSIGNED_SHORT_4_4_4_4_REV = 0x8365 + UNSIGNED_SHORT_1_5_5_5_REV = 0x8366 + UNSIGNED_INT_8_8_8_8_REV = 0x8367 + UNSIGNED_INT_2_10_10_10_REV = 0x8368 + MIRRORED_REPEAT = 0x8370 + FOG_COORDINATE_SOURCE = 0x8450 + FOG_COORD_SRC = 0x8450 + FOG_COORDINATE = 0x8451 + FOG_COORD = 0x8451 + FRAGMENT_DEPTH = 0x8452 + CURRENT_FOG_COORDINATE = 0x8453 + CURRENT_FOG_COORD = 0x8453 + FOG_COORDINATE_ARRAY_TYPE = 0x8454 + FOG_COORD_ARRAY_TYPE = 0x8454 + FOG_COORDINATE_ARRAY_STRIDE = 0x8455 + FOG_COORD_ARRAY_STRIDE = 0x8455 + FOG_COORDINATE_ARRAY_POINTER = 0x8456 + FOG_COORD_ARRAY_POINTER = 0x8456 + FOG_COORDINATE_ARRAY = 0x8457 + FOG_COORD_ARRAY = 0x8457 + COLOR_SUM = 0x8458 + CURRENT_SECONDARY_COLOR = 0x8459 + SECONDARY_COLOR_ARRAY_SIZE = 0x845A + SECONDARY_COLOR_ARRAY_TYPE = 0x845B + SECONDARY_COLOR_ARRAY_STRIDE = 0x845C + SECONDARY_COLOR_ARRAY_POINTER = 0x845D + SECONDARY_COLOR_ARRAY = 0x845E + CURRENT_RASTER_SECONDARY_COLOR = 0x845F + TEXTURE0 = 0x84C0 + TEXTURE1 = 0x84C1 + TEXTURE2 = 0x84C2 + TEXTURE3 = 0x84C3 + TEXTURE4 = 0x84C4 + TEXTURE5 = 0x84C5 + TEXTURE6 = 0x84C6 + TEXTURE7 = 0x84C7 + TEXTURE8 = 0x84C8 + TEXTURE9 = 0x84C9 + TEXTURE10 = 0x84CA + TEXTURE11 = 0x84CB + TEXTURE12 = 0x84CC + TEXTURE13 = 0x84CD + TEXTURE14 = 0x84CE + TEXTURE15 = 0x84CF + TEXTURE16 = 0x84D0 + TEXTURE17 = 0x84D1 + TEXTURE18 = 0x84D2 + TEXTURE19 = 0x84D3 + TEXTURE20 = 0x84D4 + TEXTURE21 = 0x84D5 + TEXTURE22 = 0x84D6 + TEXTURE23 = 0x84D7 + TEXTURE24 = 0x84D8 + TEXTURE25 = 0x84D9 + TEXTURE26 = 0x84DA + TEXTURE27 = 0x84DB + TEXTURE28 = 0x84DC + TEXTURE29 = 0x84DD + TEXTURE30 = 0x84DE + TEXTURE31 = 0x84DF + ACTIVE_TEXTURE = 0x84E0 + CLIENT_ACTIVE_TEXTURE = 0x84E1 + MAX_TEXTURE_UNITS = 0x84E2 + TRANSPOSE_MODELVIEW_MATRIX = 0x84E3 + TRANSPOSE_PROJECTION_MATRIX = 0x84E4 + TRANSPOSE_TEXTURE_MATRIX = 0x84E5 + TRANSPOSE_COLOR_MATRIX = 0x84E6 + SUBTRACT = 0x84E7 + MAX_RENDERBUFFER_SIZE = 0x84E8 + COMPRESSED_ALPHA = 0x84E9 + COMPRESSED_LUMINANCE = 0x84EA + COMPRESSED_LUMINANCE_ALPHA = 0x84EB + COMPRESSED_INTENSITY = 0x84EC + COMPRESSED_RGB = 0x84ED + COMPRESSED_RGBA = 0x84EE + UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER = 0x84F0 + UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x84F1 + TEXTURE_RECTANGLE = 0x84F5 + TEXTURE_BINDING_RECTANGLE = 0x84F6 + PROXY_TEXTURE_RECTANGLE = 0x84F7 + MAX_RECTANGLE_TEXTURE_SIZE = 0x84F8 + DEPTH_STENCIL = 0x84F9 + UNSIGNED_INT_24_8 = 0x84FA + MAX_TEXTURE_LOD_BIAS = 0x84FD + TEXTURE_FILTER_CONTROL = 0x8500 + TEXTURE_LOD_BIAS = 0x8501 + INCR_WRAP = 0x8507 + DECR_WRAP = 0x8508 + NORMAL_MAP = 0x8511 + REFLECTION_MAP = 0x8512 + TEXTURE_CUBE_MAP = 0x8513 + TEXTURE_BINDING_CUBE_MAP = 0x8514 + TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515 + TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516 + TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517 + TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518 + TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519 + TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A + PROXY_TEXTURE_CUBE_MAP = 0x851B + MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C + COMBINE = 0x8570 + COMBINE_RGB = 0x8571 + COMBINE_ALPHA = 0x8572 + RGB_SCALE = 0x8573 + ADD_SIGNED = 0x8574 + INTERPOLATE = 0x8575 + CONSTANT = 0x8576 + PRIMARY_COLOR = 0x8577 + PREVIOUS = 0x8578 + SOURCE0_RGB = 0x8580 + SRC0_RGB = 0x8580 + SOURCE1_RGB = 0x8581 + SRC1_RGB = 0x8581 + SOURCE2_RGB = 0x8582 + SRC2_RGB = 0x8582 + SOURCE0_ALPHA = 0x8588 + SRC0_ALPHA = 0x8588 + SOURCE1_ALPHA = 0x8589 + SRC1_ALPHA = 0x8589 + SOURCE2_ALPHA = 0x858A + SRC2_ALPHA = 0x858A + OPERAND0_RGB = 0x8590 + OPERAND1_RGB = 0x8591 + OPERAND2_RGB = 0x8592 + OPERAND0_ALPHA = 0x8598 + OPERAND1_ALPHA = 0x8599 + OPERAND2_ALPHA = 0x859A + VERTEX_ARRAY_BINDING = 0x85B5 + VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622 + VERTEX_ATTRIB_ARRAY_SIZE = 0x8623 + VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624 + VERTEX_ATTRIB_ARRAY_TYPE = 0x8625 + CURRENT_VERTEX_ATTRIB = 0x8626 + VERTEX_PROGRAM_POINT_SIZE = 0x8642 + PROGRAM_POINT_SIZE = 0x8642 + VERTEX_PROGRAM_TWO_SIDE = 0x8643 + VERTEX_ATTRIB_ARRAY_POINTER = 0x8645 + DEPTH_CLAMP = 0x864F + TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0 + TEXTURE_COMPRESSED = 0x86A1 + NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2 + COMPRESSED_TEXTURE_FORMATS = 0x86A3 + DOT3_RGB = 0x86AE + DOT3_RGBA = 0x86AF + BUFFER_SIZE = 0x8764 + BUFFER_USAGE = 0x8765 + STENCIL_BACK_FUNC = 0x8800 + STENCIL_BACK_FAIL = 0x8801 + STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802 + STENCIL_BACK_PASS_DEPTH_PASS = 0x8803 + RGBA32F = 0x8814 + RGB32F = 0x8815 + RGBA16F = 0x881A + RGB16F = 0x881B + MAX_DRAW_BUFFERS = 0x8824 + DRAW_BUFFER0 = 0x8825 + DRAW_BUFFER1 = 0x8826 + DRAW_BUFFER2 = 0x8827 + DRAW_BUFFER3 = 0x8828 + DRAW_BUFFER4 = 0x8829 + DRAW_BUFFER5 = 0x882A + DRAW_BUFFER6 = 0x882B + DRAW_BUFFER7 = 0x882C + DRAW_BUFFER8 = 0x882D + DRAW_BUFFER9 = 0x882E + DRAW_BUFFER10 = 0x882F + DRAW_BUFFER11 = 0x8830 + DRAW_BUFFER12 = 0x8831 + DRAW_BUFFER13 = 0x8832 + DRAW_BUFFER14 = 0x8833 + DRAW_BUFFER15 = 0x8834 + BLEND_EQUATION_ALPHA = 0x883D + TEXTURE_DEPTH_SIZE = 0x884A + DEPTH_TEXTURE_MODE = 0x884B + TEXTURE_COMPARE_MODE = 0x884C + TEXTURE_COMPARE_FUNC = 0x884D + COMPARE_R_TO_TEXTURE = 0x884E + COMPARE_REF_TO_TEXTURE = 0x884E + TEXTURE_CUBE_MAP_SEAMLESS = 0x884F + POINT_SPRITE = 0x8861 + COORD_REPLACE = 0x8862 + QUERY_COUNTER_BITS = 0x8864 + CURRENT_QUERY = 0x8865 + QUERY_RESULT = 0x8866 + QUERY_RESULT_AVAILABLE = 0x8867 + MAX_VERTEX_ATTRIBS = 0x8869 + VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A + MAX_TESS_CONTROL_INPUT_COMPONENTS = 0x886C + MAX_TESS_EVALUATION_INPUT_COMPONENTS = 0x886D + MAX_TEXTURE_COORDS = 0x8871 + MAX_TEXTURE_IMAGE_UNITS = 0x8872 + GEOMETRY_SHADER_INVOCATIONS = 0x887F + ARRAY_BUFFER = 0x8892 + ELEMENT_ARRAY_BUFFER = 0x8893 + ARRAY_BUFFER_BINDING = 0x8894 + ELEMENT_ARRAY_BUFFER_BINDING = 0x8895 + VERTEX_ARRAY_BUFFER_BINDING = 0x8896 + NORMAL_ARRAY_BUFFER_BINDING = 0x8897 + COLOR_ARRAY_BUFFER_BINDING = 0x8898 + INDEX_ARRAY_BUFFER_BINDING = 0x8899 + TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A + EDGE_FLAG_ARRAY_BUFFER_BINDING = 0x889B + SECONDARY_COLOR_ARRAY_BUFFER_BINDING = 0x889C + FOG_COORDINATE_ARRAY_BUFFER_BINDING = 0x889D + FOG_COORD_ARRAY_BUFFER_BINDING = 0x889D + WEIGHT_ARRAY_BUFFER_BINDING = 0x889E + VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F + READ_ONLY = 0x88B8 + WRITE_ONLY = 0x88B9 + READ_WRITE = 0x88BA + BUFFER_ACCESS = 0x88BB + BUFFER_MAPPED = 0x88BC + BUFFER_MAP_POINTER = 0x88BD + TIME_ELAPSED = 0x88BF + STREAM_DRAW = 0x88E0 + STREAM_READ = 0x88E1 + STREAM_COPY = 0x88E2 + STATIC_DRAW = 0x88E4 + STATIC_READ = 0x88E5 + STATIC_COPY = 0x88E6 + DYNAMIC_DRAW = 0x88E8 + DYNAMIC_READ = 0x88E9 + DYNAMIC_COPY = 0x88EA + PIXEL_PACK_BUFFER = 0x88EB + PIXEL_UNPACK_BUFFER = 0x88EC + PIXEL_PACK_BUFFER_BINDING = 0x88ED + PIXEL_UNPACK_BUFFER_BINDING = 0x88EF + DEPTH24_STENCIL8 = 0x88F0 + TEXTURE_STENCIL_SIZE = 0x88F1 + SRC1_COLOR = 0x88F9 + ONE_MINUS_SRC1_COLOR = 0x88FA + ONE_MINUS_SRC1_ALPHA = 0x88FB + MAX_DUAL_SOURCE_DRAW_BUFFERS = 0x88FC + VERTEX_ATTRIB_ARRAY_INTEGER = 0x88FD + VERTEX_ATTRIB_ARRAY_DIVISOR = 0x88FE + MAX_ARRAY_TEXTURE_LAYERS = 0x88FF + MIN_PROGRAM_TEXEL_OFFSET = 0x8904 + MAX_PROGRAM_TEXEL_OFFSET = 0x8905 + SAMPLES_PASSED = 0x8914 + GEOMETRY_VERTICES_OUT = 0x8916 + GEOMETRY_INPUT_TYPE = 0x8917 + GEOMETRY_OUTPUT_TYPE = 0x8918 + SAMPLER_BINDING = 0x8919 + CLAMP_VERTEX_COLOR = 0x891A + CLAMP_FRAGMENT_COLOR = 0x891B + CLAMP_READ_COLOR = 0x891C + FIXED_ONLY = 0x891D + UNIFORM_BUFFER = 0x8A11 + UNIFORM_BUFFER_BINDING = 0x8A28 + UNIFORM_BUFFER_START = 0x8A29 + UNIFORM_BUFFER_SIZE = 0x8A2A + MAX_VERTEX_UNIFORM_BLOCKS = 0x8A2B + MAX_GEOMETRY_UNIFORM_BLOCKS = 0x8A2C + MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8A2D + MAX_COMBINED_UNIFORM_BLOCKS = 0x8A2E + MAX_UNIFORM_BUFFER_BINDINGS = 0x8A2F + MAX_UNIFORM_BLOCK_SIZE = 0x8A30 + MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31 + MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 0x8A32 + MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33 + UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8A34 + ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35 + ACTIVE_UNIFORM_BLOCKS = 0x8A36 + UNIFORM_TYPE = 0x8A37 + UNIFORM_SIZE = 0x8A38 + UNIFORM_NAME_LENGTH = 0x8A39 + UNIFORM_BLOCK_INDEX = 0x8A3A + UNIFORM_OFFSET = 0x8A3B + UNIFORM_ARRAY_STRIDE = 0x8A3C + UNIFORM_MATRIX_STRIDE = 0x8A3D + UNIFORM_IS_ROW_MAJOR = 0x8A3E + UNIFORM_BLOCK_BINDING = 0x8A3F + UNIFORM_BLOCK_DATA_SIZE = 0x8A40 + UNIFORM_BLOCK_NAME_LENGTH = 0x8A41 + UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8A42 + UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43 + UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44 + UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 0x8A45 + UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46 + FRAGMENT_SHADER = 0x8B30 + VERTEX_SHADER = 0x8B31 + MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49 + MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A + MAX_VARYING_FLOATS = 0x8B4B + MAX_VARYING_COMPONENTS = 0x8B4B + MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C + MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D + SHADER_TYPE = 0x8B4F + FLOAT_VEC2 = 0x8B50 + FLOAT_VEC3 = 0x8B51 + FLOAT_VEC4 = 0x8B52 + INT_VEC2 = 0x8B53 + INT_VEC3 = 0x8B54 + INT_VEC4 = 0x8B55 + BOOL = 0x8B56 + BOOL_VEC2 = 0x8B57 + BOOL_VEC3 = 0x8B58 + BOOL_VEC4 = 0x8B59 + FLOAT_MAT2 = 0x8B5A + FLOAT_MAT3 = 0x8B5B + FLOAT_MAT4 = 0x8B5C + SAMPLER_1D = 0x8B5D + SAMPLER_2D = 0x8B5E + SAMPLER_3D = 0x8B5F + SAMPLER_CUBE = 0x8B60 + SAMPLER_1D_SHADOW = 0x8B61 + SAMPLER_2D_SHADOW = 0x8B62 + SAMPLER_2D_RECT = 0x8B63 + SAMPLER_2D_RECT_SHADOW = 0x8B64 + FLOAT_MAT2x3 = 0x8B65 + FLOAT_MAT2x4 = 0x8B66 + FLOAT_MAT3x2 = 0x8B67 + FLOAT_MAT3x4 = 0x8B68 + FLOAT_MAT4x2 = 0x8B69 + FLOAT_MAT4x3 = 0x8B6A + DELETE_STATUS = 0x8B80 + COMPILE_STATUS = 0x8B81 + LINK_STATUS = 0x8B82 + VALIDATE_STATUS = 0x8B83 + INFO_LOG_LENGTH = 0x8B84 + ATTACHED_SHADERS = 0x8B85 + ACTIVE_UNIFORMS = 0x8B86 + ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87 + SHADER_SOURCE_LENGTH = 0x8B88 + ACTIVE_ATTRIBUTES = 0x8B89 + ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A + SHADING_LANGUAGE_VERSION = 0x8B8C + CURRENT_PROGRAM = 0x8B8D + TEXTURE_RED_TYPE = 0x8C10 + TEXTURE_GREEN_TYPE = 0x8C11 + TEXTURE_BLUE_TYPE = 0x8C12 + TEXTURE_ALPHA_TYPE = 0x8C13 + TEXTURE_DEPTH_TYPE = 0x8C16 + UNSIGNED_NORMALIZED = 0x8C17 + TEXTURE_1D_ARRAY = 0x8C18 + PROXY_TEXTURE_1D_ARRAY = 0x8C19 + TEXTURE_2D_ARRAY = 0x8C1A + PROXY_TEXTURE_2D_ARRAY = 0x8C1B + TEXTURE_BINDING_1D_ARRAY = 0x8C1C + TEXTURE_BINDING_2D_ARRAY = 0x8C1D + MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = 0x8C29 + TEXTURE_BUFFER = 0x8C2A + MAX_TEXTURE_BUFFER_SIZE = 0x8C2B + TEXTURE_BINDING_BUFFER = 0x8C2C + TEXTURE_BUFFER_DATA_STORE_BINDING = 0x8C2D + ANY_SAMPLES_PASSED = 0x8C2F + SAMPLE_SHADING = 0x8C36 + MIN_SAMPLE_SHADING_VALUE = 0x8C37 + R11F_G11F_B10F = 0x8C3A + UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B + RGB9_E5 = 0x8C3D + UNSIGNED_INT_5_9_9_9_REV = 0x8C3E + TEXTURE_SHARED_SIZE = 0x8C3F + SRGB = 0x8C40 + SRGB8 = 0x8C41 + SRGB_ALPHA = 0x8C42 + SRGB8_ALPHA8 = 0x8C43 + SLUMINANCE_ALPHA = 0x8C44 + SLUMINANCE8_ALPHA8 = 0x8C45 + SLUMINANCE = 0x8C46 + SLUMINANCE8 = 0x8C47 + COMPRESSED_SRGB = 0x8C48 + COMPRESSED_SRGB_ALPHA = 0x8C49 + COMPRESSED_SLUMINANCE = 0x8C4A + COMPRESSED_SLUMINANCE_ALPHA = 0x8C4B + TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76 + TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F + MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80 + TRANSFORM_FEEDBACK_VARYINGS = 0x8C83 + TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84 + TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85 + PRIMITIVES_GENERATED = 0x8C87 + TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88 + RASTERIZER_DISCARD = 0x8C89 + MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A + MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B + INTERLEAVED_ATTRIBS = 0x8C8C + SEPARATE_ATTRIBS = 0x8C8D + TRANSFORM_FEEDBACK_BUFFER = 0x8C8E + TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F + POINT_SPRITE_COORD_ORIGIN = 0x8CA0 + LOWER_LEFT = 0x8CA1 + UPPER_LEFT = 0x8CA2 + STENCIL_BACK_REF = 0x8CA3 + STENCIL_BACK_VALUE_MASK = 0x8CA4 + STENCIL_BACK_WRITEMASK = 0x8CA5 + DRAW_FRAMEBUFFER_BINDING = 0x8CA6 + FRAMEBUFFER_BINDING = 0x8CA6 + RENDERBUFFER_BINDING = 0x8CA7 + READ_FRAMEBUFFER = 0x8CA8 + DRAW_FRAMEBUFFER = 0x8CA9 + READ_FRAMEBUFFER_BINDING = 0x8CAA + RENDERBUFFER_SAMPLES = 0x8CAB + DEPTH_COMPONENT32F = 0x8CAC + DEPTH32F_STENCIL8 = 0x8CAD + FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0 + FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1 + FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2 + FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3 + FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4 + FRAMEBUFFER_COMPLETE = 0x8CD5 + FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6 + FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7 + FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB + FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC + FRAMEBUFFER_UNSUPPORTED = 0x8CDD + MAX_COLOR_ATTACHMENTS = 0x8CDF + COLOR_ATTACHMENT0 = 0x8CE0 + COLOR_ATTACHMENT1 = 0x8CE1 + COLOR_ATTACHMENT2 = 0x8CE2 + COLOR_ATTACHMENT3 = 0x8CE3 + COLOR_ATTACHMENT4 = 0x8CE4 + COLOR_ATTACHMENT5 = 0x8CE5 + COLOR_ATTACHMENT6 = 0x8CE6 + COLOR_ATTACHMENT7 = 0x8CE7 + COLOR_ATTACHMENT8 = 0x8CE8 + COLOR_ATTACHMENT9 = 0x8CE9 + COLOR_ATTACHMENT10 = 0x8CEA + COLOR_ATTACHMENT11 = 0x8CEB + COLOR_ATTACHMENT12 = 0x8CEC + COLOR_ATTACHMENT13 = 0x8CED + COLOR_ATTACHMENT14 = 0x8CEE + COLOR_ATTACHMENT15 = 0x8CEF + DEPTH_ATTACHMENT = 0x8D00 + STENCIL_ATTACHMENT = 0x8D20 + FRAMEBUFFER = 0x8D40 + RENDERBUFFER = 0x8D41 + RENDERBUFFER_WIDTH = 0x8D42 + RENDERBUFFER_HEIGHT = 0x8D43 + RENDERBUFFER_INTERNAL_FORMAT = 0x8D44 + STENCIL_INDEX1 = 0x8D46 + STENCIL_INDEX4 = 0x8D47 + STENCIL_INDEX8 = 0x8D48 + STENCIL_INDEX16 = 0x8D49 + RENDERBUFFER_RED_SIZE = 0x8D50 + RENDERBUFFER_GREEN_SIZE = 0x8D51 + RENDERBUFFER_BLUE_SIZE = 0x8D52 + RENDERBUFFER_ALPHA_SIZE = 0x8D53 + RENDERBUFFER_DEPTH_SIZE = 0x8D54 + RENDERBUFFER_STENCIL_SIZE = 0x8D55 + FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56 + MAX_SAMPLES = 0x8D57 + RGBA32UI = 0x8D70 + RGB32UI = 0x8D71 + RGBA16UI = 0x8D76 + RGB16UI = 0x8D77 + RGBA8UI = 0x8D7C + RGB8UI = 0x8D7D + RGBA32I = 0x8D82 + RGB32I = 0x8D83 + RGBA16I = 0x8D88 + RGB16I = 0x8D89 + RGBA8I = 0x8D8E + RGB8I = 0x8D8F + RED_INTEGER = 0x8D94 + GREEN_INTEGER = 0x8D95 + BLUE_INTEGER = 0x8D96 + ALPHA_INTEGER = 0x8D97 + RGB_INTEGER = 0x8D98 + RGBA_INTEGER = 0x8D99 + BGR_INTEGER = 0x8D9A + BGRA_INTEGER = 0x8D9B + INT_2_10_10_10_REV = 0x8D9F + FRAMEBUFFER_ATTACHMENT_LAYERED = 0x8DA7 + FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = 0x8DA8 + FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD + FRAMEBUFFER_SRGB = 0x8DB9 + COMPRESSED_RED_RGTC1 = 0x8DBB + COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC + COMPRESSED_RG_RGTC2 = 0x8DBD + COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE + SAMPLER_1D_ARRAY = 0x8DC0 + SAMPLER_2D_ARRAY = 0x8DC1 + SAMPLER_BUFFER = 0x8DC2 + SAMPLER_1D_ARRAY_SHADOW = 0x8DC3 + SAMPLER_2D_ARRAY_SHADOW = 0x8DC4 + SAMPLER_CUBE_SHADOW = 0x8DC5 + UNSIGNED_INT_VEC2 = 0x8DC6 + UNSIGNED_INT_VEC3 = 0x8DC7 + UNSIGNED_INT_VEC4 = 0x8DC8 + INT_SAMPLER_1D = 0x8DC9 + INT_SAMPLER_2D = 0x8DCA + INT_SAMPLER_3D = 0x8DCB + INT_SAMPLER_CUBE = 0x8DCC + INT_SAMPLER_2D_RECT = 0x8DCD + INT_SAMPLER_1D_ARRAY = 0x8DCE + INT_SAMPLER_2D_ARRAY = 0x8DCF + INT_SAMPLER_BUFFER = 0x8DD0 + UNSIGNED_INT_SAMPLER_1D = 0x8DD1 + UNSIGNED_INT_SAMPLER_2D = 0x8DD2 + UNSIGNED_INT_SAMPLER_3D = 0x8DD3 + UNSIGNED_INT_SAMPLER_CUBE = 0x8DD4 + UNSIGNED_INT_SAMPLER_2D_RECT = 0x8DD5 + UNSIGNED_INT_SAMPLER_1D_ARRAY = 0x8DD6 + UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8DD7 + UNSIGNED_INT_SAMPLER_BUFFER = 0x8DD8 + GEOMETRY_SHADER = 0x8DD9 + MAX_GEOMETRY_UNIFORM_COMPONENTS = 0x8DDF + MAX_GEOMETRY_OUTPUT_VERTICES = 0x8DE0 + MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = 0x8DE1 + ACTIVE_SUBROUTINES = 0x8DE5 + ACTIVE_SUBROUTINE_UNIFORMS = 0x8DE6 + MAX_SUBROUTINES = 0x8DE7 + MAX_SUBROUTINE_UNIFORM_LOCATIONS = 0x8DE8 + QUERY_WAIT = 0x8E13 + QUERY_NO_WAIT = 0x8E14 + QUERY_BY_REGION_WAIT = 0x8E15 + QUERY_BY_REGION_NO_WAIT = 0x8E16 + MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E1E + MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E1F + TRANSFORM_FEEDBACK = 0x8E22 + TRANSFORM_FEEDBACK_BUFFER_PAUSED = 0x8E23 + TRANSFORM_FEEDBACK_BUFFER_ACTIVE = 0x8E24 + TRANSFORM_FEEDBACK_BINDING = 0x8E25 + TIMESTAMP = 0x8E28 + TEXTURE_SWIZZLE_R = 0x8E42 + TEXTURE_SWIZZLE_G = 0x8E43 + TEXTURE_SWIZZLE_B = 0x8E44 + TEXTURE_SWIZZLE_A = 0x8E45 + TEXTURE_SWIZZLE_RGBA = 0x8E46 + ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS = 0x8E47 + ACTIVE_SUBROUTINE_MAX_LENGTH = 0x8E48 + ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH = 0x8E49 + NUM_COMPATIBLE_SUBROUTINES = 0x8E4A + COMPATIBLE_SUBROUTINES = 0x8E4B + QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = 0x8E4C + FIRST_VERTEX_CONVENTION = 0x8E4D + LAST_VERTEX_CONVENTION = 0x8E4E + PROVOKING_VERTEX = 0x8E4F + SAMPLE_POSITION = 0x8E50 + SAMPLE_MASK = 0x8E51 + SAMPLE_MASK_VALUE = 0x8E52 + MAX_SAMPLE_MASK_WORDS = 0x8E59 + MAX_GEOMETRY_SHADER_INVOCATIONS = 0x8E5A + MIN_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5B + MAX_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5C + FRAGMENT_INTERPOLATION_OFFSET_BITS = 0x8E5D + MIN_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5E + MAX_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5F + MAX_TRANSFORM_FEEDBACK_BUFFERS = 0x8E70 + MAX_VERTEX_STREAMS = 0x8E71 + PATCH_VERTICES = 0x8E72 + PATCH_DEFAULT_INNER_LEVEL = 0x8E73 + PATCH_DEFAULT_OUTER_LEVEL = 0x8E74 + TESS_CONTROL_OUTPUT_VERTICES = 0x8E75 + TESS_GEN_MODE = 0x8E76 + TESS_GEN_SPACING = 0x8E77 + TESS_GEN_VERTEX_ORDER = 0x8E78 + TESS_GEN_POINT_MODE = 0x8E79 + ISOLINES = 0x8E7A + FRACTIONAL_ODD = 0x8E7B + FRACTIONAL_EVEN = 0x8E7C + MAX_PATCH_VERTICES = 0x8E7D + MAX_TESS_GEN_LEVEL = 0x8E7E + MAX_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E7F + MAX_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E80 + MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS = 0x8E81 + MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS = 0x8E82 + MAX_TESS_CONTROL_OUTPUT_COMPONENTS = 0x8E83 + MAX_TESS_PATCH_COMPONENTS = 0x8E84 + MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS = 0x8E85 + MAX_TESS_EVALUATION_OUTPUT_COMPONENTS = 0x8E86 + TESS_EVALUATION_SHADER = 0x8E87 + TESS_CONTROL_SHADER = 0x8E88 + MAX_TESS_CONTROL_UNIFORM_BLOCKS = 0x8E89 + MAX_TESS_EVALUATION_UNIFORM_BLOCKS = 0x8E8A + COPY_READ_BUFFER = 0x8F36 + COPY_WRITE_BUFFER = 0x8F37 + DRAW_INDIRECT_BUFFER = 0x8F3F + DRAW_INDIRECT_BUFFER_BINDING = 0x8F43 + DOUBLE_MAT2 = 0x8F46 + DOUBLE_MAT3 = 0x8F47 + DOUBLE_MAT4 = 0x8F48 + DOUBLE_MAT2x3 = 0x8F49 + DOUBLE_MAT2x4 = 0x8F4A + DOUBLE_MAT3x2 = 0x8F4B + DOUBLE_MAT3x4 = 0x8F4C + DOUBLE_MAT4x2 = 0x8F4D + DOUBLE_MAT4x3 = 0x8F4E + R8_SNORM = 0x8F94 + RG8_SNORM = 0x8F95 + RGB8_SNORM = 0x8F96 + RGBA8_SNORM = 0x8F97 + R16_SNORM = 0x8F98 + RG16_SNORM = 0x8F99 + RGB16_SNORM = 0x8F9A + RGBA16_SNORM = 0x8F9B + SIGNED_NORMALIZED = 0x8F9C + PRIMITIVE_RESTART = 0x8F9D + PRIMITIVE_RESTART_INDEX = 0x8F9E + DOUBLE_VEC2 = 0x8FFC + DOUBLE_VEC3 = 0x8FFD + DOUBLE_VEC4 = 0x8FFE + TEXTURE_CUBE_MAP_ARRAY = 0x9009 + TEXTURE_BINDING_CUBE_MAP_ARRAY = 0x900A + PROXY_TEXTURE_CUBE_MAP_ARRAY = 0x900B + SAMPLER_CUBE_MAP_ARRAY = 0x900C + SAMPLER_CUBE_MAP_ARRAY_SHADOW = 0x900D + INT_SAMPLER_CUBE_MAP_ARRAY = 0x900E + UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY = 0x900F + RGB10_A2UI = 0x906F + TEXTURE_2D_MULTISAMPLE = 0x9100 + PROXY_TEXTURE_2D_MULTISAMPLE = 0x9101 + TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9102 + PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9103 + TEXTURE_BINDING_2D_MULTISAMPLE = 0x9104 + TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = 0x9105 + TEXTURE_SAMPLES = 0x9106 + TEXTURE_FIXED_SAMPLE_LOCATIONS = 0x9107 + SAMPLER_2D_MULTISAMPLE = 0x9108 + INT_SAMPLER_2D_MULTISAMPLE = 0x9109 + UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = 0x910A + SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910B + INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910C + UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910D + MAX_COLOR_TEXTURE_SAMPLES = 0x910E + MAX_DEPTH_TEXTURE_SAMPLES = 0x910F + MAX_INTEGER_SAMPLES = 0x9110 + MAX_SERVER_WAIT_TIMEOUT = 0x9111 + OBJECT_TYPE = 0x9112 + SYNC_CONDITION = 0x9113 + SYNC_STATUS = 0x9114 + SYNC_FLAGS = 0x9115 + SYNC_FENCE = 0x9116 + SYNC_GPU_COMMANDS_COMPLETE = 0x9117 + UNSIGNALED = 0x9118 + SIGNALED = 0x9119 + ALREADY_SIGNALED = 0x911A + TIMEOUT_EXPIRED = 0x911B + CONDITION_SATISFIED = 0x911C + WAIT_FAILED = 0x911D + BUFFER_ACCESS_FLAGS = 0x911F + BUFFER_MAP_LENGTH = 0x9120 + BUFFER_MAP_OFFSET = 0x9121 + MAX_VERTEX_OUTPUT_COMPONENTS = 0x9122 + MAX_GEOMETRY_INPUT_COMPONENTS = 0x9123 + MAX_GEOMETRY_OUTPUT_COMPONENTS = 0x9124 + MAX_FRAGMENT_INPUT_COMPONENTS = 0x9125 + CONTEXT_PROFILE_MASK = 0x9126 +) + +// https://www.opengl.org/sdk/docs/man4/xhtml/glViewport.xml +func (gl *GL) Viewport(x, y, width, height int) { + C.gl4_0core_glViewport(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// DepthRange specifies the mapping of depth values from normalized device +// coordinates to window coordinates. +// +// Parameter nearVal specifies the mapping of the near clipping plane to window +// coordinates (defaults to 0), while farVal specifies the mapping of the far +// clipping plane to window coordinates (defaults to 1). +// +// After clipping and division by w, depth coordinates range from -1 to 1, +// corresponding to the near and far clipping planes. DepthRange specifies a +// linear mapping of the normalized depth coordinates in this range to window +// depth coordinates. Regardless of the actual depth buffer implementation, +// window coordinate depth values are treated as though they range from 0 through 1 +// (like color components). Thus, the values accepted by DepthRange are both +// clamped to this range before they are accepted. +// +// The default setting of (0, 1) maps the near plane to 0 and the far plane to 1. +// With this mapping, the depth buffer range is fully utilized. +// +// It is not necessary that nearVal be less than farVal. Reverse mappings such as +// nearVal 1, and farVal 0 are acceptable. +// +// GL.INVALID_OPERATION is generated if DepthRange is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) DepthRange(nearVal, farVal float64) { + C.gl4_0core_glDepthRange(gl.funcs, C.GLdouble(nearVal), C.GLdouble(farVal)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsEnabled.xml +func (gl *GL) IsEnabled(cap glbase.Enum) bool { + glresult := C.gl4_0core_glIsEnabled(gl.funcs, C.GLenum(cap)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexLevelParameteriv.xml +func (gl *GL) GetTexLevelParameteriv(target glbase.Enum, level int, pname glbase.Enum, params []int32) { + C.gl4_0core_glGetTexLevelParameteriv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexLevelParameterfv.xml +func (gl *GL) GetTexLevelParameterfv(target glbase.Enum, level int, pname glbase.Enum, params []float32) { + C.gl4_0core_glGetTexLevelParameterfv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameteriv.xml +func (gl *GL) GetTexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_0core_glGetTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameterfv.xml +func (gl *GL) GetTexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_0core_glGetTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexImage.xml +func (gl *GL) GetTexImage(target glbase.Enum, level int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_0core_glGetTexImage(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetIntegerv.xml +func (gl *GL) GetIntegerv(pname glbase.Enum, params []int32) { + C.gl4_0core_glGetIntegerv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFloatv.xml +func (gl *GL) GetFloatv(pname glbase.Enum, params []float32) { + C.gl4_0core_glGetFloatv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetError.xml +func (gl *GL) GetError() glbase.Enum { + glresult := C.gl4_0core_glGetError(gl.funcs) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetDoublev.xml +func (gl *GL) GetDoublev(pname glbase.Enum, params []float64) { + C.gl4_0core_glGetDoublev(gl.funcs, C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBooleanv.xml +func (gl *GL) GetBooleanv(pname glbase.Enum, params []bool) { + C.gl4_0core_glGetBooleanv(gl.funcs, C.GLenum(pname), (*C.GLboolean)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glReadPixels.xml +func (gl *GL) ReadPixels(x, y, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_0core_glReadPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glReadBuffer.xml +func (gl *GL) ReadBuffer(mode glbase.Enum) { + C.gl4_0core_glReadBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelStorei.xml +func (gl *GL) PixelStorei(pname glbase.Enum, param int32) { + C.gl4_0core_glPixelStorei(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelStoref.xml +func (gl *GL) PixelStoref(pname glbase.Enum, param float32) { + C.gl4_0core_glPixelStoref(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDepthFunc.xml +func (gl *GL) DepthFunc(glfunc glbase.Enum) { + C.gl4_0core_glDepthFunc(gl.funcs, C.GLenum(glfunc)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilOp.xml +func (gl *GL) StencilOp(fail, zfail, zpass glbase.Enum) { + C.gl4_0core_glStencilOp(gl.funcs, C.GLenum(fail), C.GLenum(zfail), C.GLenum(zpass)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilFunc.xml +func (gl *GL) StencilFunc(glfunc glbase.Enum, ref int32, mask uint32) { + C.gl4_0core_glStencilFunc(gl.funcs, C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLogicOp.xml +func (gl *GL) LogicOp(opcode glbase.Enum) { + C.gl4_0core_glLogicOp(gl.funcs, C.GLenum(opcode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFunc.xml +func (gl *GL) BlendFunc(sfactor, dfactor glbase.Enum) { + C.gl4_0core_glBlendFunc(gl.funcs, C.GLenum(sfactor), C.GLenum(dfactor)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFlush.xml +func (gl *GL) Flush() { + C.gl4_0core_glFlush(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFinish.xml +func (gl *GL) Finish() { + C.gl4_0core_glFinish(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEnable.xml +func (gl *GL) Enable(cap glbase.Enum) { + C.gl4_0core_glEnable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDisable.xml +func (gl *GL) Disable(cap glbase.Enum) { + C.gl4_0core_glDisable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDepthMask.xml +func (gl *GL) DepthMask(flag bool) { + C.gl4_0core_glDepthMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorMask.xml +func (gl *GL) ColorMask(red, green, blue, alpha bool) { + C.gl4_0core_glColorMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&red)), *(*C.GLboolean)(unsafe.Pointer(&green)), *(*C.GLboolean)(unsafe.Pointer(&blue)), *(*C.GLboolean)(unsafe.Pointer(&alpha))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilMask.xml +func (gl *GL) StencilMask(mask uint32) { + C.gl4_0core_glStencilMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearDepth.xml +func (gl *GL) ClearDepth(depth float64) { + C.gl4_0core_glClearDepth(gl.funcs, C.GLdouble(depth)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearStencil.xml +func (gl *GL) ClearStencil(s int32) { + C.gl4_0core_glClearStencil(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearColor.xml +func (gl *GL) ClearColor(red, green, blue, alpha float32) { + C.gl4_0core_glClearColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClear.xml +func (gl *GL) Clear(mask glbase.Bitfield) { + C.gl4_0core_glClear(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawBuffer.xml +func (gl *GL) DrawBuffer(mode glbase.Enum) { + C.gl4_0core_glDrawBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage2D.xml +func (gl *GL) TexImage2D(target glbase.Enum, level int, internalFormat int32, width, height, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_0core_glTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage1D.xml +func (gl *GL) TexImage1D(target glbase.Enum, level int, internalFormat int32, width, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_0core_glTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameteriv.xml +func (gl *GL) TexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_0core_glTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameteri.xml +func (gl *GL) TexParameteri(target, pname glbase.Enum, param int32) { + C.gl4_0core_glTexParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterfv.xml +func (gl *GL) TexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_0core_glTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterf.xml +func (gl *GL) TexParameterf(target, pname glbase.Enum, param float32) { + C.gl4_0core_glTexParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glScissor.xml +func (gl *GL) Scissor(x, y, width, height int) { + C.gl4_0core_glScissor(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPolygonMode.xml +func (gl *GL) PolygonMode(face, mode glbase.Enum) { + C.gl4_0core_glPolygonMode(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointSize.xml +func (gl *GL) PointSize(size float32) { + C.gl4_0core_glPointSize(gl.funcs, C.GLfloat(size)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLineWidth.xml +func (gl *GL) LineWidth(width float32) { + C.gl4_0core_glLineWidth(gl.funcs, C.GLfloat(width)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glHint.xml +func (gl *GL) Hint(target, mode glbase.Enum) { + C.gl4_0core_glHint(gl.funcs, C.GLenum(target), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFrontFace.xml +func (gl *GL) FrontFace(mode glbase.Enum) { + C.gl4_0core_glFrontFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCullFace.xml +func (gl *GL) CullFace(mode glbase.Enum) { + C.gl4_0core_glCullFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexubv.xml +func (gl *GL) Indexubv(c []uint8) { + C.gl4_0core_glIndexubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexub.xml +func (gl *GL) Indexub(c uint8) { + C.gl4_0core_glIndexub(gl.funcs, C.GLubyte(c)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsTexture.xml +func (gl *GL) IsTexture(texture glbase.Texture) bool { + glresult := C.gl4_0core_glIsTexture(gl.funcs, C.GLuint(texture)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenTextures returns n texture names in textures. There is no guarantee +// that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenTextures. +// +// The generated textures have no dimensionality; they assume the +// dimensionality of the texture target to which they are first bound (see +// BindTexture). +// +// Texture names returned by a call to GenTextures are not returned by +// subsequent calls, unless they are first deleted with DeleteTextures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenTextures is available in GL version 2.0 or greater. +func (gl *GL) GenTextures(n int) []glbase.Texture { + if n == 0 { + return nil + } + textures := make([]glbase.Texture, n) + C.gl4_0core_glGenTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) + return textures +} + +// DeleteTextures deletes the textures objects whose names are stored +// in the textures slice. After a texture is deleted, it has no contents or +// dimensionality, and its name is free for reuse (for example by +// GenTextures). If a texture that is currently bound is deleted, the binding +// reverts to 0 (the default texture). +// +// DeleteTextures silently ignores 0's and names that do not correspond to +// existing textures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteTextures is available in GL version 2.0 or greater. +func (gl *GL) DeleteTextures(textures []glbase.Texture) { + n := len(textures) + if n == 0 { + return + } + C.gl4_0core_glDeleteTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindTexture.xml +func (gl *GL) BindTexture(target glbase.Enum, texture glbase.Texture) { + C.gl4_0core_glBindTexture(gl.funcs, C.GLenum(target), C.GLuint(texture)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexSubImage2D.xml +func (gl *GL) TexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_0core_glTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexSubImage1D.xml +func (gl *GL) TexSubImage1D(target glbase.Enum, level, xoffset, width int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_0core_glTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexSubImage2D.xml +func (gl *GL) CopyTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, x, y, width, height int) { + C.gl4_0core_glCopyTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexSubImage1D.xml +func (gl *GL) CopyTexSubImage1D(target glbase.Enum, level, xoffset, x, y, width int) { + C.gl4_0core_glCopyTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexImage2D.xml +func (gl *GL) CopyTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, height, border int) { + C.gl4_0core_glCopyTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexImage1D.xml +func (gl *GL) CopyTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, border int) { + C.gl4_0core_glCopyTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPolygonOffset.xml +func (gl *GL) PolygonOffset(factor, units float32) { + C.gl4_0core_glPolygonOffset(gl.funcs, C.GLfloat(factor), C.GLfloat(units)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElements.xml +func (gl *GL) DrawElements(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_0core_glDrawElements(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawArrays.xml +func (gl *GL) DrawArrays(mode glbase.Enum, first, count int) { + C.gl4_0core_glDrawArrays(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexSubImage3D.xml +func (gl *GL) CopyTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, x, y, width, height int) { + C.gl4_0core_glCopyTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexSubImage3D.xml +func (gl *GL) TexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_0core_glTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage3D.xml +func (gl *GL) TexImage3D(target glbase.Enum, level int, internalFormat int32, width, height int, depth int32, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_0core_glTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawRangeElements.xml +func (gl *GL) DrawRangeElements(mode glbase.Enum, start, end uint32, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_0core_glDrawRangeElements(gl.funcs, C.GLenum(mode), C.GLuint(start), C.GLuint(end), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendEquation.xml +func (gl *GL) BlendEquation(mode glbase.Enum) { + C.gl4_0core_glBlendEquation(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendColor.xml +func (gl *GL) BlendColor(red, green, blue, alpha float32) { + C.gl4_0core_glBlendColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetCompressedTexImage.xml +func (gl *GL) GetCompressedTexImage(target glbase.Enum, level int, img interface{}) { + var img_ptr unsafe.Pointer + var img_v = reflect.ValueOf(img) + if img != nil && img_v.Kind() != reflect.Slice { + panic("parameter img must be a slice") + } + if img != nil { + img_ptr = unsafe.Pointer(img_v.Index(0).Addr().Pointer()) + } + C.gl4_0core_glGetCompressedTexImage(gl.funcs, C.GLenum(target), C.GLint(level), img_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexSubImage1D.xml +func (gl *GL) CompressedTexSubImage1D(target glbase.Enum, level, xoffset, width int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_0core_glCompressedTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexSubImage2D.xml +func (gl *GL) CompressedTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_0core_glCompressedTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexSubImage3D.xml +func (gl *GL) CompressedTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_0core_glCompressedTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexImage1D.xml +func (gl *GL) CompressedTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, width, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_0core_glCompressedTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexImage2D.xml +func (gl *GL) CompressedTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_0core_glCompressedTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexImage3D.xml +func (gl *GL) CompressedTexImage3D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height int, depth int32, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_0core_glCompressedTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSampleCoverage.xml +func (gl *GL) SampleCoverage(value float32, invert bool) { + C.gl4_0core_glSampleCoverage(gl.funcs, C.GLfloat(value), *(*C.GLboolean)(unsafe.Pointer(&invert))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glActiveTexture.xml +func (gl *GL) ActiveTexture(texture glbase.Enum) { + C.gl4_0core_glActiveTexture(gl.funcs, C.GLenum(texture)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointParameteriv.xml +func (gl *GL) PointParameteriv(pname glbase.Enum, params []int32) { + C.gl4_0core_glPointParameteriv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointParameteri.xml +func (gl *GL) PointParameteri(pname glbase.Enum, param int32) { + C.gl4_0core_glPointParameteri(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointParameterfv.xml +func (gl *GL) PointParameterfv(pname glbase.Enum, params []float32) { + C.gl4_0core_glPointParameterfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointParameterf.xml +func (gl *GL) PointParameterf(pname glbase.Enum, param float32) { + C.gl4_0core_glPointParameterf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiDrawArrays.xml +func (gl *GL) MultiDrawArrays(mode glbase.Enum, first, count []int, drawcount int32) { + C.gl4_0core_glMultiDrawArrays(gl.funcs, C.GLenum(mode), (*C.GLint)(unsafe.Pointer(&first[0])), (*C.GLsizei)(unsafe.Pointer(&count[0])), C.GLsizei(drawcount)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFuncSeparate.xml +func (gl *GL) BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha glbase.Enum) { + C.gl4_0core_glBlendFuncSeparate(gl.funcs, C.GLenum(sfactorRGB), C.GLenum(dfactorRGB), C.GLenum(sfactorAlpha), C.GLenum(dfactorAlpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBufferParameteriv.xml +func (gl *GL) GetBufferParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_0core_glGetBufferParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUnmapBuffer.xml +func (gl *GL) UnmapBuffer(target glbase.Enum) bool { + glresult := C.gl4_0core_glUnmapBuffer(gl.funcs, C.GLenum(target)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBufferSubData.xml +func (gl *GL) GetBufferSubData(target glbase.Enum, offset, size int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_0core_glGetBufferSubData(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(size), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBufferSubData.xml +func (gl *GL) BufferSubData(target glbase.Enum, offset, size int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_0core_glBufferSubData(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(size), data_ptr) +} + +// BufferData creates a new data store for the buffer object currently +// bound to target. Any pre-existing data store is deleted. The new data +// store is created with the specified size in bytes and usage. If data is +// not nil, it must be a slice that is used to initialize the data store. +// In that case the size parameter is ignored and the store size will match +// the slice data size. +// +// In its initial state, the new data store is not mapped, it has a NULL +// mapped pointer, and its mapped access is GL.READ_WRITE. +// +// The target constant must be one of GL.ARRAY_BUFFER, GL.COPY_READ_BUFFER, +// GL.COPY_WRITE_BUFFER, GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER, +// GL.PIXEL_UNPACK_BUFFER, GL.TEXTURE_BUFFER, GL.TRANSFORM_FEEDBACK_BUFFER, +// or GL.UNIFORM_BUFFER. +// +// The usage parameter is a hint to the GL implementation as to how a buffer +// object's data store will be accessed. This enables the GL implementation +// to make more intelligent decisions that may significantly impact buffer +// object performance. It does not, however, constrain the actual usage of +// the data store. usage can be broken down into two parts: first, the +// frequency of access (modification and usage), and second, the nature of +// that access. +// +// A usage frequency of STREAM and nature of DRAW is specified via the +// constant GL.STREAM_DRAW, for example. +// +// The usage frequency of access may be one of: +// +// STREAM +// The data store contents will be modified once and used at most a few times. +// +// STATIC +// The data store contents will be modified once and used many times. +// +// DYNAMIC +// The data store contents will be modified repeatedly and used many times. +// +// The usage nature of access may be one of: +// +// DRAW +// The data store contents are modified by the application, and used as +// the source for GL drawing and image specification commands. +// +// READ +// The data store contents are modified by reading data from the GL, +// and used to return that data when queried by the application. +// +// COPY +// The data store contents are modified by reading data from the GL, +// and used as the source for GL drawing and image specification +// commands. +// +// Clients must align data elements consistent with the requirements of the +// client platform, with an additional base-level requirement that an offset +// within a buffer to a datum comprising N bytes be a multiple of N. +// +// Error GL.INVALID_ENUM is generated if target is not one of the accepted +// buffer targets. GL.INVALID_ENUM is generated if usage is not +// GL.STREAM_DRAW, GL.STREAM_READ, GL.STREAM_COPY, GL.STATIC_DRAW, +// GL.STATIC_READ, GL.STATIC_COPY, GL.DYNAMIC_DRAW, GL.DYNAMIC_READ, or +// GL.DYNAMIC_COPY. GL.INVALID_VALUE is generated if size is negative. +// GL.INVALID_OPERATION is generated if the reserved buffer object name 0 is +// bound to target. GL.OUT_OF_MEMORY is generated if the GL is unable to +// create a data store with the specified size. +func (gl *GL) BufferData(target glbase.Enum, size int, data interface{}, usage glbase.Enum) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + if data != nil { + size = int(data_v.Type().Size()) * data_v.Len() + } + C.gl4_0core_glBufferData(gl.funcs, C.GLenum(target), C.GLsizeiptr(size), data_ptr, C.GLenum(usage)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsBuffer.xml +func (gl *GL) IsBuffer(buffer glbase.Buffer) bool { + glresult := C.gl4_0core_glIsBuffer(gl.funcs, C.GLuint(buffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenBuffers returns n buffer object names. There is no guarantee that +// the names form a contiguous set of integers; however, it is guaranteed +// that none of the returned names was in use immediately before the call to +// GenBuffers. +// +// Buffer object names returned by a call to GenBuffers are not returned by +// subsequent calls, unless they are first deleted with DeleteBuffers. +// +// No buffer objects are associated with the returned buffer object names +// until they are first bound by calling BindBuffer. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if GenBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// GenBuffers is available in GL version 1.5 or greater. +func (gl *GL) GenBuffers(n int) []glbase.Buffer { + if n == 0 { + return nil + } + buffers := make([]glbase.Buffer, n) + C.gl4_0core_glGenBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) + return buffers +} + +// DeleteBuffers deletes the buffer objects whose names are stored in the +// buffers slice. +// +// After a buffer object is deleted, it has no contents, and its name is free +// for reuse (for example by GenBuffers). If a buffer object that is +// currently bound is deleted, the binding reverts to 0 (the absence of any +// buffer object, which reverts to client memory usage). +// +// DeleteBuffers silently ignores 0's and names that do not correspond to +// existing buffer objects. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if DeleteBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// DeleteBuffers is available in GL version 1.5 or greater. +func (gl *GL) DeleteBuffers(buffers []glbase.Buffer) { + n := len(buffers) + if n == 0 { + return + } + C.gl4_0core_glDeleteBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) +} + +// BindBuffer creates or puts in use a named buffer object. +// Calling BindBuffer with target set to GL.ARRAY_BUFFER, +// GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER or GL.PIXEL_UNPACK_BUFFER +// and buffer set to the name of the new buffer object binds the buffer +// object name to the target. When a buffer object is bound to a target, the +// previous binding for that target is automatically broken. +// +// Buffer object names are unsigned integers. The value zero is reserved, but +// there is no default buffer object for each buffer object target. Instead, +// buffer set to zero effectively unbinds any buffer object previously bound, +// and restores client memory usage for that buffer object target. Buffer +// object names and the corresponding buffer object contents are local to the +// shared display-list space (see XCreateContext) of the current GL rendering +// context; two rendering contexts share buffer object names only if they +// also share display lists. +// +// GenBuffers may be called to generate a set of new buffer object names. +// +// The state of a buffer object immediately after it is first bound is an +// unmapped zero-sized memory buffer with GL.READ_WRITE access and +// GL.STATIC_DRAW usage. +// +// While a non-zero buffer object name is bound, GL operations on the target +// to which it is bound affect the bound buffer object, and queries of the +// target to which it is bound return state from the bound buffer object. +// While buffer object name zero is bound, as in the initial state, attempts +// to modify or query state on the target to which it is bound generates an +// GL.INVALID_OPERATION error. +// +// When vertex array pointer state is changed, for example by a call to +// NormalPointer, the current buffer object binding (GL.ARRAY_BUFFER_BINDING) +// is copied into the corresponding client state for the vertex array type +// being changed, for example GL.NORMAL_ARRAY_BUFFER_BINDING. While a +// non-zero buffer object is bound to the GL.ARRAY_BUFFER target, the vertex +// array pointer parameter that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.ELEMENT_ARRAY_BUFFER +// target, the indices parameter of DrawElements, DrawRangeElements, or +// MultiDrawElements that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_PACK_BUFFER +// target, the following commands are affected: GetCompressedTexImage, +// GetConvolutionFilter, GetHistogram, GetMinmax, GetPixelMap, +// GetPolygonStipple, GetSeparableFilter, GetTexImage, and ReadPixels. The +// pointer parameter that is traditionally interpreted as a pointer to +// client-side memory where the pixels are to be packed is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_UNPACK_BUFFER +// target, the following commands are affected: Bitmap, ColorSubTable, +// ColorTable, CompressedTexImage1D, CompressedTexImage2D, +// CompressedTexImage3D, CompressedTexSubImage1D, CompressedTexSubImage2D, +// CompressedTexSubImage3D, ConvolutionFilter1D, ConvolutionFilter2D, +// DrawPixels, PixelMap, PolygonStipple, SeparableFilter2D, TexImage1D, +// TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, and TexSubImage3D. +// The pointer parameter that is traditionally interpreted as a pointer to +// client-side memory from which the pixels are to be unpacked is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// A buffer object binding created with BindBuffer remains active until a +// different buffer object name is bound to the same target, or until the +// bound buffer object is deleted with DeleteBuffers. +// +// Once created, a named buffer object may be re-bound to any target as often +// as needed. However, the GL implementation may make choices about how to +// optimize the storage of a buffer object based on its initial binding +// target. +// +// Error GL.INVALID_ENUM is generated if target is not one of the allowable +// values. GL.INVALID_OPERATION is generated if BindBuffer is executed +// between the execution of Begin and the corresponding execution of End. +// +// BindBuffer is available in GL version 1.5 or greater. +func (gl *GL) BindBuffer(target glbase.Enum, buffer glbase.Buffer) { + C.gl4_0core_glBindBuffer(gl.funcs, C.GLenum(target), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryObjectuiv.xml +func (gl *GL) GetQueryObjectuiv(id uint32, pname glbase.Enum, params []uint32) { + C.gl4_0core_glGetQueryObjectuiv(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryObjectiv.xml +func (gl *GL) GetQueryObjectiv(id uint32, pname glbase.Enum, params []int32) { + C.gl4_0core_glGetQueryObjectiv(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryiv.xml +func (gl *GL) GetQueryiv(target, pname glbase.Enum, params []int32) { + C.gl4_0core_glGetQueryiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndQuery.xml +func (gl *GL) EndQuery(target glbase.Enum) { + C.gl4_0core_glEndQuery(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBeginQuery.xml +func (gl *GL) BeginQuery(target glbase.Enum, id uint32) { + C.gl4_0core_glBeginQuery(gl.funcs, C.GLenum(target), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsQuery.xml +func (gl *GL) IsQuery(id uint32) bool { + glresult := C.gl4_0core_glIsQuery(gl.funcs, C.GLuint(id)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteQueries.xml +func (gl *GL) DeleteQueries(n int, ids []uint32) { + C.gl4_0core_glDeleteQueries(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenQueries.xml +func (gl *GL) GenQueries(n int, ids []uint32) { + C.gl4_0core_glGenQueries(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// VertexAttribPointer specifies the location and data format of the array +// of generic vertex attributes at index to use when rendering. size +// specifies the number of components per attribute and must be 1, 2, 3, or +// 4. type specifies the data type of each component, and stride specifies +// the byte stride from one attribute to the next, allowing vertices and +// attributes to be packed into a single array or stored in separate arrays. +// normalized indicates whether the values stored in an integer format are +// to be mapped to the range [-1,1] (for signed values) or [0,1] +// (for unsigned values) when they are accessed and converted to floating +// point; otherwise, values will be converted to floats directly without +// normalization. offset is a byte offset into the buffer object's data +// store, which must be bound to the GL.ARRAY_BUFFER target with BindBuffer. +// +// The buffer object binding (GL.ARRAY_BUFFER_BINDING) is saved as +// generic vertex attribute array client-side state +// (GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING) for the provided index. +// +// To enable and disable a generic vertex attribute array, call +// EnableVertexAttribArray and DisableVertexAttribArray with index. If +// enabled, the generic vertex attribute array is used when DrawArrays or +// DrawElements is called. Each generic vertex attribute array is initially +// disabled. +// +// VertexAttribPointer is typically implemented on the client side. +// +// Error GL.INVALID_ENUM is generated if type is not an accepted value. +// GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_VALUE is generated if size is not 1, 2, +// 3, or 4. GL.INVALID_VALUE is generated if stride is negative. +func (gl *GL) VertexAttribPointer(index glbase.Attrib, size int, gltype glbase.Enum, normalized bool, stride int, offset uintptr) { + offset_ptr := unsafe.Pointer(offset) + C.gl4_0core_glVertexAttribPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLsizei(stride), offset_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glValidateProgram.xml +func (gl *GL) ValidateProgram(program glbase.Program) { + C.gl4_0core_glValidateProgram(gl.funcs, C.GLuint(program)) +} + +// UniformMatrix4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*4) != 0 { + panic("invalid value length for UniformMatrix4fv") + } + count := len(value) / (4 * 4) + C.gl4_0core_glUniformMatrix4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*3) != 0 { + panic("invalid value length for UniformMatrix3fv") + } + count := len(value) / (3 * 3) + C.gl4_0core_glUniformMatrix3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*2) != 0 { + panic("invalid value length for UniformMatrix2fv") + } + count := len(value) / (2 * 2) + C.gl4_0core_glUniformMatrix2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform4iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4iv") + } + count := len(value) / 4 + C.gl4_0core_glUniform4iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform3iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3iv") + } + count := len(value) / 3 + C.gl4_0core_glUniform3iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform2iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2iv") + } + count := len(value) / 2 + C.gl4_0core_glUniform2iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform1iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl4_0core_glUniform1iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4fv") + } + count := len(value) / 4 + C.gl4_0core_glUniform4fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3fv") + } + count := len(value) / 3 + C.gl4_0core_glUniform3fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2fv") + } + count := len(value) / 2 + C.gl4_0core_glUniform2fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform1fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl4_0core_glUniform1fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform4i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4i(location glbase.Uniform, v0, v1, v2, v3 int32) { + C.gl4_0core_glUniform4i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2), C.GLint(v3)) +} + +// Uniform3i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3i(location glbase.Uniform, v0, v1, v2 int32) { + C.gl4_0core_glUniform3i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2)) +} + +// Uniform2i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2i(location glbase.Uniform, v0, v1 int32) { + C.gl4_0core_glUniform2i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1)) +} + +// Uniform1i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1i(location glbase.Uniform, v0 int32) { + C.gl4_0core_glUniform1i(gl.funcs, C.GLint(location), C.GLint(v0)) +} + +// Uniform4f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4f(location glbase.Uniform, v0, v1, v2, v3 float32) { + C.gl4_0core_glUniform4f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2), C.GLfloat(v3)) +} + +// Uniform3f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3f(location glbase.Uniform, v0, v1, v2 float32) { + C.gl4_0core_glUniform3f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2)) +} + +// Uniform2f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2f(location glbase.Uniform, v0, v1 float32) { + C.gl4_0core_glUniform2f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1)) +} + +// Uniform1f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1f(location glbase.Uniform, v0 float32) { + C.gl4_0core_glUniform1f(gl.funcs, C.GLint(location), C.GLfloat(v0)) +} + +// UseProgram installs the program object specified by program as part of +// current rendering state. One or more executables are created in a program +// object by successfully attaching shader objects to it with AttachShader, +// successfully compiling the shader objects with CompileShader, and +// successfully linking the program object with LinkProgram. +// +// A program object will contain an executable that will run on the vertex +// processor if it contains one or more shader objects of type +// GL.VERTEX_SHADER that have been successfully compiled and linked. +// Similarly, a program object will contain an executable that will run on +// the fragment processor if it contains one or more shader objects of type +// GL.FRAGMENT_SHADER that have been successfully compiled and linked. +// +// Successfully installing an executable on a programmable processor will +// cause the corresponding fixed functionality of OpenGL to be disabled. +// Specifically, if an executable is installed on the vertex processor, the +// OpenGL fixed functionality will be disabled as follows. +// +// - The modelview matrix is not applied to vertex coordinates. +// +// - The projection matrix is not applied to vertex coordinates. +// +// - The texture matrices are not applied to texture coordinates. +// +// - Normals are not transformed to eye coordinates. +// +// - Normals are not rescaled or normalized. +// +// - Normalization of GL.AUTO_NORMAL evaluated normals is not performed. +// +// - Texture coordinates are not generated automatically. +// +// - Per-vertex lighting is not performed. +// +// - Color material computations are not performed. +// +// - Color index lighting is not performed. +// +// - This list also applies when setting the current raster position. +// +// The executable that is installed on the vertex processor is expected to +// implement any or all of the desired functionality from the preceding list. +// Similarly, if an executable is installed on the fragment processor, the +// OpenGL fixed functionality will be disabled as follows. +// +// - Texture environment and texture functions are not applied. +// +// - Texture application is not applied. +// +// - Color sum is not applied. +// +// - Fog is not applied. +// +// Again, the fragment shader that is installed is expected to implement any +// or all of the desired functionality from the preceding list. +// +// While a program object is in use, applications are free to modify attached +// shader objects, compile attached shader objects, attach additional shader +// objects, and detach or delete shader objects. None of these operations +// will affect the executables that are part of the current state. However, +// relinking the program object that is currently in use will install the +// program object as part of the current rendering state if the link +// operation was successful (see LinkProgram). If the program object +// currently in use is relinked unsuccessfully, its link status will be set +// to GL.FALSE, but the executables and associated state will remain part of +// the current state until a subsequent call to UseProgram removes it from +// use. After it is removed from use, it cannot be made part of current state +// until it has been successfully relinked. +// +// If program contains shader objects of type GL.VERTEX_SHADER but it does +// not contain shader objects of type GL.FRAGMENT_SHADER, an executable will +// be installed on the vertex processor, but fixed functionality will be used +// for fragment processing. Similarly, if program contains shader objects of +// type GL.FRAGMENT_SHADER but it does not contain shader objects of type +// GL.VERTEX_SHADER, an executable will be installed on the fragment +// processor, but fixed functionality will be used for vertex processing. If +// program is 0, the programmable processors will be disabled, and fixed +// functionality will be used for both vertex and fragment processing. +// +// While a program object is in use, the state that controls the disabled +// fixed functionality may also be updated using the normal OpenGL calls. +// +// Like display lists and texture objects, the name space for program objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// Applications are responsible for providing the synchronization across API +// calls when objects are accessed from different execution threads. +// +// Error GL.INVALID_VALUE is generated if program is neither 0 nor a value +// generated by OpenGL. GL.INVALID_OPERATION is generated if program is not +// a program object. GL.INVALID_OPERATION is generated if program could not +// be made part of current state. GL.INVALID_OPERATION is generated if +// UseProgram is executed between the execution of Begin and the +// corresponding execution of End. +// +// UseProgram is available in GL version 2.0 or greater. +func (gl *GL) UseProgram(program glbase.Program) { + C.gl4_0core_glUseProgram(gl.funcs, C.GLuint(program)) +} + +// ShaderSource sets the source code in shader to the provided source code. Any source +// code previously stored in the shader object is completely replaced. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_VALUE is generated if count is less than 0. +// GL.INVALID_OPERATION is generated if ShaderSource is executed between the +// execution of Begin and the corresponding execution of End. +// +// ShaderSource is available in GL version 2.0 or greater. +func (gl *GL) ShaderSource(shader glbase.Shader, source ...string) { + count := len(source) + length := make([]int32, count) + source_c := make([]unsafe.Pointer, count) + for i, src := range source { + length[i] = int32(len(src)) + if len(src) > 0 { + source_c[i] = *(*unsafe.Pointer)(unsafe.Pointer(&src)) + } else { + source_c[i] = unsafe.Pointer(uintptr(0)) + } + } + C.gl4_0core_glShaderSource(gl.funcs, C.GLuint(shader), C.GLsizei(count), (**C.GLchar)(unsafe.Pointer(&source_c[0])), (*C.GLint)(unsafe.Pointer(&length[0]))) +} + +// LinkProgram links the program object specified by program. If any shader +// objects of type GL.VERTEX_SHADER are attached to program, they will be +// used to create an executable that will run on the programmable vertex +// processor. If any shader objects of type GL.FRAGMENT_SHADER are attached +// to program, they will be used to create an executable that will run on the +// programmable fragment processor. +// +// The status of the link operation will be stored as part of the program +// object's state. This value will be set to GL.TRUE if the program object +// was linked without errors and is ready for use, and GL.FALSE otherwise. It +// can be queried by calling GetProgramiv with arguments program and +// GL.LINK_STATUS. +// +// As a result of a successful link operation, all active user-defined +// uniform variables belonging to program will be initialized to 0, and each +// of the program object's active uniform variables will be assigned a +// location that can be queried by calling GetUniformLocation. Also, any +// active user-defined attribute variables that have not been bound to a +// generic vertex attribute index will be bound to one at this time. +// +// Linking of a program object can fail for a number of reasons as specified +// in the OpenGL Shading Language Specification. The following lists some of +// the conditions that will cause a link error. +// +// - The number of active attribute variables supported by the +// implementation has been exceeded. +// +// - The storage limit for uniform variables has been exceeded. +// +// - The number of active uniform variables supported by the implementation +// has been exceeded. +// +// - The main function is missing for the vertex shader or the fragment +// shader. +// +// - A varying variable actually used in the fragment shader is not +// declared in the same way (or is not declared at all) in the vertex +// shader. +// +// - A reference to a function or variable name is unresolved. +// +// - A shared global is declared with two different types or two different +// initial values. +// +// - One or more of the attached shader objects has not been successfully +// compiled. +// +// - Binding a generic attribute matrix caused some rows of the matrix to +// fall outside the allowed maximum of GL.MAX_VERTEX_ATTRIBS. +// +// - Not enough contiguous vertex attribute slots could be found to bind +// attribute matrices. +// +// When a program object has been successfully linked, the program object can +// be made part of current state by calling UseProgram. Whether or not the +// link operation was successful, the program object's information log will +// be overwritten. The information log can be retrieved by calling +// GetProgramInfoLog. +// +// LinkProgram will also install the generated executables as part of the +// current rendering state if the link operation was successful and the +// specified program object is already currently in use as a result of a +// previous call to UseProgram. If the program object currently in use is +// relinked unsuccessfully, its link status will be set to GL.FALSE , but the +// executables and associated state will remain part of the current state +// until a subsequent call to UseProgram removes it from use. After it is +// removed from use, it cannot be made part of current state until it has +// been successfully relinked. +// +// If program contains shader objects of type GL.VERTEX_SHADER but does not +// contain shader objects of type GL.FRAGMENT_SHADER, the vertex shader will +// be linked against the implicit interface for fixed functionality fragment +// processing. Similarly, if program contains shader objects of type +// GL.FRAGMENT_SHADER but it does not contain shader objects of type +// GL.VERTEX_SHADER, the fragment shader will be linked against the implicit +// interface for fixed functionality vertex processing. +// +// The program object's information log is updated and the program is +// generated at the time of the link operation. After the link operation, +// applications are free to modify attached shader objects, compile attached +// shader objects, detach shader objects, delete shader objects, and attach +// additional shader objects. None of these operations affects the +// information log or the program that is part of the program object. +// +// If the link operation is unsuccessful, any information about a previous +// link operation on program is lost (a failed link does not restore the +// old state of program). Certain information can still be retrieved +// from program even after an unsuccessful link operation. See for instance +// GetActiveAttrib and GetActiveUniform. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if LinkProgram is executed +// between the execution of Begin and the corresponding execution of End. +// +// LinkProgram is available in GL version 2.0 or greater. +func (gl *GL) LinkProgram(program glbase.Program) { + C.gl4_0core_glLinkProgram(gl.funcs, C.GLuint(program)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsShader.xml +func (gl *GL) IsShader(shader glbase.Shader) bool { + glresult := C.gl4_0core_glIsShader(gl.funcs, C.GLuint(shader)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsProgram.xml +func (gl *GL) IsProgram(program glbase.Program) bool { + glresult := C.gl4_0core_glIsProgram(gl.funcs, C.GLuint(program)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GetVertexAttribiv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribiv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribiv(index glbase.Attrib, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl4_0core_glGetVertexAttribiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetVertexAttribfv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribfv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribfv(index glbase.Attrib, pname glbase.Enum, params []float32) { + var params_c [4]float32 + C.gl4_0core_glGetVertexAttribfv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetVertexAttribdv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribdv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribdv(index glbase.Attrib, pname glbase.Enum, params []float64) { + var params_c [4]float64 + C.gl4_0core_glGetVertexAttribdv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformiv returns in params the value of the specified uniform +// variable. The type of the uniform variable specified by location +// determines the number of values returned. If the uniform variable is +// defined in the shader as a boolean, int, or float, a single value will be +// returned. If it is defined as a vec2, ivec2, or bvec2, two values will be +// returned. If it is defined as a vec3, ivec3, or bvec3, three values will +// be returned, and so on. To query values stored in uniform variables +// declared as arrays, call GetUniformiv for each element of the array. To +// query values stored in uniform variables declared as structures, call +// GetUniformiv for each field in the structure. The values for uniform +// variables declared as a matrix will be returned in column major order. +// +// The locations assigned to uniform variables are not known until the +// program object is linked. After linking has occurred, the command +// GetUniformLocation can be used to obtain the location of a uniform +// variable. This location value can then be passed to GetUniformiv in order +// to query the current value of the uniform variable. After a program object +// has been linked successfully, the index values for uniform variables +// remain fixed until the next link command occurs. The uniform variable +// values can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if program has not been +// successfully linked. GL.INVALID_OPERATION is generated if location does +// not correspond to a valid uniform variable location for the specified +// program object. GL.INVALID_OPERATION is generated if GetUniformiv is +// executed between the execution of Begin and the corresponding execution of +// End. +// +// GetUniformiv is available in GL version 2.0 or greater. +func (gl *GL) GetUniformiv(program glbase.Program, location glbase.Uniform, params []int32) { + var params_c [4]int32 + C.gl4_0core_glGetUniformiv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformfv returns in params the value of the specified uniform +// variable. The type of the uniform variable specified by location +// determines the number of values returned. If the uniform variable is +// defined in the shader as a boolean, int, or float, a single value will be +// returned. If it is defined as a vec2, ivec2, or bvec2, two values will be +// returned. If it is defined as a vec3, ivec3, or bvec3, three values will +// be returned, and so on. To query values stored in uniform variables +// declared as arrays, call GetUniformfv for each element of the array. To +// query values stored in uniform variables declared as structures, call +// GetUniformfv for each field in the structure. The values for uniform +// variables declared as a matrix will be returned in column major order. +// +// The locations assigned to uniform variables are not known until the +// program object is linked. After linking has occurred, the command +// GetUniformLocation can be used to obtain the location of a uniform +// variable. This location value can then be passed to GetUniformfv in order +// to query the current value of the uniform variable. After a program object +// has been linked successfully, the index values for uniform variables +// remain fixed until the next link command occurs. The uniform variable +// values can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if program has not been +// successfully linked. GL.INVALID_OPERATION is generated if location does +// not correspond to a valid uniform variable location for the specified +// program object. GL.INVALID_OPERATION is generated if GetUniformfv is +// executed between the execution of Begin and the corresponding execution of +// End. +// +// GetUniformfv is available in GL version 2.0 or greater. +func (gl *GL) GetUniformfv(program glbase.Program, location glbase.Uniform, params []float32) { + var params_c [4]float32 + C.gl4_0core_glGetUniformfv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLfloat)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformLocation returns an integer that represents the location of a +// specific uniform variable within a program object. name must be an active +// uniform variable name in program that is not a structure, an array of +// structures, or a subcomponent of a vector or a matrix. This function +// returns -1 if name does not correspond to an active uniform variable in +// program or if name starts with the reserved prefix "gl_". +// +// Uniform variables that are structures or arrays of structures may be +// queried by calling GetUniformLocation for each field within the +// structure. The array element operator "[]" and the structure field +// operator "." may be used in name in order to select elements within an +// array or fields within a structure. The result of using these operators is +// not allowed to be another structure, an array of structures, or a +// subcomponent of a vector or a matrix. Except if the last part of name +// indicates a uniform variable array, the location of the first element of +// an array can be retrieved by using the name of the array, or by using the +// name appended by "[0]". +// +// The actual locations assigned to uniform variables are not known until the +// program object is linked successfully. After linking has occurred, the +// command GetUniformLocation can be used to obtain the location of a +// uniform variable. This location value can then be passed to Uniform to +// set the value of the uniform variable or to GetUniform in order to query +// the current value of the uniform variable. After a program object has been +// linked successfully, the index values for uniform variables remain fixed +// until the next link command occurs. Uniform variable locations and values +// can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program object. +// GL.INVALID_OPERATION is generated if program has not been successfully +// linked. GL.INVALID_OPERATION is generated if GetUniformLocation is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetUniformLocation is available in GL version 2.0 or greater. +func (gl *GL) GetUniformLocation(program glbase.Program, name string) glbase.Uniform { + name_cstr := C.CString(name) + glresult := C.gl4_0core_glGetUniformLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) + return glbase.Uniform(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetShaderSource.xml +func (gl *GL) GetShaderSource(shader glbase.Shader, bufSize int32, length []int32, source []byte) { + C.gl4_0core_glGetShaderSource(gl.funcs, C.GLuint(shader), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&source[0]))) +} + +// GetShaderInfoLog returns the information log for the specified shader +// object. The information log for a shader object is modified when the +// shader is compiled. +// +// The information log for a shader object is a string that may contain +// diagnostic messages, warning messages, and other information about the +// last compile operation. When a shader object is created, its information +// log will be a string of length 0, and the size of the current log can be +// obtained by calling GetShaderiv with the value GL.INFO_LOG_LENGTH. +// +// The information log for a shader object is the OpenGL implementer's +// primary mechanism for conveying information about the compilation process. +// Therefore, the information log can be helpful to application developers +// during the development process, even when compilation is successful. +// Application developers should not expect different OpenGL implementations +// to produce identical information logs. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_VALUE is generated if maxLength is less than 0. +// GL.INVALID_OPERATION is generated if GetShaderInfoLog is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetShaderInfoLog is available in GL version 2.0 or greater. +func (gl *GL) GetShaderInfoLog(shader glbase.Shader) []byte { + var params [1]int32 + var length int32 + gl.GetShaderiv(shader, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + C.gl4_0core_glGetShaderInfoLog(gl.funcs, C.GLuint(shader), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length)), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) + return infoLog +} + +// GetShaderiv GetShader returns in params the value of a parameter for a specific +// shader object. The following parameters are defined: +// +// GL.SHADER_TYPE +// params returns GL.VERTEX_SHADER if shader is a vertex shader object, +// and GL.FRAGMENT_SHADER if shader is a fragment shader object. +// +// GL.DELETE_STATUS +// params returns GL.TRUE if shader is currently flagged for deletion, +// and GL.FALSE otherwise. +// +// GL.COMPILE_STATUS +// params returns GL.TRUE if the last compile operation on shader was +// successful, and GL.FALSE otherwise. +// +// GL.INFO_LOG_LENGTH +// params returns the number of characters in the information log for +// shader including the null termination character (the size of the +// character buffer required to store the information log). If shader has +// no information log, a value of 0 is returned. +// +// GL.SHADER_SOURCE_LENGTH +// params returns the length of the concatenation of the source strings +// that make up the shader source for the shader, including the null +// termination character. (the size of the character buffer +// required to store the shader source). If no source code exists, 0 is +// returned. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader does not refer to a +// shader object. GL.INVALID_ENUM is generated if pname is not an accepted +// value. GL.INVALID_OPERATION is generated if GetShader is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetShaderiv is available in GL version 2.0 or greater. +func (gl *GL) GetShaderiv(shader glbase.Shader, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl4_0core_glGetShaderiv(gl.funcs, C.GLuint(shader), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetProgramInfoLog returns the information log for the specified program +// object. The information log for a program object is modified when the +// program object is linked or validated. +// +// The information log for a program object is either an empty string, or a +// string containing information about the last link operation, or a string +// containing information about the last validation operation. It may contain +// diagnostic messages, warning messages, and other information. When a +// program object is created, its information log will be a string of length +// 0, and the size of the current log can be obtained by calling GetProgramiv +// with the value GL.INFO_LOG_LENGTH. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated +// by OpenGL. GL.INVALID_OPERATION is generated if program is not a +// program object. +func (gl *GL) GetProgramInfoLog(program glbase.Program) []byte { + var params [1]int32 + var length int32 + gl.GetProgramiv(program, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + C.gl4_0core_glGetProgramInfoLog(gl.funcs, C.GLuint(program), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length)), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) + return infoLog +} + +// GetProgramiv returns in params the value of a parameter for a specific +// program object. The following parameters are defined: +// +// GL.DELETE_STATUS +// params returns GL.TRUE if program is currently flagged for deletion, +// and GL.FALSE otherwise. +// +// GL.LINK_STATUS +// params returns GL.TRUE if the last link operation on program was +// successful, and GL.FALSE otherwise. +// +// GL.VALIDATE_STATUS +// params returns GL.TRUE or if the last validation operation on +// program was successful, and GL.FALSE otherwise. +// +// GL.INFO_LOG_LENGTH +// params returns the number of characters in the information log for +// program including the null termination character (the size of +// the character buffer required to store the information log). If +// program has no information log, a value of 0 is returned. +// +// GL.ATTACHED_SHADERS +// params returns the number of shader objects attached to program. +// +// GL.ACTIVE_ATTRIBUTES +// params returns the number of active attribute variables for program. +// +// GL.ACTIVE_ATTRIBUTE_MAX_LENGTH +// params returns the length of the longest active attribute name for +// program, including the null termination character (the size of +// the character buffer required to store the longest attribute name). +// If no active attributes exist, 0 is returned. +// +// GL.ACTIVE_UNIFORMS +// params returns the number of active uniform variables for program. +// +// GL.ACTIVE_UNIFORM_MAX_LENGTH +// params returns the length of the longest active uniform variable +// name for program, including the null termination character (i.e., +// the size of the character buffer required to store the longest +// uniform variable name). If no active uniform variables exist, 0 is +// returned. +// +// GL.TRANSFORM_FEEDBACK_BUFFER_MODE +// params returns a symbolic constant indicating the buffer mode used +// when transform feedback is active. This may be GL.SEPARATE_ATTRIBS +// or GL.INTERLEAVED_ATTRIBS. +// +// GL.TRANSFORM_FEEDBACK_VARYINGS +// params returns the number of varying variables to capture in transform +// feedback mode for the program. +// +// GL.TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH +// params returns the length of the longest variable name to be used for +// transform feedback, including the null-terminator. +// +// GL.GEOMETRY_VERTICES_OUT +// params returns the maximum number of vertices that the geometry shader in +// program will output. +// +// GL.GEOMETRY_INPUT_TYPE +// params returns a symbolic constant indicating the primitive type accepted +// as input to the geometry shader contained in program. +// +// GL.GEOMETRY_OUTPUT_TYPE +// params returns a symbolic constant indicating the primitive type that will +// be output by the geometry shader contained in program. +// +// GL.ACTIVE_UNIFORM_BLOCKS and GL.ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH are +// available only if the GL version 3.1 or greater. +// +// GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE and +// GL.GEOMETRY_OUTPUT_TYPE are accepted only if the GL version is 3.2 or +// greater. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program does not refer to a +// program object. GL.INVALID_OPERATION is generated if pname is +// GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE, or +// GL.GEOMETRY_OUTPUT_TYPE, and program does not contain a geometry shader. +// GL.INVALID_ENUM is generated if pname is not an accepted value. +func (gl *GL) GetProgramiv(program glbase.Program, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl4_0core_glGetProgramiv(gl.funcs, C.GLuint(program), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetAttribLocation queries the previously linked program object specified +// by program for the attribute variable specified by name and returns the +// index of the generic vertex attribute that is bound to that attribute +// variable. If name is a matrix attribute variable, the index of the first +// column of the matrix is returned. If the named attribute variable is not +// an active attribute in the specified program object or if name starts with +// the reserved prefix "gl_", a value of -1 is returned. +// +// The association between an attribute variable name and a generic attribute +// index can be specified at any time by calling BindAttribLocation. +// Attribute bindings do not go into effect until LinkProgram is called. +// After a program object has been linked successfully, the index values for +// attribute variables remain fixed until the next link command occurs. The +// attribute values can only be queried after a link if the link was +// successful. GetAttribLocation returns the binding that actually went +// into effect the last time LinkProgram was called for the specified +// program object. Attribute bindings that have been specified since the last +// link operation are not returned by GetAttribLocation. +// +// Error GL_INVALID_OPERATION is generated if program is not a value +// generated by OpenGL. GL_INVALID_OPERATION is generated if program is not +// a program object. GL_INVALID_OPERATION is generated if program has not +// been successfully linked. GL_INVALID_OPERATION is generated if +// GetAttribLocation is executed between the execution of Begin and the +// corresponding execution of End. +// +// GetAttribLocation is available in GL version 2.0 or greater. +func (gl *GL) GetAttribLocation(program glbase.Program, name string) glbase.Attrib { + name_cstr := C.CString(name) + glresult := C.gl4_0core_glGetAttribLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) + return glbase.Attrib(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetAttachedShaders.xml +func (gl *GL) GetAttachedShaders(program glbase.Program, maxCount int32, count []int, obj []uint32) { + C.gl4_0core_glGetAttachedShaders(gl.funcs, C.GLuint(program), C.GLsizei(maxCount), (*C.GLsizei)(unsafe.Pointer(&count[0])), (*C.GLuint)(unsafe.Pointer(&obj[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniform.xml +func (gl *GL) GetActiveUniform(program glbase.Program, index uint32, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl4_0core_glGetActiveUniform(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveAttrib.xml +func (gl *GL) GetActiveAttrib(program glbase.Program, index glbase.Attrib, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl4_0core_glGetActiveAttrib(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEnableVertexAttribArray.xml +func (gl *GL) EnableVertexAttribArray(index glbase.Attrib) { + C.gl4_0core_glEnableVertexAttribArray(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDisableVertexAttribArray.xml +func (gl *GL) DisableVertexAttribArray(index glbase.Attrib) { + C.gl4_0core_glDisableVertexAttribArray(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDetachShader.xml +func (gl *GL) DetachShader(program glbase.Program, shader glbase.Shader) { + C.gl4_0core_glDetachShader(gl.funcs, C.GLuint(program), C.GLuint(shader)) +} + +// DeleteShader frees the memory and invalidates the name associated with +// the shader object specified by shader. This command effectively undoes the +// effects of a call to CreateShader. +// +// If a shader object to be deleted is attached to a program object, it will +// be flagged for deletion, but it will not be deleted until it is no longer +// attached to any program object, for any rendering context (it must +// be detached from wherever it was attached before it will be deleted). A +// value of 0 for shader will be silently ignored. +// +// To determine whether an object has been flagged for deletion, call +// GetShader with arguments shader and GL.DELETE_STATUS. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. +// +// DeleteShader is available in GL version 2.0 or greater. +func (gl *GL) DeleteShader(shader glbase.Shader) { + C.gl4_0core_glDeleteShader(gl.funcs, C.GLuint(shader)) +} + +// DeleteProgram frees the memory and invalidates the name associated with +// the program object specified by program. This command effectively undoes +// the effects of a call to CreateProgram. +// +// If a program object is in use as part of current rendering state, it will +// be flagged for deletion, but it will not be deleted until it is no longer +// part of current state for any rendering context. If a program object to be +// deleted has shader objects attached to it, those shader objects will be +// automatically detached but not deleted unless they have already been +// flagged for deletion by a previous call to DeleteShader. A value of 0 +// for program will be silently ignored. +// +// To determine whether a program object has been flagged for deletion, call +// GetProgram with arguments program and GL.DELETE_STATUS. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. +// +// DeleteProgram is available in GL version 2.0 or greater. +func (gl *GL) DeleteProgram(program glbase.Program) { + C.gl4_0core_glDeleteProgram(gl.funcs, C.GLuint(program)) +} + +// CreateShader creates an empty shader object and returns a non-zero value +// by which it can be referenced. A shader object is used to maintain the +// source code strings that define a shader. shaderType indicates the type of +// shader to be created. +// +// Two types of shaders are supported. A shader of type GL.VERTEX_SHADER is a +// shader that is intended to run on the programmable vertex processor and +// replace the fixed functionality vertex processing in OpenGL. A shader of +// type GL.FRAGMENT_SHADER is a shader that is intended to run on the +// programmable fragment processor and replace the fixed functionality +// fragment processing in OpenGL. +// +// When created, a shader object's GL.SHADER_TYPE parameter is set to either +// GL.VERTEX_SHADER or GL.FRAGMENT_SHADER, depending on the value of +// shaderType. +// +// Like display lists and texture objects, the name space for shader objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// This function returns 0 if an error occurs creating the shader object. +// +// Error GL.INVALID_ENUM is generated if shaderType is not an accepted value. +// GL.INVALID_OPERATION is generated if CreateShader is executed between the +// execution of Begin and the corresponding execution of End. +// +// CreateShader is available in GL version 2.0 or greater. +func (gl *GL) CreateShader(gltype glbase.Enum) glbase.Shader { + glresult := C.gl4_0core_glCreateShader(gl.funcs, C.GLenum(gltype)) + return glbase.Shader(glresult) +} + +// CreateProgram creates an empty program object and returns a non-zero +// value by which it can be referenced. A program object is an object to +// which shader objects can be attached. This provides a mechanism to specify +// the shader objects that will be linked to create a program. It also +// provides a means for checking the compatibility of the shaders that will +// be used to create a program (for instance, checking the compatibility +// between a vertex shader and a fragment shader). When no longer needed as +// part of a program object, shader objects can be detached. +// +// One or more executables are created in a program object by successfully +// attaching shader objects to it with AttachShader, successfully compiling +// the shader objects with CompileShader, and successfully linking the +// program object with LinkProgram. These executables are made part of +// current state when UseProgram is called. Program objects can be deleted +// by calling DeleteProgram. The memory associated with the program object +// will be deleted when it is no longer part of current rendering state for +// any context. +// +// Like display lists and texture objects, the name space for program objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// Applications are responsible for providing the synchronization across API +// calls when objects are accessed from different execution threads. +// +// This function returns 0 if an error occurs creating the program object. +// +// Error GL.INVALID_OPERATION is generated if CreateProgram is executed +// between the execution of Begin and the corresponding execution of End. +// +// CreateProgram is available in GL version 2.0 or greater. +func (gl *GL) CreateProgram() glbase.Program { + glresult := C.gl4_0core_glCreateProgram(gl.funcs) + return glbase.Program(glresult) +} + +// CompileShader compiles the source code strings that have been stored in +// the shader object specified by shader. +// +// The compilation status will be stored as part of the shader object's +// state. This value will be set to GL.TRUE if the shader was compiled without +// errors and is ready for use, and GL.FALSE otherwise. It can be queried by +// calling GetShaderiv with arguments shader and GL.COMPILE_STATUS. +// +// Compilation of a shader can fail for a number of reasons as specified by +// the OpenGL Shading Language Specification. Whether or not the compilation +// was successful, information about the compilation can be obtained from the +// shader object's information log by calling GetShaderInfoLog. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_OPERATION is generated if CompileShader is executed +// between the execution of Begin and the corresponding execution of End. +// +// CompileShader is available in GL version 2.0 or greater. +func (gl *GL) CompileShader(shader glbase.Shader) { + C.gl4_0core_glCompileShader(gl.funcs, C.GLuint(shader)) +} + +// BindAttribLocation associates a user-defined attribute variable in the program +// object specified by program with a generic vertex attribute index. The name +// parameter specifies the name of the vertex shader attribute variable to +// which index is to be bound. When program is made part of the current state, +// values provided via the generic vertex attribute index will modify the +// value of the user-defined attribute variable specified by name. +// +// If name refers to a matrix attribute variable, index refers to the first +// column of the matrix. Other matrix columns are then automatically bound to +// locations index+1 for a matrix of type mat2; index+1 and index+2 for a +// matrix of type mat3; and index+1, index+2, and index+3 for a matrix of +// type mat4. +// +// This command makes it possible for vertex shaders to use descriptive names +// for attribute variables rather than generic variables that are numbered +// from 0 to GL.MAX_VERTEX_ATTRIBS-1. The values sent to each generic +// attribute index are part of current state, just like standard vertex +// attributes such as color, normal, and vertex position. If a different +// program object is made current by calling UseProgram, the generic vertex +// attributes are tracked in such a way that the same values will be observed +// by attributes in the new program object that are also bound to index. +// +// Attribute variable name-to-generic attribute index bindings for a program +// object can be explicitly assigned at any time by calling +// BindAttribLocation. Attribute bindings do not go into effect until +// LinkProgram is called. After a program object has been linked +// successfully, the index values for generic attributes remain fixed (and +// their values can be queried) until the next link command occurs. +// +// Applications are not allowed to bind any of the standard OpenGL vertex +// attributes using this command, as they are bound automatically when +// needed. Any attribute binding that occurs after the program object has +// been linked will not take effect until the next time the program object is +// linked. +// +// If name was bound previously, that information is lost. Thus you cannot +// bind one user-defined attribute variable to multiple indices, but you can +// bind multiple user-defined attribute variables to the same index. +// +// Applications are allowed to bind more than one user-defined attribute +// variable to the same generic vertex attribute index. This is called +// aliasing, and it is allowed only if just one of the aliased attributes is +// active in the executable program, or if no path through the shader +// consumes more than one attribute of a set of attributes aliased to the +// same location. The compiler and linker are allowed to assume that no +// aliasing is done and are free to employ optimizations that work only in +// the absence of aliasing. OpenGL implementations are not required to do +// error checking to detect aliasing. Because there is no way to bind +// standard attributes, it is not possible to alias generic attributes with +// conventional ones (except for generic attribute 0). +// +// BindAttribLocation can be called before any vertex shader objects are +// bound to the specified program object. It is also permissible to bind a +// generic attribute index to an attribute variable name that is never used +// in a vertex shader. +// +// Active attributes that are not explicitly bound will be bound by the +// linker when LinkProgram is called. The locations assigned can be queried +// by calling GetAttribLocation. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. +// GL.INVALID_OPERATION is generated if name starts with the reserved prefix "gl_". +// GL.INVALID_VALUE is generated if program is not a value generated by OpenGL. +// GL.INVALID_OPERATION is generated if program is not a program object. +// GL.INVALID_OPERATION is generated if BindAttribLocation is executed +// between the execution of Begin and the corresponding execution of End. +// +// BindAttribLocation is available in GL version 2.0 or greater. +func (gl *GL) BindAttribLocation(program glbase.Program, index glbase.Attrib, name string) { + name_cstr := C.CString(name) + C.gl4_0core_glBindAttribLocation(gl.funcs, C.GLuint(program), C.GLuint(index), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) +} + +// AttachShader attaches a shader object to a program object. +// +// In order to create an executable, there must be a way to specify the list +// of things that will be linked together. Program objects provide this +// mechanism. Shaders that are to be linked together in a program object must +// first be attached to that program object. This indicates that shader will +// be included in link operations that will be performed on program. +// +// All operations that can be performed on a shader object are valid whether +// or not the shader object is attached to a program object. It is +// permissible to attach a shader object to a program object before source +// code has been loaded into the shader object or before the shader object +// has been compiled. It is permissible to attach multiple shader objects of +// the same type because each may contain a portion of the complete shader. +// It is also permissible to attach a shader object to more than one program +// object. If a shader object is deleted while it is attached to a program +// object, it will be flagged for deletion, and deletion will not occur until +// DetachShader is called to detach it from all program objects to which it +// is attached. +// +// Error GL.INVALID_VALUE is generated if either program or shader is not a +// value generated by OpenGL. GL.INVALID_OPERATION is generated if program +// is not a program object. GL.INVALID_OPERATION is generated if shader is +// not a shader object. GL.INVALID_OPERATION is generated if shader is +// already attached to program. GL.INVALID_OPERATION is generated if +// AttachShader is executed between the execution of Begin and the +// corresponding execution of End. +// +// AttachShader is available in GL version 2.0 or greater. +func (gl *GL) AttachShader(program glbase.Program, shader glbase.Shader) { + C.gl4_0core_glAttachShader(gl.funcs, C.GLuint(program), C.GLuint(shader)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilMaskSeparate.xml +func (gl *GL) StencilMaskSeparate(face glbase.Enum, mask uint32) { + C.gl4_0core_glStencilMaskSeparate(gl.funcs, C.GLenum(face), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilFuncSeparate.xml +func (gl *GL) StencilFuncSeparate(face, glfunc glbase.Enum, ref int32, mask uint32) { + C.gl4_0core_glStencilFuncSeparate(gl.funcs, C.GLenum(face), C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilOpSeparate.xml +func (gl *GL) StencilOpSeparate(face, sfail, dpfail, dppass glbase.Enum) { + C.gl4_0core_glStencilOpSeparate(gl.funcs, C.GLenum(face), C.GLenum(sfail), C.GLenum(dpfail), C.GLenum(dppass)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawBuffers.xml +func (gl *GL) DrawBuffers(n int, bufs []glbase.Enum) { + C.gl4_0core_glDrawBuffers(gl.funcs, C.GLsizei(n), (*C.GLenum)(unsafe.Pointer(&bufs[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendEquationSeparate.xml +func (gl *GL) BlendEquationSeparate(modeRGB, modeAlpha glbase.Enum) { + C.gl4_0core_glBlendEquationSeparate(gl.funcs, C.GLenum(modeRGB), C.GLenum(modeAlpha)) +} + +// UniformMatrix4x3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4x3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4x3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*3) != 0 { + panic("invalid value length for UniformMatrix4x3fv") + } + count := len(value) / (4 * 3) + C.gl4_0core_glUniformMatrix4x3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3x4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3x4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3x4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*4) != 0 { + panic("invalid value length for UniformMatrix3x4fv") + } + count := len(value) / (3 * 4) + C.gl4_0core_glUniformMatrix3x4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix4x2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4x2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4x2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*2) != 0 { + panic("invalid value length for UniformMatrix4x2fv") + } + count := len(value) / (4 * 2) + C.gl4_0core_glUniformMatrix4x2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2x4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2x4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2x4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*4) != 0 { + panic("invalid value length for UniformMatrix2x4fv") + } + count := len(value) / (2 * 4) + C.gl4_0core_glUniformMatrix2x4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3x2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3x2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3x2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*2) != 0 { + panic("invalid value length for UniformMatrix3x2fv") + } + count := len(value) / (3 * 2) + C.gl4_0core_glUniformMatrix3x2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2x3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2x3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2x3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*3) != 0 { + panic("invalid value length for UniformMatrix2x3fv") + } + count := len(value) / (2 * 3) + C.gl4_0core_glUniformMatrix2x3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsVertexArray.xml +func (gl *GL) IsVertexArray(array uint32) bool { + glresult := C.gl4_0core_glIsVertexArray(gl.funcs, C.GLuint(array)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenVertexArrays.xml +func (gl *GL) GenVertexArrays(n int, arrays []uint32) { + C.gl4_0core_glGenVertexArrays(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&arrays[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteVertexArrays.xml +func (gl *GL) DeleteVertexArrays(n int, arrays []uint32) { + C.gl4_0core_glDeleteVertexArrays(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&arrays[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindVertexArray.xml +func (gl *GL) BindVertexArray(array uint32) { + C.gl4_0core_glBindVertexArray(gl.funcs, C.GLuint(array)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFlushMappedBufferRange.xml +func (gl *GL) FlushMappedBufferRange(target glbase.Enum, offset, length int) { + C.gl4_0core_glFlushMappedBufferRange(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(length)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTextureLayer.xml +func (gl *GL) FramebufferTextureLayer(target, attachment glbase.Enum, texture glbase.Texture, level int, layer int32) { + C.gl4_0core_glFramebufferTextureLayer(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLuint(texture), C.GLint(level), C.GLint(layer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRenderbufferStorageMultisample.xml +func (gl *GL) RenderbufferStorageMultisample(target glbase.Enum, samples int32, internalFormat glbase.Enum, width, height int) { + C.gl4_0core_glRenderbufferStorageMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlitFramebuffer.xml +func (gl *GL) BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1 int32, mask glbase.Bitfield, filter glbase.Enum) { + C.gl4_0core_glBlitFramebuffer(gl.funcs, C.GLint(srcX0), C.GLint(srcY0), C.GLint(srcX1), C.GLint(srcY1), C.GLint(dstX0), C.GLint(dstY0), C.GLint(dstX1), C.GLint(dstY1), C.GLbitfield(mask), C.GLenum(filter)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenerateMipmap.xml +func (gl *GL) GenerateMipmap(target glbase.Enum) { + C.gl4_0core_glGenerateMipmap(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFramebufferAttachmentParameteriv.xml +func (gl *GL) GetFramebufferAttachmentParameteriv(target, attachment, pname glbase.Enum, params []int32) { + C.gl4_0core_glGetFramebufferAttachmentParameteriv(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferRenderbuffer.xml +func (gl *GL) FramebufferRenderbuffer(target, attachment, renderbuffertarget glbase.Enum, renderbuffer glbase.Renderbuffer) { + C.gl4_0core_glFramebufferRenderbuffer(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(renderbuffertarget), C.GLuint(renderbuffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture3D.xml +func (gl *GL) FramebufferTexture3D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int, zoffset int32) { + C.gl4_0core_glFramebufferTexture3D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level), C.GLint(zoffset)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture2D.xml +func (gl *GL) FramebufferTexture2D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int) { + C.gl4_0core_glFramebufferTexture2D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture1D.xml +func (gl *GL) FramebufferTexture1D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int) { + C.gl4_0core_glFramebufferTexture1D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCheckFramebufferStatus.xml +func (gl *GL) CheckFramebufferStatus(target glbase.Enum) glbase.Enum { + glresult := C.gl4_0core_glCheckFramebufferStatus(gl.funcs, C.GLenum(target)) + return glbase.Enum(glresult) +} + +// GenFramebuffers returns n framebuffer object names in ids. There is no +// guarantee that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenFramebuffers. +// +// Framebuffer object names returned by a call to GenFramebuffers are not +// returned by subsequent calls, unless they are first deleted with +// DeleteFramebuffers. +// +// The names returned in ids are marked as used, for the purposes of +// GenFramebuffers only, but they acquire state and type only when they are +// first bound. +// +// Error GL.INVALID_VALUE is generated if n is negative. +func (gl *GL) GenFramebuffers(n int) []glbase.Framebuffer { + if n == 0 { + return nil + } + framebuffers := make([]glbase.Framebuffer, n) + C.gl4_0core_glGenFramebuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&framebuffers[0]))) + return framebuffers +} + +// DeleteFramebuffers deletes the framebuffer objects whose names are +// stored in the framebuffers slice. The name zero is reserved by the GL and +// is silently ignored, should it occur in framebuffers, as are other unused +// names. Once a framebuffer object is deleted, its name is again unused and +// it has no attachments. If a framebuffer that is currently bound to one or +// more of the targets GL.DRAW_FRAMEBUFFER or GL.READ_FRAMEBUFFER is deleted, +// it is as though BindFramebuffer had been executed with the corresponding +// target and framebuffer zero. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteFramebuffers is available in GL version 3.0 or greater. +func (gl *GL) DeleteFramebuffers(framebuffers []glbase.Framebuffer) { + n := len(framebuffers) + if n == 0 { + return + } + C.gl4_0core_glDeleteFramebuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&framebuffers[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindFramebuffer.xml +func (gl *GL) BindFramebuffer(target glbase.Enum, framebuffer glbase.Framebuffer) { + C.gl4_0core_glBindFramebuffer(gl.funcs, C.GLenum(target), C.GLuint(framebuffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsFramebuffer.xml +func (gl *GL) IsFramebuffer(framebuffer glbase.Framebuffer) bool { + glresult := C.gl4_0core_glIsFramebuffer(gl.funcs, C.GLuint(framebuffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetRenderbufferParameteriv.xml +func (gl *GL) GetRenderbufferParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_0core_glGetRenderbufferParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRenderbufferStorage.xml +func (gl *GL) RenderbufferStorage(target, internalFormat glbase.Enum, width, height int) { + C.gl4_0core_glRenderbufferStorage(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) +} + +// GenRenderbuffers returns n renderbuffer object names in renderbuffers. +// There is no guarantee that the names form a contiguous set of integers; +// however, it is guaranteed that none of the returned names was in use +// immediately before the call to GenRenderbuffers. +// +// Renderbuffer object names returned by a call to GenRenderbuffers are not +// returned by subsequent calls, unless they are first deleted with +// DeleteRenderbuffers. +// +// The names returned in renderbuffers are marked as used, for the purposes +// of GenRenderbuffers only, but they acquire state and type only when they +// are first bound. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenRenderbuffers is available in GL version 3.0 or greater. +func (gl *GL) GenRenderbuffers(n int) []glbase.Renderbuffer { + if n == 0 { + return nil + } + renderbuffers := make([]glbase.Renderbuffer, n) + C.gl4_0core_glGenRenderbuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&renderbuffers[0]))) + return renderbuffers +} + +// DeleteRenderbuffers deletes the renderbuffer objects whose names are stored +// in the renderbuffers slice. The name zero is reserved by the GL and +// is silently ignored, should it occur in renderbuffers, as are other unused +// names. Once a renderbuffer object is deleted, its name is again unused and +// it has no contents. If a renderbuffer that is currently bound to the +// target GL.RENDERBUFFER is deleted, it is as though BindRenderbuffer had +// been executed with a target of GL.RENDERBUFFER and a name of zero. +// +// If a renderbuffer object is attached to one or more attachment points in +// the currently bound framebuffer, then it as if FramebufferRenderbuffer +// had been called, with a renderbuffer of zero for each attachment point to +// which this image was attached in the currently bound framebuffer. In other +// words, this renderbuffer object is first detached from all attachment +// ponits in the currently bound framebuffer. Note that the renderbuffer +// image is specifically not detached from any non-bound framebuffers. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteRenderbuffers is available in GL version 3.0 or greater. +func (gl *GL) DeleteRenderbuffers(renderbuffers []glbase.Renderbuffer) { + n := len(renderbuffers) + if n == 0 { + return + } + C.gl4_0core_glDeleteRenderbuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&renderbuffers[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindRenderbuffer.xml +func (gl *GL) BindRenderbuffer(target glbase.Enum, renderbuffer glbase.Renderbuffer) { + C.gl4_0core_glBindRenderbuffer(gl.funcs, C.GLenum(target), C.GLuint(renderbuffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsRenderbuffer.xml +func (gl *GL) IsRenderbuffer(renderbuffer glbase.Renderbuffer) bool { + glresult := C.gl4_0core_glIsRenderbuffer(gl.funcs, C.GLuint(renderbuffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferfi.xml +func (gl *GL) ClearBufferfi(buffer glbase.Enum, drawbuffer int32, depth float32, stencil int32) { + C.gl4_0core_glClearBufferfi(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), C.GLfloat(depth), C.GLint(stencil)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferfv.xml +func (gl *GL) ClearBufferfv(buffer glbase.Enum, drawbuffer int32, value []float32) { + C.gl4_0core_glClearBufferfv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferuiv.xml +func (gl *GL) ClearBufferuiv(buffer glbase.Enum, drawbuffer int32, value []uint32) { + C.gl4_0core_glClearBufferuiv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferiv.xml +func (gl *GL) ClearBufferiv(buffer glbase.Enum, drawbuffer int32, value []int32) { + C.gl4_0core_glClearBufferiv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameterIuiv.xml +func (gl *GL) GetTexParameterIuiv(target, pname glbase.Enum, params []uint32) { + C.gl4_0core_glGetTexParameterIuiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameterIiv.xml +func (gl *GL) GetTexParameterIiv(target, pname glbase.Enum, params []int32) { + C.gl4_0core_glGetTexParameterIiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterIuiv.xml +func (gl *GL) TexParameterIuiv(target, pname glbase.Enum, params []uint32) { + C.gl4_0core_glTexParameterIuiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterIiv.xml +func (gl *GL) TexParameterIiv(target, pname glbase.Enum, params []int32) { + C.gl4_0core_glTexParameterIiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// Uniform4uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4uiv") + } + count := len(value) / 4 + C.gl4_0core_glUniform4uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform3uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3uiv") + } + count := len(value) / 3 + C.gl4_0core_glUniform3uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform2uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2uiv") + } + count := len(value) / 2 + C.gl4_0core_glUniform2uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform1uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl4_0core_glUniform1uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform4ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4ui(location glbase.Uniform, v0, v1, v2, v3 uint32) { + C.gl4_0core_glUniform4ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2), C.GLuint(v3)) +} + +// Uniform3ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3ui(location glbase.Uniform, v0, v1, v2 uint32) { + C.gl4_0core_glUniform3ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2)) +} + +// Uniform2ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2ui(location glbase.Uniform, v0, v1 uint32) { + C.gl4_0core_glUniform2ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1)) +} + +// Uniform1ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1ui(location glbase.Uniform, v0 uint32) { + C.gl4_0core_glUniform1ui(gl.funcs, C.GLint(location), C.GLuint(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFragDataLocation.xml +func (gl *GL) GetFragDataLocation(program glbase.Program, name []byte) int32 { + glresult := C.gl4_0core_glGetFragDataLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindFragDataLocation.xml +func (gl *GL) BindFragDataLocation(program glbase.Program, color uint32, name []byte) { + C.gl4_0core_glBindFragDataLocation(gl.funcs, C.GLuint(program), C.GLuint(color), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetUniformuiv.xml +func (gl *GL) GetUniformuiv(program glbase.Program, location glbase.Uniform, params []uint32) { + C.gl4_0core_glGetUniformuiv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetVertexAttribIuiv.xml +func (gl *GL) GetVertexAttribIuiv(index glbase.Attrib, pname glbase.Enum, params []uint32) { + C.gl4_0core_glGetVertexAttribIuiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetVertexAttribIiv.xml +func (gl *GL) GetVertexAttribIiv(index glbase.Attrib, pname glbase.Enum, params []int32) { + C.gl4_0core_glGetVertexAttribIiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribIPointer.xml +func (gl *GL) VertexAttribIPointer(index glbase.Attrib, size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_0core_glVertexAttribIPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndConditionalRender.xml +func (gl *GL) EndConditionalRender() { + C.gl4_0core_glEndConditionalRender(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBeginConditionalRender.xml +func (gl *GL) BeginConditionalRender(id uint32, mode glbase.Enum) { + C.gl4_0core_glBeginConditionalRender(gl.funcs, C.GLuint(id), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClampColor.xml +func (gl *GL) ClampColor(target, clamp glbase.Enum) { + C.gl4_0core_glClampColor(gl.funcs, C.GLenum(target), C.GLenum(clamp)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTransformFeedbackVarying.xml +func (gl *GL) GetTransformFeedbackVarying(program glbase.Program, index uint32, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl4_0core_glGetTransformFeedbackVarying(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLsizei)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindBufferBase.xml +func (gl *GL) BindBufferBase(target glbase.Enum, index uint32, buffer glbase.Buffer) { + C.gl4_0core_glBindBufferBase(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindBufferRange.xml +func (gl *GL) BindBufferRange(target glbase.Enum, index uint32, buffer glbase.Buffer, offset, size int) { + C.gl4_0core_glBindBufferRange(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(buffer), C.GLintptr(offset), C.GLsizeiptr(size)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndTransformFeedback.xml +func (gl *GL) EndTransformFeedback() { + C.gl4_0core_glEndTransformFeedback(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBeginTransformFeedback.xml +func (gl *GL) BeginTransformFeedback(primitiveMode glbase.Enum) { + C.gl4_0core_glBeginTransformFeedback(gl.funcs, C.GLenum(primitiveMode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsEnabledi.xml +func (gl *GL) IsEnabledi(target glbase.Enum, index uint32) bool { + glresult := C.gl4_0core_glIsEnabledi(gl.funcs, C.GLenum(target), C.GLuint(index)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDisablei.xml +func (gl *GL) Disablei(target glbase.Enum, index uint32) { + C.gl4_0core_glDisablei(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEnablei.xml +func (gl *GL) Enablei(target glbase.Enum, index uint32) { + C.gl4_0core_glEnablei(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetIntegeri_v.xml +func (gl *GL) GetIntegeri_v(target glbase.Enum, index uint32, data []int32) { + C.gl4_0core_glGetIntegeri_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLint)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBooleani_v.xml +func (gl *GL) GetBooleani_v(target glbase.Enum, index uint32, data []bool) { + C.gl4_0core_glGetBooleani_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLboolean)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorMaski.xml +func (gl *GL) ColorMaski(index uint32, r, g, b, a bool) { + C.gl4_0core_glColorMaski(gl.funcs, C.GLuint(index), *(*C.GLboolean)(unsafe.Pointer(&r)), *(*C.GLboolean)(unsafe.Pointer(&g)), *(*C.GLboolean)(unsafe.Pointer(&b)), *(*C.GLboolean)(unsafe.Pointer(&a))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyBufferSubData.xml +func (gl *GL) CopyBufferSubData(readTarget, writeTarget glbase.Enum, readOffset, writeOffset, size int) { + C.gl4_0core_glCopyBufferSubData(gl.funcs, C.GLenum(readTarget), C.GLenum(writeTarget), C.GLintptr(readOffset), C.GLintptr(writeOffset), C.GLsizeiptr(size)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformBlockBinding.xml +func (gl *GL) UniformBlockBinding(program glbase.Program, v0, v1 uint32) { + C.gl4_0core_glUniformBlockBinding(gl.funcs, C.GLuint(program), C.GLuint(v0), C.GLuint(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformBlockName.xml +func (gl *GL) GetActiveUniformBlockName(program glbase.Program, uniformBlockIndex uint32, bufSize int32, length []int32, uniformBlockName []byte) { + C.gl4_0core_glGetActiveUniformBlockName(gl.funcs, C.GLuint(program), C.GLuint(uniformBlockIndex), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&uniformBlockName[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformBlockiv.xml +func (gl *GL) GetActiveUniformBlockiv(program glbase.Program, uniformBlockIndex uint32, pname glbase.Enum, params []int32) { + C.gl4_0core_glGetActiveUniformBlockiv(gl.funcs, C.GLuint(program), C.GLuint(uniformBlockIndex), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetUniformBlockIndex.xml +func (gl *GL) GetUniformBlockIndex(program glbase.Program, uniformBlockName []byte) uint32 { + glresult := C.gl4_0core_glGetUniformBlockIndex(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&uniformBlockName[0]))) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformName.xml +func (gl *GL) GetActiveUniformName(program glbase.Program, uniformIndex uint32, bufSize int32, length []int32, uniformName []byte) { + C.gl4_0core_glGetActiveUniformName(gl.funcs, C.GLuint(program), C.GLuint(uniformIndex), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&uniformName[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformsiv.xml +func (gl *GL) GetActiveUniformsiv(program glbase.Program, uniformCount int32, uniformIndices []uint32, pname glbase.Enum, params []int32) { + C.gl4_0core_glGetActiveUniformsiv(gl.funcs, C.GLuint(program), C.GLsizei(uniformCount), (*C.GLuint)(unsafe.Pointer(&uniformIndices[0])), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPrimitiveRestartIndex.xml +func (gl *GL) PrimitiveRestartIndex(index uint32) { + C.gl4_0core_glPrimitiveRestartIndex(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexBuffer.xml +func (gl *GL) TexBuffer(target, internalFormat glbase.Enum, buffer glbase.Buffer) { + C.gl4_0core_glTexBuffer(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsInstanced.xml +func (gl *GL) DrawElementsInstanced(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, instancecount int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_0core_glDrawElementsInstanced(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLsizei(instancecount)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawArraysInstanced.xml +func (gl *GL) DrawArraysInstanced(mode glbase.Enum, first, count int, instancecount int32) { + C.gl4_0core_glDrawArraysInstanced(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count), C.GLsizei(instancecount)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSampleMaski.xml +func (gl *GL) SampleMaski(index uint32, mask glbase.Bitfield) { + C.gl4_0core_glSampleMaski(gl.funcs, C.GLuint(index), C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMultisamplefv.xml +func (gl *GL) GetMultisamplefv(pname glbase.Enum, index uint32, val []float32) { + C.gl4_0core_glGetMultisamplefv(gl.funcs, C.GLenum(pname), C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&val[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage3DMultisample.xml +func (gl *GL) TexImage3DMultisample(target glbase.Enum, samples, internalFormat int32, width, height int, depth int32, fixedsamplelocations bool) { + C.gl4_0core_glTexImage3DMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), *(*C.GLboolean)(unsafe.Pointer(&fixedsamplelocations))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage2DMultisample.xml +func (gl *GL) TexImage2DMultisample(target glbase.Enum, samples, internalFormat int32, width, height int, fixedsamplelocations bool) { + C.gl4_0core_glTexImage2DMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), *(*C.GLboolean)(unsafe.Pointer(&fixedsamplelocations))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSynciv.xml +func (gl *GL) GetSynciv(sync glbase.Sync, pname glbase.Enum, bufSize int32, length, values []int32) { + C.gl4_0core_glGetSynciv(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLenum(pname), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetInteger64v.xml +func (gl *GL) GetInteger64v(pname glbase.Enum, params []int64) { + C.gl4_0core_glGetInteger64v(gl.funcs, C.GLenum(pname), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWaitSync.xml +func (gl *GL) WaitSync(sync glbase.Sync, flags glbase.Bitfield, timeout uint64) { + C.gl4_0core_glWaitSync(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLbitfield(flags), C.GLuint64(timeout)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClientWaitSync.xml +func (gl *GL) ClientWaitSync(sync glbase.Sync, flags glbase.Bitfield, timeout uint64) glbase.Enum { + glresult := C.gl4_0core_glClientWaitSync(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLbitfield(flags), C.GLuint64(timeout)) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteSync.xml +func (gl *GL) DeleteSync(sync glbase.Sync) { + C.gl4_0core_glDeleteSync(gl.funcs, C.GLsync(unsafe.Pointer(sync))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsSync.xml +func (gl *GL) IsSync(sync glbase.Sync) bool { + glresult := C.gl4_0core_glIsSync(gl.funcs, C.GLsync(unsafe.Pointer(sync))) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFenceSync.xml +func (gl *GL) FenceSync(condition glbase.Enum, flags glbase.Bitfield) glbase.Sync { + glresult := C.gl4_0core_glFenceSync(gl.funcs, C.GLenum(condition), C.GLbitfield(flags)) + return glbase.Sync(unsafe.Pointer(glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProvokingVertex.xml +func (gl *GL) ProvokingVertex(mode glbase.Enum) { + C.gl4_0core_glProvokingVertex(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsInstancedBaseVertex.xml +func (gl *GL) DrawElementsInstancedBaseVertex(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, instancecount, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_0core_glDrawElementsInstancedBaseVertex(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLsizei(instancecount), C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawRangeElementsBaseVertex.xml +func (gl *GL) DrawRangeElementsBaseVertex(mode glbase.Enum, start, end uint32, count int, gltype glbase.Enum, indices interface{}, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_0core_glDrawRangeElementsBaseVertex(gl.funcs, C.GLenum(mode), C.GLuint(start), C.GLuint(end), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsBaseVertex.xml +func (gl *GL) DrawElementsBaseVertex(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_0core_glDrawElementsBaseVertex(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture.xml +func (gl *GL) FramebufferTexture(target, attachment glbase.Enum, texture glbase.Texture, level int) { + C.gl4_0core_glFramebufferTexture(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBufferParameteri64v.xml +func (gl *GL) GetBufferParameteri64v(target, pname glbase.Enum, params []int64) { + C.gl4_0core_glGetBufferParameteri64v(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetInteger64i_v.xml +func (gl *GL) GetInteger64i_v(target glbase.Enum, index uint32, data []int64) { + C.gl4_0core_glGetInteger64i_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLint64)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP4uiv.xml +func (gl *GL) VertexAttribP4uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl4_0core_glVertexAttribP4uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP4ui.xml +func (gl *GL) VertexAttribP4ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl4_0core_glVertexAttribP4ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP3uiv.xml +func (gl *GL) VertexAttribP3uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl4_0core_glVertexAttribP3uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP3ui.xml +func (gl *GL) VertexAttribP3ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl4_0core_glVertexAttribP3ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP2uiv.xml +func (gl *GL) VertexAttribP2uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl4_0core_glVertexAttribP2uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP2ui.xml +func (gl *GL) VertexAttribP2ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl4_0core_glVertexAttribP2ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP1uiv.xml +func (gl *GL) VertexAttribP1uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl4_0core_glVertexAttribP1uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP1ui.xml +func (gl *GL) VertexAttribP1ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl4_0core_glVertexAttribP1ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColorP3uiv.xml +func (gl *GL) SecondaryColorP3uiv(gltype glbase.Enum, color []uint32) { + C.gl4_0core_glSecondaryColorP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&color[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColorP3ui.xml +func (gl *GL) SecondaryColorP3ui(gltype glbase.Enum, color uint32) { + C.gl4_0core_glSecondaryColorP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(color)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorP4uiv.xml +func (gl *GL) ColorP4uiv(gltype glbase.Enum, color []uint32) { + C.gl4_0core_glColorP4uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&color[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorP4ui.xml +func (gl *GL) ColorP4ui(gltype glbase.Enum, color uint32) { + C.gl4_0core_glColorP4ui(gl.funcs, C.GLenum(gltype), C.GLuint(color)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorP3uiv.xml +func (gl *GL) ColorP3uiv(gltype glbase.Enum, color []uint32) { + C.gl4_0core_glColorP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&color[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorP3ui.xml +func (gl *GL) ColorP3ui(gltype glbase.Enum, color uint32) { + C.gl4_0core_glColorP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(color)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormalP3uiv.xml +func (gl *GL) NormalP3uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_0core_glNormalP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormalP3ui.xml +func (gl *GL) NormalP3ui(gltype glbase.Enum, coords uint32) { + C.gl4_0core_glNormalP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP4uiv.xml +func (gl *GL) MultiTexCoordP4uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl4_0core_glMultiTexCoordP4uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP4ui.xml +func (gl *GL) MultiTexCoordP4ui(texture, gltype glbase.Enum, coords uint32) { + C.gl4_0core_glMultiTexCoordP4ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP3uiv.xml +func (gl *GL) MultiTexCoordP3uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl4_0core_glMultiTexCoordP3uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP3ui.xml +func (gl *GL) MultiTexCoordP3ui(texture, gltype glbase.Enum, coords uint32) { + C.gl4_0core_glMultiTexCoordP3ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP2uiv.xml +func (gl *GL) MultiTexCoordP2uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl4_0core_glMultiTexCoordP2uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP2ui.xml +func (gl *GL) MultiTexCoordP2ui(texture, gltype glbase.Enum, coords uint32) { + C.gl4_0core_glMultiTexCoordP2ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP1uiv.xml +func (gl *GL) MultiTexCoordP1uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl4_0core_glMultiTexCoordP1uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP1ui.xml +func (gl *GL) MultiTexCoordP1ui(texture, gltype glbase.Enum, coords uint32) { + C.gl4_0core_glMultiTexCoordP1ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP4uiv.xml +func (gl *GL) TexCoordP4uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_0core_glTexCoordP4uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP4ui.xml +func (gl *GL) TexCoordP4ui(gltype glbase.Enum, coords uint32) { + C.gl4_0core_glTexCoordP4ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP3uiv.xml +func (gl *GL) TexCoordP3uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_0core_glTexCoordP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP3ui.xml +func (gl *GL) TexCoordP3ui(gltype glbase.Enum, coords uint32) { + C.gl4_0core_glTexCoordP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP2uiv.xml +func (gl *GL) TexCoordP2uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_0core_glTexCoordP2uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP2ui.xml +func (gl *GL) TexCoordP2ui(gltype glbase.Enum, coords uint32) { + C.gl4_0core_glTexCoordP2ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP1uiv.xml +func (gl *GL) TexCoordP1uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_0core_glTexCoordP1uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP1ui.xml +func (gl *GL) TexCoordP1ui(gltype glbase.Enum, coords uint32) { + C.gl4_0core_glTexCoordP1ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP4uiv.xml +func (gl *GL) VertexP4uiv(gltype glbase.Enum, value []uint32) { + C.gl4_0core_glVertexP4uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP4ui.xml +func (gl *GL) VertexP4ui(gltype glbase.Enum, value uint32) { + C.gl4_0core_glVertexP4ui(gl.funcs, C.GLenum(gltype), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP3uiv.xml +func (gl *GL) VertexP3uiv(gltype glbase.Enum, value []uint32) { + C.gl4_0core_glVertexP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP3ui.xml +func (gl *GL) VertexP3ui(gltype glbase.Enum, value uint32) { + C.gl4_0core_glVertexP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP2uiv.xml +func (gl *GL) VertexP2uiv(gltype glbase.Enum, value []uint32) { + C.gl4_0core_glVertexP2uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP2ui.xml +func (gl *GL) VertexP2ui(gltype glbase.Enum, value uint32) { + C.gl4_0core_glVertexP2ui(gl.funcs, C.GLenum(gltype), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryObjectui64v.xml +func (gl *GL) GetQueryObjectui64v(id uint32, pname glbase.Enum, params []uint64) { + C.gl4_0core_glGetQueryObjectui64v(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLuint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryObjecti64v.xml +func (gl *GL) GetQueryObjecti64v(id uint32, pname glbase.Enum, params []int64) { + C.gl4_0core_glGetQueryObjecti64v(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glQueryCounter.xml +func (gl *GL) QueryCounter(id uint32, target glbase.Enum) { + C.gl4_0core_glQueryCounter(gl.funcs, C.GLuint(id), C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSamplerParameterIuiv.xml +func (gl *GL) GetSamplerParameterIuiv(sampler uint32, pname glbase.Enum, params []uint32) { + C.gl4_0core_glGetSamplerParameterIuiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSamplerParameterfv.xml +func (gl *GL) GetSamplerParameterfv(sampler uint32, pname glbase.Enum, params []float32) { + C.gl4_0core_glGetSamplerParameterfv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSamplerParameterIiv.xml +func (gl *GL) GetSamplerParameterIiv(sampler uint32, pname glbase.Enum, params []int32) { + C.gl4_0core_glGetSamplerParameterIiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSamplerParameteriv.xml +func (gl *GL) GetSamplerParameteriv(sampler uint32, pname glbase.Enum, params []int32) { + C.gl4_0core_glGetSamplerParameteriv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameterIuiv.xml +func (gl *GL) SamplerParameterIuiv(sampler uint32, pname glbase.Enum, param []uint32) { + C.gl4_0core_glSamplerParameterIuiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameterIiv.xml +func (gl *GL) SamplerParameterIiv(sampler uint32, pname glbase.Enum, param []int32) { + C.gl4_0core_glSamplerParameterIiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameterfv.xml +func (gl *GL) SamplerParameterfv(sampler uint32, pname glbase.Enum, param []float32) { + C.gl4_0core_glSamplerParameterfv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameterf.xml +func (gl *GL) SamplerParameterf(sampler uint32, pname glbase.Enum, param float32) { + C.gl4_0core_glSamplerParameterf(gl.funcs, C.GLuint(sampler), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameteriv.xml +func (gl *GL) SamplerParameteriv(sampler uint32, pname glbase.Enum, param []int32) { + C.gl4_0core_glSamplerParameteriv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameteri.xml +func (gl *GL) SamplerParameteri(sampler uint32, pname glbase.Enum, param int32) { + C.gl4_0core_glSamplerParameteri(gl.funcs, C.GLuint(sampler), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindSampler.xml +func (gl *GL) BindSampler(unit, sampler uint32) { + C.gl4_0core_glBindSampler(gl.funcs, C.GLuint(unit), C.GLuint(sampler)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsSampler.xml +func (gl *GL) IsSampler(sampler uint32) bool { + glresult := C.gl4_0core_glIsSampler(gl.funcs, C.GLuint(sampler)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteSamplers.xml +func (gl *GL) DeleteSamplers(count int, samplers []uint32) { + C.gl4_0core_glDeleteSamplers(gl.funcs, C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&samplers[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenSamplers.xml +func (gl *GL) GenSamplers(count int, samplers []uint32) { + C.gl4_0core_glGenSamplers(gl.funcs, C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&samplers[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFragDataIndex.xml +func (gl *GL) GetFragDataIndex(program glbase.Program, name []byte) int32 { + glresult := C.gl4_0core_glGetFragDataIndex(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindFragDataLocationIndexed.xml +func (gl *GL) BindFragDataLocationIndexed(program glbase.Program, colorNumber, index uint32, name []byte) { + C.gl4_0core_glBindFragDataLocationIndexed(gl.funcs, C.GLuint(program), C.GLuint(colorNumber), C.GLuint(index), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribDivisor.xml +func (gl *GL) VertexAttribDivisor(index glbase.Attrib, divisor uint32) { + C.gl4_0core_glVertexAttribDivisor(gl.funcs, C.GLuint(index), C.GLuint(divisor)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryIndexediv.xml +func (gl *GL) GetQueryIndexediv(target glbase.Enum, index uint32, pname glbase.Enum, params []int32) { + C.gl4_0core_glGetQueryIndexediv(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndQueryIndexed.xml +func (gl *GL) EndQueryIndexed(target glbase.Enum, index uint32) { + C.gl4_0core_glEndQueryIndexed(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBeginQueryIndexed.xml +func (gl *GL) BeginQueryIndexed(target glbase.Enum, index, id uint32) { + C.gl4_0core_glBeginQueryIndexed(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawTransformFeedbackStream.xml +func (gl *GL) DrawTransformFeedbackStream(mode glbase.Enum, id, stream uint32) { + C.gl4_0core_glDrawTransformFeedbackStream(gl.funcs, C.GLenum(mode), C.GLuint(id), C.GLuint(stream)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawTransformFeedback.xml +func (gl *GL) DrawTransformFeedback(mode glbase.Enum, id uint32) { + C.gl4_0core_glDrawTransformFeedback(gl.funcs, C.GLenum(mode), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glResumeTransformFeedback.xml +func (gl *GL) ResumeTransformFeedback() { + C.gl4_0core_glResumeTransformFeedback(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPauseTransformFeedback.xml +func (gl *GL) PauseTransformFeedback() { + C.gl4_0core_glPauseTransformFeedback(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsTransformFeedback.xml +func (gl *GL) IsTransformFeedback(id uint32) bool { + glresult := C.gl4_0core_glIsTransformFeedback(gl.funcs, C.GLuint(id)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenTransformFeedbacks.xml +func (gl *GL) GenTransformFeedbacks(n int, ids []uint32) { + C.gl4_0core_glGenTransformFeedbacks(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteTransformFeedbacks.xml +func (gl *GL) DeleteTransformFeedbacks(n int, ids []uint32) { + C.gl4_0core_glDeleteTransformFeedbacks(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindTransformFeedback.xml +func (gl *GL) BindTransformFeedback(target glbase.Enum, id uint32) { + C.gl4_0core_glBindTransformFeedback(gl.funcs, C.GLenum(target), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPatchParameterfv.xml +func (gl *GL) PatchParameterfv(pname glbase.Enum, values []float32) { + C.gl4_0core_glPatchParameterfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPatchParameteri.xml +func (gl *GL) PatchParameteri(pname glbase.Enum, value int32) { + C.gl4_0core_glPatchParameteri(gl.funcs, C.GLenum(pname), C.GLint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramStageiv.xml +func (gl *GL) GetProgramStageiv(program glbase.Program, shadertype, pname glbase.Enum, values []int32) { + C.gl4_0core_glGetProgramStageiv(gl.funcs, C.GLuint(program), C.GLenum(shadertype), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetUniformSubroutineuiv.xml +func (gl *GL) GetUniformSubroutineuiv(shadertype glbase.Enum, location glbase.Uniform, params []uint32) { + C.gl4_0core_glGetUniformSubroutineuiv(gl.funcs, C.GLenum(shadertype), C.GLint(location), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformSubroutinesuiv.xml +func (gl *GL) UniformSubroutinesuiv(shadertype glbase.Enum, count int, value []uint32) { + C.gl4_0core_glUniformSubroutinesuiv(gl.funcs, C.GLenum(shadertype), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveSubroutineName.xml +func (gl *GL) GetActiveSubroutineName(program glbase.Program, shadertype glbase.Enum, index uint32, bufSize int32, length []int32, name []byte) { + C.gl4_0core_glGetActiveSubroutineName(gl.funcs, C.GLuint(program), C.GLenum(shadertype), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveSubroutineUniformName.xml +func (gl *GL) GetActiveSubroutineUniformName(program glbase.Program, shadertype glbase.Enum, index uint32, bufSize int32, length []int32, name []byte) { + C.gl4_0core_glGetActiveSubroutineUniformName(gl.funcs, C.GLuint(program), C.GLenum(shadertype), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveSubroutineUniformiv.xml +func (gl *GL) GetActiveSubroutineUniformiv(program glbase.Program, shadertype glbase.Enum, index uint32, pname glbase.Enum, values []int32) { + C.gl4_0core_glGetActiveSubroutineUniformiv(gl.funcs, C.GLuint(program), C.GLenum(shadertype), C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSubroutineIndex.xml +func (gl *GL) GetSubroutineIndex(program glbase.Program, shadertype glbase.Enum, name []byte) uint32 { + glresult := C.gl4_0core_glGetSubroutineIndex(gl.funcs, C.GLuint(program), C.GLenum(shadertype), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSubroutineUniformLocation.xml +func (gl *GL) GetSubroutineUniformLocation(program glbase.Program, shadertype glbase.Enum, name []byte) int32 { + glresult := C.gl4_0core_glGetSubroutineUniformLocation(gl.funcs, C.GLuint(program), C.GLenum(shadertype), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetUniformdv.xml +func (gl *GL) GetUniformdv(program glbase.Program, location glbase.Uniform, params []float64) { + C.gl4_0core_glGetUniformdv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix4x3dv.xml +func (gl *GL) UniformMatrix4x3dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_0core_glUniformMatrix4x3dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix4x2dv.xml +func (gl *GL) UniformMatrix4x2dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_0core_glUniformMatrix4x2dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix3x4dv.xml +func (gl *GL) UniformMatrix3x4dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_0core_glUniformMatrix3x4dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix3x2dv.xml +func (gl *GL) UniformMatrix3x2dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_0core_glUniformMatrix3x2dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix2x4dv.xml +func (gl *GL) UniformMatrix2x4dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_0core_glUniformMatrix2x4dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix2x3dv.xml +func (gl *GL) UniformMatrix2x3dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_0core_glUniformMatrix2x3dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix4dv.xml +func (gl *GL) UniformMatrix4dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_0core_glUniformMatrix4dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix3dv.xml +func (gl *GL) UniformMatrix3dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_0core_glUniformMatrix3dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix2dv.xml +func (gl *GL) UniformMatrix2dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_0core_glUniformMatrix2dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform4dv.xml +func (gl *GL) Uniform4dv(location glbase.Uniform, count int, value []float64) { + C.gl4_0core_glUniform4dv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform3dv.xml +func (gl *GL) Uniform3dv(location glbase.Uniform, count int, value []float64) { + C.gl4_0core_glUniform3dv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform2dv.xml +func (gl *GL) Uniform2dv(location glbase.Uniform, count int, value []float64) { + C.gl4_0core_glUniform2dv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform1dv.xml +func (gl *GL) Uniform1dv(location glbase.Uniform, count int, value []float64) { + C.gl4_0core_glUniform1dv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform4d.xml +func (gl *GL) Uniform4d(location glbase.Uniform, v0, v1, v2, v3 float64) { + C.gl4_0core_glUniform4d(gl.funcs, C.GLint(location), C.GLdouble(v0), C.GLdouble(v1), C.GLdouble(v2), C.GLdouble(v3)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform3d.xml +func (gl *GL) Uniform3d(location glbase.Uniform, v0, v1, v2 float64) { + C.gl4_0core_glUniform3d(gl.funcs, C.GLint(location), C.GLdouble(v0), C.GLdouble(v1), C.GLdouble(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform2d.xml +func (gl *GL) Uniform2d(location glbase.Uniform, v0, v1 float64) { + C.gl4_0core_glUniform2d(gl.funcs, C.GLint(location), C.GLdouble(v0), C.GLdouble(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform1d.xml +func (gl *GL) Uniform1d(location glbase.Uniform, v0 float64) { + C.gl4_0core_glUniform1d(gl.funcs, C.GLint(location), C.GLdouble(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsIndirect.xml +func (gl *GL) DrawElementsIndirect(mode, gltype glbase.Enum, indirect interface{}) { + var indirect_ptr unsafe.Pointer + var indirect_v = reflect.ValueOf(indirect) + if indirect != nil && indirect_v.Kind() != reflect.Slice { + panic("parameter indirect must be a slice") + } + if indirect != nil { + indirect_ptr = unsafe.Pointer(indirect_v.Index(0).Addr().Pointer()) + } + C.gl4_0core_glDrawElementsIndirect(gl.funcs, C.GLenum(mode), C.GLenum(gltype), indirect_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawArraysIndirect.xml +func (gl *GL) DrawArraysIndirect(mode glbase.Enum, indirect interface{}) { + var indirect_ptr unsafe.Pointer + var indirect_v = reflect.ValueOf(indirect) + if indirect != nil && indirect_v.Kind() != reflect.Slice { + panic("parameter indirect must be a slice") + } + if indirect != nil { + indirect_ptr = unsafe.Pointer(indirect_v.Index(0).Addr().Pointer()) + } + C.gl4_0core_glDrawArraysIndirect(gl.funcs, C.GLenum(mode), indirect_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFuncSeparatei.xml +func (gl *GL) BlendFuncSeparatei(buf uint32, srcRGB, dstRGB, srcAlpha, dstAlpha glbase.Enum) { + C.gl4_0core_glBlendFuncSeparatei(gl.funcs, C.GLuint(buf), C.GLenum(srcRGB), C.GLenum(dstRGB), C.GLenum(srcAlpha), C.GLenum(dstAlpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFunci.xml +func (gl *GL) BlendFunci(buf uint32, src, dst glbase.Enum) { + C.gl4_0core_glBlendFunci(gl.funcs, C.GLuint(buf), C.GLenum(src), C.GLenum(dst)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendEquationSeparatei.xml +func (gl *GL) BlendEquationSeparatei(buf uint32, modeRGB, modeAlpha glbase.Enum) { + C.gl4_0core_glBlendEquationSeparatei(gl.funcs, C.GLuint(buf), C.GLenum(modeRGB), C.GLenum(modeAlpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendEquationi.xml +func (gl *GL) BlendEquationi(buf uint32, mode glbase.Enum) { + C.gl4_0core_glBlendEquationi(gl.funcs, C.GLuint(buf), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMinSampleShading.xml +func (gl *GL) MinSampleShading(value float32) { + C.gl4_0core_glMinSampleShading(gl.funcs, C.GLfloat(value)) +} diff --git a/gl/4.1compat/funcs.cpp b/gl/4.1compat/funcs.cpp new file mode 100644 index 00000000..70ec9e7f --- /dev/null +++ b/gl/4.1compat/funcs.cpp @@ -0,0 +1,5286 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#include +#include + +#include "funcs.h" + +void *gl4_1compat_funcs() { + QOpenGLFunctions_4_1_Compatibility* funcs = QOpenGLContext::currentContext()->versionFunctions(); + if (!funcs) { + return 0; + } + funcs->initializeOpenGLFunctions(); + return funcs; +} + + +void gl4_1compat_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewport(x, y, width, height); +} + +void gl4_1compat_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRange(nearVal, farVal); +} + +GLboolean gl4_1compat_glIsEnabled(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabled(cap); +} + +void gl4_1compat_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameteriv(target, level, pname, params); +} + +void gl4_1compat_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameterfv(target, level, pname, params); +} + +void gl4_1compat_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameteriv(target, pname, params); +} + +void gl4_1compat_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterfv(target, pname, params); +} + +void gl4_1compat_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexImage(target, level, format, gltype, pixels); +} + +void gl4_1compat_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegerv(pname, params); +} + +void gl4_1compat_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFloatv(pname, params); +} + +GLenum gl4_1compat_glGetError(void *_glfuncs) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetError(); +} + +void gl4_1compat_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetDoublev(pname, params); +} + +void gl4_1compat_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleanv(pname, params); +} + +void gl4_1compat_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadPixels(x, y, width, height, format, gltype, pixels); +} + +void gl4_1compat_glReadBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadBuffer(mode); +} + +void gl4_1compat_glPixelStorei(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStorei(pname, param); +} + +void gl4_1compat_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStoref(pname, param); +} + +void gl4_1compat_glDepthFunc(void *_glfuncs, GLenum glfunc) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthFunc(glfunc); +} + +void gl4_1compat_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOp(fail, zfail, zpass); +} + +void gl4_1compat_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFunc(glfunc, ref, mask); +} + +void gl4_1compat_glLogicOp(void *_glfuncs, GLenum opcode) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLogicOp(opcode); +} + +void gl4_1compat_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFunc(sfactor, dfactor); +} + +void gl4_1compat_glFlush(void *_glfuncs) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlush(); +} + +void gl4_1compat_glFinish(void *_glfuncs) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFinish(); +} + +void gl4_1compat_glEnable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnable(cap); +} + +void gl4_1compat_glDisable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisable(cap); +} + +void gl4_1compat_glDepthMask(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthMask(flag); +} + +void gl4_1compat_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMask(red, green, blue, alpha); +} + +void gl4_1compat_glStencilMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMask(mask); +} + +void gl4_1compat_glClearDepth(void *_glfuncs, GLdouble depth) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearDepth(depth); +} + +void gl4_1compat_glClearStencil(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearStencil(s); +} + +void gl4_1compat_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearColor(red, green, blue, alpha); +} + +void gl4_1compat_glClear(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClear(mask); +} + +void gl4_1compat_glDrawBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffer(mode); +} + +void gl4_1compat_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage2D(target, level, internalFormat, width, height, border, format, gltype, pixels); +} + +void gl4_1compat_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage1D(target, level, internalFormat, width, border, format, gltype, pixels); +} + +void gl4_1compat_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteriv(target, pname, params); +} + +void gl4_1compat_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteri(target, pname, param); +} + +void gl4_1compat_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterfv(target, pname, params); +} + +void gl4_1compat_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterf(target, pname, param); +} + +void gl4_1compat_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissor(x, y, width, height); +} + +void gl4_1compat_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonMode(face, mode); +} + +void gl4_1compat_glPointSize(void *_glfuncs, GLfloat size) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointSize(size); +} + +void gl4_1compat_glLineWidth(void *_glfuncs, GLfloat width) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineWidth(width); +} + +void gl4_1compat_glHint(void *_glfuncs, GLenum target, GLenum mode) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glHint(target, mode); +} + +void gl4_1compat_glFrontFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrontFace(mode); +} + +void gl4_1compat_glCullFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCullFace(mode); +} + +void gl4_1compat_glIndexubv(void *_glfuncs, const GLubyte* c) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexubv(c); +} + +void gl4_1compat_glIndexub(void *_glfuncs, GLubyte c) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexub(c); +} + +GLboolean gl4_1compat_glIsTexture(void *_glfuncs, GLuint texture) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsTexture(texture); +} + +void gl4_1compat_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenTextures(n, textures); +} + +void gl4_1compat_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteTextures(n, textures); +} + +void gl4_1compat_glBindTexture(void *_glfuncs, GLenum target, GLuint texture) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindTexture(target, texture); +} + +void gl4_1compat_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, gltype, pixels); +} + +void gl4_1compat_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage1D(target, level, xoffset, width, format, gltype, pixels); +} + +void gl4_1compat_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); +} + +void gl4_1compat_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage1D(target, level, xoffset, x, y, width); +} + +void gl4_1compat_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage2D(target, level, internalFormat, x, y, width, height, border); +} + +void gl4_1compat_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage1D(target, level, internalFormat, x, y, width, border); +} + +void gl4_1compat_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonOffset(factor, units); +} + +void gl4_1compat_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElements(mode, count, gltype, indices); +} + +void gl4_1compat_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArrays(mode, first, count); +} + +void gl4_1compat_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); +} + +void gl4_1compat_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, gltype, pixels); +} + +void gl4_1compat_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage3D(target, level, internalFormat, width, height, depth, border, format, gltype, pixels); +} + +void gl4_1compat_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawRangeElements(mode, start, end, count, gltype, indices); +} + +void gl4_1compat_glBlendEquation(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquation(mode); +} + +void gl4_1compat_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendColor(red, green, blue, alpha); +} + +void gl4_1compat_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetCompressedTexImage(target, level, img); +} + +void gl4_1compat_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data); +} + +void gl4_1compat_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); +} + +void gl4_1compat_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); +} + +void gl4_1compat_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage1D(target, level, internalFormat, width, border, imageSize, data); +} + +void gl4_1compat_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data); +} + +void gl4_1compat_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage3D(target, level, internalFormat, width, height, depth, border, imageSize, data); +} + +void gl4_1compat_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSampleCoverage(value, invert); +} + +void gl4_1compat_glActiveTexture(void *_glfuncs, GLenum texture) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glActiveTexture(texture); +} + +void gl4_1compat_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteriv(pname, params); +} + +void gl4_1compat_glPointParameteri(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteri(pname, param); +} + +void gl4_1compat_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterfv(pname, params); +} + +void gl4_1compat_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterf(pname, param); +} + +void gl4_1compat_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiDrawArrays(mode, first, count, drawcount); +} + +void gl4_1compat_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); +} + +void gl4_1compat_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferParameteriv(target, pname, params); +} + +GLboolean gl4_1compat_glUnmapBuffer(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glUnmapBuffer(target); +} + +void gl4_1compat_glGetBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferSubData(target, offset, size, data); +} + +void gl4_1compat_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferSubData(target, offset, size, data); +} + +void gl4_1compat_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferData(target, size, data, usage); +} + +GLboolean gl4_1compat_glIsBuffer(void *_glfuncs, GLuint buffer) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsBuffer(buffer); +} + +void gl4_1compat_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenBuffers(n, buffers); +} + +void gl4_1compat_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteBuffers(n, buffers); +} + +void gl4_1compat_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBuffer(target, buffer); +} + +void gl4_1compat_glGetQueryObjectuiv(void *_glfuncs, GLuint id, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectuiv(id, pname, params); +} + +void gl4_1compat_glGetQueryObjectiv(void *_glfuncs, GLuint id, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectiv(id, pname, params); +} + +void gl4_1compat_glGetQueryiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryiv(target, pname, params); +} + +void gl4_1compat_glEndQuery(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndQuery(target); +} + +void gl4_1compat_glBeginQuery(void *_glfuncs, GLenum target, GLuint id) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginQuery(target, id); +} + +GLboolean gl4_1compat_glIsQuery(void *_glfuncs, GLuint id) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsQuery(id); +} + +void gl4_1compat_glDeleteQueries(void *_glfuncs, GLsizei n, const GLuint* ids) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteQueries(n, ids); +} + +void gl4_1compat_glGenQueries(void *_glfuncs, GLsizei n, GLuint* ids) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenQueries(n, ids); +} + +void gl4_1compat_glVertexAttribPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLboolean normalized, GLsizei stride, const GLvoid* offset) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribPointer(index, size, gltype, normalized, stride, offset); +} + +void gl4_1compat_glValidateProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glValidateProgram(program); +} + +void gl4_1compat_glUniformMatrix4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4fv(location, count, transpose, value); +} + +void gl4_1compat_glUniformMatrix3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3fv(location, count, transpose, value); +} + +void gl4_1compat_glUniformMatrix2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2fv(location, count, transpose, value); +} + +void gl4_1compat_glUniform4iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4iv(location, count, value); +} + +void gl4_1compat_glUniform3iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3iv(location, count, value); +} + +void gl4_1compat_glUniform2iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2iv(location, count, value); +} + +void gl4_1compat_glUniform1iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1iv(location, count, value); +} + +void gl4_1compat_glUniform4fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4fv(location, count, value); +} + +void gl4_1compat_glUniform3fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3fv(location, count, value); +} + +void gl4_1compat_glUniform2fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2fv(location, count, value); +} + +void gl4_1compat_glUniform1fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1fv(location, count, value); +} + +void gl4_1compat_glUniform4i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4i(location, v0, v1, v2, v3); +} + +void gl4_1compat_glUniform3i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3i(location, v0, v1, v2); +} + +void gl4_1compat_glUniform2i(void *_glfuncs, GLint location, GLint v0, GLint v1) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2i(location, v0, v1); +} + +void gl4_1compat_glUniform1i(void *_glfuncs, GLint location, GLint v0) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1i(location, v0); +} + +void gl4_1compat_glUniform4f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4f(location, v0, v1, v2, v3); +} + +void gl4_1compat_glUniform3f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3f(location, v0, v1, v2); +} + +void gl4_1compat_glUniform2f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2f(location, v0, v1); +} + +void gl4_1compat_glUniform1f(void *_glfuncs, GLint location, GLfloat v0) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1f(location, v0); +} + +void gl4_1compat_glUseProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUseProgram(program); +} + +void gl4_1compat_glShaderSource(void *_glfuncs, GLuint shader, GLsizei count, const GLchar** source, const GLint* length) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShaderSource(shader, count, source, length); +} + +void gl4_1compat_glLinkProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLinkProgram(program); +} + +GLboolean gl4_1compat_glIsShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsShader(shader); +} + +GLboolean gl4_1compat_glIsProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsProgram(program); +} + +void gl4_1compat_glGetVertexAttribiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribiv(index, pname, params); +} + +void gl4_1compat_glGetVertexAttribfv(void *_glfuncs, GLuint index, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribfv(index, pname, params); +} + +void gl4_1compat_glGetVertexAttribdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribdv(index, pname, params); +} + +void gl4_1compat_glGetUniformiv(void *_glfuncs, GLuint program, GLint location, GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformiv(program, location, params); +} + +void gl4_1compat_glGetUniformfv(void *_glfuncs, GLuint program, GLint location, GLfloat* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformfv(program, location, params); +} + +GLint gl4_1compat_glGetUniformLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetUniformLocation(program, name); +} + +void gl4_1compat_glGetShaderSource(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderSource(shader, bufSize, length, source); +} + +void gl4_1compat_glGetShaderInfoLog(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderInfoLog(shader, bufSize, length, infoLog); +} + +void gl4_1compat_glGetShaderiv(void *_glfuncs, GLuint shader, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderiv(shader, pname, params); +} + +void gl4_1compat_glGetProgramInfoLog(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramInfoLog(program, bufSize, length, infoLog); +} + +void gl4_1compat_glGetProgramiv(void *_glfuncs, GLuint program, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramiv(program, pname, params); +} + +GLint gl4_1compat_glGetAttribLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetAttribLocation(program, name); +} + +void gl4_1compat_glGetAttachedShaders(void *_glfuncs, GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetAttachedShaders(program, maxCount, count, obj); +} + +void gl4_1compat_glGetActiveUniform(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniform(program, index, bufSize, length, size, gltype, name); +} + +void gl4_1compat_glGetActiveAttrib(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveAttrib(program, index, bufSize, length, size, gltype, name); +} + +void gl4_1compat_glEnableVertexAttribArray(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnableVertexAttribArray(index); +} + +void gl4_1compat_glDisableVertexAttribArray(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisableVertexAttribArray(index); +} + +void gl4_1compat_glDetachShader(void *_glfuncs, GLuint program, GLuint shader) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDetachShader(program, shader); +} + +void gl4_1compat_glDeleteShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteShader(shader); +} + +void gl4_1compat_glDeleteProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteProgram(program); +} + +GLuint gl4_1compat_glCreateShader(void *_glfuncs, GLenum gltype) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCreateShader(gltype); +} + +GLuint gl4_1compat_glCreateProgram(void *_glfuncs) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCreateProgram(); +} + +void gl4_1compat_glCompileShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompileShader(shader); +} + +void gl4_1compat_glBindAttribLocation(void *_glfuncs, GLuint program, GLuint index, const GLchar* name) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindAttribLocation(program, index, name); +} + +void gl4_1compat_glAttachShader(void *_glfuncs, GLuint program, GLuint shader) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAttachShader(program, shader); +} + +void gl4_1compat_glStencilMaskSeparate(void *_glfuncs, GLenum face, GLuint mask) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMaskSeparate(face, mask); +} + +void gl4_1compat_glStencilFuncSeparate(void *_glfuncs, GLenum face, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFuncSeparate(face, glfunc, ref, mask); +} + +void gl4_1compat_glStencilOpSeparate(void *_glfuncs, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOpSeparate(face, sfail, dpfail, dppass); +} + +void gl4_1compat_glDrawBuffers(void *_glfuncs, GLsizei n, const GLenum* bufs) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffers(n, bufs); +} + +void gl4_1compat_glBlendEquationSeparate(void *_glfuncs, GLenum modeRGB, GLenum modeAlpha) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquationSeparate(modeRGB, modeAlpha); +} + +void gl4_1compat_glUniformMatrix4x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x3fv(location, count, transpose, value); +} + +void gl4_1compat_glUniformMatrix3x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x4fv(location, count, transpose, value); +} + +void gl4_1compat_glUniformMatrix4x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x2fv(location, count, transpose, value); +} + +void gl4_1compat_glUniformMatrix2x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x4fv(location, count, transpose, value); +} + +void gl4_1compat_glUniformMatrix3x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x2fv(location, count, transpose, value); +} + +void gl4_1compat_glUniformMatrix2x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x3fv(location, count, transpose, value); +} + +GLboolean gl4_1compat_glIsVertexArray(void *_glfuncs, GLuint array) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsVertexArray(array); +} + +void gl4_1compat_glGenVertexArrays(void *_glfuncs, GLsizei n, GLuint* arrays) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenVertexArrays(n, arrays); +} + +void gl4_1compat_glDeleteVertexArrays(void *_glfuncs, GLsizei n, const GLuint* arrays) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteVertexArrays(n, arrays); +} + +void gl4_1compat_glBindVertexArray(void *_glfuncs, GLuint array) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindVertexArray(array); +} + +void gl4_1compat_glFlushMappedBufferRange(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr length) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlushMappedBufferRange(target, offset, length); +} + +void gl4_1compat_glFramebufferTextureLayer(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTextureLayer(target, attachment, texture, level, layer); +} + +void gl4_1compat_glRenderbufferStorageMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRenderbufferStorageMultisample(target, samples, internalFormat, width, height); +} + +void gl4_1compat_glBlitFramebuffer(void *_glfuncs, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); +} + +void gl4_1compat_glGenerateMipmap(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenerateMipmap(target); +} + +void gl4_1compat_glGetFramebufferAttachmentParameteriv(void *_glfuncs, GLenum target, GLenum attachment, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFramebufferAttachmentParameteriv(target, attachment, pname, params); +} + +void gl4_1compat_glFramebufferRenderbuffer(void *_glfuncs, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer); +} + +void gl4_1compat_glFramebufferTexture3D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset); +} + +void gl4_1compat_glFramebufferTexture2D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture2D(target, attachment, textarget, texture, level); +} + +void gl4_1compat_glFramebufferTexture1D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture1D(target, attachment, textarget, texture, level); +} + +GLenum gl4_1compat_glCheckFramebufferStatus(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCheckFramebufferStatus(target); +} + +void gl4_1compat_glGenFramebuffers(void *_glfuncs, GLsizei n, GLuint* framebuffers) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenFramebuffers(n, framebuffers); +} + +void gl4_1compat_glDeleteFramebuffers(void *_glfuncs, GLsizei n, const GLuint* framebuffers) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteFramebuffers(n, framebuffers); +} + +void gl4_1compat_glBindFramebuffer(void *_glfuncs, GLenum target, GLuint framebuffer) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFramebuffer(target, framebuffer); +} + +GLboolean gl4_1compat_glIsFramebuffer(void *_glfuncs, GLuint framebuffer) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsFramebuffer(framebuffer); +} + +void gl4_1compat_glGetRenderbufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetRenderbufferParameteriv(target, pname, params); +} + +void gl4_1compat_glRenderbufferStorage(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRenderbufferStorage(target, internalFormat, width, height); +} + +void gl4_1compat_glGenRenderbuffers(void *_glfuncs, GLsizei n, GLuint* renderbuffers) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenRenderbuffers(n, renderbuffers); +} + +void gl4_1compat_glDeleteRenderbuffers(void *_glfuncs, GLsizei n, const GLuint* renderbuffers) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteRenderbuffers(n, renderbuffers); +} + +void gl4_1compat_glBindRenderbuffer(void *_glfuncs, GLenum target, GLuint renderbuffer) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindRenderbuffer(target, renderbuffer); +} + +GLboolean gl4_1compat_glIsRenderbuffer(void *_glfuncs, GLuint renderbuffer) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsRenderbuffer(renderbuffer); +} + +void gl4_1compat_glClearBufferfi(void *_glfuncs, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferfi(buffer, drawbuffer, depth, stencil); +} + +void gl4_1compat_glClearBufferfv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferfv(buffer, drawbuffer, value); +} + +void gl4_1compat_glClearBufferuiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLuint* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferuiv(buffer, drawbuffer, value); +} + +void gl4_1compat_glClearBufferiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLint* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferiv(buffer, drawbuffer, value); +} + +void gl4_1compat_glGetTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterIuiv(target, pname, params); +} + +void gl4_1compat_glGetTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterIiv(target, pname, params); +} + +void gl4_1compat_glTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, const GLuint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterIuiv(target, pname, params); +} + +void gl4_1compat_glTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterIiv(target, pname, params); +} + +void gl4_1compat_glUniform4uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4uiv(location, count, value); +} + +void gl4_1compat_glUniform3uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3uiv(location, count, value); +} + +void gl4_1compat_glUniform2uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2uiv(location, count, value); +} + +void gl4_1compat_glUniform1uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1uiv(location, count, value); +} + +void gl4_1compat_glUniform4ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4ui(location, v0, v1, v2, v3); +} + +void gl4_1compat_glUniform3ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3ui(location, v0, v1, v2); +} + +void gl4_1compat_glUniform2ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2ui(location, v0, v1); +} + +void gl4_1compat_glUniform1ui(void *_glfuncs, GLint location, GLuint v0) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1ui(location, v0); +} + +GLint gl4_1compat_glGetFragDataLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetFragDataLocation(program, name); +} + +void gl4_1compat_glBindFragDataLocation(void *_glfuncs, GLuint program, GLuint color, const GLchar* name) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFragDataLocation(program, color, name); +} + +void gl4_1compat_glGetUniformuiv(void *_glfuncs, GLuint program, GLint location, GLuint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformuiv(program, location, params); +} + +void gl4_1compat_glGetVertexAttribIuiv(void *_glfuncs, GLuint index, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribIuiv(index, pname, params); +} + +void gl4_1compat_glGetVertexAttribIiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribIiv(index, pname, params); +} + +void gl4_1compat_glVertexAttribIPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribIPointer(index, size, gltype, stride, pointer); +} + +void gl4_1compat_glEndConditionalRender(void *_glfuncs) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndConditionalRender(); +} + +void gl4_1compat_glBeginConditionalRender(void *_glfuncs, GLuint id, GLenum mode) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginConditionalRender(id, mode); +} + +void gl4_1compat_glClampColor(void *_glfuncs, GLenum target, GLenum clamp) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClampColor(target, clamp); +} + +void gl4_1compat_glGetTransformFeedbackVarying(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTransformFeedbackVarying(program, index, bufSize, length, size, gltype, name); +} + +void gl4_1compat_glBindBufferBase(void *_glfuncs, GLenum target, GLuint index, GLuint buffer) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBufferBase(target, index, buffer); +} + +void gl4_1compat_glBindBufferRange(void *_glfuncs, GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBufferRange(target, index, buffer, offset, size); +} + +void gl4_1compat_glEndTransformFeedback(void *_glfuncs) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndTransformFeedback(); +} + +void gl4_1compat_glBeginTransformFeedback(void *_glfuncs, GLenum primitiveMode) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginTransformFeedback(primitiveMode); +} + +GLboolean gl4_1compat_glIsEnabledi(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabledi(target, index); +} + +void gl4_1compat_glDisablei(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisablei(target, index); +} + +void gl4_1compat_glEnablei(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnablei(target, index); +} + +void gl4_1compat_glGetIntegeri_v(void *_glfuncs, GLenum target, GLuint index, GLint* data) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegeri_v(target, index, data); +} + +void gl4_1compat_glGetBooleani_v(void *_glfuncs, GLenum target, GLuint index, GLboolean* data) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleani_v(target, index, data); +} + +void gl4_1compat_glColorMaski(void *_glfuncs, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMaski(index, r, g, b, a); +} + +void gl4_1compat_glCopyBufferSubData(void *_glfuncs, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); +} + +void gl4_1compat_glUniformBlockBinding(void *_glfuncs, GLuint program, GLuint v0, GLuint v1) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformBlockBinding(program, v0, v1); +} + +void gl4_1compat_glGetActiveUniformBlockName(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName); +} + +void gl4_1compat_glGetActiveUniformBlockiv(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params); +} + +GLuint gl4_1compat_glGetUniformBlockIndex(void *_glfuncs, GLuint program, const GLchar* uniformBlockName) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetUniformBlockIndex(program, uniformBlockName); +} + +void gl4_1compat_glGetActiveUniformName(void *_glfuncs, GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformName(program, uniformIndex, bufSize, length, uniformName); +} + +void gl4_1compat_glGetActiveUniformsiv(void *_glfuncs, GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params); +} + +void gl4_1compat_glPrimitiveRestartIndex(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPrimitiveRestartIndex(index); +} + +void gl4_1compat_glTexBuffer(void *_glfuncs, GLenum target, GLenum internalFormat, GLuint buffer) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexBuffer(target, internalFormat, buffer); +} + +void gl4_1compat_glDrawElementsInstanced(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsInstanced(mode, count, gltype, indices, instancecount); +} + +void gl4_1compat_glDrawArraysInstanced(void *_glfuncs, GLenum mode, GLint first, GLsizei count, GLsizei instancecount) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArraysInstanced(mode, first, count, instancecount); +} + +void gl4_1compat_glSampleMaski(void *_glfuncs, GLuint index, GLbitfield mask) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSampleMaski(index, mask); +} + +void gl4_1compat_glGetMultisamplefv(void *_glfuncs, GLenum pname, GLuint index, GLfloat* val) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMultisamplefv(pname, index, val); +} + +void gl4_1compat_glTexImage3DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage3DMultisample(target, samples, internalFormat, width, height, depth, fixedsamplelocations); +} + +void gl4_1compat_glTexImage2DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage2DMultisample(target, samples, internalFormat, width, height, fixedsamplelocations); +} + +void gl4_1compat_glGetSynciv(void *_glfuncs, GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSynciv(sync, pname, bufSize, length, values); +} + +void gl4_1compat_glGetInteger64v(void *_glfuncs, GLenum pname, GLint64* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetInteger64v(pname, params); +} + +void gl4_1compat_glWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWaitSync(sync, flags, timeout); +} + +GLenum gl4_1compat_glClientWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glClientWaitSync(sync, flags, timeout); +} + +void gl4_1compat_glDeleteSync(void *_glfuncs, GLsync sync) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteSync(sync); +} + +GLboolean gl4_1compat_glIsSync(void *_glfuncs, GLsync sync) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsSync(sync); +} + +GLsync gl4_1compat_glFenceSync(void *_glfuncs, GLenum condition, GLbitfield flags) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glFenceSync(condition, flags); +} + +void gl4_1compat_glProvokingVertex(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProvokingVertex(mode); +} + +void gl4_1compat_glDrawElementsInstancedBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLint basevertex) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsInstancedBaseVertex(mode, count, gltype, indices, instancecount, basevertex); +} + +void gl4_1compat_glDrawRangeElementsBaseVertex(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawRangeElementsBaseVertex(mode, start, end, count, gltype, indices, basevertex); +} + +void gl4_1compat_glDrawElementsBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsBaseVertex(mode, count, gltype, indices, basevertex); +} + +void gl4_1compat_glFramebufferTexture(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture(target, attachment, texture, level); +} + +void gl4_1compat_glGetBufferParameteri64v(void *_glfuncs, GLenum target, GLenum pname, GLint64* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferParameteri64v(target, pname, params); +} + +void gl4_1compat_glGetInteger64i_v(void *_glfuncs, GLenum target, GLuint index, GLint64* data) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetInteger64i_v(target, index, data); +} + +void gl4_1compat_glVertexAttribP4uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP4uiv(index, gltype, normalized, value); +} + +void gl4_1compat_glVertexAttribP4ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP4ui(index, gltype, normalized, value); +} + +void gl4_1compat_glVertexAttribP3uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP3uiv(index, gltype, normalized, value); +} + +void gl4_1compat_glVertexAttribP3ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP3ui(index, gltype, normalized, value); +} + +void gl4_1compat_glVertexAttribP2uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP2uiv(index, gltype, normalized, value); +} + +void gl4_1compat_glVertexAttribP2ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP2ui(index, gltype, normalized, value); +} + +void gl4_1compat_glVertexAttribP1uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP1uiv(index, gltype, normalized, value); +} + +void gl4_1compat_glVertexAttribP1ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP1ui(index, gltype, normalized, value); +} + +void gl4_1compat_glSecondaryColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColorP3uiv(gltype, color); +} + +void gl4_1compat_glSecondaryColorP3ui(void *_glfuncs, GLenum gltype, GLuint color) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColorP3ui(gltype, color); +} + +void gl4_1compat_glColorP4uiv(void *_glfuncs, GLenum gltype, const GLuint* color) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP4uiv(gltype, color); +} + +void gl4_1compat_glColorP4ui(void *_glfuncs, GLenum gltype, GLuint color) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP4ui(gltype, color); +} + +void gl4_1compat_glColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP3uiv(gltype, color); +} + +void gl4_1compat_glColorP3ui(void *_glfuncs, GLenum gltype, GLuint color) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP3ui(gltype, color); +} + +void gl4_1compat_glNormalP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormalP3uiv(gltype, coords); +} + +void gl4_1compat_glNormalP3ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormalP3ui(gltype, coords); +} + +void gl4_1compat_glMultiTexCoordP4uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP4uiv(texture, gltype, coords); +} + +void gl4_1compat_glMultiTexCoordP4ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP4ui(texture, gltype, coords); +} + +void gl4_1compat_glMultiTexCoordP3uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP3uiv(texture, gltype, coords); +} + +void gl4_1compat_glMultiTexCoordP3ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP3ui(texture, gltype, coords); +} + +void gl4_1compat_glMultiTexCoordP2uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP2uiv(texture, gltype, coords); +} + +void gl4_1compat_glMultiTexCoordP2ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP2ui(texture, gltype, coords); +} + +void gl4_1compat_glMultiTexCoordP1uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP1uiv(texture, gltype, coords); +} + +void gl4_1compat_glMultiTexCoordP1ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP1ui(texture, gltype, coords); +} + +void gl4_1compat_glTexCoordP4uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP4uiv(gltype, coords); +} + +void gl4_1compat_glTexCoordP4ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP4ui(gltype, coords); +} + +void gl4_1compat_glTexCoordP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP3uiv(gltype, coords); +} + +void gl4_1compat_glTexCoordP3ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP3ui(gltype, coords); +} + +void gl4_1compat_glTexCoordP2uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP2uiv(gltype, coords); +} + +void gl4_1compat_glTexCoordP2ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP2ui(gltype, coords); +} + +void gl4_1compat_glTexCoordP1uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP1uiv(gltype, coords); +} + +void gl4_1compat_glTexCoordP1ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP1ui(gltype, coords); +} + +void gl4_1compat_glVertexP4uiv(void *_glfuncs, GLenum gltype, const GLuint* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP4uiv(gltype, value); +} + +void gl4_1compat_glVertexP4ui(void *_glfuncs, GLenum gltype, GLuint value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP4ui(gltype, value); +} + +void gl4_1compat_glVertexP3uiv(void *_glfuncs, GLenum gltype, const GLuint* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP3uiv(gltype, value); +} + +void gl4_1compat_glVertexP3ui(void *_glfuncs, GLenum gltype, GLuint value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP3ui(gltype, value); +} + +void gl4_1compat_glVertexP2uiv(void *_glfuncs, GLenum gltype, const GLuint* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP2uiv(gltype, value); +} + +void gl4_1compat_glVertexP2ui(void *_glfuncs, GLenum gltype, GLuint value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP2ui(gltype, value); +} + +void gl4_1compat_glGetQueryObjectui64v(void *_glfuncs, GLuint id, GLenum pname, GLuint64* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectui64v(id, pname, params); +} + +void gl4_1compat_glGetQueryObjecti64v(void *_glfuncs, GLuint id, GLenum pname, GLint64* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjecti64v(id, pname, params); +} + +void gl4_1compat_glQueryCounter(void *_glfuncs, GLuint id, GLenum target) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glQueryCounter(id, target); +} + +void gl4_1compat_glGetSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameterIuiv(sampler, pname, params); +} + +void gl4_1compat_glGetSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameterfv(sampler, pname, params); +} + +void gl4_1compat_glGetSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameterIiv(sampler, pname, params); +} + +void gl4_1compat_glGetSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameteriv(sampler, pname, params); +} + +void gl4_1compat_glSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLuint* param) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterIuiv(sampler, pname, param); +} + +void gl4_1compat_glSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterIiv(sampler, pname, param); +} + +void gl4_1compat_glSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, const GLfloat* param) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterfv(sampler, pname, param); +} + +void gl4_1compat_glSamplerParameterf(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterf(sampler, pname, param); +} + +void gl4_1compat_glSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameteriv(sampler, pname, param); +} + +void gl4_1compat_glSamplerParameteri(void *_glfuncs, GLuint sampler, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameteri(sampler, pname, param); +} + +void gl4_1compat_glBindSampler(void *_glfuncs, GLuint unit, GLuint sampler) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindSampler(unit, sampler); +} + +GLboolean gl4_1compat_glIsSampler(void *_glfuncs, GLuint sampler) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsSampler(sampler); +} + +void gl4_1compat_glDeleteSamplers(void *_glfuncs, GLsizei count, const GLuint* samplers) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteSamplers(count, samplers); +} + +void gl4_1compat_glGenSamplers(void *_glfuncs, GLsizei count, GLuint* samplers) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenSamplers(count, samplers); +} + +GLint gl4_1compat_glGetFragDataIndex(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetFragDataIndex(program, name); +} + +void gl4_1compat_glBindFragDataLocationIndexed(void *_glfuncs, GLuint program, GLuint colorNumber, GLuint index, const GLchar* name) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFragDataLocationIndexed(program, colorNumber, index, name); +} + +void gl4_1compat_glVertexAttribDivisor(void *_glfuncs, GLuint index, GLuint divisor) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribDivisor(index, divisor); +} + +void gl4_1compat_glGetQueryIndexediv(void *_glfuncs, GLenum target, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryIndexediv(target, index, pname, params); +} + +void gl4_1compat_glEndQueryIndexed(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndQueryIndexed(target, index); +} + +void gl4_1compat_glBeginQueryIndexed(void *_glfuncs, GLenum target, GLuint index, GLuint id) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginQueryIndexed(target, index, id); +} + +void gl4_1compat_glDrawTransformFeedbackStream(void *_glfuncs, GLenum mode, GLuint id, GLuint stream) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawTransformFeedbackStream(mode, id, stream); +} + +void gl4_1compat_glDrawTransformFeedback(void *_glfuncs, GLenum mode, GLuint id) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawTransformFeedback(mode, id); +} + +void gl4_1compat_glResumeTransformFeedback(void *_glfuncs) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glResumeTransformFeedback(); +} + +void gl4_1compat_glPauseTransformFeedback(void *_glfuncs) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPauseTransformFeedback(); +} + +GLboolean gl4_1compat_glIsTransformFeedback(void *_glfuncs, GLuint id) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsTransformFeedback(id); +} + +void gl4_1compat_glGenTransformFeedbacks(void *_glfuncs, GLsizei n, GLuint* ids) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenTransformFeedbacks(n, ids); +} + +void gl4_1compat_glDeleteTransformFeedbacks(void *_glfuncs, GLsizei n, const GLuint* ids) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteTransformFeedbacks(n, ids); +} + +void gl4_1compat_glBindTransformFeedback(void *_glfuncs, GLenum target, GLuint id) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindTransformFeedback(target, id); +} + +void gl4_1compat_glPatchParameterfv(void *_glfuncs, GLenum pname, const GLfloat* values) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPatchParameterfv(pname, values); +} + +void gl4_1compat_glPatchParameteri(void *_glfuncs, GLenum pname, GLint value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPatchParameteri(pname, value); +} + +void gl4_1compat_glGetProgramStageiv(void *_glfuncs, GLuint program, GLenum shadertype, GLenum pname, GLint* values) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramStageiv(program, shadertype, pname, values); +} + +void gl4_1compat_glGetUniformSubroutineuiv(void *_glfuncs, GLenum shadertype, GLint location, GLuint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformSubroutineuiv(shadertype, location, params); +} + +void gl4_1compat_glUniformSubroutinesuiv(void *_glfuncs, GLenum shadertype, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformSubroutinesuiv(shadertype, count, value); +} + +void gl4_1compat_glGetActiveSubroutineName(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveSubroutineName(program, shadertype, index, bufSize, length, name); +} + +void gl4_1compat_glGetActiveSubroutineUniformName(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveSubroutineUniformName(program, shadertype, index, bufSize, length, name); +} + +void gl4_1compat_glGetActiveSubroutineUniformiv(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint* values) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveSubroutineUniformiv(program, shadertype, index, pname, values); +} + +GLuint gl4_1compat_glGetSubroutineIndex(void *_glfuncs, GLuint program, GLenum shadertype, const GLchar* name) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetSubroutineIndex(program, shadertype, name); +} + +GLint gl4_1compat_glGetSubroutineUniformLocation(void *_glfuncs, GLuint program, GLenum shadertype, const GLchar* name) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetSubroutineUniformLocation(program, shadertype, name); +} + +void gl4_1compat_glGetUniformdv(void *_glfuncs, GLuint program, GLint location, GLdouble* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformdv(program, location, params); +} + +void gl4_1compat_glUniformMatrix4x3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x3dv(location, count, transpose, value); +} + +void gl4_1compat_glUniformMatrix4x2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x2dv(location, count, transpose, value); +} + +void gl4_1compat_glUniformMatrix3x4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x4dv(location, count, transpose, value); +} + +void gl4_1compat_glUniformMatrix3x2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x2dv(location, count, transpose, value); +} + +void gl4_1compat_glUniformMatrix2x4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x4dv(location, count, transpose, value); +} + +void gl4_1compat_glUniformMatrix2x3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x3dv(location, count, transpose, value); +} + +void gl4_1compat_glUniformMatrix4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4dv(location, count, transpose, value); +} + +void gl4_1compat_glUniformMatrix3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3dv(location, count, transpose, value); +} + +void gl4_1compat_glUniformMatrix2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2dv(location, count, transpose, value); +} + +void gl4_1compat_glUniform4dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4dv(location, count, value); +} + +void gl4_1compat_glUniform3dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3dv(location, count, value); +} + +void gl4_1compat_glUniform2dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2dv(location, count, value); +} + +void gl4_1compat_glUniform1dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1dv(location, count, value); +} + +void gl4_1compat_glUniform4d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4d(location, v0, v1, v2, v3); +} + +void gl4_1compat_glUniform3d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1, GLdouble v2) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3d(location, v0, v1, v2); +} + +void gl4_1compat_glUniform2d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2d(location, v0, v1); +} + +void gl4_1compat_glUniform1d(void *_glfuncs, GLint location, GLdouble v0) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1d(location, v0); +} + +void gl4_1compat_glDrawElementsIndirect(void *_glfuncs, GLenum mode, GLenum gltype, const GLvoid* indirect) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsIndirect(mode, gltype, indirect); +} + +void gl4_1compat_glDrawArraysIndirect(void *_glfuncs, GLenum mode, const GLvoid* indirect) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArraysIndirect(mode, indirect); +} + +void gl4_1compat_glBlendFuncSeparatei(void *_glfuncs, GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha); +} + +void gl4_1compat_glBlendFunci(void *_glfuncs, GLuint buf, GLenum src, GLenum dst) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFunci(buf, src, dst); +} + +void gl4_1compat_glBlendEquationSeparatei(void *_glfuncs, GLuint buf, GLenum modeRGB, GLenum modeAlpha) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquationSeparatei(buf, modeRGB, modeAlpha); +} + +void gl4_1compat_glBlendEquationi(void *_glfuncs, GLuint buf, GLenum mode) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquationi(buf, mode); +} + +void gl4_1compat_glMinSampleShading(void *_glfuncs, GLfloat value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMinSampleShading(value); +} + +void gl4_1compat_glGetDoublei_v(void *_glfuncs, GLenum target, GLuint index, GLdouble* data) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetDoublei_v(target, index, data); +} + +void gl4_1compat_glGetFloati_v(void *_glfuncs, GLenum target, GLuint index, GLfloat* data) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFloati_v(target, index, data); +} + +void gl4_1compat_glDepthRangeIndexed(void *_glfuncs, GLuint index, GLdouble n, GLdouble f) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRangeIndexed(index, n, f); +} + +void gl4_1compat_glDepthRangeArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLdouble* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRangeArrayv(first, count, v); +} + +void gl4_1compat_glScissorIndexedv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissorIndexedv(index, v); +} + +void gl4_1compat_glScissorIndexed(void *_glfuncs, GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissorIndexed(index, left, bottom, width, height); +} + +void gl4_1compat_glScissorArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissorArrayv(first, count, v); +} + +void gl4_1compat_glViewportIndexedfv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewportIndexedfv(index, v); +} + +void gl4_1compat_glViewportIndexedf(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewportIndexedf(index, x, y, w, h); +} + +void gl4_1compat_glViewportArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLfloat* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewportArrayv(first, count, v); +} + +void gl4_1compat_glGetVertexAttribLdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribLdv(index, pname, params); +} + +void gl4_1compat_glVertexAttribLPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribLPointer(index, size, gltype, stride, pointer); +} + +void gl4_1compat_glVertexAttribL4dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL4dv(index, v); +} + +void gl4_1compat_glVertexAttribL3dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL3dv(index, v); +} + +void gl4_1compat_glVertexAttribL2dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL2dv(index, v); +} + +void gl4_1compat_glVertexAttribL1dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL1dv(index, v); +} + +void gl4_1compat_glVertexAttribL4d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL4d(index, x, y, z, w); +} + +void gl4_1compat_glVertexAttribL3d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL3d(index, x, y, z); +} + +void gl4_1compat_glVertexAttribL2d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL2d(index, x, y); +} + +void gl4_1compat_glVertexAttribL1d(void *_glfuncs, GLuint index, GLdouble x) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL1d(index, x); +} + +void gl4_1compat_glGetProgramPipelineInfoLog(void *_glfuncs, GLuint pipeline, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog); +} + +void gl4_1compat_glValidateProgramPipeline(void *_glfuncs, GLuint pipeline) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glValidateProgramPipeline(pipeline); +} + +void gl4_1compat_glProgramUniformMatrix4x3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4x3dv(program, location, count, transpose, value); +} + +void gl4_1compat_glProgramUniformMatrix3x4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3x4dv(program, location, count, transpose, value); +} + +void gl4_1compat_glProgramUniformMatrix4x2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4x2dv(program, location, count, transpose, value); +} + +void gl4_1compat_glProgramUniformMatrix2x4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2x4dv(program, location, count, transpose, value); +} + +void gl4_1compat_glProgramUniformMatrix3x2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3x2dv(program, location, count, transpose, value); +} + +void gl4_1compat_glProgramUniformMatrix2x3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2x3dv(program, location, count, transpose, value); +} + +void gl4_1compat_glProgramUniformMatrix4x3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4x3fv(program, location, count, transpose, value); +} + +void gl4_1compat_glProgramUniformMatrix3x4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3x4fv(program, location, count, transpose, value); +} + +void gl4_1compat_glProgramUniformMatrix4x2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4x2fv(program, location, count, transpose, value); +} + +void gl4_1compat_glProgramUniformMatrix2x4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2x4fv(program, location, count, transpose, value); +} + +void gl4_1compat_glProgramUniformMatrix3x2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3x2fv(program, location, count, transpose, value); +} + +void gl4_1compat_glProgramUniformMatrix2x3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2x3fv(program, location, count, transpose, value); +} + +void gl4_1compat_glProgramUniformMatrix4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4dv(program, location, count, transpose, value); +} + +void gl4_1compat_glProgramUniformMatrix3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3dv(program, location, count, transpose, value); +} + +void gl4_1compat_glProgramUniformMatrix2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2dv(program, location, count, transpose, value); +} + +void gl4_1compat_glProgramUniformMatrix4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4fv(program, location, count, transpose, value); +} + +void gl4_1compat_glProgramUniformMatrix3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3fv(program, location, count, transpose, value); +} + +void gl4_1compat_glProgramUniformMatrix2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2fv(program, location, count, transpose, value); +} + +void gl4_1compat_glProgramUniform4uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4uiv(program, location, count, value); +} + +void gl4_1compat_glProgramUniform4ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4ui(program, location, v0, v1, v2, v3); +} + +void gl4_1compat_glProgramUniform4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4dv(program, location, count, value); +} + +void gl4_1compat_glProgramUniform4d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4d(program, location, v0, v1, v2, v3); +} + +void gl4_1compat_glProgramUniform4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4fv(program, location, count, value); +} + +void gl4_1compat_glProgramUniform4f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4f(program, location, v0, v1, v2, v3); +} + +void gl4_1compat_glProgramUniform4iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4iv(program, location, count, value); +} + +void gl4_1compat_glProgramUniform4i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4i(program, location, v0, v1, v2, v3); +} + +void gl4_1compat_glProgramUniform3uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3uiv(program, location, count, value); +} + +void gl4_1compat_glProgramUniform3ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3ui(program, location, v0, v1, v2); +} + +void gl4_1compat_glProgramUniform3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3dv(program, location, count, value); +} + +void gl4_1compat_glProgramUniform3d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3d(program, location, v0, v1, v2); +} + +void gl4_1compat_glProgramUniform3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3fv(program, location, count, value); +} + +void gl4_1compat_glProgramUniform3f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3f(program, location, v0, v1, v2); +} + +void gl4_1compat_glProgramUniform3iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3iv(program, location, count, value); +} + +void gl4_1compat_glProgramUniform3i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1, GLint v2) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3i(program, location, v0, v1, v2); +} + +void gl4_1compat_glProgramUniform2uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2uiv(program, location, count, value); +} + +void gl4_1compat_glProgramUniform2ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2ui(program, location, v0, v1); +} + +void gl4_1compat_glProgramUniform2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2dv(program, location, count, value); +} + +void gl4_1compat_glProgramUniform2d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2d(program, location, v0, v1); +} + +void gl4_1compat_glProgramUniform2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2fv(program, location, count, value); +} + +void gl4_1compat_glProgramUniform2f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2f(program, location, v0, v1); +} + +void gl4_1compat_glProgramUniform2iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2iv(program, location, count, value); +} + +void gl4_1compat_glProgramUniform2i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2i(program, location, v0, v1); +} + +void gl4_1compat_glProgramUniform1uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1uiv(program, location, count, value); +} + +void gl4_1compat_glProgramUniform1ui(void *_glfuncs, GLuint program, GLint location, GLuint v0) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1ui(program, location, v0); +} + +void gl4_1compat_glProgramUniform1dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1dv(program, location, count, value); +} + +void gl4_1compat_glProgramUniform1d(void *_glfuncs, GLuint program, GLint location, GLdouble v0) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1d(program, location, v0); +} + +void gl4_1compat_glProgramUniform1fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1fv(program, location, count, value); +} + +void gl4_1compat_glProgramUniform1f(void *_glfuncs, GLuint program, GLint location, GLfloat v0) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1f(program, location, v0); +} + +void gl4_1compat_glProgramUniform1iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1iv(program, location, count, value); +} + +void gl4_1compat_glProgramUniform1i(void *_glfuncs, GLuint program, GLint location, GLint v0) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1i(program, location, v0); +} + +void gl4_1compat_glGetProgramPipelineiv(void *_glfuncs, GLuint pipeline, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramPipelineiv(pipeline, pname, params); +} + +GLboolean gl4_1compat_glIsProgramPipeline(void *_glfuncs, GLuint pipeline) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsProgramPipeline(pipeline); +} + +void gl4_1compat_glGenProgramPipelines(void *_glfuncs, GLsizei n, GLuint* pipelines) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenProgramPipelines(n, pipelines); +} + +void gl4_1compat_glDeleteProgramPipelines(void *_glfuncs, GLsizei n, const GLuint* pipelines) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteProgramPipelines(n, pipelines); +} + +void gl4_1compat_glBindProgramPipeline(void *_glfuncs, GLuint pipeline) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindProgramPipeline(pipeline); +} + +void gl4_1compat_glActiveShaderProgram(void *_glfuncs, GLuint pipeline, GLuint program) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glActiveShaderProgram(pipeline, program); +} + +void gl4_1compat_glUseProgramStages(void *_glfuncs, GLuint pipeline, GLbitfield stages, GLuint program) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUseProgramStages(pipeline, stages, program); +} + +void gl4_1compat_glProgramParameteri(void *_glfuncs, GLuint program, GLenum pname, GLint value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramParameteri(program, pname, value); +} + +void gl4_1compat_glProgramBinary(void *_glfuncs, GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramBinary(program, binaryFormat, binary, length); +} + +void gl4_1compat_glGetProgramBinary(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramBinary(program, bufSize, length, binaryFormat, binary); +} + +void gl4_1compat_glClearDepthf(void *_glfuncs, GLfloat dd) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearDepthf(dd); +} + +void gl4_1compat_glDepthRangef(void *_glfuncs, GLfloat n, GLfloat f) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRangef(n, f); +} + +void gl4_1compat_glGetShaderPrecisionFormat(void *_glfuncs, GLenum shadertype, GLenum precisionType, GLint* range_, GLint* precision) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderPrecisionFormat(shadertype, precisionType, range_, precision); +} + +void gl4_1compat_glShaderBinary(void *_glfuncs, GLsizei count, const GLuint* shaders, GLenum binaryFormat, const GLvoid* binary, GLsizei length) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShaderBinary(count, shaders, binaryFormat, binary, length); +} + +void gl4_1compat_glReleaseShaderCompiler(void *_glfuncs) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReleaseShaderCompiler(); +} + +void gl4_1compat_glTranslatef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTranslatef(x, y, z); +} + +void gl4_1compat_glTranslated(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTranslated(x, y, z); +} + +void gl4_1compat_glScalef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScalef(x, y, z); +} + +void gl4_1compat_glScaled(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScaled(x, y, z); +} + +void gl4_1compat_glRotatef(void *_glfuncs, GLfloat angle, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRotatef(angle, x, y, z); +} + +void gl4_1compat_glRotated(void *_glfuncs, GLdouble angle, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRotated(angle, x, y, z); +} + +void gl4_1compat_glPushMatrix(void *_glfuncs) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushMatrix(); +} + +void gl4_1compat_glPopMatrix(void *_glfuncs) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopMatrix(); +} + +void gl4_1compat_glOrtho(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glOrtho(left, right, bottom, top, zNear, zFar); +} + +void gl4_1compat_glMultMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultMatrixd(m); +} + +void gl4_1compat_glMultMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultMatrixf(m); +} + +void gl4_1compat_glMatrixMode(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMatrixMode(mode); +} + +void gl4_1compat_glLoadMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadMatrixd(m); +} + +void gl4_1compat_glLoadMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadMatrixf(m); +} + +void gl4_1compat_glLoadIdentity(void *_glfuncs) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadIdentity(); +} + +void gl4_1compat_glFrustum(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrustum(left, right, bottom, top, zNear, zFar); +} + +GLboolean gl4_1compat_glIsList(void *_glfuncs, GLuint list) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsList(list); +} + +void gl4_1compat_glGetTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGeniv(coord, pname, params); +} + +void gl4_1compat_glGetTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGenfv(coord, pname, params); +} + +void gl4_1compat_glGetTexGendv(void *_glfuncs, GLenum coord, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGendv(coord, pname, params); +} + +void gl4_1compat_glGetTexEnviv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexEnviv(target, pname, params); +} + +void gl4_1compat_glGetTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexEnvfv(target, pname, params); +} + +void gl4_1compat_glGetPolygonStipple(void *_glfuncs, GLubyte* mask) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPolygonStipple(mask); +} + +void gl4_1compat_glGetPixelMapusv(void *_glfuncs, GLenum glmap, GLushort* values) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapusv(glmap, values); +} + +void gl4_1compat_glGetPixelMapuiv(void *_glfuncs, GLenum glmap, GLuint* values) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapuiv(glmap, values); +} + +void gl4_1compat_glGetPixelMapfv(void *_glfuncs, GLenum glmap, GLfloat* values) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapfv(glmap, values); +} + +void gl4_1compat_glGetMaterialiv(void *_glfuncs, GLenum face, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMaterialiv(face, pname, params); +} + +void gl4_1compat_glGetMaterialfv(void *_glfuncs, GLenum face, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMaterialfv(face, pname, params); +} + +void gl4_1compat_glGetMapiv(void *_glfuncs, GLenum target, GLenum query, GLint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapiv(target, query, v); +} + +void gl4_1compat_glGetMapfv(void *_glfuncs, GLenum target, GLenum query, GLfloat* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapfv(target, query, v); +} + +void gl4_1compat_glGetMapdv(void *_glfuncs, GLenum target, GLenum query, GLdouble* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapdv(target, query, v); +} + +void gl4_1compat_glGetLightiv(void *_glfuncs, GLenum light, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetLightiv(light, pname, params); +} + +void gl4_1compat_glGetLightfv(void *_glfuncs, GLenum light, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetLightfv(light, pname, params); +} + +void gl4_1compat_glGetClipPlane(void *_glfuncs, GLenum plane, GLdouble* equation) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetClipPlane(plane, equation); +} + +void gl4_1compat_glDrawPixels(void *_glfuncs, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawPixels(width, height, format, gltype, pixels); +} + +void gl4_1compat_glCopyPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum gltype) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyPixels(x, y, width, height, gltype); +} + +void gl4_1compat_glPixelMapusv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLushort* values) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapusv(glmap, mapsize, values); +} + +void gl4_1compat_glPixelMapuiv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLuint* values) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapuiv(glmap, mapsize, values); +} + +void gl4_1compat_glPixelMapfv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLfloat* values) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapfv(glmap, mapsize, values); +} + +void gl4_1compat_glPixelTransferi(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelTransferi(pname, param); +} + +void gl4_1compat_glPixelTransferf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelTransferf(pname, param); +} + +void gl4_1compat_glPixelZoom(void *_glfuncs, GLfloat xfactor, GLfloat yfactor) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelZoom(xfactor, yfactor); +} + +void gl4_1compat_glAlphaFunc(void *_glfuncs, GLenum glfunc, GLfloat ref) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAlphaFunc(glfunc, ref); +} + +void gl4_1compat_glEvalPoint2(void *_glfuncs, GLint i, GLint j) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalPoint2(i, j); +} + +void gl4_1compat_glEvalMesh2(void *_glfuncs, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalMesh2(mode, i1, i2, j1, j2); +} + +void gl4_1compat_glEvalPoint1(void *_glfuncs, GLint i) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalPoint1(i); +} + +void gl4_1compat_glEvalMesh1(void *_glfuncs, GLenum mode, GLint i1, GLint i2) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalMesh1(mode, i1, i2); +} + +void gl4_1compat_glEvalCoord2fv(void *_glfuncs, const GLfloat* u) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2fv(u); +} + +void gl4_1compat_glEvalCoord2f(void *_glfuncs, GLfloat u, GLfloat v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2f(u, v); +} + +void gl4_1compat_glEvalCoord2dv(void *_glfuncs, const GLdouble* u) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2dv(u); +} + +void gl4_1compat_glEvalCoord2d(void *_glfuncs, GLdouble u, GLdouble v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2d(u, v); +} + +void gl4_1compat_glEvalCoord1fv(void *_glfuncs, const GLfloat* u) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1fv(u); +} + +void gl4_1compat_glEvalCoord1f(void *_glfuncs, GLfloat u) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1f(u); +} + +void gl4_1compat_glEvalCoord1dv(void *_glfuncs, const GLdouble* u) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1dv(u); +} + +void gl4_1compat_glEvalCoord1d(void *_glfuncs, GLdouble u) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1d(u); +} + +void gl4_1compat_glMapGrid2f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid2f(un, u1, u2, vn, v1, v2); +} + +void gl4_1compat_glMapGrid2d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid2d(un, u1, u2, vn, v1, v2); +} + +void gl4_1compat_glMapGrid1f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid1f(un, u1, u2); +} + +void gl4_1compat_glMapGrid1d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid1d(un, u1, u2); +} + +void gl4_1compat_glMap2f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); +} + +void gl4_1compat_glMap2d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); +} + +void gl4_1compat_glMap1f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap1f(target, u1, u2, stride, order, points); +} + +void gl4_1compat_glMap1d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap1d(target, u1, u2, stride, order, points); +} + +void gl4_1compat_glPushAttrib(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushAttrib(mask); +} + +void gl4_1compat_glPopAttrib(void *_glfuncs) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopAttrib(); +} + +void gl4_1compat_glAccum(void *_glfuncs, GLenum op, GLfloat value) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAccum(op, value); +} + +void gl4_1compat_glIndexMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexMask(mask); +} + +void gl4_1compat_glClearIndex(void *_glfuncs, GLfloat c) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearIndex(c); +} + +void gl4_1compat_glClearAccum(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearAccum(red, green, blue, alpha); +} + +void gl4_1compat_glPushName(void *_glfuncs, GLuint name) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushName(name); +} + +void gl4_1compat_glPopName(void *_glfuncs) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopName(); +} + +void gl4_1compat_glPassThrough(void *_glfuncs, GLfloat token) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPassThrough(token); +} + +void gl4_1compat_glLoadName(void *_glfuncs, GLuint name) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadName(name); +} + +void gl4_1compat_glInitNames(void *_glfuncs) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInitNames(); +} + +GLint gl4_1compat_glRenderMode(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glRenderMode(mode); +} + +void gl4_1compat_glSelectBuffer(void *_glfuncs, GLsizei size, GLuint* buffer) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSelectBuffer(size, buffer); +} + +void gl4_1compat_glFeedbackBuffer(void *_glfuncs, GLsizei size, GLenum gltype, GLfloat* buffer) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFeedbackBuffer(size, gltype, buffer); +} + +void gl4_1compat_glTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGeniv(coord, pname, params); +} + +void gl4_1compat_glTexGeni(void *_glfuncs, GLenum coord, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGeni(coord, pname, param); +} + +void gl4_1compat_glTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGenfv(coord, pname, params); +} + +void gl4_1compat_glTexGenf(void *_glfuncs, GLenum coord, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGenf(coord, pname, param); +} + +void gl4_1compat_glTexGendv(void *_glfuncs, GLenum coord, GLenum pname, const GLdouble* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGendv(coord, pname, params); +} + +void gl4_1compat_glTexGend(void *_glfuncs, GLenum coord, GLenum pname, GLdouble param) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGend(coord, pname, param); +} + +void gl4_1compat_glTexEnviv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnviv(target, pname, params); +} + +void gl4_1compat_glTexEnvi(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvi(target, pname, param); +} + +void gl4_1compat_glTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvfv(target, pname, params); +} + +void gl4_1compat_glTexEnvf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvf(target, pname, param); +} + +void gl4_1compat_glShadeModel(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShadeModel(mode); +} + +void gl4_1compat_glPolygonStipple(void *_glfuncs, const GLubyte* mask) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonStipple(mask); +} + +void gl4_1compat_glMaterialiv(void *_glfuncs, GLenum face, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialiv(face, pname, params); +} + +void gl4_1compat_glMateriali(void *_glfuncs, GLenum face, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMateriali(face, pname, param); +} + +void gl4_1compat_glMaterialfv(void *_glfuncs, GLenum face, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialfv(face, pname, params); +} + +void gl4_1compat_glMaterialf(void *_glfuncs, GLenum face, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialf(face, pname, param); +} + +void gl4_1compat_glLineStipple(void *_glfuncs, GLint factor, GLushort pattern) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineStipple(factor, pattern); +} + +void gl4_1compat_glLightModeliv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModeliv(pname, params); +} + +void gl4_1compat_glLightModeli(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModeli(pname, param); +} + +void gl4_1compat_glLightModelfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModelfv(pname, params); +} + +void gl4_1compat_glLightModelf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModelf(pname, param); +} + +void gl4_1compat_glLightiv(void *_glfuncs, GLenum light, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightiv(light, pname, params); +} + +void gl4_1compat_glLighti(void *_glfuncs, GLenum light, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLighti(light, pname, param); +} + +void gl4_1compat_glLightfv(void *_glfuncs, GLenum light, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightfv(light, pname, params); +} + +void gl4_1compat_glLightf(void *_glfuncs, GLenum light, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightf(light, pname, param); +} + +void gl4_1compat_glFogiv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogiv(pname, params); +} + +void gl4_1compat_glFogi(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogi(pname, param); +} + +void gl4_1compat_glFogfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogfv(pname, params); +} + +void gl4_1compat_glFogf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogf(pname, param); +} + +void gl4_1compat_glColorMaterial(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMaterial(face, mode); +} + +void gl4_1compat_glClipPlane(void *_glfuncs, GLenum plane, const GLdouble* equation) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClipPlane(plane, equation); +} + +void gl4_1compat_glVertex4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4sv(v); +} + +void gl4_1compat_glVertex4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4s(x, y, z, w); +} + +void gl4_1compat_glVertex4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4iv(v); +} + +void gl4_1compat_glVertex4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4i(x, y, z, w); +} + +void gl4_1compat_glVertex4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4fv(v); +} + +void gl4_1compat_glVertex4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4f(x, y, z, w); +} + +void gl4_1compat_glVertex4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4dv(v); +} + +void gl4_1compat_glVertex4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4d(x, y, z, w); +} + +void gl4_1compat_glVertex3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3sv(v); +} + +void gl4_1compat_glVertex3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3s(x, y, z); +} + +void gl4_1compat_glVertex3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3iv(v); +} + +void gl4_1compat_glVertex3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3i(x, y, z); +} + +void gl4_1compat_glVertex3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3fv(v); +} + +void gl4_1compat_glVertex3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3f(x, y, z); +} + +void gl4_1compat_glVertex3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3dv(v); +} + +void gl4_1compat_glVertex3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3d(x, y, z); +} + +void gl4_1compat_glVertex2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2sv(v); +} + +void gl4_1compat_glVertex2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2s(x, y); +} + +void gl4_1compat_glVertex2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2iv(v); +} + +void gl4_1compat_glVertex2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2i(x, y); +} + +void gl4_1compat_glVertex2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2fv(v); +} + +void gl4_1compat_glVertex2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2f(x, y); +} + +void gl4_1compat_glVertex2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2dv(v); +} + +void gl4_1compat_glVertex2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2d(x, y); +} + +void gl4_1compat_glTexCoord4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4sv(v); +} + +void gl4_1compat_glTexCoord4s(void *_glfuncs, GLshort s, GLshort t, GLshort r, GLshort q) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4s(s, t, r, q); +} + +void gl4_1compat_glTexCoord4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4iv(v); +} + +void gl4_1compat_glTexCoord4i(void *_glfuncs, GLint s, GLint t, GLint r, GLint q) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4i(s, t, r, q); +} + +void gl4_1compat_glTexCoord4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4fv(v); +} + +void gl4_1compat_glTexCoord4f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4f(s, t, r, q); +} + +void gl4_1compat_glTexCoord4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4dv(v); +} + +void gl4_1compat_glTexCoord4d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r, GLdouble q) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4d(s, t, r, q); +} + +void gl4_1compat_glTexCoord3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3sv(v); +} + +void gl4_1compat_glTexCoord3s(void *_glfuncs, GLshort s, GLshort t, GLshort r) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3s(s, t, r); +} + +void gl4_1compat_glTexCoord3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3iv(v); +} + +void gl4_1compat_glTexCoord3i(void *_glfuncs, GLint s, GLint t, GLint r) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3i(s, t, r); +} + +void gl4_1compat_glTexCoord3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3fv(v); +} + +void gl4_1compat_glTexCoord3f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3f(s, t, r); +} + +void gl4_1compat_glTexCoord3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3dv(v); +} + +void gl4_1compat_glTexCoord3d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3d(s, t, r); +} + +void gl4_1compat_glTexCoord2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2sv(v); +} + +void gl4_1compat_glTexCoord2s(void *_glfuncs, GLshort s, GLshort t) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2s(s, t); +} + +void gl4_1compat_glTexCoord2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2iv(v); +} + +void gl4_1compat_glTexCoord2i(void *_glfuncs, GLint s, GLint t) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2i(s, t); +} + +void gl4_1compat_glTexCoord2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2fv(v); +} + +void gl4_1compat_glTexCoord2f(void *_glfuncs, GLfloat s, GLfloat t) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2f(s, t); +} + +void gl4_1compat_glTexCoord2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2dv(v); +} + +void gl4_1compat_glTexCoord2d(void *_glfuncs, GLdouble s, GLdouble t) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2d(s, t); +} + +void gl4_1compat_glTexCoord1sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1sv(v); +} + +void gl4_1compat_glTexCoord1s(void *_glfuncs, GLshort s) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1s(s); +} + +void gl4_1compat_glTexCoord1iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1iv(v); +} + +void gl4_1compat_glTexCoord1i(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1i(s); +} + +void gl4_1compat_glTexCoord1fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1fv(v); +} + +void gl4_1compat_glTexCoord1f(void *_glfuncs, GLfloat s) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1f(s); +} + +void gl4_1compat_glTexCoord1dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1dv(v); +} + +void gl4_1compat_glTexCoord1d(void *_glfuncs, GLdouble s) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1d(s); +} + +void gl4_1compat_glRectsv(void *_glfuncs, const GLshort* v1, const GLshort* v2) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectsv(v1, v2); +} + +void gl4_1compat_glRects(void *_glfuncs, GLshort x1, GLshort y1, GLshort x2, GLshort y2) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRects(x1, y1, x2, y2); +} + +void gl4_1compat_glRectiv(void *_glfuncs, const GLint* v1, const GLint* v2) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectiv(v1, v2); +} + +void gl4_1compat_glRecti(void *_glfuncs, GLint x1, GLint y1, GLint x2, GLint y2) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRecti(x1, y1, x2, y2); +} + +void gl4_1compat_glRectfv(void *_glfuncs, const GLfloat* v1, const GLfloat* v2) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectfv(v1, v2); +} + +void gl4_1compat_glRectf(void *_glfuncs, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectf(x1, y1, x2, y2); +} + +void gl4_1compat_glRectdv(void *_glfuncs, const GLdouble* v1, const GLdouble* v2) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectdv(v1, v2); +} + +void gl4_1compat_glRectd(void *_glfuncs, GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectd(x1, y1, x2, y2); +} + +void gl4_1compat_glRasterPos4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4sv(v); +} + +void gl4_1compat_glRasterPos4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4s(x, y, z, w); +} + +void gl4_1compat_glRasterPos4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4iv(v); +} + +void gl4_1compat_glRasterPos4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4i(x, y, z, w); +} + +void gl4_1compat_glRasterPos4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4fv(v); +} + +void gl4_1compat_glRasterPos4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4f(x, y, z, w); +} + +void gl4_1compat_glRasterPos4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4dv(v); +} + +void gl4_1compat_glRasterPos4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4d(x, y, z, w); +} + +void gl4_1compat_glRasterPos3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3sv(v); +} + +void gl4_1compat_glRasterPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3s(x, y, z); +} + +void gl4_1compat_glRasterPos3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3iv(v); +} + +void gl4_1compat_glRasterPos3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3i(x, y, z); +} + +void gl4_1compat_glRasterPos3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3fv(v); +} + +void gl4_1compat_glRasterPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3f(x, y, z); +} + +void gl4_1compat_glRasterPos3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3dv(v); +} + +void gl4_1compat_glRasterPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3d(x, y, z); +} + +void gl4_1compat_glRasterPos2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2sv(v); +} + +void gl4_1compat_glRasterPos2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2s(x, y); +} + +void gl4_1compat_glRasterPos2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2iv(v); +} + +void gl4_1compat_glRasterPos2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2i(x, y); +} + +void gl4_1compat_glRasterPos2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2fv(v); +} + +void gl4_1compat_glRasterPos2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2f(x, y); +} + +void gl4_1compat_glRasterPos2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2dv(v); +} + +void gl4_1compat_glRasterPos2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2d(x, y); +} + +void gl4_1compat_glNormal3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3sv(v); +} + +void gl4_1compat_glNormal3s(void *_glfuncs, GLshort nx, GLshort ny, GLshort nz) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3s(nx, ny, nz); +} + +void gl4_1compat_glNormal3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3iv(v); +} + +void gl4_1compat_glNormal3i(void *_glfuncs, GLint nx, GLint ny, GLint nz) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3i(nx, ny, nz); +} + +void gl4_1compat_glNormal3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3fv(v); +} + +void gl4_1compat_glNormal3f(void *_glfuncs, GLfloat nx, GLfloat ny, GLfloat nz) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3f(nx, ny, nz); +} + +void gl4_1compat_glNormal3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3dv(v); +} + +void gl4_1compat_glNormal3d(void *_glfuncs, GLdouble nx, GLdouble ny, GLdouble nz) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3d(nx, ny, nz); +} + +void gl4_1compat_glNormal3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3bv(v); +} + +void gl4_1compat_glNormal3b(void *_glfuncs, GLbyte nx, GLbyte ny, GLbyte nz) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3b(nx, ny, nz); +} + +void gl4_1compat_glIndexsv(void *_glfuncs, const GLshort* c) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexsv(c); +} + +void gl4_1compat_glIndexs(void *_glfuncs, GLshort c) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexs(c); +} + +void gl4_1compat_glIndexiv(void *_glfuncs, const GLint* c) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexiv(c); +} + +void gl4_1compat_glIndexi(void *_glfuncs, GLint c) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexi(c); +} + +void gl4_1compat_glIndexfv(void *_glfuncs, const GLfloat* c) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexfv(c); +} + +void gl4_1compat_glIndexf(void *_glfuncs, GLfloat c) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexf(c); +} + +void gl4_1compat_glIndexdv(void *_glfuncs, const GLdouble* c) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexdv(c); +} + +void gl4_1compat_glIndexd(void *_glfuncs, GLdouble c) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexd(c); +} + +void gl4_1compat_glEnd(void *_glfuncs) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnd(); +} + +void gl4_1compat_glEdgeFlagv(void *_glfuncs, const GLboolean* flag) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlagv(flag); +} + +void gl4_1compat_glEdgeFlag(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlag(flag); +} + +void gl4_1compat_glColor4usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4usv(v); +} + +void gl4_1compat_glColor4us(void *_glfuncs, GLushort red, GLushort green, GLushort blue, GLushort alpha) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4us(red, green, blue, alpha); +} + +void gl4_1compat_glColor4uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4uiv(v); +} + +void gl4_1compat_glColor4ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue, GLuint alpha) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ui(red, green, blue, alpha); +} + +void gl4_1compat_glColor4ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ubv(v); +} + +void gl4_1compat_glColor4ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ub(red, green, blue, alpha); +} + +void gl4_1compat_glColor4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4sv(v); +} + +void gl4_1compat_glColor4s(void *_glfuncs, GLshort red, GLshort green, GLshort blue, GLshort alpha) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4s(red, green, blue, alpha); +} + +void gl4_1compat_glColor4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4iv(v); +} + +void gl4_1compat_glColor4i(void *_glfuncs, GLint red, GLint green, GLint blue, GLint alpha) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4i(red, green, blue, alpha); +} + +void gl4_1compat_glColor4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4fv(v); +} + +void gl4_1compat_glColor4f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4f(red, green, blue, alpha); +} + +void gl4_1compat_glColor4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4dv(v); +} + +void gl4_1compat_glColor4d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4d(red, green, blue, alpha); +} + +void gl4_1compat_glColor4bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4bv(v); +} + +void gl4_1compat_glColor4b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4b(red, green, blue, alpha); +} + +void gl4_1compat_glColor3usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3usv(v); +} + +void gl4_1compat_glColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3us(red, green, blue); +} + +void gl4_1compat_glColor3uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3uiv(v); +} + +void gl4_1compat_glColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ui(red, green, blue); +} + +void gl4_1compat_glColor3ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ubv(v); +} + +void gl4_1compat_glColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ub(red, green, blue); +} + +void gl4_1compat_glColor3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3sv(v); +} + +void gl4_1compat_glColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3s(red, green, blue); +} + +void gl4_1compat_glColor3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3iv(v); +} + +void gl4_1compat_glColor3i(void *_glfuncs, GLint red, GLint green, GLint blue) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3i(red, green, blue); +} + +void gl4_1compat_glColor3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3fv(v); +} + +void gl4_1compat_glColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3f(red, green, blue); +} + +void gl4_1compat_glColor3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3dv(v); +} + +void gl4_1compat_glColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3d(red, green, blue); +} + +void gl4_1compat_glColor3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3bv(v); +} + +void gl4_1compat_glColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3b(red, green, blue); +} + +void gl4_1compat_glBitmap(void *_glfuncs, GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBitmap(width, height, xorig, yorig, xmove, ymove, bitmap); +} + +void gl4_1compat_glBegin(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBegin(mode); +} + +void gl4_1compat_glListBase(void *_glfuncs, GLuint base) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glListBase(base); +} + +GLuint gl4_1compat_glGenLists(void *_glfuncs, GLsizei range_) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGenLists(range_); +} + +void gl4_1compat_glDeleteLists(void *_glfuncs, GLuint list, GLsizei range_) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteLists(list, range_); +} + +void gl4_1compat_glCallLists(void *_glfuncs, GLsizei n, GLenum gltype, const GLvoid* lists) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCallLists(n, gltype, lists); +} + +void gl4_1compat_glCallList(void *_glfuncs, GLuint list) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCallList(list); +} + +void gl4_1compat_glEndList(void *_glfuncs) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndList(); +} + +void gl4_1compat_glNewList(void *_glfuncs, GLuint list, GLenum mode) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNewList(list, mode); +} + +void gl4_1compat_glPushClientAttrib(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushClientAttrib(mask); +} + +void gl4_1compat_glPopClientAttrib(void *_glfuncs) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopClientAttrib(); +} + +void gl4_1compat_glPrioritizeTextures(void *_glfuncs, GLsizei n, const GLuint* textures, const GLfloat* priorities) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPrioritizeTextures(n, textures, priorities); +} + +GLboolean gl4_1compat_glAreTexturesResident(void *_glfuncs, GLsizei n, const GLuint* textures, GLboolean* residences) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glAreTexturesResident(n, textures, residences); +} + +void gl4_1compat_glVertexPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexPointer(size, gltype, stride, pointer); +} + +void gl4_1compat_glTexCoordPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordPointer(size, gltype, stride, pointer); +} + +void gl4_1compat_glNormalPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormalPointer(gltype, stride, pointer); +} + +void gl4_1compat_glInterleavedArrays(void *_glfuncs, GLenum format, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInterleavedArrays(format, stride, pointer); +} + +void gl4_1compat_glIndexPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexPointer(gltype, stride, pointer); +} + +void gl4_1compat_glEnableClientState(void *_glfuncs, GLenum array) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnableClientState(array); +} + +void gl4_1compat_glEdgeFlagPointer(void *_glfuncs, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlagPointer(stride, pointer); +} + +void gl4_1compat_glDisableClientState(void *_glfuncs, GLenum array) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisableClientState(array); +} + +void gl4_1compat_glColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorPointer(size, gltype, stride, pointer); +} + +void gl4_1compat_glArrayElement(void *_glfuncs, GLint i) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glArrayElement(i); +} + +void gl4_1compat_glResetMinmax(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glResetMinmax(target); +} + +void gl4_1compat_glResetHistogram(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glResetHistogram(target); +} + +void gl4_1compat_glMinmax(void *_glfuncs, GLenum target, GLenum internalFormat, GLboolean sink) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMinmax(target, internalFormat, sink); +} + +void gl4_1compat_glHistogram(void *_glfuncs, GLenum target, GLsizei width, GLenum internalFormat, GLboolean sink) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glHistogram(target, width, internalFormat, sink); +} + +void gl4_1compat_glGetMinmaxParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmaxParameteriv(target, pname, params); +} + +void gl4_1compat_glGetMinmaxParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmaxParameterfv(target, pname, params); +} + +void gl4_1compat_glGetMinmax(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmax(target, reset, format, gltype, values); +} + +void gl4_1compat_glGetHistogramParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogramParameteriv(target, pname, params); +} + +void gl4_1compat_glGetHistogramParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogramParameterfv(target, pname, params); +} + +void gl4_1compat_glGetHistogram(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogram(target, reset, format, gltype, values); +} + +void gl4_1compat_glSeparableFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* row, const GLvoid* column) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSeparableFilter2D(target, internalFormat, width, height, format, gltype, row, column); +} + +void gl4_1compat_glGetSeparableFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* row, GLvoid* column, GLvoid* span) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSeparableFilter(target, format, gltype, row, column, span); +} + +void gl4_1compat_glGetConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionParameteriv(target, pname, params); +} + +void gl4_1compat_glGetConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionParameterfv(target, pname, params); +} + +void gl4_1compat_glGetConvolutionFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* image) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionFilter(target, format, gltype, image); +} + +void gl4_1compat_glCopyConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyConvolutionFilter2D(target, internalFormat, x, y, width, height); +} + +void gl4_1compat_glCopyConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyConvolutionFilter1D(target, internalFormat, x, y, width); +} + +void gl4_1compat_glConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameteriv(target, pname, params); +} + +void gl4_1compat_glConvolutionParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameteri(target, pname, params); +} + +void gl4_1compat_glConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameterfv(target, pname, params); +} + +void gl4_1compat_glConvolutionParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameterf(target, pname, params); +} + +void gl4_1compat_glConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* image) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionFilter2D(target, internalFormat, width, height, format, gltype, image); +} + +void gl4_1compat_glConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* image) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionFilter1D(target, internalFormat, width, format, gltype, image); +} + +void gl4_1compat_glCopyColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyColorSubTable(target, start, x, y, width); +} + +void gl4_1compat_glColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum gltype, const GLvoid* data) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorSubTable(target, start, count, format, gltype, data); +} + +void gl4_1compat_glGetColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTableParameteriv(target, pname, params); +} + +void gl4_1compat_glGetColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTableParameterfv(target, pname, params); +} + +void gl4_1compat_glGetColorTable(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* table) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTable(target, format, gltype, table); +} + +void gl4_1compat_glCopyColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyColorTable(target, internalFormat, x, y, width); +} + +void gl4_1compat_glColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTableParameteriv(target, pname, params); +} + +void gl4_1compat_glColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTableParameterfv(target, pname, params); +} + +void gl4_1compat_glColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* table) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTable(target, internalFormat, width, format, gltype, table); +} + +void gl4_1compat_glMultTransposeMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultTransposeMatrixd(m); +} + +void gl4_1compat_glMultTransposeMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultTransposeMatrixf(m); +} + +void gl4_1compat_glLoadTransposeMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadTransposeMatrixd(m); +} + +void gl4_1compat_glLoadTransposeMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadTransposeMatrixf(m); +} + +void gl4_1compat_glMultiTexCoord4sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4sv(target, v); +} + +void gl4_1compat_glMultiTexCoord4s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r, GLshort q) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4s(target, s, t, r, q); +} + +void gl4_1compat_glMultiTexCoord4iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4iv(target, v); +} + +void gl4_1compat_glMultiTexCoord4i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r, GLint q) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4i(target, s, t, r, q); +} + +void gl4_1compat_glMultiTexCoord4fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4fv(target, v); +} + +void gl4_1compat_glMultiTexCoord4f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4f(target, s, t, r, q); +} + +void gl4_1compat_glMultiTexCoord4dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4dv(target, v); +} + +void gl4_1compat_glMultiTexCoord4d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4d(target, s, t, r, q); +} + +void gl4_1compat_glMultiTexCoord3sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3sv(target, v); +} + +void gl4_1compat_glMultiTexCoord3s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3s(target, s, t, r); +} + +void gl4_1compat_glMultiTexCoord3iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3iv(target, v); +} + +void gl4_1compat_glMultiTexCoord3i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3i(target, s, t, r); +} + +void gl4_1compat_glMultiTexCoord3fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3fv(target, v); +} + +void gl4_1compat_glMultiTexCoord3f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3f(target, s, t, r); +} + +void gl4_1compat_glMultiTexCoord3dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3dv(target, v); +} + +void gl4_1compat_glMultiTexCoord3d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3d(target, s, t, r); +} + +void gl4_1compat_glMultiTexCoord2sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2sv(target, v); +} + +void gl4_1compat_glMultiTexCoord2s(void *_glfuncs, GLenum target, GLshort s, GLshort t) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2s(target, s, t); +} + +void gl4_1compat_glMultiTexCoord2iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2iv(target, v); +} + +void gl4_1compat_glMultiTexCoord2i(void *_glfuncs, GLenum target, GLint s, GLint t) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2i(target, s, t); +} + +void gl4_1compat_glMultiTexCoord2fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2fv(target, v); +} + +void gl4_1compat_glMultiTexCoord2f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2f(target, s, t); +} + +void gl4_1compat_glMultiTexCoord2dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2dv(target, v); +} + +void gl4_1compat_glMultiTexCoord2d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2d(target, s, t); +} + +void gl4_1compat_glMultiTexCoord1sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1sv(target, v); +} + +void gl4_1compat_glMultiTexCoord1s(void *_glfuncs, GLenum target, GLshort s) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1s(target, s); +} + +void gl4_1compat_glMultiTexCoord1iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1iv(target, v); +} + +void gl4_1compat_glMultiTexCoord1i(void *_glfuncs, GLenum target, GLint s) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1i(target, s); +} + +void gl4_1compat_glMultiTexCoord1fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1fv(target, v); +} + +void gl4_1compat_glMultiTexCoord1f(void *_glfuncs, GLenum target, GLfloat s) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1f(target, s); +} + +void gl4_1compat_glMultiTexCoord1dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1dv(target, v); +} + +void gl4_1compat_glMultiTexCoord1d(void *_glfuncs, GLenum target, GLdouble s) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1d(target, s); +} + +void gl4_1compat_glClientActiveTexture(void *_glfuncs, GLenum texture) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClientActiveTexture(texture); +} + +void gl4_1compat_glWindowPos3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3sv(v); +} + +void gl4_1compat_glWindowPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3s(x, y, z); +} + +void gl4_1compat_glWindowPos3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3iv(v); +} + +void gl4_1compat_glWindowPos3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3i(x, y, z); +} + +void gl4_1compat_glWindowPos3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3fv(v); +} + +void gl4_1compat_glWindowPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3f(x, y, z); +} + +void gl4_1compat_glWindowPos3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3dv(v); +} + +void gl4_1compat_glWindowPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3d(x, y, z); +} + +void gl4_1compat_glWindowPos2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2sv(v); +} + +void gl4_1compat_glWindowPos2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2s(x, y); +} + +void gl4_1compat_glWindowPos2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2iv(v); +} + +void gl4_1compat_glWindowPos2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2i(x, y); +} + +void gl4_1compat_glWindowPos2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2fv(v); +} + +void gl4_1compat_glWindowPos2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2f(x, y); +} + +void gl4_1compat_glWindowPos2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2dv(v); +} + +void gl4_1compat_glWindowPos2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2d(x, y); +} + +void gl4_1compat_glSecondaryColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColorPointer(size, gltype, stride, pointer); +} + +void gl4_1compat_glSecondaryColor3usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3usv(v); +} + +void gl4_1compat_glSecondaryColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3us(red, green, blue); +} + +void gl4_1compat_glSecondaryColor3uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3uiv(v); +} + +void gl4_1compat_glSecondaryColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3ui(red, green, blue); +} + +void gl4_1compat_glSecondaryColor3ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3ubv(v); +} + +void gl4_1compat_glSecondaryColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3ub(red, green, blue); +} + +void gl4_1compat_glSecondaryColor3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3sv(v); +} + +void gl4_1compat_glSecondaryColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3s(red, green, blue); +} + +void gl4_1compat_glSecondaryColor3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3iv(v); +} + +void gl4_1compat_glSecondaryColor3i(void *_glfuncs, GLint red, GLint green, GLint blue) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3i(red, green, blue); +} + +void gl4_1compat_glSecondaryColor3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3fv(v); +} + +void gl4_1compat_glSecondaryColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3f(red, green, blue); +} + +void gl4_1compat_glSecondaryColor3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3dv(v); +} + +void gl4_1compat_glSecondaryColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3d(red, green, blue); +} + +void gl4_1compat_glSecondaryColor3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3bv(v); +} + +void gl4_1compat_glSecondaryColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3b(red, green, blue); +} + +void gl4_1compat_glFogCoordPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordPointer(gltype, stride, pointer); +} + +void gl4_1compat_glFogCoorddv(void *_glfuncs, const GLdouble* coord) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoorddv(coord); +} + +void gl4_1compat_glFogCoordd(void *_glfuncs, GLdouble coord) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordd(coord); +} + +void gl4_1compat_glFogCoordfv(void *_glfuncs, const GLfloat* coord) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordfv(coord); +} + +void gl4_1compat_glFogCoordf(void *_glfuncs, GLfloat coord) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordf(coord); +} + +void gl4_1compat_glVertexAttrib4usv(void *_glfuncs, GLuint index, const GLushort* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4usv(index, v); +} + +void gl4_1compat_glVertexAttrib4uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4uiv(index, v); +} + +void gl4_1compat_glVertexAttrib4ubv(void *_glfuncs, GLuint index, const GLubyte* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4ubv(index, v); +} + +void gl4_1compat_glVertexAttrib4sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4sv(index, v); +} + +void gl4_1compat_glVertexAttrib4s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4s(index, x, y, z, w); +} + +void gl4_1compat_glVertexAttrib4iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4iv(index, v); +} + +void gl4_1compat_glVertexAttrib4fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4fv(index, v); +} + +void gl4_1compat_glVertexAttrib4f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4f(index, x, y, z, w); +} + +void gl4_1compat_glVertexAttrib4dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4dv(index, v); +} + +void gl4_1compat_glVertexAttrib4d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4d(index, x, y, z, w); +} + +void gl4_1compat_glVertexAttrib4bv(void *_glfuncs, GLuint index, const GLbyte* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4bv(index, v); +} + +void gl4_1compat_glVertexAttrib4Nusv(void *_glfuncs, GLuint index, const GLushort* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nusv(index, v); +} + +void gl4_1compat_glVertexAttrib4Nuiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nuiv(index, v); +} + +void gl4_1compat_glVertexAttrib4Nubv(void *_glfuncs, GLuint index, const GLubyte* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nubv(index, v); +} + +void gl4_1compat_glVertexAttrib4Nub(void *_glfuncs, GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nub(index, x, y, z, w); +} + +void gl4_1compat_glVertexAttrib4Nsv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nsv(index, v); +} + +void gl4_1compat_glVertexAttrib4Niv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Niv(index, v); +} + +void gl4_1compat_glVertexAttrib4Nbv(void *_glfuncs, GLuint index, const GLbyte* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nbv(index, v); +} + +void gl4_1compat_glVertexAttrib3sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3sv(index, v); +} + +void gl4_1compat_glVertexAttrib3s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3s(index, x, y, z); +} + +void gl4_1compat_glVertexAttrib3fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3fv(index, v); +} + +void gl4_1compat_glVertexAttrib3f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3f(index, x, y, z); +} + +void gl4_1compat_glVertexAttrib3dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3dv(index, v); +} + +void gl4_1compat_glVertexAttrib3d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3d(index, x, y, z); +} + +void gl4_1compat_glVertexAttrib2sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2sv(index, v); +} + +void gl4_1compat_glVertexAttrib2s(void *_glfuncs, GLuint index, GLshort x, GLshort y) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2s(index, x, y); +} + +void gl4_1compat_glVertexAttrib2fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2fv(index, v); +} + +void gl4_1compat_glVertexAttrib2f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2f(index, x, y); +} + +void gl4_1compat_glVertexAttrib2dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2dv(index, v); +} + +void gl4_1compat_glVertexAttrib2d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2d(index, x, y); +} + +void gl4_1compat_glVertexAttrib1sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1sv(index, v); +} + +void gl4_1compat_glVertexAttrib1s(void *_glfuncs, GLuint index, GLshort x) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1s(index, x); +} + +void gl4_1compat_glVertexAttrib1fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1fv(index, v); +} + +void gl4_1compat_glVertexAttrib1f(void *_glfuncs, GLuint index, GLfloat x) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1f(index, x); +} + +void gl4_1compat_glVertexAttrib1dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1dv(index, v); +} + +void gl4_1compat_glVertexAttrib1d(void *_glfuncs, GLuint index, GLdouble x) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1d(index, x); +} + +void gl4_1compat_glVertexAttribI4usv(void *_glfuncs, GLuint index, const GLushort* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4usv(index, v); +} + +void gl4_1compat_glVertexAttribI4ubv(void *_glfuncs, GLuint index, const GLubyte* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4ubv(index, v); +} + +void gl4_1compat_glVertexAttribI4sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4sv(index, v); +} + +void gl4_1compat_glVertexAttribI4bv(void *_glfuncs, GLuint index, const GLbyte* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4bv(index, v); +} + +void gl4_1compat_glVertexAttribI4uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4uiv(index, v); +} + +void gl4_1compat_glVertexAttribI3uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI3uiv(index, v); +} + +void gl4_1compat_glVertexAttribI2uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI2uiv(index, v); +} + +void gl4_1compat_glVertexAttribI1uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI1uiv(index, v); +} + +void gl4_1compat_glVertexAttribI4iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4iv(index, v); +} + +void gl4_1compat_glVertexAttribI3iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI3iv(index, v); +} + +void gl4_1compat_glVertexAttribI2iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI2iv(index, v); +} + +void gl4_1compat_glVertexAttribI1iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI1iv(index, v); +} + +void gl4_1compat_glVertexAttribI4ui(void *_glfuncs, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4ui(index, x, y, z, w); +} + +void gl4_1compat_glVertexAttribI3ui(void *_glfuncs, GLuint index, GLuint x, GLuint y, GLuint z) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI3ui(index, x, y, z); +} + +void gl4_1compat_glVertexAttribI2ui(void *_glfuncs, GLuint index, GLuint x, GLuint y) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI2ui(index, x, y); +} + +void gl4_1compat_glVertexAttribI1ui(void *_glfuncs, GLuint index, GLuint x) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI1ui(index, x); +} + +void gl4_1compat_glVertexAttribI4i(void *_glfuncs, GLuint index, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4i(index, x, y, z, w); +} + +void gl4_1compat_glVertexAttribI3i(void *_glfuncs, GLuint index, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI3i(index, x, y, z); +} + +void gl4_1compat_glVertexAttribI2i(void *_glfuncs, GLuint index, GLint x, GLint y) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI2i(index, x, y); +} + +void gl4_1compat_glVertexAttribI1i(void *_glfuncs, GLuint index, GLint x) +{ + QOpenGLFunctions_4_1_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI1i(index, x); +} + diff --git a/gl/4.1compat/funcs.h b/gl/4.1compat/funcs.h new file mode 100644 index 00000000..3e583ce9 --- /dev/null +++ b/gl/4.1compat/funcs.h @@ -0,0 +1,920 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#ifndef __cplusplus +#include +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef char GLchar; +typedef signed char GLbyte; /* 1-byte signed */ +typedef short GLshort; /* 2-byte signed */ +typedef int GLint; /* 4-byte signed */ +typedef unsigned char GLubyte; /* 1-byte unsigned */ +typedef unsigned short GLushort; /* 2-byte unsigned */ +typedef unsigned int GLuint; /* 4-byte unsigned */ +typedef int GLsizei; /* 4-byte signed */ +typedef float GLfloat; /* single precision float */ +typedef float GLclampf; /* single precision float in [0,1] */ +typedef double GLdouble; /* double precision float */ +typedef double GLclampd; /* double precision float in [0,1] */ +typedef int64_t GLint64; +typedef uint64_t GLuint64; +typedef ptrdiff_t GLintptr; +typedef ptrdiff_t GLsizeiptr; +typedef ptrdiff_t GLintptrARB; +typedef ptrdiff_t GLsizeiptrARB; +typedef struct __GLsync *GLsync; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +void *gl4_1compat_funcs(); + +void gl4_1compat_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_1compat_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal); +GLboolean gl4_1compat_glIsEnabled(void *_glfuncs, GLenum cap); +void gl4_1compat_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params); +void gl4_1compat_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params); +void gl4_1compat_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_1compat_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl4_1compat_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels); +void gl4_1compat_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params); +void gl4_1compat_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params); +GLenum gl4_1compat_glGetError(void *_glfuncs); +void gl4_1compat_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params); +void gl4_1compat_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params); +void gl4_1compat_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels); +void gl4_1compat_glReadBuffer(void *_glfuncs, GLenum mode); +void gl4_1compat_glPixelStorei(void *_glfuncs, GLenum pname, GLint param); +void gl4_1compat_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param); +void gl4_1compat_glDepthFunc(void *_glfuncs, GLenum glfunc); +void gl4_1compat_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass); +void gl4_1compat_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask); +void gl4_1compat_glLogicOp(void *_glfuncs, GLenum opcode); +void gl4_1compat_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor); +void gl4_1compat_glFlush(void *_glfuncs); +void gl4_1compat_glFinish(void *_glfuncs); +void gl4_1compat_glEnable(void *_glfuncs, GLenum cap); +void gl4_1compat_glDisable(void *_glfuncs, GLenum cap); +void gl4_1compat_glDepthMask(void *_glfuncs, GLboolean flag); +void gl4_1compat_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +void gl4_1compat_glStencilMask(void *_glfuncs, GLuint mask); +void gl4_1compat_glClearDepth(void *_glfuncs, GLdouble depth); +void gl4_1compat_glClearStencil(void *_glfuncs, GLint s); +void gl4_1compat_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl4_1compat_glClear(void *_glfuncs, GLbitfield mask); +void gl4_1compat_glDrawBuffer(void *_glfuncs, GLenum mode); +void gl4_1compat_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_1compat_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_1compat_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl4_1compat_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl4_1compat_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl4_1compat_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl4_1compat_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_1compat_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode); +void gl4_1compat_glPointSize(void *_glfuncs, GLfloat size); +void gl4_1compat_glLineWidth(void *_glfuncs, GLfloat width); +void gl4_1compat_glHint(void *_glfuncs, GLenum target, GLenum mode); +void gl4_1compat_glFrontFace(void *_glfuncs, GLenum mode); +void gl4_1compat_glCullFace(void *_glfuncs, GLenum mode); +void gl4_1compat_glIndexubv(void *_glfuncs, const GLubyte* c); +void gl4_1compat_glIndexub(void *_glfuncs, GLubyte c); +GLboolean gl4_1compat_glIsTexture(void *_glfuncs, GLuint texture); +void gl4_1compat_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures); +void gl4_1compat_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures); +void gl4_1compat_glBindTexture(void *_glfuncs, GLenum target, GLuint texture); +void gl4_1compat_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_1compat_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_1compat_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_1compat_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +void gl4_1compat_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +void gl4_1compat_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border); +void gl4_1compat_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units); +void gl4_1compat_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl4_1compat_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count); +void gl4_1compat_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_1compat_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_1compat_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_1compat_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl4_1compat_glBlendEquation(void *_glfuncs, GLenum mode); +void gl4_1compat_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl4_1compat_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img); +void gl4_1compat_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl4_1compat_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl4_1compat_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl4_1compat_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data); +void gl4_1compat_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data); +void gl4_1compat_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data); +void gl4_1compat_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert); +void gl4_1compat_glActiveTexture(void *_glfuncs, GLenum texture); +void gl4_1compat_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params); +void gl4_1compat_glPointParameteri(void *_glfuncs, GLenum pname, GLint param); +void gl4_1compat_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl4_1compat_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param); +void gl4_1compat_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount); +void gl4_1compat_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +void gl4_1compat_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +GLboolean gl4_1compat_glUnmapBuffer(void *_glfuncs, GLenum target); +void gl4_1compat_glGetBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data); +void gl4_1compat_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data); +void gl4_1compat_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage); +GLboolean gl4_1compat_glIsBuffer(void *_glfuncs, GLuint buffer); +void gl4_1compat_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers); +void gl4_1compat_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers); +void gl4_1compat_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer); +void gl4_1compat_glGetQueryObjectuiv(void *_glfuncs, GLuint id, GLenum pname, GLuint* params); +void gl4_1compat_glGetQueryObjectiv(void *_glfuncs, GLuint id, GLenum pname, GLint* params); +void gl4_1compat_glGetQueryiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_1compat_glEndQuery(void *_glfuncs, GLenum target); +void gl4_1compat_glBeginQuery(void *_glfuncs, GLenum target, GLuint id); +GLboolean gl4_1compat_glIsQuery(void *_glfuncs, GLuint id); +void gl4_1compat_glDeleteQueries(void *_glfuncs, GLsizei n, const GLuint* ids); +void gl4_1compat_glGenQueries(void *_glfuncs, GLsizei n, GLuint* ids); +void gl4_1compat_glVertexAttribPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLboolean normalized, GLsizei stride, const GLvoid* offset); +void gl4_1compat_glValidateProgram(void *_glfuncs, GLuint program); +void gl4_1compat_glUniformMatrix4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_1compat_glUniformMatrix3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_1compat_glUniformMatrix2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_1compat_glUniform4iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl4_1compat_glUniform3iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl4_1compat_glUniform2iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl4_1compat_glUniform1iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl4_1compat_glUniform4fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl4_1compat_glUniform3fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl4_1compat_glUniform2fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl4_1compat_glUniform1fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl4_1compat_glUniform4i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +void gl4_1compat_glUniform3i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2); +void gl4_1compat_glUniform2i(void *_glfuncs, GLint location, GLint v0, GLint v1); +void gl4_1compat_glUniform1i(void *_glfuncs, GLint location, GLint v0); +void gl4_1compat_glUniform4f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +void gl4_1compat_glUniform3f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +void gl4_1compat_glUniform2f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1); +void gl4_1compat_glUniform1f(void *_glfuncs, GLint location, GLfloat v0); +void gl4_1compat_glUseProgram(void *_glfuncs, GLuint program); +void gl4_1compat_glShaderSource(void *_glfuncs, GLuint shader, GLsizei count, const GLchar** source, const GLint* length); +void gl4_1compat_glLinkProgram(void *_glfuncs, GLuint program); +GLboolean gl4_1compat_glIsShader(void *_glfuncs, GLuint shader); +GLboolean gl4_1compat_glIsProgram(void *_glfuncs, GLuint program); +void gl4_1compat_glGetVertexAttribiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params); +void gl4_1compat_glGetVertexAttribfv(void *_glfuncs, GLuint index, GLenum pname, GLfloat* params); +void gl4_1compat_glGetVertexAttribdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params); +void gl4_1compat_glGetUniformiv(void *_glfuncs, GLuint program, GLint location, GLint* params); +void gl4_1compat_glGetUniformfv(void *_glfuncs, GLuint program, GLint location, GLfloat* params); +GLint gl4_1compat_glGetUniformLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl4_1compat_glGetShaderSource(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source); +void gl4_1compat_glGetShaderInfoLog(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl4_1compat_glGetShaderiv(void *_glfuncs, GLuint shader, GLenum pname, GLint* params); +void gl4_1compat_glGetProgramInfoLog(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl4_1compat_glGetProgramiv(void *_glfuncs, GLuint program, GLenum pname, GLint* params); +GLint gl4_1compat_glGetAttribLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl4_1compat_glGetAttachedShaders(void *_glfuncs, GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj); +void gl4_1compat_glGetActiveUniform(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name); +void gl4_1compat_glGetActiveAttrib(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name); +void gl4_1compat_glEnableVertexAttribArray(void *_glfuncs, GLuint index); +void gl4_1compat_glDisableVertexAttribArray(void *_glfuncs, GLuint index); +void gl4_1compat_glDetachShader(void *_glfuncs, GLuint program, GLuint shader); +void gl4_1compat_glDeleteShader(void *_glfuncs, GLuint shader); +void gl4_1compat_glDeleteProgram(void *_glfuncs, GLuint program); +GLuint gl4_1compat_glCreateShader(void *_glfuncs, GLenum gltype); +GLuint gl4_1compat_glCreateProgram(void *_glfuncs); +void gl4_1compat_glCompileShader(void *_glfuncs, GLuint shader); +void gl4_1compat_glBindAttribLocation(void *_glfuncs, GLuint program, GLuint index, const GLchar* name); +void gl4_1compat_glAttachShader(void *_glfuncs, GLuint program, GLuint shader); +void gl4_1compat_glStencilMaskSeparate(void *_glfuncs, GLenum face, GLuint mask); +void gl4_1compat_glStencilFuncSeparate(void *_glfuncs, GLenum face, GLenum glfunc, GLint ref, GLuint mask); +void gl4_1compat_glStencilOpSeparate(void *_glfuncs, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +void gl4_1compat_glDrawBuffers(void *_glfuncs, GLsizei n, const GLenum* bufs); +void gl4_1compat_glBlendEquationSeparate(void *_glfuncs, GLenum modeRGB, GLenum modeAlpha); +void gl4_1compat_glUniformMatrix4x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_1compat_glUniformMatrix3x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_1compat_glUniformMatrix4x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_1compat_glUniformMatrix2x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_1compat_glUniformMatrix3x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_1compat_glUniformMatrix2x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +GLboolean gl4_1compat_glIsVertexArray(void *_glfuncs, GLuint array); +void gl4_1compat_glGenVertexArrays(void *_glfuncs, GLsizei n, GLuint* arrays); +void gl4_1compat_glDeleteVertexArrays(void *_glfuncs, GLsizei n, const GLuint* arrays); +void gl4_1compat_glBindVertexArray(void *_glfuncs, GLuint array); +void gl4_1compat_glFlushMappedBufferRange(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr length); +void gl4_1compat_glFramebufferTextureLayer(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +void gl4_1compat_glRenderbufferStorageMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height); +void gl4_1compat_glBlitFramebuffer(void *_glfuncs, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +void gl4_1compat_glGenerateMipmap(void *_glfuncs, GLenum target); +void gl4_1compat_glGetFramebufferAttachmentParameteriv(void *_glfuncs, GLenum target, GLenum attachment, GLenum pname, GLint* params); +void gl4_1compat_glFramebufferRenderbuffer(void *_glfuncs, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +void gl4_1compat_glFramebufferTexture3D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +void gl4_1compat_glFramebufferTexture2D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +void gl4_1compat_glFramebufferTexture1D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLenum gl4_1compat_glCheckFramebufferStatus(void *_glfuncs, GLenum target); +void gl4_1compat_glGenFramebuffers(void *_glfuncs, GLsizei n, GLuint* framebuffers); +void gl4_1compat_glDeleteFramebuffers(void *_glfuncs, GLsizei n, const GLuint* framebuffers); +void gl4_1compat_glBindFramebuffer(void *_glfuncs, GLenum target, GLuint framebuffer); +GLboolean gl4_1compat_glIsFramebuffer(void *_glfuncs, GLuint framebuffer); +void gl4_1compat_glGetRenderbufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_1compat_glRenderbufferStorage(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height); +void gl4_1compat_glGenRenderbuffers(void *_glfuncs, GLsizei n, GLuint* renderbuffers); +void gl4_1compat_glDeleteRenderbuffers(void *_glfuncs, GLsizei n, const GLuint* renderbuffers); +void gl4_1compat_glBindRenderbuffer(void *_glfuncs, GLenum target, GLuint renderbuffer); +GLboolean gl4_1compat_glIsRenderbuffer(void *_glfuncs, GLuint renderbuffer); +void gl4_1compat_glClearBufferfi(void *_glfuncs, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); +void gl4_1compat_glClearBufferfv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLfloat* value); +void gl4_1compat_glClearBufferuiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLuint* value); +void gl4_1compat_glClearBufferiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLint* value); +void gl4_1compat_glGetTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, GLuint* params); +void gl4_1compat_glGetTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_1compat_glTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, const GLuint* params); +void gl4_1compat_glTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl4_1compat_glUniform4uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl4_1compat_glUniform3uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl4_1compat_glUniform2uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl4_1compat_glUniform1uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl4_1compat_glUniform4ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +void gl4_1compat_glUniform3ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2); +void gl4_1compat_glUniform2ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1); +void gl4_1compat_glUniform1ui(void *_glfuncs, GLint location, GLuint v0); +GLint gl4_1compat_glGetFragDataLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl4_1compat_glBindFragDataLocation(void *_glfuncs, GLuint program, GLuint color, const GLchar* name); +void gl4_1compat_glGetUniformuiv(void *_glfuncs, GLuint program, GLint location, GLuint* params); +void gl4_1compat_glGetVertexAttribIuiv(void *_glfuncs, GLuint index, GLenum pname, GLuint* params); +void gl4_1compat_glGetVertexAttribIiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params); +void gl4_1compat_glVertexAttribIPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_1compat_glEndConditionalRender(void *_glfuncs); +void gl4_1compat_glBeginConditionalRender(void *_glfuncs, GLuint id, GLenum mode); +void gl4_1compat_glClampColor(void *_glfuncs, GLenum target, GLenum clamp); +void gl4_1compat_glGetTransformFeedbackVarying(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* gltype, GLchar* name); +void gl4_1compat_glBindBufferBase(void *_glfuncs, GLenum target, GLuint index, GLuint buffer); +void gl4_1compat_glBindBufferRange(void *_glfuncs, GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +void gl4_1compat_glEndTransformFeedback(void *_glfuncs); +void gl4_1compat_glBeginTransformFeedback(void *_glfuncs, GLenum primitiveMode); +GLboolean gl4_1compat_glIsEnabledi(void *_glfuncs, GLenum target, GLuint index); +void gl4_1compat_glDisablei(void *_glfuncs, GLenum target, GLuint index); +void gl4_1compat_glEnablei(void *_glfuncs, GLenum target, GLuint index); +void gl4_1compat_glGetIntegeri_v(void *_glfuncs, GLenum target, GLuint index, GLint* data); +void gl4_1compat_glGetBooleani_v(void *_glfuncs, GLenum target, GLuint index, GLboolean* data); +void gl4_1compat_glColorMaski(void *_glfuncs, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +void gl4_1compat_glCopyBufferSubData(void *_glfuncs, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +void gl4_1compat_glUniformBlockBinding(void *_glfuncs, GLuint program, GLuint v0, GLuint v1); +void gl4_1compat_glGetActiveUniformBlockName(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName); +void gl4_1compat_glGetActiveUniformBlockiv(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params); +GLuint gl4_1compat_glGetUniformBlockIndex(void *_glfuncs, GLuint program, const GLchar* uniformBlockName); +void gl4_1compat_glGetActiveUniformName(void *_glfuncs, GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName); +void gl4_1compat_glGetActiveUniformsiv(void *_glfuncs, GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params); +void gl4_1compat_glPrimitiveRestartIndex(void *_glfuncs, GLuint index); +void gl4_1compat_glTexBuffer(void *_glfuncs, GLenum target, GLenum internalFormat, GLuint buffer); +void gl4_1compat_glDrawElementsInstanced(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount); +void gl4_1compat_glDrawArraysInstanced(void *_glfuncs, GLenum mode, GLint first, GLsizei count, GLsizei instancecount); +void gl4_1compat_glSampleMaski(void *_glfuncs, GLuint index, GLbitfield mask); +void gl4_1compat_glGetMultisamplefv(void *_glfuncs, GLenum pname, GLuint index, GLfloat* val); +void gl4_1compat_glTexImage3DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); +void gl4_1compat_glTexImage2DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +void gl4_1compat_glGetSynciv(void *_glfuncs, GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values); +void gl4_1compat_glGetInteger64v(void *_glfuncs, GLenum pname, GLint64* params); +void gl4_1compat_glWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout); +GLenum gl4_1compat_glClientWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout); +void gl4_1compat_glDeleteSync(void *_glfuncs, GLsync sync); +GLboolean gl4_1compat_glIsSync(void *_glfuncs, GLsync sync); +GLsync gl4_1compat_glFenceSync(void *_glfuncs, GLenum condition, GLbitfield flags); +void gl4_1compat_glProvokingVertex(void *_glfuncs, GLenum mode); +void gl4_1compat_glDrawElementsInstancedBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLint basevertex); +void gl4_1compat_glDrawRangeElementsBaseVertex(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex); +void gl4_1compat_glDrawElementsBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex); +void gl4_1compat_glFramebufferTexture(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level); +void gl4_1compat_glGetBufferParameteri64v(void *_glfuncs, GLenum target, GLenum pname, GLint64* params); +void gl4_1compat_glGetInteger64i_v(void *_glfuncs, GLenum target, GLuint index, GLint64* data); +void gl4_1compat_glVertexAttribP4uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl4_1compat_glVertexAttribP4ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl4_1compat_glVertexAttribP3uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl4_1compat_glVertexAttribP3ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl4_1compat_glVertexAttribP2uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl4_1compat_glVertexAttribP2ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl4_1compat_glVertexAttribP1uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl4_1compat_glVertexAttribP1ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl4_1compat_glSecondaryColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color); +void gl4_1compat_glSecondaryColorP3ui(void *_glfuncs, GLenum gltype, GLuint color); +void gl4_1compat_glColorP4uiv(void *_glfuncs, GLenum gltype, const GLuint* color); +void gl4_1compat_glColorP4ui(void *_glfuncs, GLenum gltype, GLuint color); +void gl4_1compat_glColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color); +void gl4_1compat_glColorP3ui(void *_glfuncs, GLenum gltype, GLuint color); +void gl4_1compat_glNormalP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_1compat_glNormalP3ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_1compat_glMultiTexCoordP4uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl4_1compat_glMultiTexCoordP4ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl4_1compat_glMultiTexCoordP3uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl4_1compat_glMultiTexCoordP3ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl4_1compat_glMultiTexCoordP2uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl4_1compat_glMultiTexCoordP2ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl4_1compat_glMultiTexCoordP1uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl4_1compat_glMultiTexCoordP1ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl4_1compat_glTexCoordP4uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_1compat_glTexCoordP4ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_1compat_glTexCoordP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_1compat_glTexCoordP3ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_1compat_glTexCoordP2uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_1compat_glTexCoordP2ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_1compat_glTexCoordP1uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_1compat_glTexCoordP1ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_1compat_glVertexP4uiv(void *_glfuncs, GLenum gltype, const GLuint* value); +void gl4_1compat_glVertexP4ui(void *_glfuncs, GLenum gltype, GLuint value); +void gl4_1compat_glVertexP3uiv(void *_glfuncs, GLenum gltype, const GLuint* value); +void gl4_1compat_glVertexP3ui(void *_glfuncs, GLenum gltype, GLuint value); +void gl4_1compat_glVertexP2uiv(void *_glfuncs, GLenum gltype, const GLuint* value); +void gl4_1compat_glVertexP2ui(void *_glfuncs, GLenum gltype, GLuint value); +void gl4_1compat_glGetQueryObjectui64v(void *_glfuncs, GLuint id, GLenum pname, GLuint64* params); +void gl4_1compat_glGetQueryObjecti64v(void *_glfuncs, GLuint id, GLenum pname, GLint64* params); +void gl4_1compat_glQueryCounter(void *_glfuncs, GLuint id, GLenum target); +void gl4_1compat_glGetSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, GLuint* params); +void gl4_1compat_glGetSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat* params); +void gl4_1compat_glGetSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params); +void gl4_1compat_glGetSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params); +void gl4_1compat_glSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLuint* param); +void gl4_1compat_glSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param); +void gl4_1compat_glSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, const GLfloat* param); +void gl4_1compat_glSamplerParameterf(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat param); +void gl4_1compat_glSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param); +void gl4_1compat_glSamplerParameteri(void *_glfuncs, GLuint sampler, GLenum pname, GLint param); +void gl4_1compat_glBindSampler(void *_glfuncs, GLuint unit, GLuint sampler); +GLboolean gl4_1compat_glIsSampler(void *_glfuncs, GLuint sampler); +void gl4_1compat_glDeleteSamplers(void *_glfuncs, GLsizei count, const GLuint* samplers); +void gl4_1compat_glGenSamplers(void *_glfuncs, GLsizei count, GLuint* samplers); +GLint gl4_1compat_glGetFragDataIndex(void *_glfuncs, GLuint program, const GLchar* name); +void gl4_1compat_glBindFragDataLocationIndexed(void *_glfuncs, GLuint program, GLuint colorNumber, GLuint index, const GLchar* name); +void gl4_1compat_glVertexAttribDivisor(void *_glfuncs, GLuint index, GLuint divisor); +void gl4_1compat_glGetQueryIndexediv(void *_glfuncs, GLenum target, GLuint index, GLenum pname, GLint* params); +void gl4_1compat_glEndQueryIndexed(void *_glfuncs, GLenum target, GLuint index); +void gl4_1compat_glBeginQueryIndexed(void *_glfuncs, GLenum target, GLuint index, GLuint id); +void gl4_1compat_glDrawTransformFeedbackStream(void *_glfuncs, GLenum mode, GLuint id, GLuint stream); +void gl4_1compat_glDrawTransformFeedback(void *_glfuncs, GLenum mode, GLuint id); +void gl4_1compat_glResumeTransformFeedback(void *_glfuncs); +void gl4_1compat_glPauseTransformFeedback(void *_glfuncs); +GLboolean gl4_1compat_glIsTransformFeedback(void *_glfuncs, GLuint id); +void gl4_1compat_glGenTransformFeedbacks(void *_glfuncs, GLsizei n, GLuint* ids); +void gl4_1compat_glDeleteTransformFeedbacks(void *_glfuncs, GLsizei n, const GLuint* ids); +void gl4_1compat_glBindTransformFeedback(void *_glfuncs, GLenum target, GLuint id); +void gl4_1compat_glPatchParameterfv(void *_glfuncs, GLenum pname, const GLfloat* values); +void gl4_1compat_glPatchParameteri(void *_glfuncs, GLenum pname, GLint value); +void gl4_1compat_glGetProgramStageiv(void *_glfuncs, GLuint program, GLenum shadertype, GLenum pname, GLint* values); +void gl4_1compat_glGetUniformSubroutineuiv(void *_glfuncs, GLenum shadertype, GLint location, GLuint* params); +void gl4_1compat_glUniformSubroutinesuiv(void *_glfuncs, GLenum shadertype, GLsizei count, const GLuint* value); +void gl4_1compat_glGetActiveSubroutineName(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name); +void gl4_1compat_glGetActiveSubroutineUniformName(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name); +void gl4_1compat_glGetActiveSubroutineUniformiv(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint* values); +GLuint gl4_1compat_glGetSubroutineIndex(void *_glfuncs, GLuint program, GLenum shadertype, const GLchar* name); +GLint gl4_1compat_glGetSubroutineUniformLocation(void *_glfuncs, GLuint program, GLenum shadertype, const GLchar* name); +void gl4_1compat_glGetUniformdv(void *_glfuncs, GLuint program, GLint location, GLdouble* params); +void gl4_1compat_glUniformMatrix4x3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1compat_glUniformMatrix4x2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1compat_glUniformMatrix3x4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1compat_glUniformMatrix3x2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1compat_glUniformMatrix2x4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1compat_glUniformMatrix2x3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1compat_glUniformMatrix4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1compat_glUniformMatrix3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1compat_glUniformMatrix2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1compat_glUniform4dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value); +void gl4_1compat_glUniform3dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value); +void gl4_1compat_glUniform2dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value); +void gl4_1compat_glUniform1dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value); +void gl4_1compat_glUniform4d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3); +void gl4_1compat_glUniform3d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1, GLdouble v2); +void gl4_1compat_glUniform2d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1); +void gl4_1compat_glUniform1d(void *_glfuncs, GLint location, GLdouble v0); +void gl4_1compat_glDrawElementsIndirect(void *_glfuncs, GLenum mode, GLenum gltype, const GLvoid* indirect); +void gl4_1compat_glDrawArraysIndirect(void *_glfuncs, GLenum mode, const GLvoid* indirect); +void gl4_1compat_glBlendFuncSeparatei(void *_glfuncs, GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); +void gl4_1compat_glBlendFunci(void *_glfuncs, GLuint buf, GLenum src, GLenum dst); +void gl4_1compat_glBlendEquationSeparatei(void *_glfuncs, GLuint buf, GLenum modeRGB, GLenum modeAlpha); +void gl4_1compat_glBlendEquationi(void *_glfuncs, GLuint buf, GLenum mode); +void gl4_1compat_glMinSampleShading(void *_glfuncs, GLfloat value); +void gl4_1compat_glGetDoublei_v(void *_glfuncs, GLenum target, GLuint index, GLdouble* data); +void gl4_1compat_glGetFloati_v(void *_glfuncs, GLenum target, GLuint index, GLfloat* data); +void gl4_1compat_glDepthRangeIndexed(void *_glfuncs, GLuint index, GLdouble n, GLdouble f); +void gl4_1compat_glDepthRangeArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLdouble* v); +void gl4_1compat_glScissorIndexedv(void *_glfuncs, GLuint index, const GLint* v); +void gl4_1compat_glScissorIndexed(void *_glfuncs, GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height); +void gl4_1compat_glScissorArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLint* v); +void gl4_1compat_glViewportIndexedfv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl4_1compat_glViewportIndexedf(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h); +void gl4_1compat_glViewportArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLfloat* v); +void gl4_1compat_glGetVertexAttribLdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params); +void gl4_1compat_glVertexAttribLPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_1compat_glVertexAttribL4dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_1compat_glVertexAttribL3dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_1compat_glVertexAttribL2dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_1compat_glVertexAttribL1dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_1compat_glVertexAttribL4d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl4_1compat_glVertexAttribL3d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z); +void gl4_1compat_glVertexAttribL2d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y); +void gl4_1compat_glVertexAttribL1d(void *_glfuncs, GLuint index, GLdouble x); +void gl4_1compat_glGetProgramPipelineInfoLog(void *_glfuncs, GLuint pipeline, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl4_1compat_glValidateProgramPipeline(void *_glfuncs, GLuint pipeline); +void gl4_1compat_glProgramUniformMatrix4x3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1compat_glProgramUniformMatrix3x4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1compat_glProgramUniformMatrix4x2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1compat_glProgramUniformMatrix2x4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1compat_glProgramUniformMatrix3x2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1compat_glProgramUniformMatrix2x3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1compat_glProgramUniformMatrix4x3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_1compat_glProgramUniformMatrix3x4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_1compat_glProgramUniformMatrix4x2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_1compat_glProgramUniformMatrix2x4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_1compat_glProgramUniformMatrix3x2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_1compat_glProgramUniformMatrix2x3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_1compat_glProgramUniformMatrix4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1compat_glProgramUniformMatrix3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1compat_glProgramUniformMatrix2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1compat_glProgramUniformMatrix4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_1compat_glProgramUniformMatrix3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_1compat_glProgramUniformMatrix2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_1compat_glProgramUniform4uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value); +void gl4_1compat_glProgramUniform4ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +void gl4_1compat_glProgramUniform4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value); +void gl4_1compat_glProgramUniform4d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3); +void gl4_1compat_glProgramUniform4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value); +void gl4_1compat_glProgramUniform4f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +void gl4_1compat_glProgramUniform4iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value); +void gl4_1compat_glProgramUniform4i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +void gl4_1compat_glProgramUniform3uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value); +void gl4_1compat_glProgramUniform3ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2); +void gl4_1compat_glProgramUniform3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value); +void gl4_1compat_glProgramUniform3d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2); +void gl4_1compat_glProgramUniform3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value); +void gl4_1compat_glProgramUniform3f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +void gl4_1compat_glProgramUniform3iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value); +void gl4_1compat_glProgramUniform3i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1, GLint v2); +void gl4_1compat_glProgramUniform2uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value); +void gl4_1compat_glProgramUniform2ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1); +void gl4_1compat_glProgramUniform2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value); +void gl4_1compat_glProgramUniform2d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1); +void gl4_1compat_glProgramUniform2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value); +void gl4_1compat_glProgramUniform2f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1); +void gl4_1compat_glProgramUniform2iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value); +void gl4_1compat_glProgramUniform2i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1); +void gl4_1compat_glProgramUniform1uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value); +void gl4_1compat_glProgramUniform1ui(void *_glfuncs, GLuint program, GLint location, GLuint v0); +void gl4_1compat_glProgramUniform1dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value); +void gl4_1compat_glProgramUniform1d(void *_glfuncs, GLuint program, GLint location, GLdouble v0); +void gl4_1compat_glProgramUniform1fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value); +void gl4_1compat_glProgramUniform1f(void *_glfuncs, GLuint program, GLint location, GLfloat v0); +void gl4_1compat_glProgramUniform1iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value); +void gl4_1compat_glProgramUniform1i(void *_glfuncs, GLuint program, GLint location, GLint v0); +void gl4_1compat_glGetProgramPipelineiv(void *_glfuncs, GLuint pipeline, GLenum pname, GLint* params); +GLboolean gl4_1compat_glIsProgramPipeline(void *_glfuncs, GLuint pipeline); +void gl4_1compat_glGenProgramPipelines(void *_glfuncs, GLsizei n, GLuint* pipelines); +void gl4_1compat_glDeleteProgramPipelines(void *_glfuncs, GLsizei n, const GLuint* pipelines); +void gl4_1compat_glBindProgramPipeline(void *_glfuncs, GLuint pipeline); +void gl4_1compat_glActiveShaderProgram(void *_glfuncs, GLuint pipeline, GLuint program); +void gl4_1compat_glUseProgramStages(void *_glfuncs, GLuint pipeline, GLbitfield stages, GLuint program); +void gl4_1compat_glProgramParameteri(void *_glfuncs, GLuint program, GLenum pname, GLint value); +void gl4_1compat_glProgramBinary(void *_glfuncs, GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length); +void gl4_1compat_glGetProgramBinary(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary); +void gl4_1compat_glClearDepthf(void *_glfuncs, GLfloat dd); +void gl4_1compat_glDepthRangef(void *_glfuncs, GLfloat n, GLfloat f); +void gl4_1compat_glGetShaderPrecisionFormat(void *_glfuncs, GLenum shadertype, GLenum precisionType, GLint* range_, GLint* precision); +void gl4_1compat_glShaderBinary(void *_glfuncs, GLsizei count, const GLuint* shaders, GLenum binaryFormat, const GLvoid* binary, GLsizei length); +void gl4_1compat_glReleaseShaderCompiler(void *_glfuncs); +void gl4_1compat_glTranslatef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl4_1compat_glTranslated(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl4_1compat_glScalef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl4_1compat_glScaled(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl4_1compat_glRotatef(void *_glfuncs, GLfloat angle, GLfloat x, GLfloat y, GLfloat z); +void gl4_1compat_glRotated(void *_glfuncs, GLdouble angle, GLdouble x, GLdouble y, GLdouble z); +void gl4_1compat_glPushMatrix(void *_glfuncs); +void gl4_1compat_glPopMatrix(void *_glfuncs); +void gl4_1compat_glOrtho(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +void gl4_1compat_glMultMatrixd(void *_glfuncs, const GLdouble* m); +void gl4_1compat_glMultMatrixf(void *_glfuncs, const GLfloat* m); +void gl4_1compat_glMatrixMode(void *_glfuncs, GLenum mode); +void gl4_1compat_glLoadMatrixd(void *_glfuncs, const GLdouble* m); +void gl4_1compat_glLoadMatrixf(void *_glfuncs, const GLfloat* m); +void gl4_1compat_glLoadIdentity(void *_glfuncs); +void gl4_1compat_glFrustum(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +GLboolean gl4_1compat_glIsList(void *_glfuncs, GLuint list); +void gl4_1compat_glGetTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, GLint* params); +void gl4_1compat_glGetTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, GLfloat* params); +void gl4_1compat_glGetTexGendv(void *_glfuncs, GLenum coord, GLenum pname, GLdouble* params); +void gl4_1compat_glGetTexEnviv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_1compat_glGetTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl4_1compat_glGetPolygonStipple(void *_glfuncs, GLubyte* mask); +void gl4_1compat_glGetPixelMapusv(void *_glfuncs, GLenum glmap, GLushort* values); +void gl4_1compat_glGetPixelMapuiv(void *_glfuncs, GLenum glmap, GLuint* values); +void gl4_1compat_glGetPixelMapfv(void *_glfuncs, GLenum glmap, GLfloat* values); +void gl4_1compat_glGetMaterialiv(void *_glfuncs, GLenum face, GLenum pname, GLint* params); +void gl4_1compat_glGetMaterialfv(void *_glfuncs, GLenum face, GLenum pname, GLfloat* params); +void gl4_1compat_glGetMapiv(void *_glfuncs, GLenum target, GLenum query, GLint* v); +void gl4_1compat_glGetMapfv(void *_glfuncs, GLenum target, GLenum query, GLfloat* v); +void gl4_1compat_glGetMapdv(void *_glfuncs, GLenum target, GLenum query, GLdouble* v); +void gl4_1compat_glGetLightiv(void *_glfuncs, GLenum light, GLenum pname, GLint* params); +void gl4_1compat_glGetLightfv(void *_glfuncs, GLenum light, GLenum pname, GLfloat* params); +void gl4_1compat_glGetClipPlane(void *_glfuncs, GLenum plane, GLdouble* equation); +void gl4_1compat_glDrawPixels(void *_glfuncs, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_1compat_glCopyPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum gltype); +void gl4_1compat_glPixelMapusv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLushort* values); +void gl4_1compat_glPixelMapuiv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLuint* values); +void gl4_1compat_glPixelMapfv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLfloat* values); +void gl4_1compat_glPixelTransferi(void *_glfuncs, GLenum pname, GLint param); +void gl4_1compat_glPixelTransferf(void *_glfuncs, GLenum pname, GLfloat param); +void gl4_1compat_glPixelZoom(void *_glfuncs, GLfloat xfactor, GLfloat yfactor); +void gl4_1compat_glAlphaFunc(void *_glfuncs, GLenum glfunc, GLfloat ref); +void gl4_1compat_glEvalPoint2(void *_glfuncs, GLint i, GLint j); +void gl4_1compat_glEvalMesh2(void *_glfuncs, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); +void gl4_1compat_glEvalPoint1(void *_glfuncs, GLint i); +void gl4_1compat_glEvalMesh1(void *_glfuncs, GLenum mode, GLint i1, GLint i2); +void gl4_1compat_glEvalCoord2fv(void *_glfuncs, const GLfloat* u); +void gl4_1compat_glEvalCoord2f(void *_glfuncs, GLfloat u, GLfloat v); +void gl4_1compat_glEvalCoord2dv(void *_glfuncs, const GLdouble* u); +void gl4_1compat_glEvalCoord2d(void *_glfuncs, GLdouble u, GLdouble v); +void gl4_1compat_glEvalCoord1fv(void *_glfuncs, const GLfloat* u); +void gl4_1compat_glEvalCoord1f(void *_glfuncs, GLfloat u); +void gl4_1compat_glEvalCoord1dv(void *_glfuncs, const GLdouble* u); +void gl4_1compat_glEvalCoord1d(void *_glfuncs, GLdouble u); +void gl4_1compat_glMapGrid2f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); +void gl4_1compat_glMapGrid2d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); +void gl4_1compat_glMapGrid1f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2); +void gl4_1compat_glMapGrid1d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2); +void gl4_1compat_glMap2f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points); +void gl4_1compat_glMap2d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points); +void gl4_1compat_glMap1f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points); +void gl4_1compat_glMap1d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points); +void gl4_1compat_glPushAttrib(void *_glfuncs, GLbitfield mask); +void gl4_1compat_glPopAttrib(void *_glfuncs); +void gl4_1compat_glAccum(void *_glfuncs, GLenum op, GLfloat value); +void gl4_1compat_glIndexMask(void *_glfuncs, GLuint mask); +void gl4_1compat_glClearIndex(void *_glfuncs, GLfloat c); +void gl4_1compat_glClearAccum(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl4_1compat_glPushName(void *_glfuncs, GLuint name); +void gl4_1compat_glPopName(void *_glfuncs); +void gl4_1compat_glPassThrough(void *_glfuncs, GLfloat token); +void gl4_1compat_glLoadName(void *_glfuncs, GLuint name); +void gl4_1compat_glInitNames(void *_glfuncs); +GLint gl4_1compat_glRenderMode(void *_glfuncs, GLenum mode); +void gl4_1compat_glSelectBuffer(void *_glfuncs, GLsizei size, GLuint* buffer); +void gl4_1compat_glFeedbackBuffer(void *_glfuncs, GLsizei size, GLenum gltype, GLfloat* buffer); +void gl4_1compat_glTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, const GLint* params); +void gl4_1compat_glTexGeni(void *_glfuncs, GLenum coord, GLenum pname, GLint param); +void gl4_1compat_glTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, const GLfloat* params); +void gl4_1compat_glTexGenf(void *_glfuncs, GLenum coord, GLenum pname, GLfloat param); +void gl4_1compat_glTexGendv(void *_glfuncs, GLenum coord, GLenum pname, const GLdouble* params); +void gl4_1compat_glTexGend(void *_glfuncs, GLenum coord, GLenum pname, GLdouble param); +void gl4_1compat_glTexEnviv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl4_1compat_glTexEnvi(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl4_1compat_glTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl4_1compat_glTexEnvf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl4_1compat_glShadeModel(void *_glfuncs, GLenum mode); +void gl4_1compat_glPolygonStipple(void *_glfuncs, const GLubyte* mask); +void gl4_1compat_glMaterialiv(void *_glfuncs, GLenum face, GLenum pname, const GLint* params); +void gl4_1compat_glMateriali(void *_glfuncs, GLenum face, GLenum pname, GLint param); +void gl4_1compat_glMaterialfv(void *_glfuncs, GLenum face, GLenum pname, const GLfloat* params); +void gl4_1compat_glMaterialf(void *_glfuncs, GLenum face, GLenum pname, GLfloat param); +void gl4_1compat_glLineStipple(void *_glfuncs, GLint factor, GLushort pattern); +void gl4_1compat_glLightModeliv(void *_glfuncs, GLenum pname, const GLint* params); +void gl4_1compat_glLightModeli(void *_glfuncs, GLenum pname, GLint param); +void gl4_1compat_glLightModelfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl4_1compat_glLightModelf(void *_glfuncs, GLenum pname, GLfloat param); +void gl4_1compat_glLightiv(void *_glfuncs, GLenum light, GLenum pname, const GLint* params); +void gl4_1compat_glLighti(void *_glfuncs, GLenum light, GLenum pname, GLint param); +void gl4_1compat_glLightfv(void *_glfuncs, GLenum light, GLenum pname, const GLfloat* params); +void gl4_1compat_glLightf(void *_glfuncs, GLenum light, GLenum pname, GLfloat param); +void gl4_1compat_glFogiv(void *_glfuncs, GLenum pname, const GLint* params); +void gl4_1compat_glFogi(void *_glfuncs, GLenum pname, GLint param); +void gl4_1compat_glFogfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl4_1compat_glFogf(void *_glfuncs, GLenum pname, GLfloat param); +void gl4_1compat_glColorMaterial(void *_glfuncs, GLenum face, GLenum mode); +void gl4_1compat_glClipPlane(void *_glfuncs, GLenum plane, const GLdouble* equation); +void gl4_1compat_glVertex4sv(void *_glfuncs, const GLshort* v); +void gl4_1compat_glVertex4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w); +void gl4_1compat_glVertex4iv(void *_glfuncs, const GLint* v); +void gl4_1compat_glVertex4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w); +void gl4_1compat_glVertex4fv(void *_glfuncs, const GLfloat* v); +void gl4_1compat_glVertex4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl4_1compat_glVertex4dv(void *_glfuncs, const GLdouble* v); +void gl4_1compat_glVertex4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl4_1compat_glVertex3sv(void *_glfuncs, const GLshort* v); +void gl4_1compat_glVertex3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl4_1compat_glVertex3iv(void *_glfuncs, const GLint* v); +void gl4_1compat_glVertex3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl4_1compat_glVertex3fv(void *_glfuncs, const GLfloat* v); +void gl4_1compat_glVertex3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl4_1compat_glVertex3dv(void *_glfuncs, const GLdouble* v); +void gl4_1compat_glVertex3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl4_1compat_glVertex2sv(void *_glfuncs, const GLshort* v); +void gl4_1compat_glVertex2s(void *_glfuncs, GLshort x, GLshort y); +void gl4_1compat_glVertex2iv(void *_glfuncs, const GLint* v); +void gl4_1compat_glVertex2i(void *_glfuncs, GLint x, GLint y); +void gl4_1compat_glVertex2fv(void *_glfuncs, const GLfloat* v); +void gl4_1compat_glVertex2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl4_1compat_glVertex2dv(void *_glfuncs, const GLdouble* v); +void gl4_1compat_glVertex2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl4_1compat_glTexCoord4sv(void *_glfuncs, const GLshort* v); +void gl4_1compat_glTexCoord4s(void *_glfuncs, GLshort s, GLshort t, GLshort r, GLshort q); +void gl4_1compat_glTexCoord4iv(void *_glfuncs, const GLint* v); +void gl4_1compat_glTexCoord4i(void *_glfuncs, GLint s, GLint t, GLint r, GLint q); +void gl4_1compat_glTexCoord4fv(void *_glfuncs, const GLfloat* v); +void gl4_1compat_glTexCoord4f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +void gl4_1compat_glTexCoord4dv(void *_glfuncs, const GLdouble* v); +void gl4_1compat_glTexCoord4d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +void gl4_1compat_glTexCoord3sv(void *_glfuncs, const GLshort* v); +void gl4_1compat_glTexCoord3s(void *_glfuncs, GLshort s, GLshort t, GLshort r); +void gl4_1compat_glTexCoord3iv(void *_glfuncs, const GLint* v); +void gl4_1compat_glTexCoord3i(void *_glfuncs, GLint s, GLint t, GLint r); +void gl4_1compat_glTexCoord3fv(void *_glfuncs, const GLfloat* v); +void gl4_1compat_glTexCoord3f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r); +void gl4_1compat_glTexCoord3dv(void *_glfuncs, const GLdouble* v); +void gl4_1compat_glTexCoord3d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r); +void gl4_1compat_glTexCoord2sv(void *_glfuncs, const GLshort* v); +void gl4_1compat_glTexCoord2s(void *_glfuncs, GLshort s, GLshort t); +void gl4_1compat_glTexCoord2iv(void *_glfuncs, const GLint* v); +void gl4_1compat_glTexCoord2i(void *_glfuncs, GLint s, GLint t); +void gl4_1compat_glTexCoord2fv(void *_glfuncs, const GLfloat* v); +void gl4_1compat_glTexCoord2f(void *_glfuncs, GLfloat s, GLfloat t); +void gl4_1compat_glTexCoord2dv(void *_glfuncs, const GLdouble* v); +void gl4_1compat_glTexCoord2d(void *_glfuncs, GLdouble s, GLdouble t); +void gl4_1compat_glTexCoord1sv(void *_glfuncs, const GLshort* v); +void gl4_1compat_glTexCoord1s(void *_glfuncs, GLshort s); +void gl4_1compat_glTexCoord1iv(void *_glfuncs, const GLint* v); +void gl4_1compat_glTexCoord1i(void *_glfuncs, GLint s); +void gl4_1compat_glTexCoord1fv(void *_glfuncs, const GLfloat* v); +void gl4_1compat_glTexCoord1f(void *_glfuncs, GLfloat s); +void gl4_1compat_glTexCoord1dv(void *_glfuncs, const GLdouble* v); +void gl4_1compat_glTexCoord1d(void *_glfuncs, GLdouble s); +void gl4_1compat_glRectsv(void *_glfuncs, const GLshort* v1, const GLshort* v2); +void gl4_1compat_glRects(void *_glfuncs, GLshort x1, GLshort y1, GLshort x2, GLshort y2); +void gl4_1compat_glRectiv(void *_glfuncs, const GLint* v1, const GLint* v2); +void gl4_1compat_glRecti(void *_glfuncs, GLint x1, GLint y1, GLint x2, GLint y2); +void gl4_1compat_glRectfv(void *_glfuncs, const GLfloat* v1, const GLfloat* v2); +void gl4_1compat_glRectf(void *_glfuncs, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); +void gl4_1compat_glRectdv(void *_glfuncs, const GLdouble* v1, const GLdouble* v2); +void gl4_1compat_glRectd(void *_glfuncs, GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); +void gl4_1compat_glRasterPos4sv(void *_glfuncs, const GLshort* v); +void gl4_1compat_glRasterPos4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w); +void gl4_1compat_glRasterPos4iv(void *_glfuncs, const GLint* v); +void gl4_1compat_glRasterPos4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w); +void gl4_1compat_glRasterPos4fv(void *_glfuncs, const GLfloat* v); +void gl4_1compat_glRasterPos4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl4_1compat_glRasterPos4dv(void *_glfuncs, const GLdouble* v); +void gl4_1compat_glRasterPos4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl4_1compat_glRasterPos3sv(void *_glfuncs, const GLshort* v); +void gl4_1compat_glRasterPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl4_1compat_glRasterPos3iv(void *_glfuncs, const GLint* v); +void gl4_1compat_glRasterPos3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl4_1compat_glRasterPos3fv(void *_glfuncs, const GLfloat* v); +void gl4_1compat_glRasterPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl4_1compat_glRasterPos3dv(void *_glfuncs, const GLdouble* v); +void gl4_1compat_glRasterPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl4_1compat_glRasterPos2sv(void *_glfuncs, const GLshort* v); +void gl4_1compat_glRasterPos2s(void *_glfuncs, GLshort x, GLshort y); +void gl4_1compat_glRasterPos2iv(void *_glfuncs, const GLint* v); +void gl4_1compat_glRasterPos2i(void *_glfuncs, GLint x, GLint y); +void gl4_1compat_glRasterPos2fv(void *_glfuncs, const GLfloat* v); +void gl4_1compat_glRasterPos2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl4_1compat_glRasterPos2dv(void *_glfuncs, const GLdouble* v); +void gl4_1compat_glRasterPos2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl4_1compat_glNormal3sv(void *_glfuncs, const GLshort* v); +void gl4_1compat_glNormal3s(void *_glfuncs, GLshort nx, GLshort ny, GLshort nz); +void gl4_1compat_glNormal3iv(void *_glfuncs, const GLint* v); +void gl4_1compat_glNormal3i(void *_glfuncs, GLint nx, GLint ny, GLint nz); +void gl4_1compat_glNormal3fv(void *_glfuncs, const GLfloat* v); +void gl4_1compat_glNormal3f(void *_glfuncs, GLfloat nx, GLfloat ny, GLfloat nz); +void gl4_1compat_glNormal3dv(void *_glfuncs, const GLdouble* v); +void gl4_1compat_glNormal3d(void *_glfuncs, GLdouble nx, GLdouble ny, GLdouble nz); +void gl4_1compat_glNormal3bv(void *_glfuncs, const GLbyte* v); +void gl4_1compat_glNormal3b(void *_glfuncs, GLbyte nx, GLbyte ny, GLbyte nz); +void gl4_1compat_glIndexsv(void *_glfuncs, const GLshort* c); +void gl4_1compat_glIndexs(void *_glfuncs, GLshort c); +void gl4_1compat_glIndexiv(void *_glfuncs, const GLint* c); +void gl4_1compat_glIndexi(void *_glfuncs, GLint c); +void gl4_1compat_glIndexfv(void *_glfuncs, const GLfloat* c); +void gl4_1compat_glIndexf(void *_glfuncs, GLfloat c); +void gl4_1compat_glIndexdv(void *_glfuncs, const GLdouble* c); +void gl4_1compat_glIndexd(void *_glfuncs, GLdouble c); +void gl4_1compat_glEnd(void *_glfuncs); +void gl4_1compat_glEdgeFlagv(void *_glfuncs, const GLboolean* flag); +void gl4_1compat_glEdgeFlag(void *_glfuncs, GLboolean flag); +void gl4_1compat_glColor4usv(void *_glfuncs, const GLushort* v); +void gl4_1compat_glColor4us(void *_glfuncs, GLushort red, GLushort green, GLushort blue, GLushort alpha); +void gl4_1compat_glColor4uiv(void *_glfuncs, const GLuint* v); +void gl4_1compat_glColor4ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue, GLuint alpha); +void gl4_1compat_glColor4ubv(void *_glfuncs, const GLubyte* v); +void gl4_1compat_glColor4ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); +void gl4_1compat_glColor4sv(void *_glfuncs, const GLshort* v); +void gl4_1compat_glColor4s(void *_glfuncs, GLshort red, GLshort green, GLshort blue, GLshort alpha); +void gl4_1compat_glColor4iv(void *_glfuncs, const GLint* v); +void gl4_1compat_glColor4i(void *_glfuncs, GLint red, GLint green, GLint blue, GLint alpha); +void gl4_1compat_glColor4fv(void *_glfuncs, const GLfloat* v); +void gl4_1compat_glColor4f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl4_1compat_glColor4dv(void *_glfuncs, const GLdouble* v); +void gl4_1compat_glColor4d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); +void gl4_1compat_glColor4bv(void *_glfuncs, const GLbyte* v); +void gl4_1compat_glColor4b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); +void gl4_1compat_glColor3usv(void *_glfuncs, const GLushort* v); +void gl4_1compat_glColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue); +void gl4_1compat_glColor3uiv(void *_glfuncs, const GLuint* v); +void gl4_1compat_glColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue); +void gl4_1compat_glColor3ubv(void *_glfuncs, const GLubyte* v); +void gl4_1compat_glColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue); +void gl4_1compat_glColor3sv(void *_glfuncs, const GLshort* v); +void gl4_1compat_glColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue); +void gl4_1compat_glColor3iv(void *_glfuncs, const GLint* v); +void gl4_1compat_glColor3i(void *_glfuncs, GLint red, GLint green, GLint blue); +void gl4_1compat_glColor3fv(void *_glfuncs, const GLfloat* v); +void gl4_1compat_glColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue); +void gl4_1compat_glColor3dv(void *_glfuncs, const GLdouble* v); +void gl4_1compat_glColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue); +void gl4_1compat_glColor3bv(void *_glfuncs, const GLbyte* v); +void gl4_1compat_glColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue); +void gl4_1compat_glBitmap(void *_glfuncs, GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap); +void gl4_1compat_glBegin(void *_glfuncs, GLenum mode); +void gl4_1compat_glListBase(void *_glfuncs, GLuint base); +GLuint gl4_1compat_glGenLists(void *_glfuncs, GLsizei range_); +void gl4_1compat_glDeleteLists(void *_glfuncs, GLuint list, GLsizei range_); +void gl4_1compat_glCallLists(void *_glfuncs, GLsizei n, GLenum gltype, const GLvoid* lists); +void gl4_1compat_glCallList(void *_glfuncs, GLuint list); +void gl4_1compat_glEndList(void *_glfuncs); +void gl4_1compat_glNewList(void *_glfuncs, GLuint list, GLenum mode); +void gl4_1compat_glPushClientAttrib(void *_glfuncs, GLbitfield mask); +void gl4_1compat_glPopClientAttrib(void *_glfuncs); +void gl4_1compat_glPrioritizeTextures(void *_glfuncs, GLsizei n, const GLuint* textures, const GLfloat* priorities); +GLboolean gl4_1compat_glAreTexturesResident(void *_glfuncs, GLsizei n, const GLuint* textures, GLboolean* residences); +void gl4_1compat_glVertexPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_1compat_glTexCoordPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_1compat_glNormalPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_1compat_glInterleavedArrays(void *_glfuncs, GLenum format, GLsizei stride, const GLvoid* pointer); +void gl4_1compat_glIndexPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_1compat_glEnableClientState(void *_glfuncs, GLenum array); +void gl4_1compat_glEdgeFlagPointer(void *_glfuncs, GLsizei stride, const GLvoid* pointer); +void gl4_1compat_glDisableClientState(void *_glfuncs, GLenum array); +void gl4_1compat_glColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_1compat_glArrayElement(void *_glfuncs, GLint i); +void gl4_1compat_glResetMinmax(void *_glfuncs, GLenum target); +void gl4_1compat_glResetHistogram(void *_glfuncs, GLenum target); +void gl4_1compat_glMinmax(void *_glfuncs, GLenum target, GLenum internalFormat, GLboolean sink); +void gl4_1compat_glHistogram(void *_glfuncs, GLenum target, GLsizei width, GLenum internalFormat, GLboolean sink); +void gl4_1compat_glGetMinmaxParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_1compat_glGetMinmaxParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl4_1compat_glGetMinmax(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values); +void gl4_1compat_glGetHistogramParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_1compat_glGetHistogramParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl4_1compat_glGetHistogram(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values); +void gl4_1compat_glSeparableFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* row, const GLvoid* column); +void gl4_1compat_glGetSeparableFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* row, GLvoid* column, GLvoid* span); +void gl4_1compat_glGetConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_1compat_glGetConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl4_1compat_glGetConvolutionFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* image); +void gl4_1compat_glCopyConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_1compat_glCopyConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width); +void gl4_1compat_glConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl4_1compat_glConvolutionParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint params); +void gl4_1compat_glConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl4_1compat_glConvolutionParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat params); +void gl4_1compat_glConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* image); +void gl4_1compat_glConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* image); +void gl4_1compat_glCopyColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); +void gl4_1compat_glColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum gltype, const GLvoid* data); +void gl4_1compat_glGetColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_1compat_glGetColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl4_1compat_glGetColorTable(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* table); +void gl4_1compat_glCopyColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width); +void gl4_1compat_glColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl4_1compat_glColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl4_1compat_glColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* table); +void gl4_1compat_glMultTransposeMatrixd(void *_glfuncs, const GLdouble* m); +void gl4_1compat_glMultTransposeMatrixf(void *_glfuncs, const GLfloat* m); +void gl4_1compat_glLoadTransposeMatrixd(void *_glfuncs, const GLdouble* m); +void gl4_1compat_glLoadTransposeMatrixf(void *_glfuncs, const GLfloat* m); +void gl4_1compat_glMultiTexCoord4sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl4_1compat_glMultiTexCoord4s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); +void gl4_1compat_glMultiTexCoord4iv(void *_glfuncs, GLenum target, const GLint* v); +void gl4_1compat_glMultiTexCoord4i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r, GLint q); +void gl4_1compat_glMultiTexCoord4fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl4_1compat_glMultiTexCoord4f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +void gl4_1compat_glMultiTexCoord4dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl4_1compat_glMultiTexCoord4d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +void gl4_1compat_glMultiTexCoord3sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl4_1compat_glMultiTexCoord3s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r); +void gl4_1compat_glMultiTexCoord3iv(void *_glfuncs, GLenum target, const GLint* v); +void gl4_1compat_glMultiTexCoord3i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r); +void gl4_1compat_glMultiTexCoord3fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl4_1compat_glMultiTexCoord3f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r); +void gl4_1compat_glMultiTexCoord3dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl4_1compat_glMultiTexCoord3d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r); +void gl4_1compat_glMultiTexCoord2sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl4_1compat_glMultiTexCoord2s(void *_glfuncs, GLenum target, GLshort s, GLshort t); +void gl4_1compat_glMultiTexCoord2iv(void *_glfuncs, GLenum target, const GLint* v); +void gl4_1compat_glMultiTexCoord2i(void *_glfuncs, GLenum target, GLint s, GLint t); +void gl4_1compat_glMultiTexCoord2fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl4_1compat_glMultiTexCoord2f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t); +void gl4_1compat_glMultiTexCoord2dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl4_1compat_glMultiTexCoord2d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t); +void gl4_1compat_glMultiTexCoord1sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl4_1compat_glMultiTexCoord1s(void *_glfuncs, GLenum target, GLshort s); +void gl4_1compat_glMultiTexCoord1iv(void *_glfuncs, GLenum target, const GLint* v); +void gl4_1compat_glMultiTexCoord1i(void *_glfuncs, GLenum target, GLint s); +void gl4_1compat_glMultiTexCoord1fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl4_1compat_glMultiTexCoord1f(void *_glfuncs, GLenum target, GLfloat s); +void gl4_1compat_glMultiTexCoord1dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl4_1compat_glMultiTexCoord1d(void *_glfuncs, GLenum target, GLdouble s); +void gl4_1compat_glClientActiveTexture(void *_glfuncs, GLenum texture); +void gl4_1compat_glWindowPos3sv(void *_glfuncs, const GLshort* v); +void gl4_1compat_glWindowPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl4_1compat_glWindowPos3iv(void *_glfuncs, const GLint* v); +void gl4_1compat_glWindowPos3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl4_1compat_glWindowPos3fv(void *_glfuncs, const GLfloat* v); +void gl4_1compat_glWindowPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl4_1compat_glWindowPos3dv(void *_glfuncs, const GLdouble* v); +void gl4_1compat_glWindowPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl4_1compat_glWindowPos2sv(void *_glfuncs, const GLshort* v); +void gl4_1compat_glWindowPos2s(void *_glfuncs, GLshort x, GLshort y); +void gl4_1compat_glWindowPos2iv(void *_glfuncs, const GLint* v); +void gl4_1compat_glWindowPos2i(void *_glfuncs, GLint x, GLint y); +void gl4_1compat_glWindowPos2fv(void *_glfuncs, const GLfloat* v); +void gl4_1compat_glWindowPos2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl4_1compat_glWindowPos2dv(void *_glfuncs, const GLdouble* v); +void gl4_1compat_glWindowPos2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl4_1compat_glSecondaryColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_1compat_glSecondaryColor3usv(void *_glfuncs, const GLushort* v); +void gl4_1compat_glSecondaryColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue); +void gl4_1compat_glSecondaryColor3uiv(void *_glfuncs, const GLuint* v); +void gl4_1compat_glSecondaryColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue); +void gl4_1compat_glSecondaryColor3ubv(void *_glfuncs, const GLubyte* v); +void gl4_1compat_glSecondaryColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue); +void gl4_1compat_glSecondaryColor3sv(void *_glfuncs, const GLshort* v); +void gl4_1compat_glSecondaryColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue); +void gl4_1compat_glSecondaryColor3iv(void *_glfuncs, const GLint* v); +void gl4_1compat_glSecondaryColor3i(void *_glfuncs, GLint red, GLint green, GLint blue); +void gl4_1compat_glSecondaryColor3fv(void *_glfuncs, const GLfloat* v); +void gl4_1compat_glSecondaryColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue); +void gl4_1compat_glSecondaryColor3dv(void *_glfuncs, const GLdouble* v); +void gl4_1compat_glSecondaryColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue); +void gl4_1compat_glSecondaryColor3bv(void *_glfuncs, const GLbyte* v); +void gl4_1compat_glSecondaryColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue); +void gl4_1compat_glFogCoordPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_1compat_glFogCoorddv(void *_glfuncs, const GLdouble* coord); +void gl4_1compat_glFogCoordd(void *_glfuncs, GLdouble coord); +void gl4_1compat_glFogCoordfv(void *_glfuncs, const GLfloat* coord); +void gl4_1compat_glFogCoordf(void *_glfuncs, GLfloat coord); +void gl4_1compat_glVertexAttrib4usv(void *_glfuncs, GLuint index, const GLushort* v); +void gl4_1compat_glVertexAttrib4uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl4_1compat_glVertexAttrib4ubv(void *_glfuncs, GLuint index, const GLubyte* v); +void gl4_1compat_glVertexAttrib4sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl4_1compat_glVertexAttrib4s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +void gl4_1compat_glVertexAttrib4iv(void *_glfuncs, GLuint index, const GLint* v); +void gl4_1compat_glVertexAttrib4fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl4_1compat_glVertexAttrib4f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl4_1compat_glVertexAttrib4dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_1compat_glVertexAttrib4d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl4_1compat_glVertexAttrib4bv(void *_glfuncs, GLuint index, const GLbyte* v); +void gl4_1compat_glVertexAttrib4Nusv(void *_glfuncs, GLuint index, const GLushort* v); +void gl4_1compat_glVertexAttrib4Nuiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl4_1compat_glVertexAttrib4Nubv(void *_glfuncs, GLuint index, const GLubyte* v); +void gl4_1compat_glVertexAttrib4Nub(void *_glfuncs, GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +void gl4_1compat_glVertexAttrib4Nsv(void *_glfuncs, GLuint index, const GLshort* v); +void gl4_1compat_glVertexAttrib4Niv(void *_glfuncs, GLuint index, const GLint* v); +void gl4_1compat_glVertexAttrib4Nbv(void *_glfuncs, GLuint index, const GLbyte* v); +void gl4_1compat_glVertexAttrib3sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl4_1compat_glVertexAttrib3s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z); +void gl4_1compat_glVertexAttrib3fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl4_1compat_glVertexAttrib3f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z); +void gl4_1compat_glVertexAttrib3dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_1compat_glVertexAttrib3d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z); +void gl4_1compat_glVertexAttrib2sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl4_1compat_glVertexAttrib2s(void *_glfuncs, GLuint index, GLshort x, GLshort y); +void gl4_1compat_glVertexAttrib2fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl4_1compat_glVertexAttrib2f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y); +void gl4_1compat_glVertexAttrib2dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_1compat_glVertexAttrib2d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y); +void gl4_1compat_glVertexAttrib1sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl4_1compat_glVertexAttrib1s(void *_glfuncs, GLuint index, GLshort x); +void gl4_1compat_glVertexAttrib1fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl4_1compat_glVertexAttrib1f(void *_glfuncs, GLuint index, GLfloat x); +void gl4_1compat_glVertexAttrib1dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_1compat_glVertexAttrib1d(void *_glfuncs, GLuint index, GLdouble x); +void gl4_1compat_glVertexAttribI4usv(void *_glfuncs, GLuint index, const GLushort* v); +void gl4_1compat_glVertexAttribI4ubv(void *_glfuncs, GLuint index, const GLubyte* v); +void gl4_1compat_glVertexAttribI4sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl4_1compat_glVertexAttribI4bv(void *_glfuncs, GLuint index, const GLbyte* v); +void gl4_1compat_glVertexAttribI4uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl4_1compat_glVertexAttribI3uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl4_1compat_glVertexAttribI2uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl4_1compat_glVertexAttribI1uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl4_1compat_glVertexAttribI4iv(void *_glfuncs, GLuint index, const GLint* v); +void gl4_1compat_glVertexAttribI3iv(void *_glfuncs, GLuint index, const GLint* v); +void gl4_1compat_glVertexAttribI2iv(void *_glfuncs, GLuint index, const GLint* v); +void gl4_1compat_glVertexAttribI1iv(void *_glfuncs, GLuint index, const GLint* v); +void gl4_1compat_glVertexAttribI4ui(void *_glfuncs, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +void gl4_1compat_glVertexAttribI3ui(void *_glfuncs, GLuint index, GLuint x, GLuint y, GLuint z); +void gl4_1compat_glVertexAttribI2ui(void *_glfuncs, GLuint index, GLuint x, GLuint y); +void gl4_1compat_glVertexAttribI1ui(void *_glfuncs, GLuint index, GLuint x); +void gl4_1compat_glVertexAttribI4i(void *_glfuncs, GLuint index, GLint x, GLint y, GLint z, GLint w); +void gl4_1compat_glVertexAttribI3i(void *_glfuncs, GLuint index, GLint x, GLint y, GLint z); +void gl4_1compat_glVertexAttribI2i(void *_glfuncs, GLuint index, GLint x, GLint y); +void gl4_1compat_glVertexAttribI1i(void *_glfuncs, GLuint index, GLint x); + + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/gl/4.1compat/gl.go b/gl/4.1compat/gl.go new file mode 100644 index 00000000..3d437020 --- /dev/null +++ b/gl/4.1compat/gl.go @@ -0,0 +1,9201 @@ +// ** file automatically generated by glgen -- do not edit manually ** + +package GL + +// #cgo CXXFLAGS: -std=c++0x -pedantic-errors -Wall -fno-strict-aliasing +// #cgo LDFLAGS: -lstdc++ +// #cgo pkg-config: Qt5Core Qt5OpenGL +// +// #include "funcs.h" +// +// void free(void*); +// +import "C" + +import ( + "fmt" + "reflect" + "unsafe" + + "gopkg.in/qml.v1/gl/glbase" +) + +// API returns a value that offers methods matching the OpenGL version 4.1 API. +// +// The returned API must not be used after the provided OpenGL context becomes invalid. +func API(context glbase.Contexter) *GL { + gl := &GL{} + gl.funcs = C.gl4_1compat_funcs() + if gl.funcs == nil { + panic(fmt.Errorf("OpenGL version 4.1 is not available")) + } + return gl +} + +// GL implements the OpenGL version 4.1 API. Values of this +// type must be created via the API function, and it must not be used after +// the associated OpenGL context becomes invalid. +type GL struct { + funcs unsafe.Pointer +} + +const ( + FALSE = 0 + TRUE = 1 + NONE = 0 + + BYTE = 0x1400 + UNSIGNED_BYTE = 0x1401 + SHORT = 0x1402 + UNSIGNED_SHORT = 0x1403 + INT = 0x1404 + UNSIGNED_INT = 0x1405 + FLOAT = 0x1406 + N2_BYTES = 0x1407 + N3_BYTES = 0x1408 + N4_BYTES = 0x1409 + DOUBLE = 0x140A + HALF_FLOAT = 0x140B + FIXED = 0x140C + + ACCUM = 0x0100 + LOAD = 0x0101 + RETURN = 0x0102 + MULT = 0x0103 + ADD = 0x0104 + + ACCUM_BUFFER_BIT = 0x00000200 + ALL_ATTRIB_BITS = 0xFFFFFFFF + COLOR_BUFFER_BIT = 0x00004000 + CURRENT_BIT = 0x00000001 + DEPTH_BUFFER_BIT = 0x00000100 + ENABLE_BIT = 0x00002000 + EVAL_BIT = 0x00010000 + FOG_BIT = 0x00000080 + HINT_BIT = 0x00008000 + LIGHTING_BIT = 0x00000040 + LINE_BIT = 0x00000004 + LIST_BIT = 0x00020000 + MULTISAMPLE_BIT = 0x20000000 + PIXEL_MODE_BIT = 0x00000020 + POINT_BIT = 0x00000002 + POLYGON_BIT = 0x00000008 + POLYGON_STIPPLE_BIT = 0x00000010 + SCISSOR_BIT = 0x00080000 + STENCIL_BUFFER_BIT = 0x00000400 + TEXTURE_BIT = 0x00040000 + TRANSFORM_BIT = 0x00001000 + VIEWPORT_BIT = 0x00000800 + + ALWAYS = 0x0207 + EQUAL = 0x0202 + GEQUAL = 0x0206 + GREATER = 0x0204 + LEQUAL = 0x0203 + LESS = 0x0201 + NEVER = 0x0200 + NOTEQUAL = 0x0205 + + LOGIC_OP = 0x0BF1 + + DST_ALPHA = 0x0304 + ONE = 1 + ONE_MINUS_DST_ALPHA = 0x0305 + ONE_MINUS_SRC_ALPHA = 0x0303 + ONE_MINUS_SRC_COLOR = 0x0301 + SRC_ALPHA = 0x0302 + SRC_COLOR = 0x0300 + ZERO = 0 + + DST_COLOR = 0x0306 + ONE_MINUS_DST_COLOR = 0x0307 + SRC_ALPHA_SATURATE = 0x0308 + + CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF + CLIENT_PIXEL_STORE_BIT = 0x00000001 + CLIENT_VERTEX_ARRAY_BIT = 0x00000002 + + CLIP_DISTANCE0 = 0x3000 + CLIP_DISTANCE1 = 0x3001 + CLIP_DISTANCE2 = 0x3002 + CLIP_DISTANCE3 = 0x3003 + CLIP_DISTANCE4 = 0x3004 + CLIP_DISTANCE5 = 0x3005 + CLIP_DISTANCE6 = 0x3006 + CLIP_DISTANCE7 = 0x3007 + CLIP_PLANE0 = 0x3000 + CLIP_PLANE1 = 0x3001 + CLIP_PLANE2 = 0x3002 + CLIP_PLANE3 = 0x3003 + CLIP_PLANE4 = 0x3004 + CLIP_PLANE5 = 0x3005 + + BACK = 0x0405 + FRONT = 0x0404 + FRONT_AND_BACK = 0x0408 + + AMBIENT = 0x1200 + AMBIENT_AND_DIFFUSE = 0x1602 + DIFFUSE = 0x1201 + EMISSION = 0x1600 + SPECULAR = 0x1202 + + CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x00000001 + + CONTEXT_COMPATIBILITY_PROFILE_BIT = 0x00000002 + CONTEXT_CORE_PROFILE_BIT = 0x00000001 + + AUX0 = 0x0409 + AUX1 = 0x040A + AUX2 = 0x040B + AUX3 = 0x040C + BACK_LEFT = 0x0402 + BACK_RIGHT = 0x0403 + FRONT_LEFT = 0x0400 + FRONT_RIGHT = 0x0401 + LEFT = 0x0406 + RIGHT = 0x0407 + + ALPHA_TEST = 0x0BC0 + AUTO_NORMAL = 0x0D80 + BLEND = 0x0BE2 + COLOR_ARRAY = 0x8076 + COLOR_LOGIC_OP = 0x0BF2 + COLOR_MATERIAL = 0x0B57 + CULL_FACE = 0x0B44 + DEPTH_TEST = 0x0B71 + DITHER = 0x0BD0 + EDGE_FLAG_ARRAY = 0x8079 + FOG = 0x0B60 + INDEX_ARRAY = 0x8077 + INDEX_LOGIC_OP = 0x0BF1 + LIGHT0 = 0x4000 + LIGHT1 = 0x4001 + LIGHT2 = 0x4002 + LIGHT3 = 0x4003 + LIGHT4 = 0x4004 + LIGHT5 = 0x4005 + LIGHT6 = 0x4006 + LIGHT7 = 0x4007 + LIGHTING = 0x0B50 + LINE_SMOOTH = 0x0B20 + LINE_STIPPLE = 0x0B24 + MAP1_COLOR_4 = 0x0D90 + MAP1_INDEX = 0x0D91 + MAP1_NORMAL = 0x0D92 + MAP1_TEXTURE_COORD_1 = 0x0D93 + MAP1_TEXTURE_COORD_2 = 0x0D94 + MAP1_TEXTURE_COORD_3 = 0x0D95 + MAP1_TEXTURE_COORD_4 = 0x0D96 + MAP1_VERTEX_3 = 0x0D97 + MAP1_VERTEX_4 = 0x0D98 + MAP2_COLOR_4 = 0x0DB0 + MAP2_INDEX = 0x0DB1 + MAP2_NORMAL = 0x0DB2 + MAP2_TEXTURE_COORD_1 = 0x0DB3 + MAP2_TEXTURE_COORD_2 = 0x0DB4 + MAP2_TEXTURE_COORD_3 = 0x0DB5 + MAP2_TEXTURE_COORD_4 = 0x0DB6 + MAP2_VERTEX_3 = 0x0DB7 + MAP2_VERTEX_4 = 0x0DB8 + NORMALIZE = 0x0BA1 + NORMAL_ARRAY = 0x8075 + POINT_SMOOTH = 0x0B10 + POLYGON_OFFSET_FILL = 0x8037 + POLYGON_OFFSET_LINE = 0x2A02 + POLYGON_OFFSET_POINT = 0x2A01 + POLYGON_SMOOTH = 0x0B41 + POLYGON_STIPPLE = 0x0B42 + SCISSOR_TEST = 0x0C11 + STENCIL_TEST = 0x0B90 + TEXTURE_1D = 0x0DE0 + TEXTURE_2D = 0x0DE1 + TEXTURE_COORD_ARRAY = 0x8078 + TEXTURE_GEN_Q = 0x0C63 + TEXTURE_GEN_R = 0x0C62 + TEXTURE_GEN_S = 0x0C60 + TEXTURE_GEN_T = 0x0C61 + VERTEX_ARRAY = 0x8074 + + INVALID_ENUM = 0x0500 + INVALID_FRAMEBUFFER_OPERATION = 0x0506 + INVALID_OPERATION = 0x0502 + INVALID_VALUE = 0x0501 + NO_ERROR = 0 + OUT_OF_MEMORY = 0x0505 + STACK_OVERFLOW = 0x0503 + STACK_UNDERFLOW = 0x0504 + + N2D = 0x0600 + N3D = 0x0601 + N3D_COLOR = 0x0602 + N3D_COLOR_TEXTURE = 0x0603 + N4D_COLOR_TEXTURE = 0x0604 + + BITMAP_TOKEN = 0x0704 + COPY_PIXEL_TOKEN = 0x0706 + DRAW_PIXEL_TOKEN = 0x0705 + LINE_RESET_TOKEN = 0x0707 + LINE_TOKEN = 0x0702 + PASS_THROUGH_TOKEN = 0x0700 + POINT_TOKEN = 0x0701 + POLYGON_TOKEN = 0x0703 + + EXP = 0x0800 + EXP2 = 0x0801 + LINEAR = 0x2601 + + FOG_COLOR = 0x0B66 + FOG_DENSITY = 0x0B62 + FOG_END = 0x0B64 + FOG_INDEX = 0x0B61 + FOG_MODE = 0x0B65 + FOG_START = 0x0B63 + + CCW = 0x0901 + CW = 0x0900 + + COEFF = 0x0A00 + DOMAIN = 0x0A02 + ORDER = 0x0A01 + + PIXEL_MAP_A_TO_A = 0x0C79 + PIXEL_MAP_B_TO_B = 0x0C78 + PIXEL_MAP_G_TO_G = 0x0C77 + PIXEL_MAP_I_TO_A = 0x0C75 + PIXEL_MAP_I_TO_B = 0x0C74 + PIXEL_MAP_I_TO_G = 0x0C73 + PIXEL_MAP_I_TO_I = 0x0C70 + PIXEL_MAP_I_TO_R = 0x0C72 + PIXEL_MAP_R_TO_R = 0x0C76 + PIXEL_MAP_S_TO_S = 0x0C71 + + ACCUM_ALPHA_BITS = 0x0D5B + ACCUM_BLUE_BITS = 0x0D5A + ACCUM_CLEAR_VALUE = 0x0B80 + ACCUM_GREEN_BITS = 0x0D59 + ACCUM_RED_BITS = 0x0D58 + ALIASED_LINE_WIDTH_RANGE = 0x846E + ALIASED_POINT_SIZE_RANGE = 0x846D + ALPHA_BIAS = 0x0D1D + ALPHA_BITS = 0x0D55 + ALPHA_SCALE = 0x0D1C + ALPHA_TEST_FUNC = 0x0BC1 + ALPHA_TEST_REF = 0x0BC2 + ATTRIB_STACK_DEPTH = 0x0BB0 + AUX_BUFFERS = 0x0C00 + BLEND_DST = 0x0BE0 + BLEND_SRC = 0x0BE1 + BLUE_BIAS = 0x0D1B + BLUE_BITS = 0x0D54 + BLUE_SCALE = 0x0D1A + CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1 + COLOR_ARRAY_SIZE = 0x8081 + COLOR_ARRAY_STRIDE = 0x8083 + COLOR_ARRAY_TYPE = 0x8082 + COLOR_CLEAR_VALUE = 0x0C22 + COLOR_MATERIAL_FACE = 0x0B55 + COLOR_MATERIAL_PARAMETER = 0x0B56 + COLOR_WRITEMASK = 0x0C23 + CULL_FACE_MODE = 0x0B45 + CURRENT_COLOR = 0x0B00 + CURRENT_INDEX = 0x0B01 + CURRENT_NORMAL = 0x0B02 + CURRENT_RASTER_COLOR = 0x0B04 + CURRENT_RASTER_DISTANCE = 0x0B09 + CURRENT_RASTER_INDEX = 0x0B05 + CURRENT_RASTER_POSITION = 0x0B07 + CURRENT_RASTER_POSITION_VALID = 0x0B08 + CURRENT_RASTER_TEXTURE_COORDS = 0x0B06 + CURRENT_TEXTURE_COORDS = 0x0B03 + DEPTH_BIAS = 0x0D1F + DEPTH_BITS = 0x0D56 + DEPTH_CLEAR_VALUE = 0x0B73 + DEPTH_FUNC = 0x0B74 + DEPTH_RANGE = 0x0B70 + DEPTH_SCALE = 0x0D1E + DEPTH_WRITEMASK = 0x0B72 + DOUBLEBUFFER = 0x0C32 + DRAW_BUFFER = 0x0C01 + EDGE_FLAG = 0x0B43 + EDGE_FLAG_ARRAY_STRIDE = 0x808C + FEEDBACK_BUFFER_SIZE = 0x0DF1 + FEEDBACK_BUFFER_TYPE = 0x0DF2 + FOG_HINT = 0x0C54 + FRONT_FACE = 0x0B46 + GREEN_BIAS = 0x0D19 + GREEN_BITS = 0x0D53 + GREEN_SCALE = 0x0D18 + INDEX_ARRAY_STRIDE = 0x8086 + INDEX_ARRAY_TYPE = 0x8085 + INDEX_BITS = 0x0D51 + INDEX_CLEAR_VALUE = 0x0C20 + INDEX_MODE = 0x0C30 + INDEX_OFFSET = 0x0D13 + INDEX_SHIFT = 0x0D12 + INDEX_WRITEMASK = 0x0C21 + LIGHT_MODEL_AMBIENT = 0x0B53 + LIGHT_MODEL_COLOR_CONTROL = 0x81F8 + LIGHT_MODEL_LOCAL_VIEWER = 0x0B51 + LIGHT_MODEL_TWO_SIDE = 0x0B52 + LINE_SMOOTH_HINT = 0x0C52 + LINE_STIPPLE_PATTERN = 0x0B25 + LINE_STIPPLE_REPEAT = 0x0B26 + LINE_WIDTH = 0x0B21 + LINE_WIDTH_GRANULARITY = 0x0B23 + LINE_WIDTH_RANGE = 0x0B22 + LIST_BASE = 0x0B32 + LIST_INDEX = 0x0B33 + LIST_MODE = 0x0B30 + LOGIC_OP_MODE = 0x0BF0 + MAP1_GRID_DOMAIN = 0x0DD0 + MAP1_GRID_SEGMENTS = 0x0DD1 + MAP2_GRID_DOMAIN = 0x0DD2 + MAP2_GRID_SEGMENTS = 0x0DD3 + MAP_COLOR = 0x0D10 + MAP_STENCIL = 0x0D11 + MATRIX_MODE = 0x0BA0 + MAX_ATTRIB_STACK_DEPTH = 0x0D35 + MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B + MAX_CLIP_DISTANCES = 0x0D32 + MAX_CLIP_PLANES = 0x0D32 + MAX_EVAL_ORDER = 0x0D30 + MAX_LIGHTS = 0x0D31 + MAX_LIST_NESTING = 0x0B31 + MAX_MODELVIEW_STACK_DEPTH = 0x0D36 + MAX_NAME_STACK_DEPTH = 0x0D37 + MAX_PIXEL_MAP_TABLE = 0x0D34 + MAX_PROJECTION_STACK_DEPTH = 0x0D38 + MAX_TEXTURE_SIZE = 0x0D33 + MAX_TEXTURE_STACK_DEPTH = 0x0D39 + MAX_VIEWPORT_DIMS = 0x0D3A + MODELVIEW_MATRIX = 0x0BA6 + MODELVIEW_STACK_DEPTH = 0x0BA3 + NAME_STACK_DEPTH = 0x0D70 + NORMAL_ARRAY_STRIDE = 0x807F + NORMAL_ARRAY_TYPE = 0x807E + PACK_ALIGNMENT = 0x0D05 + PACK_LSB_FIRST = 0x0D01 + PACK_ROW_LENGTH = 0x0D02 + PACK_SKIP_PIXELS = 0x0D04 + PACK_SKIP_ROWS = 0x0D03 + PACK_SWAP_BYTES = 0x0D00 + PERSPECTIVE_CORRECTION_HINT = 0x0C50 + PIXEL_MAP_A_TO_A_SIZE = 0x0CB9 + PIXEL_MAP_B_TO_B_SIZE = 0x0CB8 + PIXEL_MAP_G_TO_G_SIZE = 0x0CB7 + PIXEL_MAP_I_TO_A_SIZE = 0x0CB5 + PIXEL_MAP_I_TO_B_SIZE = 0x0CB4 + PIXEL_MAP_I_TO_G_SIZE = 0x0CB3 + PIXEL_MAP_I_TO_I_SIZE = 0x0CB0 + PIXEL_MAP_I_TO_R_SIZE = 0x0CB2 + PIXEL_MAP_R_TO_R_SIZE = 0x0CB6 + PIXEL_MAP_S_TO_S_SIZE = 0x0CB1 + POINT_SIZE = 0x0B11 + POINT_SIZE_GRANULARITY = 0x0B13 + POINT_SIZE_RANGE = 0x0B12 + POINT_SMOOTH_HINT = 0x0C51 + POLYGON_MODE = 0x0B40 + POLYGON_OFFSET_FACTOR = 0x8038 + POLYGON_OFFSET_UNITS = 0x2A00 + POLYGON_SMOOTH_HINT = 0x0C53 + PROJECTION_MATRIX = 0x0BA7 + PROJECTION_STACK_DEPTH = 0x0BA4 + READ_BUFFER = 0x0C02 + RED_BIAS = 0x0D15 + RED_BITS = 0x0D52 + RED_SCALE = 0x0D14 + RENDER_MODE = 0x0C40 + RGBA_MODE = 0x0C31 + SCISSOR_BOX = 0x0C10 + SELECTION_BUFFER_SIZE = 0x0DF4 + SHADE_MODEL = 0x0B54 + SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23 + SMOOTH_LINE_WIDTH_RANGE = 0x0B22 + SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13 + SMOOTH_POINT_SIZE_RANGE = 0x0B12 + STENCIL_BITS = 0x0D57 + STENCIL_CLEAR_VALUE = 0x0B91 + STENCIL_FAIL = 0x0B94 + STENCIL_FUNC = 0x0B92 + STENCIL_PASS_DEPTH_FAIL = 0x0B95 + STENCIL_PASS_DEPTH_PASS = 0x0B96 + STENCIL_REF = 0x0B97 + STENCIL_VALUE_MASK = 0x0B93 + STENCIL_WRITEMASK = 0x0B98 + STEREO = 0x0C33 + SUBPIXEL_BITS = 0x0D50 + TEXTURE_BINDING_1D = 0x8068 + TEXTURE_BINDING_2D = 0x8069 + TEXTURE_BINDING_3D = 0x806A + TEXTURE_COORD_ARRAY_SIZE = 0x8088 + TEXTURE_COORD_ARRAY_STRIDE = 0x808A + TEXTURE_COORD_ARRAY_TYPE = 0x8089 + TEXTURE_MATRIX = 0x0BA8 + TEXTURE_STACK_DEPTH = 0x0BA5 + UNPACK_ALIGNMENT = 0x0CF5 + UNPACK_LSB_FIRST = 0x0CF1 + UNPACK_ROW_LENGTH = 0x0CF2 + UNPACK_SKIP_PIXELS = 0x0CF4 + UNPACK_SKIP_ROWS = 0x0CF3 + UNPACK_SWAP_BYTES = 0x0CF0 + VERTEX_ARRAY_SIZE = 0x807A + VERTEX_ARRAY_STRIDE = 0x807C + VERTEX_ARRAY_TYPE = 0x807B + VIEWPORT = 0x0BA2 + ZOOM_X = 0x0D16 + ZOOM_Y = 0x0D17 + + COLOR_ARRAY_POINTER = 0x8090 + EDGE_FLAG_ARRAY_POINTER = 0x8093 + FEEDBACK_BUFFER_POINTER = 0x0DF0 + INDEX_ARRAY_POINTER = 0x8091 + NORMAL_ARRAY_POINTER = 0x808F + SELECTION_BUFFER_POINTER = 0x0DF3 + TEXTURE_COORD_ARRAY_POINTER = 0x8092 + VERTEX_ARRAY_POINTER = 0x808E + + TEXTURE_ALPHA_SIZE = 0x805F + TEXTURE_BLUE_SIZE = 0x805E + TEXTURE_BORDER = 0x1005 + TEXTURE_BORDER_COLOR = 0x1004 + TEXTURE_COMPONENTS = 0x1003 + TEXTURE_GREEN_SIZE = 0x805D + TEXTURE_HEIGHT = 0x1001 + TEXTURE_INTENSITY_SIZE = 0x8061 + TEXTURE_INTERNAL_FORMAT = 0x1003 + TEXTURE_LUMINANCE_SIZE = 0x8060 + TEXTURE_MAG_FILTER = 0x2800 + TEXTURE_MIN_FILTER = 0x2801 + TEXTURE_PRIORITY = 0x8066 + TEXTURE_RED_SIZE = 0x805C + TEXTURE_RESIDENT = 0x8067 + TEXTURE_WIDTH = 0x1000 + TEXTURE_WRAP_S = 0x2802 + TEXTURE_WRAP_T = 0x2803 + + DONT_CARE = 0x1100 + FASTEST = 0x1101 + NICEST = 0x1102 + + FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B + GENERATE_MIPMAP_HINT = 0x8192 + PROGRAM_BINARY_RETRIEVABLE_HINT = 0x8257 + TEXTURE_COMPRESSION_HINT = 0x84EF + + C3F_V3F = 0x2A24 + C4F_N3F_V3F = 0x2A26 + C4UB_V2F = 0x2A22 + C4UB_V3F = 0x2A23 + N3F_V3F = 0x2A25 + T2F_C3F_V3F = 0x2A2A + T2F_C4F_N3F_V3F = 0x2A2C + T2F_C4UB_V3F = 0x2A29 + T2F_N3F_V3F = 0x2A2B + T2F_V3F = 0x2A27 + T4F_C4F_N3F_V4F = 0x2A2D + T4F_V4F = 0x2A28 + V2F = 0x2A20 + V3F = 0x2A21 + + MODULATE = 0x2100 + REPLACE = 0x1E01 + + SEPARATE_SPECULAR_COLOR = 0x81FA + SINGLE_COLOR = 0x81F9 + + CONSTANT_ATTENUATION = 0x1207 + LINEAR_ATTENUATION = 0x1208 + POSITION = 0x1203 + QUADRATIC_ATTENUATION = 0x1209 + SPOT_CUTOFF = 0x1206 + SPOT_DIRECTION = 0x1204 + SPOT_EXPONENT = 0x1205 + + COMPILE = 0x1300 + COMPILE_AND_EXECUTE = 0x1301 + + AND = 0x1501 + AND_INVERTED = 0x1504 + AND_REVERSE = 0x1502 + CLEAR = 0x1500 + COPY = 0x1503 + COPY_INVERTED = 0x150C + EQUIV = 0x1509 + INVERT = 0x150A + NAND = 0x150E + NOOP = 0x1505 + NOR = 0x1508 + OR = 0x1507 + OR_INVERTED = 0x150D + OR_REVERSE = 0x150B + SET = 0x150F + XOR = 0x1506 + + MAP_FLUSH_EXPLICIT_BIT = 0x0010 + MAP_INVALIDATE_BUFFER_BIT = 0x0008 + MAP_INVALIDATE_RANGE_BIT = 0x0004 + MAP_READ_BIT = 0x0001 + MAP_UNSYNCHRONIZED_BIT = 0x0020 + MAP_WRITE_BIT = 0x0002 + + COLOR_INDEXES = 0x1603 + SHININESS = 0x1601 + + MODELVIEW = 0x1700 + PROJECTION = 0x1701 + TEXTURE = 0x1702 + + LINE = 0x1B01 + POINT = 0x1B00 + + FILL = 0x1B02 + + COLOR = 0x1800 + DEPTH = 0x1801 + STENCIL = 0x1802 + + ALPHA = 0x1906 + BLUE = 0x1905 + COLOR_INDEX = 0x1900 + DEPTH_COMPONENT = 0x1902 + GREEN = 0x1904 + LUMINANCE = 0x1909 + LUMINANCE_ALPHA = 0x190A + RED = 0x1903 + RGB = 0x1907 + RGBA = 0x1908 + STENCIL_INDEX = 0x1901 + + ALPHA12 = 0x803D + ALPHA16 = 0x803E + ALPHA4 = 0x803B + ALPHA8 = 0x803C + INTENSITY = 0x8049 + INTENSITY12 = 0x804C + INTENSITY16 = 0x804D + INTENSITY4 = 0x804A + INTENSITY8 = 0x804B + LUMINANCE12 = 0x8041 + LUMINANCE12_ALPHA12 = 0x8047 + LUMINANCE12_ALPHA4 = 0x8046 + LUMINANCE16 = 0x8042 + LUMINANCE16_ALPHA16 = 0x8048 + LUMINANCE4 = 0x803F + LUMINANCE4_ALPHA4 = 0x8043 + LUMINANCE6_ALPHA2 = 0x8044 + LUMINANCE8 = 0x8040 + LUMINANCE8_ALPHA8 = 0x8045 + R3_G3_B2 = 0x2A10 + RGB10 = 0x8052 + RGB10_A2 = 0x8059 + RGB12 = 0x8053 + RGB16 = 0x8054 + RGB4 = 0x804F + RGB5 = 0x8050 + RGB5_A1 = 0x8057 + RGB8 = 0x8051 + RGBA12 = 0x805A + RGBA16 = 0x805B + RGBA2 = 0x8055 + RGBA4 = 0x8056 + RGBA8 = 0x8058 + + PACK_IMAGE_HEIGHT = 0x806C + PACK_SKIP_IMAGES = 0x806B + UNPACK_IMAGE_HEIGHT = 0x806E + UNPACK_SKIP_IMAGES = 0x806D + + BITMAP = 0x1A00 + UNSIGNED_BYTE_3_3_2 = 0x8032 + UNSIGNED_INT_10_10_10_2 = 0x8036 + UNSIGNED_INT_8_8_8_8 = 0x8035 + UNSIGNED_SHORT_4_4_4_4 = 0x8033 + UNSIGNED_SHORT_5_5_5_1 = 0x8034 + + POINT_DISTANCE_ATTENUATION = 0x8129 + POINT_FADE_THRESHOLD_SIZE = 0x8128 + POINT_SIZE_MAX = 0x8127 + POINT_SIZE_MIN = 0x8126 + + LINES = 0x0001 + LINES_ADJACENCY = 0x000A + LINE_LOOP = 0x0002 + LINE_STRIP = 0x0003 + LINE_STRIP_ADJACENCY = 0x000B + PATCHES = 0x000E + POINTS = 0x0000 + POLYGON = 0x0009 + QUADS = 0x0007 + QUAD_STRIP = 0x0008 + TRIANGLES = 0x0004 + TRIANGLES_ADJACENCY = 0x000C + TRIANGLE_FAN = 0x0006 + TRIANGLE_STRIP = 0x0005 + TRIANGLE_STRIP_ADJACENCY = 0x000D + + FEEDBACK = 0x1C01 + RENDER = 0x1C00 + SELECT = 0x1C02 + + FLAT = 0x1D00 + SMOOTH = 0x1D01 + + DECR = 0x1E03 + INCR = 0x1E02 + KEEP = 0x1E00 + + EXTENSIONS = 0x1F03 + RENDERER = 0x1F01 + VENDOR = 0x1F00 + VERSION = 0x1F02 + + S = 0x2000 + T = 0x2001 + R = 0x2002 + Q = 0x2003 + + DECAL = 0x2101 + + TEXTURE_ENV_COLOR = 0x2201 + TEXTURE_ENV_MODE = 0x2200 + + TEXTURE_ENV = 0x2300 + + EYE_LINEAR = 0x2400 + OBJECT_LINEAR = 0x2401 + SPHERE_MAP = 0x2402 + + EYE_PLANE = 0x2502 + OBJECT_PLANE = 0x2501 + TEXTURE_GEN_MODE = 0x2500 + + NEAREST = 0x2600 + + LINEAR_MIPMAP_LINEAR = 0x2703 + LINEAR_MIPMAP_NEAREST = 0x2701 + NEAREST_MIPMAP_LINEAR = 0x2702 + NEAREST_MIPMAP_NEAREST = 0x2700 + + GENERATE_MIPMAP = 0x8191 + TEXTURE_WRAP_R = 0x8072 + + PROXY_TEXTURE_1D = 0x8063 + PROXY_TEXTURE_2D = 0x8064 + PROXY_TEXTURE_3D = 0x8070 + TEXTURE_3D = 0x806F + TEXTURE_BASE_LEVEL = 0x813C + TEXTURE_MAX_LEVEL = 0x813D + TEXTURE_MAX_LOD = 0x813B + TEXTURE_MIN_LOD = 0x813A + + CLAMP = 0x2900 + CLAMP_TO_BORDER = 0x812D + CLAMP_TO_EDGE = 0x812F + REPEAT = 0x2901 + + VERTEX_SHADER_BIT = 0x00000001 + FRAGMENT_SHADER_BIT = 0x00000002 + GEOMETRY_SHADER_BIT = 0x00000004 + TESS_CONTROL_SHADER_BIT = 0x00000008 + TESS_EVALUATION_SHADER_BIT = 0x00000010 + ALL_SHADER_BITS = 0xFFFFFFFF + + SYNC_FLUSH_COMMANDS_BIT = 0x00000001 + INVALID_INDEX = 0xFFFFFFFF + TIMEOUT_IGNORED = 0xFFFFFFFFFFFFFFFF + CONSTANT_COLOR = 0x8001 + ONE_MINUS_CONSTANT_COLOR = 0x8002 + CONSTANT_ALPHA = 0x8003 + ONE_MINUS_CONSTANT_ALPHA = 0x8004 + FUNC_ADD = 0x8006 + MIN = 0x8007 + MAX = 0x8008 + BLEND_EQUATION_RGB = 0x8009 + FUNC_SUBTRACT = 0x800A + FUNC_REVERSE_SUBTRACT = 0x800B + RESCALE_NORMAL = 0x803A + TEXTURE_DEPTH = 0x8071 + MAX_3D_TEXTURE_SIZE = 0x8073 + MULTISAMPLE = 0x809D + SAMPLE_ALPHA_TO_COVERAGE = 0x809E + SAMPLE_ALPHA_TO_ONE = 0x809F + SAMPLE_COVERAGE = 0x80A0 + SAMPLE_BUFFERS = 0x80A8 + SAMPLES = 0x80A9 + SAMPLE_COVERAGE_VALUE = 0x80AA + SAMPLE_COVERAGE_INVERT = 0x80AB + BLEND_DST_RGB = 0x80C8 + BLEND_SRC_RGB = 0x80C9 + BLEND_DST_ALPHA = 0x80CA + BLEND_SRC_ALPHA = 0x80CB + BGR = 0x80E0 + BGRA = 0x80E1 + MAX_ELEMENTS_VERTICES = 0x80E8 + MAX_ELEMENTS_INDICES = 0x80E9 + DEPTH_COMPONENT16 = 0x81A5 + DEPTH_COMPONENT24 = 0x81A6 + DEPTH_COMPONENT32 = 0x81A7 + FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210 + FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211 + FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212 + FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213 + FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214 + FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215 + FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216 + FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217 + FRAMEBUFFER_DEFAULT = 0x8218 + FRAMEBUFFER_UNDEFINED = 0x8219 + DEPTH_STENCIL_ATTACHMENT = 0x821A + MAJOR_VERSION = 0x821B + MINOR_VERSION = 0x821C + NUM_EXTENSIONS = 0x821D + CONTEXT_FLAGS = 0x821E + INDEX = 0x8222 + COMPRESSED_RED = 0x8225 + COMPRESSED_RG = 0x8226 + RG = 0x8227 + RG_INTEGER = 0x8228 + R8 = 0x8229 + R16 = 0x822A + RG8 = 0x822B + RG16 = 0x822C + R16F = 0x822D + R32F = 0x822E + RG16F = 0x822F + RG32F = 0x8230 + R8I = 0x8231 + R8UI = 0x8232 + R16I = 0x8233 + R16UI = 0x8234 + R32I = 0x8235 + R32UI = 0x8236 + RG8I = 0x8237 + RG8UI = 0x8238 + RG16I = 0x8239 + RG16UI = 0x823A + RG32I = 0x823B + RG32UI = 0x823C + PROGRAM_SEPARABLE = 0x8258 + ACTIVE_PROGRAM = 0x8259 + PROGRAM_PIPELINE_BINDING = 0x825A + MAX_VIEWPORTS = 0x825B + VIEWPORT_SUBPIXEL_BITS = 0x825C + VIEWPORT_BOUNDS_RANGE = 0x825D + LAYER_PROVOKING_VERTEX = 0x825E + VIEWPORT_INDEX_PROVOKING_VERTEX = 0x825F + UNDEFINED_VERTEX = 0x8260 + UNSIGNED_BYTE_2_3_3_REV = 0x8362 + UNSIGNED_SHORT_5_6_5 = 0x8363 + UNSIGNED_SHORT_5_6_5_REV = 0x8364 + UNSIGNED_SHORT_4_4_4_4_REV = 0x8365 + UNSIGNED_SHORT_1_5_5_5_REV = 0x8366 + UNSIGNED_INT_8_8_8_8_REV = 0x8367 + UNSIGNED_INT_2_10_10_10_REV = 0x8368 + MIRRORED_REPEAT = 0x8370 + FOG_COORDINATE_SOURCE = 0x8450 + FOG_COORD_SRC = 0x8450 + FOG_COORDINATE = 0x8451 + FOG_COORD = 0x8451 + FRAGMENT_DEPTH = 0x8452 + CURRENT_FOG_COORDINATE = 0x8453 + CURRENT_FOG_COORD = 0x8453 + FOG_COORDINATE_ARRAY_TYPE = 0x8454 + FOG_COORD_ARRAY_TYPE = 0x8454 + FOG_COORDINATE_ARRAY_STRIDE = 0x8455 + FOG_COORD_ARRAY_STRIDE = 0x8455 + FOG_COORDINATE_ARRAY_POINTER = 0x8456 + FOG_COORD_ARRAY_POINTER = 0x8456 + FOG_COORDINATE_ARRAY = 0x8457 + FOG_COORD_ARRAY = 0x8457 + COLOR_SUM = 0x8458 + CURRENT_SECONDARY_COLOR = 0x8459 + SECONDARY_COLOR_ARRAY_SIZE = 0x845A + SECONDARY_COLOR_ARRAY_TYPE = 0x845B + SECONDARY_COLOR_ARRAY_STRIDE = 0x845C + SECONDARY_COLOR_ARRAY_POINTER = 0x845D + SECONDARY_COLOR_ARRAY = 0x845E + CURRENT_RASTER_SECONDARY_COLOR = 0x845F + TEXTURE0 = 0x84C0 + TEXTURE1 = 0x84C1 + TEXTURE2 = 0x84C2 + TEXTURE3 = 0x84C3 + TEXTURE4 = 0x84C4 + TEXTURE5 = 0x84C5 + TEXTURE6 = 0x84C6 + TEXTURE7 = 0x84C7 + TEXTURE8 = 0x84C8 + TEXTURE9 = 0x84C9 + TEXTURE10 = 0x84CA + TEXTURE11 = 0x84CB + TEXTURE12 = 0x84CC + TEXTURE13 = 0x84CD + TEXTURE14 = 0x84CE + TEXTURE15 = 0x84CF + TEXTURE16 = 0x84D0 + TEXTURE17 = 0x84D1 + TEXTURE18 = 0x84D2 + TEXTURE19 = 0x84D3 + TEXTURE20 = 0x84D4 + TEXTURE21 = 0x84D5 + TEXTURE22 = 0x84D6 + TEXTURE23 = 0x84D7 + TEXTURE24 = 0x84D8 + TEXTURE25 = 0x84D9 + TEXTURE26 = 0x84DA + TEXTURE27 = 0x84DB + TEXTURE28 = 0x84DC + TEXTURE29 = 0x84DD + TEXTURE30 = 0x84DE + TEXTURE31 = 0x84DF + ACTIVE_TEXTURE = 0x84E0 + CLIENT_ACTIVE_TEXTURE = 0x84E1 + MAX_TEXTURE_UNITS = 0x84E2 + TRANSPOSE_MODELVIEW_MATRIX = 0x84E3 + TRANSPOSE_PROJECTION_MATRIX = 0x84E4 + TRANSPOSE_TEXTURE_MATRIX = 0x84E5 + TRANSPOSE_COLOR_MATRIX = 0x84E6 + SUBTRACT = 0x84E7 + MAX_RENDERBUFFER_SIZE = 0x84E8 + COMPRESSED_ALPHA = 0x84E9 + COMPRESSED_LUMINANCE = 0x84EA + COMPRESSED_LUMINANCE_ALPHA = 0x84EB + COMPRESSED_INTENSITY = 0x84EC + COMPRESSED_RGB = 0x84ED + COMPRESSED_RGBA = 0x84EE + UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER = 0x84F0 + UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x84F1 + TEXTURE_RECTANGLE = 0x84F5 + TEXTURE_BINDING_RECTANGLE = 0x84F6 + PROXY_TEXTURE_RECTANGLE = 0x84F7 + MAX_RECTANGLE_TEXTURE_SIZE = 0x84F8 + DEPTH_STENCIL = 0x84F9 + UNSIGNED_INT_24_8 = 0x84FA + MAX_TEXTURE_LOD_BIAS = 0x84FD + TEXTURE_FILTER_CONTROL = 0x8500 + TEXTURE_LOD_BIAS = 0x8501 + INCR_WRAP = 0x8507 + DECR_WRAP = 0x8508 + NORMAL_MAP = 0x8511 + REFLECTION_MAP = 0x8512 + TEXTURE_CUBE_MAP = 0x8513 + TEXTURE_BINDING_CUBE_MAP = 0x8514 + TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515 + TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516 + TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517 + TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518 + TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519 + TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A + PROXY_TEXTURE_CUBE_MAP = 0x851B + MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C + COMBINE = 0x8570 + COMBINE_RGB = 0x8571 + COMBINE_ALPHA = 0x8572 + RGB_SCALE = 0x8573 + ADD_SIGNED = 0x8574 + INTERPOLATE = 0x8575 + CONSTANT = 0x8576 + PRIMARY_COLOR = 0x8577 + PREVIOUS = 0x8578 + SOURCE0_RGB = 0x8580 + SRC0_RGB = 0x8580 + SOURCE1_RGB = 0x8581 + SRC1_RGB = 0x8581 + SOURCE2_RGB = 0x8582 + SRC2_RGB = 0x8582 + SOURCE0_ALPHA = 0x8588 + SRC0_ALPHA = 0x8588 + SOURCE1_ALPHA = 0x8589 + SRC1_ALPHA = 0x8589 + SOURCE2_ALPHA = 0x858A + SRC2_ALPHA = 0x858A + OPERAND0_RGB = 0x8590 + OPERAND1_RGB = 0x8591 + OPERAND2_RGB = 0x8592 + OPERAND0_ALPHA = 0x8598 + OPERAND1_ALPHA = 0x8599 + OPERAND2_ALPHA = 0x859A + VERTEX_ARRAY_BINDING = 0x85B5 + VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622 + VERTEX_ATTRIB_ARRAY_SIZE = 0x8623 + VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624 + VERTEX_ATTRIB_ARRAY_TYPE = 0x8625 + CURRENT_VERTEX_ATTRIB = 0x8626 + VERTEX_PROGRAM_POINT_SIZE = 0x8642 + PROGRAM_POINT_SIZE = 0x8642 + VERTEX_PROGRAM_TWO_SIDE = 0x8643 + VERTEX_ATTRIB_ARRAY_POINTER = 0x8645 + DEPTH_CLAMP = 0x864F + TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0 + TEXTURE_COMPRESSED = 0x86A1 + NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2 + COMPRESSED_TEXTURE_FORMATS = 0x86A3 + DOT3_RGB = 0x86AE + DOT3_RGBA = 0x86AF + PROGRAM_BINARY_LENGTH = 0x8741 + BUFFER_SIZE = 0x8764 + BUFFER_USAGE = 0x8765 + NUM_PROGRAM_BINARY_FORMATS = 0x87FE + PROGRAM_BINARY_FORMATS = 0x87FF + STENCIL_BACK_FUNC = 0x8800 + STENCIL_BACK_FAIL = 0x8801 + STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802 + STENCIL_BACK_PASS_DEPTH_PASS = 0x8803 + RGBA32F = 0x8814 + RGB32F = 0x8815 + RGBA16F = 0x881A + RGB16F = 0x881B + MAX_DRAW_BUFFERS = 0x8824 + DRAW_BUFFER0 = 0x8825 + DRAW_BUFFER1 = 0x8826 + DRAW_BUFFER2 = 0x8827 + DRAW_BUFFER3 = 0x8828 + DRAW_BUFFER4 = 0x8829 + DRAW_BUFFER5 = 0x882A + DRAW_BUFFER6 = 0x882B + DRAW_BUFFER7 = 0x882C + DRAW_BUFFER8 = 0x882D + DRAW_BUFFER9 = 0x882E + DRAW_BUFFER10 = 0x882F + DRAW_BUFFER11 = 0x8830 + DRAW_BUFFER12 = 0x8831 + DRAW_BUFFER13 = 0x8832 + DRAW_BUFFER14 = 0x8833 + DRAW_BUFFER15 = 0x8834 + BLEND_EQUATION_ALPHA = 0x883D + TEXTURE_DEPTH_SIZE = 0x884A + DEPTH_TEXTURE_MODE = 0x884B + TEXTURE_COMPARE_MODE = 0x884C + TEXTURE_COMPARE_FUNC = 0x884D + COMPARE_R_TO_TEXTURE = 0x884E + COMPARE_REF_TO_TEXTURE = 0x884E + TEXTURE_CUBE_MAP_SEAMLESS = 0x884F + POINT_SPRITE = 0x8861 + COORD_REPLACE = 0x8862 + QUERY_COUNTER_BITS = 0x8864 + CURRENT_QUERY = 0x8865 + QUERY_RESULT = 0x8866 + QUERY_RESULT_AVAILABLE = 0x8867 + MAX_VERTEX_ATTRIBS = 0x8869 + VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A + MAX_TESS_CONTROL_INPUT_COMPONENTS = 0x886C + MAX_TESS_EVALUATION_INPUT_COMPONENTS = 0x886D + MAX_TEXTURE_COORDS = 0x8871 + MAX_TEXTURE_IMAGE_UNITS = 0x8872 + GEOMETRY_SHADER_INVOCATIONS = 0x887F + ARRAY_BUFFER = 0x8892 + ELEMENT_ARRAY_BUFFER = 0x8893 + ARRAY_BUFFER_BINDING = 0x8894 + ELEMENT_ARRAY_BUFFER_BINDING = 0x8895 + VERTEX_ARRAY_BUFFER_BINDING = 0x8896 + NORMAL_ARRAY_BUFFER_BINDING = 0x8897 + COLOR_ARRAY_BUFFER_BINDING = 0x8898 + INDEX_ARRAY_BUFFER_BINDING = 0x8899 + TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A + EDGE_FLAG_ARRAY_BUFFER_BINDING = 0x889B + SECONDARY_COLOR_ARRAY_BUFFER_BINDING = 0x889C + FOG_COORDINATE_ARRAY_BUFFER_BINDING = 0x889D + FOG_COORD_ARRAY_BUFFER_BINDING = 0x889D + WEIGHT_ARRAY_BUFFER_BINDING = 0x889E + VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F + READ_ONLY = 0x88B8 + WRITE_ONLY = 0x88B9 + READ_WRITE = 0x88BA + BUFFER_ACCESS = 0x88BB + BUFFER_MAPPED = 0x88BC + BUFFER_MAP_POINTER = 0x88BD + TIME_ELAPSED = 0x88BF + STREAM_DRAW = 0x88E0 + STREAM_READ = 0x88E1 + STREAM_COPY = 0x88E2 + STATIC_DRAW = 0x88E4 + STATIC_READ = 0x88E5 + STATIC_COPY = 0x88E6 + DYNAMIC_DRAW = 0x88E8 + DYNAMIC_READ = 0x88E9 + DYNAMIC_COPY = 0x88EA + PIXEL_PACK_BUFFER = 0x88EB + PIXEL_UNPACK_BUFFER = 0x88EC + PIXEL_PACK_BUFFER_BINDING = 0x88ED + PIXEL_UNPACK_BUFFER_BINDING = 0x88EF + DEPTH24_STENCIL8 = 0x88F0 + TEXTURE_STENCIL_SIZE = 0x88F1 + SRC1_COLOR = 0x88F9 + ONE_MINUS_SRC1_COLOR = 0x88FA + ONE_MINUS_SRC1_ALPHA = 0x88FB + MAX_DUAL_SOURCE_DRAW_BUFFERS = 0x88FC + VERTEX_ATTRIB_ARRAY_INTEGER = 0x88FD + VERTEX_ATTRIB_ARRAY_DIVISOR = 0x88FE + MAX_ARRAY_TEXTURE_LAYERS = 0x88FF + MIN_PROGRAM_TEXEL_OFFSET = 0x8904 + MAX_PROGRAM_TEXEL_OFFSET = 0x8905 + SAMPLES_PASSED = 0x8914 + GEOMETRY_VERTICES_OUT = 0x8916 + GEOMETRY_INPUT_TYPE = 0x8917 + GEOMETRY_OUTPUT_TYPE = 0x8918 + SAMPLER_BINDING = 0x8919 + CLAMP_VERTEX_COLOR = 0x891A + CLAMP_FRAGMENT_COLOR = 0x891B + CLAMP_READ_COLOR = 0x891C + FIXED_ONLY = 0x891D + UNIFORM_BUFFER = 0x8A11 + UNIFORM_BUFFER_BINDING = 0x8A28 + UNIFORM_BUFFER_START = 0x8A29 + UNIFORM_BUFFER_SIZE = 0x8A2A + MAX_VERTEX_UNIFORM_BLOCKS = 0x8A2B + MAX_GEOMETRY_UNIFORM_BLOCKS = 0x8A2C + MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8A2D + MAX_COMBINED_UNIFORM_BLOCKS = 0x8A2E + MAX_UNIFORM_BUFFER_BINDINGS = 0x8A2F + MAX_UNIFORM_BLOCK_SIZE = 0x8A30 + MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31 + MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 0x8A32 + MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33 + UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8A34 + ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35 + ACTIVE_UNIFORM_BLOCKS = 0x8A36 + UNIFORM_TYPE = 0x8A37 + UNIFORM_SIZE = 0x8A38 + UNIFORM_NAME_LENGTH = 0x8A39 + UNIFORM_BLOCK_INDEX = 0x8A3A + UNIFORM_OFFSET = 0x8A3B + UNIFORM_ARRAY_STRIDE = 0x8A3C + UNIFORM_MATRIX_STRIDE = 0x8A3D + UNIFORM_IS_ROW_MAJOR = 0x8A3E + UNIFORM_BLOCK_BINDING = 0x8A3F + UNIFORM_BLOCK_DATA_SIZE = 0x8A40 + UNIFORM_BLOCK_NAME_LENGTH = 0x8A41 + UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8A42 + UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43 + UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44 + UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 0x8A45 + UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46 + FRAGMENT_SHADER = 0x8B30 + VERTEX_SHADER = 0x8B31 + MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49 + MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A + MAX_VARYING_FLOATS = 0x8B4B + MAX_VARYING_COMPONENTS = 0x8B4B + MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C + MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D + SHADER_TYPE = 0x8B4F + FLOAT_VEC2 = 0x8B50 + FLOAT_VEC3 = 0x8B51 + FLOAT_VEC4 = 0x8B52 + INT_VEC2 = 0x8B53 + INT_VEC3 = 0x8B54 + INT_VEC4 = 0x8B55 + BOOL = 0x8B56 + BOOL_VEC2 = 0x8B57 + BOOL_VEC3 = 0x8B58 + BOOL_VEC4 = 0x8B59 + FLOAT_MAT2 = 0x8B5A + FLOAT_MAT3 = 0x8B5B + FLOAT_MAT4 = 0x8B5C + SAMPLER_1D = 0x8B5D + SAMPLER_2D = 0x8B5E + SAMPLER_3D = 0x8B5F + SAMPLER_CUBE = 0x8B60 + SAMPLER_1D_SHADOW = 0x8B61 + SAMPLER_2D_SHADOW = 0x8B62 + SAMPLER_2D_RECT = 0x8B63 + SAMPLER_2D_RECT_SHADOW = 0x8B64 + FLOAT_MAT2x3 = 0x8B65 + FLOAT_MAT2x4 = 0x8B66 + FLOAT_MAT3x2 = 0x8B67 + FLOAT_MAT3x4 = 0x8B68 + FLOAT_MAT4x2 = 0x8B69 + FLOAT_MAT4x3 = 0x8B6A + DELETE_STATUS = 0x8B80 + COMPILE_STATUS = 0x8B81 + LINK_STATUS = 0x8B82 + VALIDATE_STATUS = 0x8B83 + INFO_LOG_LENGTH = 0x8B84 + ATTACHED_SHADERS = 0x8B85 + ACTIVE_UNIFORMS = 0x8B86 + ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87 + SHADER_SOURCE_LENGTH = 0x8B88 + ACTIVE_ATTRIBUTES = 0x8B89 + ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A + SHADING_LANGUAGE_VERSION = 0x8B8C + CURRENT_PROGRAM = 0x8B8D + IMPLEMENTATION_COLOR_READ_TYPE = 0x8B9A + IMPLEMENTATION_COLOR_READ_FORMAT = 0x8B9B + TEXTURE_RED_TYPE = 0x8C10 + TEXTURE_GREEN_TYPE = 0x8C11 + TEXTURE_BLUE_TYPE = 0x8C12 + TEXTURE_ALPHA_TYPE = 0x8C13 + TEXTURE_LUMINANCE_TYPE = 0x8C14 + TEXTURE_INTENSITY_TYPE = 0x8C15 + TEXTURE_DEPTH_TYPE = 0x8C16 + UNSIGNED_NORMALIZED = 0x8C17 + TEXTURE_1D_ARRAY = 0x8C18 + PROXY_TEXTURE_1D_ARRAY = 0x8C19 + TEXTURE_2D_ARRAY = 0x8C1A + PROXY_TEXTURE_2D_ARRAY = 0x8C1B + TEXTURE_BINDING_1D_ARRAY = 0x8C1C + TEXTURE_BINDING_2D_ARRAY = 0x8C1D + MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = 0x8C29 + TEXTURE_BUFFER = 0x8C2A + MAX_TEXTURE_BUFFER_SIZE = 0x8C2B + TEXTURE_BINDING_BUFFER = 0x8C2C + TEXTURE_BUFFER_DATA_STORE_BINDING = 0x8C2D + ANY_SAMPLES_PASSED = 0x8C2F + SAMPLE_SHADING = 0x8C36 + MIN_SAMPLE_SHADING_VALUE = 0x8C37 + R11F_G11F_B10F = 0x8C3A + UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B + RGB9_E5 = 0x8C3D + UNSIGNED_INT_5_9_9_9_REV = 0x8C3E + TEXTURE_SHARED_SIZE = 0x8C3F + SRGB = 0x8C40 + SRGB8 = 0x8C41 + SRGB_ALPHA = 0x8C42 + SRGB8_ALPHA8 = 0x8C43 + SLUMINANCE_ALPHA = 0x8C44 + SLUMINANCE8_ALPHA8 = 0x8C45 + SLUMINANCE = 0x8C46 + SLUMINANCE8 = 0x8C47 + COMPRESSED_SRGB = 0x8C48 + COMPRESSED_SRGB_ALPHA = 0x8C49 + COMPRESSED_SLUMINANCE = 0x8C4A + COMPRESSED_SLUMINANCE_ALPHA = 0x8C4B + TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76 + TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F + MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80 + TRANSFORM_FEEDBACK_VARYINGS = 0x8C83 + TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84 + TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85 + PRIMITIVES_GENERATED = 0x8C87 + TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88 + RASTERIZER_DISCARD = 0x8C89 + MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A + MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B + INTERLEAVED_ATTRIBS = 0x8C8C + SEPARATE_ATTRIBS = 0x8C8D + TRANSFORM_FEEDBACK_BUFFER = 0x8C8E + TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F + POINT_SPRITE_COORD_ORIGIN = 0x8CA0 + LOWER_LEFT = 0x8CA1 + UPPER_LEFT = 0x8CA2 + STENCIL_BACK_REF = 0x8CA3 + STENCIL_BACK_VALUE_MASK = 0x8CA4 + STENCIL_BACK_WRITEMASK = 0x8CA5 + DRAW_FRAMEBUFFER_BINDING = 0x8CA6 + FRAMEBUFFER_BINDING = 0x8CA6 + RENDERBUFFER_BINDING = 0x8CA7 + READ_FRAMEBUFFER = 0x8CA8 + DRAW_FRAMEBUFFER = 0x8CA9 + READ_FRAMEBUFFER_BINDING = 0x8CAA + RENDERBUFFER_SAMPLES = 0x8CAB + DEPTH_COMPONENT32F = 0x8CAC + DEPTH32F_STENCIL8 = 0x8CAD + FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0 + FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1 + FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2 + FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3 + FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4 + FRAMEBUFFER_COMPLETE = 0x8CD5 + FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6 + FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7 + FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB + FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC + FRAMEBUFFER_UNSUPPORTED = 0x8CDD + MAX_COLOR_ATTACHMENTS = 0x8CDF + COLOR_ATTACHMENT0 = 0x8CE0 + COLOR_ATTACHMENT1 = 0x8CE1 + COLOR_ATTACHMENT2 = 0x8CE2 + COLOR_ATTACHMENT3 = 0x8CE3 + COLOR_ATTACHMENT4 = 0x8CE4 + COLOR_ATTACHMENT5 = 0x8CE5 + COLOR_ATTACHMENT6 = 0x8CE6 + COLOR_ATTACHMENT7 = 0x8CE7 + COLOR_ATTACHMENT8 = 0x8CE8 + COLOR_ATTACHMENT9 = 0x8CE9 + COLOR_ATTACHMENT10 = 0x8CEA + COLOR_ATTACHMENT11 = 0x8CEB + COLOR_ATTACHMENT12 = 0x8CEC + COLOR_ATTACHMENT13 = 0x8CED + COLOR_ATTACHMENT14 = 0x8CEE + COLOR_ATTACHMENT15 = 0x8CEF + DEPTH_ATTACHMENT = 0x8D00 + STENCIL_ATTACHMENT = 0x8D20 + FRAMEBUFFER = 0x8D40 + RENDERBUFFER = 0x8D41 + RENDERBUFFER_WIDTH = 0x8D42 + RENDERBUFFER_HEIGHT = 0x8D43 + RENDERBUFFER_INTERNAL_FORMAT = 0x8D44 + STENCIL_INDEX1 = 0x8D46 + STENCIL_INDEX4 = 0x8D47 + STENCIL_INDEX8 = 0x8D48 + STENCIL_INDEX16 = 0x8D49 + RENDERBUFFER_RED_SIZE = 0x8D50 + RENDERBUFFER_GREEN_SIZE = 0x8D51 + RENDERBUFFER_BLUE_SIZE = 0x8D52 + RENDERBUFFER_ALPHA_SIZE = 0x8D53 + RENDERBUFFER_DEPTH_SIZE = 0x8D54 + RENDERBUFFER_STENCIL_SIZE = 0x8D55 + FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56 + MAX_SAMPLES = 0x8D57 + RGB565 = 0x8D62 + RGBA32UI = 0x8D70 + RGB32UI = 0x8D71 + RGBA16UI = 0x8D76 + RGB16UI = 0x8D77 + RGBA8UI = 0x8D7C + RGB8UI = 0x8D7D + RGBA32I = 0x8D82 + RGB32I = 0x8D83 + RGBA16I = 0x8D88 + RGB16I = 0x8D89 + RGBA8I = 0x8D8E + RGB8I = 0x8D8F + RED_INTEGER = 0x8D94 + GREEN_INTEGER = 0x8D95 + BLUE_INTEGER = 0x8D96 + ALPHA_INTEGER = 0x8D97 + RGB_INTEGER = 0x8D98 + RGBA_INTEGER = 0x8D99 + BGR_INTEGER = 0x8D9A + BGRA_INTEGER = 0x8D9B + INT_2_10_10_10_REV = 0x8D9F + FRAMEBUFFER_ATTACHMENT_LAYERED = 0x8DA7 + FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = 0x8DA8 + FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD + FRAMEBUFFER_SRGB = 0x8DB9 + COMPRESSED_RED_RGTC1 = 0x8DBB + COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC + COMPRESSED_RG_RGTC2 = 0x8DBD + COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE + SAMPLER_1D_ARRAY = 0x8DC0 + SAMPLER_2D_ARRAY = 0x8DC1 + SAMPLER_BUFFER = 0x8DC2 + SAMPLER_1D_ARRAY_SHADOW = 0x8DC3 + SAMPLER_2D_ARRAY_SHADOW = 0x8DC4 + SAMPLER_CUBE_SHADOW = 0x8DC5 + UNSIGNED_INT_VEC2 = 0x8DC6 + UNSIGNED_INT_VEC3 = 0x8DC7 + UNSIGNED_INT_VEC4 = 0x8DC8 + INT_SAMPLER_1D = 0x8DC9 + INT_SAMPLER_2D = 0x8DCA + INT_SAMPLER_3D = 0x8DCB + INT_SAMPLER_CUBE = 0x8DCC + INT_SAMPLER_2D_RECT = 0x8DCD + INT_SAMPLER_1D_ARRAY = 0x8DCE + INT_SAMPLER_2D_ARRAY = 0x8DCF + INT_SAMPLER_BUFFER = 0x8DD0 + UNSIGNED_INT_SAMPLER_1D = 0x8DD1 + UNSIGNED_INT_SAMPLER_2D = 0x8DD2 + UNSIGNED_INT_SAMPLER_3D = 0x8DD3 + UNSIGNED_INT_SAMPLER_CUBE = 0x8DD4 + UNSIGNED_INT_SAMPLER_2D_RECT = 0x8DD5 + UNSIGNED_INT_SAMPLER_1D_ARRAY = 0x8DD6 + UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8DD7 + UNSIGNED_INT_SAMPLER_BUFFER = 0x8DD8 + GEOMETRY_SHADER = 0x8DD9 + MAX_GEOMETRY_UNIFORM_COMPONENTS = 0x8DDF + MAX_GEOMETRY_OUTPUT_VERTICES = 0x8DE0 + MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = 0x8DE1 + ACTIVE_SUBROUTINES = 0x8DE5 + ACTIVE_SUBROUTINE_UNIFORMS = 0x8DE6 + MAX_SUBROUTINES = 0x8DE7 + MAX_SUBROUTINE_UNIFORM_LOCATIONS = 0x8DE8 + LOW_FLOAT = 0x8DF0 + MEDIUM_FLOAT = 0x8DF1 + HIGH_FLOAT = 0x8DF2 + LOW_INT = 0x8DF3 + MEDIUM_INT = 0x8DF4 + HIGH_INT = 0x8DF5 + SHADER_BINARY_FORMATS = 0x8DF8 + NUM_SHADER_BINARY_FORMATS = 0x8DF9 + SHADER_COMPILER = 0x8DFA + MAX_VERTEX_UNIFORM_VECTORS = 0x8DFB + MAX_VARYING_VECTORS = 0x8DFC + MAX_FRAGMENT_UNIFORM_VECTORS = 0x8DFD + QUERY_WAIT = 0x8E13 + QUERY_NO_WAIT = 0x8E14 + QUERY_BY_REGION_WAIT = 0x8E15 + QUERY_BY_REGION_NO_WAIT = 0x8E16 + MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E1E + MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E1F + TRANSFORM_FEEDBACK = 0x8E22 + TRANSFORM_FEEDBACK_BUFFER_PAUSED = 0x8E23 + TRANSFORM_FEEDBACK_BUFFER_ACTIVE = 0x8E24 + TRANSFORM_FEEDBACK_BINDING = 0x8E25 + TIMESTAMP = 0x8E28 + TEXTURE_SWIZZLE_R = 0x8E42 + TEXTURE_SWIZZLE_G = 0x8E43 + TEXTURE_SWIZZLE_B = 0x8E44 + TEXTURE_SWIZZLE_A = 0x8E45 + TEXTURE_SWIZZLE_RGBA = 0x8E46 + ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS = 0x8E47 + ACTIVE_SUBROUTINE_MAX_LENGTH = 0x8E48 + ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH = 0x8E49 + NUM_COMPATIBLE_SUBROUTINES = 0x8E4A + COMPATIBLE_SUBROUTINES = 0x8E4B + QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = 0x8E4C + FIRST_VERTEX_CONVENTION = 0x8E4D + LAST_VERTEX_CONVENTION = 0x8E4E + PROVOKING_VERTEX = 0x8E4F + SAMPLE_POSITION = 0x8E50 + SAMPLE_MASK = 0x8E51 + SAMPLE_MASK_VALUE = 0x8E52 + MAX_SAMPLE_MASK_WORDS = 0x8E59 + MAX_GEOMETRY_SHADER_INVOCATIONS = 0x8E5A + MIN_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5B + MAX_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5C + FRAGMENT_INTERPOLATION_OFFSET_BITS = 0x8E5D + MIN_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5E + MAX_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5F + MAX_TRANSFORM_FEEDBACK_BUFFERS = 0x8E70 + MAX_VERTEX_STREAMS = 0x8E71 + PATCH_VERTICES = 0x8E72 + PATCH_DEFAULT_INNER_LEVEL = 0x8E73 + PATCH_DEFAULT_OUTER_LEVEL = 0x8E74 + TESS_CONTROL_OUTPUT_VERTICES = 0x8E75 + TESS_GEN_MODE = 0x8E76 + TESS_GEN_SPACING = 0x8E77 + TESS_GEN_VERTEX_ORDER = 0x8E78 + TESS_GEN_POINT_MODE = 0x8E79 + ISOLINES = 0x8E7A + FRACTIONAL_ODD = 0x8E7B + FRACTIONAL_EVEN = 0x8E7C + MAX_PATCH_VERTICES = 0x8E7D + MAX_TESS_GEN_LEVEL = 0x8E7E + MAX_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E7F + MAX_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E80 + MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS = 0x8E81 + MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS = 0x8E82 + MAX_TESS_CONTROL_OUTPUT_COMPONENTS = 0x8E83 + MAX_TESS_PATCH_COMPONENTS = 0x8E84 + MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS = 0x8E85 + MAX_TESS_EVALUATION_OUTPUT_COMPONENTS = 0x8E86 + TESS_EVALUATION_SHADER = 0x8E87 + TESS_CONTROL_SHADER = 0x8E88 + MAX_TESS_CONTROL_UNIFORM_BLOCKS = 0x8E89 + MAX_TESS_EVALUATION_UNIFORM_BLOCKS = 0x8E8A + COPY_READ_BUFFER = 0x8F36 + COPY_WRITE_BUFFER = 0x8F37 + DRAW_INDIRECT_BUFFER = 0x8F3F + DRAW_INDIRECT_BUFFER_BINDING = 0x8F43 + DOUBLE_MAT2 = 0x8F46 + DOUBLE_MAT3 = 0x8F47 + DOUBLE_MAT4 = 0x8F48 + DOUBLE_MAT2x3 = 0x8F49 + DOUBLE_MAT2x4 = 0x8F4A + DOUBLE_MAT3x2 = 0x8F4B + DOUBLE_MAT3x4 = 0x8F4C + DOUBLE_MAT4x2 = 0x8F4D + DOUBLE_MAT4x3 = 0x8F4E + R8_SNORM = 0x8F94 + RG8_SNORM = 0x8F95 + RGB8_SNORM = 0x8F96 + RGBA8_SNORM = 0x8F97 + R16_SNORM = 0x8F98 + RG16_SNORM = 0x8F99 + RGB16_SNORM = 0x8F9A + RGBA16_SNORM = 0x8F9B + SIGNED_NORMALIZED = 0x8F9C + PRIMITIVE_RESTART = 0x8F9D + PRIMITIVE_RESTART_INDEX = 0x8F9E + DOUBLE_VEC2 = 0x8FFC + DOUBLE_VEC3 = 0x8FFD + DOUBLE_VEC4 = 0x8FFE + TEXTURE_CUBE_MAP_ARRAY = 0x9009 + TEXTURE_BINDING_CUBE_MAP_ARRAY = 0x900A + PROXY_TEXTURE_CUBE_MAP_ARRAY = 0x900B + SAMPLER_CUBE_MAP_ARRAY = 0x900C + SAMPLER_CUBE_MAP_ARRAY_SHADOW = 0x900D + INT_SAMPLER_CUBE_MAP_ARRAY = 0x900E + UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY = 0x900F + RGB10_A2UI = 0x906F + TEXTURE_2D_MULTISAMPLE = 0x9100 + PROXY_TEXTURE_2D_MULTISAMPLE = 0x9101 + TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9102 + PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9103 + TEXTURE_BINDING_2D_MULTISAMPLE = 0x9104 + TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = 0x9105 + TEXTURE_SAMPLES = 0x9106 + TEXTURE_FIXED_SAMPLE_LOCATIONS = 0x9107 + SAMPLER_2D_MULTISAMPLE = 0x9108 + INT_SAMPLER_2D_MULTISAMPLE = 0x9109 + UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = 0x910A + SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910B + INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910C + UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910D + MAX_COLOR_TEXTURE_SAMPLES = 0x910E + MAX_DEPTH_TEXTURE_SAMPLES = 0x910F + MAX_INTEGER_SAMPLES = 0x9110 + MAX_SERVER_WAIT_TIMEOUT = 0x9111 + OBJECT_TYPE = 0x9112 + SYNC_CONDITION = 0x9113 + SYNC_STATUS = 0x9114 + SYNC_FLAGS = 0x9115 + SYNC_FENCE = 0x9116 + SYNC_GPU_COMMANDS_COMPLETE = 0x9117 + UNSIGNALED = 0x9118 + SIGNALED = 0x9119 + ALREADY_SIGNALED = 0x911A + TIMEOUT_EXPIRED = 0x911B + CONDITION_SATISFIED = 0x911C + WAIT_FAILED = 0x911D + BUFFER_ACCESS_FLAGS = 0x911F + BUFFER_MAP_LENGTH = 0x9120 + BUFFER_MAP_OFFSET = 0x9121 + MAX_VERTEX_OUTPUT_COMPONENTS = 0x9122 + MAX_GEOMETRY_INPUT_COMPONENTS = 0x9123 + MAX_GEOMETRY_OUTPUT_COMPONENTS = 0x9124 + MAX_FRAGMENT_INPUT_COMPONENTS = 0x9125 + CONTEXT_PROFILE_MASK = 0x9126 +) + +// https://www.opengl.org/sdk/docs/man4/xhtml/glViewport.xml +func (gl *GL) Viewport(x, y, width, height int) { + C.gl4_1compat_glViewport(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// DepthRange specifies the mapping of depth values from normalized device +// coordinates to window coordinates. +// +// Parameter nearVal specifies the mapping of the near clipping plane to window +// coordinates (defaults to 0), while farVal specifies the mapping of the far +// clipping plane to window coordinates (defaults to 1). +// +// After clipping and division by w, depth coordinates range from -1 to 1, +// corresponding to the near and far clipping planes. DepthRange specifies a +// linear mapping of the normalized depth coordinates in this range to window +// depth coordinates. Regardless of the actual depth buffer implementation, +// window coordinate depth values are treated as though they range from 0 through 1 +// (like color components). Thus, the values accepted by DepthRange are both +// clamped to this range before they are accepted. +// +// The default setting of (0, 1) maps the near plane to 0 and the far plane to 1. +// With this mapping, the depth buffer range is fully utilized. +// +// It is not necessary that nearVal be less than farVal. Reverse mappings such as +// nearVal 1, and farVal 0 are acceptable. +// +// GL.INVALID_OPERATION is generated if DepthRange is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) DepthRange(nearVal, farVal float64) { + C.gl4_1compat_glDepthRange(gl.funcs, C.GLdouble(nearVal), C.GLdouble(farVal)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsEnabled.xml +func (gl *GL) IsEnabled(cap glbase.Enum) bool { + glresult := C.gl4_1compat_glIsEnabled(gl.funcs, C.GLenum(cap)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexLevelParameteriv.xml +func (gl *GL) GetTexLevelParameteriv(target glbase.Enum, level int, pname glbase.Enum, params []int32) { + C.gl4_1compat_glGetTexLevelParameteriv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexLevelParameterfv.xml +func (gl *GL) GetTexLevelParameterfv(target glbase.Enum, level int, pname glbase.Enum, params []float32) { + C.gl4_1compat_glGetTexLevelParameterfv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameteriv.xml +func (gl *GL) GetTexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_1compat_glGetTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameterfv.xml +func (gl *GL) GetTexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_1compat_glGetTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexImage.xml +func (gl *GL) GetTexImage(target glbase.Enum, level int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glGetTexImage(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetIntegerv.xml +func (gl *GL) GetIntegerv(pname glbase.Enum, params []int32) { + C.gl4_1compat_glGetIntegerv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFloatv.xml +func (gl *GL) GetFloatv(pname glbase.Enum, params []float32) { + C.gl4_1compat_glGetFloatv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetError.xml +func (gl *GL) GetError() glbase.Enum { + glresult := C.gl4_1compat_glGetError(gl.funcs) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetDoublev.xml +func (gl *GL) GetDoublev(pname glbase.Enum, params []float64) { + C.gl4_1compat_glGetDoublev(gl.funcs, C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBooleanv.xml +func (gl *GL) GetBooleanv(pname glbase.Enum, params []bool) { + C.gl4_1compat_glGetBooleanv(gl.funcs, C.GLenum(pname), (*C.GLboolean)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glReadPixels.xml +func (gl *GL) ReadPixels(x, y, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glReadPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glReadBuffer.xml +func (gl *GL) ReadBuffer(mode glbase.Enum) { + C.gl4_1compat_glReadBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelStorei.xml +func (gl *GL) PixelStorei(pname glbase.Enum, param int32) { + C.gl4_1compat_glPixelStorei(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelStoref.xml +func (gl *GL) PixelStoref(pname glbase.Enum, param float32) { + C.gl4_1compat_glPixelStoref(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDepthFunc.xml +func (gl *GL) DepthFunc(glfunc glbase.Enum) { + C.gl4_1compat_glDepthFunc(gl.funcs, C.GLenum(glfunc)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilOp.xml +func (gl *GL) StencilOp(fail, zfail, zpass glbase.Enum) { + C.gl4_1compat_glStencilOp(gl.funcs, C.GLenum(fail), C.GLenum(zfail), C.GLenum(zpass)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilFunc.xml +func (gl *GL) StencilFunc(glfunc glbase.Enum, ref int32, mask uint32) { + C.gl4_1compat_glStencilFunc(gl.funcs, C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLogicOp.xml +func (gl *GL) LogicOp(opcode glbase.Enum) { + C.gl4_1compat_glLogicOp(gl.funcs, C.GLenum(opcode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFunc.xml +func (gl *GL) BlendFunc(sfactor, dfactor glbase.Enum) { + C.gl4_1compat_glBlendFunc(gl.funcs, C.GLenum(sfactor), C.GLenum(dfactor)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFlush.xml +func (gl *GL) Flush() { + C.gl4_1compat_glFlush(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFinish.xml +func (gl *GL) Finish() { + C.gl4_1compat_glFinish(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEnable.xml +func (gl *GL) Enable(cap glbase.Enum) { + C.gl4_1compat_glEnable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDisable.xml +func (gl *GL) Disable(cap glbase.Enum) { + C.gl4_1compat_glDisable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDepthMask.xml +func (gl *GL) DepthMask(flag bool) { + C.gl4_1compat_glDepthMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorMask.xml +func (gl *GL) ColorMask(red, green, blue, alpha bool) { + C.gl4_1compat_glColorMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&red)), *(*C.GLboolean)(unsafe.Pointer(&green)), *(*C.GLboolean)(unsafe.Pointer(&blue)), *(*C.GLboolean)(unsafe.Pointer(&alpha))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilMask.xml +func (gl *GL) StencilMask(mask uint32) { + C.gl4_1compat_glStencilMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearDepth.xml +func (gl *GL) ClearDepth(depth float64) { + C.gl4_1compat_glClearDepth(gl.funcs, C.GLdouble(depth)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearStencil.xml +func (gl *GL) ClearStencil(s int32) { + C.gl4_1compat_glClearStencil(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearColor.xml +func (gl *GL) ClearColor(red, green, blue, alpha float32) { + C.gl4_1compat_glClearColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClear.xml +func (gl *GL) Clear(mask glbase.Bitfield) { + C.gl4_1compat_glClear(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawBuffer.xml +func (gl *GL) DrawBuffer(mode glbase.Enum) { + C.gl4_1compat_glDrawBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage2D.xml +func (gl *GL) TexImage2D(target glbase.Enum, level int, internalFormat int32, width, height, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage1D.xml +func (gl *GL) TexImage1D(target glbase.Enum, level int, internalFormat int32, width, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameteriv.xml +func (gl *GL) TexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_1compat_glTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameteri.xml +func (gl *GL) TexParameteri(target, pname glbase.Enum, param int32) { + C.gl4_1compat_glTexParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterfv.xml +func (gl *GL) TexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_1compat_glTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterf.xml +func (gl *GL) TexParameterf(target, pname glbase.Enum, param float32) { + C.gl4_1compat_glTexParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glScissor.xml +func (gl *GL) Scissor(x, y, width, height int) { + C.gl4_1compat_glScissor(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPolygonMode.xml +func (gl *GL) PolygonMode(face, mode glbase.Enum) { + C.gl4_1compat_glPolygonMode(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointSize.xml +func (gl *GL) PointSize(size float32) { + C.gl4_1compat_glPointSize(gl.funcs, C.GLfloat(size)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLineWidth.xml +func (gl *GL) LineWidth(width float32) { + C.gl4_1compat_glLineWidth(gl.funcs, C.GLfloat(width)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glHint.xml +func (gl *GL) Hint(target, mode glbase.Enum) { + C.gl4_1compat_glHint(gl.funcs, C.GLenum(target), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFrontFace.xml +func (gl *GL) FrontFace(mode glbase.Enum) { + C.gl4_1compat_glFrontFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCullFace.xml +func (gl *GL) CullFace(mode glbase.Enum) { + C.gl4_1compat_glCullFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexubv.xml +func (gl *GL) Indexubv(c []uint8) { + C.gl4_1compat_glIndexubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexub.xml +func (gl *GL) Indexub(c uint8) { + C.gl4_1compat_glIndexub(gl.funcs, C.GLubyte(c)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsTexture.xml +func (gl *GL) IsTexture(texture glbase.Texture) bool { + glresult := C.gl4_1compat_glIsTexture(gl.funcs, C.GLuint(texture)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenTextures returns n texture names in textures. There is no guarantee +// that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenTextures. +// +// The generated textures have no dimensionality; they assume the +// dimensionality of the texture target to which they are first bound (see +// BindTexture). +// +// Texture names returned by a call to GenTextures are not returned by +// subsequent calls, unless they are first deleted with DeleteTextures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenTextures is available in GL version 2.0 or greater. +func (gl *GL) GenTextures(n int) []glbase.Texture { + if n == 0 { + return nil + } + textures := make([]glbase.Texture, n) + C.gl4_1compat_glGenTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) + return textures +} + +// DeleteTextures deletes the textures objects whose names are stored +// in the textures slice. After a texture is deleted, it has no contents or +// dimensionality, and its name is free for reuse (for example by +// GenTextures). If a texture that is currently bound is deleted, the binding +// reverts to 0 (the default texture). +// +// DeleteTextures silently ignores 0's and names that do not correspond to +// existing textures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteTextures is available in GL version 2.0 or greater. +func (gl *GL) DeleteTextures(textures []glbase.Texture) { + n := len(textures) + if n == 0 { + return + } + C.gl4_1compat_glDeleteTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindTexture.xml +func (gl *GL) BindTexture(target glbase.Enum, texture glbase.Texture) { + C.gl4_1compat_glBindTexture(gl.funcs, C.GLenum(target), C.GLuint(texture)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexSubImage2D.xml +func (gl *GL) TexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexSubImage1D.xml +func (gl *GL) TexSubImage1D(target glbase.Enum, level, xoffset, width int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexSubImage2D.xml +func (gl *GL) CopyTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, x, y, width, height int) { + C.gl4_1compat_glCopyTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexSubImage1D.xml +func (gl *GL) CopyTexSubImage1D(target glbase.Enum, level, xoffset, x, y, width int) { + C.gl4_1compat_glCopyTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexImage2D.xml +func (gl *GL) CopyTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, height, border int) { + C.gl4_1compat_glCopyTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexImage1D.xml +func (gl *GL) CopyTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, border int) { + C.gl4_1compat_glCopyTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPolygonOffset.xml +func (gl *GL) PolygonOffset(factor, units float32) { + C.gl4_1compat_glPolygonOffset(gl.funcs, C.GLfloat(factor), C.GLfloat(units)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElements.xml +func (gl *GL) DrawElements(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glDrawElements(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawArrays.xml +func (gl *GL) DrawArrays(mode glbase.Enum, first, count int) { + C.gl4_1compat_glDrawArrays(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexSubImage3D.xml +func (gl *GL) CopyTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, x, y, width, height int) { + C.gl4_1compat_glCopyTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexSubImage3D.xml +func (gl *GL) TexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage3D.xml +func (gl *GL) TexImage3D(target glbase.Enum, level int, internalFormat int32, width, height int, depth int32, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawRangeElements.xml +func (gl *GL) DrawRangeElements(mode glbase.Enum, start, end uint32, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glDrawRangeElements(gl.funcs, C.GLenum(mode), C.GLuint(start), C.GLuint(end), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendEquation.xml +func (gl *GL) BlendEquation(mode glbase.Enum) { + C.gl4_1compat_glBlendEquation(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendColor.xml +func (gl *GL) BlendColor(red, green, blue, alpha float32) { + C.gl4_1compat_glBlendColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetCompressedTexImage.xml +func (gl *GL) GetCompressedTexImage(target glbase.Enum, level int, img interface{}) { + var img_ptr unsafe.Pointer + var img_v = reflect.ValueOf(img) + if img != nil && img_v.Kind() != reflect.Slice { + panic("parameter img must be a slice") + } + if img != nil { + img_ptr = unsafe.Pointer(img_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glGetCompressedTexImage(gl.funcs, C.GLenum(target), C.GLint(level), img_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexSubImage1D.xml +func (gl *GL) CompressedTexSubImage1D(target glbase.Enum, level, xoffset, width int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glCompressedTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexSubImage2D.xml +func (gl *GL) CompressedTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glCompressedTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexSubImage3D.xml +func (gl *GL) CompressedTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glCompressedTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexImage1D.xml +func (gl *GL) CompressedTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, width, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glCompressedTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexImage2D.xml +func (gl *GL) CompressedTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glCompressedTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexImage3D.xml +func (gl *GL) CompressedTexImage3D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height int, depth int32, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glCompressedTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSampleCoverage.xml +func (gl *GL) SampleCoverage(value float32, invert bool) { + C.gl4_1compat_glSampleCoverage(gl.funcs, C.GLfloat(value), *(*C.GLboolean)(unsafe.Pointer(&invert))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glActiveTexture.xml +func (gl *GL) ActiveTexture(texture glbase.Enum) { + C.gl4_1compat_glActiveTexture(gl.funcs, C.GLenum(texture)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointParameteriv.xml +func (gl *GL) PointParameteriv(pname glbase.Enum, params []int32) { + C.gl4_1compat_glPointParameteriv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointParameteri.xml +func (gl *GL) PointParameteri(pname glbase.Enum, param int32) { + C.gl4_1compat_glPointParameteri(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointParameterfv.xml +func (gl *GL) PointParameterfv(pname glbase.Enum, params []float32) { + C.gl4_1compat_glPointParameterfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointParameterf.xml +func (gl *GL) PointParameterf(pname glbase.Enum, param float32) { + C.gl4_1compat_glPointParameterf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiDrawArrays.xml +func (gl *GL) MultiDrawArrays(mode glbase.Enum, first, count []int, drawcount int32) { + C.gl4_1compat_glMultiDrawArrays(gl.funcs, C.GLenum(mode), (*C.GLint)(unsafe.Pointer(&first[0])), (*C.GLsizei)(unsafe.Pointer(&count[0])), C.GLsizei(drawcount)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFuncSeparate.xml +func (gl *GL) BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha glbase.Enum) { + C.gl4_1compat_glBlendFuncSeparate(gl.funcs, C.GLenum(sfactorRGB), C.GLenum(dfactorRGB), C.GLenum(sfactorAlpha), C.GLenum(dfactorAlpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBufferParameteriv.xml +func (gl *GL) GetBufferParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_1compat_glGetBufferParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUnmapBuffer.xml +func (gl *GL) UnmapBuffer(target glbase.Enum) bool { + glresult := C.gl4_1compat_glUnmapBuffer(gl.funcs, C.GLenum(target)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBufferSubData.xml +func (gl *GL) GetBufferSubData(target glbase.Enum, offset, size int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glGetBufferSubData(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(size), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBufferSubData.xml +func (gl *GL) BufferSubData(target glbase.Enum, offset, size int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glBufferSubData(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(size), data_ptr) +} + +// BufferData creates a new data store for the buffer object currently +// bound to target. Any pre-existing data store is deleted. The new data +// store is created with the specified size in bytes and usage. If data is +// not nil, it must be a slice that is used to initialize the data store. +// In that case the size parameter is ignored and the store size will match +// the slice data size. +// +// In its initial state, the new data store is not mapped, it has a NULL +// mapped pointer, and its mapped access is GL.READ_WRITE. +// +// The target constant must be one of GL.ARRAY_BUFFER, GL.COPY_READ_BUFFER, +// GL.COPY_WRITE_BUFFER, GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER, +// GL.PIXEL_UNPACK_BUFFER, GL.TEXTURE_BUFFER, GL.TRANSFORM_FEEDBACK_BUFFER, +// or GL.UNIFORM_BUFFER. +// +// The usage parameter is a hint to the GL implementation as to how a buffer +// object's data store will be accessed. This enables the GL implementation +// to make more intelligent decisions that may significantly impact buffer +// object performance. It does not, however, constrain the actual usage of +// the data store. usage can be broken down into two parts: first, the +// frequency of access (modification and usage), and second, the nature of +// that access. +// +// A usage frequency of STREAM and nature of DRAW is specified via the +// constant GL.STREAM_DRAW, for example. +// +// The usage frequency of access may be one of: +// +// STREAM +// The data store contents will be modified once and used at most a few times. +// +// STATIC +// The data store contents will be modified once and used many times. +// +// DYNAMIC +// The data store contents will be modified repeatedly and used many times. +// +// The usage nature of access may be one of: +// +// DRAW +// The data store contents are modified by the application, and used as +// the source for GL drawing and image specification commands. +// +// READ +// The data store contents are modified by reading data from the GL, +// and used to return that data when queried by the application. +// +// COPY +// The data store contents are modified by reading data from the GL, +// and used as the source for GL drawing and image specification +// commands. +// +// Clients must align data elements consistent with the requirements of the +// client platform, with an additional base-level requirement that an offset +// within a buffer to a datum comprising N bytes be a multiple of N. +// +// Error GL.INVALID_ENUM is generated if target is not one of the accepted +// buffer targets. GL.INVALID_ENUM is generated if usage is not +// GL.STREAM_DRAW, GL.STREAM_READ, GL.STREAM_COPY, GL.STATIC_DRAW, +// GL.STATIC_READ, GL.STATIC_COPY, GL.DYNAMIC_DRAW, GL.DYNAMIC_READ, or +// GL.DYNAMIC_COPY. GL.INVALID_VALUE is generated if size is negative. +// GL.INVALID_OPERATION is generated if the reserved buffer object name 0 is +// bound to target. GL.OUT_OF_MEMORY is generated if the GL is unable to +// create a data store with the specified size. +func (gl *GL) BufferData(target glbase.Enum, size int, data interface{}, usage glbase.Enum) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + if data != nil { + size = int(data_v.Type().Size()) * data_v.Len() + } + C.gl4_1compat_glBufferData(gl.funcs, C.GLenum(target), C.GLsizeiptr(size), data_ptr, C.GLenum(usage)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsBuffer.xml +func (gl *GL) IsBuffer(buffer glbase.Buffer) bool { + glresult := C.gl4_1compat_glIsBuffer(gl.funcs, C.GLuint(buffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenBuffers returns n buffer object names. There is no guarantee that +// the names form a contiguous set of integers; however, it is guaranteed +// that none of the returned names was in use immediately before the call to +// GenBuffers. +// +// Buffer object names returned by a call to GenBuffers are not returned by +// subsequent calls, unless they are first deleted with DeleteBuffers. +// +// No buffer objects are associated with the returned buffer object names +// until they are first bound by calling BindBuffer. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if GenBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// GenBuffers is available in GL version 1.5 or greater. +func (gl *GL) GenBuffers(n int) []glbase.Buffer { + if n == 0 { + return nil + } + buffers := make([]glbase.Buffer, n) + C.gl4_1compat_glGenBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) + return buffers +} + +// DeleteBuffers deletes the buffer objects whose names are stored in the +// buffers slice. +// +// After a buffer object is deleted, it has no contents, and its name is free +// for reuse (for example by GenBuffers). If a buffer object that is +// currently bound is deleted, the binding reverts to 0 (the absence of any +// buffer object, which reverts to client memory usage). +// +// DeleteBuffers silently ignores 0's and names that do not correspond to +// existing buffer objects. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if DeleteBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// DeleteBuffers is available in GL version 1.5 or greater. +func (gl *GL) DeleteBuffers(buffers []glbase.Buffer) { + n := len(buffers) + if n == 0 { + return + } + C.gl4_1compat_glDeleteBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) +} + +// BindBuffer creates or puts in use a named buffer object. +// Calling BindBuffer with target set to GL.ARRAY_BUFFER, +// GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER or GL.PIXEL_UNPACK_BUFFER +// and buffer set to the name of the new buffer object binds the buffer +// object name to the target. When a buffer object is bound to a target, the +// previous binding for that target is automatically broken. +// +// Buffer object names are unsigned integers. The value zero is reserved, but +// there is no default buffer object for each buffer object target. Instead, +// buffer set to zero effectively unbinds any buffer object previously bound, +// and restores client memory usage for that buffer object target. Buffer +// object names and the corresponding buffer object contents are local to the +// shared display-list space (see XCreateContext) of the current GL rendering +// context; two rendering contexts share buffer object names only if they +// also share display lists. +// +// GenBuffers may be called to generate a set of new buffer object names. +// +// The state of a buffer object immediately after it is first bound is an +// unmapped zero-sized memory buffer with GL.READ_WRITE access and +// GL.STATIC_DRAW usage. +// +// While a non-zero buffer object name is bound, GL operations on the target +// to which it is bound affect the bound buffer object, and queries of the +// target to which it is bound return state from the bound buffer object. +// While buffer object name zero is bound, as in the initial state, attempts +// to modify or query state on the target to which it is bound generates an +// GL.INVALID_OPERATION error. +// +// When vertex array pointer state is changed, for example by a call to +// NormalPointer, the current buffer object binding (GL.ARRAY_BUFFER_BINDING) +// is copied into the corresponding client state for the vertex array type +// being changed, for example GL.NORMAL_ARRAY_BUFFER_BINDING. While a +// non-zero buffer object is bound to the GL.ARRAY_BUFFER target, the vertex +// array pointer parameter that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.ELEMENT_ARRAY_BUFFER +// target, the indices parameter of DrawElements, DrawRangeElements, or +// MultiDrawElements that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_PACK_BUFFER +// target, the following commands are affected: GetCompressedTexImage, +// GetConvolutionFilter, GetHistogram, GetMinmax, GetPixelMap, +// GetPolygonStipple, GetSeparableFilter, GetTexImage, and ReadPixels. The +// pointer parameter that is traditionally interpreted as a pointer to +// client-side memory where the pixels are to be packed is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_UNPACK_BUFFER +// target, the following commands are affected: Bitmap, ColorSubTable, +// ColorTable, CompressedTexImage1D, CompressedTexImage2D, +// CompressedTexImage3D, CompressedTexSubImage1D, CompressedTexSubImage2D, +// CompressedTexSubImage3D, ConvolutionFilter1D, ConvolutionFilter2D, +// DrawPixels, PixelMap, PolygonStipple, SeparableFilter2D, TexImage1D, +// TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, and TexSubImage3D. +// The pointer parameter that is traditionally interpreted as a pointer to +// client-side memory from which the pixels are to be unpacked is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// A buffer object binding created with BindBuffer remains active until a +// different buffer object name is bound to the same target, or until the +// bound buffer object is deleted with DeleteBuffers. +// +// Once created, a named buffer object may be re-bound to any target as often +// as needed. However, the GL implementation may make choices about how to +// optimize the storage of a buffer object based on its initial binding +// target. +// +// Error GL.INVALID_ENUM is generated if target is not one of the allowable +// values. GL.INVALID_OPERATION is generated if BindBuffer is executed +// between the execution of Begin and the corresponding execution of End. +// +// BindBuffer is available in GL version 1.5 or greater. +func (gl *GL) BindBuffer(target glbase.Enum, buffer glbase.Buffer) { + C.gl4_1compat_glBindBuffer(gl.funcs, C.GLenum(target), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryObjectuiv.xml +func (gl *GL) GetQueryObjectuiv(id uint32, pname glbase.Enum, params []uint32) { + C.gl4_1compat_glGetQueryObjectuiv(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryObjectiv.xml +func (gl *GL) GetQueryObjectiv(id uint32, pname glbase.Enum, params []int32) { + C.gl4_1compat_glGetQueryObjectiv(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryiv.xml +func (gl *GL) GetQueryiv(target, pname glbase.Enum, params []int32) { + C.gl4_1compat_glGetQueryiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndQuery.xml +func (gl *GL) EndQuery(target glbase.Enum) { + C.gl4_1compat_glEndQuery(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBeginQuery.xml +func (gl *GL) BeginQuery(target glbase.Enum, id uint32) { + C.gl4_1compat_glBeginQuery(gl.funcs, C.GLenum(target), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsQuery.xml +func (gl *GL) IsQuery(id uint32) bool { + glresult := C.gl4_1compat_glIsQuery(gl.funcs, C.GLuint(id)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteQueries.xml +func (gl *GL) DeleteQueries(n int, ids []uint32) { + C.gl4_1compat_glDeleteQueries(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenQueries.xml +func (gl *GL) GenQueries(n int, ids []uint32) { + C.gl4_1compat_glGenQueries(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// VertexAttribPointer specifies the location and data format of the array +// of generic vertex attributes at index to use when rendering. size +// specifies the number of components per attribute and must be 1, 2, 3, or +// 4. type specifies the data type of each component, and stride specifies +// the byte stride from one attribute to the next, allowing vertices and +// attributes to be packed into a single array or stored in separate arrays. +// normalized indicates whether the values stored in an integer format are +// to be mapped to the range [-1,1] (for signed values) or [0,1] +// (for unsigned values) when they are accessed and converted to floating +// point; otherwise, values will be converted to floats directly without +// normalization. offset is a byte offset into the buffer object's data +// store, which must be bound to the GL.ARRAY_BUFFER target with BindBuffer. +// +// The buffer object binding (GL.ARRAY_BUFFER_BINDING) is saved as +// generic vertex attribute array client-side state +// (GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING) for the provided index. +// +// To enable and disable a generic vertex attribute array, call +// EnableVertexAttribArray and DisableVertexAttribArray with index. If +// enabled, the generic vertex attribute array is used when DrawArrays or +// DrawElements is called. Each generic vertex attribute array is initially +// disabled. +// +// VertexAttribPointer is typically implemented on the client side. +// +// Error GL.INVALID_ENUM is generated if type is not an accepted value. +// GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_VALUE is generated if size is not 1, 2, +// 3, or 4. GL.INVALID_VALUE is generated if stride is negative. +func (gl *GL) VertexAttribPointer(index glbase.Attrib, size int, gltype glbase.Enum, normalized bool, stride int, offset uintptr) { + offset_ptr := unsafe.Pointer(offset) + C.gl4_1compat_glVertexAttribPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLsizei(stride), offset_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glValidateProgram.xml +func (gl *GL) ValidateProgram(program glbase.Program) { + C.gl4_1compat_glValidateProgram(gl.funcs, C.GLuint(program)) +} + +// UniformMatrix4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*4) != 0 { + panic("invalid value length for UniformMatrix4fv") + } + count := len(value) / (4 * 4) + C.gl4_1compat_glUniformMatrix4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*3) != 0 { + panic("invalid value length for UniformMatrix3fv") + } + count := len(value) / (3 * 3) + C.gl4_1compat_glUniformMatrix3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*2) != 0 { + panic("invalid value length for UniformMatrix2fv") + } + count := len(value) / (2 * 2) + C.gl4_1compat_glUniformMatrix2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform4iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4iv") + } + count := len(value) / 4 + C.gl4_1compat_glUniform4iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform3iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3iv") + } + count := len(value) / 3 + C.gl4_1compat_glUniform3iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform2iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2iv") + } + count := len(value) / 2 + C.gl4_1compat_glUniform2iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform1iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl4_1compat_glUniform1iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4fv") + } + count := len(value) / 4 + C.gl4_1compat_glUniform4fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3fv") + } + count := len(value) / 3 + C.gl4_1compat_glUniform3fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2fv") + } + count := len(value) / 2 + C.gl4_1compat_glUniform2fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform1fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl4_1compat_glUniform1fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform4i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4i(location glbase.Uniform, v0, v1, v2, v3 int32) { + C.gl4_1compat_glUniform4i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2), C.GLint(v3)) +} + +// Uniform3i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3i(location glbase.Uniform, v0, v1, v2 int32) { + C.gl4_1compat_glUniform3i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2)) +} + +// Uniform2i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2i(location glbase.Uniform, v0, v1 int32) { + C.gl4_1compat_glUniform2i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1)) +} + +// Uniform1i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1i(location glbase.Uniform, v0 int32) { + C.gl4_1compat_glUniform1i(gl.funcs, C.GLint(location), C.GLint(v0)) +} + +// Uniform4f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4f(location glbase.Uniform, v0, v1, v2, v3 float32) { + C.gl4_1compat_glUniform4f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2), C.GLfloat(v3)) +} + +// Uniform3f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3f(location glbase.Uniform, v0, v1, v2 float32) { + C.gl4_1compat_glUniform3f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2)) +} + +// Uniform2f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2f(location glbase.Uniform, v0, v1 float32) { + C.gl4_1compat_glUniform2f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1)) +} + +// Uniform1f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1f(location glbase.Uniform, v0 float32) { + C.gl4_1compat_glUniform1f(gl.funcs, C.GLint(location), C.GLfloat(v0)) +} + +// UseProgram installs the program object specified by program as part of +// current rendering state. One or more executables are created in a program +// object by successfully attaching shader objects to it with AttachShader, +// successfully compiling the shader objects with CompileShader, and +// successfully linking the program object with LinkProgram. +// +// A program object will contain an executable that will run on the vertex +// processor if it contains one or more shader objects of type +// GL.VERTEX_SHADER that have been successfully compiled and linked. +// Similarly, a program object will contain an executable that will run on +// the fragment processor if it contains one or more shader objects of type +// GL.FRAGMENT_SHADER that have been successfully compiled and linked. +// +// Successfully installing an executable on a programmable processor will +// cause the corresponding fixed functionality of OpenGL to be disabled. +// Specifically, if an executable is installed on the vertex processor, the +// OpenGL fixed functionality will be disabled as follows. +// +// - The modelview matrix is not applied to vertex coordinates. +// +// - The projection matrix is not applied to vertex coordinates. +// +// - The texture matrices are not applied to texture coordinates. +// +// - Normals are not transformed to eye coordinates. +// +// - Normals are not rescaled or normalized. +// +// - Normalization of GL.AUTO_NORMAL evaluated normals is not performed. +// +// - Texture coordinates are not generated automatically. +// +// - Per-vertex lighting is not performed. +// +// - Color material computations are not performed. +// +// - Color index lighting is not performed. +// +// - This list also applies when setting the current raster position. +// +// The executable that is installed on the vertex processor is expected to +// implement any or all of the desired functionality from the preceding list. +// Similarly, if an executable is installed on the fragment processor, the +// OpenGL fixed functionality will be disabled as follows. +// +// - Texture environment and texture functions are not applied. +// +// - Texture application is not applied. +// +// - Color sum is not applied. +// +// - Fog is not applied. +// +// Again, the fragment shader that is installed is expected to implement any +// or all of the desired functionality from the preceding list. +// +// While a program object is in use, applications are free to modify attached +// shader objects, compile attached shader objects, attach additional shader +// objects, and detach or delete shader objects. None of these operations +// will affect the executables that are part of the current state. However, +// relinking the program object that is currently in use will install the +// program object as part of the current rendering state if the link +// operation was successful (see LinkProgram). If the program object +// currently in use is relinked unsuccessfully, its link status will be set +// to GL.FALSE, but the executables and associated state will remain part of +// the current state until a subsequent call to UseProgram removes it from +// use. After it is removed from use, it cannot be made part of current state +// until it has been successfully relinked. +// +// If program contains shader objects of type GL.VERTEX_SHADER but it does +// not contain shader objects of type GL.FRAGMENT_SHADER, an executable will +// be installed on the vertex processor, but fixed functionality will be used +// for fragment processing. Similarly, if program contains shader objects of +// type GL.FRAGMENT_SHADER but it does not contain shader objects of type +// GL.VERTEX_SHADER, an executable will be installed on the fragment +// processor, but fixed functionality will be used for vertex processing. If +// program is 0, the programmable processors will be disabled, and fixed +// functionality will be used for both vertex and fragment processing. +// +// While a program object is in use, the state that controls the disabled +// fixed functionality may also be updated using the normal OpenGL calls. +// +// Like display lists and texture objects, the name space for program objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// Applications are responsible for providing the synchronization across API +// calls when objects are accessed from different execution threads. +// +// Error GL.INVALID_VALUE is generated if program is neither 0 nor a value +// generated by OpenGL. GL.INVALID_OPERATION is generated if program is not +// a program object. GL.INVALID_OPERATION is generated if program could not +// be made part of current state. GL.INVALID_OPERATION is generated if +// UseProgram is executed between the execution of Begin and the +// corresponding execution of End. +// +// UseProgram is available in GL version 2.0 or greater. +func (gl *GL) UseProgram(program glbase.Program) { + C.gl4_1compat_glUseProgram(gl.funcs, C.GLuint(program)) +} + +// ShaderSource sets the source code in shader to the provided source code. Any source +// code previously stored in the shader object is completely replaced. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_VALUE is generated if count is less than 0. +// GL.INVALID_OPERATION is generated if ShaderSource is executed between the +// execution of Begin and the corresponding execution of End. +// +// ShaderSource is available in GL version 2.0 or greater. +func (gl *GL) ShaderSource(shader glbase.Shader, source ...string) { + count := len(source) + length := make([]int32, count) + source_c := make([]unsafe.Pointer, count) + for i, src := range source { + length[i] = int32(len(src)) + if len(src) > 0 { + source_c[i] = *(*unsafe.Pointer)(unsafe.Pointer(&src)) + } else { + source_c[i] = unsafe.Pointer(uintptr(0)) + } + } + C.gl4_1compat_glShaderSource(gl.funcs, C.GLuint(shader), C.GLsizei(count), (**C.GLchar)(unsafe.Pointer(&source_c[0])), (*C.GLint)(unsafe.Pointer(&length[0]))) +} + +// LinkProgram links the program object specified by program. If any shader +// objects of type GL.VERTEX_SHADER are attached to program, they will be +// used to create an executable that will run on the programmable vertex +// processor. If any shader objects of type GL.FRAGMENT_SHADER are attached +// to program, they will be used to create an executable that will run on the +// programmable fragment processor. +// +// The status of the link operation will be stored as part of the program +// object's state. This value will be set to GL.TRUE if the program object +// was linked without errors and is ready for use, and GL.FALSE otherwise. It +// can be queried by calling GetProgramiv with arguments program and +// GL.LINK_STATUS. +// +// As a result of a successful link operation, all active user-defined +// uniform variables belonging to program will be initialized to 0, and each +// of the program object's active uniform variables will be assigned a +// location that can be queried by calling GetUniformLocation. Also, any +// active user-defined attribute variables that have not been bound to a +// generic vertex attribute index will be bound to one at this time. +// +// Linking of a program object can fail for a number of reasons as specified +// in the OpenGL Shading Language Specification. The following lists some of +// the conditions that will cause a link error. +// +// - The number of active attribute variables supported by the +// implementation has been exceeded. +// +// - The storage limit for uniform variables has been exceeded. +// +// - The number of active uniform variables supported by the implementation +// has been exceeded. +// +// - The main function is missing for the vertex shader or the fragment +// shader. +// +// - A varying variable actually used in the fragment shader is not +// declared in the same way (or is not declared at all) in the vertex +// shader. +// +// - A reference to a function or variable name is unresolved. +// +// - A shared global is declared with two different types or two different +// initial values. +// +// - One or more of the attached shader objects has not been successfully +// compiled. +// +// - Binding a generic attribute matrix caused some rows of the matrix to +// fall outside the allowed maximum of GL.MAX_VERTEX_ATTRIBS. +// +// - Not enough contiguous vertex attribute slots could be found to bind +// attribute matrices. +// +// When a program object has been successfully linked, the program object can +// be made part of current state by calling UseProgram. Whether or not the +// link operation was successful, the program object's information log will +// be overwritten. The information log can be retrieved by calling +// GetProgramInfoLog. +// +// LinkProgram will also install the generated executables as part of the +// current rendering state if the link operation was successful and the +// specified program object is already currently in use as a result of a +// previous call to UseProgram. If the program object currently in use is +// relinked unsuccessfully, its link status will be set to GL.FALSE , but the +// executables and associated state will remain part of the current state +// until a subsequent call to UseProgram removes it from use. After it is +// removed from use, it cannot be made part of current state until it has +// been successfully relinked. +// +// If program contains shader objects of type GL.VERTEX_SHADER but does not +// contain shader objects of type GL.FRAGMENT_SHADER, the vertex shader will +// be linked against the implicit interface for fixed functionality fragment +// processing. Similarly, if program contains shader objects of type +// GL.FRAGMENT_SHADER but it does not contain shader objects of type +// GL.VERTEX_SHADER, the fragment shader will be linked against the implicit +// interface for fixed functionality vertex processing. +// +// The program object's information log is updated and the program is +// generated at the time of the link operation. After the link operation, +// applications are free to modify attached shader objects, compile attached +// shader objects, detach shader objects, delete shader objects, and attach +// additional shader objects. None of these operations affects the +// information log or the program that is part of the program object. +// +// If the link operation is unsuccessful, any information about a previous +// link operation on program is lost (a failed link does not restore the +// old state of program). Certain information can still be retrieved +// from program even after an unsuccessful link operation. See for instance +// GetActiveAttrib and GetActiveUniform. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if LinkProgram is executed +// between the execution of Begin and the corresponding execution of End. +// +// LinkProgram is available in GL version 2.0 or greater. +func (gl *GL) LinkProgram(program glbase.Program) { + C.gl4_1compat_glLinkProgram(gl.funcs, C.GLuint(program)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsShader.xml +func (gl *GL) IsShader(shader glbase.Shader) bool { + glresult := C.gl4_1compat_glIsShader(gl.funcs, C.GLuint(shader)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsProgram.xml +func (gl *GL) IsProgram(program glbase.Program) bool { + glresult := C.gl4_1compat_glIsProgram(gl.funcs, C.GLuint(program)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GetVertexAttribiv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribiv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribiv(index glbase.Attrib, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl4_1compat_glGetVertexAttribiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetVertexAttribfv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribfv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribfv(index glbase.Attrib, pname glbase.Enum, params []float32) { + var params_c [4]float32 + C.gl4_1compat_glGetVertexAttribfv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetVertexAttribdv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribdv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribdv(index glbase.Attrib, pname glbase.Enum, params []float64) { + var params_c [4]float64 + C.gl4_1compat_glGetVertexAttribdv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformiv returns in params the value of the specified uniform +// variable. The type of the uniform variable specified by location +// determines the number of values returned. If the uniform variable is +// defined in the shader as a boolean, int, or float, a single value will be +// returned. If it is defined as a vec2, ivec2, or bvec2, two values will be +// returned. If it is defined as a vec3, ivec3, or bvec3, three values will +// be returned, and so on. To query values stored in uniform variables +// declared as arrays, call GetUniformiv for each element of the array. To +// query values stored in uniform variables declared as structures, call +// GetUniformiv for each field in the structure. The values for uniform +// variables declared as a matrix will be returned in column major order. +// +// The locations assigned to uniform variables are not known until the +// program object is linked. After linking has occurred, the command +// GetUniformLocation can be used to obtain the location of a uniform +// variable. This location value can then be passed to GetUniformiv in order +// to query the current value of the uniform variable. After a program object +// has been linked successfully, the index values for uniform variables +// remain fixed until the next link command occurs. The uniform variable +// values can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if program has not been +// successfully linked. GL.INVALID_OPERATION is generated if location does +// not correspond to a valid uniform variable location for the specified +// program object. GL.INVALID_OPERATION is generated if GetUniformiv is +// executed between the execution of Begin and the corresponding execution of +// End. +// +// GetUniformiv is available in GL version 2.0 or greater. +func (gl *GL) GetUniformiv(program glbase.Program, location glbase.Uniform, params []int32) { + var params_c [4]int32 + C.gl4_1compat_glGetUniformiv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformfv returns in params the value of the specified uniform +// variable. The type of the uniform variable specified by location +// determines the number of values returned. If the uniform variable is +// defined in the shader as a boolean, int, or float, a single value will be +// returned. If it is defined as a vec2, ivec2, or bvec2, two values will be +// returned. If it is defined as a vec3, ivec3, or bvec3, three values will +// be returned, and so on. To query values stored in uniform variables +// declared as arrays, call GetUniformfv for each element of the array. To +// query values stored in uniform variables declared as structures, call +// GetUniformfv for each field in the structure. The values for uniform +// variables declared as a matrix will be returned in column major order. +// +// The locations assigned to uniform variables are not known until the +// program object is linked. After linking has occurred, the command +// GetUniformLocation can be used to obtain the location of a uniform +// variable. This location value can then be passed to GetUniformfv in order +// to query the current value of the uniform variable. After a program object +// has been linked successfully, the index values for uniform variables +// remain fixed until the next link command occurs. The uniform variable +// values can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if program has not been +// successfully linked. GL.INVALID_OPERATION is generated if location does +// not correspond to a valid uniform variable location for the specified +// program object. GL.INVALID_OPERATION is generated if GetUniformfv is +// executed between the execution of Begin and the corresponding execution of +// End. +// +// GetUniformfv is available in GL version 2.0 or greater. +func (gl *GL) GetUniformfv(program glbase.Program, location glbase.Uniform, params []float32) { + var params_c [4]float32 + C.gl4_1compat_glGetUniformfv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLfloat)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformLocation returns an integer that represents the location of a +// specific uniform variable within a program object. name must be an active +// uniform variable name in program that is not a structure, an array of +// structures, or a subcomponent of a vector or a matrix. This function +// returns -1 if name does not correspond to an active uniform variable in +// program or if name starts with the reserved prefix "gl_". +// +// Uniform variables that are structures or arrays of structures may be +// queried by calling GetUniformLocation for each field within the +// structure. The array element operator "[]" and the structure field +// operator "." may be used in name in order to select elements within an +// array or fields within a structure. The result of using these operators is +// not allowed to be another structure, an array of structures, or a +// subcomponent of a vector or a matrix. Except if the last part of name +// indicates a uniform variable array, the location of the first element of +// an array can be retrieved by using the name of the array, or by using the +// name appended by "[0]". +// +// The actual locations assigned to uniform variables are not known until the +// program object is linked successfully. After linking has occurred, the +// command GetUniformLocation can be used to obtain the location of a +// uniform variable. This location value can then be passed to Uniform to +// set the value of the uniform variable or to GetUniform in order to query +// the current value of the uniform variable. After a program object has been +// linked successfully, the index values for uniform variables remain fixed +// until the next link command occurs. Uniform variable locations and values +// can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program object. +// GL.INVALID_OPERATION is generated if program has not been successfully +// linked. GL.INVALID_OPERATION is generated if GetUniformLocation is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetUniformLocation is available in GL version 2.0 or greater. +func (gl *GL) GetUniformLocation(program glbase.Program, name string) glbase.Uniform { + name_cstr := C.CString(name) + glresult := C.gl4_1compat_glGetUniformLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) + return glbase.Uniform(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetShaderSource.xml +func (gl *GL) GetShaderSource(shader glbase.Shader, bufSize int32, length []int32, source []byte) { + C.gl4_1compat_glGetShaderSource(gl.funcs, C.GLuint(shader), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&source[0]))) +} + +// GetShaderInfoLog returns the information log for the specified shader +// object. The information log for a shader object is modified when the +// shader is compiled. +// +// The information log for a shader object is a string that may contain +// diagnostic messages, warning messages, and other information about the +// last compile operation. When a shader object is created, its information +// log will be a string of length 0, and the size of the current log can be +// obtained by calling GetShaderiv with the value GL.INFO_LOG_LENGTH. +// +// The information log for a shader object is the OpenGL implementer's +// primary mechanism for conveying information about the compilation process. +// Therefore, the information log can be helpful to application developers +// during the development process, even when compilation is successful. +// Application developers should not expect different OpenGL implementations +// to produce identical information logs. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_VALUE is generated if maxLength is less than 0. +// GL.INVALID_OPERATION is generated if GetShaderInfoLog is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetShaderInfoLog is available in GL version 2.0 or greater. +func (gl *GL) GetShaderInfoLog(shader glbase.Shader) []byte { + var params [1]int32 + var length int32 + gl.GetShaderiv(shader, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + C.gl4_1compat_glGetShaderInfoLog(gl.funcs, C.GLuint(shader), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length)), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) + return infoLog +} + +// GetShaderiv GetShader returns in params the value of a parameter for a specific +// shader object. The following parameters are defined: +// +// GL.SHADER_TYPE +// params returns GL.VERTEX_SHADER if shader is a vertex shader object, +// and GL.FRAGMENT_SHADER if shader is a fragment shader object. +// +// GL.DELETE_STATUS +// params returns GL.TRUE if shader is currently flagged for deletion, +// and GL.FALSE otherwise. +// +// GL.COMPILE_STATUS +// params returns GL.TRUE if the last compile operation on shader was +// successful, and GL.FALSE otherwise. +// +// GL.INFO_LOG_LENGTH +// params returns the number of characters in the information log for +// shader including the null termination character (the size of the +// character buffer required to store the information log). If shader has +// no information log, a value of 0 is returned. +// +// GL.SHADER_SOURCE_LENGTH +// params returns the length of the concatenation of the source strings +// that make up the shader source for the shader, including the null +// termination character. (the size of the character buffer +// required to store the shader source). If no source code exists, 0 is +// returned. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader does not refer to a +// shader object. GL.INVALID_ENUM is generated if pname is not an accepted +// value. GL.INVALID_OPERATION is generated if GetShader is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetShaderiv is available in GL version 2.0 or greater. +func (gl *GL) GetShaderiv(shader glbase.Shader, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl4_1compat_glGetShaderiv(gl.funcs, C.GLuint(shader), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetProgramInfoLog returns the information log for the specified program +// object. The information log for a program object is modified when the +// program object is linked or validated. +// +// The information log for a program object is either an empty string, or a +// string containing information about the last link operation, or a string +// containing information about the last validation operation. It may contain +// diagnostic messages, warning messages, and other information. When a +// program object is created, its information log will be a string of length +// 0, and the size of the current log can be obtained by calling GetProgramiv +// with the value GL.INFO_LOG_LENGTH. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated +// by OpenGL. GL.INVALID_OPERATION is generated if program is not a +// program object. +func (gl *GL) GetProgramInfoLog(program glbase.Program) []byte { + var params [1]int32 + var length int32 + gl.GetProgramiv(program, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + C.gl4_1compat_glGetProgramInfoLog(gl.funcs, C.GLuint(program), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length)), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) + return infoLog +} + +// GetProgramiv returns in params the value of a parameter for a specific +// program object. The following parameters are defined: +// +// GL.DELETE_STATUS +// params returns GL.TRUE if program is currently flagged for deletion, +// and GL.FALSE otherwise. +// +// GL.LINK_STATUS +// params returns GL.TRUE if the last link operation on program was +// successful, and GL.FALSE otherwise. +// +// GL.VALIDATE_STATUS +// params returns GL.TRUE or if the last validation operation on +// program was successful, and GL.FALSE otherwise. +// +// GL.INFO_LOG_LENGTH +// params returns the number of characters in the information log for +// program including the null termination character (the size of +// the character buffer required to store the information log). If +// program has no information log, a value of 0 is returned. +// +// GL.ATTACHED_SHADERS +// params returns the number of shader objects attached to program. +// +// GL.ACTIVE_ATTRIBUTES +// params returns the number of active attribute variables for program. +// +// GL.ACTIVE_ATTRIBUTE_MAX_LENGTH +// params returns the length of the longest active attribute name for +// program, including the null termination character (the size of +// the character buffer required to store the longest attribute name). +// If no active attributes exist, 0 is returned. +// +// GL.ACTIVE_UNIFORMS +// params returns the number of active uniform variables for program. +// +// GL.ACTIVE_UNIFORM_MAX_LENGTH +// params returns the length of the longest active uniform variable +// name for program, including the null termination character (i.e., +// the size of the character buffer required to store the longest +// uniform variable name). If no active uniform variables exist, 0 is +// returned. +// +// GL.TRANSFORM_FEEDBACK_BUFFER_MODE +// params returns a symbolic constant indicating the buffer mode used +// when transform feedback is active. This may be GL.SEPARATE_ATTRIBS +// or GL.INTERLEAVED_ATTRIBS. +// +// GL.TRANSFORM_FEEDBACK_VARYINGS +// params returns the number of varying variables to capture in transform +// feedback mode for the program. +// +// GL.TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH +// params returns the length of the longest variable name to be used for +// transform feedback, including the null-terminator. +// +// GL.GEOMETRY_VERTICES_OUT +// params returns the maximum number of vertices that the geometry shader in +// program will output. +// +// GL.GEOMETRY_INPUT_TYPE +// params returns a symbolic constant indicating the primitive type accepted +// as input to the geometry shader contained in program. +// +// GL.GEOMETRY_OUTPUT_TYPE +// params returns a symbolic constant indicating the primitive type that will +// be output by the geometry shader contained in program. +// +// GL.ACTIVE_UNIFORM_BLOCKS and GL.ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH are +// available only if the GL version 3.1 or greater. +// +// GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE and +// GL.GEOMETRY_OUTPUT_TYPE are accepted only if the GL version is 3.2 or +// greater. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program does not refer to a +// program object. GL.INVALID_OPERATION is generated if pname is +// GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE, or +// GL.GEOMETRY_OUTPUT_TYPE, and program does not contain a geometry shader. +// GL.INVALID_ENUM is generated if pname is not an accepted value. +func (gl *GL) GetProgramiv(program glbase.Program, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl4_1compat_glGetProgramiv(gl.funcs, C.GLuint(program), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetAttribLocation queries the previously linked program object specified +// by program for the attribute variable specified by name and returns the +// index of the generic vertex attribute that is bound to that attribute +// variable. If name is a matrix attribute variable, the index of the first +// column of the matrix is returned. If the named attribute variable is not +// an active attribute in the specified program object or if name starts with +// the reserved prefix "gl_", a value of -1 is returned. +// +// The association between an attribute variable name and a generic attribute +// index can be specified at any time by calling BindAttribLocation. +// Attribute bindings do not go into effect until LinkProgram is called. +// After a program object has been linked successfully, the index values for +// attribute variables remain fixed until the next link command occurs. The +// attribute values can only be queried after a link if the link was +// successful. GetAttribLocation returns the binding that actually went +// into effect the last time LinkProgram was called for the specified +// program object. Attribute bindings that have been specified since the last +// link operation are not returned by GetAttribLocation. +// +// Error GL_INVALID_OPERATION is generated if program is not a value +// generated by OpenGL. GL_INVALID_OPERATION is generated if program is not +// a program object. GL_INVALID_OPERATION is generated if program has not +// been successfully linked. GL_INVALID_OPERATION is generated if +// GetAttribLocation is executed between the execution of Begin and the +// corresponding execution of End. +// +// GetAttribLocation is available in GL version 2.0 or greater. +func (gl *GL) GetAttribLocation(program glbase.Program, name string) glbase.Attrib { + name_cstr := C.CString(name) + glresult := C.gl4_1compat_glGetAttribLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) + return glbase.Attrib(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetAttachedShaders.xml +func (gl *GL) GetAttachedShaders(program glbase.Program, maxCount int32, count []int, obj []uint32) { + C.gl4_1compat_glGetAttachedShaders(gl.funcs, C.GLuint(program), C.GLsizei(maxCount), (*C.GLsizei)(unsafe.Pointer(&count[0])), (*C.GLuint)(unsafe.Pointer(&obj[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniform.xml +func (gl *GL) GetActiveUniform(program glbase.Program, index uint32, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl4_1compat_glGetActiveUniform(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveAttrib.xml +func (gl *GL) GetActiveAttrib(program glbase.Program, index glbase.Attrib, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl4_1compat_glGetActiveAttrib(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEnableVertexAttribArray.xml +func (gl *GL) EnableVertexAttribArray(index glbase.Attrib) { + C.gl4_1compat_glEnableVertexAttribArray(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDisableVertexAttribArray.xml +func (gl *GL) DisableVertexAttribArray(index glbase.Attrib) { + C.gl4_1compat_glDisableVertexAttribArray(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDetachShader.xml +func (gl *GL) DetachShader(program glbase.Program, shader glbase.Shader) { + C.gl4_1compat_glDetachShader(gl.funcs, C.GLuint(program), C.GLuint(shader)) +} + +// DeleteShader frees the memory and invalidates the name associated with +// the shader object specified by shader. This command effectively undoes the +// effects of a call to CreateShader. +// +// If a shader object to be deleted is attached to a program object, it will +// be flagged for deletion, but it will not be deleted until it is no longer +// attached to any program object, for any rendering context (it must +// be detached from wherever it was attached before it will be deleted). A +// value of 0 for shader will be silently ignored. +// +// To determine whether an object has been flagged for deletion, call +// GetShader with arguments shader and GL.DELETE_STATUS. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. +// +// DeleteShader is available in GL version 2.0 or greater. +func (gl *GL) DeleteShader(shader glbase.Shader) { + C.gl4_1compat_glDeleteShader(gl.funcs, C.GLuint(shader)) +} + +// DeleteProgram frees the memory and invalidates the name associated with +// the program object specified by program. This command effectively undoes +// the effects of a call to CreateProgram. +// +// If a program object is in use as part of current rendering state, it will +// be flagged for deletion, but it will not be deleted until it is no longer +// part of current state for any rendering context. If a program object to be +// deleted has shader objects attached to it, those shader objects will be +// automatically detached but not deleted unless they have already been +// flagged for deletion by a previous call to DeleteShader. A value of 0 +// for program will be silently ignored. +// +// To determine whether a program object has been flagged for deletion, call +// GetProgram with arguments program and GL.DELETE_STATUS. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. +// +// DeleteProgram is available in GL version 2.0 or greater. +func (gl *GL) DeleteProgram(program glbase.Program) { + C.gl4_1compat_glDeleteProgram(gl.funcs, C.GLuint(program)) +} + +// CreateShader creates an empty shader object and returns a non-zero value +// by which it can be referenced. A shader object is used to maintain the +// source code strings that define a shader. shaderType indicates the type of +// shader to be created. +// +// Two types of shaders are supported. A shader of type GL.VERTEX_SHADER is a +// shader that is intended to run on the programmable vertex processor and +// replace the fixed functionality vertex processing in OpenGL. A shader of +// type GL.FRAGMENT_SHADER is a shader that is intended to run on the +// programmable fragment processor and replace the fixed functionality +// fragment processing in OpenGL. +// +// When created, a shader object's GL.SHADER_TYPE parameter is set to either +// GL.VERTEX_SHADER or GL.FRAGMENT_SHADER, depending on the value of +// shaderType. +// +// Like display lists and texture objects, the name space for shader objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// This function returns 0 if an error occurs creating the shader object. +// +// Error GL.INVALID_ENUM is generated if shaderType is not an accepted value. +// GL.INVALID_OPERATION is generated if CreateShader is executed between the +// execution of Begin and the corresponding execution of End. +// +// CreateShader is available in GL version 2.0 or greater. +func (gl *GL) CreateShader(gltype glbase.Enum) glbase.Shader { + glresult := C.gl4_1compat_glCreateShader(gl.funcs, C.GLenum(gltype)) + return glbase.Shader(glresult) +} + +// CreateProgram creates an empty program object and returns a non-zero +// value by which it can be referenced. A program object is an object to +// which shader objects can be attached. This provides a mechanism to specify +// the shader objects that will be linked to create a program. It also +// provides a means for checking the compatibility of the shaders that will +// be used to create a program (for instance, checking the compatibility +// between a vertex shader and a fragment shader). When no longer needed as +// part of a program object, shader objects can be detached. +// +// One or more executables are created in a program object by successfully +// attaching shader objects to it with AttachShader, successfully compiling +// the shader objects with CompileShader, and successfully linking the +// program object with LinkProgram. These executables are made part of +// current state when UseProgram is called. Program objects can be deleted +// by calling DeleteProgram. The memory associated with the program object +// will be deleted when it is no longer part of current rendering state for +// any context. +// +// Like display lists and texture objects, the name space for program objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// Applications are responsible for providing the synchronization across API +// calls when objects are accessed from different execution threads. +// +// This function returns 0 if an error occurs creating the program object. +// +// Error GL.INVALID_OPERATION is generated if CreateProgram is executed +// between the execution of Begin and the corresponding execution of End. +// +// CreateProgram is available in GL version 2.0 or greater. +func (gl *GL) CreateProgram() glbase.Program { + glresult := C.gl4_1compat_glCreateProgram(gl.funcs) + return glbase.Program(glresult) +} + +// CompileShader compiles the source code strings that have been stored in +// the shader object specified by shader. +// +// The compilation status will be stored as part of the shader object's +// state. This value will be set to GL.TRUE if the shader was compiled without +// errors and is ready for use, and GL.FALSE otherwise. It can be queried by +// calling GetShaderiv with arguments shader and GL.COMPILE_STATUS. +// +// Compilation of a shader can fail for a number of reasons as specified by +// the OpenGL Shading Language Specification. Whether or not the compilation +// was successful, information about the compilation can be obtained from the +// shader object's information log by calling GetShaderInfoLog. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_OPERATION is generated if CompileShader is executed +// between the execution of Begin and the corresponding execution of End. +// +// CompileShader is available in GL version 2.0 or greater. +func (gl *GL) CompileShader(shader glbase.Shader) { + C.gl4_1compat_glCompileShader(gl.funcs, C.GLuint(shader)) +} + +// BindAttribLocation associates a user-defined attribute variable in the program +// object specified by program with a generic vertex attribute index. The name +// parameter specifies the name of the vertex shader attribute variable to +// which index is to be bound. When program is made part of the current state, +// values provided via the generic vertex attribute index will modify the +// value of the user-defined attribute variable specified by name. +// +// If name refers to a matrix attribute variable, index refers to the first +// column of the matrix. Other matrix columns are then automatically bound to +// locations index+1 for a matrix of type mat2; index+1 and index+2 for a +// matrix of type mat3; and index+1, index+2, and index+3 for a matrix of +// type mat4. +// +// This command makes it possible for vertex shaders to use descriptive names +// for attribute variables rather than generic variables that are numbered +// from 0 to GL.MAX_VERTEX_ATTRIBS-1. The values sent to each generic +// attribute index are part of current state, just like standard vertex +// attributes such as color, normal, and vertex position. If a different +// program object is made current by calling UseProgram, the generic vertex +// attributes are tracked in such a way that the same values will be observed +// by attributes in the new program object that are also bound to index. +// +// Attribute variable name-to-generic attribute index bindings for a program +// object can be explicitly assigned at any time by calling +// BindAttribLocation. Attribute bindings do not go into effect until +// LinkProgram is called. After a program object has been linked +// successfully, the index values for generic attributes remain fixed (and +// their values can be queried) until the next link command occurs. +// +// Applications are not allowed to bind any of the standard OpenGL vertex +// attributes using this command, as they are bound automatically when +// needed. Any attribute binding that occurs after the program object has +// been linked will not take effect until the next time the program object is +// linked. +// +// If name was bound previously, that information is lost. Thus you cannot +// bind one user-defined attribute variable to multiple indices, but you can +// bind multiple user-defined attribute variables to the same index. +// +// Applications are allowed to bind more than one user-defined attribute +// variable to the same generic vertex attribute index. This is called +// aliasing, and it is allowed only if just one of the aliased attributes is +// active in the executable program, or if no path through the shader +// consumes more than one attribute of a set of attributes aliased to the +// same location. The compiler and linker are allowed to assume that no +// aliasing is done and are free to employ optimizations that work only in +// the absence of aliasing. OpenGL implementations are not required to do +// error checking to detect aliasing. Because there is no way to bind +// standard attributes, it is not possible to alias generic attributes with +// conventional ones (except for generic attribute 0). +// +// BindAttribLocation can be called before any vertex shader objects are +// bound to the specified program object. It is also permissible to bind a +// generic attribute index to an attribute variable name that is never used +// in a vertex shader. +// +// Active attributes that are not explicitly bound will be bound by the +// linker when LinkProgram is called. The locations assigned can be queried +// by calling GetAttribLocation. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. +// GL.INVALID_OPERATION is generated if name starts with the reserved prefix "gl_". +// GL.INVALID_VALUE is generated if program is not a value generated by OpenGL. +// GL.INVALID_OPERATION is generated if program is not a program object. +// GL.INVALID_OPERATION is generated if BindAttribLocation is executed +// between the execution of Begin and the corresponding execution of End. +// +// BindAttribLocation is available in GL version 2.0 or greater. +func (gl *GL) BindAttribLocation(program glbase.Program, index glbase.Attrib, name string) { + name_cstr := C.CString(name) + C.gl4_1compat_glBindAttribLocation(gl.funcs, C.GLuint(program), C.GLuint(index), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) +} + +// AttachShader attaches a shader object to a program object. +// +// In order to create an executable, there must be a way to specify the list +// of things that will be linked together. Program objects provide this +// mechanism. Shaders that are to be linked together in a program object must +// first be attached to that program object. This indicates that shader will +// be included in link operations that will be performed on program. +// +// All operations that can be performed on a shader object are valid whether +// or not the shader object is attached to a program object. It is +// permissible to attach a shader object to a program object before source +// code has been loaded into the shader object or before the shader object +// has been compiled. It is permissible to attach multiple shader objects of +// the same type because each may contain a portion of the complete shader. +// It is also permissible to attach a shader object to more than one program +// object. If a shader object is deleted while it is attached to a program +// object, it will be flagged for deletion, and deletion will not occur until +// DetachShader is called to detach it from all program objects to which it +// is attached. +// +// Error GL.INVALID_VALUE is generated if either program or shader is not a +// value generated by OpenGL. GL.INVALID_OPERATION is generated if program +// is not a program object. GL.INVALID_OPERATION is generated if shader is +// not a shader object. GL.INVALID_OPERATION is generated if shader is +// already attached to program. GL.INVALID_OPERATION is generated if +// AttachShader is executed between the execution of Begin and the +// corresponding execution of End. +// +// AttachShader is available in GL version 2.0 or greater. +func (gl *GL) AttachShader(program glbase.Program, shader glbase.Shader) { + C.gl4_1compat_glAttachShader(gl.funcs, C.GLuint(program), C.GLuint(shader)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilMaskSeparate.xml +func (gl *GL) StencilMaskSeparate(face glbase.Enum, mask uint32) { + C.gl4_1compat_glStencilMaskSeparate(gl.funcs, C.GLenum(face), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilFuncSeparate.xml +func (gl *GL) StencilFuncSeparate(face, glfunc glbase.Enum, ref int32, mask uint32) { + C.gl4_1compat_glStencilFuncSeparate(gl.funcs, C.GLenum(face), C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilOpSeparate.xml +func (gl *GL) StencilOpSeparate(face, sfail, dpfail, dppass glbase.Enum) { + C.gl4_1compat_glStencilOpSeparate(gl.funcs, C.GLenum(face), C.GLenum(sfail), C.GLenum(dpfail), C.GLenum(dppass)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawBuffers.xml +func (gl *GL) DrawBuffers(n int, bufs []glbase.Enum) { + C.gl4_1compat_glDrawBuffers(gl.funcs, C.GLsizei(n), (*C.GLenum)(unsafe.Pointer(&bufs[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendEquationSeparate.xml +func (gl *GL) BlendEquationSeparate(modeRGB, modeAlpha glbase.Enum) { + C.gl4_1compat_glBlendEquationSeparate(gl.funcs, C.GLenum(modeRGB), C.GLenum(modeAlpha)) +} + +// UniformMatrix4x3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4x3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4x3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*3) != 0 { + panic("invalid value length for UniformMatrix4x3fv") + } + count := len(value) / (4 * 3) + C.gl4_1compat_glUniformMatrix4x3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3x4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3x4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3x4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*4) != 0 { + panic("invalid value length for UniformMatrix3x4fv") + } + count := len(value) / (3 * 4) + C.gl4_1compat_glUniformMatrix3x4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix4x2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4x2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4x2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*2) != 0 { + panic("invalid value length for UniformMatrix4x2fv") + } + count := len(value) / (4 * 2) + C.gl4_1compat_glUniformMatrix4x2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2x4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2x4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2x4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*4) != 0 { + panic("invalid value length for UniformMatrix2x4fv") + } + count := len(value) / (2 * 4) + C.gl4_1compat_glUniformMatrix2x4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3x2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3x2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3x2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*2) != 0 { + panic("invalid value length for UniformMatrix3x2fv") + } + count := len(value) / (3 * 2) + C.gl4_1compat_glUniformMatrix3x2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2x3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2x3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2x3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*3) != 0 { + panic("invalid value length for UniformMatrix2x3fv") + } + count := len(value) / (2 * 3) + C.gl4_1compat_glUniformMatrix2x3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsVertexArray.xml +func (gl *GL) IsVertexArray(array uint32) bool { + glresult := C.gl4_1compat_glIsVertexArray(gl.funcs, C.GLuint(array)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenVertexArrays.xml +func (gl *GL) GenVertexArrays(n int, arrays []uint32) { + C.gl4_1compat_glGenVertexArrays(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&arrays[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteVertexArrays.xml +func (gl *GL) DeleteVertexArrays(n int, arrays []uint32) { + C.gl4_1compat_glDeleteVertexArrays(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&arrays[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindVertexArray.xml +func (gl *GL) BindVertexArray(array uint32) { + C.gl4_1compat_glBindVertexArray(gl.funcs, C.GLuint(array)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFlushMappedBufferRange.xml +func (gl *GL) FlushMappedBufferRange(target glbase.Enum, offset, length int) { + C.gl4_1compat_glFlushMappedBufferRange(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(length)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTextureLayer.xml +func (gl *GL) FramebufferTextureLayer(target, attachment glbase.Enum, texture glbase.Texture, level int, layer int32) { + C.gl4_1compat_glFramebufferTextureLayer(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLuint(texture), C.GLint(level), C.GLint(layer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRenderbufferStorageMultisample.xml +func (gl *GL) RenderbufferStorageMultisample(target glbase.Enum, samples int32, internalFormat glbase.Enum, width, height int) { + C.gl4_1compat_glRenderbufferStorageMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlitFramebuffer.xml +func (gl *GL) BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1 int32, mask glbase.Bitfield, filter glbase.Enum) { + C.gl4_1compat_glBlitFramebuffer(gl.funcs, C.GLint(srcX0), C.GLint(srcY0), C.GLint(srcX1), C.GLint(srcY1), C.GLint(dstX0), C.GLint(dstY0), C.GLint(dstX1), C.GLint(dstY1), C.GLbitfield(mask), C.GLenum(filter)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenerateMipmap.xml +func (gl *GL) GenerateMipmap(target glbase.Enum) { + C.gl4_1compat_glGenerateMipmap(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFramebufferAttachmentParameteriv.xml +func (gl *GL) GetFramebufferAttachmentParameteriv(target, attachment, pname glbase.Enum, params []int32) { + C.gl4_1compat_glGetFramebufferAttachmentParameteriv(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferRenderbuffer.xml +func (gl *GL) FramebufferRenderbuffer(target, attachment, renderbuffertarget glbase.Enum, renderbuffer glbase.Renderbuffer) { + C.gl4_1compat_glFramebufferRenderbuffer(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(renderbuffertarget), C.GLuint(renderbuffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture3D.xml +func (gl *GL) FramebufferTexture3D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int, zoffset int32) { + C.gl4_1compat_glFramebufferTexture3D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level), C.GLint(zoffset)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture2D.xml +func (gl *GL) FramebufferTexture2D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int) { + C.gl4_1compat_glFramebufferTexture2D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture1D.xml +func (gl *GL) FramebufferTexture1D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int) { + C.gl4_1compat_glFramebufferTexture1D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCheckFramebufferStatus.xml +func (gl *GL) CheckFramebufferStatus(target glbase.Enum) glbase.Enum { + glresult := C.gl4_1compat_glCheckFramebufferStatus(gl.funcs, C.GLenum(target)) + return glbase.Enum(glresult) +} + +// GenFramebuffers returns n framebuffer object names in ids. There is no +// guarantee that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenFramebuffers. +// +// Framebuffer object names returned by a call to GenFramebuffers are not +// returned by subsequent calls, unless they are first deleted with +// DeleteFramebuffers. +// +// The names returned in ids are marked as used, for the purposes of +// GenFramebuffers only, but they acquire state and type only when they are +// first bound. +// +// Error GL.INVALID_VALUE is generated if n is negative. +func (gl *GL) GenFramebuffers(n int) []glbase.Framebuffer { + if n == 0 { + return nil + } + framebuffers := make([]glbase.Framebuffer, n) + C.gl4_1compat_glGenFramebuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&framebuffers[0]))) + return framebuffers +} + +// DeleteFramebuffers deletes the framebuffer objects whose names are +// stored in the framebuffers slice. The name zero is reserved by the GL and +// is silently ignored, should it occur in framebuffers, as are other unused +// names. Once a framebuffer object is deleted, its name is again unused and +// it has no attachments. If a framebuffer that is currently bound to one or +// more of the targets GL.DRAW_FRAMEBUFFER or GL.READ_FRAMEBUFFER is deleted, +// it is as though BindFramebuffer had been executed with the corresponding +// target and framebuffer zero. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteFramebuffers is available in GL version 3.0 or greater. +func (gl *GL) DeleteFramebuffers(framebuffers []glbase.Framebuffer) { + n := len(framebuffers) + if n == 0 { + return + } + C.gl4_1compat_glDeleteFramebuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&framebuffers[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindFramebuffer.xml +func (gl *GL) BindFramebuffer(target glbase.Enum, framebuffer glbase.Framebuffer) { + C.gl4_1compat_glBindFramebuffer(gl.funcs, C.GLenum(target), C.GLuint(framebuffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsFramebuffer.xml +func (gl *GL) IsFramebuffer(framebuffer glbase.Framebuffer) bool { + glresult := C.gl4_1compat_glIsFramebuffer(gl.funcs, C.GLuint(framebuffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetRenderbufferParameteriv.xml +func (gl *GL) GetRenderbufferParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_1compat_glGetRenderbufferParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRenderbufferStorage.xml +func (gl *GL) RenderbufferStorage(target, internalFormat glbase.Enum, width, height int) { + C.gl4_1compat_glRenderbufferStorage(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) +} + +// GenRenderbuffers returns n renderbuffer object names in renderbuffers. +// There is no guarantee that the names form a contiguous set of integers; +// however, it is guaranteed that none of the returned names was in use +// immediately before the call to GenRenderbuffers. +// +// Renderbuffer object names returned by a call to GenRenderbuffers are not +// returned by subsequent calls, unless they are first deleted with +// DeleteRenderbuffers. +// +// The names returned in renderbuffers are marked as used, for the purposes +// of GenRenderbuffers only, but they acquire state and type only when they +// are first bound. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenRenderbuffers is available in GL version 3.0 or greater. +func (gl *GL) GenRenderbuffers(n int) []glbase.Renderbuffer { + if n == 0 { + return nil + } + renderbuffers := make([]glbase.Renderbuffer, n) + C.gl4_1compat_glGenRenderbuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&renderbuffers[0]))) + return renderbuffers +} + +// DeleteRenderbuffers deletes the renderbuffer objects whose names are stored +// in the renderbuffers slice. The name zero is reserved by the GL and +// is silently ignored, should it occur in renderbuffers, as are other unused +// names. Once a renderbuffer object is deleted, its name is again unused and +// it has no contents. If a renderbuffer that is currently bound to the +// target GL.RENDERBUFFER is deleted, it is as though BindRenderbuffer had +// been executed with a target of GL.RENDERBUFFER and a name of zero. +// +// If a renderbuffer object is attached to one or more attachment points in +// the currently bound framebuffer, then it as if FramebufferRenderbuffer +// had been called, with a renderbuffer of zero for each attachment point to +// which this image was attached in the currently bound framebuffer. In other +// words, this renderbuffer object is first detached from all attachment +// ponits in the currently bound framebuffer. Note that the renderbuffer +// image is specifically not detached from any non-bound framebuffers. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteRenderbuffers is available in GL version 3.0 or greater. +func (gl *GL) DeleteRenderbuffers(renderbuffers []glbase.Renderbuffer) { + n := len(renderbuffers) + if n == 0 { + return + } + C.gl4_1compat_glDeleteRenderbuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&renderbuffers[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindRenderbuffer.xml +func (gl *GL) BindRenderbuffer(target glbase.Enum, renderbuffer glbase.Renderbuffer) { + C.gl4_1compat_glBindRenderbuffer(gl.funcs, C.GLenum(target), C.GLuint(renderbuffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsRenderbuffer.xml +func (gl *GL) IsRenderbuffer(renderbuffer glbase.Renderbuffer) bool { + glresult := C.gl4_1compat_glIsRenderbuffer(gl.funcs, C.GLuint(renderbuffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferfi.xml +func (gl *GL) ClearBufferfi(buffer glbase.Enum, drawbuffer int32, depth float32, stencil int32) { + C.gl4_1compat_glClearBufferfi(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), C.GLfloat(depth), C.GLint(stencil)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferfv.xml +func (gl *GL) ClearBufferfv(buffer glbase.Enum, drawbuffer int32, value []float32) { + C.gl4_1compat_glClearBufferfv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferuiv.xml +func (gl *GL) ClearBufferuiv(buffer glbase.Enum, drawbuffer int32, value []uint32) { + C.gl4_1compat_glClearBufferuiv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferiv.xml +func (gl *GL) ClearBufferiv(buffer glbase.Enum, drawbuffer int32, value []int32) { + C.gl4_1compat_glClearBufferiv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameterIuiv.xml +func (gl *GL) GetTexParameterIuiv(target, pname glbase.Enum, params []uint32) { + C.gl4_1compat_glGetTexParameterIuiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameterIiv.xml +func (gl *GL) GetTexParameterIiv(target, pname glbase.Enum, params []int32) { + C.gl4_1compat_glGetTexParameterIiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterIuiv.xml +func (gl *GL) TexParameterIuiv(target, pname glbase.Enum, params []uint32) { + C.gl4_1compat_glTexParameterIuiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterIiv.xml +func (gl *GL) TexParameterIiv(target, pname glbase.Enum, params []int32) { + C.gl4_1compat_glTexParameterIiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// Uniform4uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4uiv") + } + count := len(value) / 4 + C.gl4_1compat_glUniform4uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform3uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3uiv") + } + count := len(value) / 3 + C.gl4_1compat_glUniform3uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform2uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2uiv") + } + count := len(value) / 2 + C.gl4_1compat_glUniform2uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform1uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl4_1compat_glUniform1uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform4ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4ui(location glbase.Uniform, v0, v1, v2, v3 uint32) { + C.gl4_1compat_glUniform4ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2), C.GLuint(v3)) +} + +// Uniform3ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3ui(location glbase.Uniform, v0, v1, v2 uint32) { + C.gl4_1compat_glUniform3ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2)) +} + +// Uniform2ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2ui(location glbase.Uniform, v0, v1 uint32) { + C.gl4_1compat_glUniform2ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1)) +} + +// Uniform1ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1ui(location glbase.Uniform, v0 uint32) { + C.gl4_1compat_glUniform1ui(gl.funcs, C.GLint(location), C.GLuint(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFragDataLocation.xml +func (gl *GL) GetFragDataLocation(program glbase.Program, name []byte) int32 { + glresult := C.gl4_1compat_glGetFragDataLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindFragDataLocation.xml +func (gl *GL) BindFragDataLocation(program glbase.Program, color uint32, name []byte) { + C.gl4_1compat_glBindFragDataLocation(gl.funcs, C.GLuint(program), C.GLuint(color), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetUniformuiv.xml +func (gl *GL) GetUniformuiv(program glbase.Program, location glbase.Uniform, params []uint32) { + C.gl4_1compat_glGetUniformuiv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetVertexAttribIuiv.xml +func (gl *GL) GetVertexAttribIuiv(index glbase.Attrib, pname glbase.Enum, params []uint32) { + C.gl4_1compat_glGetVertexAttribIuiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetVertexAttribIiv.xml +func (gl *GL) GetVertexAttribIiv(index glbase.Attrib, pname glbase.Enum, params []int32) { + C.gl4_1compat_glGetVertexAttribIiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribIPointer.xml +func (gl *GL) VertexAttribIPointer(index glbase.Attrib, size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glVertexAttribIPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndConditionalRender.xml +func (gl *GL) EndConditionalRender() { + C.gl4_1compat_glEndConditionalRender(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBeginConditionalRender.xml +func (gl *GL) BeginConditionalRender(id uint32, mode glbase.Enum) { + C.gl4_1compat_glBeginConditionalRender(gl.funcs, C.GLuint(id), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClampColor.xml +func (gl *GL) ClampColor(target, clamp glbase.Enum) { + C.gl4_1compat_glClampColor(gl.funcs, C.GLenum(target), C.GLenum(clamp)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTransformFeedbackVarying.xml +func (gl *GL) GetTransformFeedbackVarying(program glbase.Program, index uint32, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl4_1compat_glGetTransformFeedbackVarying(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLsizei)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindBufferBase.xml +func (gl *GL) BindBufferBase(target glbase.Enum, index uint32, buffer glbase.Buffer) { + C.gl4_1compat_glBindBufferBase(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindBufferRange.xml +func (gl *GL) BindBufferRange(target glbase.Enum, index uint32, buffer glbase.Buffer, offset, size int) { + C.gl4_1compat_glBindBufferRange(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(buffer), C.GLintptr(offset), C.GLsizeiptr(size)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndTransformFeedback.xml +func (gl *GL) EndTransformFeedback() { + C.gl4_1compat_glEndTransformFeedback(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBeginTransformFeedback.xml +func (gl *GL) BeginTransformFeedback(primitiveMode glbase.Enum) { + C.gl4_1compat_glBeginTransformFeedback(gl.funcs, C.GLenum(primitiveMode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsEnabledi.xml +func (gl *GL) IsEnabledi(target glbase.Enum, index uint32) bool { + glresult := C.gl4_1compat_glIsEnabledi(gl.funcs, C.GLenum(target), C.GLuint(index)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDisablei.xml +func (gl *GL) Disablei(target glbase.Enum, index uint32) { + C.gl4_1compat_glDisablei(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEnablei.xml +func (gl *GL) Enablei(target glbase.Enum, index uint32) { + C.gl4_1compat_glEnablei(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetIntegeri_v.xml +func (gl *GL) GetIntegeri_v(target glbase.Enum, index uint32, data []int32) { + C.gl4_1compat_glGetIntegeri_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLint)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBooleani_v.xml +func (gl *GL) GetBooleani_v(target glbase.Enum, index uint32, data []bool) { + C.gl4_1compat_glGetBooleani_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLboolean)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorMaski.xml +func (gl *GL) ColorMaski(index uint32, r, g, b, a bool) { + C.gl4_1compat_glColorMaski(gl.funcs, C.GLuint(index), *(*C.GLboolean)(unsafe.Pointer(&r)), *(*C.GLboolean)(unsafe.Pointer(&g)), *(*C.GLboolean)(unsafe.Pointer(&b)), *(*C.GLboolean)(unsafe.Pointer(&a))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyBufferSubData.xml +func (gl *GL) CopyBufferSubData(readTarget, writeTarget glbase.Enum, readOffset, writeOffset, size int) { + C.gl4_1compat_glCopyBufferSubData(gl.funcs, C.GLenum(readTarget), C.GLenum(writeTarget), C.GLintptr(readOffset), C.GLintptr(writeOffset), C.GLsizeiptr(size)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformBlockBinding.xml +func (gl *GL) UniformBlockBinding(program glbase.Program, v0, v1 uint32) { + C.gl4_1compat_glUniformBlockBinding(gl.funcs, C.GLuint(program), C.GLuint(v0), C.GLuint(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformBlockName.xml +func (gl *GL) GetActiveUniformBlockName(program glbase.Program, uniformBlockIndex uint32, bufSize int32, length []int32, uniformBlockName []byte) { + C.gl4_1compat_glGetActiveUniformBlockName(gl.funcs, C.GLuint(program), C.GLuint(uniformBlockIndex), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&uniformBlockName[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformBlockiv.xml +func (gl *GL) GetActiveUniformBlockiv(program glbase.Program, uniformBlockIndex uint32, pname glbase.Enum, params []int32) { + C.gl4_1compat_glGetActiveUniformBlockiv(gl.funcs, C.GLuint(program), C.GLuint(uniformBlockIndex), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetUniformBlockIndex.xml +func (gl *GL) GetUniformBlockIndex(program glbase.Program, uniformBlockName []byte) uint32 { + glresult := C.gl4_1compat_glGetUniformBlockIndex(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&uniformBlockName[0]))) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformName.xml +func (gl *GL) GetActiveUniformName(program glbase.Program, uniformIndex uint32, bufSize int32, length []int32, uniformName []byte) { + C.gl4_1compat_glGetActiveUniformName(gl.funcs, C.GLuint(program), C.GLuint(uniformIndex), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&uniformName[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformsiv.xml +func (gl *GL) GetActiveUniformsiv(program glbase.Program, uniformCount int32, uniformIndices []uint32, pname glbase.Enum, params []int32) { + C.gl4_1compat_glGetActiveUniformsiv(gl.funcs, C.GLuint(program), C.GLsizei(uniformCount), (*C.GLuint)(unsafe.Pointer(&uniformIndices[0])), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPrimitiveRestartIndex.xml +func (gl *GL) PrimitiveRestartIndex(index uint32) { + C.gl4_1compat_glPrimitiveRestartIndex(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexBuffer.xml +func (gl *GL) TexBuffer(target, internalFormat glbase.Enum, buffer glbase.Buffer) { + C.gl4_1compat_glTexBuffer(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsInstanced.xml +func (gl *GL) DrawElementsInstanced(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, instancecount int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glDrawElementsInstanced(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLsizei(instancecount)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawArraysInstanced.xml +func (gl *GL) DrawArraysInstanced(mode glbase.Enum, first, count int, instancecount int32) { + C.gl4_1compat_glDrawArraysInstanced(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count), C.GLsizei(instancecount)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSampleMaski.xml +func (gl *GL) SampleMaski(index uint32, mask glbase.Bitfield) { + C.gl4_1compat_glSampleMaski(gl.funcs, C.GLuint(index), C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMultisamplefv.xml +func (gl *GL) GetMultisamplefv(pname glbase.Enum, index uint32, val []float32) { + C.gl4_1compat_glGetMultisamplefv(gl.funcs, C.GLenum(pname), C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&val[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage3DMultisample.xml +func (gl *GL) TexImage3DMultisample(target glbase.Enum, samples, internalFormat int32, width, height int, depth int32, fixedsamplelocations bool) { + C.gl4_1compat_glTexImage3DMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), *(*C.GLboolean)(unsafe.Pointer(&fixedsamplelocations))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage2DMultisample.xml +func (gl *GL) TexImage2DMultisample(target glbase.Enum, samples, internalFormat int32, width, height int, fixedsamplelocations bool) { + C.gl4_1compat_glTexImage2DMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), *(*C.GLboolean)(unsafe.Pointer(&fixedsamplelocations))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSynciv.xml +func (gl *GL) GetSynciv(sync glbase.Sync, pname glbase.Enum, bufSize int32, length, values []int32) { + C.gl4_1compat_glGetSynciv(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLenum(pname), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetInteger64v.xml +func (gl *GL) GetInteger64v(pname glbase.Enum, params []int64) { + C.gl4_1compat_glGetInteger64v(gl.funcs, C.GLenum(pname), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWaitSync.xml +func (gl *GL) WaitSync(sync glbase.Sync, flags glbase.Bitfield, timeout uint64) { + C.gl4_1compat_glWaitSync(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLbitfield(flags), C.GLuint64(timeout)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClientWaitSync.xml +func (gl *GL) ClientWaitSync(sync glbase.Sync, flags glbase.Bitfield, timeout uint64) glbase.Enum { + glresult := C.gl4_1compat_glClientWaitSync(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLbitfield(flags), C.GLuint64(timeout)) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteSync.xml +func (gl *GL) DeleteSync(sync glbase.Sync) { + C.gl4_1compat_glDeleteSync(gl.funcs, C.GLsync(unsafe.Pointer(sync))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsSync.xml +func (gl *GL) IsSync(sync glbase.Sync) bool { + glresult := C.gl4_1compat_glIsSync(gl.funcs, C.GLsync(unsafe.Pointer(sync))) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFenceSync.xml +func (gl *GL) FenceSync(condition glbase.Enum, flags glbase.Bitfield) glbase.Sync { + glresult := C.gl4_1compat_glFenceSync(gl.funcs, C.GLenum(condition), C.GLbitfield(flags)) + return glbase.Sync(unsafe.Pointer(glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProvokingVertex.xml +func (gl *GL) ProvokingVertex(mode glbase.Enum) { + C.gl4_1compat_glProvokingVertex(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsInstancedBaseVertex.xml +func (gl *GL) DrawElementsInstancedBaseVertex(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, instancecount, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glDrawElementsInstancedBaseVertex(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLsizei(instancecount), C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawRangeElementsBaseVertex.xml +func (gl *GL) DrawRangeElementsBaseVertex(mode glbase.Enum, start, end uint32, count int, gltype glbase.Enum, indices interface{}, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glDrawRangeElementsBaseVertex(gl.funcs, C.GLenum(mode), C.GLuint(start), C.GLuint(end), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsBaseVertex.xml +func (gl *GL) DrawElementsBaseVertex(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glDrawElementsBaseVertex(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture.xml +func (gl *GL) FramebufferTexture(target, attachment glbase.Enum, texture glbase.Texture, level int) { + C.gl4_1compat_glFramebufferTexture(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBufferParameteri64v.xml +func (gl *GL) GetBufferParameteri64v(target, pname glbase.Enum, params []int64) { + C.gl4_1compat_glGetBufferParameteri64v(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetInteger64i_v.xml +func (gl *GL) GetInteger64i_v(target glbase.Enum, index uint32, data []int64) { + C.gl4_1compat_glGetInteger64i_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLint64)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP4uiv.xml +func (gl *GL) VertexAttribP4uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl4_1compat_glVertexAttribP4uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP4ui.xml +func (gl *GL) VertexAttribP4ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl4_1compat_glVertexAttribP4ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP3uiv.xml +func (gl *GL) VertexAttribP3uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl4_1compat_glVertexAttribP3uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP3ui.xml +func (gl *GL) VertexAttribP3ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl4_1compat_glVertexAttribP3ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP2uiv.xml +func (gl *GL) VertexAttribP2uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl4_1compat_glVertexAttribP2uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP2ui.xml +func (gl *GL) VertexAttribP2ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl4_1compat_glVertexAttribP2ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP1uiv.xml +func (gl *GL) VertexAttribP1uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl4_1compat_glVertexAttribP1uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP1ui.xml +func (gl *GL) VertexAttribP1ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl4_1compat_glVertexAttribP1ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColorP3uiv.xml +func (gl *GL) SecondaryColorP3uiv(gltype glbase.Enum, color []uint32) { + C.gl4_1compat_glSecondaryColorP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&color[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColorP3ui.xml +func (gl *GL) SecondaryColorP3ui(gltype glbase.Enum, color uint32) { + C.gl4_1compat_glSecondaryColorP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(color)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorP4uiv.xml +func (gl *GL) ColorP4uiv(gltype glbase.Enum, color []uint32) { + C.gl4_1compat_glColorP4uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&color[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorP4ui.xml +func (gl *GL) ColorP4ui(gltype glbase.Enum, color uint32) { + C.gl4_1compat_glColorP4ui(gl.funcs, C.GLenum(gltype), C.GLuint(color)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorP3uiv.xml +func (gl *GL) ColorP3uiv(gltype glbase.Enum, color []uint32) { + C.gl4_1compat_glColorP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&color[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorP3ui.xml +func (gl *GL) ColorP3ui(gltype glbase.Enum, color uint32) { + C.gl4_1compat_glColorP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(color)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormalP3uiv.xml +func (gl *GL) NormalP3uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_1compat_glNormalP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormalP3ui.xml +func (gl *GL) NormalP3ui(gltype glbase.Enum, coords uint32) { + C.gl4_1compat_glNormalP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP4uiv.xml +func (gl *GL) MultiTexCoordP4uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl4_1compat_glMultiTexCoordP4uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP4ui.xml +func (gl *GL) MultiTexCoordP4ui(texture, gltype glbase.Enum, coords uint32) { + C.gl4_1compat_glMultiTexCoordP4ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP3uiv.xml +func (gl *GL) MultiTexCoordP3uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl4_1compat_glMultiTexCoordP3uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP3ui.xml +func (gl *GL) MultiTexCoordP3ui(texture, gltype glbase.Enum, coords uint32) { + C.gl4_1compat_glMultiTexCoordP3ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP2uiv.xml +func (gl *GL) MultiTexCoordP2uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl4_1compat_glMultiTexCoordP2uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP2ui.xml +func (gl *GL) MultiTexCoordP2ui(texture, gltype glbase.Enum, coords uint32) { + C.gl4_1compat_glMultiTexCoordP2ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP1uiv.xml +func (gl *GL) MultiTexCoordP1uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl4_1compat_glMultiTexCoordP1uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP1ui.xml +func (gl *GL) MultiTexCoordP1ui(texture, gltype glbase.Enum, coords uint32) { + C.gl4_1compat_glMultiTexCoordP1ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP4uiv.xml +func (gl *GL) TexCoordP4uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_1compat_glTexCoordP4uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP4ui.xml +func (gl *GL) TexCoordP4ui(gltype glbase.Enum, coords uint32) { + C.gl4_1compat_glTexCoordP4ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP3uiv.xml +func (gl *GL) TexCoordP3uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_1compat_glTexCoordP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP3ui.xml +func (gl *GL) TexCoordP3ui(gltype glbase.Enum, coords uint32) { + C.gl4_1compat_glTexCoordP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP2uiv.xml +func (gl *GL) TexCoordP2uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_1compat_glTexCoordP2uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP2ui.xml +func (gl *GL) TexCoordP2ui(gltype glbase.Enum, coords uint32) { + C.gl4_1compat_glTexCoordP2ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP1uiv.xml +func (gl *GL) TexCoordP1uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_1compat_glTexCoordP1uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP1ui.xml +func (gl *GL) TexCoordP1ui(gltype glbase.Enum, coords uint32) { + C.gl4_1compat_glTexCoordP1ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP4uiv.xml +func (gl *GL) VertexP4uiv(gltype glbase.Enum, value []uint32) { + C.gl4_1compat_glVertexP4uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP4ui.xml +func (gl *GL) VertexP4ui(gltype glbase.Enum, value uint32) { + C.gl4_1compat_glVertexP4ui(gl.funcs, C.GLenum(gltype), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP3uiv.xml +func (gl *GL) VertexP3uiv(gltype glbase.Enum, value []uint32) { + C.gl4_1compat_glVertexP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP3ui.xml +func (gl *GL) VertexP3ui(gltype glbase.Enum, value uint32) { + C.gl4_1compat_glVertexP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP2uiv.xml +func (gl *GL) VertexP2uiv(gltype glbase.Enum, value []uint32) { + C.gl4_1compat_glVertexP2uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP2ui.xml +func (gl *GL) VertexP2ui(gltype glbase.Enum, value uint32) { + C.gl4_1compat_glVertexP2ui(gl.funcs, C.GLenum(gltype), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryObjectui64v.xml +func (gl *GL) GetQueryObjectui64v(id uint32, pname glbase.Enum, params []uint64) { + C.gl4_1compat_glGetQueryObjectui64v(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLuint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryObjecti64v.xml +func (gl *GL) GetQueryObjecti64v(id uint32, pname glbase.Enum, params []int64) { + C.gl4_1compat_glGetQueryObjecti64v(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glQueryCounter.xml +func (gl *GL) QueryCounter(id uint32, target glbase.Enum) { + C.gl4_1compat_glQueryCounter(gl.funcs, C.GLuint(id), C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSamplerParameterIuiv.xml +func (gl *GL) GetSamplerParameterIuiv(sampler uint32, pname glbase.Enum, params []uint32) { + C.gl4_1compat_glGetSamplerParameterIuiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSamplerParameterfv.xml +func (gl *GL) GetSamplerParameterfv(sampler uint32, pname glbase.Enum, params []float32) { + C.gl4_1compat_glGetSamplerParameterfv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSamplerParameterIiv.xml +func (gl *GL) GetSamplerParameterIiv(sampler uint32, pname glbase.Enum, params []int32) { + C.gl4_1compat_glGetSamplerParameterIiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSamplerParameteriv.xml +func (gl *GL) GetSamplerParameteriv(sampler uint32, pname glbase.Enum, params []int32) { + C.gl4_1compat_glGetSamplerParameteriv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameterIuiv.xml +func (gl *GL) SamplerParameterIuiv(sampler uint32, pname glbase.Enum, param []uint32) { + C.gl4_1compat_glSamplerParameterIuiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameterIiv.xml +func (gl *GL) SamplerParameterIiv(sampler uint32, pname glbase.Enum, param []int32) { + C.gl4_1compat_glSamplerParameterIiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameterfv.xml +func (gl *GL) SamplerParameterfv(sampler uint32, pname glbase.Enum, param []float32) { + C.gl4_1compat_glSamplerParameterfv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameterf.xml +func (gl *GL) SamplerParameterf(sampler uint32, pname glbase.Enum, param float32) { + C.gl4_1compat_glSamplerParameterf(gl.funcs, C.GLuint(sampler), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameteriv.xml +func (gl *GL) SamplerParameteriv(sampler uint32, pname glbase.Enum, param []int32) { + C.gl4_1compat_glSamplerParameteriv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameteri.xml +func (gl *GL) SamplerParameteri(sampler uint32, pname glbase.Enum, param int32) { + C.gl4_1compat_glSamplerParameteri(gl.funcs, C.GLuint(sampler), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindSampler.xml +func (gl *GL) BindSampler(unit, sampler uint32) { + C.gl4_1compat_glBindSampler(gl.funcs, C.GLuint(unit), C.GLuint(sampler)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsSampler.xml +func (gl *GL) IsSampler(sampler uint32) bool { + glresult := C.gl4_1compat_glIsSampler(gl.funcs, C.GLuint(sampler)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteSamplers.xml +func (gl *GL) DeleteSamplers(count int, samplers []uint32) { + C.gl4_1compat_glDeleteSamplers(gl.funcs, C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&samplers[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenSamplers.xml +func (gl *GL) GenSamplers(count int, samplers []uint32) { + C.gl4_1compat_glGenSamplers(gl.funcs, C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&samplers[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFragDataIndex.xml +func (gl *GL) GetFragDataIndex(program glbase.Program, name []byte) int32 { + glresult := C.gl4_1compat_glGetFragDataIndex(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindFragDataLocationIndexed.xml +func (gl *GL) BindFragDataLocationIndexed(program glbase.Program, colorNumber, index uint32, name []byte) { + C.gl4_1compat_glBindFragDataLocationIndexed(gl.funcs, C.GLuint(program), C.GLuint(colorNumber), C.GLuint(index), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribDivisor.xml +func (gl *GL) VertexAttribDivisor(index glbase.Attrib, divisor uint32) { + C.gl4_1compat_glVertexAttribDivisor(gl.funcs, C.GLuint(index), C.GLuint(divisor)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryIndexediv.xml +func (gl *GL) GetQueryIndexediv(target glbase.Enum, index uint32, pname glbase.Enum, params []int32) { + C.gl4_1compat_glGetQueryIndexediv(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndQueryIndexed.xml +func (gl *GL) EndQueryIndexed(target glbase.Enum, index uint32) { + C.gl4_1compat_glEndQueryIndexed(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBeginQueryIndexed.xml +func (gl *GL) BeginQueryIndexed(target glbase.Enum, index, id uint32) { + C.gl4_1compat_glBeginQueryIndexed(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawTransformFeedbackStream.xml +func (gl *GL) DrawTransformFeedbackStream(mode glbase.Enum, id, stream uint32) { + C.gl4_1compat_glDrawTransformFeedbackStream(gl.funcs, C.GLenum(mode), C.GLuint(id), C.GLuint(stream)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawTransformFeedback.xml +func (gl *GL) DrawTransformFeedback(mode glbase.Enum, id uint32) { + C.gl4_1compat_glDrawTransformFeedback(gl.funcs, C.GLenum(mode), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glResumeTransformFeedback.xml +func (gl *GL) ResumeTransformFeedback() { + C.gl4_1compat_glResumeTransformFeedback(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPauseTransformFeedback.xml +func (gl *GL) PauseTransformFeedback() { + C.gl4_1compat_glPauseTransformFeedback(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsTransformFeedback.xml +func (gl *GL) IsTransformFeedback(id uint32) bool { + glresult := C.gl4_1compat_glIsTransformFeedback(gl.funcs, C.GLuint(id)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenTransformFeedbacks.xml +func (gl *GL) GenTransformFeedbacks(n int, ids []uint32) { + C.gl4_1compat_glGenTransformFeedbacks(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteTransformFeedbacks.xml +func (gl *GL) DeleteTransformFeedbacks(n int, ids []uint32) { + C.gl4_1compat_glDeleteTransformFeedbacks(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindTransformFeedback.xml +func (gl *GL) BindTransformFeedback(target glbase.Enum, id uint32) { + C.gl4_1compat_glBindTransformFeedback(gl.funcs, C.GLenum(target), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPatchParameterfv.xml +func (gl *GL) PatchParameterfv(pname glbase.Enum, values []float32) { + C.gl4_1compat_glPatchParameterfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPatchParameteri.xml +func (gl *GL) PatchParameteri(pname glbase.Enum, value int32) { + C.gl4_1compat_glPatchParameteri(gl.funcs, C.GLenum(pname), C.GLint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramStageiv.xml +func (gl *GL) GetProgramStageiv(program glbase.Program, shadertype, pname glbase.Enum, values []int32) { + C.gl4_1compat_glGetProgramStageiv(gl.funcs, C.GLuint(program), C.GLenum(shadertype), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetUniformSubroutineuiv.xml +func (gl *GL) GetUniformSubroutineuiv(shadertype glbase.Enum, location glbase.Uniform, params []uint32) { + C.gl4_1compat_glGetUniformSubroutineuiv(gl.funcs, C.GLenum(shadertype), C.GLint(location), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformSubroutinesuiv.xml +func (gl *GL) UniformSubroutinesuiv(shadertype glbase.Enum, count int, value []uint32) { + C.gl4_1compat_glUniformSubroutinesuiv(gl.funcs, C.GLenum(shadertype), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveSubroutineName.xml +func (gl *GL) GetActiveSubroutineName(program glbase.Program, shadertype glbase.Enum, index uint32, bufSize int32, length []int32, name []byte) { + C.gl4_1compat_glGetActiveSubroutineName(gl.funcs, C.GLuint(program), C.GLenum(shadertype), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveSubroutineUniformName.xml +func (gl *GL) GetActiveSubroutineUniformName(program glbase.Program, shadertype glbase.Enum, index uint32, bufSize int32, length []int32, name []byte) { + C.gl4_1compat_glGetActiveSubroutineUniformName(gl.funcs, C.GLuint(program), C.GLenum(shadertype), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveSubroutineUniformiv.xml +func (gl *GL) GetActiveSubroutineUniformiv(program glbase.Program, shadertype glbase.Enum, index uint32, pname glbase.Enum, values []int32) { + C.gl4_1compat_glGetActiveSubroutineUniformiv(gl.funcs, C.GLuint(program), C.GLenum(shadertype), C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSubroutineIndex.xml +func (gl *GL) GetSubroutineIndex(program glbase.Program, shadertype glbase.Enum, name []byte) uint32 { + glresult := C.gl4_1compat_glGetSubroutineIndex(gl.funcs, C.GLuint(program), C.GLenum(shadertype), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSubroutineUniformLocation.xml +func (gl *GL) GetSubroutineUniformLocation(program glbase.Program, shadertype glbase.Enum, name []byte) int32 { + glresult := C.gl4_1compat_glGetSubroutineUniformLocation(gl.funcs, C.GLuint(program), C.GLenum(shadertype), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetUniformdv.xml +func (gl *GL) GetUniformdv(program glbase.Program, location glbase.Uniform, params []float64) { + C.gl4_1compat_glGetUniformdv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix4x3dv.xml +func (gl *GL) UniformMatrix4x3dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_1compat_glUniformMatrix4x3dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix4x2dv.xml +func (gl *GL) UniformMatrix4x2dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_1compat_glUniformMatrix4x2dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix3x4dv.xml +func (gl *GL) UniformMatrix3x4dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_1compat_glUniformMatrix3x4dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix3x2dv.xml +func (gl *GL) UniformMatrix3x2dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_1compat_glUniformMatrix3x2dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix2x4dv.xml +func (gl *GL) UniformMatrix2x4dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_1compat_glUniformMatrix2x4dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix2x3dv.xml +func (gl *GL) UniformMatrix2x3dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_1compat_glUniformMatrix2x3dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix4dv.xml +func (gl *GL) UniformMatrix4dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_1compat_glUniformMatrix4dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix3dv.xml +func (gl *GL) UniformMatrix3dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_1compat_glUniformMatrix3dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix2dv.xml +func (gl *GL) UniformMatrix2dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_1compat_glUniformMatrix2dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform4dv.xml +func (gl *GL) Uniform4dv(location glbase.Uniform, count int, value []float64) { + C.gl4_1compat_glUniform4dv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform3dv.xml +func (gl *GL) Uniform3dv(location glbase.Uniform, count int, value []float64) { + C.gl4_1compat_glUniform3dv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform2dv.xml +func (gl *GL) Uniform2dv(location glbase.Uniform, count int, value []float64) { + C.gl4_1compat_glUniform2dv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform1dv.xml +func (gl *GL) Uniform1dv(location glbase.Uniform, count int, value []float64) { + C.gl4_1compat_glUniform1dv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform4d.xml +func (gl *GL) Uniform4d(location glbase.Uniform, v0, v1, v2, v3 float64) { + C.gl4_1compat_glUniform4d(gl.funcs, C.GLint(location), C.GLdouble(v0), C.GLdouble(v1), C.GLdouble(v2), C.GLdouble(v3)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform3d.xml +func (gl *GL) Uniform3d(location glbase.Uniform, v0, v1, v2 float64) { + C.gl4_1compat_glUniform3d(gl.funcs, C.GLint(location), C.GLdouble(v0), C.GLdouble(v1), C.GLdouble(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform2d.xml +func (gl *GL) Uniform2d(location glbase.Uniform, v0, v1 float64) { + C.gl4_1compat_glUniform2d(gl.funcs, C.GLint(location), C.GLdouble(v0), C.GLdouble(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform1d.xml +func (gl *GL) Uniform1d(location glbase.Uniform, v0 float64) { + C.gl4_1compat_glUniform1d(gl.funcs, C.GLint(location), C.GLdouble(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsIndirect.xml +func (gl *GL) DrawElementsIndirect(mode, gltype glbase.Enum, indirect interface{}) { + var indirect_ptr unsafe.Pointer + var indirect_v = reflect.ValueOf(indirect) + if indirect != nil && indirect_v.Kind() != reflect.Slice { + panic("parameter indirect must be a slice") + } + if indirect != nil { + indirect_ptr = unsafe.Pointer(indirect_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glDrawElementsIndirect(gl.funcs, C.GLenum(mode), C.GLenum(gltype), indirect_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawArraysIndirect.xml +func (gl *GL) DrawArraysIndirect(mode glbase.Enum, indirect interface{}) { + var indirect_ptr unsafe.Pointer + var indirect_v = reflect.ValueOf(indirect) + if indirect != nil && indirect_v.Kind() != reflect.Slice { + panic("parameter indirect must be a slice") + } + if indirect != nil { + indirect_ptr = unsafe.Pointer(indirect_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glDrawArraysIndirect(gl.funcs, C.GLenum(mode), indirect_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFuncSeparatei.xml +func (gl *GL) BlendFuncSeparatei(buf uint32, srcRGB, dstRGB, srcAlpha, dstAlpha glbase.Enum) { + C.gl4_1compat_glBlendFuncSeparatei(gl.funcs, C.GLuint(buf), C.GLenum(srcRGB), C.GLenum(dstRGB), C.GLenum(srcAlpha), C.GLenum(dstAlpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFunci.xml +func (gl *GL) BlendFunci(buf uint32, src, dst glbase.Enum) { + C.gl4_1compat_glBlendFunci(gl.funcs, C.GLuint(buf), C.GLenum(src), C.GLenum(dst)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendEquationSeparatei.xml +func (gl *GL) BlendEquationSeparatei(buf uint32, modeRGB, modeAlpha glbase.Enum) { + C.gl4_1compat_glBlendEquationSeparatei(gl.funcs, C.GLuint(buf), C.GLenum(modeRGB), C.GLenum(modeAlpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendEquationi.xml +func (gl *GL) BlendEquationi(buf uint32, mode glbase.Enum) { + C.gl4_1compat_glBlendEquationi(gl.funcs, C.GLuint(buf), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMinSampleShading.xml +func (gl *GL) MinSampleShading(value float32) { + C.gl4_1compat_glMinSampleShading(gl.funcs, C.GLfloat(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetDoublei_v.xml +func (gl *GL) GetDoublei_v(target glbase.Enum, index uint32, data []float64) { + C.gl4_1compat_glGetDoublei_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFloati_v.xml +func (gl *GL) GetFloati_v(target glbase.Enum, index uint32, data []float32) { + C.gl4_1compat_glGetFloati_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDepthRangeIndexed.xml +func (gl *GL) DepthRangeIndexed(index uint32, n, f float64) { + C.gl4_1compat_glDepthRangeIndexed(gl.funcs, C.GLuint(index), C.GLdouble(n), C.GLdouble(f)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDepthRangeArrayv.xml +func (gl *GL) DepthRangeArrayv(first uint32, count int, v []float64) { + C.gl4_1compat_glDepthRangeArrayv(gl.funcs, C.GLuint(first), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glScissorIndexedv.xml +func (gl *GL) ScissorIndexedv(index uint32, v []int32) { + C.gl4_1compat_glScissorIndexedv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glScissorIndexed.xml +func (gl *GL) ScissorIndexed(index uint32, left, bottom int32, width, height int) { + C.gl4_1compat_glScissorIndexed(gl.funcs, C.GLuint(index), C.GLint(left), C.GLint(bottom), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glScissorArrayv.xml +func (gl *GL) ScissorArrayv(first uint32, count int, v []int32) { + C.gl4_1compat_glScissorArrayv(gl.funcs, C.GLuint(first), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glViewportIndexedfv.xml +func (gl *GL) ViewportIndexedfv(index uint32, v []float32) { + C.gl4_1compat_glViewportIndexedfv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glViewportIndexedf.xml +func (gl *GL) ViewportIndexedf(index uint32, x, y, w, h float32) { + C.gl4_1compat_glViewportIndexedf(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y), C.GLfloat(w), C.GLfloat(h)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glViewportArrayv.xml +func (gl *GL) ViewportArrayv(first uint32, count int, v []float32) { + C.gl4_1compat_glViewportArrayv(gl.funcs, C.GLuint(first), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetVertexAttribLdv.xml +func (gl *GL) GetVertexAttribLdv(index glbase.Attrib, pname glbase.Enum, params []float64) { + C.gl4_1compat_glGetVertexAttribLdv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribLPointer.xml +func (gl *GL) VertexAttribLPointer(index glbase.Attrib, size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glVertexAttribLPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL4dv.xml +func (gl *GL) VertexAttribL4dv(index glbase.Attrib, v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glVertexAttribL4dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL3dv.xml +func (gl *GL) VertexAttribL3dv(index glbase.Attrib, v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glVertexAttribL3dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL2dv.xml +func (gl *GL) VertexAttribL2dv(index glbase.Attrib, v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glVertexAttribL2dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL1dv.xml +func (gl *GL) VertexAttribL1dv(index glbase.Attrib, v []float64) { + C.gl4_1compat_glVertexAttribL1dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL4d.xml +func (gl *GL) VertexAttribL4d(index glbase.Attrib, x, y, z, w float64) { + C.gl4_1compat_glVertexAttribL4d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL3d.xml +func (gl *GL) VertexAttribL3d(index glbase.Attrib, x, y, z float64) { + C.gl4_1compat_glVertexAttribL3d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL2d.xml +func (gl *GL) VertexAttribL2d(index glbase.Attrib, x, y float64) { + C.gl4_1compat_glVertexAttribL2d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL1d.xml +func (gl *GL) VertexAttribL1d(index glbase.Attrib, x float64) { + C.gl4_1compat_glVertexAttribL1d(gl.funcs, C.GLuint(index), C.GLdouble(x)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramPipelineInfoLog.xml +func (gl *GL) GetProgramPipelineInfoLog(pipeline uint32, bufSize int32, length []int32, infoLog []byte) { + C.gl4_1compat_glGetProgramPipelineInfoLog(gl.funcs, C.GLuint(pipeline), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glValidateProgramPipeline.xml +func (gl *GL) ValidateProgramPipeline(pipeline uint32) { + C.gl4_1compat_glValidateProgramPipeline(gl.funcs, C.GLuint(pipeline)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4x3dv.xml +func (gl *GL) ProgramUniformMatrix4x3dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_1compat_glProgramUniformMatrix4x3dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3x4dv.xml +func (gl *GL) ProgramUniformMatrix3x4dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_1compat_glProgramUniformMatrix3x4dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4x2dv.xml +func (gl *GL) ProgramUniformMatrix4x2dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_1compat_glProgramUniformMatrix4x2dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2x4dv.xml +func (gl *GL) ProgramUniformMatrix2x4dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_1compat_glProgramUniformMatrix2x4dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3x2dv.xml +func (gl *GL) ProgramUniformMatrix3x2dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_1compat_glProgramUniformMatrix3x2dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2x3dv.xml +func (gl *GL) ProgramUniformMatrix2x3dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_1compat_glProgramUniformMatrix2x3dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4x3fv.xml +func (gl *GL) ProgramUniformMatrix4x3fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_1compat_glProgramUniformMatrix4x3fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3x4fv.xml +func (gl *GL) ProgramUniformMatrix3x4fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_1compat_glProgramUniformMatrix3x4fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4x2fv.xml +func (gl *GL) ProgramUniformMatrix4x2fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_1compat_glProgramUniformMatrix4x2fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2x4fv.xml +func (gl *GL) ProgramUniformMatrix2x4fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_1compat_glProgramUniformMatrix2x4fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3x2fv.xml +func (gl *GL) ProgramUniformMatrix3x2fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_1compat_glProgramUniformMatrix3x2fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2x3fv.xml +func (gl *GL) ProgramUniformMatrix2x3fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_1compat_glProgramUniformMatrix2x3fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4dv.xml +func (gl *GL) ProgramUniformMatrix4dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_1compat_glProgramUniformMatrix4dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3dv.xml +func (gl *GL) ProgramUniformMatrix3dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_1compat_glProgramUniformMatrix3dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2dv.xml +func (gl *GL) ProgramUniformMatrix2dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_1compat_glProgramUniformMatrix2dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4fv.xml +func (gl *GL) ProgramUniformMatrix4fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_1compat_glProgramUniformMatrix4fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3fv.xml +func (gl *GL) ProgramUniformMatrix3fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_1compat_glProgramUniformMatrix3fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2fv.xml +func (gl *GL) ProgramUniformMatrix2fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_1compat_glProgramUniformMatrix2fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4uiv.xml +func (gl *GL) ProgramUniform4uiv(program glbase.Program, location glbase.Uniform, count int, value []uint32) { + C.gl4_1compat_glProgramUniform4uiv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4ui.xml +func (gl *GL) ProgramUniform4ui(program glbase.Program, location glbase.Uniform, v0, v1, v2, v3 uint32) { + C.gl4_1compat_glProgramUniform4ui(gl.funcs, C.GLuint(program), C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2), C.GLuint(v3)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4dv.xml +func (gl *GL) ProgramUniform4dv(program glbase.Program, location glbase.Uniform, count int, value []float64) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_1compat_glProgramUniform4dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4d.xml +func (gl *GL) ProgramUniform4d(program glbase.Program, location glbase.Uniform, v0, v1, v2, v3 float64) { + C.gl4_1compat_glProgramUniform4d(gl.funcs, C.GLuint(program), C.GLint(location), C.GLdouble(v0), C.GLdouble(v1), C.GLdouble(v2), C.GLdouble(v3)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4fv.xml +func (gl *GL) ProgramUniform4fv(program glbase.Program, location glbase.Uniform, count int, value []float32) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_1compat_glProgramUniform4fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4f.xml +func (gl *GL) ProgramUniform4f(program glbase.Program, location glbase.Uniform, v0, v1, v2, v3 float32) { + C.gl4_1compat_glProgramUniform4f(gl.funcs, C.GLuint(program), C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2), C.GLfloat(v3)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4iv.xml +func (gl *GL) ProgramUniform4iv(program glbase.Program, location glbase.Uniform, count int, value []int32) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_1compat_glProgramUniform4iv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4i.xml +func (gl *GL) ProgramUniform4i(program glbase.Program, location glbase.Uniform, v0, v1, v2, v3 int32) { + C.gl4_1compat_glProgramUniform4i(gl.funcs, C.GLuint(program), C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2), C.GLint(v3)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3uiv.xml +func (gl *GL) ProgramUniform3uiv(program glbase.Program, location glbase.Uniform, count int, value []uint32) { + C.gl4_1compat_glProgramUniform3uiv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3ui.xml +func (gl *GL) ProgramUniform3ui(program glbase.Program, location glbase.Uniform, v0, v1, v2 uint32) { + C.gl4_1compat_glProgramUniform3ui(gl.funcs, C.GLuint(program), C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3dv.xml +func (gl *GL) ProgramUniform3dv(program glbase.Program, location glbase.Uniform, count int, value []float64) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_1compat_glProgramUniform3dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3d.xml +func (gl *GL) ProgramUniform3d(program glbase.Program, location glbase.Uniform, v0, v1, v2 float64) { + C.gl4_1compat_glProgramUniform3d(gl.funcs, C.GLuint(program), C.GLint(location), C.GLdouble(v0), C.GLdouble(v1), C.GLdouble(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3fv.xml +func (gl *GL) ProgramUniform3fv(program glbase.Program, location glbase.Uniform, count int, value []float32) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_1compat_glProgramUniform3fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3f.xml +func (gl *GL) ProgramUniform3f(program glbase.Program, location glbase.Uniform, v0, v1, v2 float32) { + C.gl4_1compat_glProgramUniform3f(gl.funcs, C.GLuint(program), C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3iv.xml +func (gl *GL) ProgramUniform3iv(program glbase.Program, location glbase.Uniform, count int, value []int32) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_1compat_glProgramUniform3iv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3i.xml +func (gl *GL) ProgramUniform3i(program glbase.Program, location glbase.Uniform, v0, v1, v2 int32) { + C.gl4_1compat_glProgramUniform3i(gl.funcs, C.GLuint(program), C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2uiv.xml +func (gl *GL) ProgramUniform2uiv(program glbase.Program, location glbase.Uniform, count int, value []uint32) { + C.gl4_1compat_glProgramUniform2uiv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2ui.xml +func (gl *GL) ProgramUniform2ui(program glbase.Program, location glbase.Uniform, v0, v1 uint32) { + C.gl4_1compat_glProgramUniform2ui(gl.funcs, C.GLuint(program), C.GLint(location), C.GLuint(v0), C.GLuint(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2dv.xml +func (gl *GL) ProgramUniform2dv(program glbase.Program, location glbase.Uniform, count int, value []float64) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_1compat_glProgramUniform2dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2d.xml +func (gl *GL) ProgramUniform2d(program glbase.Program, location glbase.Uniform, v0, v1 float64) { + C.gl4_1compat_glProgramUniform2d(gl.funcs, C.GLuint(program), C.GLint(location), C.GLdouble(v0), C.GLdouble(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2fv.xml +func (gl *GL) ProgramUniform2fv(program glbase.Program, location glbase.Uniform, count int, value []float32) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_1compat_glProgramUniform2fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2f.xml +func (gl *GL) ProgramUniform2f(program glbase.Program, location glbase.Uniform, v0, v1 float32) { + C.gl4_1compat_glProgramUniform2f(gl.funcs, C.GLuint(program), C.GLint(location), C.GLfloat(v0), C.GLfloat(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2iv.xml +func (gl *GL) ProgramUniform2iv(program glbase.Program, location glbase.Uniform, count int, value []int32) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_1compat_glProgramUniform2iv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2i.xml +func (gl *GL) ProgramUniform2i(program glbase.Program, location glbase.Uniform, v0, v1 int32) { + C.gl4_1compat_glProgramUniform2i(gl.funcs, C.GLuint(program), C.GLint(location), C.GLint(v0), C.GLint(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1uiv.xml +func (gl *GL) ProgramUniform1uiv(program glbase.Program, location glbase.Uniform, count int, value []uint32) { + C.gl4_1compat_glProgramUniform1uiv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1ui.xml +func (gl *GL) ProgramUniform1ui(program glbase.Program, location glbase.Uniform, v0 uint32) { + C.gl4_1compat_glProgramUniform1ui(gl.funcs, C.GLuint(program), C.GLint(location), C.GLuint(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1dv.xml +func (gl *GL) ProgramUniform1dv(program glbase.Program, location glbase.Uniform, count int, value []float64) { + C.gl4_1compat_glProgramUniform1dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1d.xml +func (gl *GL) ProgramUniform1d(program glbase.Program, location glbase.Uniform, v0 float64) { + C.gl4_1compat_glProgramUniform1d(gl.funcs, C.GLuint(program), C.GLint(location), C.GLdouble(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1fv.xml +func (gl *GL) ProgramUniform1fv(program glbase.Program, location glbase.Uniform, count int, value []float32) { + C.gl4_1compat_glProgramUniform1fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1f.xml +func (gl *GL) ProgramUniform1f(program glbase.Program, location glbase.Uniform, v0 float32) { + C.gl4_1compat_glProgramUniform1f(gl.funcs, C.GLuint(program), C.GLint(location), C.GLfloat(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1iv.xml +func (gl *GL) ProgramUniform1iv(program glbase.Program, location glbase.Uniform, count int, value []int32) { + C.gl4_1compat_glProgramUniform1iv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1i.xml +func (gl *GL) ProgramUniform1i(program glbase.Program, location glbase.Uniform, v0 int32) { + C.gl4_1compat_glProgramUniform1i(gl.funcs, C.GLuint(program), C.GLint(location), C.GLint(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramPipelineiv.xml +func (gl *GL) GetProgramPipelineiv(pipeline uint32, pname glbase.Enum, params []int32) { + C.gl4_1compat_glGetProgramPipelineiv(gl.funcs, C.GLuint(pipeline), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsProgramPipeline.xml +func (gl *GL) IsProgramPipeline(pipeline uint32) bool { + glresult := C.gl4_1compat_glIsProgramPipeline(gl.funcs, C.GLuint(pipeline)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenProgramPipelines.xml +func (gl *GL) GenProgramPipelines(n int, pipelines []uint32) { + C.gl4_1compat_glGenProgramPipelines(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&pipelines[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteProgramPipelines.xml +func (gl *GL) DeleteProgramPipelines(n int, pipelines []uint32) { + C.gl4_1compat_glDeleteProgramPipelines(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&pipelines[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindProgramPipeline.xml +func (gl *GL) BindProgramPipeline(pipeline uint32) { + C.gl4_1compat_glBindProgramPipeline(gl.funcs, C.GLuint(pipeline)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glActiveShaderProgram.xml +func (gl *GL) ActiveShaderProgram(pipeline uint32, program glbase.Program) { + C.gl4_1compat_glActiveShaderProgram(gl.funcs, C.GLuint(pipeline), C.GLuint(program)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUseProgramStages.xml +func (gl *GL) UseProgramStages(pipeline uint32, stages glbase.Bitfield, program glbase.Program) { + C.gl4_1compat_glUseProgramStages(gl.funcs, C.GLuint(pipeline), C.GLbitfield(stages), C.GLuint(program)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramParameteri.xml +func (gl *GL) ProgramParameteri(program glbase.Program, pname glbase.Enum, value int32) { + C.gl4_1compat_glProgramParameteri(gl.funcs, C.GLuint(program), C.GLenum(pname), C.GLint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramBinary.xml +func (gl *GL) ProgramBinary(program glbase.Program, binaryFormat glbase.Enum, binary interface{}, length int32) { + var binary_ptr unsafe.Pointer + var binary_v = reflect.ValueOf(binary) + if binary != nil && binary_v.Kind() != reflect.Slice { + panic("parameter binary must be a slice") + } + if binary != nil { + binary_ptr = unsafe.Pointer(binary_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glProgramBinary(gl.funcs, C.GLuint(program), C.GLenum(binaryFormat), binary_ptr, C.GLsizei(length)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramBinary.xml +func (gl *GL) GetProgramBinary(program glbase.Program, bufSize int32, length []int32, binaryFormat []glbase.Enum, binary interface{}) { + var binary_ptr unsafe.Pointer + var binary_v = reflect.ValueOf(binary) + if binary != nil && binary_v.Kind() != reflect.Slice { + panic("parameter binary must be a slice") + } + if binary != nil { + binary_ptr = unsafe.Pointer(binary_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glGetProgramBinary(gl.funcs, C.GLuint(program), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLenum)(unsafe.Pointer(&binaryFormat[0])), binary_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearDepthf.xml +func (gl *GL) ClearDepthf(dd float32) { + C.gl4_1compat_glClearDepthf(gl.funcs, C.GLfloat(dd)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDepthRangef.xml +func (gl *GL) DepthRangef(n, f float32) { + C.gl4_1compat_glDepthRangef(gl.funcs, C.GLfloat(n), C.GLfloat(f)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetShaderPrecisionFormat.xml +func (gl *GL) GetShaderPrecisionFormat(shadertype, precisionType glbase.Enum, range_, precision []int32) { + C.gl4_1compat_glGetShaderPrecisionFormat(gl.funcs, C.GLenum(shadertype), C.GLenum(precisionType), (*C.GLint)(unsafe.Pointer(&range_[0])), (*C.GLint)(unsafe.Pointer(&precision[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glShaderBinary.xml +func (gl *GL) ShaderBinary(count int, shaders []glbase.Shader, binaryFormat glbase.Enum, binary interface{}, length int32) { + var binary_ptr unsafe.Pointer + var binary_v = reflect.ValueOf(binary) + if binary != nil && binary_v.Kind() != reflect.Slice { + panic("parameter binary must be a slice") + } + if binary != nil { + binary_ptr = unsafe.Pointer(binary_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glShaderBinary(gl.funcs, C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&shaders[0])), C.GLenum(binaryFormat), binary_ptr, C.GLsizei(length)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glReleaseShaderCompiler.xml +func (gl *GL) ReleaseShaderCompiler() { + C.gl4_1compat_glReleaseShaderCompiler(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTranslatef.xml +func (gl *GL) Translatef(x, y, z float32) { + C.gl4_1compat_glTranslatef(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTranslated.xml +func (gl *GL) Translated(x, y, z float64) { + C.gl4_1compat_glTranslated(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glScalef.xml +func (gl *GL) Scalef(x, y, z float32) { + C.gl4_1compat_glScalef(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glScaled.xml +func (gl *GL) Scaled(x, y, z float64) { + C.gl4_1compat_glScaled(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRotatef.xml +func (gl *GL) Rotatef(angle, x, y, z float32) { + C.gl4_1compat_glRotatef(gl.funcs, C.GLfloat(angle), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRotated.xml +func (gl *GL) Rotated(angle, x, y, z float64) { + C.gl4_1compat_glRotated(gl.funcs, C.GLdouble(angle), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPushMatrix.xml +func (gl *GL) PushMatrix() { + C.gl4_1compat_glPushMatrix(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPopMatrix.xml +func (gl *GL) PopMatrix() { + C.gl4_1compat_glPopMatrix(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glOrtho.xml +func (gl *GL) Ortho(left, right, bottom, top, zNear, zFar float64) { + C.gl4_1compat_glOrtho(gl.funcs, C.GLdouble(left), C.GLdouble(right), C.GLdouble(bottom), C.GLdouble(top), C.GLdouble(zNear), C.GLdouble(zFar)) +} + +// MultMatrixd multiplies the current matrix with the provided matrix. +// +// The m parameter must hold 16 consecutive elements of a 4x4 column-major matrix. +// +// The current matrix is determined by the current matrix mode (see +// MatrixMode). It is either the projection matrix, modelview matrix, or the +// texture matrix. +// +// For example, if the current matrix is C and the coordinates to be transformed +// are v = (v[0], v[1], v[2], v[3]), then the current transformation is C × v, or +// +// c[0] c[4] c[8] c[12] v[0] +// c[1] c[5] c[9] c[13] v[1] +// c[2] c[6] c[10] c[14] X v[2] +// c[3] c[7] c[11] c[15] v[3] +// +// Calling MultMatrix with an argument of m = m[0], m[1], ..., m[15] +// replaces the current transformation with (C X M) x v, or +// +// c[0] c[4] c[8] c[12] m[0] m[4] m[8] m[12] v[0] +// c[1] c[5] c[9] c[13] m[1] m[5] m[9] m[13] v[1] +// c[2] c[6] c[10] c[14] X m[2] m[6] m[10] m[14] X v[2] +// c[3] c[7] c[11] c[15] m[3] m[7] m[11] m[15] v[3] +// +// Where 'X' denotes matrix multiplication, and v is represented as a 4x1 matrix. +// +// While the elements of the matrix may be specified with single or double +// precision, the GL may store or operate on these values in less-than-single +// precision. +// +// In many computer languages, 4×4 arrays are represented in row-major +// order. The transformations just described represent these matrices in +// column-major order. The order of the multiplication is important. For +// example, if the current transformation is a rotation, and MultMatrix is +// called with a translation matrix, the translation is done directly on the +// coordinates to be transformed, while the rotation is done on the results +// of that translation. +// +// GL.INVALID_OPERATION is generated if MultMatrix is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) MultMatrixd(m []float64) { + if len(m) != 16 { + panic("parameter m must have length 16 for the 4x4 matrix") + } + C.gl4_1compat_glMultMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// MultMatrixf multiplies the current matrix with the provided matrix. +// +// The m parameter must hold 16 consecutive elements of a 4x4 column-major matrix. +// +// The current matrix is determined by the current matrix mode (see +// MatrixMode). It is either the projection matrix, modelview matrix, or the +// texture matrix. +// +// For example, if the current matrix is C and the coordinates to be transformed +// are v = (v[0], v[1], v[2], v[3]), then the current transformation is C × v, or +// +// c[0] c[4] c[8] c[12] v[0] +// c[1] c[5] c[9] c[13] v[1] +// c[2] c[6] c[10] c[14] X v[2] +// c[3] c[7] c[11] c[15] v[3] +// +// Calling MultMatrix with an argument of m = m[0], m[1], ..., m[15] +// replaces the current transformation with (C X M) x v, or +// +// c[0] c[4] c[8] c[12] m[0] m[4] m[8] m[12] v[0] +// c[1] c[5] c[9] c[13] m[1] m[5] m[9] m[13] v[1] +// c[2] c[6] c[10] c[14] X m[2] m[6] m[10] m[14] X v[2] +// c[3] c[7] c[11] c[15] m[3] m[7] m[11] m[15] v[3] +// +// Where 'X' denotes matrix multiplication, and v is represented as a 4x1 matrix. +// +// While the elements of the matrix may be specified with single or double +// precision, the GL may store or operate on these values in less-than-single +// precision. +// +// In many computer languages, 4×4 arrays are represented in row-major +// order. The transformations just described represent these matrices in +// column-major order. The order of the multiplication is important. For +// example, if the current transformation is a rotation, and MultMatrix is +// called with a translation matrix, the translation is done directly on the +// coordinates to be transformed, while the rotation is done on the results +// of that translation. +// +// GL.INVALID_OPERATION is generated if MultMatrix is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) MultMatrixf(m []float32) { + if len(m) != 16 { + panic("parameter m must have length 16 for the 4x4 matrix") + } + C.gl4_1compat_glMultMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMatrixMode.xml +func (gl *GL) MatrixMode(mode glbase.Enum) { + C.gl4_1compat_glMatrixMode(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLoadMatrixd.xml +func (gl *GL) LoadMatrixd(m []float64) { + C.gl4_1compat_glLoadMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLoadMatrixf.xml +func (gl *GL) LoadMatrixf(m []float32) { + C.gl4_1compat_glLoadMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLoadIdentity.xml +func (gl *GL) LoadIdentity() { + C.gl4_1compat_glLoadIdentity(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFrustum.xml +func (gl *GL) Frustum(left, right, bottom, top, zNear, zFar float64) { + C.gl4_1compat_glFrustum(gl.funcs, C.GLdouble(left), C.GLdouble(right), C.GLdouble(bottom), C.GLdouble(top), C.GLdouble(zNear), C.GLdouble(zFar)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsList.xml +func (gl *GL) IsList(list uint32) bool { + glresult := C.gl4_1compat_glIsList(gl.funcs, C.GLuint(list)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexGeniv.xml +func (gl *GL) GetTexGeniv(coord, pname glbase.Enum, params []int32) { + C.gl4_1compat_glGetTexGeniv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexGenfv.xml +func (gl *GL) GetTexGenfv(coord, pname glbase.Enum, params []float32) { + C.gl4_1compat_glGetTexGenfv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexGendv.xml +func (gl *GL) GetTexGendv(coord, pname glbase.Enum, params []float64) { + C.gl4_1compat_glGetTexGendv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexEnviv.xml +func (gl *GL) GetTexEnviv(target, pname glbase.Enum, params []int32) { + C.gl4_1compat_glGetTexEnviv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexEnvfv.xml +func (gl *GL) GetTexEnvfv(target, pname glbase.Enum, params []float32) { + C.gl4_1compat_glGetTexEnvfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetPolygonStipple.xml +func (gl *GL) GetPolygonStipple(mask []uint8) { + C.gl4_1compat_glGetPolygonStipple(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&mask[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetPixelMapusv.xml +func (gl *GL) GetPixelMapusv(glmap glbase.Enum, values []uint16) { + C.gl4_1compat_glGetPixelMapusv(gl.funcs, C.GLenum(glmap), (*C.GLushort)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetPixelMapuiv.xml +func (gl *GL) GetPixelMapuiv(glmap glbase.Enum, values []uint32) { + C.gl4_1compat_glGetPixelMapuiv(gl.funcs, C.GLenum(glmap), (*C.GLuint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetPixelMapfv.xml +func (gl *GL) GetPixelMapfv(glmap glbase.Enum, values []float32) { + C.gl4_1compat_glGetPixelMapfv(gl.funcs, C.GLenum(glmap), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMaterialiv.xml +func (gl *GL) GetMaterialiv(face, pname glbase.Enum, params []int32) { + C.gl4_1compat_glGetMaterialiv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMaterialfv.xml +func (gl *GL) GetMaterialfv(face, pname glbase.Enum, params []float32) { + C.gl4_1compat_glGetMaterialfv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMapiv.xml +func (gl *GL) GetMapiv(target, query glbase.Enum, v []int32) { + C.gl4_1compat_glGetMapiv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMapfv.xml +func (gl *GL) GetMapfv(target, query glbase.Enum, v []float32) { + C.gl4_1compat_glGetMapfv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMapdv.xml +func (gl *GL) GetMapdv(target, query glbase.Enum, v []float64) { + C.gl4_1compat_glGetMapdv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetLightiv.xml +func (gl *GL) GetLightiv(light, pname glbase.Enum, params []int32) { + C.gl4_1compat_glGetLightiv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetLightfv.xml +func (gl *GL) GetLightfv(light, pname glbase.Enum, params []float32) { + C.gl4_1compat_glGetLightfv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetClipPlane.xml +func (gl *GL) GetClipPlane(plane glbase.Enum, equation []float64) { + C.gl4_1compat_glGetClipPlane(gl.funcs, C.GLenum(plane), (*C.GLdouble)(unsafe.Pointer(&equation[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawPixels.xml +func (gl *GL) DrawPixels(width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glDrawPixels(gl.funcs, C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyPixels.xml +func (gl *GL) CopyPixels(x, y, width, height int, gltype glbase.Enum) { + C.gl4_1compat_glCopyPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(gltype)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelMapusv.xml +func (gl *GL) PixelMapusv(glmap glbase.Enum, mapsize int32, values []uint16) { + C.gl4_1compat_glPixelMapusv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLushort)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelMapuiv.xml +func (gl *GL) PixelMapuiv(glmap glbase.Enum, mapsize int32, values []uint32) { + C.gl4_1compat_glPixelMapuiv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLuint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelMapfv.xml +func (gl *GL) PixelMapfv(glmap glbase.Enum, mapsize int32, values []float32) { + C.gl4_1compat_glPixelMapfv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelTransferi.xml +func (gl *GL) PixelTransferi(pname glbase.Enum, param int32) { + C.gl4_1compat_glPixelTransferi(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelTransferf.xml +func (gl *GL) PixelTransferf(pname glbase.Enum, param float32) { + C.gl4_1compat_glPixelTransferf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelZoom.xml +func (gl *GL) PixelZoom(xfactor, yfactor float32) { + C.gl4_1compat_glPixelZoom(gl.funcs, C.GLfloat(xfactor), C.GLfloat(yfactor)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glAlphaFunc.xml +func (gl *GL) AlphaFunc(glfunc glbase.Enum, ref float32) { + C.gl4_1compat_glAlphaFunc(gl.funcs, C.GLenum(glfunc), C.GLfloat(ref)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalPoint2.xml +func (gl *GL) EvalPoint2(i, j int32) { + C.gl4_1compat_glEvalPoint2(gl.funcs, C.GLint(i), C.GLint(j)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalMesh2.xml +func (gl *GL) EvalMesh2(mode glbase.Enum, i1, i2, j1, j2 int32) { + C.gl4_1compat_glEvalMesh2(gl.funcs, C.GLenum(mode), C.GLint(i1), C.GLint(i2), C.GLint(j1), C.GLint(j2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalPoint1.xml +func (gl *GL) EvalPoint1(i int32) { + C.gl4_1compat_glEvalPoint1(gl.funcs, C.GLint(i)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalMesh1.xml +func (gl *GL) EvalMesh1(mode glbase.Enum, i1, i2 int32) { + C.gl4_1compat_glEvalMesh1(gl.funcs, C.GLenum(mode), C.GLint(i1), C.GLint(i2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalCoord2fv.xml +func (gl *GL) EvalCoord2fv(u []float32) { + if len(u) != 2 { + panic("parameter u has incorrect length") + } + C.gl4_1compat_glEvalCoord2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalCoord2f.xml +func (gl *GL) EvalCoord2f(u, v float32) { + C.gl4_1compat_glEvalCoord2f(gl.funcs, C.GLfloat(u), C.GLfloat(v)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalCoord2dv.xml +func (gl *GL) EvalCoord2dv(u []float64) { + if len(u) != 2 { + panic("parameter u has incorrect length") + } + C.gl4_1compat_glEvalCoord2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalCoord2d.xml +func (gl *GL) EvalCoord2d(u, v float64) { + C.gl4_1compat_glEvalCoord2d(gl.funcs, C.GLdouble(u), C.GLdouble(v)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalCoord1fv.xml +func (gl *GL) EvalCoord1fv(u []float32) { + C.gl4_1compat_glEvalCoord1fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalCoord1f.xml +func (gl *GL) EvalCoord1f(u float32) { + C.gl4_1compat_glEvalCoord1f(gl.funcs, C.GLfloat(u)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalCoord1dv.xml +func (gl *GL) EvalCoord1dv(u []float64) { + C.gl4_1compat_glEvalCoord1dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalCoord1d.xml +func (gl *GL) EvalCoord1d(u float64) { + C.gl4_1compat_glEvalCoord1d(gl.funcs, C.GLdouble(u)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMapGrid2f.xml +func (gl *GL) MapGrid2f(un int32, u1, u2 float32, vn int32, v1, v2 float32) { + C.gl4_1compat_glMapGrid2f(gl.funcs, C.GLint(un), C.GLfloat(u1), C.GLfloat(u2), C.GLint(vn), C.GLfloat(v1), C.GLfloat(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMapGrid2d.xml +func (gl *GL) MapGrid2d(un int32, u1, u2 float64, vn int32, v1, v2 float64) { + C.gl4_1compat_glMapGrid2d(gl.funcs, C.GLint(un), C.GLdouble(u1), C.GLdouble(u2), C.GLint(vn), C.GLdouble(v1), C.GLdouble(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMapGrid1f.xml +func (gl *GL) MapGrid1f(un int32, u1, u2 float32) { + C.gl4_1compat_glMapGrid1f(gl.funcs, C.GLint(un), C.GLfloat(u1), C.GLfloat(u2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMapGrid1d.xml +func (gl *GL) MapGrid1d(un int32, u1, u2 float64) { + C.gl4_1compat_glMapGrid1d(gl.funcs, C.GLint(un), C.GLdouble(u1), C.GLdouble(u2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMap2f.xml +func (gl *GL) Map2f(target glbase.Enum, u1, u2 float32, ustride, uorder int32, v1, v2 float32, vstride, vorder int32, points []float32) { + C.gl4_1compat_glMap2f(gl.funcs, C.GLenum(target), C.GLfloat(u1), C.GLfloat(u2), C.GLint(ustride), C.GLint(uorder), C.GLfloat(v1), C.GLfloat(v2), C.GLint(vstride), C.GLint(vorder), (*C.GLfloat)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMap2d.xml +func (gl *GL) Map2d(target glbase.Enum, u1, u2 float64, ustride, uorder int32, v1, v2 float64, vstride, vorder int32, points []float64) { + C.gl4_1compat_glMap2d(gl.funcs, C.GLenum(target), C.GLdouble(u1), C.GLdouble(u2), C.GLint(ustride), C.GLint(uorder), C.GLdouble(v1), C.GLdouble(v2), C.GLint(vstride), C.GLint(vorder), (*C.GLdouble)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMap1f.xml +func (gl *GL) Map1f(target glbase.Enum, u1, u2 float32, stride, order int, points []float32) { + C.gl4_1compat_glMap1f(gl.funcs, C.GLenum(target), C.GLfloat(u1), C.GLfloat(u2), C.GLint(stride), C.GLint(order), (*C.GLfloat)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMap1d.xml +func (gl *GL) Map1d(target glbase.Enum, u1, u2 float64, stride, order int, points []float64) { + C.gl4_1compat_glMap1d(gl.funcs, C.GLenum(target), C.GLdouble(u1), C.GLdouble(u2), C.GLint(stride), C.GLint(order), (*C.GLdouble)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPushAttrib.xml +func (gl *GL) PushAttrib(mask glbase.Bitfield) { + C.gl4_1compat_glPushAttrib(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPopAttrib.xml +func (gl *GL) PopAttrib() { + C.gl4_1compat_glPopAttrib(gl.funcs) +} + +// Accum executes an operation on the accumulation buffer. +// +// Parameter op defines the accumulation buffer operation (GL.ACCUM, GL.LOAD, +// GL.ADD, GL.MULT, or GL.RETURN) and specifies how the value parameter is +// used. +// +// The accumulation buffer is an extended-range color buffer. Images are not +// rendered into it. Rather, images rendered into one of the color buffers +// are added to the contents of the accumulation buffer after rendering. +// Effects such as antialiasing (of points, lines, and polygons), motion +// blur, and depth of field can be created by accumulating images generated +// with different transformation matrices. +// +// Each pixel in the accumulation buffer consists of red, green, blue, and +// alpha values. The number of bits per component in the accumulation buffer +// depends on the implementation. You can examine this number by calling +// GetIntegerv four times, with arguments GL.ACCUM_RED_BITS, +// GL.ACCUM_GREEN_BITS, GL.ACCUM_BLUE_BITS, and GL.ACCUM_ALPHA_BITS. +// Regardless of the number of bits per component, the range of values stored +// by each component is (-1, 1). The accumulation buffer pixels are mapped +// one-to-one with frame buffer pixels. +// +// All accumulation buffer operations are limited to the area of the current +// scissor box and applied identically to the red, green, blue, and alpha +// components of each pixel. If a Accum operation results in a value outside +// the range (-1, 1), the contents of an accumulation buffer pixel component +// are undefined. +// +// The operations are as follows: +// +// GL.ACCUM +// Obtains R, G, B, and A values from the buffer currently selected for +// reading (see ReadBuffer). Each component value is divided by 2 n - +// 1 , where n is the number of bits allocated to each color component +// in the currently selected buffer. The result is a floating-point +// value in the range 0 1 , which is multiplied by value and added to +// the corresponding pixel component in the accumulation buffer, +// thereby updating the accumulation buffer. +// +// GL.LOAD +// Similar to GL.ACCUM, except that the current value in the +// accumulation buffer is not used in the calculation of the new value. +// That is, the R, G, B, and A values from the currently selected +// buffer are divided by 2 n - 1 , multiplied by value, and then stored +// in the corresponding accumulation buffer cell, overwriting the +// current value. +// +// GL.ADD +// Adds value to each R, G, B, and A in the accumulation buffer. +// +// GL.MULT +// Multiplies each R, G, B, and A in the accumulation buffer by value +// and returns the scaled component to its corresponding accumulation +// buffer location. +// +// GL.RETURN +// Transfers accumulation buffer values to the color buffer or buffers +// currently selected for writing. Each R, G, B, and A component is +// multiplied by value, then multiplied by 2 n - 1 , clamped to the +// range 0 2 n - 1 , and stored in the corresponding display buffer +// cell. The only fragment operations that are applied to this transfer +// are pixel ownership, scissor, dithering, and color writemasks. +// +// To clear the accumulation buffer, call ClearAccum with R, G, B, and A +// values to set it to, then call Clear with the accumulation buffer +// enabled. +// +// Error GL.INVALID_ENUM is generated if op is not an accepted value. +// GL.INVALID_OPERATION is generated if there is no accumulation buffer. +// GL.INVALID_OPERATION is generated if Accum is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) Accum(op glbase.Enum, value float32) { + C.gl4_1compat_glAccum(gl.funcs, C.GLenum(op), C.GLfloat(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexMask.xml +func (gl *GL) IndexMask(mask uint32) { + C.gl4_1compat_glIndexMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearIndex.xml +func (gl *GL) ClearIndex(c float32) { + C.gl4_1compat_glClearIndex(gl.funcs, C.GLfloat(c)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearAccum.xml +func (gl *GL) ClearAccum(red, green, blue, alpha float32) { + C.gl4_1compat_glClearAccum(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPushName.xml +func (gl *GL) PushName(name uint32) { + C.gl4_1compat_glPushName(gl.funcs, C.GLuint(name)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPopName.xml +func (gl *GL) PopName() { + C.gl4_1compat_glPopName(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPassThrough.xml +func (gl *GL) PassThrough(token float32) { + C.gl4_1compat_glPassThrough(gl.funcs, C.GLfloat(token)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLoadName.xml +func (gl *GL) LoadName(name uint32) { + C.gl4_1compat_glLoadName(gl.funcs, C.GLuint(name)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glInitNames.xml +func (gl *GL) InitNames() { + C.gl4_1compat_glInitNames(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRenderMode.xml +func (gl *GL) RenderMode(mode glbase.Enum) int32 { + glresult := C.gl4_1compat_glRenderMode(gl.funcs, C.GLenum(mode)) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSelectBuffer.xml +func (gl *GL) SelectBuffer(size int, buffer []glbase.Buffer) { + C.gl4_1compat_glSelectBuffer(gl.funcs, C.GLsizei(size), (*C.GLuint)(unsafe.Pointer(&buffer[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFeedbackBuffer.xml +func (gl *GL) FeedbackBuffer(size int, gltype glbase.Enum, buffer []float32) { + C.gl4_1compat_glFeedbackBuffer(gl.funcs, C.GLsizei(size), C.GLenum(gltype), (*C.GLfloat)(unsafe.Pointer(&buffer[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexGeniv.xml +func (gl *GL) TexGeniv(coord, pname glbase.Enum, params []int32) { + C.gl4_1compat_glTexGeniv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexGeni.xml +func (gl *GL) TexGeni(coord, pname glbase.Enum, param int32) { + C.gl4_1compat_glTexGeni(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexGenfv.xml +func (gl *GL) TexGenfv(coord, pname glbase.Enum, params []float32) { + C.gl4_1compat_glTexGenfv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexGenf.xml +func (gl *GL) TexGenf(coord, pname glbase.Enum, param float32) { + C.gl4_1compat_glTexGenf(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexGendv.xml +func (gl *GL) TexGendv(coord, pname glbase.Enum, params []float64) { + C.gl4_1compat_glTexGendv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexGend.xml +func (gl *GL) TexGend(coord, pname glbase.Enum, param float64) { + C.gl4_1compat_glTexGend(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLdouble(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexEnviv.xml +func (gl *GL) TexEnviv(target, pname glbase.Enum, params []int32) { + C.gl4_1compat_glTexEnviv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexEnvi.xml +func (gl *GL) TexEnvi(target, pname glbase.Enum, param int32) { + C.gl4_1compat_glTexEnvi(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexEnvfv.xml +func (gl *GL) TexEnvfv(target, pname glbase.Enum, params []float32) { + C.gl4_1compat_glTexEnvfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexEnvf.xml +func (gl *GL) TexEnvf(target, pname glbase.Enum, param float32) { + C.gl4_1compat_glTexEnvf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glShadeModel.xml +func (gl *GL) ShadeModel(mode glbase.Enum) { + C.gl4_1compat_glShadeModel(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPolygonStipple.xml +func (gl *GL) PolygonStipple(mask []uint8) { + C.gl4_1compat_glPolygonStipple(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&mask[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMaterialiv.xml +func (gl *GL) Materialiv(face, pname glbase.Enum, params []int32) { + C.gl4_1compat_glMaterialiv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMateriali.xml +func (gl *GL) Materiali(face, pname glbase.Enum, param int32) { + C.gl4_1compat_glMateriali(gl.funcs, C.GLenum(face), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMaterialfv.xml +func (gl *GL) Materialfv(face, pname glbase.Enum, params []float32) { + C.gl4_1compat_glMaterialfv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMaterialf.xml +func (gl *GL) Materialf(face, pname glbase.Enum, param float32) { + C.gl4_1compat_glMaterialf(gl.funcs, C.GLenum(face), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLineStipple.xml +func (gl *GL) LineStipple(factor int32, pattern uint16) { + C.gl4_1compat_glLineStipple(gl.funcs, C.GLint(factor), C.GLushort(pattern)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLightModeliv.xml +func (gl *GL) LightModeliv(pname glbase.Enum, params []int32) { + C.gl4_1compat_glLightModeliv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLightModeli.xml +func (gl *GL) LightModeli(pname glbase.Enum, param int32) { + C.gl4_1compat_glLightModeli(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLightModelfv.xml +func (gl *GL) LightModelfv(pname glbase.Enum, params []float32) { + C.gl4_1compat_glLightModelfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLightModelf.xml +func (gl *GL) LightModelf(pname glbase.Enum, param float32) { + C.gl4_1compat_glLightModelf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLightiv.xml +func (gl *GL) Lightiv(light, pname glbase.Enum, params []int32) { + C.gl4_1compat_glLightiv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLighti.xml +func (gl *GL) Lighti(light, pname glbase.Enum, param int32) { + C.gl4_1compat_glLighti(gl.funcs, C.GLenum(light), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLightfv.xml +func (gl *GL) Lightfv(light, pname glbase.Enum, params []float32) { + C.gl4_1compat_glLightfv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLightf.xml +func (gl *GL) Lightf(light, pname glbase.Enum, param float32) { + C.gl4_1compat_glLightf(gl.funcs, C.GLenum(light), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogiv.xml +func (gl *GL) Fogiv(pname glbase.Enum, params []int32) { + C.gl4_1compat_glFogiv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogi.xml +func (gl *GL) Fogi(pname glbase.Enum, param int32) { + C.gl4_1compat_glFogi(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogfv.xml +func (gl *GL) Fogfv(pname glbase.Enum, params []float32) { + C.gl4_1compat_glFogfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogf.xml +func (gl *GL) Fogf(pname glbase.Enum, param float32) { + C.gl4_1compat_glFogf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorMaterial.xml +func (gl *GL) ColorMaterial(face, mode glbase.Enum) { + C.gl4_1compat_glColorMaterial(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClipPlane.xml +func (gl *GL) ClipPlane(plane glbase.Enum, equation []float64) { + C.gl4_1compat_glClipPlane(gl.funcs, C.GLenum(plane), (*C.GLdouble)(unsafe.Pointer(&equation[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex4sv.xml +func (gl *GL) Vertex4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glVertex4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex4s.xml +func (gl *GL) Vertex4s(x, y, z, w int16) { + C.gl4_1compat_glVertex4s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex4iv.xml +func (gl *GL) Vertex4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glVertex4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex4i.xml +func (gl *GL) Vertex4i(x, y, z, w int) { + C.gl4_1compat_glVertex4i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex4fv.xml +func (gl *GL) Vertex4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glVertex4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex4f.xml +func (gl *GL) Vertex4f(x, y, z, w float32) { + C.gl4_1compat_glVertex4f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex4dv.xml +func (gl *GL) Vertex4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glVertex4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex4d.xml +func (gl *GL) Vertex4d(x, y, z, w float64) { + C.gl4_1compat_glVertex4d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex3sv.xml +func (gl *GL) Vertex3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glVertex3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex3s.xml +func (gl *GL) Vertex3s(x, y, z int16) { + C.gl4_1compat_glVertex3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex3iv.xml +func (gl *GL) Vertex3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glVertex3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex3i.xml +func (gl *GL) Vertex3i(x, y, z int) { + C.gl4_1compat_glVertex3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex3fv.xml +func (gl *GL) Vertex3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glVertex3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex3f.xml +func (gl *GL) Vertex3f(x, y, z float32) { + C.gl4_1compat_glVertex3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex3dv.xml +func (gl *GL) Vertex3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glVertex3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex3d.xml +func (gl *GL) Vertex3d(x, y, z float64) { + C.gl4_1compat_glVertex3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex2sv.xml +func (gl *GL) Vertex2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glVertex2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex2s.xml +func (gl *GL) Vertex2s(x, y int16) { + C.gl4_1compat_glVertex2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex2iv.xml +func (gl *GL) Vertex2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glVertex2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex2i.xml +func (gl *GL) Vertex2i(x, y int) { + C.gl4_1compat_glVertex2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex2fv.xml +func (gl *GL) Vertex2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glVertex2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex2f.xml +func (gl *GL) Vertex2f(x, y float32) { + C.gl4_1compat_glVertex2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex2dv.xml +func (gl *GL) Vertex2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glVertex2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex2d.xml +func (gl *GL) Vertex2d(x, y float64) { + C.gl4_1compat_glVertex2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord4sv.xml +func (gl *GL) TexCoord4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glTexCoord4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord4s.xml +func (gl *GL) TexCoord4s(s, t, r, q int16) { + C.gl4_1compat_glTexCoord4s(gl.funcs, C.GLshort(s), C.GLshort(t), C.GLshort(r), C.GLshort(q)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord4iv.xml +func (gl *GL) TexCoord4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glTexCoord4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord4i.xml +func (gl *GL) TexCoord4i(s, t, r, q int32) { + C.gl4_1compat_glTexCoord4i(gl.funcs, C.GLint(s), C.GLint(t), C.GLint(r), C.GLint(q)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord4fv.xml +func (gl *GL) TexCoord4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glTexCoord4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord4f.xml +func (gl *GL) TexCoord4f(s, t, r, q float32) { + C.gl4_1compat_glTexCoord4f(gl.funcs, C.GLfloat(s), C.GLfloat(t), C.GLfloat(r), C.GLfloat(q)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord4dv.xml +func (gl *GL) TexCoord4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glTexCoord4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord4d.xml +func (gl *GL) TexCoord4d(s, t, r, q float64) { + C.gl4_1compat_glTexCoord4d(gl.funcs, C.GLdouble(s), C.GLdouble(t), C.GLdouble(r), C.GLdouble(q)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord3sv.xml +func (gl *GL) TexCoord3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glTexCoord3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord3s.xml +func (gl *GL) TexCoord3s(s, t, r int16) { + C.gl4_1compat_glTexCoord3s(gl.funcs, C.GLshort(s), C.GLshort(t), C.GLshort(r)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord3iv.xml +func (gl *GL) TexCoord3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glTexCoord3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord3i.xml +func (gl *GL) TexCoord3i(s, t, r int32) { + C.gl4_1compat_glTexCoord3i(gl.funcs, C.GLint(s), C.GLint(t), C.GLint(r)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord3fv.xml +func (gl *GL) TexCoord3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glTexCoord3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord3f.xml +func (gl *GL) TexCoord3f(s, t, r float32) { + C.gl4_1compat_glTexCoord3f(gl.funcs, C.GLfloat(s), C.GLfloat(t), C.GLfloat(r)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord3dv.xml +func (gl *GL) TexCoord3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glTexCoord3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord3d.xml +func (gl *GL) TexCoord3d(s, t, r float64) { + C.gl4_1compat_glTexCoord3d(gl.funcs, C.GLdouble(s), C.GLdouble(t), C.GLdouble(r)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord2sv.xml +func (gl *GL) TexCoord2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glTexCoord2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord2s.xml +func (gl *GL) TexCoord2s(s, t int16) { + C.gl4_1compat_glTexCoord2s(gl.funcs, C.GLshort(s), C.GLshort(t)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord2iv.xml +func (gl *GL) TexCoord2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glTexCoord2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord2i.xml +func (gl *GL) TexCoord2i(s, t int32) { + C.gl4_1compat_glTexCoord2i(gl.funcs, C.GLint(s), C.GLint(t)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord2fv.xml +func (gl *GL) TexCoord2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glTexCoord2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord2f.xml +func (gl *GL) TexCoord2f(s, t float32) { + C.gl4_1compat_glTexCoord2f(gl.funcs, C.GLfloat(s), C.GLfloat(t)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord2dv.xml +func (gl *GL) TexCoord2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glTexCoord2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord2d.xml +func (gl *GL) TexCoord2d(s, t float64) { + C.gl4_1compat_glTexCoord2d(gl.funcs, C.GLdouble(s), C.GLdouble(t)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord1sv.xml +func (gl *GL) TexCoord1sv(v []int16) { + C.gl4_1compat_glTexCoord1sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord1s.xml +func (gl *GL) TexCoord1s(s int16) { + C.gl4_1compat_glTexCoord1s(gl.funcs, C.GLshort(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord1iv.xml +func (gl *GL) TexCoord1iv(v []int32) { + C.gl4_1compat_glTexCoord1iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord1i.xml +func (gl *GL) TexCoord1i(s int32) { + C.gl4_1compat_glTexCoord1i(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord1fv.xml +func (gl *GL) TexCoord1fv(v []float32) { + C.gl4_1compat_glTexCoord1fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord1f.xml +func (gl *GL) TexCoord1f(s float32) { + C.gl4_1compat_glTexCoord1f(gl.funcs, C.GLfloat(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord1dv.xml +func (gl *GL) TexCoord1dv(v []float64) { + C.gl4_1compat_glTexCoord1dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord1d.xml +func (gl *GL) TexCoord1d(s float64) { + C.gl4_1compat_glTexCoord1d(gl.funcs, C.GLdouble(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRectsv.xml +func (gl *GL) Rectsv(v1, v2 []int16) { + C.gl4_1compat_glRectsv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v1[0])), (*C.GLshort)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRects.xml +func (gl *GL) Rects(x1, y1, x2, y2 int16) { + C.gl4_1compat_glRects(gl.funcs, C.GLshort(x1), C.GLshort(y1), C.GLshort(x2), C.GLshort(y2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRectiv.xml +func (gl *GL) Rectiv(v1, v2 []int32) { + C.gl4_1compat_glRectiv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v1[0])), (*C.GLint)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRecti.xml +func (gl *GL) Recti(x1, y1, x2, y2 int32) { + C.gl4_1compat_glRecti(gl.funcs, C.GLint(x1), C.GLint(y1), C.GLint(x2), C.GLint(y2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRectfv.xml +func (gl *GL) Rectfv(v1, v2 []float32) { + C.gl4_1compat_glRectfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v1[0])), (*C.GLfloat)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRectf.xml +func (gl *GL) Rectf(x1, y1, x2, y2 float32) { + C.gl4_1compat_glRectf(gl.funcs, C.GLfloat(x1), C.GLfloat(y1), C.GLfloat(x2), C.GLfloat(y2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRectdv.xml +func (gl *GL) Rectdv(v1, v2 []float64) { + C.gl4_1compat_glRectdv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v1[0])), (*C.GLdouble)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRectd.xml +func (gl *GL) Rectd(x1, y1, x2, y2 float64) { + C.gl4_1compat_glRectd(gl.funcs, C.GLdouble(x1), C.GLdouble(y1), C.GLdouble(x2), C.GLdouble(y2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos4sv.xml +func (gl *GL) RasterPos4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glRasterPos4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos4s.xml +func (gl *GL) RasterPos4s(x, y, z, w int16) { + C.gl4_1compat_glRasterPos4s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos4iv.xml +func (gl *GL) RasterPos4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glRasterPos4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos4i.xml +func (gl *GL) RasterPos4i(x, y, z, w int) { + C.gl4_1compat_glRasterPos4i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos4fv.xml +func (gl *GL) RasterPos4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glRasterPos4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos4f.xml +func (gl *GL) RasterPos4f(x, y, z, w float32) { + C.gl4_1compat_glRasterPos4f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos4dv.xml +func (gl *GL) RasterPos4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glRasterPos4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos4d.xml +func (gl *GL) RasterPos4d(x, y, z, w float64) { + C.gl4_1compat_glRasterPos4d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos3sv.xml +func (gl *GL) RasterPos3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glRasterPos3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos3s.xml +func (gl *GL) RasterPos3s(x, y, z int16) { + C.gl4_1compat_glRasterPos3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos3iv.xml +func (gl *GL) RasterPos3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glRasterPos3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos3i.xml +func (gl *GL) RasterPos3i(x, y, z int) { + C.gl4_1compat_glRasterPos3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos3fv.xml +func (gl *GL) RasterPos3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glRasterPos3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos3f.xml +func (gl *GL) RasterPos3f(x, y, z float32) { + C.gl4_1compat_glRasterPos3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos3dv.xml +func (gl *GL) RasterPos3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glRasterPos3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos3d.xml +func (gl *GL) RasterPos3d(x, y, z float64) { + C.gl4_1compat_glRasterPos3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos2sv.xml +func (gl *GL) RasterPos2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glRasterPos2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos2s.xml +func (gl *GL) RasterPos2s(x, y int16) { + C.gl4_1compat_glRasterPos2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos2iv.xml +func (gl *GL) RasterPos2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glRasterPos2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos2i.xml +func (gl *GL) RasterPos2i(x, y int) { + C.gl4_1compat_glRasterPos2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos2fv.xml +func (gl *GL) RasterPos2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glRasterPos2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos2f.xml +func (gl *GL) RasterPos2f(x, y float32) { + C.gl4_1compat_glRasterPos2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos2dv.xml +func (gl *GL) RasterPos2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glRasterPos2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos2d.xml +func (gl *GL) RasterPos2d(x, y float64) { + C.gl4_1compat_glRasterPos2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3sv.xml +func (gl *GL) Normal3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glNormal3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3s.xml +func (gl *GL) Normal3s(nx, ny, nz int16) { + C.gl4_1compat_glNormal3s(gl.funcs, C.GLshort(nx), C.GLshort(ny), C.GLshort(nz)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3iv.xml +func (gl *GL) Normal3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glNormal3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3i.xml +func (gl *GL) Normal3i(nx, ny, nz int32) { + C.gl4_1compat_glNormal3i(gl.funcs, C.GLint(nx), C.GLint(ny), C.GLint(nz)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3fv.xml +func (gl *GL) Normal3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glNormal3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3f.xml +func (gl *GL) Normal3f(nx, ny, nz float32) { + C.gl4_1compat_glNormal3f(gl.funcs, C.GLfloat(nx), C.GLfloat(ny), C.GLfloat(nz)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3dv.xml +func (gl *GL) Normal3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glNormal3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3d.xml +func (gl *GL) Normal3d(nx, ny, nz float64) { + C.gl4_1compat_glNormal3d(gl.funcs, C.GLdouble(nx), C.GLdouble(ny), C.GLdouble(nz)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3bv.xml +func (gl *GL) Normal3bv(v []byte) { + C.gl4_1compat_glNormal3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3b.xml +func (gl *GL) Normal3b(nx, ny, nz byte) { + C.gl4_1compat_glNormal3b(gl.funcs, C.GLbyte(nx), C.GLbyte(ny), C.GLbyte(nz)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexsv.xml +func (gl *GL) Indexsv(c []int16) { + C.gl4_1compat_glIndexsv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexs.xml +func (gl *GL) Indexs(c int16) { + C.gl4_1compat_glIndexs(gl.funcs, C.GLshort(c)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexiv.xml +func (gl *GL) Indexiv(c []int32) { + C.gl4_1compat_glIndexiv(gl.funcs, (*C.GLint)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexi.xml +func (gl *GL) Indexi(c int32) { + C.gl4_1compat_glIndexi(gl.funcs, C.GLint(c)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexfv.xml +func (gl *GL) Indexfv(c []float32) { + C.gl4_1compat_glIndexfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexf.xml +func (gl *GL) Indexf(c float32) { + C.gl4_1compat_glIndexf(gl.funcs, C.GLfloat(c)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexdv.xml +func (gl *GL) Indexdv(c []float64) { + C.gl4_1compat_glIndexdv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexd.xml +func (gl *GL) Indexd(c float64) { + C.gl4_1compat_glIndexd(gl.funcs, C.GLdouble(c)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEnd.xml +func (gl *GL) End() { + C.gl4_1compat_glEnd(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEdgeFlagv.xml +func (gl *GL) EdgeFlagv(flag []bool) { + C.gl4_1compat_glEdgeFlagv(gl.funcs, (*C.GLboolean)(unsafe.Pointer(&flag[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEdgeFlag.xml +func (gl *GL) EdgeFlag(flag bool) { + C.gl4_1compat_glEdgeFlag(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4usv.xml +func (gl *GL) Color4usv(v []uint16) { + C.gl4_1compat_glColor4usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4us.xml +func (gl *GL) Color4us(red, green, blue, alpha uint16) { + C.gl4_1compat_glColor4us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue), C.GLushort(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4uiv.xml +func (gl *GL) Color4uiv(v []uint32) { + C.gl4_1compat_glColor4uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4ui.xml +func (gl *GL) Color4ui(red, green, blue, alpha uint32) { + C.gl4_1compat_glColor4ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue), C.GLuint(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4ubv.xml +func (gl *GL) Color4ubv(v []uint8) { + C.gl4_1compat_glColor4ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4ub.xml +func (gl *GL) Color4ub(red, green, blue, alpha uint8) { + C.gl4_1compat_glColor4ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue), C.GLubyte(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4sv.xml +func (gl *GL) Color4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glColor4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4s.xml +func (gl *GL) Color4s(red, green, blue, alpha int16) { + C.gl4_1compat_glColor4s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue), C.GLshort(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4iv.xml +func (gl *GL) Color4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glColor4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4i.xml +func (gl *GL) Color4i(red, green, blue, alpha int32) { + C.gl4_1compat_glColor4i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue), C.GLint(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4fv.xml +func (gl *GL) Color4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glColor4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4f.xml +func (gl *GL) Color4f(red, green, blue, alpha float32) { + C.gl4_1compat_glColor4f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4dv.xml +func (gl *GL) Color4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glColor4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4d.xml +func (gl *GL) Color4d(red, green, blue, alpha float64) { + C.gl4_1compat_glColor4d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue), C.GLdouble(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4bv.xml +func (gl *GL) Color4bv(v []byte) { + C.gl4_1compat_glColor4bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4b.xml +func (gl *GL) Color4b(red, green, blue, alpha byte) { + C.gl4_1compat_glColor4b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue), C.GLbyte(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3usv.xml +func (gl *GL) Color3usv(v []uint16) { + C.gl4_1compat_glColor3usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3us.xml +func (gl *GL) Color3us(red, green, blue uint16) { + C.gl4_1compat_glColor3us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3uiv.xml +func (gl *GL) Color3uiv(v []uint32) { + C.gl4_1compat_glColor3uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3ui.xml +func (gl *GL) Color3ui(red, green, blue uint32) { + C.gl4_1compat_glColor3ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3ubv.xml +func (gl *GL) Color3ubv(v []uint8) { + C.gl4_1compat_glColor3ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3ub.xml +func (gl *GL) Color3ub(red, green, blue uint8) { + C.gl4_1compat_glColor3ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3sv.xml +func (gl *GL) Color3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glColor3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3s.xml +func (gl *GL) Color3s(red, green, blue int16) { + C.gl4_1compat_glColor3s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3iv.xml +func (gl *GL) Color3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glColor3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3i.xml +func (gl *GL) Color3i(red, green, blue int32) { + C.gl4_1compat_glColor3i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3fv.xml +func (gl *GL) Color3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glColor3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3f.xml +func (gl *GL) Color3f(red, green, blue float32) { + C.gl4_1compat_glColor3f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3dv.xml +func (gl *GL) Color3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glColor3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3d.xml +func (gl *GL) Color3d(red, green, blue float64) { + C.gl4_1compat_glColor3d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3bv.xml +func (gl *GL) Color3bv(v []byte) { + C.gl4_1compat_glColor3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3b.xml +func (gl *GL) Color3b(red, green, blue byte) { + C.gl4_1compat_glColor3b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBitmap.xml +func (gl *GL) Bitmap(width, height int, xorig, yorig, xmove, ymove float32, bitmap []uint8) { + C.gl4_1compat_glBitmap(gl.funcs, C.GLsizei(width), C.GLsizei(height), C.GLfloat(xorig), C.GLfloat(yorig), C.GLfloat(xmove), C.GLfloat(ymove), (*C.GLubyte)(unsafe.Pointer(&bitmap[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBegin.xml +func (gl *GL) Begin(mode glbase.Enum) { + C.gl4_1compat_glBegin(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glListBase.xml +func (gl *GL) ListBase(base uint32) { + C.gl4_1compat_glListBase(gl.funcs, C.GLuint(base)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenLists.xml +func (gl *GL) GenLists(range_ int32) uint32 { + glresult := C.gl4_1compat_glGenLists(gl.funcs, C.GLsizei(range_)) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteLists.xml +func (gl *GL) DeleteLists(list uint32, range_ int32) { + C.gl4_1compat_glDeleteLists(gl.funcs, C.GLuint(list), C.GLsizei(range_)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCallLists.xml +func (gl *GL) CallLists(n int, gltype glbase.Enum, lists interface{}) { + var lists_ptr unsafe.Pointer + var lists_v = reflect.ValueOf(lists) + if lists != nil && lists_v.Kind() != reflect.Slice { + panic("parameter lists must be a slice") + } + if lists != nil { + lists_ptr = unsafe.Pointer(lists_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glCallLists(gl.funcs, C.GLsizei(n), C.GLenum(gltype), lists_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCallList.xml +func (gl *GL) CallList(list uint32) { + C.gl4_1compat_glCallList(gl.funcs, C.GLuint(list)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndList.xml +func (gl *GL) EndList() { + C.gl4_1compat_glEndList(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNewList.xml +func (gl *GL) NewList(list uint32, mode glbase.Enum) { + C.gl4_1compat_glNewList(gl.funcs, C.GLuint(list), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPushClientAttrib.xml +func (gl *GL) PushClientAttrib(mask glbase.Bitfield) { + C.gl4_1compat_glPushClientAttrib(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPopClientAttrib.xml +func (gl *GL) PopClientAttrib() { + C.gl4_1compat_glPopClientAttrib(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPrioritizeTextures.xml +func (gl *GL) PrioritizeTextures(n int, textures []glbase.Texture, priorities []float32) { + C.gl4_1compat_glPrioritizeTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0])), (*C.GLfloat)(unsafe.Pointer(&priorities[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glAreTexturesResident.xml +func (gl *GL) AreTexturesResident(n int, textures []glbase.Texture, residences []bool) bool { + glresult := C.gl4_1compat_glAreTexturesResident(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0])), (*C.GLboolean)(unsafe.Pointer(&residences[0]))) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexPointer.xml +func (gl *GL) VertexPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glVertexPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordPointer.xml +func (gl *GL) TexCoordPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glTexCoordPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormalPointer.xml +func (gl *GL) NormalPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glNormalPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glInterleavedArrays.xml +func (gl *GL) InterleavedArrays(format glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glInterleavedArrays(gl.funcs, C.GLenum(format), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexPointer.xml +func (gl *GL) IndexPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glIndexPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEnableClientState.xml +func (gl *GL) EnableClientState(array glbase.Enum) { + C.gl4_1compat_glEnableClientState(gl.funcs, C.GLenum(array)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEdgeFlagPointer.xml +func (gl *GL) EdgeFlagPointer(stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glEdgeFlagPointer(gl.funcs, C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDisableClientState.xml +func (gl *GL) DisableClientState(array glbase.Enum) { + C.gl4_1compat_glDisableClientState(gl.funcs, C.GLenum(array)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorPointer.xml +func (gl *GL) ColorPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glColorPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glArrayElement.xml +func (gl *GL) ArrayElement(i int32) { + C.gl4_1compat_glArrayElement(gl.funcs, C.GLint(i)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glResetMinmax.xml +func (gl *GL) ResetMinmax(target glbase.Enum) { + C.gl4_1compat_glResetMinmax(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glResetHistogram.xml +func (gl *GL) ResetHistogram(target glbase.Enum) { + C.gl4_1compat_glResetHistogram(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMinmax.xml +func (gl *GL) Minmax(target, internalFormat glbase.Enum, sink bool) { + C.gl4_1compat_glMinmax(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), *(*C.GLboolean)(unsafe.Pointer(&sink))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glHistogram.xml +func (gl *GL) Histogram(target glbase.Enum, width int, internalFormat glbase.Enum, sink bool) { + C.gl4_1compat_glHistogram(gl.funcs, C.GLenum(target), C.GLsizei(width), C.GLenum(internalFormat), *(*C.GLboolean)(unsafe.Pointer(&sink))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMinmaxParameteriv.xml +func (gl *GL) GetMinmaxParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_1compat_glGetMinmaxParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMinmaxParameterfv.xml +func (gl *GL) GetMinmaxParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_1compat_glGetMinmaxParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMinmax.xml +func (gl *GL) GetMinmax(target glbase.Enum, reset bool, format, gltype glbase.Enum, values interface{}) { + var values_ptr unsafe.Pointer + var values_v = reflect.ValueOf(values) + if values != nil && values_v.Kind() != reflect.Slice { + panic("parameter values must be a slice") + } + if values != nil { + values_ptr = unsafe.Pointer(values_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glGetMinmax(gl.funcs, C.GLenum(target), *(*C.GLboolean)(unsafe.Pointer(&reset)), C.GLenum(format), C.GLenum(gltype), values_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetHistogramParameteriv.xml +func (gl *GL) GetHistogramParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_1compat_glGetHistogramParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetHistogramParameterfv.xml +func (gl *GL) GetHistogramParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_1compat_glGetHistogramParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetHistogram.xml +func (gl *GL) GetHistogram(target glbase.Enum, reset bool, format, gltype glbase.Enum, values interface{}) { + var values_ptr unsafe.Pointer + var values_v = reflect.ValueOf(values) + if values != nil && values_v.Kind() != reflect.Slice { + panic("parameter values must be a slice") + } + if values != nil { + values_ptr = unsafe.Pointer(values_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glGetHistogram(gl.funcs, C.GLenum(target), *(*C.GLboolean)(unsafe.Pointer(&reset)), C.GLenum(format), C.GLenum(gltype), values_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSeparableFilter2D.xml +func (gl *GL) SeparableFilter2D(target, internalFormat glbase.Enum, width, height int, format, gltype glbase.Enum, row, column interface{}) { + var row_ptr unsafe.Pointer + var row_v = reflect.ValueOf(row) + if row != nil && row_v.Kind() != reflect.Slice { + panic("parameter row must be a slice") + } + if row != nil { + row_ptr = unsafe.Pointer(row_v.Index(0).Addr().Pointer()) + } + var column_ptr unsafe.Pointer + var column_v = reflect.ValueOf(column) + if column != nil && column_v.Kind() != reflect.Slice { + panic("parameter column must be a slice") + } + if column != nil { + column_ptr = unsafe.Pointer(column_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glSeparableFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), row_ptr, column_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSeparableFilter.xml +func (gl *GL) GetSeparableFilter(target, format, gltype glbase.Enum, row, column, span interface{}) { + var row_ptr unsafe.Pointer + var row_v = reflect.ValueOf(row) + if row != nil && row_v.Kind() != reflect.Slice { + panic("parameter row must be a slice") + } + if row != nil { + row_ptr = unsafe.Pointer(row_v.Index(0).Addr().Pointer()) + } + var column_ptr unsafe.Pointer + var column_v = reflect.ValueOf(column) + if column != nil && column_v.Kind() != reflect.Slice { + panic("parameter column must be a slice") + } + if column != nil { + column_ptr = unsafe.Pointer(column_v.Index(0).Addr().Pointer()) + } + var span_ptr unsafe.Pointer + var span_v = reflect.ValueOf(span) + if span != nil && span_v.Kind() != reflect.Slice { + panic("parameter span must be a slice") + } + if span != nil { + span_ptr = unsafe.Pointer(span_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glGetSeparableFilter(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), row_ptr, column_ptr, span_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetConvolutionParameteriv.xml +func (gl *GL) GetConvolutionParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_1compat_glGetConvolutionParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetConvolutionParameterfv.xml +func (gl *GL) GetConvolutionParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_1compat_glGetConvolutionParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetConvolutionFilter.xml +func (gl *GL) GetConvolutionFilter(target, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glGetConvolutionFilter(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyConvolutionFilter2D.xml +func (gl *GL) CopyConvolutionFilter2D(target, internalFormat glbase.Enum, x, y, width, height int) { + C.gl4_1compat_glCopyConvolutionFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyConvolutionFilter1D.xml +func (gl *GL) CopyConvolutionFilter1D(target, internalFormat glbase.Enum, x, y, width int) { + C.gl4_1compat_glCopyConvolutionFilter1D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glConvolutionParameteriv.xml +func (gl *GL) ConvolutionParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_1compat_glConvolutionParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glConvolutionParameteri.xml +func (gl *GL) ConvolutionParameteri(target, pname glbase.Enum, params int32) { + C.gl4_1compat_glConvolutionParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(params)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glConvolutionParameterfv.xml +func (gl *GL) ConvolutionParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_1compat_glConvolutionParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glConvolutionParameterf.xml +func (gl *GL) ConvolutionParameterf(target, pname glbase.Enum, params float32) { + C.gl4_1compat_glConvolutionParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(params)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glConvolutionFilter2D.xml +func (gl *GL) ConvolutionFilter2D(target, internalFormat glbase.Enum, width, height int, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glConvolutionFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glConvolutionFilter1D.xml +func (gl *GL) ConvolutionFilter1D(target, internalFormat glbase.Enum, width int, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glConvolutionFilter1D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyColorSubTable.xml +func (gl *GL) CopyColorSubTable(target glbase.Enum, start int32, x, y, width int) { + C.gl4_1compat_glCopyColorSubTable(gl.funcs, C.GLenum(target), C.GLsizei(start), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorSubTable.xml +func (gl *GL) ColorSubTable(target glbase.Enum, start int32, count int, format, gltype glbase.Enum, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glColorSubTable(gl.funcs, C.GLenum(target), C.GLsizei(start), C.GLsizei(count), C.GLenum(format), C.GLenum(gltype), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetColorTableParameteriv.xml +func (gl *GL) GetColorTableParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_1compat_glGetColorTableParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetColorTableParameterfv.xml +func (gl *GL) GetColorTableParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_1compat_glGetColorTableParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetColorTable.xml +func (gl *GL) GetColorTable(target, format, gltype glbase.Enum, table interface{}) { + var table_ptr unsafe.Pointer + var table_v = reflect.ValueOf(table) + if table != nil && table_v.Kind() != reflect.Slice { + panic("parameter table must be a slice") + } + if table != nil { + table_ptr = unsafe.Pointer(table_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glGetColorTable(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), table_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyColorTable.xml +func (gl *GL) CopyColorTable(target, internalFormat glbase.Enum, x, y, width int) { + C.gl4_1compat_glCopyColorTable(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorTableParameteriv.xml +func (gl *GL) ColorTableParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_1compat_glColorTableParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorTableParameterfv.xml +func (gl *GL) ColorTableParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_1compat_glColorTableParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorTable.xml +func (gl *GL) ColorTable(target, internalFormat glbase.Enum, width int, format, gltype glbase.Enum, table interface{}) { + var table_ptr unsafe.Pointer + var table_v = reflect.ValueOf(table) + if table != nil && table_v.Kind() != reflect.Slice { + panic("parameter table must be a slice") + } + if table != nil { + table_ptr = unsafe.Pointer(table_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glColorTable(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), table_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultTransposeMatrixd.xml +func (gl *GL) MultTransposeMatrixd(m []float64) { + C.gl4_1compat_glMultTransposeMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultTransposeMatrixf.xml +func (gl *GL) MultTransposeMatrixf(m []float32) { + C.gl4_1compat_glMultTransposeMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLoadTransposeMatrixd.xml +func (gl *GL) LoadTransposeMatrixd(m []float64) { + C.gl4_1compat_glLoadTransposeMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLoadTransposeMatrixf.xml +func (gl *GL) LoadTransposeMatrixf(m []float32) { + C.gl4_1compat_glLoadTransposeMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord4sv.xml +func (gl *GL) MultiTexCoord4sv(target glbase.Enum, v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glMultiTexCoord4sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord4s.xml +func (gl *GL) MultiTexCoord4s(target glbase.Enum, s, t, r, q int16) { + C.gl4_1compat_glMultiTexCoord4s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t), C.GLshort(r), C.GLshort(q)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord4iv.xml +func (gl *GL) MultiTexCoord4iv(target glbase.Enum, v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glMultiTexCoord4iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord4i.xml +func (gl *GL) MultiTexCoord4i(target glbase.Enum, s, t, r, q int32) { + C.gl4_1compat_glMultiTexCoord4i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t), C.GLint(r), C.GLint(q)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord4fv.xml +func (gl *GL) MultiTexCoord4fv(target glbase.Enum, v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glMultiTexCoord4fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord4f.xml +func (gl *GL) MultiTexCoord4f(target glbase.Enum, s, t, r, q float32) { + C.gl4_1compat_glMultiTexCoord4f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t), C.GLfloat(r), C.GLfloat(q)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord4dv.xml +func (gl *GL) MultiTexCoord4dv(target glbase.Enum, v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glMultiTexCoord4dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord4d.xml +func (gl *GL) MultiTexCoord4d(target glbase.Enum, s, t, r, q float64) { + C.gl4_1compat_glMultiTexCoord4d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t), C.GLdouble(r), C.GLdouble(q)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord3sv.xml +func (gl *GL) MultiTexCoord3sv(target glbase.Enum, v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glMultiTexCoord3sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord3s.xml +func (gl *GL) MultiTexCoord3s(target glbase.Enum, s, t, r int16) { + C.gl4_1compat_glMultiTexCoord3s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t), C.GLshort(r)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord3iv.xml +func (gl *GL) MultiTexCoord3iv(target glbase.Enum, v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glMultiTexCoord3iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord3i.xml +func (gl *GL) MultiTexCoord3i(target glbase.Enum, s, t, r int32) { + C.gl4_1compat_glMultiTexCoord3i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t), C.GLint(r)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord3fv.xml +func (gl *GL) MultiTexCoord3fv(target glbase.Enum, v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glMultiTexCoord3fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord3f.xml +func (gl *GL) MultiTexCoord3f(target glbase.Enum, s, t, r float32) { + C.gl4_1compat_glMultiTexCoord3f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t), C.GLfloat(r)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord3dv.xml +func (gl *GL) MultiTexCoord3dv(target glbase.Enum, v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glMultiTexCoord3dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord3d.xml +func (gl *GL) MultiTexCoord3d(target glbase.Enum, s, t, r float64) { + C.gl4_1compat_glMultiTexCoord3d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t), C.GLdouble(r)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord2sv.xml +func (gl *GL) MultiTexCoord2sv(target glbase.Enum, v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glMultiTexCoord2sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord2s.xml +func (gl *GL) MultiTexCoord2s(target glbase.Enum, s, t int16) { + C.gl4_1compat_glMultiTexCoord2s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord2iv.xml +func (gl *GL) MultiTexCoord2iv(target glbase.Enum, v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glMultiTexCoord2iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord2i.xml +func (gl *GL) MultiTexCoord2i(target glbase.Enum, s, t int32) { + C.gl4_1compat_glMultiTexCoord2i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord2fv.xml +func (gl *GL) MultiTexCoord2fv(target glbase.Enum, v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glMultiTexCoord2fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord2f.xml +func (gl *GL) MultiTexCoord2f(target glbase.Enum, s, t float32) { + C.gl4_1compat_glMultiTexCoord2f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord2dv.xml +func (gl *GL) MultiTexCoord2dv(target glbase.Enum, v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glMultiTexCoord2dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord2d.xml +func (gl *GL) MultiTexCoord2d(target glbase.Enum, s, t float64) { + C.gl4_1compat_glMultiTexCoord2d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord1sv.xml +func (gl *GL) MultiTexCoord1sv(target glbase.Enum, v []int16) { + C.gl4_1compat_glMultiTexCoord1sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord1s.xml +func (gl *GL) MultiTexCoord1s(target glbase.Enum, s int16) { + C.gl4_1compat_glMultiTexCoord1s(gl.funcs, C.GLenum(target), C.GLshort(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord1iv.xml +func (gl *GL) MultiTexCoord1iv(target glbase.Enum, v []int32) { + C.gl4_1compat_glMultiTexCoord1iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord1i.xml +func (gl *GL) MultiTexCoord1i(target glbase.Enum, s int32) { + C.gl4_1compat_glMultiTexCoord1i(gl.funcs, C.GLenum(target), C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord1fv.xml +func (gl *GL) MultiTexCoord1fv(target glbase.Enum, v []float32) { + C.gl4_1compat_glMultiTexCoord1fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord1f.xml +func (gl *GL) MultiTexCoord1f(target glbase.Enum, s float32) { + C.gl4_1compat_glMultiTexCoord1f(gl.funcs, C.GLenum(target), C.GLfloat(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord1dv.xml +func (gl *GL) MultiTexCoord1dv(target glbase.Enum, v []float64) { + C.gl4_1compat_glMultiTexCoord1dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord1d.xml +func (gl *GL) MultiTexCoord1d(target glbase.Enum, s float64) { + C.gl4_1compat_glMultiTexCoord1d(gl.funcs, C.GLenum(target), C.GLdouble(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClientActiveTexture.xml +func (gl *GL) ClientActiveTexture(texture glbase.Enum) { + C.gl4_1compat_glClientActiveTexture(gl.funcs, C.GLenum(texture)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos3sv.xml +func (gl *GL) WindowPos3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glWindowPos3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos3s.xml +func (gl *GL) WindowPos3s(x, y, z int16) { + C.gl4_1compat_glWindowPos3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos3iv.xml +func (gl *GL) WindowPos3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glWindowPos3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos3i.xml +func (gl *GL) WindowPos3i(x, y, z int) { + C.gl4_1compat_glWindowPos3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos3fv.xml +func (gl *GL) WindowPos3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glWindowPos3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos3f.xml +func (gl *GL) WindowPos3f(x, y, z float32) { + C.gl4_1compat_glWindowPos3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos3dv.xml +func (gl *GL) WindowPos3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glWindowPos3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos3d.xml +func (gl *GL) WindowPos3d(x, y, z float64) { + C.gl4_1compat_glWindowPos3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos2sv.xml +func (gl *GL) WindowPos2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glWindowPos2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos2s.xml +func (gl *GL) WindowPos2s(x, y int16) { + C.gl4_1compat_glWindowPos2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos2iv.xml +func (gl *GL) WindowPos2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glWindowPos2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos2i.xml +func (gl *GL) WindowPos2i(x, y int) { + C.gl4_1compat_glWindowPos2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos2fv.xml +func (gl *GL) WindowPos2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glWindowPos2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos2f.xml +func (gl *GL) WindowPos2f(x, y float32) { + C.gl4_1compat_glWindowPos2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos2dv.xml +func (gl *GL) WindowPos2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glWindowPos2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos2d.xml +func (gl *GL) WindowPos2d(x, y float64) { + C.gl4_1compat_glWindowPos2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColorPointer.xml +func (gl *GL) SecondaryColorPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glSecondaryColorPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3usv.xml +func (gl *GL) SecondaryColor3usv(v []uint16) { + C.gl4_1compat_glSecondaryColor3usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3us.xml +func (gl *GL) SecondaryColor3us(red, green, blue uint16) { + C.gl4_1compat_glSecondaryColor3us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3uiv.xml +func (gl *GL) SecondaryColor3uiv(v []uint32) { + C.gl4_1compat_glSecondaryColor3uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3ui.xml +func (gl *GL) SecondaryColor3ui(red, green, blue uint32) { + C.gl4_1compat_glSecondaryColor3ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3ubv.xml +func (gl *GL) SecondaryColor3ubv(v []uint8) { + C.gl4_1compat_glSecondaryColor3ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3ub.xml +func (gl *GL) SecondaryColor3ub(red, green, blue uint8) { + C.gl4_1compat_glSecondaryColor3ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3sv.xml +func (gl *GL) SecondaryColor3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glSecondaryColor3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3s.xml +func (gl *GL) SecondaryColor3s(red, green, blue int16) { + C.gl4_1compat_glSecondaryColor3s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3iv.xml +func (gl *GL) SecondaryColor3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glSecondaryColor3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3i.xml +func (gl *GL) SecondaryColor3i(red, green, blue int32) { + C.gl4_1compat_glSecondaryColor3i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3fv.xml +func (gl *GL) SecondaryColor3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glSecondaryColor3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3f.xml +func (gl *GL) SecondaryColor3f(red, green, blue float32) { + C.gl4_1compat_glSecondaryColor3f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3dv.xml +func (gl *GL) SecondaryColor3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glSecondaryColor3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3d.xml +func (gl *GL) SecondaryColor3d(red, green, blue float64) { + C.gl4_1compat_glSecondaryColor3d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3bv.xml +func (gl *GL) SecondaryColor3bv(v []byte) { + C.gl4_1compat_glSecondaryColor3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3b.xml +func (gl *GL) SecondaryColor3b(red, green, blue byte) { + C.gl4_1compat_glSecondaryColor3b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogCoordPointer.xml +func (gl *GL) FogCoordPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_1compat_glFogCoordPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogCoorddv.xml +func (gl *GL) FogCoorddv(coord []float64) { + C.gl4_1compat_glFogCoorddv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&coord[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogCoordd.xml +func (gl *GL) FogCoordd(coord float64) { + C.gl4_1compat_glFogCoordd(gl.funcs, C.GLdouble(coord)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogCoordfv.xml +func (gl *GL) FogCoordfv(coord []float32) { + C.gl4_1compat_glFogCoordfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&coord[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogCoordf.xml +func (gl *GL) FogCoordf(coord float32) { + C.gl4_1compat_glFogCoordf(gl.funcs, C.GLfloat(coord)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4usv.xml +func (gl *GL) VertexAttrib4usv(index glbase.Attrib, v []uint16) { + C.gl4_1compat_glVertexAttrib4usv(gl.funcs, C.GLuint(index), (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4uiv.xml +func (gl *GL) VertexAttrib4uiv(index glbase.Attrib, v []uint32) { + C.gl4_1compat_glVertexAttrib4uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4ubv.xml +func (gl *GL) VertexAttrib4ubv(index glbase.Attrib, v []uint8) { + C.gl4_1compat_glVertexAttrib4ubv(gl.funcs, C.GLuint(index), (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4sv.xml +func (gl *GL) VertexAttrib4sv(index glbase.Attrib, v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glVertexAttrib4sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4s.xml +func (gl *GL) VertexAttrib4s(index glbase.Attrib, x, y, z, w int16) { + C.gl4_1compat_glVertexAttrib4s(gl.funcs, C.GLuint(index), C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4iv.xml +func (gl *GL) VertexAttrib4iv(index glbase.Attrib, v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glVertexAttrib4iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4fv.xml +func (gl *GL) VertexAttrib4fv(index glbase.Attrib, v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glVertexAttrib4fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4f.xml +func (gl *GL) VertexAttrib4f(index glbase.Attrib, x, y, z, w float32) { + C.gl4_1compat_glVertexAttrib4f(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4dv.xml +func (gl *GL) VertexAttrib4dv(index glbase.Attrib, v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glVertexAttrib4dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4d.xml +func (gl *GL) VertexAttrib4d(index glbase.Attrib, x, y, z, w float64) { + C.gl4_1compat_glVertexAttrib4d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4bv.xml +func (gl *GL) VertexAttrib4bv(index glbase.Attrib, v []byte) { + C.gl4_1compat_glVertexAttrib4bv(gl.funcs, C.GLuint(index), (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4Nusv.xml +func (gl *GL) VertexAttrib4Nusv(index glbase.Attrib, v []uint16) { + C.gl4_1compat_glVertexAttrib4Nusv(gl.funcs, C.GLuint(index), (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4Nuiv.xml +func (gl *GL) VertexAttrib4Nuiv(index glbase.Attrib, v []uint32) { + C.gl4_1compat_glVertexAttrib4Nuiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4Nubv.xml +func (gl *GL) VertexAttrib4Nubv(index glbase.Attrib, v []uint8) { + C.gl4_1compat_glVertexAttrib4Nubv(gl.funcs, C.GLuint(index), (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4Nub.xml +func (gl *GL) VertexAttrib4Nub(index glbase.Attrib, x, y, z, w uint8) { + C.gl4_1compat_glVertexAttrib4Nub(gl.funcs, C.GLuint(index), C.GLubyte(x), C.GLubyte(y), C.GLubyte(z), C.GLubyte(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4Nsv.xml +func (gl *GL) VertexAttrib4Nsv(index glbase.Attrib, v []int16) { + C.gl4_1compat_glVertexAttrib4Nsv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4Niv.xml +func (gl *GL) VertexAttrib4Niv(index glbase.Attrib, v []int32) { + C.gl4_1compat_glVertexAttrib4Niv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4Nbv.xml +func (gl *GL) VertexAttrib4Nbv(index glbase.Attrib, v []byte) { + C.gl4_1compat_glVertexAttrib4Nbv(gl.funcs, C.GLuint(index), (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib3sv.xml +func (gl *GL) VertexAttrib3sv(index glbase.Attrib, v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glVertexAttrib3sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib3s.xml +func (gl *GL) VertexAttrib3s(index glbase.Attrib, x, y, z int16) { + C.gl4_1compat_glVertexAttrib3s(gl.funcs, C.GLuint(index), C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib3fv.xml +func (gl *GL) VertexAttrib3fv(index glbase.Attrib, v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glVertexAttrib3fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib3f.xml +func (gl *GL) VertexAttrib3f(index glbase.Attrib, x, y, z float32) { + C.gl4_1compat_glVertexAttrib3f(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib3dv.xml +func (gl *GL) VertexAttrib3dv(index glbase.Attrib, v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glVertexAttrib3dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib3d.xml +func (gl *GL) VertexAttrib3d(index glbase.Attrib, x, y, z float64) { + C.gl4_1compat_glVertexAttrib3d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib2sv.xml +func (gl *GL) VertexAttrib2sv(index glbase.Attrib, v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glVertexAttrib2sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib2s.xml +func (gl *GL) VertexAttrib2s(index glbase.Attrib, x, y int16) { + C.gl4_1compat_glVertexAttrib2s(gl.funcs, C.GLuint(index), C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib2fv.xml +func (gl *GL) VertexAttrib2fv(index glbase.Attrib, v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glVertexAttrib2fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib2f.xml +func (gl *GL) VertexAttrib2f(index glbase.Attrib, x, y float32) { + C.gl4_1compat_glVertexAttrib2f(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib2dv.xml +func (gl *GL) VertexAttrib2dv(index glbase.Attrib, v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glVertexAttrib2dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib2d.xml +func (gl *GL) VertexAttrib2d(index glbase.Attrib, x, y float64) { + C.gl4_1compat_glVertexAttrib2d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib1sv.xml +func (gl *GL) VertexAttrib1sv(index glbase.Attrib, v []int16) { + C.gl4_1compat_glVertexAttrib1sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib1s.xml +func (gl *GL) VertexAttrib1s(index glbase.Attrib, x int16) { + C.gl4_1compat_glVertexAttrib1s(gl.funcs, C.GLuint(index), C.GLshort(x)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib1fv.xml +func (gl *GL) VertexAttrib1fv(index glbase.Attrib, v []float32) { + C.gl4_1compat_glVertexAttrib1fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib1f.xml +func (gl *GL) VertexAttrib1f(index glbase.Attrib, x float32) { + C.gl4_1compat_glVertexAttrib1f(gl.funcs, C.GLuint(index), C.GLfloat(x)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib1dv.xml +func (gl *GL) VertexAttrib1dv(index glbase.Attrib, v []float64) { + C.gl4_1compat_glVertexAttrib1dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib1d.xml +func (gl *GL) VertexAttrib1d(index glbase.Attrib, x float64) { + C.gl4_1compat_glVertexAttrib1d(gl.funcs, C.GLuint(index), C.GLdouble(x)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI4usv.xml +func (gl *GL) VertexAttribI4usv(index glbase.Attrib, v []uint16) { + C.gl4_1compat_glVertexAttribI4usv(gl.funcs, C.GLuint(index), (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI4ubv.xml +func (gl *GL) VertexAttribI4ubv(index glbase.Attrib, v []uint8) { + C.gl4_1compat_glVertexAttribI4ubv(gl.funcs, C.GLuint(index), (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI4sv.xml +func (gl *GL) VertexAttribI4sv(index glbase.Attrib, v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glVertexAttribI4sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI4bv.xml +func (gl *GL) VertexAttribI4bv(index glbase.Attrib, v []byte) { + C.gl4_1compat_glVertexAttribI4bv(gl.funcs, C.GLuint(index), (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI4uiv.xml +func (gl *GL) VertexAttribI4uiv(index glbase.Attrib, v []uint32) { + C.gl4_1compat_glVertexAttribI4uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI3uiv.xml +func (gl *GL) VertexAttribI3uiv(index glbase.Attrib, v []uint32) { + C.gl4_1compat_glVertexAttribI3uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI2uiv.xml +func (gl *GL) VertexAttribI2uiv(index glbase.Attrib, v []uint32) { + C.gl4_1compat_glVertexAttribI2uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI1uiv.xml +func (gl *GL) VertexAttribI1uiv(index glbase.Attrib, v []uint32) { + C.gl4_1compat_glVertexAttribI1uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI4iv.xml +func (gl *GL) VertexAttribI4iv(index glbase.Attrib, v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glVertexAttribI4iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI3iv.xml +func (gl *GL) VertexAttribI3iv(index glbase.Attrib, v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glVertexAttribI3iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI2iv.xml +func (gl *GL) VertexAttribI2iv(index glbase.Attrib, v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_1compat_glVertexAttribI2iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI1iv.xml +func (gl *GL) VertexAttribI1iv(index glbase.Attrib, v []int32) { + C.gl4_1compat_glVertexAttribI1iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI4ui.xml +func (gl *GL) VertexAttribI4ui(index glbase.Attrib, x, y, z, w uint32) { + C.gl4_1compat_glVertexAttribI4ui(gl.funcs, C.GLuint(index), C.GLuint(x), C.GLuint(y), C.GLuint(z), C.GLuint(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI3ui.xml +func (gl *GL) VertexAttribI3ui(index glbase.Attrib, x, y, z uint32) { + C.gl4_1compat_glVertexAttribI3ui(gl.funcs, C.GLuint(index), C.GLuint(x), C.GLuint(y), C.GLuint(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI2ui.xml +func (gl *GL) VertexAttribI2ui(index glbase.Attrib, x, y uint32) { + C.gl4_1compat_glVertexAttribI2ui(gl.funcs, C.GLuint(index), C.GLuint(x), C.GLuint(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI1ui.xml +func (gl *GL) VertexAttribI1ui(index glbase.Attrib, x uint32) { + C.gl4_1compat_glVertexAttribI1ui(gl.funcs, C.GLuint(index), C.GLuint(x)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI4i.xml +func (gl *GL) VertexAttribI4i(index glbase.Attrib, x, y, z, w int) { + C.gl4_1compat_glVertexAttribI4i(gl.funcs, C.GLuint(index), C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI3i.xml +func (gl *GL) VertexAttribI3i(index glbase.Attrib, x, y, z int) { + C.gl4_1compat_glVertexAttribI3i(gl.funcs, C.GLuint(index), C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI2i.xml +func (gl *GL) VertexAttribI2i(index glbase.Attrib, x, y int) { + C.gl4_1compat_glVertexAttribI2i(gl.funcs, C.GLuint(index), C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI1i.xml +func (gl *GL) VertexAttribI1i(index glbase.Attrib, x int) { + C.gl4_1compat_glVertexAttribI1i(gl.funcs, C.GLuint(index), C.GLint(x)) +} diff --git a/gl/4.1core/funcs.cpp b/gl/4.1core/funcs.cpp new file mode 100644 index 00000000..9ae51693 --- /dev/null +++ b/gl/4.1core/funcs.cpp @@ -0,0 +1,2676 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#include +#include + +#include "funcs.h" + +void *gl4_1core_funcs() { + QOpenGLFunctions_4_1_Core* funcs = QOpenGLContext::currentContext()->versionFunctions(); + if (!funcs) { + return 0; + } + funcs->initializeOpenGLFunctions(); + return funcs; +} + + +void gl4_1core_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewport(x, y, width, height); +} + +void gl4_1core_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRange(nearVal, farVal); +} + +GLboolean gl4_1core_glIsEnabled(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabled(cap); +} + +void gl4_1core_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameteriv(target, level, pname, params); +} + +void gl4_1core_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameterfv(target, level, pname, params); +} + +void gl4_1core_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameteriv(target, pname, params); +} + +void gl4_1core_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterfv(target, pname, params); +} + +void gl4_1core_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexImage(target, level, format, gltype, pixels); +} + +void gl4_1core_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegerv(pname, params); +} + +void gl4_1core_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFloatv(pname, params); +} + +GLenum gl4_1core_glGetError(void *_glfuncs) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetError(); +} + +void gl4_1core_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetDoublev(pname, params); +} + +void gl4_1core_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleanv(pname, params); +} + +void gl4_1core_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadPixels(x, y, width, height, format, gltype, pixels); +} + +void gl4_1core_glReadBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadBuffer(mode); +} + +void gl4_1core_glPixelStorei(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStorei(pname, param); +} + +void gl4_1core_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStoref(pname, param); +} + +void gl4_1core_glDepthFunc(void *_glfuncs, GLenum glfunc) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthFunc(glfunc); +} + +void gl4_1core_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOp(fail, zfail, zpass); +} + +void gl4_1core_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFunc(glfunc, ref, mask); +} + +void gl4_1core_glLogicOp(void *_glfuncs, GLenum opcode) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLogicOp(opcode); +} + +void gl4_1core_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFunc(sfactor, dfactor); +} + +void gl4_1core_glFlush(void *_glfuncs) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlush(); +} + +void gl4_1core_glFinish(void *_glfuncs) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFinish(); +} + +void gl4_1core_glEnable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnable(cap); +} + +void gl4_1core_glDisable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisable(cap); +} + +void gl4_1core_glDepthMask(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthMask(flag); +} + +void gl4_1core_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMask(red, green, blue, alpha); +} + +void gl4_1core_glStencilMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMask(mask); +} + +void gl4_1core_glClearDepth(void *_glfuncs, GLdouble depth) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearDepth(depth); +} + +void gl4_1core_glClearStencil(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearStencil(s); +} + +void gl4_1core_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearColor(red, green, blue, alpha); +} + +void gl4_1core_glClear(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClear(mask); +} + +void gl4_1core_glDrawBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffer(mode); +} + +void gl4_1core_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage2D(target, level, internalFormat, width, height, border, format, gltype, pixels); +} + +void gl4_1core_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage1D(target, level, internalFormat, width, border, format, gltype, pixels); +} + +void gl4_1core_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteriv(target, pname, params); +} + +void gl4_1core_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteri(target, pname, param); +} + +void gl4_1core_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterfv(target, pname, params); +} + +void gl4_1core_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterf(target, pname, param); +} + +void gl4_1core_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissor(x, y, width, height); +} + +void gl4_1core_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonMode(face, mode); +} + +void gl4_1core_glPointSize(void *_glfuncs, GLfloat size) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointSize(size); +} + +void gl4_1core_glLineWidth(void *_glfuncs, GLfloat width) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineWidth(width); +} + +void gl4_1core_glHint(void *_glfuncs, GLenum target, GLenum mode) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glHint(target, mode); +} + +void gl4_1core_glFrontFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrontFace(mode); +} + +void gl4_1core_glCullFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCullFace(mode); +} + +void gl4_1core_glIndexubv(void *_glfuncs, const GLubyte* c) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexubv(c); +} + +void gl4_1core_glIndexub(void *_glfuncs, GLubyte c) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexub(c); +} + +GLboolean gl4_1core_glIsTexture(void *_glfuncs, GLuint texture) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsTexture(texture); +} + +void gl4_1core_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenTextures(n, textures); +} + +void gl4_1core_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteTextures(n, textures); +} + +void gl4_1core_glBindTexture(void *_glfuncs, GLenum target, GLuint texture) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindTexture(target, texture); +} + +void gl4_1core_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, gltype, pixels); +} + +void gl4_1core_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage1D(target, level, xoffset, width, format, gltype, pixels); +} + +void gl4_1core_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); +} + +void gl4_1core_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage1D(target, level, xoffset, x, y, width); +} + +void gl4_1core_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage2D(target, level, internalFormat, x, y, width, height, border); +} + +void gl4_1core_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage1D(target, level, internalFormat, x, y, width, border); +} + +void gl4_1core_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonOffset(factor, units); +} + +void gl4_1core_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElements(mode, count, gltype, indices); +} + +void gl4_1core_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArrays(mode, first, count); +} + +void gl4_1core_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); +} + +void gl4_1core_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, gltype, pixels); +} + +void gl4_1core_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage3D(target, level, internalFormat, width, height, depth, border, format, gltype, pixels); +} + +void gl4_1core_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawRangeElements(mode, start, end, count, gltype, indices); +} + +void gl4_1core_glBlendEquation(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquation(mode); +} + +void gl4_1core_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendColor(red, green, blue, alpha); +} + +void gl4_1core_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetCompressedTexImage(target, level, img); +} + +void gl4_1core_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data); +} + +void gl4_1core_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); +} + +void gl4_1core_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); +} + +void gl4_1core_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage1D(target, level, internalFormat, width, border, imageSize, data); +} + +void gl4_1core_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data); +} + +void gl4_1core_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage3D(target, level, internalFormat, width, height, depth, border, imageSize, data); +} + +void gl4_1core_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSampleCoverage(value, invert); +} + +void gl4_1core_glActiveTexture(void *_glfuncs, GLenum texture) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glActiveTexture(texture); +} + +void gl4_1core_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteriv(pname, params); +} + +void gl4_1core_glPointParameteri(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteri(pname, param); +} + +void gl4_1core_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterfv(pname, params); +} + +void gl4_1core_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterf(pname, param); +} + +void gl4_1core_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiDrawArrays(mode, first, count, drawcount); +} + +void gl4_1core_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); +} + +void gl4_1core_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferParameteriv(target, pname, params); +} + +GLboolean gl4_1core_glUnmapBuffer(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glUnmapBuffer(target); +} + +void gl4_1core_glGetBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferSubData(target, offset, size, data); +} + +void gl4_1core_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferSubData(target, offset, size, data); +} + +void gl4_1core_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferData(target, size, data, usage); +} + +GLboolean gl4_1core_glIsBuffer(void *_glfuncs, GLuint buffer) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsBuffer(buffer); +} + +void gl4_1core_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenBuffers(n, buffers); +} + +void gl4_1core_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteBuffers(n, buffers); +} + +void gl4_1core_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBuffer(target, buffer); +} + +void gl4_1core_glGetQueryObjectuiv(void *_glfuncs, GLuint id, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectuiv(id, pname, params); +} + +void gl4_1core_glGetQueryObjectiv(void *_glfuncs, GLuint id, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectiv(id, pname, params); +} + +void gl4_1core_glGetQueryiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryiv(target, pname, params); +} + +void gl4_1core_glEndQuery(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndQuery(target); +} + +void gl4_1core_glBeginQuery(void *_glfuncs, GLenum target, GLuint id) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginQuery(target, id); +} + +GLboolean gl4_1core_glIsQuery(void *_glfuncs, GLuint id) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsQuery(id); +} + +void gl4_1core_glDeleteQueries(void *_glfuncs, GLsizei n, const GLuint* ids) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteQueries(n, ids); +} + +void gl4_1core_glGenQueries(void *_glfuncs, GLsizei n, GLuint* ids) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenQueries(n, ids); +} + +void gl4_1core_glVertexAttribPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLboolean normalized, GLsizei stride, const GLvoid* offset) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribPointer(index, size, gltype, normalized, stride, offset); +} + +void gl4_1core_glValidateProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glValidateProgram(program); +} + +void gl4_1core_glUniformMatrix4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4fv(location, count, transpose, value); +} + +void gl4_1core_glUniformMatrix3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3fv(location, count, transpose, value); +} + +void gl4_1core_glUniformMatrix2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2fv(location, count, transpose, value); +} + +void gl4_1core_glUniform4iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4iv(location, count, value); +} + +void gl4_1core_glUniform3iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3iv(location, count, value); +} + +void gl4_1core_glUniform2iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2iv(location, count, value); +} + +void gl4_1core_glUniform1iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1iv(location, count, value); +} + +void gl4_1core_glUniform4fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4fv(location, count, value); +} + +void gl4_1core_glUniform3fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3fv(location, count, value); +} + +void gl4_1core_glUniform2fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2fv(location, count, value); +} + +void gl4_1core_glUniform1fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1fv(location, count, value); +} + +void gl4_1core_glUniform4i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4i(location, v0, v1, v2, v3); +} + +void gl4_1core_glUniform3i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3i(location, v0, v1, v2); +} + +void gl4_1core_glUniform2i(void *_glfuncs, GLint location, GLint v0, GLint v1) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2i(location, v0, v1); +} + +void gl4_1core_glUniform1i(void *_glfuncs, GLint location, GLint v0) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1i(location, v0); +} + +void gl4_1core_glUniform4f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4f(location, v0, v1, v2, v3); +} + +void gl4_1core_glUniform3f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3f(location, v0, v1, v2); +} + +void gl4_1core_glUniform2f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2f(location, v0, v1); +} + +void gl4_1core_glUniform1f(void *_glfuncs, GLint location, GLfloat v0) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1f(location, v0); +} + +void gl4_1core_glUseProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUseProgram(program); +} + +void gl4_1core_glShaderSource(void *_glfuncs, GLuint shader, GLsizei count, const GLchar** source, const GLint* length) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShaderSource(shader, count, source, length); +} + +void gl4_1core_glLinkProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLinkProgram(program); +} + +GLboolean gl4_1core_glIsShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsShader(shader); +} + +GLboolean gl4_1core_glIsProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsProgram(program); +} + +void gl4_1core_glGetVertexAttribiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribiv(index, pname, params); +} + +void gl4_1core_glGetVertexAttribfv(void *_glfuncs, GLuint index, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribfv(index, pname, params); +} + +void gl4_1core_glGetVertexAttribdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribdv(index, pname, params); +} + +void gl4_1core_glGetUniformiv(void *_glfuncs, GLuint program, GLint location, GLint* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformiv(program, location, params); +} + +void gl4_1core_glGetUniformfv(void *_glfuncs, GLuint program, GLint location, GLfloat* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformfv(program, location, params); +} + +GLint gl4_1core_glGetUniformLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetUniformLocation(program, name); +} + +void gl4_1core_glGetShaderSource(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderSource(shader, bufSize, length, source); +} + +void gl4_1core_glGetShaderInfoLog(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderInfoLog(shader, bufSize, length, infoLog); +} + +void gl4_1core_glGetShaderiv(void *_glfuncs, GLuint shader, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderiv(shader, pname, params); +} + +void gl4_1core_glGetProgramInfoLog(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramInfoLog(program, bufSize, length, infoLog); +} + +void gl4_1core_glGetProgramiv(void *_glfuncs, GLuint program, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramiv(program, pname, params); +} + +GLint gl4_1core_glGetAttribLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetAttribLocation(program, name); +} + +void gl4_1core_glGetAttachedShaders(void *_glfuncs, GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetAttachedShaders(program, maxCount, count, obj); +} + +void gl4_1core_glGetActiveUniform(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniform(program, index, bufSize, length, size, gltype, name); +} + +void gl4_1core_glGetActiveAttrib(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveAttrib(program, index, bufSize, length, size, gltype, name); +} + +void gl4_1core_glEnableVertexAttribArray(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnableVertexAttribArray(index); +} + +void gl4_1core_glDisableVertexAttribArray(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisableVertexAttribArray(index); +} + +void gl4_1core_glDetachShader(void *_glfuncs, GLuint program, GLuint shader) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDetachShader(program, shader); +} + +void gl4_1core_glDeleteShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteShader(shader); +} + +void gl4_1core_glDeleteProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteProgram(program); +} + +GLuint gl4_1core_glCreateShader(void *_glfuncs, GLenum gltype) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCreateShader(gltype); +} + +GLuint gl4_1core_glCreateProgram(void *_glfuncs) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCreateProgram(); +} + +void gl4_1core_glCompileShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompileShader(shader); +} + +void gl4_1core_glBindAttribLocation(void *_glfuncs, GLuint program, GLuint index, const GLchar* name) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindAttribLocation(program, index, name); +} + +void gl4_1core_glAttachShader(void *_glfuncs, GLuint program, GLuint shader) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAttachShader(program, shader); +} + +void gl4_1core_glStencilMaskSeparate(void *_glfuncs, GLenum face, GLuint mask) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMaskSeparate(face, mask); +} + +void gl4_1core_glStencilFuncSeparate(void *_glfuncs, GLenum face, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFuncSeparate(face, glfunc, ref, mask); +} + +void gl4_1core_glStencilOpSeparate(void *_glfuncs, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOpSeparate(face, sfail, dpfail, dppass); +} + +void gl4_1core_glDrawBuffers(void *_glfuncs, GLsizei n, const GLenum* bufs) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffers(n, bufs); +} + +void gl4_1core_glBlendEquationSeparate(void *_glfuncs, GLenum modeRGB, GLenum modeAlpha) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquationSeparate(modeRGB, modeAlpha); +} + +void gl4_1core_glUniformMatrix4x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x3fv(location, count, transpose, value); +} + +void gl4_1core_glUniformMatrix3x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x4fv(location, count, transpose, value); +} + +void gl4_1core_glUniformMatrix4x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x2fv(location, count, transpose, value); +} + +void gl4_1core_glUniformMatrix2x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x4fv(location, count, transpose, value); +} + +void gl4_1core_glUniformMatrix3x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x2fv(location, count, transpose, value); +} + +void gl4_1core_glUniformMatrix2x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x3fv(location, count, transpose, value); +} + +GLboolean gl4_1core_glIsVertexArray(void *_glfuncs, GLuint array) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsVertexArray(array); +} + +void gl4_1core_glGenVertexArrays(void *_glfuncs, GLsizei n, GLuint* arrays) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenVertexArrays(n, arrays); +} + +void gl4_1core_glDeleteVertexArrays(void *_glfuncs, GLsizei n, const GLuint* arrays) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteVertexArrays(n, arrays); +} + +void gl4_1core_glBindVertexArray(void *_glfuncs, GLuint array) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindVertexArray(array); +} + +void gl4_1core_glFlushMappedBufferRange(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr length) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlushMappedBufferRange(target, offset, length); +} + +void gl4_1core_glFramebufferTextureLayer(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTextureLayer(target, attachment, texture, level, layer); +} + +void gl4_1core_glRenderbufferStorageMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRenderbufferStorageMultisample(target, samples, internalFormat, width, height); +} + +void gl4_1core_glBlitFramebuffer(void *_glfuncs, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); +} + +void gl4_1core_glGenerateMipmap(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenerateMipmap(target); +} + +void gl4_1core_glGetFramebufferAttachmentParameteriv(void *_glfuncs, GLenum target, GLenum attachment, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFramebufferAttachmentParameteriv(target, attachment, pname, params); +} + +void gl4_1core_glFramebufferRenderbuffer(void *_glfuncs, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer); +} + +void gl4_1core_glFramebufferTexture3D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset); +} + +void gl4_1core_glFramebufferTexture2D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture2D(target, attachment, textarget, texture, level); +} + +void gl4_1core_glFramebufferTexture1D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture1D(target, attachment, textarget, texture, level); +} + +GLenum gl4_1core_glCheckFramebufferStatus(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCheckFramebufferStatus(target); +} + +void gl4_1core_glGenFramebuffers(void *_glfuncs, GLsizei n, GLuint* framebuffers) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenFramebuffers(n, framebuffers); +} + +void gl4_1core_glDeleteFramebuffers(void *_glfuncs, GLsizei n, const GLuint* framebuffers) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteFramebuffers(n, framebuffers); +} + +void gl4_1core_glBindFramebuffer(void *_glfuncs, GLenum target, GLuint framebuffer) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFramebuffer(target, framebuffer); +} + +GLboolean gl4_1core_glIsFramebuffer(void *_glfuncs, GLuint framebuffer) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsFramebuffer(framebuffer); +} + +void gl4_1core_glGetRenderbufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetRenderbufferParameteriv(target, pname, params); +} + +void gl4_1core_glRenderbufferStorage(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRenderbufferStorage(target, internalFormat, width, height); +} + +void gl4_1core_glGenRenderbuffers(void *_glfuncs, GLsizei n, GLuint* renderbuffers) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenRenderbuffers(n, renderbuffers); +} + +void gl4_1core_glDeleteRenderbuffers(void *_glfuncs, GLsizei n, const GLuint* renderbuffers) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteRenderbuffers(n, renderbuffers); +} + +void gl4_1core_glBindRenderbuffer(void *_glfuncs, GLenum target, GLuint renderbuffer) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindRenderbuffer(target, renderbuffer); +} + +GLboolean gl4_1core_glIsRenderbuffer(void *_glfuncs, GLuint renderbuffer) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsRenderbuffer(renderbuffer); +} + +void gl4_1core_glClearBufferfi(void *_glfuncs, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferfi(buffer, drawbuffer, depth, stencil); +} + +void gl4_1core_glClearBufferfv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferfv(buffer, drawbuffer, value); +} + +void gl4_1core_glClearBufferuiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLuint* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferuiv(buffer, drawbuffer, value); +} + +void gl4_1core_glClearBufferiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLint* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferiv(buffer, drawbuffer, value); +} + +void gl4_1core_glGetTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterIuiv(target, pname, params); +} + +void gl4_1core_glGetTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterIiv(target, pname, params); +} + +void gl4_1core_glTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, const GLuint* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterIuiv(target, pname, params); +} + +void gl4_1core_glTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterIiv(target, pname, params); +} + +void gl4_1core_glUniform4uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4uiv(location, count, value); +} + +void gl4_1core_glUniform3uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3uiv(location, count, value); +} + +void gl4_1core_glUniform2uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2uiv(location, count, value); +} + +void gl4_1core_glUniform1uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1uiv(location, count, value); +} + +void gl4_1core_glUniform4ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4ui(location, v0, v1, v2, v3); +} + +void gl4_1core_glUniform3ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3ui(location, v0, v1, v2); +} + +void gl4_1core_glUniform2ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2ui(location, v0, v1); +} + +void gl4_1core_glUniform1ui(void *_glfuncs, GLint location, GLuint v0) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1ui(location, v0); +} + +GLint gl4_1core_glGetFragDataLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetFragDataLocation(program, name); +} + +void gl4_1core_glBindFragDataLocation(void *_glfuncs, GLuint program, GLuint color, const GLchar* name) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFragDataLocation(program, color, name); +} + +void gl4_1core_glGetUniformuiv(void *_glfuncs, GLuint program, GLint location, GLuint* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformuiv(program, location, params); +} + +void gl4_1core_glGetVertexAttribIuiv(void *_glfuncs, GLuint index, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribIuiv(index, pname, params); +} + +void gl4_1core_glGetVertexAttribIiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribIiv(index, pname, params); +} + +void gl4_1core_glVertexAttribIPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribIPointer(index, size, gltype, stride, pointer); +} + +void gl4_1core_glEndConditionalRender(void *_glfuncs) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndConditionalRender(); +} + +void gl4_1core_glBeginConditionalRender(void *_glfuncs, GLuint id, GLenum mode) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginConditionalRender(id, mode); +} + +void gl4_1core_glClampColor(void *_glfuncs, GLenum target, GLenum clamp) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClampColor(target, clamp); +} + +void gl4_1core_glGetTransformFeedbackVarying(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTransformFeedbackVarying(program, index, bufSize, length, size, gltype, name); +} + +void gl4_1core_glBindBufferBase(void *_glfuncs, GLenum target, GLuint index, GLuint buffer) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBufferBase(target, index, buffer); +} + +void gl4_1core_glBindBufferRange(void *_glfuncs, GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBufferRange(target, index, buffer, offset, size); +} + +void gl4_1core_glEndTransformFeedback(void *_glfuncs) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndTransformFeedback(); +} + +void gl4_1core_glBeginTransformFeedback(void *_glfuncs, GLenum primitiveMode) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginTransformFeedback(primitiveMode); +} + +GLboolean gl4_1core_glIsEnabledi(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabledi(target, index); +} + +void gl4_1core_glDisablei(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisablei(target, index); +} + +void gl4_1core_glEnablei(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnablei(target, index); +} + +void gl4_1core_glGetIntegeri_v(void *_glfuncs, GLenum target, GLuint index, GLint* data) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegeri_v(target, index, data); +} + +void gl4_1core_glGetBooleani_v(void *_glfuncs, GLenum target, GLuint index, GLboolean* data) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleani_v(target, index, data); +} + +void gl4_1core_glColorMaski(void *_glfuncs, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMaski(index, r, g, b, a); +} + +void gl4_1core_glCopyBufferSubData(void *_glfuncs, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); +} + +void gl4_1core_glUniformBlockBinding(void *_glfuncs, GLuint program, GLuint v0, GLuint v1) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformBlockBinding(program, v0, v1); +} + +void gl4_1core_glGetActiveUniformBlockName(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName); +} + +void gl4_1core_glGetActiveUniformBlockiv(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params); +} + +GLuint gl4_1core_glGetUniformBlockIndex(void *_glfuncs, GLuint program, const GLchar* uniformBlockName) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetUniformBlockIndex(program, uniformBlockName); +} + +void gl4_1core_glGetActiveUniformName(void *_glfuncs, GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformName(program, uniformIndex, bufSize, length, uniformName); +} + +void gl4_1core_glGetActiveUniformsiv(void *_glfuncs, GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params); +} + +void gl4_1core_glPrimitiveRestartIndex(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPrimitiveRestartIndex(index); +} + +void gl4_1core_glTexBuffer(void *_glfuncs, GLenum target, GLenum internalFormat, GLuint buffer) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexBuffer(target, internalFormat, buffer); +} + +void gl4_1core_glDrawElementsInstanced(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsInstanced(mode, count, gltype, indices, instancecount); +} + +void gl4_1core_glDrawArraysInstanced(void *_glfuncs, GLenum mode, GLint first, GLsizei count, GLsizei instancecount) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArraysInstanced(mode, first, count, instancecount); +} + +void gl4_1core_glSampleMaski(void *_glfuncs, GLuint index, GLbitfield mask) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSampleMaski(index, mask); +} + +void gl4_1core_glGetMultisamplefv(void *_glfuncs, GLenum pname, GLuint index, GLfloat* val) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMultisamplefv(pname, index, val); +} + +void gl4_1core_glTexImage3DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage3DMultisample(target, samples, internalFormat, width, height, depth, fixedsamplelocations); +} + +void gl4_1core_glTexImage2DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage2DMultisample(target, samples, internalFormat, width, height, fixedsamplelocations); +} + +void gl4_1core_glGetSynciv(void *_glfuncs, GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSynciv(sync, pname, bufSize, length, values); +} + +void gl4_1core_glGetInteger64v(void *_glfuncs, GLenum pname, GLint64* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetInteger64v(pname, params); +} + +void gl4_1core_glWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWaitSync(sync, flags, timeout); +} + +GLenum gl4_1core_glClientWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glClientWaitSync(sync, flags, timeout); +} + +void gl4_1core_glDeleteSync(void *_glfuncs, GLsync sync) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteSync(sync); +} + +GLboolean gl4_1core_glIsSync(void *_glfuncs, GLsync sync) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsSync(sync); +} + +GLsync gl4_1core_glFenceSync(void *_glfuncs, GLenum condition, GLbitfield flags) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glFenceSync(condition, flags); +} + +void gl4_1core_glProvokingVertex(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProvokingVertex(mode); +} + +void gl4_1core_glDrawElementsInstancedBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLint basevertex) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsInstancedBaseVertex(mode, count, gltype, indices, instancecount, basevertex); +} + +void gl4_1core_glDrawRangeElementsBaseVertex(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawRangeElementsBaseVertex(mode, start, end, count, gltype, indices, basevertex); +} + +void gl4_1core_glDrawElementsBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsBaseVertex(mode, count, gltype, indices, basevertex); +} + +void gl4_1core_glFramebufferTexture(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture(target, attachment, texture, level); +} + +void gl4_1core_glGetBufferParameteri64v(void *_glfuncs, GLenum target, GLenum pname, GLint64* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferParameteri64v(target, pname, params); +} + +void gl4_1core_glGetInteger64i_v(void *_glfuncs, GLenum target, GLuint index, GLint64* data) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetInteger64i_v(target, index, data); +} + +void gl4_1core_glVertexAttribP4uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP4uiv(index, gltype, normalized, value); +} + +void gl4_1core_glVertexAttribP4ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP4ui(index, gltype, normalized, value); +} + +void gl4_1core_glVertexAttribP3uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP3uiv(index, gltype, normalized, value); +} + +void gl4_1core_glVertexAttribP3ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP3ui(index, gltype, normalized, value); +} + +void gl4_1core_glVertexAttribP2uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP2uiv(index, gltype, normalized, value); +} + +void gl4_1core_glVertexAttribP2ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP2ui(index, gltype, normalized, value); +} + +void gl4_1core_glVertexAttribP1uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP1uiv(index, gltype, normalized, value); +} + +void gl4_1core_glVertexAttribP1ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP1ui(index, gltype, normalized, value); +} + +void gl4_1core_glSecondaryColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColorP3uiv(gltype, color); +} + +void gl4_1core_glSecondaryColorP3ui(void *_glfuncs, GLenum gltype, GLuint color) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColorP3ui(gltype, color); +} + +void gl4_1core_glColorP4uiv(void *_glfuncs, GLenum gltype, const GLuint* color) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP4uiv(gltype, color); +} + +void gl4_1core_glColorP4ui(void *_glfuncs, GLenum gltype, GLuint color) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP4ui(gltype, color); +} + +void gl4_1core_glColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP3uiv(gltype, color); +} + +void gl4_1core_glColorP3ui(void *_glfuncs, GLenum gltype, GLuint color) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP3ui(gltype, color); +} + +void gl4_1core_glNormalP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormalP3uiv(gltype, coords); +} + +void gl4_1core_glNormalP3ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormalP3ui(gltype, coords); +} + +void gl4_1core_glMultiTexCoordP4uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP4uiv(texture, gltype, coords); +} + +void gl4_1core_glMultiTexCoordP4ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP4ui(texture, gltype, coords); +} + +void gl4_1core_glMultiTexCoordP3uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP3uiv(texture, gltype, coords); +} + +void gl4_1core_glMultiTexCoordP3ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP3ui(texture, gltype, coords); +} + +void gl4_1core_glMultiTexCoordP2uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP2uiv(texture, gltype, coords); +} + +void gl4_1core_glMultiTexCoordP2ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP2ui(texture, gltype, coords); +} + +void gl4_1core_glMultiTexCoordP1uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP1uiv(texture, gltype, coords); +} + +void gl4_1core_glMultiTexCoordP1ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP1ui(texture, gltype, coords); +} + +void gl4_1core_glTexCoordP4uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP4uiv(gltype, coords); +} + +void gl4_1core_glTexCoordP4ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP4ui(gltype, coords); +} + +void gl4_1core_glTexCoordP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP3uiv(gltype, coords); +} + +void gl4_1core_glTexCoordP3ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP3ui(gltype, coords); +} + +void gl4_1core_glTexCoordP2uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP2uiv(gltype, coords); +} + +void gl4_1core_glTexCoordP2ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP2ui(gltype, coords); +} + +void gl4_1core_glTexCoordP1uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP1uiv(gltype, coords); +} + +void gl4_1core_glTexCoordP1ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP1ui(gltype, coords); +} + +void gl4_1core_glVertexP4uiv(void *_glfuncs, GLenum gltype, const GLuint* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP4uiv(gltype, value); +} + +void gl4_1core_glVertexP4ui(void *_glfuncs, GLenum gltype, GLuint value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP4ui(gltype, value); +} + +void gl4_1core_glVertexP3uiv(void *_glfuncs, GLenum gltype, const GLuint* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP3uiv(gltype, value); +} + +void gl4_1core_glVertexP3ui(void *_glfuncs, GLenum gltype, GLuint value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP3ui(gltype, value); +} + +void gl4_1core_glVertexP2uiv(void *_glfuncs, GLenum gltype, const GLuint* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP2uiv(gltype, value); +} + +void gl4_1core_glVertexP2ui(void *_glfuncs, GLenum gltype, GLuint value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP2ui(gltype, value); +} + +void gl4_1core_glGetQueryObjectui64v(void *_glfuncs, GLuint id, GLenum pname, GLuint64* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectui64v(id, pname, params); +} + +void gl4_1core_glGetQueryObjecti64v(void *_glfuncs, GLuint id, GLenum pname, GLint64* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjecti64v(id, pname, params); +} + +void gl4_1core_glQueryCounter(void *_glfuncs, GLuint id, GLenum target) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glQueryCounter(id, target); +} + +void gl4_1core_glGetSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameterIuiv(sampler, pname, params); +} + +void gl4_1core_glGetSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameterfv(sampler, pname, params); +} + +void gl4_1core_glGetSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameterIiv(sampler, pname, params); +} + +void gl4_1core_glGetSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameteriv(sampler, pname, params); +} + +void gl4_1core_glSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLuint* param) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterIuiv(sampler, pname, param); +} + +void gl4_1core_glSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterIiv(sampler, pname, param); +} + +void gl4_1core_glSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, const GLfloat* param) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterfv(sampler, pname, param); +} + +void gl4_1core_glSamplerParameterf(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterf(sampler, pname, param); +} + +void gl4_1core_glSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameteriv(sampler, pname, param); +} + +void gl4_1core_glSamplerParameteri(void *_glfuncs, GLuint sampler, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameteri(sampler, pname, param); +} + +void gl4_1core_glBindSampler(void *_glfuncs, GLuint unit, GLuint sampler) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindSampler(unit, sampler); +} + +GLboolean gl4_1core_glIsSampler(void *_glfuncs, GLuint sampler) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsSampler(sampler); +} + +void gl4_1core_glDeleteSamplers(void *_glfuncs, GLsizei count, const GLuint* samplers) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteSamplers(count, samplers); +} + +void gl4_1core_glGenSamplers(void *_glfuncs, GLsizei count, GLuint* samplers) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenSamplers(count, samplers); +} + +GLint gl4_1core_glGetFragDataIndex(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetFragDataIndex(program, name); +} + +void gl4_1core_glBindFragDataLocationIndexed(void *_glfuncs, GLuint program, GLuint colorNumber, GLuint index, const GLchar* name) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFragDataLocationIndexed(program, colorNumber, index, name); +} + +void gl4_1core_glVertexAttribDivisor(void *_glfuncs, GLuint index, GLuint divisor) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribDivisor(index, divisor); +} + +void gl4_1core_glGetQueryIndexediv(void *_glfuncs, GLenum target, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryIndexediv(target, index, pname, params); +} + +void gl4_1core_glEndQueryIndexed(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndQueryIndexed(target, index); +} + +void gl4_1core_glBeginQueryIndexed(void *_glfuncs, GLenum target, GLuint index, GLuint id) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginQueryIndexed(target, index, id); +} + +void gl4_1core_glDrawTransformFeedbackStream(void *_glfuncs, GLenum mode, GLuint id, GLuint stream) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawTransformFeedbackStream(mode, id, stream); +} + +void gl4_1core_glDrawTransformFeedback(void *_glfuncs, GLenum mode, GLuint id) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawTransformFeedback(mode, id); +} + +void gl4_1core_glResumeTransformFeedback(void *_glfuncs) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glResumeTransformFeedback(); +} + +void gl4_1core_glPauseTransformFeedback(void *_glfuncs) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPauseTransformFeedback(); +} + +GLboolean gl4_1core_glIsTransformFeedback(void *_glfuncs, GLuint id) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsTransformFeedback(id); +} + +void gl4_1core_glGenTransformFeedbacks(void *_glfuncs, GLsizei n, GLuint* ids) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenTransformFeedbacks(n, ids); +} + +void gl4_1core_glDeleteTransformFeedbacks(void *_glfuncs, GLsizei n, const GLuint* ids) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteTransformFeedbacks(n, ids); +} + +void gl4_1core_glBindTransformFeedback(void *_glfuncs, GLenum target, GLuint id) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindTransformFeedback(target, id); +} + +void gl4_1core_glPatchParameterfv(void *_glfuncs, GLenum pname, const GLfloat* values) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPatchParameterfv(pname, values); +} + +void gl4_1core_glPatchParameteri(void *_glfuncs, GLenum pname, GLint value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPatchParameteri(pname, value); +} + +void gl4_1core_glGetProgramStageiv(void *_glfuncs, GLuint program, GLenum shadertype, GLenum pname, GLint* values) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramStageiv(program, shadertype, pname, values); +} + +void gl4_1core_glGetUniformSubroutineuiv(void *_glfuncs, GLenum shadertype, GLint location, GLuint* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformSubroutineuiv(shadertype, location, params); +} + +void gl4_1core_glUniformSubroutinesuiv(void *_glfuncs, GLenum shadertype, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformSubroutinesuiv(shadertype, count, value); +} + +void gl4_1core_glGetActiveSubroutineName(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveSubroutineName(program, shadertype, index, bufSize, length, name); +} + +void gl4_1core_glGetActiveSubroutineUniformName(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveSubroutineUniformName(program, shadertype, index, bufSize, length, name); +} + +void gl4_1core_glGetActiveSubroutineUniformiv(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint* values) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveSubroutineUniformiv(program, shadertype, index, pname, values); +} + +GLuint gl4_1core_glGetSubroutineIndex(void *_glfuncs, GLuint program, GLenum shadertype, const GLchar* name) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetSubroutineIndex(program, shadertype, name); +} + +GLint gl4_1core_glGetSubroutineUniformLocation(void *_glfuncs, GLuint program, GLenum shadertype, const GLchar* name) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetSubroutineUniformLocation(program, shadertype, name); +} + +void gl4_1core_glGetUniformdv(void *_glfuncs, GLuint program, GLint location, GLdouble* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformdv(program, location, params); +} + +void gl4_1core_glUniformMatrix4x3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x3dv(location, count, transpose, value); +} + +void gl4_1core_glUniformMatrix4x2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x2dv(location, count, transpose, value); +} + +void gl4_1core_glUniformMatrix3x4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x4dv(location, count, transpose, value); +} + +void gl4_1core_glUniformMatrix3x2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x2dv(location, count, transpose, value); +} + +void gl4_1core_glUniformMatrix2x4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x4dv(location, count, transpose, value); +} + +void gl4_1core_glUniformMatrix2x3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x3dv(location, count, transpose, value); +} + +void gl4_1core_glUniformMatrix4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4dv(location, count, transpose, value); +} + +void gl4_1core_glUniformMatrix3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3dv(location, count, transpose, value); +} + +void gl4_1core_glUniformMatrix2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2dv(location, count, transpose, value); +} + +void gl4_1core_glUniform4dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4dv(location, count, value); +} + +void gl4_1core_glUniform3dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3dv(location, count, value); +} + +void gl4_1core_glUniform2dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2dv(location, count, value); +} + +void gl4_1core_glUniform1dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1dv(location, count, value); +} + +void gl4_1core_glUniform4d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4d(location, v0, v1, v2, v3); +} + +void gl4_1core_glUniform3d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1, GLdouble v2) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3d(location, v0, v1, v2); +} + +void gl4_1core_glUniform2d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2d(location, v0, v1); +} + +void gl4_1core_glUniform1d(void *_glfuncs, GLint location, GLdouble v0) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1d(location, v0); +} + +void gl4_1core_glDrawElementsIndirect(void *_glfuncs, GLenum mode, GLenum gltype, const GLvoid* indirect) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsIndirect(mode, gltype, indirect); +} + +void gl4_1core_glDrawArraysIndirect(void *_glfuncs, GLenum mode, const GLvoid* indirect) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArraysIndirect(mode, indirect); +} + +void gl4_1core_glBlendFuncSeparatei(void *_glfuncs, GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha); +} + +void gl4_1core_glBlendFunci(void *_glfuncs, GLuint buf, GLenum src, GLenum dst) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFunci(buf, src, dst); +} + +void gl4_1core_glBlendEquationSeparatei(void *_glfuncs, GLuint buf, GLenum modeRGB, GLenum modeAlpha) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquationSeparatei(buf, modeRGB, modeAlpha); +} + +void gl4_1core_glBlendEquationi(void *_glfuncs, GLuint buf, GLenum mode) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquationi(buf, mode); +} + +void gl4_1core_glMinSampleShading(void *_glfuncs, GLfloat value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMinSampleShading(value); +} + +void gl4_1core_glGetDoublei_v(void *_glfuncs, GLenum target, GLuint index, GLdouble* data) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetDoublei_v(target, index, data); +} + +void gl4_1core_glGetFloati_v(void *_glfuncs, GLenum target, GLuint index, GLfloat* data) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFloati_v(target, index, data); +} + +void gl4_1core_glDepthRangeIndexed(void *_glfuncs, GLuint index, GLdouble n, GLdouble f) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRangeIndexed(index, n, f); +} + +void gl4_1core_glDepthRangeArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLdouble* v) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRangeArrayv(first, count, v); +} + +void gl4_1core_glScissorIndexedv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissorIndexedv(index, v); +} + +void gl4_1core_glScissorIndexed(void *_glfuncs, GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissorIndexed(index, left, bottom, width, height); +} + +void gl4_1core_glScissorArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLint* v) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissorArrayv(first, count, v); +} + +void gl4_1core_glViewportIndexedfv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewportIndexedfv(index, v); +} + +void gl4_1core_glViewportIndexedf(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewportIndexedf(index, x, y, w, h); +} + +void gl4_1core_glViewportArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLfloat* v) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewportArrayv(first, count, v); +} + +void gl4_1core_glGetVertexAttribLdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribLdv(index, pname, params); +} + +void gl4_1core_glVertexAttribLPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribLPointer(index, size, gltype, stride, pointer); +} + +void gl4_1core_glVertexAttribL4dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL4dv(index, v); +} + +void gl4_1core_glVertexAttribL3dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL3dv(index, v); +} + +void gl4_1core_glVertexAttribL2dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL2dv(index, v); +} + +void gl4_1core_glVertexAttribL1dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL1dv(index, v); +} + +void gl4_1core_glVertexAttribL4d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL4d(index, x, y, z, w); +} + +void gl4_1core_glVertexAttribL3d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL3d(index, x, y, z); +} + +void gl4_1core_glVertexAttribL2d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL2d(index, x, y); +} + +void gl4_1core_glVertexAttribL1d(void *_glfuncs, GLuint index, GLdouble x) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL1d(index, x); +} + +void gl4_1core_glGetProgramPipelineInfoLog(void *_glfuncs, GLuint pipeline, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog); +} + +void gl4_1core_glValidateProgramPipeline(void *_glfuncs, GLuint pipeline) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glValidateProgramPipeline(pipeline); +} + +void gl4_1core_glProgramUniformMatrix4x3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4x3dv(program, location, count, transpose, value); +} + +void gl4_1core_glProgramUniformMatrix3x4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3x4dv(program, location, count, transpose, value); +} + +void gl4_1core_glProgramUniformMatrix4x2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4x2dv(program, location, count, transpose, value); +} + +void gl4_1core_glProgramUniformMatrix2x4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2x4dv(program, location, count, transpose, value); +} + +void gl4_1core_glProgramUniformMatrix3x2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3x2dv(program, location, count, transpose, value); +} + +void gl4_1core_glProgramUniformMatrix2x3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2x3dv(program, location, count, transpose, value); +} + +void gl4_1core_glProgramUniformMatrix4x3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4x3fv(program, location, count, transpose, value); +} + +void gl4_1core_glProgramUniformMatrix3x4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3x4fv(program, location, count, transpose, value); +} + +void gl4_1core_glProgramUniformMatrix4x2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4x2fv(program, location, count, transpose, value); +} + +void gl4_1core_glProgramUniformMatrix2x4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2x4fv(program, location, count, transpose, value); +} + +void gl4_1core_glProgramUniformMatrix3x2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3x2fv(program, location, count, transpose, value); +} + +void gl4_1core_glProgramUniformMatrix2x3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2x3fv(program, location, count, transpose, value); +} + +void gl4_1core_glProgramUniformMatrix4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4dv(program, location, count, transpose, value); +} + +void gl4_1core_glProgramUniformMatrix3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3dv(program, location, count, transpose, value); +} + +void gl4_1core_glProgramUniformMatrix2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2dv(program, location, count, transpose, value); +} + +void gl4_1core_glProgramUniformMatrix4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4fv(program, location, count, transpose, value); +} + +void gl4_1core_glProgramUniformMatrix3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3fv(program, location, count, transpose, value); +} + +void gl4_1core_glProgramUniformMatrix2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2fv(program, location, count, transpose, value); +} + +void gl4_1core_glProgramUniform4uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4uiv(program, location, count, value); +} + +void gl4_1core_glProgramUniform4ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4ui(program, location, v0, v1, v2, v3); +} + +void gl4_1core_glProgramUniform4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4dv(program, location, count, value); +} + +void gl4_1core_glProgramUniform4d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4d(program, location, v0, v1, v2, v3); +} + +void gl4_1core_glProgramUniform4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4fv(program, location, count, value); +} + +void gl4_1core_glProgramUniform4f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4f(program, location, v0, v1, v2, v3); +} + +void gl4_1core_glProgramUniform4iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4iv(program, location, count, value); +} + +void gl4_1core_glProgramUniform4i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4i(program, location, v0, v1, v2, v3); +} + +void gl4_1core_glProgramUniform3uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3uiv(program, location, count, value); +} + +void gl4_1core_glProgramUniform3ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3ui(program, location, v0, v1, v2); +} + +void gl4_1core_glProgramUniform3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3dv(program, location, count, value); +} + +void gl4_1core_glProgramUniform3d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3d(program, location, v0, v1, v2); +} + +void gl4_1core_glProgramUniform3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3fv(program, location, count, value); +} + +void gl4_1core_glProgramUniform3f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3f(program, location, v0, v1, v2); +} + +void gl4_1core_glProgramUniform3iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3iv(program, location, count, value); +} + +void gl4_1core_glProgramUniform3i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1, GLint v2) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3i(program, location, v0, v1, v2); +} + +void gl4_1core_glProgramUniform2uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2uiv(program, location, count, value); +} + +void gl4_1core_glProgramUniform2ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2ui(program, location, v0, v1); +} + +void gl4_1core_glProgramUniform2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2dv(program, location, count, value); +} + +void gl4_1core_glProgramUniform2d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2d(program, location, v0, v1); +} + +void gl4_1core_glProgramUniform2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2fv(program, location, count, value); +} + +void gl4_1core_glProgramUniform2f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2f(program, location, v0, v1); +} + +void gl4_1core_glProgramUniform2iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2iv(program, location, count, value); +} + +void gl4_1core_glProgramUniform2i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2i(program, location, v0, v1); +} + +void gl4_1core_glProgramUniform1uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1uiv(program, location, count, value); +} + +void gl4_1core_glProgramUniform1ui(void *_glfuncs, GLuint program, GLint location, GLuint v0) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1ui(program, location, v0); +} + +void gl4_1core_glProgramUniform1dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1dv(program, location, count, value); +} + +void gl4_1core_glProgramUniform1d(void *_glfuncs, GLuint program, GLint location, GLdouble v0) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1d(program, location, v0); +} + +void gl4_1core_glProgramUniform1fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1fv(program, location, count, value); +} + +void gl4_1core_glProgramUniform1f(void *_glfuncs, GLuint program, GLint location, GLfloat v0) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1f(program, location, v0); +} + +void gl4_1core_glProgramUniform1iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1iv(program, location, count, value); +} + +void gl4_1core_glProgramUniform1i(void *_glfuncs, GLuint program, GLint location, GLint v0) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1i(program, location, v0); +} + +void gl4_1core_glGetProgramPipelineiv(void *_glfuncs, GLuint pipeline, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramPipelineiv(pipeline, pname, params); +} + +GLboolean gl4_1core_glIsProgramPipeline(void *_glfuncs, GLuint pipeline) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsProgramPipeline(pipeline); +} + +void gl4_1core_glGenProgramPipelines(void *_glfuncs, GLsizei n, GLuint* pipelines) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenProgramPipelines(n, pipelines); +} + +void gl4_1core_glDeleteProgramPipelines(void *_glfuncs, GLsizei n, const GLuint* pipelines) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteProgramPipelines(n, pipelines); +} + +void gl4_1core_glBindProgramPipeline(void *_glfuncs, GLuint pipeline) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindProgramPipeline(pipeline); +} + +void gl4_1core_glActiveShaderProgram(void *_glfuncs, GLuint pipeline, GLuint program) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glActiveShaderProgram(pipeline, program); +} + +void gl4_1core_glUseProgramStages(void *_glfuncs, GLuint pipeline, GLbitfield stages, GLuint program) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUseProgramStages(pipeline, stages, program); +} + +void gl4_1core_glProgramParameteri(void *_glfuncs, GLuint program, GLenum pname, GLint value) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramParameteri(program, pname, value); +} + +void gl4_1core_glProgramBinary(void *_glfuncs, GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramBinary(program, binaryFormat, binary, length); +} + +void gl4_1core_glGetProgramBinary(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramBinary(program, bufSize, length, binaryFormat, binary); +} + +void gl4_1core_glClearDepthf(void *_glfuncs, GLfloat dd) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearDepthf(dd); +} + +void gl4_1core_glDepthRangef(void *_glfuncs, GLfloat n, GLfloat f) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRangef(n, f); +} + +void gl4_1core_glGetShaderPrecisionFormat(void *_glfuncs, GLenum shadertype, GLenum precisionType, GLint* range_, GLint* precision) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderPrecisionFormat(shadertype, precisionType, range_, precision); +} + +void gl4_1core_glShaderBinary(void *_glfuncs, GLsizei count, const GLuint* shaders, GLenum binaryFormat, const GLvoid* binary, GLsizei length) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShaderBinary(count, shaders, binaryFormat, binary, length); +} + +void gl4_1core_glReleaseShaderCompiler(void *_glfuncs) +{ + QOpenGLFunctions_4_1_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReleaseShaderCompiler(); +} + diff --git a/gl/4.1core/funcs.h b/gl/4.1core/funcs.h new file mode 100644 index 00000000..e582a112 --- /dev/null +++ b/gl/4.1core/funcs.h @@ -0,0 +1,485 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#ifndef __cplusplus +#include +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef char GLchar; +typedef signed char GLbyte; /* 1-byte signed */ +typedef short GLshort; /* 2-byte signed */ +typedef int GLint; /* 4-byte signed */ +typedef unsigned char GLubyte; /* 1-byte unsigned */ +typedef unsigned short GLushort; /* 2-byte unsigned */ +typedef unsigned int GLuint; /* 4-byte unsigned */ +typedef int GLsizei; /* 4-byte signed */ +typedef float GLfloat; /* single precision float */ +typedef float GLclampf; /* single precision float in [0,1] */ +typedef double GLdouble; /* double precision float */ +typedef double GLclampd; /* double precision float in [0,1] */ +typedef int64_t GLint64; +typedef uint64_t GLuint64; +typedef ptrdiff_t GLintptr; +typedef ptrdiff_t GLsizeiptr; +typedef ptrdiff_t GLintptrARB; +typedef ptrdiff_t GLsizeiptrARB; +typedef struct __GLsync *GLsync; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +void *gl4_1core_funcs(); + +void gl4_1core_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_1core_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal); +GLboolean gl4_1core_glIsEnabled(void *_glfuncs, GLenum cap); +void gl4_1core_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params); +void gl4_1core_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params); +void gl4_1core_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_1core_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl4_1core_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels); +void gl4_1core_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params); +void gl4_1core_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params); +GLenum gl4_1core_glGetError(void *_glfuncs); +void gl4_1core_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params); +void gl4_1core_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params); +void gl4_1core_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels); +void gl4_1core_glReadBuffer(void *_glfuncs, GLenum mode); +void gl4_1core_glPixelStorei(void *_glfuncs, GLenum pname, GLint param); +void gl4_1core_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param); +void gl4_1core_glDepthFunc(void *_glfuncs, GLenum glfunc); +void gl4_1core_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass); +void gl4_1core_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask); +void gl4_1core_glLogicOp(void *_glfuncs, GLenum opcode); +void gl4_1core_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor); +void gl4_1core_glFlush(void *_glfuncs); +void gl4_1core_glFinish(void *_glfuncs); +void gl4_1core_glEnable(void *_glfuncs, GLenum cap); +void gl4_1core_glDisable(void *_glfuncs, GLenum cap); +void gl4_1core_glDepthMask(void *_glfuncs, GLboolean flag); +void gl4_1core_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +void gl4_1core_glStencilMask(void *_glfuncs, GLuint mask); +void gl4_1core_glClearDepth(void *_glfuncs, GLdouble depth); +void gl4_1core_glClearStencil(void *_glfuncs, GLint s); +void gl4_1core_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl4_1core_glClear(void *_glfuncs, GLbitfield mask); +void gl4_1core_glDrawBuffer(void *_glfuncs, GLenum mode); +void gl4_1core_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_1core_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_1core_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl4_1core_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl4_1core_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl4_1core_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl4_1core_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_1core_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode); +void gl4_1core_glPointSize(void *_glfuncs, GLfloat size); +void gl4_1core_glLineWidth(void *_glfuncs, GLfloat width); +void gl4_1core_glHint(void *_glfuncs, GLenum target, GLenum mode); +void gl4_1core_glFrontFace(void *_glfuncs, GLenum mode); +void gl4_1core_glCullFace(void *_glfuncs, GLenum mode); +void gl4_1core_glIndexubv(void *_glfuncs, const GLubyte* c); +void gl4_1core_glIndexub(void *_glfuncs, GLubyte c); +GLboolean gl4_1core_glIsTexture(void *_glfuncs, GLuint texture); +void gl4_1core_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures); +void gl4_1core_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures); +void gl4_1core_glBindTexture(void *_glfuncs, GLenum target, GLuint texture); +void gl4_1core_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_1core_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_1core_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_1core_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +void gl4_1core_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +void gl4_1core_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border); +void gl4_1core_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units); +void gl4_1core_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl4_1core_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count); +void gl4_1core_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_1core_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_1core_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_1core_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl4_1core_glBlendEquation(void *_glfuncs, GLenum mode); +void gl4_1core_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl4_1core_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img); +void gl4_1core_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl4_1core_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl4_1core_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl4_1core_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data); +void gl4_1core_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data); +void gl4_1core_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data); +void gl4_1core_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert); +void gl4_1core_glActiveTexture(void *_glfuncs, GLenum texture); +void gl4_1core_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params); +void gl4_1core_glPointParameteri(void *_glfuncs, GLenum pname, GLint param); +void gl4_1core_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl4_1core_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param); +void gl4_1core_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount); +void gl4_1core_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +void gl4_1core_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +GLboolean gl4_1core_glUnmapBuffer(void *_glfuncs, GLenum target); +void gl4_1core_glGetBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data); +void gl4_1core_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data); +void gl4_1core_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage); +GLboolean gl4_1core_glIsBuffer(void *_glfuncs, GLuint buffer); +void gl4_1core_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers); +void gl4_1core_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers); +void gl4_1core_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer); +void gl4_1core_glGetQueryObjectuiv(void *_glfuncs, GLuint id, GLenum pname, GLuint* params); +void gl4_1core_glGetQueryObjectiv(void *_glfuncs, GLuint id, GLenum pname, GLint* params); +void gl4_1core_glGetQueryiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_1core_glEndQuery(void *_glfuncs, GLenum target); +void gl4_1core_glBeginQuery(void *_glfuncs, GLenum target, GLuint id); +GLboolean gl4_1core_glIsQuery(void *_glfuncs, GLuint id); +void gl4_1core_glDeleteQueries(void *_glfuncs, GLsizei n, const GLuint* ids); +void gl4_1core_glGenQueries(void *_glfuncs, GLsizei n, GLuint* ids); +void gl4_1core_glVertexAttribPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLboolean normalized, GLsizei stride, const GLvoid* offset); +void gl4_1core_glValidateProgram(void *_glfuncs, GLuint program); +void gl4_1core_glUniformMatrix4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_1core_glUniformMatrix3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_1core_glUniformMatrix2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_1core_glUniform4iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl4_1core_glUniform3iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl4_1core_glUniform2iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl4_1core_glUniform1iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl4_1core_glUniform4fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl4_1core_glUniform3fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl4_1core_glUniform2fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl4_1core_glUniform1fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl4_1core_glUniform4i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +void gl4_1core_glUniform3i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2); +void gl4_1core_glUniform2i(void *_glfuncs, GLint location, GLint v0, GLint v1); +void gl4_1core_glUniform1i(void *_glfuncs, GLint location, GLint v0); +void gl4_1core_glUniform4f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +void gl4_1core_glUniform3f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +void gl4_1core_glUniform2f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1); +void gl4_1core_glUniform1f(void *_glfuncs, GLint location, GLfloat v0); +void gl4_1core_glUseProgram(void *_glfuncs, GLuint program); +void gl4_1core_glShaderSource(void *_glfuncs, GLuint shader, GLsizei count, const GLchar** source, const GLint* length); +void gl4_1core_glLinkProgram(void *_glfuncs, GLuint program); +GLboolean gl4_1core_glIsShader(void *_glfuncs, GLuint shader); +GLboolean gl4_1core_glIsProgram(void *_glfuncs, GLuint program); +void gl4_1core_glGetVertexAttribiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params); +void gl4_1core_glGetVertexAttribfv(void *_glfuncs, GLuint index, GLenum pname, GLfloat* params); +void gl4_1core_glGetVertexAttribdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params); +void gl4_1core_glGetUniformiv(void *_glfuncs, GLuint program, GLint location, GLint* params); +void gl4_1core_glGetUniformfv(void *_glfuncs, GLuint program, GLint location, GLfloat* params); +GLint gl4_1core_glGetUniformLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl4_1core_glGetShaderSource(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source); +void gl4_1core_glGetShaderInfoLog(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl4_1core_glGetShaderiv(void *_glfuncs, GLuint shader, GLenum pname, GLint* params); +void gl4_1core_glGetProgramInfoLog(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl4_1core_glGetProgramiv(void *_glfuncs, GLuint program, GLenum pname, GLint* params); +GLint gl4_1core_glGetAttribLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl4_1core_glGetAttachedShaders(void *_glfuncs, GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj); +void gl4_1core_glGetActiveUniform(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name); +void gl4_1core_glGetActiveAttrib(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name); +void gl4_1core_glEnableVertexAttribArray(void *_glfuncs, GLuint index); +void gl4_1core_glDisableVertexAttribArray(void *_glfuncs, GLuint index); +void gl4_1core_glDetachShader(void *_glfuncs, GLuint program, GLuint shader); +void gl4_1core_glDeleteShader(void *_glfuncs, GLuint shader); +void gl4_1core_glDeleteProgram(void *_glfuncs, GLuint program); +GLuint gl4_1core_glCreateShader(void *_glfuncs, GLenum gltype); +GLuint gl4_1core_glCreateProgram(void *_glfuncs); +void gl4_1core_glCompileShader(void *_glfuncs, GLuint shader); +void gl4_1core_glBindAttribLocation(void *_glfuncs, GLuint program, GLuint index, const GLchar* name); +void gl4_1core_glAttachShader(void *_glfuncs, GLuint program, GLuint shader); +void gl4_1core_glStencilMaskSeparate(void *_glfuncs, GLenum face, GLuint mask); +void gl4_1core_glStencilFuncSeparate(void *_glfuncs, GLenum face, GLenum glfunc, GLint ref, GLuint mask); +void gl4_1core_glStencilOpSeparate(void *_glfuncs, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +void gl4_1core_glDrawBuffers(void *_glfuncs, GLsizei n, const GLenum* bufs); +void gl4_1core_glBlendEquationSeparate(void *_glfuncs, GLenum modeRGB, GLenum modeAlpha); +void gl4_1core_glUniformMatrix4x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_1core_glUniformMatrix3x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_1core_glUniformMatrix4x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_1core_glUniformMatrix2x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_1core_glUniformMatrix3x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_1core_glUniformMatrix2x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +GLboolean gl4_1core_glIsVertexArray(void *_glfuncs, GLuint array); +void gl4_1core_glGenVertexArrays(void *_glfuncs, GLsizei n, GLuint* arrays); +void gl4_1core_glDeleteVertexArrays(void *_glfuncs, GLsizei n, const GLuint* arrays); +void gl4_1core_glBindVertexArray(void *_glfuncs, GLuint array); +void gl4_1core_glFlushMappedBufferRange(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr length); +void gl4_1core_glFramebufferTextureLayer(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +void gl4_1core_glRenderbufferStorageMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height); +void gl4_1core_glBlitFramebuffer(void *_glfuncs, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +void gl4_1core_glGenerateMipmap(void *_glfuncs, GLenum target); +void gl4_1core_glGetFramebufferAttachmentParameteriv(void *_glfuncs, GLenum target, GLenum attachment, GLenum pname, GLint* params); +void gl4_1core_glFramebufferRenderbuffer(void *_glfuncs, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +void gl4_1core_glFramebufferTexture3D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +void gl4_1core_glFramebufferTexture2D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +void gl4_1core_glFramebufferTexture1D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLenum gl4_1core_glCheckFramebufferStatus(void *_glfuncs, GLenum target); +void gl4_1core_glGenFramebuffers(void *_glfuncs, GLsizei n, GLuint* framebuffers); +void gl4_1core_glDeleteFramebuffers(void *_glfuncs, GLsizei n, const GLuint* framebuffers); +void gl4_1core_glBindFramebuffer(void *_glfuncs, GLenum target, GLuint framebuffer); +GLboolean gl4_1core_glIsFramebuffer(void *_glfuncs, GLuint framebuffer); +void gl4_1core_glGetRenderbufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_1core_glRenderbufferStorage(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height); +void gl4_1core_glGenRenderbuffers(void *_glfuncs, GLsizei n, GLuint* renderbuffers); +void gl4_1core_glDeleteRenderbuffers(void *_glfuncs, GLsizei n, const GLuint* renderbuffers); +void gl4_1core_glBindRenderbuffer(void *_glfuncs, GLenum target, GLuint renderbuffer); +GLboolean gl4_1core_glIsRenderbuffer(void *_glfuncs, GLuint renderbuffer); +void gl4_1core_glClearBufferfi(void *_glfuncs, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); +void gl4_1core_glClearBufferfv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLfloat* value); +void gl4_1core_glClearBufferuiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLuint* value); +void gl4_1core_glClearBufferiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLint* value); +void gl4_1core_glGetTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, GLuint* params); +void gl4_1core_glGetTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_1core_glTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, const GLuint* params); +void gl4_1core_glTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl4_1core_glUniform4uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl4_1core_glUniform3uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl4_1core_glUniform2uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl4_1core_glUniform1uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl4_1core_glUniform4ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +void gl4_1core_glUniform3ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2); +void gl4_1core_glUniform2ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1); +void gl4_1core_glUniform1ui(void *_glfuncs, GLint location, GLuint v0); +GLint gl4_1core_glGetFragDataLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl4_1core_glBindFragDataLocation(void *_glfuncs, GLuint program, GLuint color, const GLchar* name); +void gl4_1core_glGetUniformuiv(void *_glfuncs, GLuint program, GLint location, GLuint* params); +void gl4_1core_glGetVertexAttribIuiv(void *_glfuncs, GLuint index, GLenum pname, GLuint* params); +void gl4_1core_glGetVertexAttribIiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params); +void gl4_1core_glVertexAttribIPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_1core_glEndConditionalRender(void *_glfuncs); +void gl4_1core_glBeginConditionalRender(void *_glfuncs, GLuint id, GLenum mode); +void gl4_1core_glClampColor(void *_glfuncs, GLenum target, GLenum clamp); +void gl4_1core_glGetTransformFeedbackVarying(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* gltype, GLchar* name); +void gl4_1core_glBindBufferBase(void *_glfuncs, GLenum target, GLuint index, GLuint buffer); +void gl4_1core_glBindBufferRange(void *_glfuncs, GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +void gl4_1core_glEndTransformFeedback(void *_glfuncs); +void gl4_1core_glBeginTransformFeedback(void *_glfuncs, GLenum primitiveMode); +GLboolean gl4_1core_glIsEnabledi(void *_glfuncs, GLenum target, GLuint index); +void gl4_1core_glDisablei(void *_glfuncs, GLenum target, GLuint index); +void gl4_1core_glEnablei(void *_glfuncs, GLenum target, GLuint index); +void gl4_1core_glGetIntegeri_v(void *_glfuncs, GLenum target, GLuint index, GLint* data); +void gl4_1core_glGetBooleani_v(void *_glfuncs, GLenum target, GLuint index, GLboolean* data); +void gl4_1core_glColorMaski(void *_glfuncs, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +void gl4_1core_glCopyBufferSubData(void *_glfuncs, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +void gl4_1core_glUniformBlockBinding(void *_glfuncs, GLuint program, GLuint v0, GLuint v1); +void gl4_1core_glGetActiveUniformBlockName(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName); +void gl4_1core_glGetActiveUniformBlockiv(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params); +GLuint gl4_1core_glGetUniformBlockIndex(void *_glfuncs, GLuint program, const GLchar* uniformBlockName); +void gl4_1core_glGetActiveUniformName(void *_glfuncs, GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName); +void gl4_1core_glGetActiveUniformsiv(void *_glfuncs, GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params); +void gl4_1core_glPrimitiveRestartIndex(void *_glfuncs, GLuint index); +void gl4_1core_glTexBuffer(void *_glfuncs, GLenum target, GLenum internalFormat, GLuint buffer); +void gl4_1core_glDrawElementsInstanced(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount); +void gl4_1core_glDrawArraysInstanced(void *_glfuncs, GLenum mode, GLint first, GLsizei count, GLsizei instancecount); +void gl4_1core_glSampleMaski(void *_glfuncs, GLuint index, GLbitfield mask); +void gl4_1core_glGetMultisamplefv(void *_glfuncs, GLenum pname, GLuint index, GLfloat* val); +void gl4_1core_glTexImage3DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); +void gl4_1core_glTexImage2DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +void gl4_1core_glGetSynciv(void *_glfuncs, GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values); +void gl4_1core_glGetInteger64v(void *_glfuncs, GLenum pname, GLint64* params); +void gl4_1core_glWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout); +GLenum gl4_1core_glClientWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout); +void gl4_1core_glDeleteSync(void *_glfuncs, GLsync sync); +GLboolean gl4_1core_glIsSync(void *_glfuncs, GLsync sync); +GLsync gl4_1core_glFenceSync(void *_glfuncs, GLenum condition, GLbitfield flags); +void gl4_1core_glProvokingVertex(void *_glfuncs, GLenum mode); +void gl4_1core_glDrawElementsInstancedBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLint basevertex); +void gl4_1core_glDrawRangeElementsBaseVertex(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex); +void gl4_1core_glDrawElementsBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex); +void gl4_1core_glFramebufferTexture(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level); +void gl4_1core_glGetBufferParameteri64v(void *_glfuncs, GLenum target, GLenum pname, GLint64* params); +void gl4_1core_glGetInteger64i_v(void *_glfuncs, GLenum target, GLuint index, GLint64* data); +void gl4_1core_glVertexAttribP4uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl4_1core_glVertexAttribP4ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl4_1core_glVertexAttribP3uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl4_1core_glVertexAttribP3ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl4_1core_glVertexAttribP2uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl4_1core_glVertexAttribP2ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl4_1core_glVertexAttribP1uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl4_1core_glVertexAttribP1ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl4_1core_glSecondaryColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color); +void gl4_1core_glSecondaryColorP3ui(void *_glfuncs, GLenum gltype, GLuint color); +void gl4_1core_glColorP4uiv(void *_glfuncs, GLenum gltype, const GLuint* color); +void gl4_1core_glColorP4ui(void *_glfuncs, GLenum gltype, GLuint color); +void gl4_1core_glColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color); +void gl4_1core_glColorP3ui(void *_glfuncs, GLenum gltype, GLuint color); +void gl4_1core_glNormalP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_1core_glNormalP3ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_1core_glMultiTexCoordP4uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl4_1core_glMultiTexCoordP4ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl4_1core_glMultiTexCoordP3uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl4_1core_glMultiTexCoordP3ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl4_1core_glMultiTexCoordP2uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl4_1core_glMultiTexCoordP2ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl4_1core_glMultiTexCoordP1uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl4_1core_glMultiTexCoordP1ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl4_1core_glTexCoordP4uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_1core_glTexCoordP4ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_1core_glTexCoordP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_1core_glTexCoordP3ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_1core_glTexCoordP2uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_1core_glTexCoordP2ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_1core_glTexCoordP1uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_1core_glTexCoordP1ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_1core_glVertexP4uiv(void *_glfuncs, GLenum gltype, const GLuint* value); +void gl4_1core_glVertexP4ui(void *_glfuncs, GLenum gltype, GLuint value); +void gl4_1core_glVertexP3uiv(void *_glfuncs, GLenum gltype, const GLuint* value); +void gl4_1core_glVertexP3ui(void *_glfuncs, GLenum gltype, GLuint value); +void gl4_1core_glVertexP2uiv(void *_glfuncs, GLenum gltype, const GLuint* value); +void gl4_1core_glVertexP2ui(void *_glfuncs, GLenum gltype, GLuint value); +void gl4_1core_glGetQueryObjectui64v(void *_glfuncs, GLuint id, GLenum pname, GLuint64* params); +void gl4_1core_glGetQueryObjecti64v(void *_glfuncs, GLuint id, GLenum pname, GLint64* params); +void gl4_1core_glQueryCounter(void *_glfuncs, GLuint id, GLenum target); +void gl4_1core_glGetSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, GLuint* params); +void gl4_1core_glGetSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat* params); +void gl4_1core_glGetSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params); +void gl4_1core_glGetSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params); +void gl4_1core_glSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLuint* param); +void gl4_1core_glSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param); +void gl4_1core_glSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, const GLfloat* param); +void gl4_1core_glSamplerParameterf(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat param); +void gl4_1core_glSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param); +void gl4_1core_glSamplerParameteri(void *_glfuncs, GLuint sampler, GLenum pname, GLint param); +void gl4_1core_glBindSampler(void *_glfuncs, GLuint unit, GLuint sampler); +GLboolean gl4_1core_glIsSampler(void *_glfuncs, GLuint sampler); +void gl4_1core_glDeleteSamplers(void *_glfuncs, GLsizei count, const GLuint* samplers); +void gl4_1core_glGenSamplers(void *_glfuncs, GLsizei count, GLuint* samplers); +GLint gl4_1core_glGetFragDataIndex(void *_glfuncs, GLuint program, const GLchar* name); +void gl4_1core_glBindFragDataLocationIndexed(void *_glfuncs, GLuint program, GLuint colorNumber, GLuint index, const GLchar* name); +void gl4_1core_glVertexAttribDivisor(void *_glfuncs, GLuint index, GLuint divisor); +void gl4_1core_glGetQueryIndexediv(void *_glfuncs, GLenum target, GLuint index, GLenum pname, GLint* params); +void gl4_1core_glEndQueryIndexed(void *_glfuncs, GLenum target, GLuint index); +void gl4_1core_glBeginQueryIndexed(void *_glfuncs, GLenum target, GLuint index, GLuint id); +void gl4_1core_glDrawTransformFeedbackStream(void *_glfuncs, GLenum mode, GLuint id, GLuint stream); +void gl4_1core_glDrawTransformFeedback(void *_glfuncs, GLenum mode, GLuint id); +void gl4_1core_glResumeTransformFeedback(void *_glfuncs); +void gl4_1core_glPauseTransformFeedback(void *_glfuncs); +GLboolean gl4_1core_glIsTransformFeedback(void *_glfuncs, GLuint id); +void gl4_1core_glGenTransformFeedbacks(void *_glfuncs, GLsizei n, GLuint* ids); +void gl4_1core_glDeleteTransformFeedbacks(void *_glfuncs, GLsizei n, const GLuint* ids); +void gl4_1core_glBindTransformFeedback(void *_glfuncs, GLenum target, GLuint id); +void gl4_1core_glPatchParameterfv(void *_glfuncs, GLenum pname, const GLfloat* values); +void gl4_1core_glPatchParameteri(void *_glfuncs, GLenum pname, GLint value); +void gl4_1core_glGetProgramStageiv(void *_glfuncs, GLuint program, GLenum shadertype, GLenum pname, GLint* values); +void gl4_1core_glGetUniformSubroutineuiv(void *_glfuncs, GLenum shadertype, GLint location, GLuint* params); +void gl4_1core_glUniformSubroutinesuiv(void *_glfuncs, GLenum shadertype, GLsizei count, const GLuint* value); +void gl4_1core_glGetActiveSubroutineName(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name); +void gl4_1core_glGetActiveSubroutineUniformName(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name); +void gl4_1core_glGetActiveSubroutineUniformiv(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint* values); +GLuint gl4_1core_glGetSubroutineIndex(void *_glfuncs, GLuint program, GLenum shadertype, const GLchar* name); +GLint gl4_1core_glGetSubroutineUniformLocation(void *_glfuncs, GLuint program, GLenum shadertype, const GLchar* name); +void gl4_1core_glGetUniformdv(void *_glfuncs, GLuint program, GLint location, GLdouble* params); +void gl4_1core_glUniformMatrix4x3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1core_glUniformMatrix4x2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1core_glUniformMatrix3x4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1core_glUniformMatrix3x2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1core_glUniformMatrix2x4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1core_glUniformMatrix2x3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1core_glUniformMatrix4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1core_glUniformMatrix3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1core_glUniformMatrix2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1core_glUniform4dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value); +void gl4_1core_glUniform3dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value); +void gl4_1core_glUniform2dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value); +void gl4_1core_glUniform1dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value); +void gl4_1core_glUniform4d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3); +void gl4_1core_glUniform3d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1, GLdouble v2); +void gl4_1core_glUniform2d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1); +void gl4_1core_glUniform1d(void *_glfuncs, GLint location, GLdouble v0); +void gl4_1core_glDrawElementsIndirect(void *_glfuncs, GLenum mode, GLenum gltype, const GLvoid* indirect); +void gl4_1core_glDrawArraysIndirect(void *_glfuncs, GLenum mode, const GLvoid* indirect); +void gl4_1core_glBlendFuncSeparatei(void *_glfuncs, GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); +void gl4_1core_glBlendFunci(void *_glfuncs, GLuint buf, GLenum src, GLenum dst); +void gl4_1core_glBlendEquationSeparatei(void *_glfuncs, GLuint buf, GLenum modeRGB, GLenum modeAlpha); +void gl4_1core_glBlendEquationi(void *_glfuncs, GLuint buf, GLenum mode); +void gl4_1core_glMinSampleShading(void *_glfuncs, GLfloat value); +void gl4_1core_glGetDoublei_v(void *_glfuncs, GLenum target, GLuint index, GLdouble* data); +void gl4_1core_glGetFloati_v(void *_glfuncs, GLenum target, GLuint index, GLfloat* data); +void gl4_1core_glDepthRangeIndexed(void *_glfuncs, GLuint index, GLdouble n, GLdouble f); +void gl4_1core_glDepthRangeArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLdouble* v); +void gl4_1core_glScissorIndexedv(void *_glfuncs, GLuint index, const GLint* v); +void gl4_1core_glScissorIndexed(void *_glfuncs, GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height); +void gl4_1core_glScissorArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLint* v); +void gl4_1core_glViewportIndexedfv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl4_1core_glViewportIndexedf(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h); +void gl4_1core_glViewportArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLfloat* v); +void gl4_1core_glGetVertexAttribLdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params); +void gl4_1core_glVertexAttribLPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_1core_glVertexAttribL4dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_1core_glVertexAttribL3dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_1core_glVertexAttribL2dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_1core_glVertexAttribL1dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_1core_glVertexAttribL4d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl4_1core_glVertexAttribL3d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z); +void gl4_1core_glVertexAttribL2d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y); +void gl4_1core_glVertexAttribL1d(void *_glfuncs, GLuint index, GLdouble x); +void gl4_1core_glGetProgramPipelineInfoLog(void *_glfuncs, GLuint pipeline, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl4_1core_glValidateProgramPipeline(void *_glfuncs, GLuint pipeline); +void gl4_1core_glProgramUniformMatrix4x3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1core_glProgramUniformMatrix3x4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1core_glProgramUniformMatrix4x2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1core_glProgramUniformMatrix2x4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1core_glProgramUniformMatrix3x2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1core_glProgramUniformMatrix2x3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1core_glProgramUniformMatrix4x3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_1core_glProgramUniformMatrix3x4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_1core_glProgramUniformMatrix4x2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_1core_glProgramUniformMatrix2x4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_1core_glProgramUniformMatrix3x2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_1core_glProgramUniformMatrix2x3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_1core_glProgramUniformMatrix4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1core_glProgramUniformMatrix3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1core_glProgramUniformMatrix2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_1core_glProgramUniformMatrix4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_1core_glProgramUniformMatrix3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_1core_glProgramUniformMatrix2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_1core_glProgramUniform4uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value); +void gl4_1core_glProgramUniform4ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +void gl4_1core_glProgramUniform4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value); +void gl4_1core_glProgramUniform4d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3); +void gl4_1core_glProgramUniform4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value); +void gl4_1core_glProgramUniform4f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +void gl4_1core_glProgramUniform4iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value); +void gl4_1core_glProgramUniform4i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +void gl4_1core_glProgramUniform3uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value); +void gl4_1core_glProgramUniform3ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2); +void gl4_1core_glProgramUniform3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value); +void gl4_1core_glProgramUniform3d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2); +void gl4_1core_glProgramUniform3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value); +void gl4_1core_glProgramUniform3f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +void gl4_1core_glProgramUniform3iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value); +void gl4_1core_glProgramUniform3i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1, GLint v2); +void gl4_1core_glProgramUniform2uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value); +void gl4_1core_glProgramUniform2ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1); +void gl4_1core_glProgramUniform2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value); +void gl4_1core_glProgramUniform2d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1); +void gl4_1core_glProgramUniform2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value); +void gl4_1core_glProgramUniform2f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1); +void gl4_1core_glProgramUniform2iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value); +void gl4_1core_glProgramUniform2i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1); +void gl4_1core_glProgramUniform1uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value); +void gl4_1core_glProgramUniform1ui(void *_glfuncs, GLuint program, GLint location, GLuint v0); +void gl4_1core_glProgramUniform1dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value); +void gl4_1core_glProgramUniform1d(void *_glfuncs, GLuint program, GLint location, GLdouble v0); +void gl4_1core_glProgramUniform1fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value); +void gl4_1core_glProgramUniform1f(void *_glfuncs, GLuint program, GLint location, GLfloat v0); +void gl4_1core_glProgramUniform1iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value); +void gl4_1core_glProgramUniform1i(void *_glfuncs, GLuint program, GLint location, GLint v0); +void gl4_1core_glGetProgramPipelineiv(void *_glfuncs, GLuint pipeline, GLenum pname, GLint* params); +GLboolean gl4_1core_glIsProgramPipeline(void *_glfuncs, GLuint pipeline); +void gl4_1core_glGenProgramPipelines(void *_glfuncs, GLsizei n, GLuint* pipelines); +void gl4_1core_glDeleteProgramPipelines(void *_glfuncs, GLsizei n, const GLuint* pipelines); +void gl4_1core_glBindProgramPipeline(void *_glfuncs, GLuint pipeline); +void gl4_1core_glActiveShaderProgram(void *_glfuncs, GLuint pipeline, GLuint program); +void gl4_1core_glUseProgramStages(void *_glfuncs, GLuint pipeline, GLbitfield stages, GLuint program); +void gl4_1core_glProgramParameteri(void *_glfuncs, GLuint program, GLenum pname, GLint value); +void gl4_1core_glProgramBinary(void *_glfuncs, GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length); +void gl4_1core_glGetProgramBinary(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary); +void gl4_1core_glClearDepthf(void *_glfuncs, GLfloat dd); +void gl4_1core_glDepthRangef(void *_glfuncs, GLfloat n, GLfloat f); +void gl4_1core_glGetShaderPrecisionFormat(void *_glfuncs, GLenum shadertype, GLenum precisionType, GLint* range_, GLint* precision); +void gl4_1core_glShaderBinary(void *_glfuncs, GLsizei count, const GLuint* shaders, GLenum binaryFormat, const GLvoid* binary, GLsizei length); +void gl4_1core_glReleaseShaderCompiler(void *_glfuncs); + + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/gl/4.1core/gl.go b/gl/4.1core/gl.go new file mode 100644 index 00000000..e5579001 --- /dev/null +++ b/gl/4.1core/gl.go @@ -0,0 +1,6409 @@ +// ** file automatically generated by glgen -- do not edit manually ** + +package GL + +// #cgo CXXFLAGS: -std=c++0x -pedantic-errors -Wall -fno-strict-aliasing +// #cgo LDFLAGS: -lstdc++ +// #cgo pkg-config: Qt5Core Qt5OpenGL +// +// #include "funcs.h" +// +// void free(void*); +// +import "C" + +import ( + "fmt" + "reflect" + "unsafe" + + "gopkg.in/qml.v1/gl/glbase" +) + +// API returns a value that offers methods matching the OpenGL version 4.1 API. +// +// The returned API must not be used after the provided OpenGL context becomes invalid. +func API(context glbase.Contexter) *GL { + gl := &GL{} + gl.funcs = C.gl4_1core_funcs() + if gl.funcs == nil { + panic(fmt.Errorf("OpenGL version 4.1 is not available")) + } + return gl +} + +// GL implements the OpenGL version 4.1 API. Values of this +// type must be created via the API function, and it must not be used after +// the associated OpenGL context becomes invalid. +type GL struct { + funcs unsafe.Pointer +} + +const ( + FALSE = 0 + TRUE = 1 + NONE = 0 + + BYTE = 0x1400 + UNSIGNED_BYTE = 0x1401 + SHORT = 0x1402 + UNSIGNED_SHORT = 0x1403 + INT = 0x1404 + UNSIGNED_INT = 0x1405 + FLOAT = 0x1406 + N2_BYTES = 0x1407 + N3_BYTES = 0x1408 + N4_BYTES = 0x1409 + DOUBLE = 0x140A + HALF_FLOAT = 0x140B + FIXED = 0x140C + + ACCUM = 0x0100 + LOAD = 0x0101 + RETURN = 0x0102 + MULT = 0x0103 + ADD = 0x0104 + + ACCUM_BUFFER_BIT = 0x00000200 + ALL_ATTRIB_BITS = 0xFFFFFFFF + COLOR_BUFFER_BIT = 0x00004000 + CURRENT_BIT = 0x00000001 + DEPTH_BUFFER_BIT = 0x00000100 + ENABLE_BIT = 0x00002000 + EVAL_BIT = 0x00010000 + FOG_BIT = 0x00000080 + HINT_BIT = 0x00008000 + LIGHTING_BIT = 0x00000040 + LINE_BIT = 0x00000004 + LIST_BIT = 0x00020000 + MULTISAMPLE_BIT = 0x20000000 + PIXEL_MODE_BIT = 0x00000020 + POINT_BIT = 0x00000002 + POLYGON_BIT = 0x00000008 + POLYGON_STIPPLE_BIT = 0x00000010 + SCISSOR_BIT = 0x00080000 + STENCIL_BUFFER_BIT = 0x00000400 + TEXTURE_BIT = 0x00040000 + TRANSFORM_BIT = 0x00001000 + VIEWPORT_BIT = 0x00000800 + + ALWAYS = 0x0207 + EQUAL = 0x0202 + GEQUAL = 0x0206 + GREATER = 0x0204 + LEQUAL = 0x0203 + LESS = 0x0201 + NEVER = 0x0200 + NOTEQUAL = 0x0205 + + LOGIC_OP = 0x0BF1 + + DST_ALPHA = 0x0304 + ONE = 1 + ONE_MINUS_DST_ALPHA = 0x0305 + ONE_MINUS_SRC_ALPHA = 0x0303 + ONE_MINUS_SRC_COLOR = 0x0301 + SRC_ALPHA = 0x0302 + SRC_COLOR = 0x0300 + ZERO = 0 + + DST_COLOR = 0x0306 + ONE_MINUS_DST_COLOR = 0x0307 + SRC_ALPHA_SATURATE = 0x0308 + + CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF + CLIENT_PIXEL_STORE_BIT = 0x00000001 + CLIENT_VERTEX_ARRAY_BIT = 0x00000002 + + CLIP_DISTANCE0 = 0x3000 + CLIP_DISTANCE1 = 0x3001 + CLIP_DISTANCE2 = 0x3002 + CLIP_DISTANCE3 = 0x3003 + CLIP_DISTANCE4 = 0x3004 + CLIP_DISTANCE5 = 0x3005 + CLIP_DISTANCE6 = 0x3006 + CLIP_DISTANCE7 = 0x3007 + CLIP_PLANE0 = 0x3000 + CLIP_PLANE1 = 0x3001 + CLIP_PLANE2 = 0x3002 + CLIP_PLANE3 = 0x3003 + CLIP_PLANE4 = 0x3004 + CLIP_PLANE5 = 0x3005 + + BACK = 0x0405 + FRONT = 0x0404 + FRONT_AND_BACK = 0x0408 + + AMBIENT = 0x1200 + AMBIENT_AND_DIFFUSE = 0x1602 + DIFFUSE = 0x1201 + EMISSION = 0x1600 + SPECULAR = 0x1202 + + CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x00000001 + + CONTEXT_COMPATIBILITY_PROFILE_BIT = 0x00000002 + CONTEXT_CORE_PROFILE_BIT = 0x00000001 + + AUX0 = 0x0409 + AUX1 = 0x040A + AUX2 = 0x040B + AUX3 = 0x040C + BACK_LEFT = 0x0402 + BACK_RIGHT = 0x0403 + FRONT_LEFT = 0x0400 + FRONT_RIGHT = 0x0401 + LEFT = 0x0406 + RIGHT = 0x0407 + + ALPHA_TEST = 0x0BC0 + AUTO_NORMAL = 0x0D80 + BLEND = 0x0BE2 + COLOR_ARRAY = 0x8076 + COLOR_LOGIC_OP = 0x0BF2 + COLOR_MATERIAL = 0x0B57 + CULL_FACE = 0x0B44 + DEPTH_TEST = 0x0B71 + DITHER = 0x0BD0 + EDGE_FLAG_ARRAY = 0x8079 + FOG = 0x0B60 + INDEX_ARRAY = 0x8077 + INDEX_LOGIC_OP = 0x0BF1 + LIGHT0 = 0x4000 + LIGHT1 = 0x4001 + LIGHT2 = 0x4002 + LIGHT3 = 0x4003 + LIGHT4 = 0x4004 + LIGHT5 = 0x4005 + LIGHT6 = 0x4006 + LIGHT7 = 0x4007 + LIGHTING = 0x0B50 + LINE_SMOOTH = 0x0B20 + LINE_STIPPLE = 0x0B24 + MAP1_COLOR_4 = 0x0D90 + MAP1_INDEX = 0x0D91 + MAP1_NORMAL = 0x0D92 + MAP1_TEXTURE_COORD_1 = 0x0D93 + MAP1_TEXTURE_COORD_2 = 0x0D94 + MAP1_TEXTURE_COORD_3 = 0x0D95 + MAP1_TEXTURE_COORD_4 = 0x0D96 + MAP1_VERTEX_3 = 0x0D97 + MAP1_VERTEX_4 = 0x0D98 + MAP2_COLOR_4 = 0x0DB0 + MAP2_INDEX = 0x0DB1 + MAP2_NORMAL = 0x0DB2 + MAP2_TEXTURE_COORD_1 = 0x0DB3 + MAP2_TEXTURE_COORD_2 = 0x0DB4 + MAP2_TEXTURE_COORD_3 = 0x0DB5 + MAP2_TEXTURE_COORD_4 = 0x0DB6 + MAP2_VERTEX_3 = 0x0DB7 + MAP2_VERTEX_4 = 0x0DB8 + NORMALIZE = 0x0BA1 + NORMAL_ARRAY = 0x8075 + POINT_SMOOTH = 0x0B10 + POLYGON_OFFSET_FILL = 0x8037 + POLYGON_OFFSET_LINE = 0x2A02 + POLYGON_OFFSET_POINT = 0x2A01 + POLYGON_SMOOTH = 0x0B41 + POLYGON_STIPPLE = 0x0B42 + SCISSOR_TEST = 0x0C11 + STENCIL_TEST = 0x0B90 + TEXTURE_1D = 0x0DE0 + TEXTURE_2D = 0x0DE1 + TEXTURE_COORD_ARRAY = 0x8078 + TEXTURE_GEN_Q = 0x0C63 + TEXTURE_GEN_R = 0x0C62 + TEXTURE_GEN_S = 0x0C60 + TEXTURE_GEN_T = 0x0C61 + VERTEX_ARRAY = 0x8074 + + INVALID_ENUM = 0x0500 + INVALID_FRAMEBUFFER_OPERATION = 0x0506 + INVALID_OPERATION = 0x0502 + INVALID_VALUE = 0x0501 + NO_ERROR = 0 + OUT_OF_MEMORY = 0x0505 + STACK_OVERFLOW = 0x0503 + STACK_UNDERFLOW = 0x0504 + + N2D = 0x0600 + N3D = 0x0601 + N3D_COLOR = 0x0602 + N3D_COLOR_TEXTURE = 0x0603 + N4D_COLOR_TEXTURE = 0x0604 + + BITMAP_TOKEN = 0x0704 + COPY_PIXEL_TOKEN = 0x0706 + DRAW_PIXEL_TOKEN = 0x0705 + LINE_RESET_TOKEN = 0x0707 + LINE_TOKEN = 0x0702 + PASS_THROUGH_TOKEN = 0x0700 + POINT_TOKEN = 0x0701 + POLYGON_TOKEN = 0x0703 + + EXP = 0x0800 + EXP2 = 0x0801 + LINEAR = 0x2601 + + FOG_COLOR = 0x0B66 + FOG_DENSITY = 0x0B62 + FOG_END = 0x0B64 + FOG_INDEX = 0x0B61 + FOG_MODE = 0x0B65 + FOG_START = 0x0B63 + + CCW = 0x0901 + CW = 0x0900 + + COEFF = 0x0A00 + DOMAIN = 0x0A02 + ORDER = 0x0A01 + + PIXEL_MAP_A_TO_A = 0x0C79 + PIXEL_MAP_B_TO_B = 0x0C78 + PIXEL_MAP_G_TO_G = 0x0C77 + PIXEL_MAP_I_TO_A = 0x0C75 + PIXEL_MAP_I_TO_B = 0x0C74 + PIXEL_MAP_I_TO_G = 0x0C73 + PIXEL_MAP_I_TO_I = 0x0C70 + PIXEL_MAP_I_TO_R = 0x0C72 + PIXEL_MAP_R_TO_R = 0x0C76 + PIXEL_MAP_S_TO_S = 0x0C71 + + ACCUM_ALPHA_BITS = 0x0D5B + ACCUM_BLUE_BITS = 0x0D5A + ACCUM_CLEAR_VALUE = 0x0B80 + ACCUM_GREEN_BITS = 0x0D59 + ACCUM_RED_BITS = 0x0D58 + ALIASED_LINE_WIDTH_RANGE = 0x846E + ALIASED_POINT_SIZE_RANGE = 0x846D + ALPHA_BIAS = 0x0D1D + ALPHA_BITS = 0x0D55 + ALPHA_SCALE = 0x0D1C + ALPHA_TEST_FUNC = 0x0BC1 + ALPHA_TEST_REF = 0x0BC2 + ATTRIB_STACK_DEPTH = 0x0BB0 + AUX_BUFFERS = 0x0C00 + BLEND_DST = 0x0BE0 + BLEND_SRC = 0x0BE1 + BLUE_BIAS = 0x0D1B + BLUE_BITS = 0x0D54 + BLUE_SCALE = 0x0D1A + CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1 + COLOR_ARRAY_SIZE = 0x8081 + COLOR_ARRAY_STRIDE = 0x8083 + COLOR_ARRAY_TYPE = 0x8082 + COLOR_CLEAR_VALUE = 0x0C22 + COLOR_MATERIAL_FACE = 0x0B55 + COLOR_MATERIAL_PARAMETER = 0x0B56 + COLOR_WRITEMASK = 0x0C23 + CULL_FACE_MODE = 0x0B45 + CURRENT_COLOR = 0x0B00 + CURRENT_INDEX = 0x0B01 + CURRENT_NORMAL = 0x0B02 + CURRENT_RASTER_COLOR = 0x0B04 + CURRENT_RASTER_DISTANCE = 0x0B09 + CURRENT_RASTER_INDEX = 0x0B05 + CURRENT_RASTER_POSITION = 0x0B07 + CURRENT_RASTER_POSITION_VALID = 0x0B08 + CURRENT_RASTER_TEXTURE_COORDS = 0x0B06 + CURRENT_TEXTURE_COORDS = 0x0B03 + DEPTH_BIAS = 0x0D1F + DEPTH_BITS = 0x0D56 + DEPTH_CLEAR_VALUE = 0x0B73 + DEPTH_FUNC = 0x0B74 + DEPTH_RANGE = 0x0B70 + DEPTH_SCALE = 0x0D1E + DEPTH_WRITEMASK = 0x0B72 + DOUBLEBUFFER = 0x0C32 + DRAW_BUFFER = 0x0C01 + EDGE_FLAG = 0x0B43 + EDGE_FLAG_ARRAY_STRIDE = 0x808C + FEEDBACK_BUFFER_SIZE = 0x0DF1 + FEEDBACK_BUFFER_TYPE = 0x0DF2 + FOG_HINT = 0x0C54 + FRONT_FACE = 0x0B46 + GREEN_BIAS = 0x0D19 + GREEN_BITS = 0x0D53 + GREEN_SCALE = 0x0D18 + INDEX_ARRAY_STRIDE = 0x8086 + INDEX_ARRAY_TYPE = 0x8085 + INDEX_BITS = 0x0D51 + INDEX_CLEAR_VALUE = 0x0C20 + INDEX_MODE = 0x0C30 + INDEX_OFFSET = 0x0D13 + INDEX_SHIFT = 0x0D12 + INDEX_WRITEMASK = 0x0C21 + LIGHT_MODEL_AMBIENT = 0x0B53 + LIGHT_MODEL_COLOR_CONTROL = 0x81F8 + LIGHT_MODEL_LOCAL_VIEWER = 0x0B51 + LIGHT_MODEL_TWO_SIDE = 0x0B52 + LINE_SMOOTH_HINT = 0x0C52 + LINE_STIPPLE_PATTERN = 0x0B25 + LINE_STIPPLE_REPEAT = 0x0B26 + LINE_WIDTH = 0x0B21 + LINE_WIDTH_GRANULARITY = 0x0B23 + LINE_WIDTH_RANGE = 0x0B22 + LIST_BASE = 0x0B32 + LIST_INDEX = 0x0B33 + LIST_MODE = 0x0B30 + LOGIC_OP_MODE = 0x0BF0 + MAP1_GRID_DOMAIN = 0x0DD0 + MAP1_GRID_SEGMENTS = 0x0DD1 + MAP2_GRID_DOMAIN = 0x0DD2 + MAP2_GRID_SEGMENTS = 0x0DD3 + MAP_COLOR = 0x0D10 + MAP_STENCIL = 0x0D11 + MATRIX_MODE = 0x0BA0 + MAX_ATTRIB_STACK_DEPTH = 0x0D35 + MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B + MAX_CLIP_DISTANCES = 0x0D32 + MAX_CLIP_PLANES = 0x0D32 + MAX_EVAL_ORDER = 0x0D30 + MAX_LIGHTS = 0x0D31 + MAX_LIST_NESTING = 0x0B31 + MAX_MODELVIEW_STACK_DEPTH = 0x0D36 + MAX_NAME_STACK_DEPTH = 0x0D37 + MAX_PIXEL_MAP_TABLE = 0x0D34 + MAX_PROJECTION_STACK_DEPTH = 0x0D38 + MAX_TEXTURE_SIZE = 0x0D33 + MAX_TEXTURE_STACK_DEPTH = 0x0D39 + MAX_VIEWPORT_DIMS = 0x0D3A + MODELVIEW_MATRIX = 0x0BA6 + MODELVIEW_STACK_DEPTH = 0x0BA3 + NAME_STACK_DEPTH = 0x0D70 + NORMAL_ARRAY_STRIDE = 0x807F + NORMAL_ARRAY_TYPE = 0x807E + PACK_ALIGNMENT = 0x0D05 + PACK_LSB_FIRST = 0x0D01 + PACK_ROW_LENGTH = 0x0D02 + PACK_SKIP_PIXELS = 0x0D04 + PACK_SKIP_ROWS = 0x0D03 + PACK_SWAP_BYTES = 0x0D00 + PERSPECTIVE_CORRECTION_HINT = 0x0C50 + PIXEL_MAP_A_TO_A_SIZE = 0x0CB9 + PIXEL_MAP_B_TO_B_SIZE = 0x0CB8 + PIXEL_MAP_G_TO_G_SIZE = 0x0CB7 + PIXEL_MAP_I_TO_A_SIZE = 0x0CB5 + PIXEL_MAP_I_TO_B_SIZE = 0x0CB4 + PIXEL_MAP_I_TO_G_SIZE = 0x0CB3 + PIXEL_MAP_I_TO_I_SIZE = 0x0CB0 + PIXEL_MAP_I_TO_R_SIZE = 0x0CB2 + PIXEL_MAP_R_TO_R_SIZE = 0x0CB6 + PIXEL_MAP_S_TO_S_SIZE = 0x0CB1 + POINT_SIZE = 0x0B11 + POINT_SIZE_GRANULARITY = 0x0B13 + POINT_SIZE_RANGE = 0x0B12 + POINT_SMOOTH_HINT = 0x0C51 + POLYGON_MODE = 0x0B40 + POLYGON_OFFSET_FACTOR = 0x8038 + POLYGON_OFFSET_UNITS = 0x2A00 + POLYGON_SMOOTH_HINT = 0x0C53 + PROJECTION_MATRIX = 0x0BA7 + PROJECTION_STACK_DEPTH = 0x0BA4 + READ_BUFFER = 0x0C02 + RED_BIAS = 0x0D15 + RED_BITS = 0x0D52 + RED_SCALE = 0x0D14 + RENDER_MODE = 0x0C40 + RGBA_MODE = 0x0C31 + SCISSOR_BOX = 0x0C10 + SELECTION_BUFFER_SIZE = 0x0DF4 + SHADE_MODEL = 0x0B54 + SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23 + SMOOTH_LINE_WIDTH_RANGE = 0x0B22 + SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13 + SMOOTH_POINT_SIZE_RANGE = 0x0B12 + STENCIL_BITS = 0x0D57 + STENCIL_CLEAR_VALUE = 0x0B91 + STENCIL_FAIL = 0x0B94 + STENCIL_FUNC = 0x0B92 + STENCIL_PASS_DEPTH_FAIL = 0x0B95 + STENCIL_PASS_DEPTH_PASS = 0x0B96 + STENCIL_REF = 0x0B97 + STENCIL_VALUE_MASK = 0x0B93 + STENCIL_WRITEMASK = 0x0B98 + STEREO = 0x0C33 + SUBPIXEL_BITS = 0x0D50 + TEXTURE_BINDING_1D = 0x8068 + TEXTURE_BINDING_2D = 0x8069 + TEXTURE_BINDING_3D = 0x806A + TEXTURE_COORD_ARRAY_SIZE = 0x8088 + TEXTURE_COORD_ARRAY_STRIDE = 0x808A + TEXTURE_COORD_ARRAY_TYPE = 0x8089 + TEXTURE_MATRIX = 0x0BA8 + TEXTURE_STACK_DEPTH = 0x0BA5 + UNPACK_ALIGNMENT = 0x0CF5 + UNPACK_LSB_FIRST = 0x0CF1 + UNPACK_ROW_LENGTH = 0x0CF2 + UNPACK_SKIP_PIXELS = 0x0CF4 + UNPACK_SKIP_ROWS = 0x0CF3 + UNPACK_SWAP_BYTES = 0x0CF0 + VERTEX_ARRAY_SIZE = 0x807A + VERTEX_ARRAY_STRIDE = 0x807C + VERTEX_ARRAY_TYPE = 0x807B + VIEWPORT = 0x0BA2 + ZOOM_X = 0x0D16 + ZOOM_Y = 0x0D17 + + COLOR_ARRAY_POINTER = 0x8090 + EDGE_FLAG_ARRAY_POINTER = 0x8093 + FEEDBACK_BUFFER_POINTER = 0x0DF0 + INDEX_ARRAY_POINTER = 0x8091 + NORMAL_ARRAY_POINTER = 0x808F + SELECTION_BUFFER_POINTER = 0x0DF3 + TEXTURE_COORD_ARRAY_POINTER = 0x8092 + VERTEX_ARRAY_POINTER = 0x808E + + TEXTURE_ALPHA_SIZE = 0x805F + TEXTURE_BLUE_SIZE = 0x805E + TEXTURE_BORDER = 0x1005 + TEXTURE_BORDER_COLOR = 0x1004 + TEXTURE_COMPONENTS = 0x1003 + TEXTURE_GREEN_SIZE = 0x805D + TEXTURE_HEIGHT = 0x1001 + TEXTURE_INTENSITY_SIZE = 0x8061 + TEXTURE_INTERNAL_FORMAT = 0x1003 + TEXTURE_LUMINANCE_SIZE = 0x8060 + TEXTURE_MAG_FILTER = 0x2800 + TEXTURE_MIN_FILTER = 0x2801 + TEXTURE_PRIORITY = 0x8066 + TEXTURE_RED_SIZE = 0x805C + TEXTURE_RESIDENT = 0x8067 + TEXTURE_WIDTH = 0x1000 + TEXTURE_WRAP_S = 0x2802 + TEXTURE_WRAP_T = 0x2803 + + DONT_CARE = 0x1100 + FASTEST = 0x1101 + NICEST = 0x1102 + + FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B + GENERATE_MIPMAP_HINT = 0x8192 + PROGRAM_BINARY_RETRIEVABLE_HINT = 0x8257 + TEXTURE_COMPRESSION_HINT = 0x84EF + + C3F_V3F = 0x2A24 + C4F_N3F_V3F = 0x2A26 + C4UB_V2F = 0x2A22 + C4UB_V3F = 0x2A23 + N3F_V3F = 0x2A25 + T2F_C3F_V3F = 0x2A2A + T2F_C4F_N3F_V3F = 0x2A2C + T2F_C4UB_V3F = 0x2A29 + T2F_N3F_V3F = 0x2A2B + T2F_V3F = 0x2A27 + T4F_C4F_N3F_V4F = 0x2A2D + T4F_V4F = 0x2A28 + V2F = 0x2A20 + V3F = 0x2A21 + + MODULATE = 0x2100 + REPLACE = 0x1E01 + + SEPARATE_SPECULAR_COLOR = 0x81FA + SINGLE_COLOR = 0x81F9 + + CONSTANT_ATTENUATION = 0x1207 + LINEAR_ATTENUATION = 0x1208 + POSITION = 0x1203 + QUADRATIC_ATTENUATION = 0x1209 + SPOT_CUTOFF = 0x1206 + SPOT_DIRECTION = 0x1204 + SPOT_EXPONENT = 0x1205 + + COMPILE = 0x1300 + COMPILE_AND_EXECUTE = 0x1301 + + AND = 0x1501 + AND_INVERTED = 0x1504 + AND_REVERSE = 0x1502 + CLEAR = 0x1500 + COPY = 0x1503 + COPY_INVERTED = 0x150C + EQUIV = 0x1509 + INVERT = 0x150A + NAND = 0x150E + NOOP = 0x1505 + NOR = 0x1508 + OR = 0x1507 + OR_INVERTED = 0x150D + OR_REVERSE = 0x150B + SET = 0x150F + XOR = 0x1506 + + MAP_FLUSH_EXPLICIT_BIT = 0x0010 + MAP_INVALIDATE_BUFFER_BIT = 0x0008 + MAP_INVALIDATE_RANGE_BIT = 0x0004 + MAP_READ_BIT = 0x0001 + MAP_UNSYNCHRONIZED_BIT = 0x0020 + MAP_WRITE_BIT = 0x0002 + + COLOR_INDEXES = 0x1603 + SHININESS = 0x1601 + + MODELVIEW = 0x1700 + PROJECTION = 0x1701 + TEXTURE = 0x1702 + + LINE = 0x1B01 + POINT = 0x1B00 + + FILL = 0x1B02 + + COLOR = 0x1800 + DEPTH = 0x1801 + STENCIL = 0x1802 + + ALPHA = 0x1906 + BLUE = 0x1905 + COLOR_INDEX = 0x1900 + DEPTH_COMPONENT = 0x1902 + GREEN = 0x1904 + LUMINANCE = 0x1909 + LUMINANCE_ALPHA = 0x190A + RED = 0x1903 + RGB = 0x1907 + RGBA = 0x1908 + STENCIL_INDEX = 0x1901 + + ALPHA12 = 0x803D + ALPHA16 = 0x803E + ALPHA4 = 0x803B + ALPHA8 = 0x803C + INTENSITY = 0x8049 + INTENSITY12 = 0x804C + INTENSITY16 = 0x804D + INTENSITY4 = 0x804A + INTENSITY8 = 0x804B + LUMINANCE12 = 0x8041 + LUMINANCE12_ALPHA12 = 0x8047 + LUMINANCE12_ALPHA4 = 0x8046 + LUMINANCE16 = 0x8042 + LUMINANCE16_ALPHA16 = 0x8048 + LUMINANCE4 = 0x803F + LUMINANCE4_ALPHA4 = 0x8043 + LUMINANCE6_ALPHA2 = 0x8044 + LUMINANCE8 = 0x8040 + LUMINANCE8_ALPHA8 = 0x8045 + R3_G3_B2 = 0x2A10 + RGB10 = 0x8052 + RGB10_A2 = 0x8059 + RGB12 = 0x8053 + RGB16 = 0x8054 + RGB4 = 0x804F + RGB5 = 0x8050 + RGB5_A1 = 0x8057 + RGB8 = 0x8051 + RGBA12 = 0x805A + RGBA16 = 0x805B + RGBA2 = 0x8055 + RGBA4 = 0x8056 + RGBA8 = 0x8058 + + PACK_IMAGE_HEIGHT = 0x806C + PACK_SKIP_IMAGES = 0x806B + UNPACK_IMAGE_HEIGHT = 0x806E + UNPACK_SKIP_IMAGES = 0x806D + + BITMAP = 0x1A00 + UNSIGNED_BYTE_3_3_2 = 0x8032 + UNSIGNED_INT_10_10_10_2 = 0x8036 + UNSIGNED_INT_8_8_8_8 = 0x8035 + UNSIGNED_SHORT_4_4_4_4 = 0x8033 + UNSIGNED_SHORT_5_5_5_1 = 0x8034 + + POINT_DISTANCE_ATTENUATION = 0x8129 + POINT_FADE_THRESHOLD_SIZE = 0x8128 + POINT_SIZE_MAX = 0x8127 + POINT_SIZE_MIN = 0x8126 + + LINES = 0x0001 + LINES_ADJACENCY = 0x000A + LINE_LOOP = 0x0002 + LINE_STRIP = 0x0003 + LINE_STRIP_ADJACENCY = 0x000B + PATCHES = 0x000E + POINTS = 0x0000 + POLYGON = 0x0009 + QUADS = 0x0007 + QUAD_STRIP = 0x0008 + TRIANGLES = 0x0004 + TRIANGLES_ADJACENCY = 0x000C + TRIANGLE_FAN = 0x0006 + TRIANGLE_STRIP = 0x0005 + TRIANGLE_STRIP_ADJACENCY = 0x000D + + FEEDBACK = 0x1C01 + RENDER = 0x1C00 + SELECT = 0x1C02 + + FLAT = 0x1D00 + SMOOTH = 0x1D01 + + DECR = 0x1E03 + INCR = 0x1E02 + KEEP = 0x1E00 + + EXTENSIONS = 0x1F03 + RENDERER = 0x1F01 + VENDOR = 0x1F00 + VERSION = 0x1F02 + + S = 0x2000 + T = 0x2001 + R = 0x2002 + Q = 0x2003 + + DECAL = 0x2101 + + TEXTURE_ENV_COLOR = 0x2201 + TEXTURE_ENV_MODE = 0x2200 + + TEXTURE_ENV = 0x2300 + + EYE_LINEAR = 0x2400 + OBJECT_LINEAR = 0x2401 + SPHERE_MAP = 0x2402 + + EYE_PLANE = 0x2502 + OBJECT_PLANE = 0x2501 + TEXTURE_GEN_MODE = 0x2500 + + NEAREST = 0x2600 + + LINEAR_MIPMAP_LINEAR = 0x2703 + LINEAR_MIPMAP_NEAREST = 0x2701 + NEAREST_MIPMAP_LINEAR = 0x2702 + NEAREST_MIPMAP_NEAREST = 0x2700 + + GENERATE_MIPMAP = 0x8191 + TEXTURE_WRAP_R = 0x8072 + + PROXY_TEXTURE_1D = 0x8063 + PROXY_TEXTURE_2D = 0x8064 + PROXY_TEXTURE_3D = 0x8070 + TEXTURE_3D = 0x806F + TEXTURE_BASE_LEVEL = 0x813C + TEXTURE_MAX_LEVEL = 0x813D + TEXTURE_MAX_LOD = 0x813B + TEXTURE_MIN_LOD = 0x813A + + CLAMP = 0x2900 + CLAMP_TO_BORDER = 0x812D + CLAMP_TO_EDGE = 0x812F + REPEAT = 0x2901 + + VERTEX_SHADER_BIT = 0x00000001 + FRAGMENT_SHADER_BIT = 0x00000002 + GEOMETRY_SHADER_BIT = 0x00000004 + TESS_CONTROL_SHADER_BIT = 0x00000008 + TESS_EVALUATION_SHADER_BIT = 0x00000010 + ALL_SHADER_BITS = 0xFFFFFFFF + + SYNC_FLUSH_COMMANDS_BIT = 0x00000001 + INVALID_INDEX = 0xFFFFFFFF + TIMEOUT_IGNORED = 0xFFFFFFFFFFFFFFFF + CONSTANT_COLOR = 0x8001 + ONE_MINUS_CONSTANT_COLOR = 0x8002 + CONSTANT_ALPHA = 0x8003 + ONE_MINUS_CONSTANT_ALPHA = 0x8004 + FUNC_ADD = 0x8006 + MIN = 0x8007 + MAX = 0x8008 + BLEND_EQUATION_RGB = 0x8009 + FUNC_SUBTRACT = 0x800A + FUNC_REVERSE_SUBTRACT = 0x800B + RESCALE_NORMAL = 0x803A + TEXTURE_DEPTH = 0x8071 + MAX_3D_TEXTURE_SIZE = 0x8073 + MULTISAMPLE = 0x809D + SAMPLE_ALPHA_TO_COVERAGE = 0x809E + SAMPLE_ALPHA_TO_ONE = 0x809F + SAMPLE_COVERAGE = 0x80A0 + SAMPLE_BUFFERS = 0x80A8 + SAMPLES = 0x80A9 + SAMPLE_COVERAGE_VALUE = 0x80AA + SAMPLE_COVERAGE_INVERT = 0x80AB + BLEND_DST_RGB = 0x80C8 + BLEND_SRC_RGB = 0x80C9 + BLEND_DST_ALPHA = 0x80CA + BLEND_SRC_ALPHA = 0x80CB + BGR = 0x80E0 + BGRA = 0x80E1 + MAX_ELEMENTS_VERTICES = 0x80E8 + MAX_ELEMENTS_INDICES = 0x80E9 + DEPTH_COMPONENT16 = 0x81A5 + DEPTH_COMPONENT24 = 0x81A6 + DEPTH_COMPONENT32 = 0x81A7 + FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210 + FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211 + FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212 + FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213 + FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214 + FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215 + FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216 + FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217 + FRAMEBUFFER_DEFAULT = 0x8218 + FRAMEBUFFER_UNDEFINED = 0x8219 + DEPTH_STENCIL_ATTACHMENT = 0x821A + MAJOR_VERSION = 0x821B + MINOR_VERSION = 0x821C + NUM_EXTENSIONS = 0x821D + CONTEXT_FLAGS = 0x821E + COMPRESSED_RED = 0x8225 + COMPRESSED_RG = 0x8226 + RG = 0x8227 + RG_INTEGER = 0x8228 + R8 = 0x8229 + R16 = 0x822A + RG8 = 0x822B + RG16 = 0x822C + R16F = 0x822D + R32F = 0x822E + RG16F = 0x822F + RG32F = 0x8230 + R8I = 0x8231 + R8UI = 0x8232 + R16I = 0x8233 + R16UI = 0x8234 + R32I = 0x8235 + R32UI = 0x8236 + RG8I = 0x8237 + RG8UI = 0x8238 + RG16I = 0x8239 + RG16UI = 0x823A + RG32I = 0x823B + RG32UI = 0x823C + PROGRAM_SEPARABLE = 0x8258 + ACTIVE_PROGRAM = 0x8259 + PROGRAM_PIPELINE_BINDING = 0x825A + MAX_VIEWPORTS = 0x825B + VIEWPORT_SUBPIXEL_BITS = 0x825C + VIEWPORT_BOUNDS_RANGE = 0x825D + LAYER_PROVOKING_VERTEX = 0x825E + VIEWPORT_INDEX_PROVOKING_VERTEX = 0x825F + UNDEFINED_VERTEX = 0x8260 + UNSIGNED_BYTE_2_3_3_REV = 0x8362 + UNSIGNED_SHORT_5_6_5 = 0x8363 + UNSIGNED_SHORT_5_6_5_REV = 0x8364 + UNSIGNED_SHORT_4_4_4_4_REV = 0x8365 + UNSIGNED_SHORT_1_5_5_5_REV = 0x8366 + UNSIGNED_INT_8_8_8_8_REV = 0x8367 + UNSIGNED_INT_2_10_10_10_REV = 0x8368 + MIRRORED_REPEAT = 0x8370 + FOG_COORDINATE_SOURCE = 0x8450 + FOG_COORD_SRC = 0x8450 + FOG_COORDINATE = 0x8451 + FOG_COORD = 0x8451 + FRAGMENT_DEPTH = 0x8452 + CURRENT_FOG_COORDINATE = 0x8453 + CURRENT_FOG_COORD = 0x8453 + FOG_COORDINATE_ARRAY_TYPE = 0x8454 + FOG_COORD_ARRAY_TYPE = 0x8454 + FOG_COORDINATE_ARRAY_STRIDE = 0x8455 + FOG_COORD_ARRAY_STRIDE = 0x8455 + FOG_COORDINATE_ARRAY_POINTER = 0x8456 + FOG_COORD_ARRAY_POINTER = 0x8456 + FOG_COORDINATE_ARRAY = 0x8457 + FOG_COORD_ARRAY = 0x8457 + COLOR_SUM = 0x8458 + CURRENT_SECONDARY_COLOR = 0x8459 + SECONDARY_COLOR_ARRAY_SIZE = 0x845A + SECONDARY_COLOR_ARRAY_TYPE = 0x845B + SECONDARY_COLOR_ARRAY_STRIDE = 0x845C + SECONDARY_COLOR_ARRAY_POINTER = 0x845D + SECONDARY_COLOR_ARRAY = 0x845E + CURRENT_RASTER_SECONDARY_COLOR = 0x845F + TEXTURE0 = 0x84C0 + TEXTURE1 = 0x84C1 + TEXTURE2 = 0x84C2 + TEXTURE3 = 0x84C3 + TEXTURE4 = 0x84C4 + TEXTURE5 = 0x84C5 + TEXTURE6 = 0x84C6 + TEXTURE7 = 0x84C7 + TEXTURE8 = 0x84C8 + TEXTURE9 = 0x84C9 + TEXTURE10 = 0x84CA + TEXTURE11 = 0x84CB + TEXTURE12 = 0x84CC + TEXTURE13 = 0x84CD + TEXTURE14 = 0x84CE + TEXTURE15 = 0x84CF + TEXTURE16 = 0x84D0 + TEXTURE17 = 0x84D1 + TEXTURE18 = 0x84D2 + TEXTURE19 = 0x84D3 + TEXTURE20 = 0x84D4 + TEXTURE21 = 0x84D5 + TEXTURE22 = 0x84D6 + TEXTURE23 = 0x84D7 + TEXTURE24 = 0x84D8 + TEXTURE25 = 0x84D9 + TEXTURE26 = 0x84DA + TEXTURE27 = 0x84DB + TEXTURE28 = 0x84DC + TEXTURE29 = 0x84DD + TEXTURE30 = 0x84DE + TEXTURE31 = 0x84DF + ACTIVE_TEXTURE = 0x84E0 + CLIENT_ACTIVE_TEXTURE = 0x84E1 + MAX_TEXTURE_UNITS = 0x84E2 + TRANSPOSE_MODELVIEW_MATRIX = 0x84E3 + TRANSPOSE_PROJECTION_MATRIX = 0x84E4 + TRANSPOSE_TEXTURE_MATRIX = 0x84E5 + TRANSPOSE_COLOR_MATRIX = 0x84E6 + SUBTRACT = 0x84E7 + MAX_RENDERBUFFER_SIZE = 0x84E8 + COMPRESSED_ALPHA = 0x84E9 + COMPRESSED_LUMINANCE = 0x84EA + COMPRESSED_LUMINANCE_ALPHA = 0x84EB + COMPRESSED_INTENSITY = 0x84EC + COMPRESSED_RGB = 0x84ED + COMPRESSED_RGBA = 0x84EE + UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER = 0x84F0 + UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x84F1 + TEXTURE_RECTANGLE = 0x84F5 + TEXTURE_BINDING_RECTANGLE = 0x84F6 + PROXY_TEXTURE_RECTANGLE = 0x84F7 + MAX_RECTANGLE_TEXTURE_SIZE = 0x84F8 + DEPTH_STENCIL = 0x84F9 + UNSIGNED_INT_24_8 = 0x84FA + MAX_TEXTURE_LOD_BIAS = 0x84FD + TEXTURE_FILTER_CONTROL = 0x8500 + TEXTURE_LOD_BIAS = 0x8501 + INCR_WRAP = 0x8507 + DECR_WRAP = 0x8508 + NORMAL_MAP = 0x8511 + REFLECTION_MAP = 0x8512 + TEXTURE_CUBE_MAP = 0x8513 + TEXTURE_BINDING_CUBE_MAP = 0x8514 + TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515 + TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516 + TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517 + TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518 + TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519 + TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A + PROXY_TEXTURE_CUBE_MAP = 0x851B + MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C + COMBINE = 0x8570 + COMBINE_RGB = 0x8571 + COMBINE_ALPHA = 0x8572 + RGB_SCALE = 0x8573 + ADD_SIGNED = 0x8574 + INTERPOLATE = 0x8575 + CONSTANT = 0x8576 + PRIMARY_COLOR = 0x8577 + PREVIOUS = 0x8578 + SOURCE0_RGB = 0x8580 + SRC0_RGB = 0x8580 + SOURCE1_RGB = 0x8581 + SRC1_RGB = 0x8581 + SOURCE2_RGB = 0x8582 + SRC2_RGB = 0x8582 + SOURCE0_ALPHA = 0x8588 + SRC0_ALPHA = 0x8588 + SOURCE1_ALPHA = 0x8589 + SRC1_ALPHA = 0x8589 + SOURCE2_ALPHA = 0x858A + SRC2_ALPHA = 0x858A + OPERAND0_RGB = 0x8590 + OPERAND1_RGB = 0x8591 + OPERAND2_RGB = 0x8592 + OPERAND0_ALPHA = 0x8598 + OPERAND1_ALPHA = 0x8599 + OPERAND2_ALPHA = 0x859A + VERTEX_ARRAY_BINDING = 0x85B5 + VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622 + VERTEX_ATTRIB_ARRAY_SIZE = 0x8623 + VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624 + VERTEX_ATTRIB_ARRAY_TYPE = 0x8625 + CURRENT_VERTEX_ATTRIB = 0x8626 + VERTEX_PROGRAM_POINT_SIZE = 0x8642 + PROGRAM_POINT_SIZE = 0x8642 + VERTEX_PROGRAM_TWO_SIDE = 0x8643 + VERTEX_ATTRIB_ARRAY_POINTER = 0x8645 + DEPTH_CLAMP = 0x864F + TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0 + TEXTURE_COMPRESSED = 0x86A1 + NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2 + COMPRESSED_TEXTURE_FORMATS = 0x86A3 + DOT3_RGB = 0x86AE + DOT3_RGBA = 0x86AF + PROGRAM_BINARY_LENGTH = 0x8741 + BUFFER_SIZE = 0x8764 + BUFFER_USAGE = 0x8765 + NUM_PROGRAM_BINARY_FORMATS = 0x87FE + PROGRAM_BINARY_FORMATS = 0x87FF + STENCIL_BACK_FUNC = 0x8800 + STENCIL_BACK_FAIL = 0x8801 + STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802 + STENCIL_BACK_PASS_DEPTH_PASS = 0x8803 + RGBA32F = 0x8814 + RGB32F = 0x8815 + RGBA16F = 0x881A + RGB16F = 0x881B + MAX_DRAW_BUFFERS = 0x8824 + DRAW_BUFFER0 = 0x8825 + DRAW_BUFFER1 = 0x8826 + DRAW_BUFFER2 = 0x8827 + DRAW_BUFFER3 = 0x8828 + DRAW_BUFFER4 = 0x8829 + DRAW_BUFFER5 = 0x882A + DRAW_BUFFER6 = 0x882B + DRAW_BUFFER7 = 0x882C + DRAW_BUFFER8 = 0x882D + DRAW_BUFFER9 = 0x882E + DRAW_BUFFER10 = 0x882F + DRAW_BUFFER11 = 0x8830 + DRAW_BUFFER12 = 0x8831 + DRAW_BUFFER13 = 0x8832 + DRAW_BUFFER14 = 0x8833 + DRAW_BUFFER15 = 0x8834 + BLEND_EQUATION_ALPHA = 0x883D + TEXTURE_DEPTH_SIZE = 0x884A + DEPTH_TEXTURE_MODE = 0x884B + TEXTURE_COMPARE_MODE = 0x884C + TEXTURE_COMPARE_FUNC = 0x884D + COMPARE_R_TO_TEXTURE = 0x884E + COMPARE_REF_TO_TEXTURE = 0x884E + TEXTURE_CUBE_MAP_SEAMLESS = 0x884F + POINT_SPRITE = 0x8861 + COORD_REPLACE = 0x8862 + QUERY_COUNTER_BITS = 0x8864 + CURRENT_QUERY = 0x8865 + QUERY_RESULT = 0x8866 + QUERY_RESULT_AVAILABLE = 0x8867 + MAX_VERTEX_ATTRIBS = 0x8869 + VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A + MAX_TESS_CONTROL_INPUT_COMPONENTS = 0x886C + MAX_TESS_EVALUATION_INPUT_COMPONENTS = 0x886D + MAX_TEXTURE_COORDS = 0x8871 + MAX_TEXTURE_IMAGE_UNITS = 0x8872 + GEOMETRY_SHADER_INVOCATIONS = 0x887F + ARRAY_BUFFER = 0x8892 + ELEMENT_ARRAY_BUFFER = 0x8893 + ARRAY_BUFFER_BINDING = 0x8894 + ELEMENT_ARRAY_BUFFER_BINDING = 0x8895 + VERTEX_ARRAY_BUFFER_BINDING = 0x8896 + NORMAL_ARRAY_BUFFER_BINDING = 0x8897 + COLOR_ARRAY_BUFFER_BINDING = 0x8898 + INDEX_ARRAY_BUFFER_BINDING = 0x8899 + TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A + EDGE_FLAG_ARRAY_BUFFER_BINDING = 0x889B + SECONDARY_COLOR_ARRAY_BUFFER_BINDING = 0x889C + FOG_COORDINATE_ARRAY_BUFFER_BINDING = 0x889D + FOG_COORD_ARRAY_BUFFER_BINDING = 0x889D + WEIGHT_ARRAY_BUFFER_BINDING = 0x889E + VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F + READ_ONLY = 0x88B8 + WRITE_ONLY = 0x88B9 + READ_WRITE = 0x88BA + BUFFER_ACCESS = 0x88BB + BUFFER_MAPPED = 0x88BC + BUFFER_MAP_POINTER = 0x88BD + TIME_ELAPSED = 0x88BF + STREAM_DRAW = 0x88E0 + STREAM_READ = 0x88E1 + STREAM_COPY = 0x88E2 + STATIC_DRAW = 0x88E4 + STATIC_READ = 0x88E5 + STATIC_COPY = 0x88E6 + DYNAMIC_DRAW = 0x88E8 + DYNAMIC_READ = 0x88E9 + DYNAMIC_COPY = 0x88EA + PIXEL_PACK_BUFFER = 0x88EB + PIXEL_UNPACK_BUFFER = 0x88EC + PIXEL_PACK_BUFFER_BINDING = 0x88ED + PIXEL_UNPACK_BUFFER_BINDING = 0x88EF + DEPTH24_STENCIL8 = 0x88F0 + TEXTURE_STENCIL_SIZE = 0x88F1 + SRC1_COLOR = 0x88F9 + ONE_MINUS_SRC1_COLOR = 0x88FA + ONE_MINUS_SRC1_ALPHA = 0x88FB + MAX_DUAL_SOURCE_DRAW_BUFFERS = 0x88FC + VERTEX_ATTRIB_ARRAY_INTEGER = 0x88FD + VERTEX_ATTRIB_ARRAY_DIVISOR = 0x88FE + MAX_ARRAY_TEXTURE_LAYERS = 0x88FF + MIN_PROGRAM_TEXEL_OFFSET = 0x8904 + MAX_PROGRAM_TEXEL_OFFSET = 0x8905 + SAMPLES_PASSED = 0x8914 + GEOMETRY_VERTICES_OUT = 0x8916 + GEOMETRY_INPUT_TYPE = 0x8917 + GEOMETRY_OUTPUT_TYPE = 0x8918 + SAMPLER_BINDING = 0x8919 + CLAMP_VERTEX_COLOR = 0x891A + CLAMP_FRAGMENT_COLOR = 0x891B + CLAMP_READ_COLOR = 0x891C + FIXED_ONLY = 0x891D + UNIFORM_BUFFER = 0x8A11 + UNIFORM_BUFFER_BINDING = 0x8A28 + UNIFORM_BUFFER_START = 0x8A29 + UNIFORM_BUFFER_SIZE = 0x8A2A + MAX_VERTEX_UNIFORM_BLOCKS = 0x8A2B + MAX_GEOMETRY_UNIFORM_BLOCKS = 0x8A2C + MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8A2D + MAX_COMBINED_UNIFORM_BLOCKS = 0x8A2E + MAX_UNIFORM_BUFFER_BINDINGS = 0x8A2F + MAX_UNIFORM_BLOCK_SIZE = 0x8A30 + MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31 + MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 0x8A32 + MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33 + UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8A34 + ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35 + ACTIVE_UNIFORM_BLOCKS = 0x8A36 + UNIFORM_TYPE = 0x8A37 + UNIFORM_SIZE = 0x8A38 + UNIFORM_NAME_LENGTH = 0x8A39 + UNIFORM_BLOCK_INDEX = 0x8A3A + UNIFORM_OFFSET = 0x8A3B + UNIFORM_ARRAY_STRIDE = 0x8A3C + UNIFORM_MATRIX_STRIDE = 0x8A3D + UNIFORM_IS_ROW_MAJOR = 0x8A3E + UNIFORM_BLOCK_BINDING = 0x8A3F + UNIFORM_BLOCK_DATA_SIZE = 0x8A40 + UNIFORM_BLOCK_NAME_LENGTH = 0x8A41 + UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8A42 + UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43 + UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44 + UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 0x8A45 + UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46 + FRAGMENT_SHADER = 0x8B30 + VERTEX_SHADER = 0x8B31 + MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49 + MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A + MAX_VARYING_FLOATS = 0x8B4B + MAX_VARYING_COMPONENTS = 0x8B4B + MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C + MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D + SHADER_TYPE = 0x8B4F + FLOAT_VEC2 = 0x8B50 + FLOAT_VEC3 = 0x8B51 + FLOAT_VEC4 = 0x8B52 + INT_VEC2 = 0x8B53 + INT_VEC3 = 0x8B54 + INT_VEC4 = 0x8B55 + BOOL = 0x8B56 + BOOL_VEC2 = 0x8B57 + BOOL_VEC3 = 0x8B58 + BOOL_VEC4 = 0x8B59 + FLOAT_MAT2 = 0x8B5A + FLOAT_MAT3 = 0x8B5B + FLOAT_MAT4 = 0x8B5C + SAMPLER_1D = 0x8B5D + SAMPLER_2D = 0x8B5E + SAMPLER_3D = 0x8B5F + SAMPLER_CUBE = 0x8B60 + SAMPLER_1D_SHADOW = 0x8B61 + SAMPLER_2D_SHADOW = 0x8B62 + SAMPLER_2D_RECT = 0x8B63 + SAMPLER_2D_RECT_SHADOW = 0x8B64 + FLOAT_MAT2x3 = 0x8B65 + FLOAT_MAT2x4 = 0x8B66 + FLOAT_MAT3x2 = 0x8B67 + FLOAT_MAT3x4 = 0x8B68 + FLOAT_MAT4x2 = 0x8B69 + FLOAT_MAT4x3 = 0x8B6A + DELETE_STATUS = 0x8B80 + COMPILE_STATUS = 0x8B81 + LINK_STATUS = 0x8B82 + VALIDATE_STATUS = 0x8B83 + INFO_LOG_LENGTH = 0x8B84 + ATTACHED_SHADERS = 0x8B85 + ACTIVE_UNIFORMS = 0x8B86 + ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87 + SHADER_SOURCE_LENGTH = 0x8B88 + ACTIVE_ATTRIBUTES = 0x8B89 + ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A + SHADING_LANGUAGE_VERSION = 0x8B8C + CURRENT_PROGRAM = 0x8B8D + IMPLEMENTATION_COLOR_READ_TYPE = 0x8B9A + IMPLEMENTATION_COLOR_READ_FORMAT = 0x8B9B + TEXTURE_RED_TYPE = 0x8C10 + TEXTURE_GREEN_TYPE = 0x8C11 + TEXTURE_BLUE_TYPE = 0x8C12 + TEXTURE_ALPHA_TYPE = 0x8C13 + TEXTURE_DEPTH_TYPE = 0x8C16 + UNSIGNED_NORMALIZED = 0x8C17 + TEXTURE_1D_ARRAY = 0x8C18 + PROXY_TEXTURE_1D_ARRAY = 0x8C19 + TEXTURE_2D_ARRAY = 0x8C1A + PROXY_TEXTURE_2D_ARRAY = 0x8C1B + TEXTURE_BINDING_1D_ARRAY = 0x8C1C + TEXTURE_BINDING_2D_ARRAY = 0x8C1D + MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = 0x8C29 + TEXTURE_BUFFER = 0x8C2A + MAX_TEXTURE_BUFFER_SIZE = 0x8C2B + TEXTURE_BINDING_BUFFER = 0x8C2C + TEXTURE_BUFFER_DATA_STORE_BINDING = 0x8C2D + ANY_SAMPLES_PASSED = 0x8C2F + SAMPLE_SHADING = 0x8C36 + MIN_SAMPLE_SHADING_VALUE = 0x8C37 + R11F_G11F_B10F = 0x8C3A + UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B + RGB9_E5 = 0x8C3D + UNSIGNED_INT_5_9_9_9_REV = 0x8C3E + TEXTURE_SHARED_SIZE = 0x8C3F + SRGB = 0x8C40 + SRGB8 = 0x8C41 + SRGB_ALPHA = 0x8C42 + SRGB8_ALPHA8 = 0x8C43 + SLUMINANCE_ALPHA = 0x8C44 + SLUMINANCE8_ALPHA8 = 0x8C45 + SLUMINANCE = 0x8C46 + SLUMINANCE8 = 0x8C47 + COMPRESSED_SRGB = 0x8C48 + COMPRESSED_SRGB_ALPHA = 0x8C49 + COMPRESSED_SLUMINANCE = 0x8C4A + COMPRESSED_SLUMINANCE_ALPHA = 0x8C4B + TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76 + TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F + MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80 + TRANSFORM_FEEDBACK_VARYINGS = 0x8C83 + TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84 + TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85 + PRIMITIVES_GENERATED = 0x8C87 + TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88 + RASTERIZER_DISCARD = 0x8C89 + MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A + MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B + INTERLEAVED_ATTRIBS = 0x8C8C + SEPARATE_ATTRIBS = 0x8C8D + TRANSFORM_FEEDBACK_BUFFER = 0x8C8E + TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F + POINT_SPRITE_COORD_ORIGIN = 0x8CA0 + LOWER_LEFT = 0x8CA1 + UPPER_LEFT = 0x8CA2 + STENCIL_BACK_REF = 0x8CA3 + STENCIL_BACK_VALUE_MASK = 0x8CA4 + STENCIL_BACK_WRITEMASK = 0x8CA5 + DRAW_FRAMEBUFFER_BINDING = 0x8CA6 + FRAMEBUFFER_BINDING = 0x8CA6 + RENDERBUFFER_BINDING = 0x8CA7 + READ_FRAMEBUFFER = 0x8CA8 + DRAW_FRAMEBUFFER = 0x8CA9 + READ_FRAMEBUFFER_BINDING = 0x8CAA + RENDERBUFFER_SAMPLES = 0x8CAB + DEPTH_COMPONENT32F = 0x8CAC + DEPTH32F_STENCIL8 = 0x8CAD + FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0 + FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1 + FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2 + FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3 + FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4 + FRAMEBUFFER_COMPLETE = 0x8CD5 + FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6 + FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7 + FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB + FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC + FRAMEBUFFER_UNSUPPORTED = 0x8CDD + MAX_COLOR_ATTACHMENTS = 0x8CDF + COLOR_ATTACHMENT0 = 0x8CE0 + COLOR_ATTACHMENT1 = 0x8CE1 + COLOR_ATTACHMENT2 = 0x8CE2 + COLOR_ATTACHMENT3 = 0x8CE3 + COLOR_ATTACHMENT4 = 0x8CE4 + COLOR_ATTACHMENT5 = 0x8CE5 + COLOR_ATTACHMENT6 = 0x8CE6 + COLOR_ATTACHMENT7 = 0x8CE7 + COLOR_ATTACHMENT8 = 0x8CE8 + COLOR_ATTACHMENT9 = 0x8CE9 + COLOR_ATTACHMENT10 = 0x8CEA + COLOR_ATTACHMENT11 = 0x8CEB + COLOR_ATTACHMENT12 = 0x8CEC + COLOR_ATTACHMENT13 = 0x8CED + COLOR_ATTACHMENT14 = 0x8CEE + COLOR_ATTACHMENT15 = 0x8CEF + DEPTH_ATTACHMENT = 0x8D00 + STENCIL_ATTACHMENT = 0x8D20 + FRAMEBUFFER = 0x8D40 + RENDERBUFFER = 0x8D41 + RENDERBUFFER_WIDTH = 0x8D42 + RENDERBUFFER_HEIGHT = 0x8D43 + RENDERBUFFER_INTERNAL_FORMAT = 0x8D44 + STENCIL_INDEX1 = 0x8D46 + STENCIL_INDEX4 = 0x8D47 + STENCIL_INDEX8 = 0x8D48 + STENCIL_INDEX16 = 0x8D49 + RENDERBUFFER_RED_SIZE = 0x8D50 + RENDERBUFFER_GREEN_SIZE = 0x8D51 + RENDERBUFFER_BLUE_SIZE = 0x8D52 + RENDERBUFFER_ALPHA_SIZE = 0x8D53 + RENDERBUFFER_DEPTH_SIZE = 0x8D54 + RENDERBUFFER_STENCIL_SIZE = 0x8D55 + FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56 + MAX_SAMPLES = 0x8D57 + RGB565 = 0x8D62 + RGBA32UI = 0x8D70 + RGB32UI = 0x8D71 + RGBA16UI = 0x8D76 + RGB16UI = 0x8D77 + RGBA8UI = 0x8D7C + RGB8UI = 0x8D7D + RGBA32I = 0x8D82 + RGB32I = 0x8D83 + RGBA16I = 0x8D88 + RGB16I = 0x8D89 + RGBA8I = 0x8D8E + RGB8I = 0x8D8F + RED_INTEGER = 0x8D94 + GREEN_INTEGER = 0x8D95 + BLUE_INTEGER = 0x8D96 + ALPHA_INTEGER = 0x8D97 + RGB_INTEGER = 0x8D98 + RGBA_INTEGER = 0x8D99 + BGR_INTEGER = 0x8D9A + BGRA_INTEGER = 0x8D9B + INT_2_10_10_10_REV = 0x8D9F + FRAMEBUFFER_ATTACHMENT_LAYERED = 0x8DA7 + FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = 0x8DA8 + FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD + FRAMEBUFFER_SRGB = 0x8DB9 + COMPRESSED_RED_RGTC1 = 0x8DBB + COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC + COMPRESSED_RG_RGTC2 = 0x8DBD + COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE + SAMPLER_1D_ARRAY = 0x8DC0 + SAMPLER_2D_ARRAY = 0x8DC1 + SAMPLER_BUFFER = 0x8DC2 + SAMPLER_1D_ARRAY_SHADOW = 0x8DC3 + SAMPLER_2D_ARRAY_SHADOW = 0x8DC4 + SAMPLER_CUBE_SHADOW = 0x8DC5 + UNSIGNED_INT_VEC2 = 0x8DC6 + UNSIGNED_INT_VEC3 = 0x8DC7 + UNSIGNED_INT_VEC4 = 0x8DC8 + INT_SAMPLER_1D = 0x8DC9 + INT_SAMPLER_2D = 0x8DCA + INT_SAMPLER_3D = 0x8DCB + INT_SAMPLER_CUBE = 0x8DCC + INT_SAMPLER_2D_RECT = 0x8DCD + INT_SAMPLER_1D_ARRAY = 0x8DCE + INT_SAMPLER_2D_ARRAY = 0x8DCF + INT_SAMPLER_BUFFER = 0x8DD0 + UNSIGNED_INT_SAMPLER_1D = 0x8DD1 + UNSIGNED_INT_SAMPLER_2D = 0x8DD2 + UNSIGNED_INT_SAMPLER_3D = 0x8DD3 + UNSIGNED_INT_SAMPLER_CUBE = 0x8DD4 + UNSIGNED_INT_SAMPLER_2D_RECT = 0x8DD5 + UNSIGNED_INT_SAMPLER_1D_ARRAY = 0x8DD6 + UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8DD7 + UNSIGNED_INT_SAMPLER_BUFFER = 0x8DD8 + GEOMETRY_SHADER = 0x8DD9 + MAX_GEOMETRY_UNIFORM_COMPONENTS = 0x8DDF + MAX_GEOMETRY_OUTPUT_VERTICES = 0x8DE0 + MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = 0x8DE1 + ACTIVE_SUBROUTINES = 0x8DE5 + ACTIVE_SUBROUTINE_UNIFORMS = 0x8DE6 + MAX_SUBROUTINES = 0x8DE7 + MAX_SUBROUTINE_UNIFORM_LOCATIONS = 0x8DE8 + LOW_FLOAT = 0x8DF0 + MEDIUM_FLOAT = 0x8DF1 + HIGH_FLOAT = 0x8DF2 + LOW_INT = 0x8DF3 + MEDIUM_INT = 0x8DF4 + HIGH_INT = 0x8DF5 + SHADER_BINARY_FORMATS = 0x8DF8 + NUM_SHADER_BINARY_FORMATS = 0x8DF9 + SHADER_COMPILER = 0x8DFA + MAX_VERTEX_UNIFORM_VECTORS = 0x8DFB + MAX_VARYING_VECTORS = 0x8DFC + MAX_FRAGMENT_UNIFORM_VECTORS = 0x8DFD + QUERY_WAIT = 0x8E13 + QUERY_NO_WAIT = 0x8E14 + QUERY_BY_REGION_WAIT = 0x8E15 + QUERY_BY_REGION_NO_WAIT = 0x8E16 + MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E1E + MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E1F + TRANSFORM_FEEDBACK = 0x8E22 + TRANSFORM_FEEDBACK_BUFFER_PAUSED = 0x8E23 + TRANSFORM_FEEDBACK_BUFFER_ACTIVE = 0x8E24 + TRANSFORM_FEEDBACK_BINDING = 0x8E25 + TIMESTAMP = 0x8E28 + TEXTURE_SWIZZLE_R = 0x8E42 + TEXTURE_SWIZZLE_G = 0x8E43 + TEXTURE_SWIZZLE_B = 0x8E44 + TEXTURE_SWIZZLE_A = 0x8E45 + TEXTURE_SWIZZLE_RGBA = 0x8E46 + ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS = 0x8E47 + ACTIVE_SUBROUTINE_MAX_LENGTH = 0x8E48 + ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH = 0x8E49 + NUM_COMPATIBLE_SUBROUTINES = 0x8E4A + COMPATIBLE_SUBROUTINES = 0x8E4B + QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = 0x8E4C + FIRST_VERTEX_CONVENTION = 0x8E4D + LAST_VERTEX_CONVENTION = 0x8E4E + PROVOKING_VERTEX = 0x8E4F + SAMPLE_POSITION = 0x8E50 + SAMPLE_MASK = 0x8E51 + SAMPLE_MASK_VALUE = 0x8E52 + MAX_SAMPLE_MASK_WORDS = 0x8E59 + MAX_GEOMETRY_SHADER_INVOCATIONS = 0x8E5A + MIN_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5B + MAX_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5C + FRAGMENT_INTERPOLATION_OFFSET_BITS = 0x8E5D + MIN_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5E + MAX_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5F + MAX_TRANSFORM_FEEDBACK_BUFFERS = 0x8E70 + MAX_VERTEX_STREAMS = 0x8E71 + PATCH_VERTICES = 0x8E72 + PATCH_DEFAULT_INNER_LEVEL = 0x8E73 + PATCH_DEFAULT_OUTER_LEVEL = 0x8E74 + TESS_CONTROL_OUTPUT_VERTICES = 0x8E75 + TESS_GEN_MODE = 0x8E76 + TESS_GEN_SPACING = 0x8E77 + TESS_GEN_VERTEX_ORDER = 0x8E78 + TESS_GEN_POINT_MODE = 0x8E79 + ISOLINES = 0x8E7A + FRACTIONAL_ODD = 0x8E7B + FRACTIONAL_EVEN = 0x8E7C + MAX_PATCH_VERTICES = 0x8E7D + MAX_TESS_GEN_LEVEL = 0x8E7E + MAX_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E7F + MAX_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E80 + MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS = 0x8E81 + MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS = 0x8E82 + MAX_TESS_CONTROL_OUTPUT_COMPONENTS = 0x8E83 + MAX_TESS_PATCH_COMPONENTS = 0x8E84 + MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS = 0x8E85 + MAX_TESS_EVALUATION_OUTPUT_COMPONENTS = 0x8E86 + TESS_EVALUATION_SHADER = 0x8E87 + TESS_CONTROL_SHADER = 0x8E88 + MAX_TESS_CONTROL_UNIFORM_BLOCKS = 0x8E89 + MAX_TESS_EVALUATION_UNIFORM_BLOCKS = 0x8E8A + COPY_READ_BUFFER = 0x8F36 + COPY_WRITE_BUFFER = 0x8F37 + DRAW_INDIRECT_BUFFER = 0x8F3F + DRAW_INDIRECT_BUFFER_BINDING = 0x8F43 + DOUBLE_MAT2 = 0x8F46 + DOUBLE_MAT3 = 0x8F47 + DOUBLE_MAT4 = 0x8F48 + DOUBLE_MAT2x3 = 0x8F49 + DOUBLE_MAT2x4 = 0x8F4A + DOUBLE_MAT3x2 = 0x8F4B + DOUBLE_MAT3x4 = 0x8F4C + DOUBLE_MAT4x2 = 0x8F4D + DOUBLE_MAT4x3 = 0x8F4E + R8_SNORM = 0x8F94 + RG8_SNORM = 0x8F95 + RGB8_SNORM = 0x8F96 + RGBA8_SNORM = 0x8F97 + R16_SNORM = 0x8F98 + RG16_SNORM = 0x8F99 + RGB16_SNORM = 0x8F9A + RGBA16_SNORM = 0x8F9B + SIGNED_NORMALIZED = 0x8F9C + PRIMITIVE_RESTART = 0x8F9D + PRIMITIVE_RESTART_INDEX = 0x8F9E + DOUBLE_VEC2 = 0x8FFC + DOUBLE_VEC3 = 0x8FFD + DOUBLE_VEC4 = 0x8FFE + TEXTURE_CUBE_MAP_ARRAY = 0x9009 + TEXTURE_BINDING_CUBE_MAP_ARRAY = 0x900A + PROXY_TEXTURE_CUBE_MAP_ARRAY = 0x900B + SAMPLER_CUBE_MAP_ARRAY = 0x900C + SAMPLER_CUBE_MAP_ARRAY_SHADOW = 0x900D + INT_SAMPLER_CUBE_MAP_ARRAY = 0x900E + UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY = 0x900F + RGB10_A2UI = 0x906F + TEXTURE_2D_MULTISAMPLE = 0x9100 + PROXY_TEXTURE_2D_MULTISAMPLE = 0x9101 + TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9102 + PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9103 + TEXTURE_BINDING_2D_MULTISAMPLE = 0x9104 + TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = 0x9105 + TEXTURE_SAMPLES = 0x9106 + TEXTURE_FIXED_SAMPLE_LOCATIONS = 0x9107 + SAMPLER_2D_MULTISAMPLE = 0x9108 + INT_SAMPLER_2D_MULTISAMPLE = 0x9109 + UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = 0x910A + SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910B + INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910C + UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910D + MAX_COLOR_TEXTURE_SAMPLES = 0x910E + MAX_DEPTH_TEXTURE_SAMPLES = 0x910F + MAX_INTEGER_SAMPLES = 0x9110 + MAX_SERVER_WAIT_TIMEOUT = 0x9111 + OBJECT_TYPE = 0x9112 + SYNC_CONDITION = 0x9113 + SYNC_STATUS = 0x9114 + SYNC_FLAGS = 0x9115 + SYNC_FENCE = 0x9116 + SYNC_GPU_COMMANDS_COMPLETE = 0x9117 + UNSIGNALED = 0x9118 + SIGNALED = 0x9119 + ALREADY_SIGNALED = 0x911A + TIMEOUT_EXPIRED = 0x911B + CONDITION_SATISFIED = 0x911C + WAIT_FAILED = 0x911D + BUFFER_ACCESS_FLAGS = 0x911F + BUFFER_MAP_LENGTH = 0x9120 + BUFFER_MAP_OFFSET = 0x9121 + MAX_VERTEX_OUTPUT_COMPONENTS = 0x9122 + MAX_GEOMETRY_INPUT_COMPONENTS = 0x9123 + MAX_GEOMETRY_OUTPUT_COMPONENTS = 0x9124 + MAX_FRAGMENT_INPUT_COMPONENTS = 0x9125 + CONTEXT_PROFILE_MASK = 0x9126 +) + +// https://www.opengl.org/sdk/docs/man4/xhtml/glViewport.xml +func (gl *GL) Viewport(x, y, width, height int) { + C.gl4_1core_glViewport(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// DepthRange specifies the mapping of depth values from normalized device +// coordinates to window coordinates. +// +// Parameter nearVal specifies the mapping of the near clipping plane to window +// coordinates (defaults to 0), while farVal specifies the mapping of the far +// clipping plane to window coordinates (defaults to 1). +// +// After clipping and division by w, depth coordinates range from -1 to 1, +// corresponding to the near and far clipping planes. DepthRange specifies a +// linear mapping of the normalized depth coordinates in this range to window +// depth coordinates. Regardless of the actual depth buffer implementation, +// window coordinate depth values are treated as though they range from 0 through 1 +// (like color components). Thus, the values accepted by DepthRange are both +// clamped to this range before they are accepted. +// +// The default setting of (0, 1) maps the near plane to 0 and the far plane to 1. +// With this mapping, the depth buffer range is fully utilized. +// +// It is not necessary that nearVal be less than farVal. Reverse mappings such as +// nearVal 1, and farVal 0 are acceptable. +// +// GL.INVALID_OPERATION is generated if DepthRange is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) DepthRange(nearVal, farVal float64) { + C.gl4_1core_glDepthRange(gl.funcs, C.GLdouble(nearVal), C.GLdouble(farVal)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsEnabled.xml +func (gl *GL) IsEnabled(cap glbase.Enum) bool { + glresult := C.gl4_1core_glIsEnabled(gl.funcs, C.GLenum(cap)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexLevelParameteriv.xml +func (gl *GL) GetTexLevelParameteriv(target glbase.Enum, level int, pname glbase.Enum, params []int32) { + C.gl4_1core_glGetTexLevelParameteriv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexLevelParameterfv.xml +func (gl *GL) GetTexLevelParameterfv(target glbase.Enum, level int, pname glbase.Enum, params []float32) { + C.gl4_1core_glGetTexLevelParameterfv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameteriv.xml +func (gl *GL) GetTexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_1core_glGetTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameterfv.xml +func (gl *GL) GetTexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_1core_glGetTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexImage.xml +func (gl *GL) GetTexImage(target glbase.Enum, level int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_1core_glGetTexImage(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetIntegerv.xml +func (gl *GL) GetIntegerv(pname glbase.Enum, params []int32) { + C.gl4_1core_glGetIntegerv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFloatv.xml +func (gl *GL) GetFloatv(pname glbase.Enum, params []float32) { + C.gl4_1core_glGetFloatv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetError.xml +func (gl *GL) GetError() glbase.Enum { + glresult := C.gl4_1core_glGetError(gl.funcs) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetDoublev.xml +func (gl *GL) GetDoublev(pname glbase.Enum, params []float64) { + C.gl4_1core_glGetDoublev(gl.funcs, C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBooleanv.xml +func (gl *GL) GetBooleanv(pname glbase.Enum, params []bool) { + C.gl4_1core_glGetBooleanv(gl.funcs, C.GLenum(pname), (*C.GLboolean)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glReadPixels.xml +func (gl *GL) ReadPixels(x, y, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_1core_glReadPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glReadBuffer.xml +func (gl *GL) ReadBuffer(mode glbase.Enum) { + C.gl4_1core_glReadBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelStorei.xml +func (gl *GL) PixelStorei(pname glbase.Enum, param int32) { + C.gl4_1core_glPixelStorei(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelStoref.xml +func (gl *GL) PixelStoref(pname glbase.Enum, param float32) { + C.gl4_1core_glPixelStoref(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDepthFunc.xml +func (gl *GL) DepthFunc(glfunc glbase.Enum) { + C.gl4_1core_glDepthFunc(gl.funcs, C.GLenum(glfunc)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilOp.xml +func (gl *GL) StencilOp(fail, zfail, zpass glbase.Enum) { + C.gl4_1core_glStencilOp(gl.funcs, C.GLenum(fail), C.GLenum(zfail), C.GLenum(zpass)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilFunc.xml +func (gl *GL) StencilFunc(glfunc glbase.Enum, ref int32, mask uint32) { + C.gl4_1core_glStencilFunc(gl.funcs, C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLogicOp.xml +func (gl *GL) LogicOp(opcode glbase.Enum) { + C.gl4_1core_glLogicOp(gl.funcs, C.GLenum(opcode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFunc.xml +func (gl *GL) BlendFunc(sfactor, dfactor glbase.Enum) { + C.gl4_1core_glBlendFunc(gl.funcs, C.GLenum(sfactor), C.GLenum(dfactor)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFlush.xml +func (gl *GL) Flush() { + C.gl4_1core_glFlush(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFinish.xml +func (gl *GL) Finish() { + C.gl4_1core_glFinish(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEnable.xml +func (gl *GL) Enable(cap glbase.Enum) { + C.gl4_1core_glEnable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDisable.xml +func (gl *GL) Disable(cap glbase.Enum) { + C.gl4_1core_glDisable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDepthMask.xml +func (gl *GL) DepthMask(flag bool) { + C.gl4_1core_glDepthMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorMask.xml +func (gl *GL) ColorMask(red, green, blue, alpha bool) { + C.gl4_1core_glColorMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&red)), *(*C.GLboolean)(unsafe.Pointer(&green)), *(*C.GLboolean)(unsafe.Pointer(&blue)), *(*C.GLboolean)(unsafe.Pointer(&alpha))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilMask.xml +func (gl *GL) StencilMask(mask uint32) { + C.gl4_1core_glStencilMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearDepth.xml +func (gl *GL) ClearDepth(depth float64) { + C.gl4_1core_glClearDepth(gl.funcs, C.GLdouble(depth)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearStencil.xml +func (gl *GL) ClearStencil(s int32) { + C.gl4_1core_glClearStencil(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearColor.xml +func (gl *GL) ClearColor(red, green, blue, alpha float32) { + C.gl4_1core_glClearColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClear.xml +func (gl *GL) Clear(mask glbase.Bitfield) { + C.gl4_1core_glClear(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawBuffer.xml +func (gl *GL) DrawBuffer(mode glbase.Enum) { + C.gl4_1core_glDrawBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage2D.xml +func (gl *GL) TexImage2D(target glbase.Enum, level int, internalFormat int32, width, height, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_1core_glTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage1D.xml +func (gl *GL) TexImage1D(target glbase.Enum, level int, internalFormat int32, width, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_1core_glTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameteriv.xml +func (gl *GL) TexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_1core_glTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameteri.xml +func (gl *GL) TexParameteri(target, pname glbase.Enum, param int32) { + C.gl4_1core_glTexParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterfv.xml +func (gl *GL) TexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_1core_glTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterf.xml +func (gl *GL) TexParameterf(target, pname glbase.Enum, param float32) { + C.gl4_1core_glTexParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glScissor.xml +func (gl *GL) Scissor(x, y, width, height int) { + C.gl4_1core_glScissor(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPolygonMode.xml +func (gl *GL) PolygonMode(face, mode glbase.Enum) { + C.gl4_1core_glPolygonMode(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointSize.xml +func (gl *GL) PointSize(size float32) { + C.gl4_1core_glPointSize(gl.funcs, C.GLfloat(size)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLineWidth.xml +func (gl *GL) LineWidth(width float32) { + C.gl4_1core_glLineWidth(gl.funcs, C.GLfloat(width)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glHint.xml +func (gl *GL) Hint(target, mode glbase.Enum) { + C.gl4_1core_glHint(gl.funcs, C.GLenum(target), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFrontFace.xml +func (gl *GL) FrontFace(mode glbase.Enum) { + C.gl4_1core_glFrontFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCullFace.xml +func (gl *GL) CullFace(mode glbase.Enum) { + C.gl4_1core_glCullFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexubv.xml +func (gl *GL) Indexubv(c []uint8) { + C.gl4_1core_glIndexubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexub.xml +func (gl *GL) Indexub(c uint8) { + C.gl4_1core_glIndexub(gl.funcs, C.GLubyte(c)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsTexture.xml +func (gl *GL) IsTexture(texture glbase.Texture) bool { + glresult := C.gl4_1core_glIsTexture(gl.funcs, C.GLuint(texture)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenTextures returns n texture names in textures. There is no guarantee +// that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenTextures. +// +// The generated textures have no dimensionality; they assume the +// dimensionality of the texture target to which they are first bound (see +// BindTexture). +// +// Texture names returned by a call to GenTextures are not returned by +// subsequent calls, unless they are first deleted with DeleteTextures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenTextures is available in GL version 2.0 or greater. +func (gl *GL) GenTextures(n int) []glbase.Texture { + if n == 0 { + return nil + } + textures := make([]glbase.Texture, n) + C.gl4_1core_glGenTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) + return textures +} + +// DeleteTextures deletes the textures objects whose names are stored +// in the textures slice. After a texture is deleted, it has no contents or +// dimensionality, and its name is free for reuse (for example by +// GenTextures). If a texture that is currently bound is deleted, the binding +// reverts to 0 (the default texture). +// +// DeleteTextures silently ignores 0's and names that do not correspond to +// existing textures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteTextures is available in GL version 2.0 or greater. +func (gl *GL) DeleteTextures(textures []glbase.Texture) { + n := len(textures) + if n == 0 { + return + } + C.gl4_1core_glDeleteTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindTexture.xml +func (gl *GL) BindTexture(target glbase.Enum, texture glbase.Texture) { + C.gl4_1core_glBindTexture(gl.funcs, C.GLenum(target), C.GLuint(texture)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexSubImage2D.xml +func (gl *GL) TexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_1core_glTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexSubImage1D.xml +func (gl *GL) TexSubImage1D(target glbase.Enum, level, xoffset, width int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_1core_glTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexSubImage2D.xml +func (gl *GL) CopyTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, x, y, width, height int) { + C.gl4_1core_glCopyTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexSubImage1D.xml +func (gl *GL) CopyTexSubImage1D(target glbase.Enum, level, xoffset, x, y, width int) { + C.gl4_1core_glCopyTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexImage2D.xml +func (gl *GL) CopyTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, height, border int) { + C.gl4_1core_glCopyTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexImage1D.xml +func (gl *GL) CopyTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, border int) { + C.gl4_1core_glCopyTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPolygonOffset.xml +func (gl *GL) PolygonOffset(factor, units float32) { + C.gl4_1core_glPolygonOffset(gl.funcs, C.GLfloat(factor), C.GLfloat(units)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElements.xml +func (gl *GL) DrawElements(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_1core_glDrawElements(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawArrays.xml +func (gl *GL) DrawArrays(mode glbase.Enum, first, count int) { + C.gl4_1core_glDrawArrays(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexSubImage3D.xml +func (gl *GL) CopyTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, x, y, width, height int) { + C.gl4_1core_glCopyTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexSubImage3D.xml +func (gl *GL) TexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_1core_glTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage3D.xml +func (gl *GL) TexImage3D(target glbase.Enum, level int, internalFormat int32, width, height int, depth int32, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_1core_glTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawRangeElements.xml +func (gl *GL) DrawRangeElements(mode glbase.Enum, start, end uint32, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_1core_glDrawRangeElements(gl.funcs, C.GLenum(mode), C.GLuint(start), C.GLuint(end), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendEquation.xml +func (gl *GL) BlendEquation(mode glbase.Enum) { + C.gl4_1core_glBlendEquation(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendColor.xml +func (gl *GL) BlendColor(red, green, blue, alpha float32) { + C.gl4_1core_glBlendColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetCompressedTexImage.xml +func (gl *GL) GetCompressedTexImage(target glbase.Enum, level int, img interface{}) { + var img_ptr unsafe.Pointer + var img_v = reflect.ValueOf(img) + if img != nil && img_v.Kind() != reflect.Slice { + panic("parameter img must be a slice") + } + if img != nil { + img_ptr = unsafe.Pointer(img_v.Index(0).Addr().Pointer()) + } + C.gl4_1core_glGetCompressedTexImage(gl.funcs, C.GLenum(target), C.GLint(level), img_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexSubImage1D.xml +func (gl *GL) CompressedTexSubImage1D(target glbase.Enum, level, xoffset, width int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_1core_glCompressedTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexSubImage2D.xml +func (gl *GL) CompressedTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_1core_glCompressedTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexSubImage3D.xml +func (gl *GL) CompressedTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_1core_glCompressedTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexImage1D.xml +func (gl *GL) CompressedTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, width, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_1core_glCompressedTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexImage2D.xml +func (gl *GL) CompressedTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_1core_glCompressedTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexImage3D.xml +func (gl *GL) CompressedTexImage3D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height int, depth int32, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_1core_glCompressedTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSampleCoverage.xml +func (gl *GL) SampleCoverage(value float32, invert bool) { + C.gl4_1core_glSampleCoverage(gl.funcs, C.GLfloat(value), *(*C.GLboolean)(unsafe.Pointer(&invert))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glActiveTexture.xml +func (gl *GL) ActiveTexture(texture glbase.Enum) { + C.gl4_1core_glActiveTexture(gl.funcs, C.GLenum(texture)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointParameteriv.xml +func (gl *GL) PointParameteriv(pname glbase.Enum, params []int32) { + C.gl4_1core_glPointParameteriv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointParameteri.xml +func (gl *GL) PointParameteri(pname glbase.Enum, param int32) { + C.gl4_1core_glPointParameteri(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointParameterfv.xml +func (gl *GL) PointParameterfv(pname glbase.Enum, params []float32) { + C.gl4_1core_glPointParameterfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointParameterf.xml +func (gl *GL) PointParameterf(pname glbase.Enum, param float32) { + C.gl4_1core_glPointParameterf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiDrawArrays.xml +func (gl *GL) MultiDrawArrays(mode glbase.Enum, first, count []int, drawcount int32) { + C.gl4_1core_glMultiDrawArrays(gl.funcs, C.GLenum(mode), (*C.GLint)(unsafe.Pointer(&first[0])), (*C.GLsizei)(unsafe.Pointer(&count[0])), C.GLsizei(drawcount)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFuncSeparate.xml +func (gl *GL) BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha glbase.Enum) { + C.gl4_1core_glBlendFuncSeparate(gl.funcs, C.GLenum(sfactorRGB), C.GLenum(dfactorRGB), C.GLenum(sfactorAlpha), C.GLenum(dfactorAlpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBufferParameteriv.xml +func (gl *GL) GetBufferParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_1core_glGetBufferParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUnmapBuffer.xml +func (gl *GL) UnmapBuffer(target glbase.Enum) bool { + glresult := C.gl4_1core_glUnmapBuffer(gl.funcs, C.GLenum(target)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBufferSubData.xml +func (gl *GL) GetBufferSubData(target glbase.Enum, offset, size int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_1core_glGetBufferSubData(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(size), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBufferSubData.xml +func (gl *GL) BufferSubData(target glbase.Enum, offset, size int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_1core_glBufferSubData(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(size), data_ptr) +} + +// BufferData creates a new data store for the buffer object currently +// bound to target. Any pre-existing data store is deleted. The new data +// store is created with the specified size in bytes and usage. If data is +// not nil, it must be a slice that is used to initialize the data store. +// In that case the size parameter is ignored and the store size will match +// the slice data size. +// +// In its initial state, the new data store is not mapped, it has a NULL +// mapped pointer, and its mapped access is GL.READ_WRITE. +// +// The target constant must be one of GL.ARRAY_BUFFER, GL.COPY_READ_BUFFER, +// GL.COPY_WRITE_BUFFER, GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER, +// GL.PIXEL_UNPACK_BUFFER, GL.TEXTURE_BUFFER, GL.TRANSFORM_FEEDBACK_BUFFER, +// or GL.UNIFORM_BUFFER. +// +// The usage parameter is a hint to the GL implementation as to how a buffer +// object's data store will be accessed. This enables the GL implementation +// to make more intelligent decisions that may significantly impact buffer +// object performance. It does not, however, constrain the actual usage of +// the data store. usage can be broken down into two parts: first, the +// frequency of access (modification and usage), and second, the nature of +// that access. +// +// A usage frequency of STREAM and nature of DRAW is specified via the +// constant GL.STREAM_DRAW, for example. +// +// The usage frequency of access may be one of: +// +// STREAM +// The data store contents will be modified once and used at most a few times. +// +// STATIC +// The data store contents will be modified once and used many times. +// +// DYNAMIC +// The data store contents will be modified repeatedly and used many times. +// +// The usage nature of access may be one of: +// +// DRAW +// The data store contents are modified by the application, and used as +// the source for GL drawing and image specification commands. +// +// READ +// The data store contents are modified by reading data from the GL, +// and used to return that data when queried by the application. +// +// COPY +// The data store contents are modified by reading data from the GL, +// and used as the source for GL drawing and image specification +// commands. +// +// Clients must align data elements consistent with the requirements of the +// client platform, with an additional base-level requirement that an offset +// within a buffer to a datum comprising N bytes be a multiple of N. +// +// Error GL.INVALID_ENUM is generated if target is not one of the accepted +// buffer targets. GL.INVALID_ENUM is generated if usage is not +// GL.STREAM_DRAW, GL.STREAM_READ, GL.STREAM_COPY, GL.STATIC_DRAW, +// GL.STATIC_READ, GL.STATIC_COPY, GL.DYNAMIC_DRAW, GL.DYNAMIC_READ, or +// GL.DYNAMIC_COPY. GL.INVALID_VALUE is generated if size is negative. +// GL.INVALID_OPERATION is generated if the reserved buffer object name 0 is +// bound to target. GL.OUT_OF_MEMORY is generated if the GL is unable to +// create a data store with the specified size. +func (gl *GL) BufferData(target glbase.Enum, size int, data interface{}, usage glbase.Enum) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + if data != nil { + size = int(data_v.Type().Size()) * data_v.Len() + } + C.gl4_1core_glBufferData(gl.funcs, C.GLenum(target), C.GLsizeiptr(size), data_ptr, C.GLenum(usage)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsBuffer.xml +func (gl *GL) IsBuffer(buffer glbase.Buffer) bool { + glresult := C.gl4_1core_glIsBuffer(gl.funcs, C.GLuint(buffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenBuffers returns n buffer object names. There is no guarantee that +// the names form a contiguous set of integers; however, it is guaranteed +// that none of the returned names was in use immediately before the call to +// GenBuffers. +// +// Buffer object names returned by a call to GenBuffers are not returned by +// subsequent calls, unless they are first deleted with DeleteBuffers. +// +// No buffer objects are associated with the returned buffer object names +// until they are first bound by calling BindBuffer. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if GenBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// GenBuffers is available in GL version 1.5 or greater. +func (gl *GL) GenBuffers(n int) []glbase.Buffer { + if n == 0 { + return nil + } + buffers := make([]glbase.Buffer, n) + C.gl4_1core_glGenBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) + return buffers +} + +// DeleteBuffers deletes the buffer objects whose names are stored in the +// buffers slice. +// +// After a buffer object is deleted, it has no contents, and its name is free +// for reuse (for example by GenBuffers). If a buffer object that is +// currently bound is deleted, the binding reverts to 0 (the absence of any +// buffer object, which reverts to client memory usage). +// +// DeleteBuffers silently ignores 0's and names that do not correspond to +// existing buffer objects. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if DeleteBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// DeleteBuffers is available in GL version 1.5 or greater. +func (gl *GL) DeleteBuffers(buffers []glbase.Buffer) { + n := len(buffers) + if n == 0 { + return + } + C.gl4_1core_glDeleteBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) +} + +// BindBuffer creates or puts in use a named buffer object. +// Calling BindBuffer with target set to GL.ARRAY_BUFFER, +// GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER or GL.PIXEL_UNPACK_BUFFER +// and buffer set to the name of the new buffer object binds the buffer +// object name to the target. When a buffer object is bound to a target, the +// previous binding for that target is automatically broken. +// +// Buffer object names are unsigned integers. The value zero is reserved, but +// there is no default buffer object for each buffer object target. Instead, +// buffer set to zero effectively unbinds any buffer object previously bound, +// and restores client memory usage for that buffer object target. Buffer +// object names and the corresponding buffer object contents are local to the +// shared display-list space (see XCreateContext) of the current GL rendering +// context; two rendering contexts share buffer object names only if they +// also share display lists. +// +// GenBuffers may be called to generate a set of new buffer object names. +// +// The state of a buffer object immediately after it is first bound is an +// unmapped zero-sized memory buffer with GL.READ_WRITE access and +// GL.STATIC_DRAW usage. +// +// While a non-zero buffer object name is bound, GL operations on the target +// to which it is bound affect the bound buffer object, and queries of the +// target to which it is bound return state from the bound buffer object. +// While buffer object name zero is bound, as in the initial state, attempts +// to modify or query state on the target to which it is bound generates an +// GL.INVALID_OPERATION error. +// +// When vertex array pointer state is changed, for example by a call to +// NormalPointer, the current buffer object binding (GL.ARRAY_BUFFER_BINDING) +// is copied into the corresponding client state for the vertex array type +// being changed, for example GL.NORMAL_ARRAY_BUFFER_BINDING. While a +// non-zero buffer object is bound to the GL.ARRAY_BUFFER target, the vertex +// array pointer parameter that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.ELEMENT_ARRAY_BUFFER +// target, the indices parameter of DrawElements, DrawRangeElements, or +// MultiDrawElements that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_PACK_BUFFER +// target, the following commands are affected: GetCompressedTexImage, +// GetConvolutionFilter, GetHistogram, GetMinmax, GetPixelMap, +// GetPolygonStipple, GetSeparableFilter, GetTexImage, and ReadPixels. The +// pointer parameter that is traditionally interpreted as a pointer to +// client-side memory where the pixels are to be packed is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_UNPACK_BUFFER +// target, the following commands are affected: Bitmap, ColorSubTable, +// ColorTable, CompressedTexImage1D, CompressedTexImage2D, +// CompressedTexImage3D, CompressedTexSubImage1D, CompressedTexSubImage2D, +// CompressedTexSubImage3D, ConvolutionFilter1D, ConvolutionFilter2D, +// DrawPixels, PixelMap, PolygonStipple, SeparableFilter2D, TexImage1D, +// TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, and TexSubImage3D. +// The pointer parameter that is traditionally interpreted as a pointer to +// client-side memory from which the pixels are to be unpacked is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// A buffer object binding created with BindBuffer remains active until a +// different buffer object name is bound to the same target, or until the +// bound buffer object is deleted with DeleteBuffers. +// +// Once created, a named buffer object may be re-bound to any target as often +// as needed. However, the GL implementation may make choices about how to +// optimize the storage of a buffer object based on its initial binding +// target. +// +// Error GL.INVALID_ENUM is generated if target is not one of the allowable +// values. GL.INVALID_OPERATION is generated if BindBuffer is executed +// between the execution of Begin and the corresponding execution of End. +// +// BindBuffer is available in GL version 1.5 or greater. +func (gl *GL) BindBuffer(target glbase.Enum, buffer glbase.Buffer) { + C.gl4_1core_glBindBuffer(gl.funcs, C.GLenum(target), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryObjectuiv.xml +func (gl *GL) GetQueryObjectuiv(id uint32, pname glbase.Enum, params []uint32) { + C.gl4_1core_glGetQueryObjectuiv(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryObjectiv.xml +func (gl *GL) GetQueryObjectiv(id uint32, pname glbase.Enum, params []int32) { + C.gl4_1core_glGetQueryObjectiv(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryiv.xml +func (gl *GL) GetQueryiv(target, pname glbase.Enum, params []int32) { + C.gl4_1core_glGetQueryiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndQuery.xml +func (gl *GL) EndQuery(target glbase.Enum) { + C.gl4_1core_glEndQuery(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBeginQuery.xml +func (gl *GL) BeginQuery(target glbase.Enum, id uint32) { + C.gl4_1core_glBeginQuery(gl.funcs, C.GLenum(target), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsQuery.xml +func (gl *GL) IsQuery(id uint32) bool { + glresult := C.gl4_1core_glIsQuery(gl.funcs, C.GLuint(id)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteQueries.xml +func (gl *GL) DeleteQueries(n int, ids []uint32) { + C.gl4_1core_glDeleteQueries(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenQueries.xml +func (gl *GL) GenQueries(n int, ids []uint32) { + C.gl4_1core_glGenQueries(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// VertexAttribPointer specifies the location and data format of the array +// of generic vertex attributes at index to use when rendering. size +// specifies the number of components per attribute and must be 1, 2, 3, or +// 4. type specifies the data type of each component, and stride specifies +// the byte stride from one attribute to the next, allowing vertices and +// attributes to be packed into a single array or stored in separate arrays. +// normalized indicates whether the values stored in an integer format are +// to be mapped to the range [-1,1] (for signed values) or [0,1] +// (for unsigned values) when they are accessed and converted to floating +// point; otherwise, values will be converted to floats directly without +// normalization. offset is a byte offset into the buffer object's data +// store, which must be bound to the GL.ARRAY_BUFFER target with BindBuffer. +// +// The buffer object binding (GL.ARRAY_BUFFER_BINDING) is saved as +// generic vertex attribute array client-side state +// (GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING) for the provided index. +// +// To enable and disable a generic vertex attribute array, call +// EnableVertexAttribArray and DisableVertexAttribArray with index. If +// enabled, the generic vertex attribute array is used when DrawArrays or +// DrawElements is called. Each generic vertex attribute array is initially +// disabled. +// +// VertexAttribPointer is typically implemented on the client side. +// +// Error GL.INVALID_ENUM is generated if type is not an accepted value. +// GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_VALUE is generated if size is not 1, 2, +// 3, or 4. GL.INVALID_VALUE is generated if stride is negative. +func (gl *GL) VertexAttribPointer(index glbase.Attrib, size int, gltype glbase.Enum, normalized bool, stride int, offset uintptr) { + offset_ptr := unsafe.Pointer(offset) + C.gl4_1core_glVertexAttribPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLsizei(stride), offset_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glValidateProgram.xml +func (gl *GL) ValidateProgram(program glbase.Program) { + C.gl4_1core_glValidateProgram(gl.funcs, C.GLuint(program)) +} + +// UniformMatrix4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*4) != 0 { + panic("invalid value length for UniformMatrix4fv") + } + count := len(value) / (4 * 4) + C.gl4_1core_glUniformMatrix4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*3) != 0 { + panic("invalid value length for UniformMatrix3fv") + } + count := len(value) / (3 * 3) + C.gl4_1core_glUniformMatrix3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*2) != 0 { + panic("invalid value length for UniformMatrix2fv") + } + count := len(value) / (2 * 2) + C.gl4_1core_glUniformMatrix2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform4iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4iv") + } + count := len(value) / 4 + C.gl4_1core_glUniform4iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform3iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3iv") + } + count := len(value) / 3 + C.gl4_1core_glUniform3iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform2iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2iv") + } + count := len(value) / 2 + C.gl4_1core_glUniform2iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform1iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl4_1core_glUniform1iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4fv") + } + count := len(value) / 4 + C.gl4_1core_glUniform4fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3fv") + } + count := len(value) / 3 + C.gl4_1core_glUniform3fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2fv") + } + count := len(value) / 2 + C.gl4_1core_glUniform2fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform1fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl4_1core_glUniform1fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform4i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4i(location glbase.Uniform, v0, v1, v2, v3 int32) { + C.gl4_1core_glUniform4i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2), C.GLint(v3)) +} + +// Uniform3i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3i(location glbase.Uniform, v0, v1, v2 int32) { + C.gl4_1core_glUniform3i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2)) +} + +// Uniform2i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2i(location glbase.Uniform, v0, v1 int32) { + C.gl4_1core_glUniform2i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1)) +} + +// Uniform1i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1i(location glbase.Uniform, v0 int32) { + C.gl4_1core_glUniform1i(gl.funcs, C.GLint(location), C.GLint(v0)) +} + +// Uniform4f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4f(location glbase.Uniform, v0, v1, v2, v3 float32) { + C.gl4_1core_glUniform4f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2), C.GLfloat(v3)) +} + +// Uniform3f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3f(location glbase.Uniform, v0, v1, v2 float32) { + C.gl4_1core_glUniform3f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2)) +} + +// Uniform2f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2f(location glbase.Uniform, v0, v1 float32) { + C.gl4_1core_glUniform2f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1)) +} + +// Uniform1f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1f(location glbase.Uniform, v0 float32) { + C.gl4_1core_glUniform1f(gl.funcs, C.GLint(location), C.GLfloat(v0)) +} + +// UseProgram installs the program object specified by program as part of +// current rendering state. One or more executables are created in a program +// object by successfully attaching shader objects to it with AttachShader, +// successfully compiling the shader objects with CompileShader, and +// successfully linking the program object with LinkProgram. +// +// A program object will contain an executable that will run on the vertex +// processor if it contains one or more shader objects of type +// GL.VERTEX_SHADER that have been successfully compiled and linked. +// Similarly, a program object will contain an executable that will run on +// the fragment processor if it contains one or more shader objects of type +// GL.FRAGMENT_SHADER that have been successfully compiled and linked. +// +// Successfully installing an executable on a programmable processor will +// cause the corresponding fixed functionality of OpenGL to be disabled. +// Specifically, if an executable is installed on the vertex processor, the +// OpenGL fixed functionality will be disabled as follows. +// +// - The modelview matrix is not applied to vertex coordinates. +// +// - The projection matrix is not applied to vertex coordinates. +// +// - The texture matrices are not applied to texture coordinates. +// +// - Normals are not transformed to eye coordinates. +// +// - Normals are not rescaled or normalized. +// +// - Normalization of GL.AUTO_NORMAL evaluated normals is not performed. +// +// - Texture coordinates are not generated automatically. +// +// - Per-vertex lighting is not performed. +// +// - Color material computations are not performed. +// +// - Color index lighting is not performed. +// +// - This list also applies when setting the current raster position. +// +// The executable that is installed on the vertex processor is expected to +// implement any or all of the desired functionality from the preceding list. +// Similarly, if an executable is installed on the fragment processor, the +// OpenGL fixed functionality will be disabled as follows. +// +// - Texture environment and texture functions are not applied. +// +// - Texture application is not applied. +// +// - Color sum is not applied. +// +// - Fog is not applied. +// +// Again, the fragment shader that is installed is expected to implement any +// or all of the desired functionality from the preceding list. +// +// While a program object is in use, applications are free to modify attached +// shader objects, compile attached shader objects, attach additional shader +// objects, and detach or delete shader objects. None of these operations +// will affect the executables that are part of the current state. However, +// relinking the program object that is currently in use will install the +// program object as part of the current rendering state if the link +// operation was successful (see LinkProgram). If the program object +// currently in use is relinked unsuccessfully, its link status will be set +// to GL.FALSE, but the executables and associated state will remain part of +// the current state until a subsequent call to UseProgram removes it from +// use. After it is removed from use, it cannot be made part of current state +// until it has been successfully relinked. +// +// If program contains shader objects of type GL.VERTEX_SHADER but it does +// not contain shader objects of type GL.FRAGMENT_SHADER, an executable will +// be installed on the vertex processor, but fixed functionality will be used +// for fragment processing. Similarly, if program contains shader objects of +// type GL.FRAGMENT_SHADER but it does not contain shader objects of type +// GL.VERTEX_SHADER, an executable will be installed on the fragment +// processor, but fixed functionality will be used for vertex processing. If +// program is 0, the programmable processors will be disabled, and fixed +// functionality will be used for both vertex and fragment processing. +// +// While a program object is in use, the state that controls the disabled +// fixed functionality may also be updated using the normal OpenGL calls. +// +// Like display lists and texture objects, the name space for program objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// Applications are responsible for providing the synchronization across API +// calls when objects are accessed from different execution threads. +// +// Error GL.INVALID_VALUE is generated if program is neither 0 nor a value +// generated by OpenGL. GL.INVALID_OPERATION is generated if program is not +// a program object. GL.INVALID_OPERATION is generated if program could not +// be made part of current state. GL.INVALID_OPERATION is generated if +// UseProgram is executed between the execution of Begin and the +// corresponding execution of End. +// +// UseProgram is available in GL version 2.0 or greater. +func (gl *GL) UseProgram(program glbase.Program) { + C.gl4_1core_glUseProgram(gl.funcs, C.GLuint(program)) +} + +// ShaderSource sets the source code in shader to the provided source code. Any source +// code previously stored in the shader object is completely replaced. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_VALUE is generated if count is less than 0. +// GL.INVALID_OPERATION is generated if ShaderSource is executed between the +// execution of Begin and the corresponding execution of End. +// +// ShaderSource is available in GL version 2.0 or greater. +func (gl *GL) ShaderSource(shader glbase.Shader, source ...string) { + count := len(source) + length := make([]int32, count) + source_c := make([]unsafe.Pointer, count) + for i, src := range source { + length[i] = int32(len(src)) + if len(src) > 0 { + source_c[i] = *(*unsafe.Pointer)(unsafe.Pointer(&src)) + } else { + source_c[i] = unsafe.Pointer(uintptr(0)) + } + } + C.gl4_1core_glShaderSource(gl.funcs, C.GLuint(shader), C.GLsizei(count), (**C.GLchar)(unsafe.Pointer(&source_c[0])), (*C.GLint)(unsafe.Pointer(&length[0]))) +} + +// LinkProgram links the program object specified by program. If any shader +// objects of type GL.VERTEX_SHADER are attached to program, they will be +// used to create an executable that will run on the programmable vertex +// processor. If any shader objects of type GL.FRAGMENT_SHADER are attached +// to program, they will be used to create an executable that will run on the +// programmable fragment processor. +// +// The status of the link operation will be stored as part of the program +// object's state. This value will be set to GL.TRUE if the program object +// was linked without errors and is ready for use, and GL.FALSE otherwise. It +// can be queried by calling GetProgramiv with arguments program and +// GL.LINK_STATUS. +// +// As a result of a successful link operation, all active user-defined +// uniform variables belonging to program will be initialized to 0, and each +// of the program object's active uniform variables will be assigned a +// location that can be queried by calling GetUniformLocation. Also, any +// active user-defined attribute variables that have not been bound to a +// generic vertex attribute index will be bound to one at this time. +// +// Linking of a program object can fail for a number of reasons as specified +// in the OpenGL Shading Language Specification. The following lists some of +// the conditions that will cause a link error. +// +// - The number of active attribute variables supported by the +// implementation has been exceeded. +// +// - The storage limit for uniform variables has been exceeded. +// +// - The number of active uniform variables supported by the implementation +// has been exceeded. +// +// - The main function is missing for the vertex shader or the fragment +// shader. +// +// - A varying variable actually used in the fragment shader is not +// declared in the same way (or is not declared at all) in the vertex +// shader. +// +// - A reference to a function or variable name is unresolved. +// +// - A shared global is declared with two different types or two different +// initial values. +// +// - One or more of the attached shader objects has not been successfully +// compiled. +// +// - Binding a generic attribute matrix caused some rows of the matrix to +// fall outside the allowed maximum of GL.MAX_VERTEX_ATTRIBS. +// +// - Not enough contiguous vertex attribute slots could be found to bind +// attribute matrices. +// +// When a program object has been successfully linked, the program object can +// be made part of current state by calling UseProgram. Whether or not the +// link operation was successful, the program object's information log will +// be overwritten. The information log can be retrieved by calling +// GetProgramInfoLog. +// +// LinkProgram will also install the generated executables as part of the +// current rendering state if the link operation was successful and the +// specified program object is already currently in use as a result of a +// previous call to UseProgram. If the program object currently in use is +// relinked unsuccessfully, its link status will be set to GL.FALSE , but the +// executables and associated state will remain part of the current state +// until a subsequent call to UseProgram removes it from use. After it is +// removed from use, it cannot be made part of current state until it has +// been successfully relinked. +// +// If program contains shader objects of type GL.VERTEX_SHADER but does not +// contain shader objects of type GL.FRAGMENT_SHADER, the vertex shader will +// be linked against the implicit interface for fixed functionality fragment +// processing. Similarly, if program contains shader objects of type +// GL.FRAGMENT_SHADER but it does not contain shader objects of type +// GL.VERTEX_SHADER, the fragment shader will be linked against the implicit +// interface for fixed functionality vertex processing. +// +// The program object's information log is updated and the program is +// generated at the time of the link operation. After the link operation, +// applications are free to modify attached shader objects, compile attached +// shader objects, detach shader objects, delete shader objects, and attach +// additional shader objects. None of these operations affects the +// information log or the program that is part of the program object. +// +// If the link operation is unsuccessful, any information about a previous +// link operation on program is lost (a failed link does not restore the +// old state of program). Certain information can still be retrieved +// from program even after an unsuccessful link operation. See for instance +// GetActiveAttrib and GetActiveUniform. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if LinkProgram is executed +// between the execution of Begin and the corresponding execution of End. +// +// LinkProgram is available in GL version 2.0 or greater. +func (gl *GL) LinkProgram(program glbase.Program) { + C.gl4_1core_glLinkProgram(gl.funcs, C.GLuint(program)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsShader.xml +func (gl *GL) IsShader(shader glbase.Shader) bool { + glresult := C.gl4_1core_glIsShader(gl.funcs, C.GLuint(shader)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsProgram.xml +func (gl *GL) IsProgram(program glbase.Program) bool { + glresult := C.gl4_1core_glIsProgram(gl.funcs, C.GLuint(program)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GetVertexAttribiv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribiv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribiv(index glbase.Attrib, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl4_1core_glGetVertexAttribiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetVertexAttribfv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribfv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribfv(index glbase.Attrib, pname glbase.Enum, params []float32) { + var params_c [4]float32 + C.gl4_1core_glGetVertexAttribfv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetVertexAttribdv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribdv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribdv(index glbase.Attrib, pname glbase.Enum, params []float64) { + var params_c [4]float64 + C.gl4_1core_glGetVertexAttribdv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformiv returns in params the value of the specified uniform +// variable. The type of the uniform variable specified by location +// determines the number of values returned. If the uniform variable is +// defined in the shader as a boolean, int, or float, a single value will be +// returned. If it is defined as a vec2, ivec2, or bvec2, two values will be +// returned. If it is defined as a vec3, ivec3, or bvec3, three values will +// be returned, and so on. To query values stored in uniform variables +// declared as arrays, call GetUniformiv for each element of the array. To +// query values stored in uniform variables declared as structures, call +// GetUniformiv for each field in the structure. The values for uniform +// variables declared as a matrix will be returned in column major order. +// +// The locations assigned to uniform variables are not known until the +// program object is linked. After linking has occurred, the command +// GetUniformLocation can be used to obtain the location of a uniform +// variable. This location value can then be passed to GetUniformiv in order +// to query the current value of the uniform variable. After a program object +// has been linked successfully, the index values for uniform variables +// remain fixed until the next link command occurs. The uniform variable +// values can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if program has not been +// successfully linked. GL.INVALID_OPERATION is generated if location does +// not correspond to a valid uniform variable location for the specified +// program object. GL.INVALID_OPERATION is generated if GetUniformiv is +// executed between the execution of Begin and the corresponding execution of +// End. +// +// GetUniformiv is available in GL version 2.0 or greater. +func (gl *GL) GetUniformiv(program glbase.Program, location glbase.Uniform, params []int32) { + var params_c [4]int32 + C.gl4_1core_glGetUniformiv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformfv returns in params the value of the specified uniform +// variable. The type of the uniform variable specified by location +// determines the number of values returned. If the uniform variable is +// defined in the shader as a boolean, int, or float, a single value will be +// returned. If it is defined as a vec2, ivec2, or bvec2, two values will be +// returned. If it is defined as a vec3, ivec3, or bvec3, three values will +// be returned, and so on. To query values stored in uniform variables +// declared as arrays, call GetUniformfv for each element of the array. To +// query values stored in uniform variables declared as structures, call +// GetUniformfv for each field in the structure. The values for uniform +// variables declared as a matrix will be returned in column major order. +// +// The locations assigned to uniform variables are not known until the +// program object is linked. After linking has occurred, the command +// GetUniformLocation can be used to obtain the location of a uniform +// variable. This location value can then be passed to GetUniformfv in order +// to query the current value of the uniform variable. After a program object +// has been linked successfully, the index values for uniform variables +// remain fixed until the next link command occurs. The uniform variable +// values can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if program has not been +// successfully linked. GL.INVALID_OPERATION is generated if location does +// not correspond to a valid uniform variable location for the specified +// program object. GL.INVALID_OPERATION is generated if GetUniformfv is +// executed between the execution of Begin and the corresponding execution of +// End. +// +// GetUniformfv is available in GL version 2.0 or greater. +func (gl *GL) GetUniformfv(program glbase.Program, location glbase.Uniform, params []float32) { + var params_c [4]float32 + C.gl4_1core_glGetUniformfv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLfloat)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformLocation returns an integer that represents the location of a +// specific uniform variable within a program object. name must be an active +// uniform variable name in program that is not a structure, an array of +// structures, or a subcomponent of a vector or a matrix. This function +// returns -1 if name does not correspond to an active uniform variable in +// program or if name starts with the reserved prefix "gl_". +// +// Uniform variables that are structures or arrays of structures may be +// queried by calling GetUniformLocation for each field within the +// structure. The array element operator "[]" and the structure field +// operator "." may be used in name in order to select elements within an +// array or fields within a structure. The result of using these operators is +// not allowed to be another structure, an array of structures, or a +// subcomponent of a vector or a matrix. Except if the last part of name +// indicates a uniform variable array, the location of the first element of +// an array can be retrieved by using the name of the array, or by using the +// name appended by "[0]". +// +// The actual locations assigned to uniform variables are not known until the +// program object is linked successfully. After linking has occurred, the +// command GetUniformLocation can be used to obtain the location of a +// uniform variable. This location value can then be passed to Uniform to +// set the value of the uniform variable or to GetUniform in order to query +// the current value of the uniform variable. After a program object has been +// linked successfully, the index values for uniform variables remain fixed +// until the next link command occurs. Uniform variable locations and values +// can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program object. +// GL.INVALID_OPERATION is generated if program has not been successfully +// linked. GL.INVALID_OPERATION is generated if GetUniformLocation is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetUniformLocation is available in GL version 2.0 or greater. +func (gl *GL) GetUniformLocation(program glbase.Program, name string) glbase.Uniform { + name_cstr := C.CString(name) + glresult := C.gl4_1core_glGetUniformLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) + return glbase.Uniform(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetShaderSource.xml +func (gl *GL) GetShaderSource(shader glbase.Shader, bufSize int32, length []int32, source []byte) { + C.gl4_1core_glGetShaderSource(gl.funcs, C.GLuint(shader), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&source[0]))) +} + +// GetShaderInfoLog returns the information log for the specified shader +// object. The information log for a shader object is modified when the +// shader is compiled. +// +// The information log for a shader object is a string that may contain +// diagnostic messages, warning messages, and other information about the +// last compile operation. When a shader object is created, its information +// log will be a string of length 0, and the size of the current log can be +// obtained by calling GetShaderiv with the value GL.INFO_LOG_LENGTH. +// +// The information log for a shader object is the OpenGL implementer's +// primary mechanism for conveying information about the compilation process. +// Therefore, the information log can be helpful to application developers +// during the development process, even when compilation is successful. +// Application developers should not expect different OpenGL implementations +// to produce identical information logs. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_VALUE is generated if maxLength is less than 0. +// GL.INVALID_OPERATION is generated if GetShaderInfoLog is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetShaderInfoLog is available in GL version 2.0 or greater. +func (gl *GL) GetShaderInfoLog(shader glbase.Shader) []byte { + var params [1]int32 + var length int32 + gl.GetShaderiv(shader, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + C.gl4_1core_glGetShaderInfoLog(gl.funcs, C.GLuint(shader), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length)), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) + return infoLog +} + +// GetShaderiv GetShader returns in params the value of a parameter for a specific +// shader object. The following parameters are defined: +// +// GL.SHADER_TYPE +// params returns GL.VERTEX_SHADER if shader is a vertex shader object, +// and GL.FRAGMENT_SHADER if shader is a fragment shader object. +// +// GL.DELETE_STATUS +// params returns GL.TRUE if shader is currently flagged for deletion, +// and GL.FALSE otherwise. +// +// GL.COMPILE_STATUS +// params returns GL.TRUE if the last compile operation on shader was +// successful, and GL.FALSE otherwise. +// +// GL.INFO_LOG_LENGTH +// params returns the number of characters in the information log for +// shader including the null termination character (the size of the +// character buffer required to store the information log). If shader has +// no information log, a value of 0 is returned. +// +// GL.SHADER_SOURCE_LENGTH +// params returns the length of the concatenation of the source strings +// that make up the shader source for the shader, including the null +// termination character. (the size of the character buffer +// required to store the shader source). If no source code exists, 0 is +// returned. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader does not refer to a +// shader object. GL.INVALID_ENUM is generated if pname is not an accepted +// value. GL.INVALID_OPERATION is generated if GetShader is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetShaderiv is available in GL version 2.0 or greater. +func (gl *GL) GetShaderiv(shader glbase.Shader, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl4_1core_glGetShaderiv(gl.funcs, C.GLuint(shader), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetProgramInfoLog returns the information log for the specified program +// object. The information log for a program object is modified when the +// program object is linked or validated. +// +// The information log for a program object is either an empty string, or a +// string containing information about the last link operation, or a string +// containing information about the last validation operation. It may contain +// diagnostic messages, warning messages, and other information. When a +// program object is created, its information log will be a string of length +// 0, and the size of the current log can be obtained by calling GetProgramiv +// with the value GL.INFO_LOG_LENGTH. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated +// by OpenGL. GL.INVALID_OPERATION is generated if program is not a +// program object. +func (gl *GL) GetProgramInfoLog(program glbase.Program) []byte { + var params [1]int32 + var length int32 + gl.GetProgramiv(program, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + C.gl4_1core_glGetProgramInfoLog(gl.funcs, C.GLuint(program), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length)), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) + return infoLog +} + +// GetProgramiv returns in params the value of a parameter for a specific +// program object. The following parameters are defined: +// +// GL.DELETE_STATUS +// params returns GL.TRUE if program is currently flagged for deletion, +// and GL.FALSE otherwise. +// +// GL.LINK_STATUS +// params returns GL.TRUE if the last link operation on program was +// successful, and GL.FALSE otherwise. +// +// GL.VALIDATE_STATUS +// params returns GL.TRUE or if the last validation operation on +// program was successful, and GL.FALSE otherwise. +// +// GL.INFO_LOG_LENGTH +// params returns the number of characters in the information log for +// program including the null termination character (the size of +// the character buffer required to store the information log). If +// program has no information log, a value of 0 is returned. +// +// GL.ATTACHED_SHADERS +// params returns the number of shader objects attached to program. +// +// GL.ACTIVE_ATTRIBUTES +// params returns the number of active attribute variables for program. +// +// GL.ACTIVE_ATTRIBUTE_MAX_LENGTH +// params returns the length of the longest active attribute name for +// program, including the null termination character (the size of +// the character buffer required to store the longest attribute name). +// If no active attributes exist, 0 is returned. +// +// GL.ACTIVE_UNIFORMS +// params returns the number of active uniform variables for program. +// +// GL.ACTIVE_UNIFORM_MAX_LENGTH +// params returns the length of the longest active uniform variable +// name for program, including the null termination character (i.e., +// the size of the character buffer required to store the longest +// uniform variable name). If no active uniform variables exist, 0 is +// returned. +// +// GL.TRANSFORM_FEEDBACK_BUFFER_MODE +// params returns a symbolic constant indicating the buffer mode used +// when transform feedback is active. This may be GL.SEPARATE_ATTRIBS +// or GL.INTERLEAVED_ATTRIBS. +// +// GL.TRANSFORM_FEEDBACK_VARYINGS +// params returns the number of varying variables to capture in transform +// feedback mode for the program. +// +// GL.TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH +// params returns the length of the longest variable name to be used for +// transform feedback, including the null-terminator. +// +// GL.GEOMETRY_VERTICES_OUT +// params returns the maximum number of vertices that the geometry shader in +// program will output. +// +// GL.GEOMETRY_INPUT_TYPE +// params returns a symbolic constant indicating the primitive type accepted +// as input to the geometry shader contained in program. +// +// GL.GEOMETRY_OUTPUT_TYPE +// params returns a symbolic constant indicating the primitive type that will +// be output by the geometry shader contained in program. +// +// GL.ACTIVE_UNIFORM_BLOCKS and GL.ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH are +// available only if the GL version 3.1 or greater. +// +// GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE and +// GL.GEOMETRY_OUTPUT_TYPE are accepted only if the GL version is 3.2 or +// greater. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program does not refer to a +// program object. GL.INVALID_OPERATION is generated if pname is +// GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE, or +// GL.GEOMETRY_OUTPUT_TYPE, and program does not contain a geometry shader. +// GL.INVALID_ENUM is generated if pname is not an accepted value. +func (gl *GL) GetProgramiv(program glbase.Program, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl4_1core_glGetProgramiv(gl.funcs, C.GLuint(program), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetAttribLocation queries the previously linked program object specified +// by program for the attribute variable specified by name and returns the +// index of the generic vertex attribute that is bound to that attribute +// variable. If name is a matrix attribute variable, the index of the first +// column of the matrix is returned. If the named attribute variable is not +// an active attribute in the specified program object or if name starts with +// the reserved prefix "gl_", a value of -1 is returned. +// +// The association between an attribute variable name and a generic attribute +// index can be specified at any time by calling BindAttribLocation. +// Attribute bindings do not go into effect until LinkProgram is called. +// After a program object has been linked successfully, the index values for +// attribute variables remain fixed until the next link command occurs. The +// attribute values can only be queried after a link if the link was +// successful. GetAttribLocation returns the binding that actually went +// into effect the last time LinkProgram was called for the specified +// program object. Attribute bindings that have been specified since the last +// link operation are not returned by GetAttribLocation. +// +// Error GL_INVALID_OPERATION is generated if program is not a value +// generated by OpenGL. GL_INVALID_OPERATION is generated if program is not +// a program object. GL_INVALID_OPERATION is generated if program has not +// been successfully linked. GL_INVALID_OPERATION is generated if +// GetAttribLocation is executed between the execution of Begin and the +// corresponding execution of End. +// +// GetAttribLocation is available in GL version 2.0 or greater. +func (gl *GL) GetAttribLocation(program glbase.Program, name string) glbase.Attrib { + name_cstr := C.CString(name) + glresult := C.gl4_1core_glGetAttribLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) + return glbase.Attrib(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetAttachedShaders.xml +func (gl *GL) GetAttachedShaders(program glbase.Program, maxCount int32, count []int, obj []uint32) { + C.gl4_1core_glGetAttachedShaders(gl.funcs, C.GLuint(program), C.GLsizei(maxCount), (*C.GLsizei)(unsafe.Pointer(&count[0])), (*C.GLuint)(unsafe.Pointer(&obj[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniform.xml +func (gl *GL) GetActiveUniform(program glbase.Program, index uint32, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl4_1core_glGetActiveUniform(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveAttrib.xml +func (gl *GL) GetActiveAttrib(program glbase.Program, index glbase.Attrib, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl4_1core_glGetActiveAttrib(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEnableVertexAttribArray.xml +func (gl *GL) EnableVertexAttribArray(index glbase.Attrib) { + C.gl4_1core_glEnableVertexAttribArray(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDisableVertexAttribArray.xml +func (gl *GL) DisableVertexAttribArray(index glbase.Attrib) { + C.gl4_1core_glDisableVertexAttribArray(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDetachShader.xml +func (gl *GL) DetachShader(program glbase.Program, shader glbase.Shader) { + C.gl4_1core_glDetachShader(gl.funcs, C.GLuint(program), C.GLuint(shader)) +} + +// DeleteShader frees the memory and invalidates the name associated with +// the shader object specified by shader. This command effectively undoes the +// effects of a call to CreateShader. +// +// If a shader object to be deleted is attached to a program object, it will +// be flagged for deletion, but it will not be deleted until it is no longer +// attached to any program object, for any rendering context (it must +// be detached from wherever it was attached before it will be deleted). A +// value of 0 for shader will be silently ignored. +// +// To determine whether an object has been flagged for deletion, call +// GetShader with arguments shader and GL.DELETE_STATUS. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. +// +// DeleteShader is available in GL version 2.0 or greater. +func (gl *GL) DeleteShader(shader glbase.Shader) { + C.gl4_1core_glDeleteShader(gl.funcs, C.GLuint(shader)) +} + +// DeleteProgram frees the memory and invalidates the name associated with +// the program object specified by program. This command effectively undoes +// the effects of a call to CreateProgram. +// +// If a program object is in use as part of current rendering state, it will +// be flagged for deletion, but it will not be deleted until it is no longer +// part of current state for any rendering context. If a program object to be +// deleted has shader objects attached to it, those shader objects will be +// automatically detached but not deleted unless they have already been +// flagged for deletion by a previous call to DeleteShader. A value of 0 +// for program will be silently ignored. +// +// To determine whether a program object has been flagged for deletion, call +// GetProgram with arguments program and GL.DELETE_STATUS. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. +// +// DeleteProgram is available in GL version 2.0 or greater. +func (gl *GL) DeleteProgram(program glbase.Program) { + C.gl4_1core_glDeleteProgram(gl.funcs, C.GLuint(program)) +} + +// CreateShader creates an empty shader object and returns a non-zero value +// by which it can be referenced. A shader object is used to maintain the +// source code strings that define a shader. shaderType indicates the type of +// shader to be created. +// +// Two types of shaders are supported. A shader of type GL.VERTEX_SHADER is a +// shader that is intended to run on the programmable vertex processor and +// replace the fixed functionality vertex processing in OpenGL. A shader of +// type GL.FRAGMENT_SHADER is a shader that is intended to run on the +// programmable fragment processor and replace the fixed functionality +// fragment processing in OpenGL. +// +// When created, a shader object's GL.SHADER_TYPE parameter is set to either +// GL.VERTEX_SHADER or GL.FRAGMENT_SHADER, depending on the value of +// shaderType. +// +// Like display lists and texture objects, the name space for shader objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// This function returns 0 if an error occurs creating the shader object. +// +// Error GL.INVALID_ENUM is generated if shaderType is not an accepted value. +// GL.INVALID_OPERATION is generated if CreateShader is executed between the +// execution of Begin and the corresponding execution of End. +// +// CreateShader is available in GL version 2.0 or greater. +func (gl *GL) CreateShader(gltype glbase.Enum) glbase.Shader { + glresult := C.gl4_1core_glCreateShader(gl.funcs, C.GLenum(gltype)) + return glbase.Shader(glresult) +} + +// CreateProgram creates an empty program object and returns a non-zero +// value by which it can be referenced. A program object is an object to +// which shader objects can be attached. This provides a mechanism to specify +// the shader objects that will be linked to create a program. It also +// provides a means for checking the compatibility of the shaders that will +// be used to create a program (for instance, checking the compatibility +// between a vertex shader and a fragment shader). When no longer needed as +// part of a program object, shader objects can be detached. +// +// One or more executables are created in a program object by successfully +// attaching shader objects to it with AttachShader, successfully compiling +// the shader objects with CompileShader, and successfully linking the +// program object with LinkProgram. These executables are made part of +// current state when UseProgram is called. Program objects can be deleted +// by calling DeleteProgram. The memory associated with the program object +// will be deleted when it is no longer part of current rendering state for +// any context. +// +// Like display lists and texture objects, the name space for program objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// Applications are responsible for providing the synchronization across API +// calls when objects are accessed from different execution threads. +// +// This function returns 0 if an error occurs creating the program object. +// +// Error GL.INVALID_OPERATION is generated if CreateProgram is executed +// between the execution of Begin and the corresponding execution of End. +// +// CreateProgram is available in GL version 2.0 or greater. +func (gl *GL) CreateProgram() glbase.Program { + glresult := C.gl4_1core_glCreateProgram(gl.funcs) + return glbase.Program(glresult) +} + +// CompileShader compiles the source code strings that have been stored in +// the shader object specified by shader. +// +// The compilation status will be stored as part of the shader object's +// state. This value will be set to GL.TRUE if the shader was compiled without +// errors and is ready for use, and GL.FALSE otherwise. It can be queried by +// calling GetShaderiv with arguments shader and GL.COMPILE_STATUS. +// +// Compilation of a shader can fail for a number of reasons as specified by +// the OpenGL Shading Language Specification. Whether or not the compilation +// was successful, information about the compilation can be obtained from the +// shader object's information log by calling GetShaderInfoLog. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_OPERATION is generated if CompileShader is executed +// between the execution of Begin and the corresponding execution of End. +// +// CompileShader is available in GL version 2.0 or greater. +func (gl *GL) CompileShader(shader glbase.Shader) { + C.gl4_1core_glCompileShader(gl.funcs, C.GLuint(shader)) +} + +// BindAttribLocation associates a user-defined attribute variable in the program +// object specified by program with a generic vertex attribute index. The name +// parameter specifies the name of the vertex shader attribute variable to +// which index is to be bound. When program is made part of the current state, +// values provided via the generic vertex attribute index will modify the +// value of the user-defined attribute variable specified by name. +// +// If name refers to a matrix attribute variable, index refers to the first +// column of the matrix. Other matrix columns are then automatically bound to +// locations index+1 for a matrix of type mat2; index+1 and index+2 for a +// matrix of type mat3; and index+1, index+2, and index+3 for a matrix of +// type mat4. +// +// This command makes it possible for vertex shaders to use descriptive names +// for attribute variables rather than generic variables that are numbered +// from 0 to GL.MAX_VERTEX_ATTRIBS-1. The values sent to each generic +// attribute index are part of current state, just like standard vertex +// attributes such as color, normal, and vertex position. If a different +// program object is made current by calling UseProgram, the generic vertex +// attributes are tracked in such a way that the same values will be observed +// by attributes in the new program object that are also bound to index. +// +// Attribute variable name-to-generic attribute index bindings for a program +// object can be explicitly assigned at any time by calling +// BindAttribLocation. Attribute bindings do not go into effect until +// LinkProgram is called. After a program object has been linked +// successfully, the index values for generic attributes remain fixed (and +// their values can be queried) until the next link command occurs. +// +// Applications are not allowed to bind any of the standard OpenGL vertex +// attributes using this command, as they are bound automatically when +// needed. Any attribute binding that occurs after the program object has +// been linked will not take effect until the next time the program object is +// linked. +// +// If name was bound previously, that information is lost. Thus you cannot +// bind one user-defined attribute variable to multiple indices, but you can +// bind multiple user-defined attribute variables to the same index. +// +// Applications are allowed to bind more than one user-defined attribute +// variable to the same generic vertex attribute index. This is called +// aliasing, and it is allowed only if just one of the aliased attributes is +// active in the executable program, or if no path through the shader +// consumes more than one attribute of a set of attributes aliased to the +// same location. The compiler and linker are allowed to assume that no +// aliasing is done and are free to employ optimizations that work only in +// the absence of aliasing. OpenGL implementations are not required to do +// error checking to detect aliasing. Because there is no way to bind +// standard attributes, it is not possible to alias generic attributes with +// conventional ones (except for generic attribute 0). +// +// BindAttribLocation can be called before any vertex shader objects are +// bound to the specified program object. It is also permissible to bind a +// generic attribute index to an attribute variable name that is never used +// in a vertex shader. +// +// Active attributes that are not explicitly bound will be bound by the +// linker when LinkProgram is called. The locations assigned can be queried +// by calling GetAttribLocation. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. +// GL.INVALID_OPERATION is generated if name starts with the reserved prefix "gl_". +// GL.INVALID_VALUE is generated if program is not a value generated by OpenGL. +// GL.INVALID_OPERATION is generated if program is not a program object. +// GL.INVALID_OPERATION is generated if BindAttribLocation is executed +// between the execution of Begin and the corresponding execution of End. +// +// BindAttribLocation is available in GL version 2.0 or greater. +func (gl *GL) BindAttribLocation(program glbase.Program, index glbase.Attrib, name string) { + name_cstr := C.CString(name) + C.gl4_1core_glBindAttribLocation(gl.funcs, C.GLuint(program), C.GLuint(index), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) +} + +// AttachShader attaches a shader object to a program object. +// +// In order to create an executable, there must be a way to specify the list +// of things that will be linked together. Program objects provide this +// mechanism. Shaders that are to be linked together in a program object must +// first be attached to that program object. This indicates that shader will +// be included in link operations that will be performed on program. +// +// All operations that can be performed on a shader object are valid whether +// or not the shader object is attached to a program object. It is +// permissible to attach a shader object to a program object before source +// code has been loaded into the shader object or before the shader object +// has been compiled. It is permissible to attach multiple shader objects of +// the same type because each may contain a portion of the complete shader. +// It is also permissible to attach a shader object to more than one program +// object. If a shader object is deleted while it is attached to a program +// object, it will be flagged for deletion, and deletion will not occur until +// DetachShader is called to detach it from all program objects to which it +// is attached. +// +// Error GL.INVALID_VALUE is generated if either program or shader is not a +// value generated by OpenGL. GL.INVALID_OPERATION is generated if program +// is not a program object. GL.INVALID_OPERATION is generated if shader is +// not a shader object. GL.INVALID_OPERATION is generated if shader is +// already attached to program. GL.INVALID_OPERATION is generated if +// AttachShader is executed between the execution of Begin and the +// corresponding execution of End. +// +// AttachShader is available in GL version 2.0 or greater. +func (gl *GL) AttachShader(program glbase.Program, shader glbase.Shader) { + C.gl4_1core_glAttachShader(gl.funcs, C.GLuint(program), C.GLuint(shader)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilMaskSeparate.xml +func (gl *GL) StencilMaskSeparate(face glbase.Enum, mask uint32) { + C.gl4_1core_glStencilMaskSeparate(gl.funcs, C.GLenum(face), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilFuncSeparate.xml +func (gl *GL) StencilFuncSeparate(face, glfunc glbase.Enum, ref int32, mask uint32) { + C.gl4_1core_glStencilFuncSeparate(gl.funcs, C.GLenum(face), C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilOpSeparate.xml +func (gl *GL) StencilOpSeparate(face, sfail, dpfail, dppass glbase.Enum) { + C.gl4_1core_glStencilOpSeparate(gl.funcs, C.GLenum(face), C.GLenum(sfail), C.GLenum(dpfail), C.GLenum(dppass)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawBuffers.xml +func (gl *GL) DrawBuffers(n int, bufs []glbase.Enum) { + C.gl4_1core_glDrawBuffers(gl.funcs, C.GLsizei(n), (*C.GLenum)(unsafe.Pointer(&bufs[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendEquationSeparate.xml +func (gl *GL) BlendEquationSeparate(modeRGB, modeAlpha glbase.Enum) { + C.gl4_1core_glBlendEquationSeparate(gl.funcs, C.GLenum(modeRGB), C.GLenum(modeAlpha)) +} + +// UniformMatrix4x3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4x3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4x3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*3) != 0 { + panic("invalid value length for UniformMatrix4x3fv") + } + count := len(value) / (4 * 3) + C.gl4_1core_glUniformMatrix4x3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3x4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3x4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3x4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*4) != 0 { + panic("invalid value length for UniformMatrix3x4fv") + } + count := len(value) / (3 * 4) + C.gl4_1core_glUniformMatrix3x4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix4x2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4x2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4x2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*2) != 0 { + panic("invalid value length for UniformMatrix4x2fv") + } + count := len(value) / (4 * 2) + C.gl4_1core_glUniformMatrix4x2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2x4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2x4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2x4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*4) != 0 { + panic("invalid value length for UniformMatrix2x4fv") + } + count := len(value) / (2 * 4) + C.gl4_1core_glUniformMatrix2x4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3x2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3x2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3x2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*2) != 0 { + panic("invalid value length for UniformMatrix3x2fv") + } + count := len(value) / (3 * 2) + C.gl4_1core_glUniformMatrix3x2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2x3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2x3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2x3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*3) != 0 { + panic("invalid value length for UniformMatrix2x3fv") + } + count := len(value) / (2 * 3) + C.gl4_1core_glUniformMatrix2x3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsVertexArray.xml +func (gl *GL) IsVertexArray(array uint32) bool { + glresult := C.gl4_1core_glIsVertexArray(gl.funcs, C.GLuint(array)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenVertexArrays.xml +func (gl *GL) GenVertexArrays(n int, arrays []uint32) { + C.gl4_1core_glGenVertexArrays(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&arrays[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteVertexArrays.xml +func (gl *GL) DeleteVertexArrays(n int, arrays []uint32) { + C.gl4_1core_glDeleteVertexArrays(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&arrays[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindVertexArray.xml +func (gl *GL) BindVertexArray(array uint32) { + C.gl4_1core_glBindVertexArray(gl.funcs, C.GLuint(array)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFlushMappedBufferRange.xml +func (gl *GL) FlushMappedBufferRange(target glbase.Enum, offset, length int) { + C.gl4_1core_glFlushMappedBufferRange(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(length)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTextureLayer.xml +func (gl *GL) FramebufferTextureLayer(target, attachment glbase.Enum, texture glbase.Texture, level int, layer int32) { + C.gl4_1core_glFramebufferTextureLayer(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLuint(texture), C.GLint(level), C.GLint(layer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRenderbufferStorageMultisample.xml +func (gl *GL) RenderbufferStorageMultisample(target glbase.Enum, samples int32, internalFormat glbase.Enum, width, height int) { + C.gl4_1core_glRenderbufferStorageMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlitFramebuffer.xml +func (gl *GL) BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1 int32, mask glbase.Bitfield, filter glbase.Enum) { + C.gl4_1core_glBlitFramebuffer(gl.funcs, C.GLint(srcX0), C.GLint(srcY0), C.GLint(srcX1), C.GLint(srcY1), C.GLint(dstX0), C.GLint(dstY0), C.GLint(dstX1), C.GLint(dstY1), C.GLbitfield(mask), C.GLenum(filter)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenerateMipmap.xml +func (gl *GL) GenerateMipmap(target glbase.Enum) { + C.gl4_1core_glGenerateMipmap(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFramebufferAttachmentParameteriv.xml +func (gl *GL) GetFramebufferAttachmentParameteriv(target, attachment, pname glbase.Enum, params []int32) { + C.gl4_1core_glGetFramebufferAttachmentParameteriv(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferRenderbuffer.xml +func (gl *GL) FramebufferRenderbuffer(target, attachment, renderbuffertarget glbase.Enum, renderbuffer glbase.Renderbuffer) { + C.gl4_1core_glFramebufferRenderbuffer(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(renderbuffertarget), C.GLuint(renderbuffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture3D.xml +func (gl *GL) FramebufferTexture3D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int, zoffset int32) { + C.gl4_1core_glFramebufferTexture3D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level), C.GLint(zoffset)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture2D.xml +func (gl *GL) FramebufferTexture2D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int) { + C.gl4_1core_glFramebufferTexture2D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture1D.xml +func (gl *GL) FramebufferTexture1D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int) { + C.gl4_1core_glFramebufferTexture1D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCheckFramebufferStatus.xml +func (gl *GL) CheckFramebufferStatus(target glbase.Enum) glbase.Enum { + glresult := C.gl4_1core_glCheckFramebufferStatus(gl.funcs, C.GLenum(target)) + return glbase.Enum(glresult) +} + +// GenFramebuffers returns n framebuffer object names in ids. There is no +// guarantee that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenFramebuffers. +// +// Framebuffer object names returned by a call to GenFramebuffers are not +// returned by subsequent calls, unless they are first deleted with +// DeleteFramebuffers. +// +// The names returned in ids are marked as used, for the purposes of +// GenFramebuffers only, but they acquire state and type only when they are +// first bound. +// +// Error GL.INVALID_VALUE is generated if n is negative. +func (gl *GL) GenFramebuffers(n int) []glbase.Framebuffer { + if n == 0 { + return nil + } + framebuffers := make([]glbase.Framebuffer, n) + C.gl4_1core_glGenFramebuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&framebuffers[0]))) + return framebuffers +} + +// DeleteFramebuffers deletes the framebuffer objects whose names are +// stored in the framebuffers slice. The name zero is reserved by the GL and +// is silently ignored, should it occur in framebuffers, as are other unused +// names. Once a framebuffer object is deleted, its name is again unused and +// it has no attachments. If a framebuffer that is currently bound to one or +// more of the targets GL.DRAW_FRAMEBUFFER or GL.READ_FRAMEBUFFER is deleted, +// it is as though BindFramebuffer had been executed with the corresponding +// target and framebuffer zero. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteFramebuffers is available in GL version 3.0 or greater. +func (gl *GL) DeleteFramebuffers(framebuffers []glbase.Framebuffer) { + n := len(framebuffers) + if n == 0 { + return + } + C.gl4_1core_glDeleteFramebuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&framebuffers[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindFramebuffer.xml +func (gl *GL) BindFramebuffer(target glbase.Enum, framebuffer glbase.Framebuffer) { + C.gl4_1core_glBindFramebuffer(gl.funcs, C.GLenum(target), C.GLuint(framebuffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsFramebuffer.xml +func (gl *GL) IsFramebuffer(framebuffer glbase.Framebuffer) bool { + glresult := C.gl4_1core_glIsFramebuffer(gl.funcs, C.GLuint(framebuffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetRenderbufferParameteriv.xml +func (gl *GL) GetRenderbufferParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_1core_glGetRenderbufferParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRenderbufferStorage.xml +func (gl *GL) RenderbufferStorage(target, internalFormat glbase.Enum, width, height int) { + C.gl4_1core_glRenderbufferStorage(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) +} + +// GenRenderbuffers returns n renderbuffer object names in renderbuffers. +// There is no guarantee that the names form a contiguous set of integers; +// however, it is guaranteed that none of the returned names was in use +// immediately before the call to GenRenderbuffers. +// +// Renderbuffer object names returned by a call to GenRenderbuffers are not +// returned by subsequent calls, unless they are first deleted with +// DeleteRenderbuffers. +// +// The names returned in renderbuffers are marked as used, for the purposes +// of GenRenderbuffers only, but they acquire state and type only when they +// are first bound. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenRenderbuffers is available in GL version 3.0 or greater. +func (gl *GL) GenRenderbuffers(n int) []glbase.Renderbuffer { + if n == 0 { + return nil + } + renderbuffers := make([]glbase.Renderbuffer, n) + C.gl4_1core_glGenRenderbuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&renderbuffers[0]))) + return renderbuffers +} + +// DeleteRenderbuffers deletes the renderbuffer objects whose names are stored +// in the renderbuffers slice. The name zero is reserved by the GL and +// is silently ignored, should it occur in renderbuffers, as are other unused +// names. Once a renderbuffer object is deleted, its name is again unused and +// it has no contents. If a renderbuffer that is currently bound to the +// target GL.RENDERBUFFER is deleted, it is as though BindRenderbuffer had +// been executed with a target of GL.RENDERBUFFER and a name of zero. +// +// If a renderbuffer object is attached to one or more attachment points in +// the currently bound framebuffer, then it as if FramebufferRenderbuffer +// had been called, with a renderbuffer of zero for each attachment point to +// which this image was attached in the currently bound framebuffer. In other +// words, this renderbuffer object is first detached from all attachment +// ponits in the currently bound framebuffer. Note that the renderbuffer +// image is specifically not detached from any non-bound framebuffers. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteRenderbuffers is available in GL version 3.0 or greater. +func (gl *GL) DeleteRenderbuffers(renderbuffers []glbase.Renderbuffer) { + n := len(renderbuffers) + if n == 0 { + return + } + C.gl4_1core_glDeleteRenderbuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&renderbuffers[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindRenderbuffer.xml +func (gl *GL) BindRenderbuffer(target glbase.Enum, renderbuffer glbase.Renderbuffer) { + C.gl4_1core_glBindRenderbuffer(gl.funcs, C.GLenum(target), C.GLuint(renderbuffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsRenderbuffer.xml +func (gl *GL) IsRenderbuffer(renderbuffer glbase.Renderbuffer) bool { + glresult := C.gl4_1core_glIsRenderbuffer(gl.funcs, C.GLuint(renderbuffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferfi.xml +func (gl *GL) ClearBufferfi(buffer glbase.Enum, drawbuffer int32, depth float32, stencil int32) { + C.gl4_1core_glClearBufferfi(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), C.GLfloat(depth), C.GLint(stencil)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferfv.xml +func (gl *GL) ClearBufferfv(buffer glbase.Enum, drawbuffer int32, value []float32) { + C.gl4_1core_glClearBufferfv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferuiv.xml +func (gl *GL) ClearBufferuiv(buffer glbase.Enum, drawbuffer int32, value []uint32) { + C.gl4_1core_glClearBufferuiv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferiv.xml +func (gl *GL) ClearBufferiv(buffer glbase.Enum, drawbuffer int32, value []int32) { + C.gl4_1core_glClearBufferiv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameterIuiv.xml +func (gl *GL) GetTexParameterIuiv(target, pname glbase.Enum, params []uint32) { + C.gl4_1core_glGetTexParameterIuiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameterIiv.xml +func (gl *GL) GetTexParameterIiv(target, pname glbase.Enum, params []int32) { + C.gl4_1core_glGetTexParameterIiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterIuiv.xml +func (gl *GL) TexParameterIuiv(target, pname glbase.Enum, params []uint32) { + C.gl4_1core_glTexParameterIuiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterIiv.xml +func (gl *GL) TexParameterIiv(target, pname glbase.Enum, params []int32) { + C.gl4_1core_glTexParameterIiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// Uniform4uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4uiv") + } + count := len(value) / 4 + C.gl4_1core_glUniform4uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform3uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3uiv") + } + count := len(value) / 3 + C.gl4_1core_glUniform3uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform2uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2uiv") + } + count := len(value) / 2 + C.gl4_1core_glUniform2uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform1uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl4_1core_glUniform1uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform4ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4ui(location glbase.Uniform, v0, v1, v2, v3 uint32) { + C.gl4_1core_glUniform4ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2), C.GLuint(v3)) +} + +// Uniform3ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3ui(location glbase.Uniform, v0, v1, v2 uint32) { + C.gl4_1core_glUniform3ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2)) +} + +// Uniform2ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2ui(location glbase.Uniform, v0, v1 uint32) { + C.gl4_1core_glUniform2ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1)) +} + +// Uniform1ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1ui(location glbase.Uniform, v0 uint32) { + C.gl4_1core_glUniform1ui(gl.funcs, C.GLint(location), C.GLuint(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFragDataLocation.xml +func (gl *GL) GetFragDataLocation(program glbase.Program, name []byte) int32 { + glresult := C.gl4_1core_glGetFragDataLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindFragDataLocation.xml +func (gl *GL) BindFragDataLocation(program glbase.Program, color uint32, name []byte) { + C.gl4_1core_glBindFragDataLocation(gl.funcs, C.GLuint(program), C.GLuint(color), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetUniformuiv.xml +func (gl *GL) GetUniformuiv(program glbase.Program, location glbase.Uniform, params []uint32) { + C.gl4_1core_glGetUniformuiv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetVertexAttribIuiv.xml +func (gl *GL) GetVertexAttribIuiv(index glbase.Attrib, pname glbase.Enum, params []uint32) { + C.gl4_1core_glGetVertexAttribIuiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetVertexAttribIiv.xml +func (gl *GL) GetVertexAttribIiv(index glbase.Attrib, pname glbase.Enum, params []int32) { + C.gl4_1core_glGetVertexAttribIiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribIPointer.xml +func (gl *GL) VertexAttribIPointer(index glbase.Attrib, size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_1core_glVertexAttribIPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndConditionalRender.xml +func (gl *GL) EndConditionalRender() { + C.gl4_1core_glEndConditionalRender(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBeginConditionalRender.xml +func (gl *GL) BeginConditionalRender(id uint32, mode glbase.Enum) { + C.gl4_1core_glBeginConditionalRender(gl.funcs, C.GLuint(id), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClampColor.xml +func (gl *GL) ClampColor(target, clamp glbase.Enum) { + C.gl4_1core_glClampColor(gl.funcs, C.GLenum(target), C.GLenum(clamp)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTransformFeedbackVarying.xml +func (gl *GL) GetTransformFeedbackVarying(program glbase.Program, index uint32, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl4_1core_glGetTransformFeedbackVarying(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLsizei)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindBufferBase.xml +func (gl *GL) BindBufferBase(target glbase.Enum, index uint32, buffer glbase.Buffer) { + C.gl4_1core_glBindBufferBase(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindBufferRange.xml +func (gl *GL) BindBufferRange(target glbase.Enum, index uint32, buffer glbase.Buffer, offset, size int) { + C.gl4_1core_glBindBufferRange(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(buffer), C.GLintptr(offset), C.GLsizeiptr(size)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndTransformFeedback.xml +func (gl *GL) EndTransformFeedback() { + C.gl4_1core_glEndTransformFeedback(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBeginTransformFeedback.xml +func (gl *GL) BeginTransformFeedback(primitiveMode glbase.Enum) { + C.gl4_1core_glBeginTransformFeedback(gl.funcs, C.GLenum(primitiveMode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsEnabledi.xml +func (gl *GL) IsEnabledi(target glbase.Enum, index uint32) bool { + glresult := C.gl4_1core_glIsEnabledi(gl.funcs, C.GLenum(target), C.GLuint(index)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDisablei.xml +func (gl *GL) Disablei(target glbase.Enum, index uint32) { + C.gl4_1core_glDisablei(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEnablei.xml +func (gl *GL) Enablei(target glbase.Enum, index uint32) { + C.gl4_1core_glEnablei(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetIntegeri_v.xml +func (gl *GL) GetIntegeri_v(target glbase.Enum, index uint32, data []int32) { + C.gl4_1core_glGetIntegeri_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLint)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBooleani_v.xml +func (gl *GL) GetBooleani_v(target glbase.Enum, index uint32, data []bool) { + C.gl4_1core_glGetBooleani_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLboolean)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorMaski.xml +func (gl *GL) ColorMaski(index uint32, r, g, b, a bool) { + C.gl4_1core_glColorMaski(gl.funcs, C.GLuint(index), *(*C.GLboolean)(unsafe.Pointer(&r)), *(*C.GLboolean)(unsafe.Pointer(&g)), *(*C.GLboolean)(unsafe.Pointer(&b)), *(*C.GLboolean)(unsafe.Pointer(&a))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyBufferSubData.xml +func (gl *GL) CopyBufferSubData(readTarget, writeTarget glbase.Enum, readOffset, writeOffset, size int) { + C.gl4_1core_glCopyBufferSubData(gl.funcs, C.GLenum(readTarget), C.GLenum(writeTarget), C.GLintptr(readOffset), C.GLintptr(writeOffset), C.GLsizeiptr(size)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformBlockBinding.xml +func (gl *GL) UniformBlockBinding(program glbase.Program, v0, v1 uint32) { + C.gl4_1core_glUniformBlockBinding(gl.funcs, C.GLuint(program), C.GLuint(v0), C.GLuint(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformBlockName.xml +func (gl *GL) GetActiveUniformBlockName(program glbase.Program, uniformBlockIndex uint32, bufSize int32, length []int32, uniformBlockName []byte) { + C.gl4_1core_glGetActiveUniformBlockName(gl.funcs, C.GLuint(program), C.GLuint(uniformBlockIndex), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&uniformBlockName[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformBlockiv.xml +func (gl *GL) GetActiveUniformBlockiv(program glbase.Program, uniformBlockIndex uint32, pname glbase.Enum, params []int32) { + C.gl4_1core_glGetActiveUniformBlockiv(gl.funcs, C.GLuint(program), C.GLuint(uniformBlockIndex), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetUniformBlockIndex.xml +func (gl *GL) GetUniformBlockIndex(program glbase.Program, uniformBlockName []byte) uint32 { + glresult := C.gl4_1core_glGetUniformBlockIndex(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&uniformBlockName[0]))) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformName.xml +func (gl *GL) GetActiveUniformName(program glbase.Program, uniformIndex uint32, bufSize int32, length []int32, uniformName []byte) { + C.gl4_1core_glGetActiveUniformName(gl.funcs, C.GLuint(program), C.GLuint(uniformIndex), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&uniformName[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformsiv.xml +func (gl *GL) GetActiveUniformsiv(program glbase.Program, uniformCount int32, uniformIndices []uint32, pname glbase.Enum, params []int32) { + C.gl4_1core_glGetActiveUniformsiv(gl.funcs, C.GLuint(program), C.GLsizei(uniformCount), (*C.GLuint)(unsafe.Pointer(&uniformIndices[0])), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPrimitiveRestartIndex.xml +func (gl *GL) PrimitiveRestartIndex(index uint32) { + C.gl4_1core_glPrimitiveRestartIndex(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexBuffer.xml +func (gl *GL) TexBuffer(target, internalFormat glbase.Enum, buffer glbase.Buffer) { + C.gl4_1core_glTexBuffer(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsInstanced.xml +func (gl *GL) DrawElementsInstanced(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, instancecount int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_1core_glDrawElementsInstanced(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLsizei(instancecount)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawArraysInstanced.xml +func (gl *GL) DrawArraysInstanced(mode glbase.Enum, first, count int, instancecount int32) { + C.gl4_1core_glDrawArraysInstanced(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count), C.GLsizei(instancecount)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSampleMaski.xml +func (gl *GL) SampleMaski(index uint32, mask glbase.Bitfield) { + C.gl4_1core_glSampleMaski(gl.funcs, C.GLuint(index), C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMultisamplefv.xml +func (gl *GL) GetMultisamplefv(pname glbase.Enum, index uint32, val []float32) { + C.gl4_1core_glGetMultisamplefv(gl.funcs, C.GLenum(pname), C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&val[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage3DMultisample.xml +func (gl *GL) TexImage3DMultisample(target glbase.Enum, samples, internalFormat int32, width, height int, depth int32, fixedsamplelocations bool) { + C.gl4_1core_glTexImage3DMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), *(*C.GLboolean)(unsafe.Pointer(&fixedsamplelocations))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage2DMultisample.xml +func (gl *GL) TexImage2DMultisample(target glbase.Enum, samples, internalFormat int32, width, height int, fixedsamplelocations bool) { + C.gl4_1core_glTexImage2DMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), *(*C.GLboolean)(unsafe.Pointer(&fixedsamplelocations))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSynciv.xml +func (gl *GL) GetSynciv(sync glbase.Sync, pname glbase.Enum, bufSize int32, length, values []int32) { + C.gl4_1core_glGetSynciv(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLenum(pname), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetInteger64v.xml +func (gl *GL) GetInteger64v(pname glbase.Enum, params []int64) { + C.gl4_1core_glGetInteger64v(gl.funcs, C.GLenum(pname), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWaitSync.xml +func (gl *GL) WaitSync(sync glbase.Sync, flags glbase.Bitfield, timeout uint64) { + C.gl4_1core_glWaitSync(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLbitfield(flags), C.GLuint64(timeout)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClientWaitSync.xml +func (gl *GL) ClientWaitSync(sync glbase.Sync, flags glbase.Bitfield, timeout uint64) glbase.Enum { + glresult := C.gl4_1core_glClientWaitSync(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLbitfield(flags), C.GLuint64(timeout)) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteSync.xml +func (gl *GL) DeleteSync(sync glbase.Sync) { + C.gl4_1core_glDeleteSync(gl.funcs, C.GLsync(unsafe.Pointer(sync))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsSync.xml +func (gl *GL) IsSync(sync glbase.Sync) bool { + glresult := C.gl4_1core_glIsSync(gl.funcs, C.GLsync(unsafe.Pointer(sync))) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFenceSync.xml +func (gl *GL) FenceSync(condition glbase.Enum, flags glbase.Bitfield) glbase.Sync { + glresult := C.gl4_1core_glFenceSync(gl.funcs, C.GLenum(condition), C.GLbitfield(flags)) + return glbase.Sync(unsafe.Pointer(glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProvokingVertex.xml +func (gl *GL) ProvokingVertex(mode glbase.Enum) { + C.gl4_1core_glProvokingVertex(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsInstancedBaseVertex.xml +func (gl *GL) DrawElementsInstancedBaseVertex(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, instancecount, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_1core_glDrawElementsInstancedBaseVertex(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLsizei(instancecount), C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawRangeElementsBaseVertex.xml +func (gl *GL) DrawRangeElementsBaseVertex(mode glbase.Enum, start, end uint32, count int, gltype glbase.Enum, indices interface{}, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_1core_glDrawRangeElementsBaseVertex(gl.funcs, C.GLenum(mode), C.GLuint(start), C.GLuint(end), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsBaseVertex.xml +func (gl *GL) DrawElementsBaseVertex(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_1core_glDrawElementsBaseVertex(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture.xml +func (gl *GL) FramebufferTexture(target, attachment glbase.Enum, texture glbase.Texture, level int) { + C.gl4_1core_glFramebufferTexture(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBufferParameteri64v.xml +func (gl *GL) GetBufferParameteri64v(target, pname glbase.Enum, params []int64) { + C.gl4_1core_glGetBufferParameteri64v(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetInteger64i_v.xml +func (gl *GL) GetInteger64i_v(target glbase.Enum, index uint32, data []int64) { + C.gl4_1core_glGetInteger64i_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLint64)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP4uiv.xml +func (gl *GL) VertexAttribP4uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl4_1core_glVertexAttribP4uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP4ui.xml +func (gl *GL) VertexAttribP4ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl4_1core_glVertexAttribP4ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP3uiv.xml +func (gl *GL) VertexAttribP3uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl4_1core_glVertexAttribP3uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP3ui.xml +func (gl *GL) VertexAttribP3ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl4_1core_glVertexAttribP3ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP2uiv.xml +func (gl *GL) VertexAttribP2uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl4_1core_glVertexAttribP2uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP2ui.xml +func (gl *GL) VertexAttribP2ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl4_1core_glVertexAttribP2ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP1uiv.xml +func (gl *GL) VertexAttribP1uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl4_1core_glVertexAttribP1uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP1ui.xml +func (gl *GL) VertexAttribP1ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl4_1core_glVertexAttribP1ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColorP3uiv.xml +func (gl *GL) SecondaryColorP3uiv(gltype glbase.Enum, color []uint32) { + C.gl4_1core_glSecondaryColorP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&color[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColorP3ui.xml +func (gl *GL) SecondaryColorP3ui(gltype glbase.Enum, color uint32) { + C.gl4_1core_glSecondaryColorP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(color)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorP4uiv.xml +func (gl *GL) ColorP4uiv(gltype glbase.Enum, color []uint32) { + C.gl4_1core_glColorP4uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&color[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorP4ui.xml +func (gl *GL) ColorP4ui(gltype glbase.Enum, color uint32) { + C.gl4_1core_glColorP4ui(gl.funcs, C.GLenum(gltype), C.GLuint(color)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorP3uiv.xml +func (gl *GL) ColorP3uiv(gltype glbase.Enum, color []uint32) { + C.gl4_1core_glColorP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&color[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorP3ui.xml +func (gl *GL) ColorP3ui(gltype glbase.Enum, color uint32) { + C.gl4_1core_glColorP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(color)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormalP3uiv.xml +func (gl *GL) NormalP3uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_1core_glNormalP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormalP3ui.xml +func (gl *GL) NormalP3ui(gltype glbase.Enum, coords uint32) { + C.gl4_1core_glNormalP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP4uiv.xml +func (gl *GL) MultiTexCoordP4uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl4_1core_glMultiTexCoordP4uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP4ui.xml +func (gl *GL) MultiTexCoordP4ui(texture, gltype glbase.Enum, coords uint32) { + C.gl4_1core_glMultiTexCoordP4ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP3uiv.xml +func (gl *GL) MultiTexCoordP3uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl4_1core_glMultiTexCoordP3uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP3ui.xml +func (gl *GL) MultiTexCoordP3ui(texture, gltype glbase.Enum, coords uint32) { + C.gl4_1core_glMultiTexCoordP3ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP2uiv.xml +func (gl *GL) MultiTexCoordP2uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl4_1core_glMultiTexCoordP2uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP2ui.xml +func (gl *GL) MultiTexCoordP2ui(texture, gltype glbase.Enum, coords uint32) { + C.gl4_1core_glMultiTexCoordP2ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP1uiv.xml +func (gl *GL) MultiTexCoordP1uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl4_1core_glMultiTexCoordP1uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP1ui.xml +func (gl *GL) MultiTexCoordP1ui(texture, gltype glbase.Enum, coords uint32) { + C.gl4_1core_glMultiTexCoordP1ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP4uiv.xml +func (gl *GL) TexCoordP4uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_1core_glTexCoordP4uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP4ui.xml +func (gl *GL) TexCoordP4ui(gltype glbase.Enum, coords uint32) { + C.gl4_1core_glTexCoordP4ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP3uiv.xml +func (gl *GL) TexCoordP3uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_1core_glTexCoordP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP3ui.xml +func (gl *GL) TexCoordP3ui(gltype glbase.Enum, coords uint32) { + C.gl4_1core_glTexCoordP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP2uiv.xml +func (gl *GL) TexCoordP2uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_1core_glTexCoordP2uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP2ui.xml +func (gl *GL) TexCoordP2ui(gltype glbase.Enum, coords uint32) { + C.gl4_1core_glTexCoordP2ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP1uiv.xml +func (gl *GL) TexCoordP1uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_1core_glTexCoordP1uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP1ui.xml +func (gl *GL) TexCoordP1ui(gltype glbase.Enum, coords uint32) { + C.gl4_1core_glTexCoordP1ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP4uiv.xml +func (gl *GL) VertexP4uiv(gltype glbase.Enum, value []uint32) { + C.gl4_1core_glVertexP4uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP4ui.xml +func (gl *GL) VertexP4ui(gltype glbase.Enum, value uint32) { + C.gl4_1core_glVertexP4ui(gl.funcs, C.GLenum(gltype), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP3uiv.xml +func (gl *GL) VertexP3uiv(gltype glbase.Enum, value []uint32) { + C.gl4_1core_glVertexP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP3ui.xml +func (gl *GL) VertexP3ui(gltype glbase.Enum, value uint32) { + C.gl4_1core_glVertexP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP2uiv.xml +func (gl *GL) VertexP2uiv(gltype glbase.Enum, value []uint32) { + C.gl4_1core_glVertexP2uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP2ui.xml +func (gl *GL) VertexP2ui(gltype glbase.Enum, value uint32) { + C.gl4_1core_glVertexP2ui(gl.funcs, C.GLenum(gltype), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryObjectui64v.xml +func (gl *GL) GetQueryObjectui64v(id uint32, pname glbase.Enum, params []uint64) { + C.gl4_1core_glGetQueryObjectui64v(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLuint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryObjecti64v.xml +func (gl *GL) GetQueryObjecti64v(id uint32, pname glbase.Enum, params []int64) { + C.gl4_1core_glGetQueryObjecti64v(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glQueryCounter.xml +func (gl *GL) QueryCounter(id uint32, target glbase.Enum) { + C.gl4_1core_glQueryCounter(gl.funcs, C.GLuint(id), C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSamplerParameterIuiv.xml +func (gl *GL) GetSamplerParameterIuiv(sampler uint32, pname glbase.Enum, params []uint32) { + C.gl4_1core_glGetSamplerParameterIuiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSamplerParameterfv.xml +func (gl *GL) GetSamplerParameterfv(sampler uint32, pname glbase.Enum, params []float32) { + C.gl4_1core_glGetSamplerParameterfv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSamplerParameterIiv.xml +func (gl *GL) GetSamplerParameterIiv(sampler uint32, pname glbase.Enum, params []int32) { + C.gl4_1core_glGetSamplerParameterIiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSamplerParameteriv.xml +func (gl *GL) GetSamplerParameteriv(sampler uint32, pname glbase.Enum, params []int32) { + C.gl4_1core_glGetSamplerParameteriv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameterIuiv.xml +func (gl *GL) SamplerParameterIuiv(sampler uint32, pname glbase.Enum, param []uint32) { + C.gl4_1core_glSamplerParameterIuiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameterIiv.xml +func (gl *GL) SamplerParameterIiv(sampler uint32, pname glbase.Enum, param []int32) { + C.gl4_1core_glSamplerParameterIiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameterfv.xml +func (gl *GL) SamplerParameterfv(sampler uint32, pname glbase.Enum, param []float32) { + C.gl4_1core_glSamplerParameterfv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameterf.xml +func (gl *GL) SamplerParameterf(sampler uint32, pname glbase.Enum, param float32) { + C.gl4_1core_glSamplerParameterf(gl.funcs, C.GLuint(sampler), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameteriv.xml +func (gl *GL) SamplerParameteriv(sampler uint32, pname glbase.Enum, param []int32) { + C.gl4_1core_glSamplerParameteriv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameteri.xml +func (gl *GL) SamplerParameteri(sampler uint32, pname glbase.Enum, param int32) { + C.gl4_1core_glSamplerParameteri(gl.funcs, C.GLuint(sampler), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindSampler.xml +func (gl *GL) BindSampler(unit, sampler uint32) { + C.gl4_1core_glBindSampler(gl.funcs, C.GLuint(unit), C.GLuint(sampler)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsSampler.xml +func (gl *GL) IsSampler(sampler uint32) bool { + glresult := C.gl4_1core_glIsSampler(gl.funcs, C.GLuint(sampler)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteSamplers.xml +func (gl *GL) DeleteSamplers(count int, samplers []uint32) { + C.gl4_1core_glDeleteSamplers(gl.funcs, C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&samplers[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenSamplers.xml +func (gl *GL) GenSamplers(count int, samplers []uint32) { + C.gl4_1core_glGenSamplers(gl.funcs, C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&samplers[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFragDataIndex.xml +func (gl *GL) GetFragDataIndex(program glbase.Program, name []byte) int32 { + glresult := C.gl4_1core_glGetFragDataIndex(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindFragDataLocationIndexed.xml +func (gl *GL) BindFragDataLocationIndexed(program glbase.Program, colorNumber, index uint32, name []byte) { + C.gl4_1core_glBindFragDataLocationIndexed(gl.funcs, C.GLuint(program), C.GLuint(colorNumber), C.GLuint(index), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribDivisor.xml +func (gl *GL) VertexAttribDivisor(index glbase.Attrib, divisor uint32) { + C.gl4_1core_glVertexAttribDivisor(gl.funcs, C.GLuint(index), C.GLuint(divisor)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryIndexediv.xml +func (gl *GL) GetQueryIndexediv(target glbase.Enum, index uint32, pname glbase.Enum, params []int32) { + C.gl4_1core_glGetQueryIndexediv(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndQueryIndexed.xml +func (gl *GL) EndQueryIndexed(target glbase.Enum, index uint32) { + C.gl4_1core_glEndQueryIndexed(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBeginQueryIndexed.xml +func (gl *GL) BeginQueryIndexed(target glbase.Enum, index, id uint32) { + C.gl4_1core_glBeginQueryIndexed(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawTransformFeedbackStream.xml +func (gl *GL) DrawTransformFeedbackStream(mode glbase.Enum, id, stream uint32) { + C.gl4_1core_glDrawTransformFeedbackStream(gl.funcs, C.GLenum(mode), C.GLuint(id), C.GLuint(stream)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawTransformFeedback.xml +func (gl *GL) DrawTransformFeedback(mode glbase.Enum, id uint32) { + C.gl4_1core_glDrawTransformFeedback(gl.funcs, C.GLenum(mode), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glResumeTransformFeedback.xml +func (gl *GL) ResumeTransformFeedback() { + C.gl4_1core_glResumeTransformFeedback(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPauseTransformFeedback.xml +func (gl *GL) PauseTransformFeedback() { + C.gl4_1core_glPauseTransformFeedback(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsTransformFeedback.xml +func (gl *GL) IsTransformFeedback(id uint32) bool { + glresult := C.gl4_1core_glIsTransformFeedback(gl.funcs, C.GLuint(id)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenTransformFeedbacks.xml +func (gl *GL) GenTransformFeedbacks(n int, ids []uint32) { + C.gl4_1core_glGenTransformFeedbacks(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteTransformFeedbacks.xml +func (gl *GL) DeleteTransformFeedbacks(n int, ids []uint32) { + C.gl4_1core_glDeleteTransformFeedbacks(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindTransformFeedback.xml +func (gl *GL) BindTransformFeedback(target glbase.Enum, id uint32) { + C.gl4_1core_glBindTransformFeedback(gl.funcs, C.GLenum(target), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPatchParameterfv.xml +func (gl *GL) PatchParameterfv(pname glbase.Enum, values []float32) { + C.gl4_1core_glPatchParameterfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPatchParameteri.xml +func (gl *GL) PatchParameteri(pname glbase.Enum, value int32) { + C.gl4_1core_glPatchParameteri(gl.funcs, C.GLenum(pname), C.GLint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramStageiv.xml +func (gl *GL) GetProgramStageiv(program glbase.Program, shadertype, pname glbase.Enum, values []int32) { + C.gl4_1core_glGetProgramStageiv(gl.funcs, C.GLuint(program), C.GLenum(shadertype), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetUniformSubroutineuiv.xml +func (gl *GL) GetUniformSubroutineuiv(shadertype glbase.Enum, location glbase.Uniform, params []uint32) { + C.gl4_1core_glGetUniformSubroutineuiv(gl.funcs, C.GLenum(shadertype), C.GLint(location), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformSubroutinesuiv.xml +func (gl *GL) UniformSubroutinesuiv(shadertype glbase.Enum, count int, value []uint32) { + C.gl4_1core_glUniformSubroutinesuiv(gl.funcs, C.GLenum(shadertype), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveSubroutineName.xml +func (gl *GL) GetActiveSubroutineName(program glbase.Program, shadertype glbase.Enum, index uint32, bufSize int32, length []int32, name []byte) { + C.gl4_1core_glGetActiveSubroutineName(gl.funcs, C.GLuint(program), C.GLenum(shadertype), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveSubroutineUniformName.xml +func (gl *GL) GetActiveSubroutineUniformName(program glbase.Program, shadertype glbase.Enum, index uint32, bufSize int32, length []int32, name []byte) { + C.gl4_1core_glGetActiveSubroutineUniformName(gl.funcs, C.GLuint(program), C.GLenum(shadertype), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveSubroutineUniformiv.xml +func (gl *GL) GetActiveSubroutineUniformiv(program glbase.Program, shadertype glbase.Enum, index uint32, pname glbase.Enum, values []int32) { + C.gl4_1core_glGetActiveSubroutineUniformiv(gl.funcs, C.GLuint(program), C.GLenum(shadertype), C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSubroutineIndex.xml +func (gl *GL) GetSubroutineIndex(program glbase.Program, shadertype glbase.Enum, name []byte) uint32 { + glresult := C.gl4_1core_glGetSubroutineIndex(gl.funcs, C.GLuint(program), C.GLenum(shadertype), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSubroutineUniformLocation.xml +func (gl *GL) GetSubroutineUniformLocation(program glbase.Program, shadertype glbase.Enum, name []byte) int32 { + glresult := C.gl4_1core_glGetSubroutineUniformLocation(gl.funcs, C.GLuint(program), C.GLenum(shadertype), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetUniformdv.xml +func (gl *GL) GetUniformdv(program glbase.Program, location glbase.Uniform, params []float64) { + C.gl4_1core_glGetUniformdv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix4x3dv.xml +func (gl *GL) UniformMatrix4x3dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_1core_glUniformMatrix4x3dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix4x2dv.xml +func (gl *GL) UniformMatrix4x2dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_1core_glUniformMatrix4x2dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix3x4dv.xml +func (gl *GL) UniformMatrix3x4dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_1core_glUniformMatrix3x4dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix3x2dv.xml +func (gl *GL) UniformMatrix3x2dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_1core_glUniformMatrix3x2dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix2x4dv.xml +func (gl *GL) UniformMatrix2x4dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_1core_glUniformMatrix2x4dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix2x3dv.xml +func (gl *GL) UniformMatrix2x3dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_1core_glUniformMatrix2x3dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix4dv.xml +func (gl *GL) UniformMatrix4dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_1core_glUniformMatrix4dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix3dv.xml +func (gl *GL) UniformMatrix3dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_1core_glUniformMatrix3dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix2dv.xml +func (gl *GL) UniformMatrix2dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_1core_glUniformMatrix2dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform4dv.xml +func (gl *GL) Uniform4dv(location glbase.Uniform, count int, value []float64) { + C.gl4_1core_glUniform4dv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform3dv.xml +func (gl *GL) Uniform3dv(location glbase.Uniform, count int, value []float64) { + C.gl4_1core_glUniform3dv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform2dv.xml +func (gl *GL) Uniform2dv(location glbase.Uniform, count int, value []float64) { + C.gl4_1core_glUniform2dv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform1dv.xml +func (gl *GL) Uniform1dv(location glbase.Uniform, count int, value []float64) { + C.gl4_1core_glUniform1dv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform4d.xml +func (gl *GL) Uniform4d(location glbase.Uniform, v0, v1, v2, v3 float64) { + C.gl4_1core_glUniform4d(gl.funcs, C.GLint(location), C.GLdouble(v0), C.GLdouble(v1), C.GLdouble(v2), C.GLdouble(v3)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform3d.xml +func (gl *GL) Uniform3d(location glbase.Uniform, v0, v1, v2 float64) { + C.gl4_1core_glUniform3d(gl.funcs, C.GLint(location), C.GLdouble(v0), C.GLdouble(v1), C.GLdouble(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform2d.xml +func (gl *GL) Uniform2d(location glbase.Uniform, v0, v1 float64) { + C.gl4_1core_glUniform2d(gl.funcs, C.GLint(location), C.GLdouble(v0), C.GLdouble(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform1d.xml +func (gl *GL) Uniform1d(location glbase.Uniform, v0 float64) { + C.gl4_1core_glUniform1d(gl.funcs, C.GLint(location), C.GLdouble(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsIndirect.xml +func (gl *GL) DrawElementsIndirect(mode, gltype glbase.Enum, indirect interface{}) { + var indirect_ptr unsafe.Pointer + var indirect_v = reflect.ValueOf(indirect) + if indirect != nil && indirect_v.Kind() != reflect.Slice { + panic("parameter indirect must be a slice") + } + if indirect != nil { + indirect_ptr = unsafe.Pointer(indirect_v.Index(0).Addr().Pointer()) + } + C.gl4_1core_glDrawElementsIndirect(gl.funcs, C.GLenum(mode), C.GLenum(gltype), indirect_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawArraysIndirect.xml +func (gl *GL) DrawArraysIndirect(mode glbase.Enum, indirect interface{}) { + var indirect_ptr unsafe.Pointer + var indirect_v = reflect.ValueOf(indirect) + if indirect != nil && indirect_v.Kind() != reflect.Slice { + panic("parameter indirect must be a slice") + } + if indirect != nil { + indirect_ptr = unsafe.Pointer(indirect_v.Index(0).Addr().Pointer()) + } + C.gl4_1core_glDrawArraysIndirect(gl.funcs, C.GLenum(mode), indirect_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFuncSeparatei.xml +func (gl *GL) BlendFuncSeparatei(buf uint32, srcRGB, dstRGB, srcAlpha, dstAlpha glbase.Enum) { + C.gl4_1core_glBlendFuncSeparatei(gl.funcs, C.GLuint(buf), C.GLenum(srcRGB), C.GLenum(dstRGB), C.GLenum(srcAlpha), C.GLenum(dstAlpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFunci.xml +func (gl *GL) BlendFunci(buf uint32, src, dst glbase.Enum) { + C.gl4_1core_glBlendFunci(gl.funcs, C.GLuint(buf), C.GLenum(src), C.GLenum(dst)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendEquationSeparatei.xml +func (gl *GL) BlendEquationSeparatei(buf uint32, modeRGB, modeAlpha glbase.Enum) { + C.gl4_1core_glBlendEquationSeparatei(gl.funcs, C.GLuint(buf), C.GLenum(modeRGB), C.GLenum(modeAlpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendEquationi.xml +func (gl *GL) BlendEquationi(buf uint32, mode glbase.Enum) { + C.gl4_1core_glBlendEquationi(gl.funcs, C.GLuint(buf), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMinSampleShading.xml +func (gl *GL) MinSampleShading(value float32) { + C.gl4_1core_glMinSampleShading(gl.funcs, C.GLfloat(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetDoublei_v.xml +func (gl *GL) GetDoublei_v(target glbase.Enum, index uint32, data []float64) { + C.gl4_1core_glGetDoublei_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFloati_v.xml +func (gl *GL) GetFloati_v(target glbase.Enum, index uint32, data []float32) { + C.gl4_1core_glGetFloati_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDepthRangeIndexed.xml +func (gl *GL) DepthRangeIndexed(index uint32, n, f float64) { + C.gl4_1core_glDepthRangeIndexed(gl.funcs, C.GLuint(index), C.GLdouble(n), C.GLdouble(f)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDepthRangeArrayv.xml +func (gl *GL) DepthRangeArrayv(first uint32, count int, v []float64) { + C.gl4_1core_glDepthRangeArrayv(gl.funcs, C.GLuint(first), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glScissorIndexedv.xml +func (gl *GL) ScissorIndexedv(index uint32, v []int32) { + C.gl4_1core_glScissorIndexedv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glScissorIndexed.xml +func (gl *GL) ScissorIndexed(index uint32, left, bottom int32, width, height int) { + C.gl4_1core_glScissorIndexed(gl.funcs, C.GLuint(index), C.GLint(left), C.GLint(bottom), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glScissorArrayv.xml +func (gl *GL) ScissorArrayv(first uint32, count int, v []int32) { + C.gl4_1core_glScissorArrayv(gl.funcs, C.GLuint(first), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glViewportIndexedfv.xml +func (gl *GL) ViewportIndexedfv(index uint32, v []float32) { + C.gl4_1core_glViewportIndexedfv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glViewportIndexedf.xml +func (gl *GL) ViewportIndexedf(index uint32, x, y, w, h float32) { + C.gl4_1core_glViewportIndexedf(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y), C.GLfloat(w), C.GLfloat(h)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glViewportArrayv.xml +func (gl *GL) ViewportArrayv(first uint32, count int, v []float32) { + C.gl4_1core_glViewportArrayv(gl.funcs, C.GLuint(first), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetVertexAttribLdv.xml +func (gl *GL) GetVertexAttribLdv(index glbase.Attrib, pname glbase.Enum, params []float64) { + C.gl4_1core_glGetVertexAttribLdv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribLPointer.xml +func (gl *GL) VertexAttribLPointer(index glbase.Attrib, size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_1core_glVertexAttribLPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL4dv.xml +func (gl *GL) VertexAttribL4dv(index glbase.Attrib, v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_1core_glVertexAttribL4dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL3dv.xml +func (gl *GL) VertexAttribL3dv(index glbase.Attrib, v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_1core_glVertexAttribL3dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL2dv.xml +func (gl *GL) VertexAttribL2dv(index glbase.Attrib, v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_1core_glVertexAttribL2dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL1dv.xml +func (gl *GL) VertexAttribL1dv(index glbase.Attrib, v []float64) { + C.gl4_1core_glVertexAttribL1dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL4d.xml +func (gl *GL) VertexAttribL4d(index glbase.Attrib, x, y, z, w float64) { + C.gl4_1core_glVertexAttribL4d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL3d.xml +func (gl *GL) VertexAttribL3d(index glbase.Attrib, x, y, z float64) { + C.gl4_1core_glVertexAttribL3d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL2d.xml +func (gl *GL) VertexAttribL2d(index glbase.Attrib, x, y float64) { + C.gl4_1core_glVertexAttribL2d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL1d.xml +func (gl *GL) VertexAttribL1d(index glbase.Attrib, x float64) { + C.gl4_1core_glVertexAttribL1d(gl.funcs, C.GLuint(index), C.GLdouble(x)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramPipelineInfoLog.xml +func (gl *GL) GetProgramPipelineInfoLog(pipeline uint32, bufSize int32, length []int32, infoLog []byte) { + C.gl4_1core_glGetProgramPipelineInfoLog(gl.funcs, C.GLuint(pipeline), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glValidateProgramPipeline.xml +func (gl *GL) ValidateProgramPipeline(pipeline uint32) { + C.gl4_1core_glValidateProgramPipeline(gl.funcs, C.GLuint(pipeline)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4x3dv.xml +func (gl *GL) ProgramUniformMatrix4x3dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_1core_glProgramUniformMatrix4x3dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3x4dv.xml +func (gl *GL) ProgramUniformMatrix3x4dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_1core_glProgramUniformMatrix3x4dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4x2dv.xml +func (gl *GL) ProgramUniformMatrix4x2dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_1core_glProgramUniformMatrix4x2dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2x4dv.xml +func (gl *GL) ProgramUniformMatrix2x4dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_1core_glProgramUniformMatrix2x4dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3x2dv.xml +func (gl *GL) ProgramUniformMatrix3x2dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_1core_glProgramUniformMatrix3x2dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2x3dv.xml +func (gl *GL) ProgramUniformMatrix2x3dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_1core_glProgramUniformMatrix2x3dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4x3fv.xml +func (gl *GL) ProgramUniformMatrix4x3fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_1core_glProgramUniformMatrix4x3fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3x4fv.xml +func (gl *GL) ProgramUniformMatrix3x4fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_1core_glProgramUniformMatrix3x4fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4x2fv.xml +func (gl *GL) ProgramUniformMatrix4x2fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_1core_glProgramUniformMatrix4x2fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2x4fv.xml +func (gl *GL) ProgramUniformMatrix2x4fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_1core_glProgramUniformMatrix2x4fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3x2fv.xml +func (gl *GL) ProgramUniformMatrix3x2fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_1core_glProgramUniformMatrix3x2fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2x3fv.xml +func (gl *GL) ProgramUniformMatrix2x3fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_1core_glProgramUniformMatrix2x3fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4dv.xml +func (gl *GL) ProgramUniformMatrix4dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_1core_glProgramUniformMatrix4dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3dv.xml +func (gl *GL) ProgramUniformMatrix3dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_1core_glProgramUniformMatrix3dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2dv.xml +func (gl *GL) ProgramUniformMatrix2dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_1core_glProgramUniformMatrix2dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4fv.xml +func (gl *GL) ProgramUniformMatrix4fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_1core_glProgramUniformMatrix4fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3fv.xml +func (gl *GL) ProgramUniformMatrix3fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_1core_glProgramUniformMatrix3fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2fv.xml +func (gl *GL) ProgramUniformMatrix2fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_1core_glProgramUniformMatrix2fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4uiv.xml +func (gl *GL) ProgramUniform4uiv(program glbase.Program, location glbase.Uniform, count int, value []uint32) { + C.gl4_1core_glProgramUniform4uiv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4ui.xml +func (gl *GL) ProgramUniform4ui(program glbase.Program, location glbase.Uniform, v0, v1, v2, v3 uint32) { + C.gl4_1core_glProgramUniform4ui(gl.funcs, C.GLuint(program), C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2), C.GLuint(v3)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4dv.xml +func (gl *GL) ProgramUniform4dv(program glbase.Program, location glbase.Uniform, count int, value []float64) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_1core_glProgramUniform4dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4d.xml +func (gl *GL) ProgramUniform4d(program glbase.Program, location glbase.Uniform, v0, v1, v2, v3 float64) { + C.gl4_1core_glProgramUniform4d(gl.funcs, C.GLuint(program), C.GLint(location), C.GLdouble(v0), C.GLdouble(v1), C.GLdouble(v2), C.GLdouble(v3)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4fv.xml +func (gl *GL) ProgramUniform4fv(program glbase.Program, location glbase.Uniform, count int, value []float32) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_1core_glProgramUniform4fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4f.xml +func (gl *GL) ProgramUniform4f(program glbase.Program, location glbase.Uniform, v0, v1, v2, v3 float32) { + C.gl4_1core_glProgramUniform4f(gl.funcs, C.GLuint(program), C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2), C.GLfloat(v3)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4iv.xml +func (gl *GL) ProgramUniform4iv(program glbase.Program, location glbase.Uniform, count int, value []int32) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_1core_glProgramUniform4iv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4i.xml +func (gl *GL) ProgramUniform4i(program glbase.Program, location glbase.Uniform, v0, v1, v2, v3 int32) { + C.gl4_1core_glProgramUniform4i(gl.funcs, C.GLuint(program), C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2), C.GLint(v3)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3uiv.xml +func (gl *GL) ProgramUniform3uiv(program glbase.Program, location glbase.Uniform, count int, value []uint32) { + C.gl4_1core_glProgramUniform3uiv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3ui.xml +func (gl *GL) ProgramUniform3ui(program glbase.Program, location glbase.Uniform, v0, v1, v2 uint32) { + C.gl4_1core_glProgramUniform3ui(gl.funcs, C.GLuint(program), C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3dv.xml +func (gl *GL) ProgramUniform3dv(program glbase.Program, location glbase.Uniform, count int, value []float64) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_1core_glProgramUniform3dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3d.xml +func (gl *GL) ProgramUniform3d(program glbase.Program, location glbase.Uniform, v0, v1, v2 float64) { + C.gl4_1core_glProgramUniform3d(gl.funcs, C.GLuint(program), C.GLint(location), C.GLdouble(v0), C.GLdouble(v1), C.GLdouble(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3fv.xml +func (gl *GL) ProgramUniform3fv(program glbase.Program, location glbase.Uniform, count int, value []float32) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_1core_glProgramUniform3fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3f.xml +func (gl *GL) ProgramUniform3f(program glbase.Program, location glbase.Uniform, v0, v1, v2 float32) { + C.gl4_1core_glProgramUniform3f(gl.funcs, C.GLuint(program), C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3iv.xml +func (gl *GL) ProgramUniform3iv(program glbase.Program, location glbase.Uniform, count int, value []int32) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_1core_glProgramUniform3iv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3i.xml +func (gl *GL) ProgramUniform3i(program glbase.Program, location glbase.Uniform, v0, v1, v2 int32) { + C.gl4_1core_glProgramUniform3i(gl.funcs, C.GLuint(program), C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2uiv.xml +func (gl *GL) ProgramUniform2uiv(program glbase.Program, location glbase.Uniform, count int, value []uint32) { + C.gl4_1core_glProgramUniform2uiv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2ui.xml +func (gl *GL) ProgramUniform2ui(program glbase.Program, location glbase.Uniform, v0, v1 uint32) { + C.gl4_1core_glProgramUniform2ui(gl.funcs, C.GLuint(program), C.GLint(location), C.GLuint(v0), C.GLuint(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2dv.xml +func (gl *GL) ProgramUniform2dv(program glbase.Program, location glbase.Uniform, count int, value []float64) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_1core_glProgramUniform2dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2d.xml +func (gl *GL) ProgramUniform2d(program glbase.Program, location glbase.Uniform, v0, v1 float64) { + C.gl4_1core_glProgramUniform2d(gl.funcs, C.GLuint(program), C.GLint(location), C.GLdouble(v0), C.GLdouble(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2fv.xml +func (gl *GL) ProgramUniform2fv(program glbase.Program, location glbase.Uniform, count int, value []float32) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_1core_glProgramUniform2fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2f.xml +func (gl *GL) ProgramUniform2f(program glbase.Program, location glbase.Uniform, v0, v1 float32) { + C.gl4_1core_glProgramUniform2f(gl.funcs, C.GLuint(program), C.GLint(location), C.GLfloat(v0), C.GLfloat(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2iv.xml +func (gl *GL) ProgramUniform2iv(program glbase.Program, location glbase.Uniform, count int, value []int32) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_1core_glProgramUniform2iv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2i.xml +func (gl *GL) ProgramUniform2i(program glbase.Program, location glbase.Uniform, v0, v1 int32) { + C.gl4_1core_glProgramUniform2i(gl.funcs, C.GLuint(program), C.GLint(location), C.GLint(v0), C.GLint(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1uiv.xml +func (gl *GL) ProgramUniform1uiv(program glbase.Program, location glbase.Uniform, count int, value []uint32) { + C.gl4_1core_glProgramUniform1uiv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1ui.xml +func (gl *GL) ProgramUniform1ui(program glbase.Program, location glbase.Uniform, v0 uint32) { + C.gl4_1core_glProgramUniform1ui(gl.funcs, C.GLuint(program), C.GLint(location), C.GLuint(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1dv.xml +func (gl *GL) ProgramUniform1dv(program glbase.Program, location glbase.Uniform, count int, value []float64) { + C.gl4_1core_glProgramUniform1dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1d.xml +func (gl *GL) ProgramUniform1d(program glbase.Program, location glbase.Uniform, v0 float64) { + C.gl4_1core_glProgramUniform1d(gl.funcs, C.GLuint(program), C.GLint(location), C.GLdouble(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1fv.xml +func (gl *GL) ProgramUniform1fv(program glbase.Program, location glbase.Uniform, count int, value []float32) { + C.gl4_1core_glProgramUniform1fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1f.xml +func (gl *GL) ProgramUniform1f(program glbase.Program, location glbase.Uniform, v0 float32) { + C.gl4_1core_glProgramUniform1f(gl.funcs, C.GLuint(program), C.GLint(location), C.GLfloat(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1iv.xml +func (gl *GL) ProgramUniform1iv(program glbase.Program, location glbase.Uniform, count int, value []int32) { + C.gl4_1core_glProgramUniform1iv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1i.xml +func (gl *GL) ProgramUniform1i(program glbase.Program, location glbase.Uniform, v0 int32) { + C.gl4_1core_glProgramUniform1i(gl.funcs, C.GLuint(program), C.GLint(location), C.GLint(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramPipelineiv.xml +func (gl *GL) GetProgramPipelineiv(pipeline uint32, pname glbase.Enum, params []int32) { + C.gl4_1core_glGetProgramPipelineiv(gl.funcs, C.GLuint(pipeline), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsProgramPipeline.xml +func (gl *GL) IsProgramPipeline(pipeline uint32) bool { + glresult := C.gl4_1core_glIsProgramPipeline(gl.funcs, C.GLuint(pipeline)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenProgramPipelines.xml +func (gl *GL) GenProgramPipelines(n int, pipelines []uint32) { + C.gl4_1core_glGenProgramPipelines(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&pipelines[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteProgramPipelines.xml +func (gl *GL) DeleteProgramPipelines(n int, pipelines []uint32) { + C.gl4_1core_glDeleteProgramPipelines(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&pipelines[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindProgramPipeline.xml +func (gl *GL) BindProgramPipeline(pipeline uint32) { + C.gl4_1core_glBindProgramPipeline(gl.funcs, C.GLuint(pipeline)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glActiveShaderProgram.xml +func (gl *GL) ActiveShaderProgram(pipeline uint32, program glbase.Program) { + C.gl4_1core_glActiveShaderProgram(gl.funcs, C.GLuint(pipeline), C.GLuint(program)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUseProgramStages.xml +func (gl *GL) UseProgramStages(pipeline uint32, stages glbase.Bitfield, program glbase.Program) { + C.gl4_1core_glUseProgramStages(gl.funcs, C.GLuint(pipeline), C.GLbitfield(stages), C.GLuint(program)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramParameteri.xml +func (gl *GL) ProgramParameteri(program glbase.Program, pname glbase.Enum, value int32) { + C.gl4_1core_glProgramParameteri(gl.funcs, C.GLuint(program), C.GLenum(pname), C.GLint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramBinary.xml +func (gl *GL) ProgramBinary(program glbase.Program, binaryFormat glbase.Enum, binary interface{}, length int32) { + var binary_ptr unsafe.Pointer + var binary_v = reflect.ValueOf(binary) + if binary != nil && binary_v.Kind() != reflect.Slice { + panic("parameter binary must be a slice") + } + if binary != nil { + binary_ptr = unsafe.Pointer(binary_v.Index(0).Addr().Pointer()) + } + C.gl4_1core_glProgramBinary(gl.funcs, C.GLuint(program), C.GLenum(binaryFormat), binary_ptr, C.GLsizei(length)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramBinary.xml +func (gl *GL) GetProgramBinary(program glbase.Program, bufSize int32, length []int32, binaryFormat []glbase.Enum, binary interface{}) { + var binary_ptr unsafe.Pointer + var binary_v = reflect.ValueOf(binary) + if binary != nil && binary_v.Kind() != reflect.Slice { + panic("parameter binary must be a slice") + } + if binary != nil { + binary_ptr = unsafe.Pointer(binary_v.Index(0).Addr().Pointer()) + } + C.gl4_1core_glGetProgramBinary(gl.funcs, C.GLuint(program), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLenum)(unsafe.Pointer(&binaryFormat[0])), binary_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearDepthf.xml +func (gl *GL) ClearDepthf(dd float32) { + C.gl4_1core_glClearDepthf(gl.funcs, C.GLfloat(dd)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDepthRangef.xml +func (gl *GL) DepthRangef(n, f float32) { + C.gl4_1core_glDepthRangef(gl.funcs, C.GLfloat(n), C.GLfloat(f)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetShaderPrecisionFormat.xml +func (gl *GL) GetShaderPrecisionFormat(shadertype, precisionType glbase.Enum, range_, precision []int32) { + C.gl4_1core_glGetShaderPrecisionFormat(gl.funcs, C.GLenum(shadertype), C.GLenum(precisionType), (*C.GLint)(unsafe.Pointer(&range_[0])), (*C.GLint)(unsafe.Pointer(&precision[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glShaderBinary.xml +func (gl *GL) ShaderBinary(count int, shaders []glbase.Shader, binaryFormat glbase.Enum, binary interface{}, length int32) { + var binary_ptr unsafe.Pointer + var binary_v = reflect.ValueOf(binary) + if binary != nil && binary_v.Kind() != reflect.Slice { + panic("parameter binary must be a slice") + } + if binary != nil { + binary_ptr = unsafe.Pointer(binary_v.Index(0).Addr().Pointer()) + } + C.gl4_1core_glShaderBinary(gl.funcs, C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&shaders[0])), C.GLenum(binaryFormat), binary_ptr, C.GLsizei(length)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glReleaseShaderCompiler.xml +func (gl *GL) ReleaseShaderCompiler() { + C.gl4_1core_glReleaseShaderCompiler(gl.funcs) +} diff --git a/gl/4.2compat/funcs.cpp b/gl/4.2compat/funcs.cpp new file mode 100644 index 00000000..6101e99d --- /dev/null +++ b/gl/4.2compat/funcs.cpp @@ -0,0 +1,5358 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#include +#include + +#include "funcs.h" + +void *gl4_2compat_funcs() { + QOpenGLFunctions_4_2_Compatibility* funcs = QOpenGLContext::currentContext()->versionFunctions(); + if (!funcs) { + return 0; + } + funcs->initializeOpenGLFunctions(); + return funcs; +} + + +void gl4_2compat_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewport(x, y, width, height); +} + +void gl4_2compat_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRange(nearVal, farVal); +} + +GLboolean gl4_2compat_glIsEnabled(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabled(cap); +} + +void gl4_2compat_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameteriv(target, level, pname, params); +} + +void gl4_2compat_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameterfv(target, level, pname, params); +} + +void gl4_2compat_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameteriv(target, pname, params); +} + +void gl4_2compat_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterfv(target, pname, params); +} + +void gl4_2compat_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexImage(target, level, format, gltype, pixels); +} + +void gl4_2compat_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegerv(pname, params); +} + +void gl4_2compat_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFloatv(pname, params); +} + +GLenum gl4_2compat_glGetError(void *_glfuncs) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetError(); +} + +void gl4_2compat_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetDoublev(pname, params); +} + +void gl4_2compat_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleanv(pname, params); +} + +void gl4_2compat_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadPixels(x, y, width, height, format, gltype, pixels); +} + +void gl4_2compat_glReadBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadBuffer(mode); +} + +void gl4_2compat_glPixelStorei(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStorei(pname, param); +} + +void gl4_2compat_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStoref(pname, param); +} + +void gl4_2compat_glDepthFunc(void *_glfuncs, GLenum glfunc) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthFunc(glfunc); +} + +void gl4_2compat_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOp(fail, zfail, zpass); +} + +void gl4_2compat_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFunc(glfunc, ref, mask); +} + +void gl4_2compat_glLogicOp(void *_glfuncs, GLenum opcode) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLogicOp(opcode); +} + +void gl4_2compat_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFunc(sfactor, dfactor); +} + +void gl4_2compat_glFlush(void *_glfuncs) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlush(); +} + +void gl4_2compat_glFinish(void *_glfuncs) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFinish(); +} + +void gl4_2compat_glEnable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnable(cap); +} + +void gl4_2compat_glDisable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisable(cap); +} + +void gl4_2compat_glDepthMask(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthMask(flag); +} + +void gl4_2compat_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMask(red, green, blue, alpha); +} + +void gl4_2compat_glStencilMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMask(mask); +} + +void gl4_2compat_glClearDepth(void *_glfuncs, GLdouble depth) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearDepth(depth); +} + +void gl4_2compat_glClearStencil(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearStencil(s); +} + +void gl4_2compat_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearColor(red, green, blue, alpha); +} + +void gl4_2compat_glClear(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClear(mask); +} + +void gl4_2compat_glDrawBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffer(mode); +} + +void gl4_2compat_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage2D(target, level, internalFormat, width, height, border, format, gltype, pixels); +} + +void gl4_2compat_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage1D(target, level, internalFormat, width, border, format, gltype, pixels); +} + +void gl4_2compat_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteriv(target, pname, params); +} + +void gl4_2compat_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteri(target, pname, param); +} + +void gl4_2compat_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterfv(target, pname, params); +} + +void gl4_2compat_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterf(target, pname, param); +} + +void gl4_2compat_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissor(x, y, width, height); +} + +void gl4_2compat_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonMode(face, mode); +} + +void gl4_2compat_glPointSize(void *_glfuncs, GLfloat size) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointSize(size); +} + +void gl4_2compat_glLineWidth(void *_glfuncs, GLfloat width) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineWidth(width); +} + +void gl4_2compat_glHint(void *_glfuncs, GLenum target, GLenum mode) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glHint(target, mode); +} + +void gl4_2compat_glFrontFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrontFace(mode); +} + +void gl4_2compat_glCullFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCullFace(mode); +} + +void gl4_2compat_glIndexubv(void *_glfuncs, const GLubyte* c) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexubv(c); +} + +void gl4_2compat_glIndexub(void *_glfuncs, GLubyte c) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexub(c); +} + +GLboolean gl4_2compat_glIsTexture(void *_glfuncs, GLuint texture) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsTexture(texture); +} + +void gl4_2compat_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenTextures(n, textures); +} + +void gl4_2compat_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteTextures(n, textures); +} + +void gl4_2compat_glBindTexture(void *_glfuncs, GLenum target, GLuint texture) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindTexture(target, texture); +} + +void gl4_2compat_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, gltype, pixels); +} + +void gl4_2compat_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage1D(target, level, xoffset, width, format, gltype, pixels); +} + +void gl4_2compat_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); +} + +void gl4_2compat_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage1D(target, level, xoffset, x, y, width); +} + +void gl4_2compat_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage2D(target, level, internalFormat, x, y, width, height, border); +} + +void gl4_2compat_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage1D(target, level, internalFormat, x, y, width, border); +} + +void gl4_2compat_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonOffset(factor, units); +} + +void gl4_2compat_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElements(mode, count, gltype, indices); +} + +void gl4_2compat_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArrays(mode, first, count); +} + +void gl4_2compat_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); +} + +void gl4_2compat_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, gltype, pixels); +} + +void gl4_2compat_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage3D(target, level, internalFormat, width, height, depth, border, format, gltype, pixels); +} + +void gl4_2compat_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawRangeElements(mode, start, end, count, gltype, indices); +} + +void gl4_2compat_glBlendEquation(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquation(mode); +} + +void gl4_2compat_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendColor(red, green, blue, alpha); +} + +void gl4_2compat_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetCompressedTexImage(target, level, img); +} + +void gl4_2compat_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data); +} + +void gl4_2compat_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); +} + +void gl4_2compat_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); +} + +void gl4_2compat_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage1D(target, level, internalFormat, width, border, imageSize, data); +} + +void gl4_2compat_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data); +} + +void gl4_2compat_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage3D(target, level, internalFormat, width, height, depth, border, imageSize, data); +} + +void gl4_2compat_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSampleCoverage(value, invert); +} + +void gl4_2compat_glActiveTexture(void *_glfuncs, GLenum texture) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glActiveTexture(texture); +} + +void gl4_2compat_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteriv(pname, params); +} + +void gl4_2compat_glPointParameteri(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteri(pname, param); +} + +void gl4_2compat_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterfv(pname, params); +} + +void gl4_2compat_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterf(pname, param); +} + +void gl4_2compat_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiDrawArrays(mode, first, count, drawcount); +} + +void gl4_2compat_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); +} + +void gl4_2compat_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferParameteriv(target, pname, params); +} + +GLboolean gl4_2compat_glUnmapBuffer(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glUnmapBuffer(target); +} + +void gl4_2compat_glGetBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferSubData(target, offset, size, data); +} + +void gl4_2compat_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferSubData(target, offset, size, data); +} + +void gl4_2compat_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferData(target, size, data, usage); +} + +GLboolean gl4_2compat_glIsBuffer(void *_glfuncs, GLuint buffer) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsBuffer(buffer); +} + +void gl4_2compat_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenBuffers(n, buffers); +} + +void gl4_2compat_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteBuffers(n, buffers); +} + +void gl4_2compat_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBuffer(target, buffer); +} + +void gl4_2compat_glGetQueryObjectuiv(void *_glfuncs, GLuint id, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectuiv(id, pname, params); +} + +void gl4_2compat_glGetQueryObjectiv(void *_glfuncs, GLuint id, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectiv(id, pname, params); +} + +void gl4_2compat_glGetQueryiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryiv(target, pname, params); +} + +void gl4_2compat_glEndQuery(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndQuery(target); +} + +void gl4_2compat_glBeginQuery(void *_glfuncs, GLenum target, GLuint id) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginQuery(target, id); +} + +GLboolean gl4_2compat_glIsQuery(void *_glfuncs, GLuint id) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsQuery(id); +} + +void gl4_2compat_glDeleteQueries(void *_glfuncs, GLsizei n, const GLuint* ids) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteQueries(n, ids); +} + +void gl4_2compat_glGenQueries(void *_glfuncs, GLsizei n, GLuint* ids) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenQueries(n, ids); +} + +void gl4_2compat_glVertexAttribPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLboolean normalized, GLsizei stride, const GLvoid* offset) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribPointer(index, size, gltype, normalized, stride, offset); +} + +void gl4_2compat_glValidateProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glValidateProgram(program); +} + +void gl4_2compat_glUniformMatrix4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4fv(location, count, transpose, value); +} + +void gl4_2compat_glUniformMatrix3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3fv(location, count, transpose, value); +} + +void gl4_2compat_glUniformMatrix2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2fv(location, count, transpose, value); +} + +void gl4_2compat_glUniform4iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4iv(location, count, value); +} + +void gl4_2compat_glUniform3iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3iv(location, count, value); +} + +void gl4_2compat_glUniform2iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2iv(location, count, value); +} + +void gl4_2compat_glUniform1iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1iv(location, count, value); +} + +void gl4_2compat_glUniform4fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4fv(location, count, value); +} + +void gl4_2compat_glUniform3fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3fv(location, count, value); +} + +void gl4_2compat_glUniform2fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2fv(location, count, value); +} + +void gl4_2compat_glUniform1fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1fv(location, count, value); +} + +void gl4_2compat_glUniform4i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4i(location, v0, v1, v2, v3); +} + +void gl4_2compat_glUniform3i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3i(location, v0, v1, v2); +} + +void gl4_2compat_glUniform2i(void *_glfuncs, GLint location, GLint v0, GLint v1) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2i(location, v0, v1); +} + +void gl4_2compat_glUniform1i(void *_glfuncs, GLint location, GLint v0) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1i(location, v0); +} + +void gl4_2compat_glUniform4f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4f(location, v0, v1, v2, v3); +} + +void gl4_2compat_glUniform3f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3f(location, v0, v1, v2); +} + +void gl4_2compat_glUniform2f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2f(location, v0, v1); +} + +void gl4_2compat_glUniform1f(void *_glfuncs, GLint location, GLfloat v0) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1f(location, v0); +} + +void gl4_2compat_glUseProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUseProgram(program); +} + +void gl4_2compat_glShaderSource(void *_glfuncs, GLuint shader, GLsizei count, const GLchar** source, const GLint* length) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShaderSource(shader, count, source, length); +} + +void gl4_2compat_glLinkProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLinkProgram(program); +} + +GLboolean gl4_2compat_glIsShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsShader(shader); +} + +GLboolean gl4_2compat_glIsProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsProgram(program); +} + +void gl4_2compat_glGetVertexAttribiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribiv(index, pname, params); +} + +void gl4_2compat_glGetVertexAttribfv(void *_glfuncs, GLuint index, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribfv(index, pname, params); +} + +void gl4_2compat_glGetVertexAttribdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribdv(index, pname, params); +} + +void gl4_2compat_glGetUniformiv(void *_glfuncs, GLuint program, GLint location, GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformiv(program, location, params); +} + +void gl4_2compat_glGetUniformfv(void *_glfuncs, GLuint program, GLint location, GLfloat* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformfv(program, location, params); +} + +GLint gl4_2compat_glGetUniformLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetUniformLocation(program, name); +} + +void gl4_2compat_glGetShaderSource(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderSource(shader, bufSize, length, source); +} + +void gl4_2compat_glGetShaderInfoLog(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderInfoLog(shader, bufSize, length, infoLog); +} + +void gl4_2compat_glGetShaderiv(void *_glfuncs, GLuint shader, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderiv(shader, pname, params); +} + +void gl4_2compat_glGetProgramInfoLog(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramInfoLog(program, bufSize, length, infoLog); +} + +void gl4_2compat_glGetProgramiv(void *_glfuncs, GLuint program, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramiv(program, pname, params); +} + +GLint gl4_2compat_glGetAttribLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetAttribLocation(program, name); +} + +void gl4_2compat_glGetAttachedShaders(void *_glfuncs, GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetAttachedShaders(program, maxCount, count, obj); +} + +void gl4_2compat_glGetActiveUniform(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniform(program, index, bufSize, length, size, gltype, name); +} + +void gl4_2compat_glGetActiveAttrib(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveAttrib(program, index, bufSize, length, size, gltype, name); +} + +void gl4_2compat_glEnableVertexAttribArray(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnableVertexAttribArray(index); +} + +void gl4_2compat_glDisableVertexAttribArray(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisableVertexAttribArray(index); +} + +void gl4_2compat_glDetachShader(void *_glfuncs, GLuint program, GLuint shader) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDetachShader(program, shader); +} + +void gl4_2compat_glDeleteShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteShader(shader); +} + +void gl4_2compat_glDeleteProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteProgram(program); +} + +GLuint gl4_2compat_glCreateShader(void *_glfuncs, GLenum gltype) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCreateShader(gltype); +} + +GLuint gl4_2compat_glCreateProgram(void *_glfuncs) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCreateProgram(); +} + +void gl4_2compat_glCompileShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompileShader(shader); +} + +void gl4_2compat_glBindAttribLocation(void *_glfuncs, GLuint program, GLuint index, const GLchar* name) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindAttribLocation(program, index, name); +} + +void gl4_2compat_glAttachShader(void *_glfuncs, GLuint program, GLuint shader) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAttachShader(program, shader); +} + +void gl4_2compat_glStencilMaskSeparate(void *_glfuncs, GLenum face, GLuint mask) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMaskSeparate(face, mask); +} + +void gl4_2compat_glStencilFuncSeparate(void *_glfuncs, GLenum face, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFuncSeparate(face, glfunc, ref, mask); +} + +void gl4_2compat_glStencilOpSeparate(void *_glfuncs, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOpSeparate(face, sfail, dpfail, dppass); +} + +void gl4_2compat_glDrawBuffers(void *_glfuncs, GLsizei n, const GLenum* bufs) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffers(n, bufs); +} + +void gl4_2compat_glBlendEquationSeparate(void *_glfuncs, GLenum modeRGB, GLenum modeAlpha) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquationSeparate(modeRGB, modeAlpha); +} + +void gl4_2compat_glUniformMatrix4x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x3fv(location, count, transpose, value); +} + +void gl4_2compat_glUniformMatrix3x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x4fv(location, count, transpose, value); +} + +void gl4_2compat_glUniformMatrix4x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x2fv(location, count, transpose, value); +} + +void gl4_2compat_glUniformMatrix2x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x4fv(location, count, transpose, value); +} + +void gl4_2compat_glUniformMatrix3x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x2fv(location, count, transpose, value); +} + +void gl4_2compat_glUniformMatrix2x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x3fv(location, count, transpose, value); +} + +GLboolean gl4_2compat_glIsVertexArray(void *_glfuncs, GLuint array) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsVertexArray(array); +} + +void gl4_2compat_glGenVertexArrays(void *_glfuncs, GLsizei n, GLuint* arrays) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenVertexArrays(n, arrays); +} + +void gl4_2compat_glDeleteVertexArrays(void *_glfuncs, GLsizei n, const GLuint* arrays) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteVertexArrays(n, arrays); +} + +void gl4_2compat_glBindVertexArray(void *_glfuncs, GLuint array) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindVertexArray(array); +} + +void gl4_2compat_glFlushMappedBufferRange(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr length) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlushMappedBufferRange(target, offset, length); +} + +void gl4_2compat_glFramebufferTextureLayer(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTextureLayer(target, attachment, texture, level, layer); +} + +void gl4_2compat_glRenderbufferStorageMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRenderbufferStorageMultisample(target, samples, internalFormat, width, height); +} + +void gl4_2compat_glBlitFramebuffer(void *_glfuncs, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); +} + +void gl4_2compat_glGenerateMipmap(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenerateMipmap(target); +} + +void gl4_2compat_glGetFramebufferAttachmentParameteriv(void *_glfuncs, GLenum target, GLenum attachment, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFramebufferAttachmentParameteriv(target, attachment, pname, params); +} + +void gl4_2compat_glFramebufferRenderbuffer(void *_glfuncs, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer); +} + +void gl4_2compat_glFramebufferTexture3D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset); +} + +void gl4_2compat_glFramebufferTexture2D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture2D(target, attachment, textarget, texture, level); +} + +void gl4_2compat_glFramebufferTexture1D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture1D(target, attachment, textarget, texture, level); +} + +GLenum gl4_2compat_glCheckFramebufferStatus(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCheckFramebufferStatus(target); +} + +void gl4_2compat_glGenFramebuffers(void *_glfuncs, GLsizei n, GLuint* framebuffers) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenFramebuffers(n, framebuffers); +} + +void gl4_2compat_glDeleteFramebuffers(void *_glfuncs, GLsizei n, const GLuint* framebuffers) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteFramebuffers(n, framebuffers); +} + +void gl4_2compat_glBindFramebuffer(void *_glfuncs, GLenum target, GLuint framebuffer) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFramebuffer(target, framebuffer); +} + +GLboolean gl4_2compat_glIsFramebuffer(void *_glfuncs, GLuint framebuffer) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsFramebuffer(framebuffer); +} + +void gl4_2compat_glGetRenderbufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetRenderbufferParameteriv(target, pname, params); +} + +void gl4_2compat_glRenderbufferStorage(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRenderbufferStorage(target, internalFormat, width, height); +} + +void gl4_2compat_glGenRenderbuffers(void *_glfuncs, GLsizei n, GLuint* renderbuffers) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenRenderbuffers(n, renderbuffers); +} + +void gl4_2compat_glDeleteRenderbuffers(void *_glfuncs, GLsizei n, const GLuint* renderbuffers) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteRenderbuffers(n, renderbuffers); +} + +void gl4_2compat_glBindRenderbuffer(void *_glfuncs, GLenum target, GLuint renderbuffer) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindRenderbuffer(target, renderbuffer); +} + +GLboolean gl4_2compat_glIsRenderbuffer(void *_glfuncs, GLuint renderbuffer) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsRenderbuffer(renderbuffer); +} + +void gl4_2compat_glClearBufferfi(void *_glfuncs, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferfi(buffer, drawbuffer, depth, stencil); +} + +void gl4_2compat_glClearBufferfv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferfv(buffer, drawbuffer, value); +} + +void gl4_2compat_glClearBufferuiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLuint* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferuiv(buffer, drawbuffer, value); +} + +void gl4_2compat_glClearBufferiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLint* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferiv(buffer, drawbuffer, value); +} + +void gl4_2compat_glGetTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterIuiv(target, pname, params); +} + +void gl4_2compat_glGetTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterIiv(target, pname, params); +} + +void gl4_2compat_glTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, const GLuint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterIuiv(target, pname, params); +} + +void gl4_2compat_glTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterIiv(target, pname, params); +} + +void gl4_2compat_glUniform4uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4uiv(location, count, value); +} + +void gl4_2compat_glUniform3uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3uiv(location, count, value); +} + +void gl4_2compat_glUniform2uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2uiv(location, count, value); +} + +void gl4_2compat_glUniform1uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1uiv(location, count, value); +} + +void gl4_2compat_glUniform4ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4ui(location, v0, v1, v2, v3); +} + +void gl4_2compat_glUniform3ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3ui(location, v0, v1, v2); +} + +void gl4_2compat_glUniform2ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2ui(location, v0, v1); +} + +void gl4_2compat_glUniform1ui(void *_glfuncs, GLint location, GLuint v0) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1ui(location, v0); +} + +GLint gl4_2compat_glGetFragDataLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetFragDataLocation(program, name); +} + +void gl4_2compat_glBindFragDataLocation(void *_glfuncs, GLuint program, GLuint color, const GLchar* name) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFragDataLocation(program, color, name); +} + +void gl4_2compat_glGetUniformuiv(void *_glfuncs, GLuint program, GLint location, GLuint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformuiv(program, location, params); +} + +void gl4_2compat_glGetVertexAttribIuiv(void *_glfuncs, GLuint index, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribIuiv(index, pname, params); +} + +void gl4_2compat_glGetVertexAttribIiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribIiv(index, pname, params); +} + +void gl4_2compat_glVertexAttribIPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribIPointer(index, size, gltype, stride, pointer); +} + +void gl4_2compat_glEndConditionalRender(void *_glfuncs) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndConditionalRender(); +} + +void gl4_2compat_glBeginConditionalRender(void *_glfuncs, GLuint id, GLenum mode) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginConditionalRender(id, mode); +} + +void gl4_2compat_glClampColor(void *_glfuncs, GLenum target, GLenum clamp) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClampColor(target, clamp); +} + +void gl4_2compat_glGetTransformFeedbackVarying(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTransformFeedbackVarying(program, index, bufSize, length, size, gltype, name); +} + +void gl4_2compat_glBindBufferBase(void *_glfuncs, GLenum target, GLuint index, GLuint buffer) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBufferBase(target, index, buffer); +} + +void gl4_2compat_glBindBufferRange(void *_glfuncs, GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBufferRange(target, index, buffer, offset, size); +} + +void gl4_2compat_glEndTransformFeedback(void *_glfuncs) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndTransformFeedback(); +} + +void gl4_2compat_glBeginTransformFeedback(void *_glfuncs, GLenum primitiveMode) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginTransformFeedback(primitiveMode); +} + +GLboolean gl4_2compat_glIsEnabledi(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabledi(target, index); +} + +void gl4_2compat_glDisablei(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisablei(target, index); +} + +void gl4_2compat_glEnablei(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnablei(target, index); +} + +void gl4_2compat_glGetIntegeri_v(void *_glfuncs, GLenum target, GLuint index, GLint* data) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegeri_v(target, index, data); +} + +void gl4_2compat_glGetBooleani_v(void *_glfuncs, GLenum target, GLuint index, GLboolean* data) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleani_v(target, index, data); +} + +void gl4_2compat_glColorMaski(void *_glfuncs, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMaski(index, r, g, b, a); +} + +void gl4_2compat_glCopyBufferSubData(void *_glfuncs, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); +} + +void gl4_2compat_glUniformBlockBinding(void *_glfuncs, GLuint program, GLuint v0, GLuint v1) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformBlockBinding(program, v0, v1); +} + +void gl4_2compat_glGetActiveUniformBlockName(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName); +} + +void gl4_2compat_glGetActiveUniformBlockiv(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params); +} + +GLuint gl4_2compat_glGetUniformBlockIndex(void *_glfuncs, GLuint program, const GLchar* uniformBlockName) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetUniformBlockIndex(program, uniformBlockName); +} + +void gl4_2compat_glGetActiveUniformName(void *_glfuncs, GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformName(program, uniformIndex, bufSize, length, uniformName); +} + +void gl4_2compat_glGetActiveUniformsiv(void *_glfuncs, GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params); +} + +void gl4_2compat_glPrimitiveRestartIndex(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPrimitiveRestartIndex(index); +} + +void gl4_2compat_glTexBuffer(void *_glfuncs, GLenum target, GLenum internalFormat, GLuint buffer) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexBuffer(target, internalFormat, buffer); +} + +void gl4_2compat_glDrawElementsInstanced(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsInstanced(mode, count, gltype, indices, instancecount); +} + +void gl4_2compat_glDrawArraysInstanced(void *_glfuncs, GLenum mode, GLint first, GLsizei count, GLsizei instancecount) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArraysInstanced(mode, first, count, instancecount); +} + +void gl4_2compat_glSampleMaski(void *_glfuncs, GLuint index, GLbitfield mask) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSampleMaski(index, mask); +} + +void gl4_2compat_glGetMultisamplefv(void *_glfuncs, GLenum pname, GLuint index, GLfloat* val) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMultisamplefv(pname, index, val); +} + +void gl4_2compat_glTexImage3DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage3DMultisample(target, samples, internalFormat, width, height, depth, fixedsamplelocations); +} + +void gl4_2compat_glTexImage2DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage2DMultisample(target, samples, internalFormat, width, height, fixedsamplelocations); +} + +void gl4_2compat_glGetSynciv(void *_glfuncs, GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSynciv(sync, pname, bufSize, length, values); +} + +void gl4_2compat_glGetInteger64v(void *_glfuncs, GLenum pname, GLint64* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetInteger64v(pname, params); +} + +void gl4_2compat_glWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWaitSync(sync, flags, timeout); +} + +GLenum gl4_2compat_glClientWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glClientWaitSync(sync, flags, timeout); +} + +void gl4_2compat_glDeleteSync(void *_glfuncs, GLsync sync) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteSync(sync); +} + +GLboolean gl4_2compat_glIsSync(void *_glfuncs, GLsync sync) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsSync(sync); +} + +GLsync gl4_2compat_glFenceSync(void *_glfuncs, GLenum condition, GLbitfield flags) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glFenceSync(condition, flags); +} + +void gl4_2compat_glProvokingVertex(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProvokingVertex(mode); +} + +void gl4_2compat_glDrawElementsInstancedBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLint basevertex) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsInstancedBaseVertex(mode, count, gltype, indices, instancecount, basevertex); +} + +void gl4_2compat_glDrawRangeElementsBaseVertex(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawRangeElementsBaseVertex(mode, start, end, count, gltype, indices, basevertex); +} + +void gl4_2compat_glDrawElementsBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsBaseVertex(mode, count, gltype, indices, basevertex); +} + +void gl4_2compat_glFramebufferTexture(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture(target, attachment, texture, level); +} + +void gl4_2compat_glGetBufferParameteri64v(void *_glfuncs, GLenum target, GLenum pname, GLint64* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferParameteri64v(target, pname, params); +} + +void gl4_2compat_glGetInteger64i_v(void *_glfuncs, GLenum target, GLuint index, GLint64* data) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetInteger64i_v(target, index, data); +} + +void gl4_2compat_glVertexAttribP4uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP4uiv(index, gltype, normalized, value); +} + +void gl4_2compat_glVertexAttribP4ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP4ui(index, gltype, normalized, value); +} + +void gl4_2compat_glVertexAttribP3uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP3uiv(index, gltype, normalized, value); +} + +void gl4_2compat_glVertexAttribP3ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP3ui(index, gltype, normalized, value); +} + +void gl4_2compat_glVertexAttribP2uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP2uiv(index, gltype, normalized, value); +} + +void gl4_2compat_glVertexAttribP2ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP2ui(index, gltype, normalized, value); +} + +void gl4_2compat_glVertexAttribP1uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP1uiv(index, gltype, normalized, value); +} + +void gl4_2compat_glVertexAttribP1ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP1ui(index, gltype, normalized, value); +} + +void gl4_2compat_glSecondaryColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColorP3uiv(gltype, color); +} + +void gl4_2compat_glSecondaryColorP3ui(void *_glfuncs, GLenum gltype, GLuint color) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColorP3ui(gltype, color); +} + +void gl4_2compat_glColorP4uiv(void *_glfuncs, GLenum gltype, const GLuint* color) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP4uiv(gltype, color); +} + +void gl4_2compat_glColorP4ui(void *_glfuncs, GLenum gltype, GLuint color) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP4ui(gltype, color); +} + +void gl4_2compat_glColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP3uiv(gltype, color); +} + +void gl4_2compat_glColorP3ui(void *_glfuncs, GLenum gltype, GLuint color) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP3ui(gltype, color); +} + +void gl4_2compat_glNormalP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormalP3uiv(gltype, coords); +} + +void gl4_2compat_glNormalP3ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormalP3ui(gltype, coords); +} + +void gl4_2compat_glMultiTexCoordP4uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP4uiv(texture, gltype, coords); +} + +void gl4_2compat_glMultiTexCoordP4ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP4ui(texture, gltype, coords); +} + +void gl4_2compat_glMultiTexCoordP3uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP3uiv(texture, gltype, coords); +} + +void gl4_2compat_glMultiTexCoordP3ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP3ui(texture, gltype, coords); +} + +void gl4_2compat_glMultiTexCoordP2uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP2uiv(texture, gltype, coords); +} + +void gl4_2compat_glMultiTexCoordP2ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP2ui(texture, gltype, coords); +} + +void gl4_2compat_glMultiTexCoordP1uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP1uiv(texture, gltype, coords); +} + +void gl4_2compat_glMultiTexCoordP1ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP1ui(texture, gltype, coords); +} + +void gl4_2compat_glTexCoordP4uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP4uiv(gltype, coords); +} + +void gl4_2compat_glTexCoordP4ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP4ui(gltype, coords); +} + +void gl4_2compat_glTexCoordP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP3uiv(gltype, coords); +} + +void gl4_2compat_glTexCoordP3ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP3ui(gltype, coords); +} + +void gl4_2compat_glTexCoordP2uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP2uiv(gltype, coords); +} + +void gl4_2compat_glTexCoordP2ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP2ui(gltype, coords); +} + +void gl4_2compat_glTexCoordP1uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP1uiv(gltype, coords); +} + +void gl4_2compat_glTexCoordP1ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP1ui(gltype, coords); +} + +void gl4_2compat_glVertexP4uiv(void *_glfuncs, GLenum gltype, const GLuint* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP4uiv(gltype, value); +} + +void gl4_2compat_glVertexP4ui(void *_glfuncs, GLenum gltype, GLuint value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP4ui(gltype, value); +} + +void gl4_2compat_glVertexP3uiv(void *_glfuncs, GLenum gltype, const GLuint* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP3uiv(gltype, value); +} + +void gl4_2compat_glVertexP3ui(void *_glfuncs, GLenum gltype, GLuint value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP3ui(gltype, value); +} + +void gl4_2compat_glVertexP2uiv(void *_glfuncs, GLenum gltype, const GLuint* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP2uiv(gltype, value); +} + +void gl4_2compat_glVertexP2ui(void *_glfuncs, GLenum gltype, GLuint value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP2ui(gltype, value); +} + +void gl4_2compat_glGetQueryObjectui64v(void *_glfuncs, GLuint id, GLenum pname, GLuint64* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectui64v(id, pname, params); +} + +void gl4_2compat_glGetQueryObjecti64v(void *_glfuncs, GLuint id, GLenum pname, GLint64* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjecti64v(id, pname, params); +} + +void gl4_2compat_glQueryCounter(void *_glfuncs, GLuint id, GLenum target) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glQueryCounter(id, target); +} + +void gl4_2compat_glGetSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameterIuiv(sampler, pname, params); +} + +void gl4_2compat_glGetSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameterfv(sampler, pname, params); +} + +void gl4_2compat_glGetSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameterIiv(sampler, pname, params); +} + +void gl4_2compat_glGetSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameteriv(sampler, pname, params); +} + +void gl4_2compat_glSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLuint* param) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterIuiv(sampler, pname, param); +} + +void gl4_2compat_glSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterIiv(sampler, pname, param); +} + +void gl4_2compat_glSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, const GLfloat* param) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterfv(sampler, pname, param); +} + +void gl4_2compat_glSamplerParameterf(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterf(sampler, pname, param); +} + +void gl4_2compat_glSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameteriv(sampler, pname, param); +} + +void gl4_2compat_glSamplerParameteri(void *_glfuncs, GLuint sampler, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameteri(sampler, pname, param); +} + +void gl4_2compat_glBindSampler(void *_glfuncs, GLuint unit, GLuint sampler) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindSampler(unit, sampler); +} + +GLboolean gl4_2compat_glIsSampler(void *_glfuncs, GLuint sampler) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsSampler(sampler); +} + +void gl4_2compat_glDeleteSamplers(void *_glfuncs, GLsizei count, const GLuint* samplers) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteSamplers(count, samplers); +} + +void gl4_2compat_glGenSamplers(void *_glfuncs, GLsizei count, GLuint* samplers) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenSamplers(count, samplers); +} + +GLint gl4_2compat_glGetFragDataIndex(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetFragDataIndex(program, name); +} + +void gl4_2compat_glBindFragDataLocationIndexed(void *_glfuncs, GLuint program, GLuint colorNumber, GLuint index, const GLchar* name) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFragDataLocationIndexed(program, colorNumber, index, name); +} + +void gl4_2compat_glVertexAttribDivisor(void *_glfuncs, GLuint index, GLuint divisor) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribDivisor(index, divisor); +} + +void gl4_2compat_glGetQueryIndexediv(void *_glfuncs, GLenum target, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryIndexediv(target, index, pname, params); +} + +void gl4_2compat_glEndQueryIndexed(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndQueryIndexed(target, index); +} + +void gl4_2compat_glBeginQueryIndexed(void *_glfuncs, GLenum target, GLuint index, GLuint id) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginQueryIndexed(target, index, id); +} + +void gl4_2compat_glDrawTransformFeedbackStream(void *_glfuncs, GLenum mode, GLuint id, GLuint stream) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawTransformFeedbackStream(mode, id, stream); +} + +void gl4_2compat_glDrawTransformFeedback(void *_glfuncs, GLenum mode, GLuint id) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawTransformFeedback(mode, id); +} + +void gl4_2compat_glResumeTransformFeedback(void *_glfuncs) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glResumeTransformFeedback(); +} + +void gl4_2compat_glPauseTransformFeedback(void *_glfuncs) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPauseTransformFeedback(); +} + +GLboolean gl4_2compat_glIsTransformFeedback(void *_glfuncs, GLuint id) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsTransformFeedback(id); +} + +void gl4_2compat_glGenTransformFeedbacks(void *_glfuncs, GLsizei n, GLuint* ids) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenTransformFeedbacks(n, ids); +} + +void gl4_2compat_glDeleteTransformFeedbacks(void *_glfuncs, GLsizei n, const GLuint* ids) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteTransformFeedbacks(n, ids); +} + +void gl4_2compat_glBindTransformFeedback(void *_glfuncs, GLenum target, GLuint id) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindTransformFeedback(target, id); +} + +void gl4_2compat_glPatchParameterfv(void *_glfuncs, GLenum pname, const GLfloat* values) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPatchParameterfv(pname, values); +} + +void gl4_2compat_glPatchParameteri(void *_glfuncs, GLenum pname, GLint value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPatchParameteri(pname, value); +} + +void gl4_2compat_glGetProgramStageiv(void *_glfuncs, GLuint program, GLenum shadertype, GLenum pname, GLint* values) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramStageiv(program, shadertype, pname, values); +} + +void gl4_2compat_glGetUniformSubroutineuiv(void *_glfuncs, GLenum shadertype, GLint location, GLuint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformSubroutineuiv(shadertype, location, params); +} + +void gl4_2compat_glUniformSubroutinesuiv(void *_glfuncs, GLenum shadertype, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformSubroutinesuiv(shadertype, count, value); +} + +void gl4_2compat_glGetActiveSubroutineName(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveSubroutineName(program, shadertype, index, bufSize, length, name); +} + +void gl4_2compat_glGetActiveSubroutineUniformName(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveSubroutineUniformName(program, shadertype, index, bufSize, length, name); +} + +void gl4_2compat_glGetActiveSubroutineUniformiv(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint* values) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveSubroutineUniformiv(program, shadertype, index, pname, values); +} + +GLuint gl4_2compat_glGetSubroutineIndex(void *_glfuncs, GLuint program, GLenum shadertype, const GLchar* name) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetSubroutineIndex(program, shadertype, name); +} + +GLint gl4_2compat_glGetSubroutineUniformLocation(void *_glfuncs, GLuint program, GLenum shadertype, const GLchar* name) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetSubroutineUniformLocation(program, shadertype, name); +} + +void gl4_2compat_glGetUniformdv(void *_glfuncs, GLuint program, GLint location, GLdouble* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformdv(program, location, params); +} + +void gl4_2compat_glUniformMatrix4x3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x3dv(location, count, transpose, value); +} + +void gl4_2compat_glUniformMatrix4x2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x2dv(location, count, transpose, value); +} + +void gl4_2compat_glUniformMatrix3x4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x4dv(location, count, transpose, value); +} + +void gl4_2compat_glUniformMatrix3x2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x2dv(location, count, transpose, value); +} + +void gl4_2compat_glUniformMatrix2x4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x4dv(location, count, transpose, value); +} + +void gl4_2compat_glUniformMatrix2x3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x3dv(location, count, transpose, value); +} + +void gl4_2compat_glUniformMatrix4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4dv(location, count, transpose, value); +} + +void gl4_2compat_glUniformMatrix3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3dv(location, count, transpose, value); +} + +void gl4_2compat_glUniformMatrix2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2dv(location, count, transpose, value); +} + +void gl4_2compat_glUniform4dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4dv(location, count, value); +} + +void gl4_2compat_glUniform3dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3dv(location, count, value); +} + +void gl4_2compat_glUniform2dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2dv(location, count, value); +} + +void gl4_2compat_glUniform1dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1dv(location, count, value); +} + +void gl4_2compat_glUniform4d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4d(location, v0, v1, v2, v3); +} + +void gl4_2compat_glUniform3d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1, GLdouble v2) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3d(location, v0, v1, v2); +} + +void gl4_2compat_glUniform2d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2d(location, v0, v1); +} + +void gl4_2compat_glUniform1d(void *_glfuncs, GLint location, GLdouble v0) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1d(location, v0); +} + +void gl4_2compat_glDrawElementsIndirect(void *_glfuncs, GLenum mode, GLenum gltype, const GLvoid* indirect) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsIndirect(mode, gltype, indirect); +} + +void gl4_2compat_glDrawArraysIndirect(void *_glfuncs, GLenum mode, const GLvoid* indirect) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArraysIndirect(mode, indirect); +} + +void gl4_2compat_glBlendFuncSeparatei(void *_glfuncs, GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha); +} + +void gl4_2compat_glBlendFunci(void *_glfuncs, GLuint buf, GLenum src, GLenum dst) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFunci(buf, src, dst); +} + +void gl4_2compat_glBlendEquationSeparatei(void *_glfuncs, GLuint buf, GLenum modeRGB, GLenum modeAlpha) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquationSeparatei(buf, modeRGB, modeAlpha); +} + +void gl4_2compat_glBlendEquationi(void *_glfuncs, GLuint buf, GLenum mode) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquationi(buf, mode); +} + +void gl4_2compat_glMinSampleShading(void *_glfuncs, GLfloat value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMinSampleShading(value); +} + +void gl4_2compat_glGetDoublei_v(void *_glfuncs, GLenum target, GLuint index, GLdouble* data) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetDoublei_v(target, index, data); +} + +void gl4_2compat_glGetFloati_v(void *_glfuncs, GLenum target, GLuint index, GLfloat* data) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFloati_v(target, index, data); +} + +void gl4_2compat_glDepthRangeIndexed(void *_glfuncs, GLuint index, GLdouble n, GLdouble f) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRangeIndexed(index, n, f); +} + +void gl4_2compat_glDepthRangeArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLdouble* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRangeArrayv(first, count, v); +} + +void gl4_2compat_glScissorIndexedv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissorIndexedv(index, v); +} + +void gl4_2compat_glScissorIndexed(void *_glfuncs, GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissorIndexed(index, left, bottom, width, height); +} + +void gl4_2compat_glScissorArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissorArrayv(first, count, v); +} + +void gl4_2compat_glViewportIndexedfv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewportIndexedfv(index, v); +} + +void gl4_2compat_glViewportIndexedf(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewportIndexedf(index, x, y, w, h); +} + +void gl4_2compat_glViewportArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLfloat* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewportArrayv(first, count, v); +} + +void gl4_2compat_glGetVertexAttribLdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribLdv(index, pname, params); +} + +void gl4_2compat_glVertexAttribLPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribLPointer(index, size, gltype, stride, pointer); +} + +void gl4_2compat_glVertexAttribL4dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL4dv(index, v); +} + +void gl4_2compat_glVertexAttribL3dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL3dv(index, v); +} + +void gl4_2compat_glVertexAttribL2dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL2dv(index, v); +} + +void gl4_2compat_glVertexAttribL1dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL1dv(index, v); +} + +void gl4_2compat_glVertexAttribL4d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL4d(index, x, y, z, w); +} + +void gl4_2compat_glVertexAttribL3d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL3d(index, x, y, z); +} + +void gl4_2compat_glVertexAttribL2d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL2d(index, x, y); +} + +void gl4_2compat_glVertexAttribL1d(void *_glfuncs, GLuint index, GLdouble x) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL1d(index, x); +} + +void gl4_2compat_glGetProgramPipelineInfoLog(void *_glfuncs, GLuint pipeline, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog); +} + +void gl4_2compat_glValidateProgramPipeline(void *_glfuncs, GLuint pipeline) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glValidateProgramPipeline(pipeline); +} + +void gl4_2compat_glProgramUniformMatrix4x3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4x3dv(program, location, count, transpose, value); +} + +void gl4_2compat_glProgramUniformMatrix3x4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3x4dv(program, location, count, transpose, value); +} + +void gl4_2compat_glProgramUniformMatrix4x2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4x2dv(program, location, count, transpose, value); +} + +void gl4_2compat_glProgramUniformMatrix2x4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2x4dv(program, location, count, transpose, value); +} + +void gl4_2compat_glProgramUniformMatrix3x2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3x2dv(program, location, count, transpose, value); +} + +void gl4_2compat_glProgramUniformMatrix2x3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2x3dv(program, location, count, transpose, value); +} + +void gl4_2compat_glProgramUniformMatrix4x3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4x3fv(program, location, count, transpose, value); +} + +void gl4_2compat_glProgramUniformMatrix3x4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3x4fv(program, location, count, transpose, value); +} + +void gl4_2compat_glProgramUniformMatrix4x2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4x2fv(program, location, count, transpose, value); +} + +void gl4_2compat_glProgramUniformMatrix2x4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2x4fv(program, location, count, transpose, value); +} + +void gl4_2compat_glProgramUniformMatrix3x2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3x2fv(program, location, count, transpose, value); +} + +void gl4_2compat_glProgramUniformMatrix2x3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2x3fv(program, location, count, transpose, value); +} + +void gl4_2compat_glProgramUniformMatrix4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4dv(program, location, count, transpose, value); +} + +void gl4_2compat_glProgramUniformMatrix3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3dv(program, location, count, transpose, value); +} + +void gl4_2compat_glProgramUniformMatrix2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2dv(program, location, count, transpose, value); +} + +void gl4_2compat_glProgramUniformMatrix4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4fv(program, location, count, transpose, value); +} + +void gl4_2compat_glProgramUniformMatrix3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3fv(program, location, count, transpose, value); +} + +void gl4_2compat_glProgramUniformMatrix2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2fv(program, location, count, transpose, value); +} + +void gl4_2compat_glProgramUniform4uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4uiv(program, location, count, value); +} + +void gl4_2compat_glProgramUniform4ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4ui(program, location, v0, v1, v2, v3); +} + +void gl4_2compat_glProgramUniform4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4dv(program, location, count, value); +} + +void gl4_2compat_glProgramUniform4d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4d(program, location, v0, v1, v2, v3); +} + +void gl4_2compat_glProgramUniform4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4fv(program, location, count, value); +} + +void gl4_2compat_glProgramUniform4f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4f(program, location, v0, v1, v2, v3); +} + +void gl4_2compat_glProgramUniform4iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4iv(program, location, count, value); +} + +void gl4_2compat_glProgramUniform4i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4i(program, location, v0, v1, v2, v3); +} + +void gl4_2compat_glProgramUniform3uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3uiv(program, location, count, value); +} + +void gl4_2compat_glProgramUniform3ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3ui(program, location, v0, v1, v2); +} + +void gl4_2compat_glProgramUniform3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3dv(program, location, count, value); +} + +void gl4_2compat_glProgramUniform3d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3d(program, location, v0, v1, v2); +} + +void gl4_2compat_glProgramUniform3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3fv(program, location, count, value); +} + +void gl4_2compat_glProgramUniform3f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3f(program, location, v0, v1, v2); +} + +void gl4_2compat_glProgramUniform3iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3iv(program, location, count, value); +} + +void gl4_2compat_glProgramUniform3i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1, GLint v2) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3i(program, location, v0, v1, v2); +} + +void gl4_2compat_glProgramUniform2uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2uiv(program, location, count, value); +} + +void gl4_2compat_glProgramUniform2ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2ui(program, location, v0, v1); +} + +void gl4_2compat_glProgramUniform2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2dv(program, location, count, value); +} + +void gl4_2compat_glProgramUniform2d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2d(program, location, v0, v1); +} + +void gl4_2compat_glProgramUniform2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2fv(program, location, count, value); +} + +void gl4_2compat_glProgramUniform2f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2f(program, location, v0, v1); +} + +void gl4_2compat_glProgramUniform2iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2iv(program, location, count, value); +} + +void gl4_2compat_glProgramUniform2i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2i(program, location, v0, v1); +} + +void gl4_2compat_glProgramUniform1uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1uiv(program, location, count, value); +} + +void gl4_2compat_glProgramUniform1ui(void *_glfuncs, GLuint program, GLint location, GLuint v0) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1ui(program, location, v0); +} + +void gl4_2compat_glProgramUniform1dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1dv(program, location, count, value); +} + +void gl4_2compat_glProgramUniform1d(void *_glfuncs, GLuint program, GLint location, GLdouble v0) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1d(program, location, v0); +} + +void gl4_2compat_glProgramUniform1fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1fv(program, location, count, value); +} + +void gl4_2compat_glProgramUniform1f(void *_glfuncs, GLuint program, GLint location, GLfloat v0) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1f(program, location, v0); +} + +void gl4_2compat_glProgramUniform1iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1iv(program, location, count, value); +} + +void gl4_2compat_glProgramUniform1i(void *_glfuncs, GLuint program, GLint location, GLint v0) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1i(program, location, v0); +} + +void gl4_2compat_glGetProgramPipelineiv(void *_glfuncs, GLuint pipeline, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramPipelineiv(pipeline, pname, params); +} + +GLboolean gl4_2compat_glIsProgramPipeline(void *_glfuncs, GLuint pipeline) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsProgramPipeline(pipeline); +} + +void gl4_2compat_glGenProgramPipelines(void *_glfuncs, GLsizei n, GLuint* pipelines) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenProgramPipelines(n, pipelines); +} + +void gl4_2compat_glDeleteProgramPipelines(void *_glfuncs, GLsizei n, const GLuint* pipelines) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteProgramPipelines(n, pipelines); +} + +void gl4_2compat_glBindProgramPipeline(void *_glfuncs, GLuint pipeline) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindProgramPipeline(pipeline); +} + +void gl4_2compat_glActiveShaderProgram(void *_glfuncs, GLuint pipeline, GLuint program) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glActiveShaderProgram(pipeline, program); +} + +void gl4_2compat_glUseProgramStages(void *_glfuncs, GLuint pipeline, GLbitfield stages, GLuint program) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUseProgramStages(pipeline, stages, program); +} + +void gl4_2compat_glProgramParameteri(void *_glfuncs, GLuint program, GLenum pname, GLint value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramParameteri(program, pname, value); +} + +void gl4_2compat_glProgramBinary(void *_glfuncs, GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramBinary(program, binaryFormat, binary, length); +} + +void gl4_2compat_glGetProgramBinary(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramBinary(program, bufSize, length, binaryFormat, binary); +} + +void gl4_2compat_glClearDepthf(void *_glfuncs, GLfloat dd) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearDepthf(dd); +} + +void gl4_2compat_glDepthRangef(void *_glfuncs, GLfloat n, GLfloat f) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRangef(n, f); +} + +void gl4_2compat_glGetShaderPrecisionFormat(void *_glfuncs, GLenum shadertype, GLenum precisionType, GLint* range_, GLint* precision) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderPrecisionFormat(shadertype, precisionType, range_, precision); +} + +void gl4_2compat_glShaderBinary(void *_glfuncs, GLsizei count, const GLuint* shaders, GLenum binaryFormat, const GLvoid* binary, GLsizei length) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShaderBinary(count, shaders, binaryFormat, binary, length); +} + +void gl4_2compat_glReleaseShaderCompiler(void *_glfuncs) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReleaseShaderCompiler(); +} + +void gl4_2compat_glTexStorage3D(void *_glfuncs, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexStorage3D(target, levels, internalFormat, width, height, depth); +} + +void gl4_2compat_glTexStorage2D(void *_glfuncs, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexStorage2D(target, levels, internalFormat, width, height); +} + +void gl4_2compat_glTexStorage1D(void *_glfuncs, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexStorage1D(target, levels, internalFormat, width); +} + +void gl4_2compat_glMemoryBarrier(void *_glfuncs, GLbitfield barriers) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMemoryBarrier(barriers); +} + +void gl4_2compat_glBindImageTexture(void *_glfuncs, GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindImageTexture(unit, texture, level, layered, layer, access, format); +} + +void gl4_2compat_glGetActiveAtomicCounterBufferiv(void *_glfuncs, GLuint program, GLuint bufferIndex, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params); +} + +void gl4_2compat_glGetInternalformativ(void *_glfuncs, GLenum target, GLenum internalFormat, GLenum pname, GLsizei bufSize, GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetInternalformativ(target, internalFormat, pname, bufSize, params); +} + +void gl4_2compat_glDrawTransformFeedbackStreamInstanced(void *_glfuncs, GLenum mode, GLuint id, GLuint stream, GLsizei instancecount) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount); +} + +void gl4_2compat_glDrawTransformFeedbackInstanced(void *_glfuncs, GLenum mode, GLuint id, GLsizei instancecount) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawTransformFeedbackInstanced(mode, id, instancecount); +} + +void gl4_2compat_glDrawElementsInstancedBaseVertexBaseInstance(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsInstancedBaseVertexBaseInstance(mode, count, gltype, indices, instancecount, basevertex, baseinstance); +} + +void gl4_2compat_glDrawElementsInstancedBaseInstance(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLuint baseinstance) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsInstancedBaseInstance(mode, count, gltype, indices, instancecount, baseinstance); +} + +void gl4_2compat_glDrawArraysInstancedBaseInstance(void *_glfuncs, GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance); +} + +void gl4_2compat_glTranslatef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTranslatef(x, y, z); +} + +void gl4_2compat_glTranslated(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTranslated(x, y, z); +} + +void gl4_2compat_glScalef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScalef(x, y, z); +} + +void gl4_2compat_glScaled(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScaled(x, y, z); +} + +void gl4_2compat_glRotatef(void *_glfuncs, GLfloat angle, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRotatef(angle, x, y, z); +} + +void gl4_2compat_glRotated(void *_glfuncs, GLdouble angle, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRotated(angle, x, y, z); +} + +void gl4_2compat_glPushMatrix(void *_glfuncs) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushMatrix(); +} + +void gl4_2compat_glPopMatrix(void *_glfuncs) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopMatrix(); +} + +void gl4_2compat_glOrtho(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glOrtho(left, right, bottom, top, zNear, zFar); +} + +void gl4_2compat_glMultMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultMatrixd(m); +} + +void gl4_2compat_glMultMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultMatrixf(m); +} + +void gl4_2compat_glMatrixMode(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMatrixMode(mode); +} + +void gl4_2compat_glLoadMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadMatrixd(m); +} + +void gl4_2compat_glLoadMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadMatrixf(m); +} + +void gl4_2compat_glLoadIdentity(void *_glfuncs) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadIdentity(); +} + +void gl4_2compat_glFrustum(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrustum(left, right, bottom, top, zNear, zFar); +} + +GLboolean gl4_2compat_glIsList(void *_glfuncs, GLuint list) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsList(list); +} + +void gl4_2compat_glGetTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGeniv(coord, pname, params); +} + +void gl4_2compat_glGetTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGenfv(coord, pname, params); +} + +void gl4_2compat_glGetTexGendv(void *_glfuncs, GLenum coord, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGendv(coord, pname, params); +} + +void gl4_2compat_glGetTexEnviv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexEnviv(target, pname, params); +} + +void gl4_2compat_glGetTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexEnvfv(target, pname, params); +} + +void gl4_2compat_glGetPolygonStipple(void *_glfuncs, GLubyte* mask) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPolygonStipple(mask); +} + +void gl4_2compat_glGetPixelMapusv(void *_glfuncs, GLenum glmap, GLushort* values) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapusv(glmap, values); +} + +void gl4_2compat_glGetPixelMapuiv(void *_glfuncs, GLenum glmap, GLuint* values) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapuiv(glmap, values); +} + +void gl4_2compat_glGetPixelMapfv(void *_glfuncs, GLenum glmap, GLfloat* values) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapfv(glmap, values); +} + +void gl4_2compat_glGetMaterialiv(void *_glfuncs, GLenum face, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMaterialiv(face, pname, params); +} + +void gl4_2compat_glGetMaterialfv(void *_glfuncs, GLenum face, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMaterialfv(face, pname, params); +} + +void gl4_2compat_glGetMapiv(void *_glfuncs, GLenum target, GLenum query, GLint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapiv(target, query, v); +} + +void gl4_2compat_glGetMapfv(void *_glfuncs, GLenum target, GLenum query, GLfloat* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapfv(target, query, v); +} + +void gl4_2compat_glGetMapdv(void *_glfuncs, GLenum target, GLenum query, GLdouble* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapdv(target, query, v); +} + +void gl4_2compat_glGetLightiv(void *_glfuncs, GLenum light, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetLightiv(light, pname, params); +} + +void gl4_2compat_glGetLightfv(void *_glfuncs, GLenum light, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetLightfv(light, pname, params); +} + +void gl4_2compat_glGetClipPlane(void *_glfuncs, GLenum plane, GLdouble* equation) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetClipPlane(plane, equation); +} + +void gl4_2compat_glDrawPixels(void *_glfuncs, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawPixels(width, height, format, gltype, pixels); +} + +void gl4_2compat_glCopyPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum gltype) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyPixels(x, y, width, height, gltype); +} + +void gl4_2compat_glPixelMapusv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLushort* values) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapusv(glmap, mapsize, values); +} + +void gl4_2compat_glPixelMapuiv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLuint* values) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapuiv(glmap, mapsize, values); +} + +void gl4_2compat_glPixelMapfv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLfloat* values) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapfv(glmap, mapsize, values); +} + +void gl4_2compat_glPixelTransferi(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelTransferi(pname, param); +} + +void gl4_2compat_glPixelTransferf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelTransferf(pname, param); +} + +void gl4_2compat_glPixelZoom(void *_glfuncs, GLfloat xfactor, GLfloat yfactor) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelZoom(xfactor, yfactor); +} + +void gl4_2compat_glAlphaFunc(void *_glfuncs, GLenum glfunc, GLfloat ref) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAlphaFunc(glfunc, ref); +} + +void gl4_2compat_glEvalPoint2(void *_glfuncs, GLint i, GLint j) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalPoint2(i, j); +} + +void gl4_2compat_glEvalMesh2(void *_glfuncs, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalMesh2(mode, i1, i2, j1, j2); +} + +void gl4_2compat_glEvalPoint1(void *_glfuncs, GLint i) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalPoint1(i); +} + +void gl4_2compat_glEvalMesh1(void *_glfuncs, GLenum mode, GLint i1, GLint i2) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalMesh1(mode, i1, i2); +} + +void gl4_2compat_glEvalCoord2fv(void *_glfuncs, const GLfloat* u) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2fv(u); +} + +void gl4_2compat_glEvalCoord2f(void *_glfuncs, GLfloat u, GLfloat v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2f(u, v); +} + +void gl4_2compat_glEvalCoord2dv(void *_glfuncs, const GLdouble* u) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2dv(u); +} + +void gl4_2compat_glEvalCoord2d(void *_glfuncs, GLdouble u, GLdouble v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2d(u, v); +} + +void gl4_2compat_glEvalCoord1fv(void *_glfuncs, const GLfloat* u) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1fv(u); +} + +void gl4_2compat_glEvalCoord1f(void *_glfuncs, GLfloat u) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1f(u); +} + +void gl4_2compat_glEvalCoord1dv(void *_glfuncs, const GLdouble* u) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1dv(u); +} + +void gl4_2compat_glEvalCoord1d(void *_glfuncs, GLdouble u) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1d(u); +} + +void gl4_2compat_glMapGrid2f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid2f(un, u1, u2, vn, v1, v2); +} + +void gl4_2compat_glMapGrid2d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid2d(un, u1, u2, vn, v1, v2); +} + +void gl4_2compat_glMapGrid1f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid1f(un, u1, u2); +} + +void gl4_2compat_glMapGrid1d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid1d(un, u1, u2); +} + +void gl4_2compat_glMap2f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); +} + +void gl4_2compat_glMap2d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); +} + +void gl4_2compat_glMap1f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap1f(target, u1, u2, stride, order, points); +} + +void gl4_2compat_glMap1d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap1d(target, u1, u2, stride, order, points); +} + +void gl4_2compat_glPushAttrib(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushAttrib(mask); +} + +void gl4_2compat_glPopAttrib(void *_glfuncs) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopAttrib(); +} + +void gl4_2compat_glAccum(void *_glfuncs, GLenum op, GLfloat value) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAccum(op, value); +} + +void gl4_2compat_glIndexMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexMask(mask); +} + +void gl4_2compat_glClearIndex(void *_glfuncs, GLfloat c) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearIndex(c); +} + +void gl4_2compat_glClearAccum(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearAccum(red, green, blue, alpha); +} + +void gl4_2compat_glPushName(void *_glfuncs, GLuint name) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushName(name); +} + +void gl4_2compat_glPopName(void *_glfuncs) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopName(); +} + +void gl4_2compat_glPassThrough(void *_glfuncs, GLfloat token) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPassThrough(token); +} + +void gl4_2compat_glLoadName(void *_glfuncs, GLuint name) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadName(name); +} + +void gl4_2compat_glInitNames(void *_glfuncs) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInitNames(); +} + +GLint gl4_2compat_glRenderMode(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glRenderMode(mode); +} + +void gl4_2compat_glSelectBuffer(void *_glfuncs, GLsizei size, GLuint* buffer) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSelectBuffer(size, buffer); +} + +void gl4_2compat_glFeedbackBuffer(void *_glfuncs, GLsizei size, GLenum gltype, GLfloat* buffer) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFeedbackBuffer(size, gltype, buffer); +} + +void gl4_2compat_glTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGeniv(coord, pname, params); +} + +void gl4_2compat_glTexGeni(void *_glfuncs, GLenum coord, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGeni(coord, pname, param); +} + +void gl4_2compat_glTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGenfv(coord, pname, params); +} + +void gl4_2compat_glTexGenf(void *_glfuncs, GLenum coord, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGenf(coord, pname, param); +} + +void gl4_2compat_glTexGendv(void *_glfuncs, GLenum coord, GLenum pname, const GLdouble* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGendv(coord, pname, params); +} + +void gl4_2compat_glTexGend(void *_glfuncs, GLenum coord, GLenum pname, GLdouble param) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGend(coord, pname, param); +} + +void gl4_2compat_glTexEnviv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnviv(target, pname, params); +} + +void gl4_2compat_glTexEnvi(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvi(target, pname, param); +} + +void gl4_2compat_glTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvfv(target, pname, params); +} + +void gl4_2compat_glTexEnvf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvf(target, pname, param); +} + +void gl4_2compat_glShadeModel(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShadeModel(mode); +} + +void gl4_2compat_glPolygonStipple(void *_glfuncs, const GLubyte* mask) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonStipple(mask); +} + +void gl4_2compat_glMaterialiv(void *_glfuncs, GLenum face, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialiv(face, pname, params); +} + +void gl4_2compat_glMateriali(void *_glfuncs, GLenum face, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMateriali(face, pname, param); +} + +void gl4_2compat_glMaterialfv(void *_glfuncs, GLenum face, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialfv(face, pname, params); +} + +void gl4_2compat_glMaterialf(void *_glfuncs, GLenum face, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialf(face, pname, param); +} + +void gl4_2compat_glLineStipple(void *_glfuncs, GLint factor, GLushort pattern) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineStipple(factor, pattern); +} + +void gl4_2compat_glLightModeliv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModeliv(pname, params); +} + +void gl4_2compat_glLightModeli(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModeli(pname, param); +} + +void gl4_2compat_glLightModelfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModelfv(pname, params); +} + +void gl4_2compat_glLightModelf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModelf(pname, param); +} + +void gl4_2compat_glLightiv(void *_glfuncs, GLenum light, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightiv(light, pname, params); +} + +void gl4_2compat_glLighti(void *_glfuncs, GLenum light, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLighti(light, pname, param); +} + +void gl4_2compat_glLightfv(void *_glfuncs, GLenum light, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightfv(light, pname, params); +} + +void gl4_2compat_glLightf(void *_glfuncs, GLenum light, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightf(light, pname, param); +} + +void gl4_2compat_glFogiv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogiv(pname, params); +} + +void gl4_2compat_glFogi(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogi(pname, param); +} + +void gl4_2compat_glFogfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogfv(pname, params); +} + +void gl4_2compat_glFogf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogf(pname, param); +} + +void gl4_2compat_glColorMaterial(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMaterial(face, mode); +} + +void gl4_2compat_glClipPlane(void *_glfuncs, GLenum plane, const GLdouble* equation) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClipPlane(plane, equation); +} + +void gl4_2compat_glVertex4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4sv(v); +} + +void gl4_2compat_glVertex4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4s(x, y, z, w); +} + +void gl4_2compat_glVertex4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4iv(v); +} + +void gl4_2compat_glVertex4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4i(x, y, z, w); +} + +void gl4_2compat_glVertex4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4fv(v); +} + +void gl4_2compat_glVertex4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4f(x, y, z, w); +} + +void gl4_2compat_glVertex4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4dv(v); +} + +void gl4_2compat_glVertex4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4d(x, y, z, w); +} + +void gl4_2compat_glVertex3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3sv(v); +} + +void gl4_2compat_glVertex3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3s(x, y, z); +} + +void gl4_2compat_glVertex3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3iv(v); +} + +void gl4_2compat_glVertex3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3i(x, y, z); +} + +void gl4_2compat_glVertex3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3fv(v); +} + +void gl4_2compat_glVertex3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3f(x, y, z); +} + +void gl4_2compat_glVertex3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3dv(v); +} + +void gl4_2compat_glVertex3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3d(x, y, z); +} + +void gl4_2compat_glVertex2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2sv(v); +} + +void gl4_2compat_glVertex2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2s(x, y); +} + +void gl4_2compat_glVertex2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2iv(v); +} + +void gl4_2compat_glVertex2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2i(x, y); +} + +void gl4_2compat_glVertex2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2fv(v); +} + +void gl4_2compat_glVertex2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2f(x, y); +} + +void gl4_2compat_glVertex2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2dv(v); +} + +void gl4_2compat_glVertex2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2d(x, y); +} + +void gl4_2compat_glTexCoord4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4sv(v); +} + +void gl4_2compat_glTexCoord4s(void *_glfuncs, GLshort s, GLshort t, GLshort r, GLshort q) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4s(s, t, r, q); +} + +void gl4_2compat_glTexCoord4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4iv(v); +} + +void gl4_2compat_glTexCoord4i(void *_glfuncs, GLint s, GLint t, GLint r, GLint q) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4i(s, t, r, q); +} + +void gl4_2compat_glTexCoord4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4fv(v); +} + +void gl4_2compat_glTexCoord4f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4f(s, t, r, q); +} + +void gl4_2compat_glTexCoord4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4dv(v); +} + +void gl4_2compat_glTexCoord4d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r, GLdouble q) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4d(s, t, r, q); +} + +void gl4_2compat_glTexCoord3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3sv(v); +} + +void gl4_2compat_glTexCoord3s(void *_glfuncs, GLshort s, GLshort t, GLshort r) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3s(s, t, r); +} + +void gl4_2compat_glTexCoord3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3iv(v); +} + +void gl4_2compat_glTexCoord3i(void *_glfuncs, GLint s, GLint t, GLint r) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3i(s, t, r); +} + +void gl4_2compat_glTexCoord3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3fv(v); +} + +void gl4_2compat_glTexCoord3f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3f(s, t, r); +} + +void gl4_2compat_glTexCoord3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3dv(v); +} + +void gl4_2compat_glTexCoord3d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3d(s, t, r); +} + +void gl4_2compat_glTexCoord2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2sv(v); +} + +void gl4_2compat_glTexCoord2s(void *_glfuncs, GLshort s, GLshort t) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2s(s, t); +} + +void gl4_2compat_glTexCoord2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2iv(v); +} + +void gl4_2compat_glTexCoord2i(void *_glfuncs, GLint s, GLint t) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2i(s, t); +} + +void gl4_2compat_glTexCoord2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2fv(v); +} + +void gl4_2compat_glTexCoord2f(void *_glfuncs, GLfloat s, GLfloat t) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2f(s, t); +} + +void gl4_2compat_glTexCoord2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2dv(v); +} + +void gl4_2compat_glTexCoord2d(void *_glfuncs, GLdouble s, GLdouble t) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2d(s, t); +} + +void gl4_2compat_glTexCoord1sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1sv(v); +} + +void gl4_2compat_glTexCoord1s(void *_glfuncs, GLshort s) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1s(s); +} + +void gl4_2compat_glTexCoord1iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1iv(v); +} + +void gl4_2compat_glTexCoord1i(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1i(s); +} + +void gl4_2compat_glTexCoord1fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1fv(v); +} + +void gl4_2compat_glTexCoord1f(void *_glfuncs, GLfloat s) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1f(s); +} + +void gl4_2compat_glTexCoord1dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1dv(v); +} + +void gl4_2compat_glTexCoord1d(void *_glfuncs, GLdouble s) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1d(s); +} + +void gl4_2compat_glRectsv(void *_glfuncs, const GLshort* v1, const GLshort* v2) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectsv(v1, v2); +} + +void gl4_2compat_glRects(void *_glfuncs, GLshort x1, GLshort y1, GLshort x2, GLshort y2) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRects(x1, y1, x2, y2); +} + +void gl4_2compat_glRectiv(void *_glfuncs, const GLint* v1, const GLint* v2) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectiv(v1, v2); +} + +void gl4_2compat_glRecti(void *_glfuncs, GLint x1, GLint y1, GLint x2, GLint y2) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRecti(x1, y1, x2, y2); +} + +void gl4_2compat_glRectfv(void *_glfuncs, const GLfloat* v1, const GLfloat* v2) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectfv(v1, v2); +} + +void gl4_2compat_glRectf(void *_glfuncs, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectf(x1, y1, x2, y2); +} + +void gl4_2compat_glRectdv(void *_glfuncs, const GLdouble* v1, const GLdouble* v2) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectdv(v1, v2); +} + +void gl4_2compat_glRectd(void *_glfuncs, GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectd(x1, y1, x2, y2); +} + +void gl4_2compat_glRasterPos4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4sv(v); +} + +void gl4_2compat_glRasterPos4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4s(x, y, z, w); +} + +void gl4_2compat_glRasterPos4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4iv(v); +} + +void gl4_2compat_glRasterPos4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4i(x, y, z, w); +} + +void gl4_2compat_glRasterPos4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4fv(v); +} + +void gl4_2compat_glRasterPos4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4f(x, y, z, w); +} + +void gl4_2compat_glRasterPos4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4dv(v); +} + +void gl4_2compat_glRasterPos4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4d(x, y, z, w); +} + +void gl4_2compat_glRasterPos3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3sv(v); +} + +void gl4_2compat_glRasterPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3s(x, y, z); +} + +void gl4_2compat_glRasterPos3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3iv(v); +} + +void gl4_2compat_glRasterPos3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3i(x, y, z); +} + +void gl4_2compat_glRasterPos3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3fv(v); +} + +void gl4_2compat_glRasterPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3f(x, y, z); +} + +void gl4_2compat_glRasterPos3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3dv(v); +} + +void gl4_2compat_glRasterPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3d(x, y, z); +} + +void gl4_2compat_glRasterPos2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2sv(v); +} + +void gl4_2compat_glRasterPos2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2s(x, y); +} + +void gl4_2compat_glRasterPos2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2iv(v); +} + +void gl4_2compat_glRasterPos2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2i(x, y); +} + +void gl4_2compat_glRasterPos2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2fv(v); +} + +void gl4_2compat_glRasterPos2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2f(x, y); +} + +void gl4_2compat_glRasterPos2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2dv(v); +} + +void gl4_2compat_glRasterPos2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2d(x, y); +} + +void gl4_2compat_glNormal3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3sv(v); +} + +void gl4_2compat_glNormal3s(void *_glfuncs, GLshort nx, GLshort ny, GLshort nz) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3s(nx, ny, nz); +} + +void gl4_2compat_glNormal3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3iv(v); +} + +void gl4_2compat_glNormal3i(void *_glfuncs, GLint nx, GLint ny, GLint nz) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3i(nx, ny, nz); +} + +void gl4_2compat_glNormal3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3fv(v); +} + +void gl4_2compat_glNormal3f(void *_glfuncs, GLfloat nx, GLfloat ny, GLfloat nz) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3f(nx, ny, nz); +} + +void gl4_2compat_glNormal3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3dv(v); +} + +void gl4_2compat_glNormal3d(void *_glfuncs, GLdouble nx, GLdouble ny, GLdouble nz) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3d(nx, ny, nz); +} + +void gl4_2compat_glNormal3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3bv(v); +} + +void gl4_2compat_glNormal3b(void *_glfuncs, GLbyte nx, GLbyte ny, GLbyte nz) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3b(nx, ny, nz); +} + +void gl4_2compat_glIndexsv(void *_glfuncs, const GLshort* c) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexsv(c); +} + +void gl4_2compat_glIndexs(void *_glfuncs, GLshort c) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexs(c); +} + +void gl4_2compat_glIndexiv(void *_glfuncs, const GLint* c) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexiv(c); +} + +void gl4_2compat_glIndexi(void *_glfuncs, GLint c) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexi(c); +} + +void gl4_2compat_glIndexfv(void *_glfuncs, const GLfloat* c) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexfv(c); +} + +void gl4_2compat_glIndexf(void *_glfuncs, GLfloat c) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexf(c); +} + +void gl4_2compat_glIndexdv(void *_glfuncs, const GLdouble* c) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexdv(c); +} + +void gl4_2compat_glIndexd(void *_glfuncs, GLdouble c) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexd(c); +} + +void gl4_2compat_glEnd(void *_glfuncs) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnd(); +} + +void gl4_2compat_glEdgeFlagv(void *_glfuncs, const GLboolean* flag) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlagv(flag); +} + +void gl4_2compat_glEdgeFlag(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlag(flag); +} + +void gl4_2compat_glColor4usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4usv(v); +} + +void gl4_2compat_glColor4us(void *_glfuncs, GLushort red, GLushort green, GLushort blue, GLushort alpha) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4us(red, green, blue, alpha); +} + +void gl4_2compat_glColor4uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4uiv(v); +} + +void gl4_2compat_glColor4ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue, GLuint alpha) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ui(red, green, blue, alpha); +} + +void gl4_2compat_glColor4ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ubv(v); +} + +void gl4_2compat_glColor4ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ub(red, green, blue, alpha); +} + +void gl4_2compat_glColor4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4sv(v); +} + +void gl4_2compat_glColor4s(void *_glfuncs, GLshort red, GLshort green, GLshort blue, GLshort alpha) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4s(red, green, blue, alpha); +} + +void gl4_2compat_glColor4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4iv(v); +} + +void gl4_2compat_glColor4i(void *_glfuncs, GLint red, GLint green, GLint blue, GLint alpha) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4i(red, green, blue, alpha); +} + +void gl4_2compat_glColor4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4fv(v); +} + +void gl4_2compat_glColor4f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4f(red, green, blue, alpha); +} + +void gl4_2compat_glColor4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4dv(v); +} + +void gl4_2compat_glColor4d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4d(red, green, blue, alpha); +} + +void gl4_2compat_glColor4bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4bv(v); +} + +void gl4_2compat_glColor4b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4b(red, green, blue, alpha); +} + +void gl4_2compat_glColor3usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3usv(v); +} + +void gl4_2compat_glColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3us(red, green, blue); +} + +void gl4_2compat_glColor3uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3uiv(v); +} + +void gl4_2compat_glColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ui(red, green, blue); +} + +void gl4_2compat_glColor3ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ubv(v); +} + +void gl4_2compat_glColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ub(red, green, blue); +} + +void gl4_2compat_glColor3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3sv(v); +} + +void gl4_2compat_glColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3s(red, green, blue); +} + +void gl4_2compat_glColor3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3iv(v); +} + +void gl4_2compat_glColor3i(void *_glfuncs, GLint red, GLint green, GLint blue) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3i(red, green, blue); +} + +void gl4_2compat_glColor3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3fv(v); +} + +void gl4_2compat_glColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3f(red, green, blue); +} + +void gl4_2compat_glColor3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3dv(v); +} + +void gl4_2compat_glColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3d(red, green, blue); +} + +void gl4_2compat_glColor3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3bv(v); +} + +void gl4_2compat_glColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3b(red, green, blue); +} + +void gl4_2compat_glBitmap(void *_glfuncs, GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBitmap(width, height, xorig, yorig, xmove, ymove, bitmap); +} + +void gl4_2compat_glBegin(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBegin(mode); +} + +void gl4_2compat_glListBase(void *_glfuncs, GLuint base) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glListBase(base); +} + +GLuint gl4_2compat_glGenLists(void *_glfuncs, GLsizei range_) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGenLists(range_); +} + +void gl4_2compat_glDeleteLists(void *_glfuncs, GLuint list, GLsizei range_) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteLists(list, range_); +} + +void gl4_2compat_glCallLists(void *_glfuncs, GLsizei n, GLenum gltype, const GLvoid* lists) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCallLists(n, gltype, lists); +} + +void gl4_2compat_glCallList(void *_glfuncs, GLuint list) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCallList(list); +} + +void gl4_2compat_glEndList(void *_glfuncs) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndList(); +} + +void gl4_2compat_glNewList(void *_glfuncs, GLuint list, GLenum mode) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNewList(list, mode); +} + +void gl4_2compat_glPushClientAttrib(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushClientAttrib(mask); +} + +void gl4_2compat_glPopClientAttrib(void *_glfuncs) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopClientAttrib(); +} + +void gl4_2compat_glPrioritizeTextures(void *_glfuncs, GLsizei n, const GLuint* textures, const GLfloat* priorities) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPrioritizeTextures(n, textures, priorities); +} + +GLboolean gl4_2compat_glAreTexturesResident(void *_glfuncs, GLsizei n, const GLuint* textures, GLboolean* residences) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glAreTexturesResident(n, textures, residences); +} + +void gl4_2compat_glVertexPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexPointer(size, gltype, stride, pointer); +} + +void gl4_2compat_glTexCoordPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordPointer(size, gltype, stride, pointer); +} + +void gl4_2compat_glNormalPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormalPointer(gltype, stride, pointer); +} + +void gl4_2compat_glInterleavedArrays(void *_glfuncs, GLenum format, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInterleavedArrays(format, stride, pointer); +} + +void gl4_2compat_glIndexPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexPointer(gltype, stride, pointer); +} + +void gl4_2compat_glEnableClientState(void *_glfuncs, GLenum array) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnableClientState(array); +} + +void gl4_2compat_glEdgeFlagPointer(void *_glfuncs, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlagPointer(stride, pointer); +} + +void gl4_2compat_glDisableClientState(void *_glfuncs, GLenum array) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisableClientState(array); +} + +void gl4_2compat_glColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorPointer(size, gltype, stride, pointer); +} + +void gl4_2compat_glArrayElement(void *_glfuncs, GLint i) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glArrayElement(i); +} + +void gl4_2compat_glResetMinmax(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glResetMinmax(target); +} + +void gl4_2compat_glResetHistogram(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glResetHistogram(target); +} + +void gl4_2compat_glMinmax(void *_glfuncs, GLenum target, GLenum internalFormat, GLboolean sink) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMinmax(target, internalFormat, sink); +} + +void gl4_2compat_glHistogram(void *_glfuncs, GLenum target, GLsizei width, GLenum internalFormat, GLboolean sink) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glHistogram(target, width, internalFormat, sink); +} + +void gl4_2compat_glGetMinmaxParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmaxParameteriv(target, pname, params); +} + +void gl4_2compat_glGetMinmaxParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmaxParameterfv(target, pname, params); +} + +void gl4_2compat_glGetMinmax(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmax(target, reset, format, gltype, values); +} + +void gl4_2compat_glGetHistogramParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogramParameteriv(target, pname, params); +} + +void gl4_2compat_glGetHistogramParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogramParameterfv(target, pname, params); +} + +void gl4_2compat_glGetHistogram(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogram(target, reset, format, gltype, values); +} + +void gl4_2compat_glSeparableFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* row, const GLvoid* column) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSeparableFilter2D(target, internalFormat, width, height, format, gltype, row, column); +} + +void gl4_2compat_glGetSeparableFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* row, GLvoid* column, GLvoid* span) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSeparableFilter(target, format, gltype, row, column, span); +} + +void gl4_2compat_glGetConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionParameteriv(target, pname, params); +} + +void gl4_2compat_glGetConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionParameterfv(target, pname, params); +} + +void gl4_2compat_glGetConvolutionFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* image) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionFilter(target, format, gltype, image); +} + +void gl4_2compat_glCopyConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyConvolutionFilter2D(target, internalFormat, x, y, width, height); +} + +void gl4_2compat_glCopyConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyConvolutionFilter1D(target, internalFormat, x, y, width); +} + +void gl4_2compat_glConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameteriv(target, pname, params); +} + +void gl4_2compat_glConvolutionParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameteri(target, pname, params); +} + +void gl4_2compat_glConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameterfv(target, pname, params); +} + +void gl4_2compat_glConvolutionParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameterf(target, pname, params); +} + +void gl4_2compat_glConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* image) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionFilter2D(target, internalFormat, width, height, format, gltype, image); +} + +void gl4_2compat_glConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* image) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionFilter1D(target, internalFormat, width, format, gltype, image); +} + +void gl4_2compat_glCopyColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyColorSubTable(target, start, x, y, width); +} + +void gl4_2compat_glColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum gltype, const GLvoid* data) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorSubTable(target, start, count, format, gltype, data); +} + +void gl4_2compat_glGetColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTableParameteriv(target, pname, params); +} + +void gl4_2compat_glGetColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTableParameterfv(target, pname, params); +} + +void gl4_2compat_glGetColorTable(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* table) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTable(target, format, gltype, table); +} + +void gl4_2compat_glCopyColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyColorTable(target, internalFormat, x, y, width); +} + +void gl4_2compat_glColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTableParameteriv(target, pname, params); +} + +void gl4_2compat_glColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTableParameterfv(target, pname, params); +} + +void gl4_2compat_glColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* table) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTable(target, internalFormat, width, format, gltype, table); +} + +void gl4_2compat_glMultTransposeMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultTransposeMatrixd(m); +} + +void gl4_2compat_glMultTransposeMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultTransposeMatrixf(m); +} + +void gl4_2compat_glLoadTransposeMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadTransposeMatrixd(m); +} + +void gl4_2compat_glLoadTransposeMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadTransposeMatrixf(m); +} + +void gl4_2compat_glMultiTexCoord4sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4sv(target, v); +} + +void gl4_2compat_glMultiTexCoord4s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r, GLshort q) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4s(target, s, t, r, q); +} + +void gl4_2compat_glMultiTexCoord4iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4iv(target, v); +} + +void gl4_2compat_glMultiTexCoord4i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r, GLint q) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4i(target, s, t, r, q); +} + +void gl4_2compat_glMultiTexCoord4fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4fv(target, v); +} + +void gl4_2compat_glMultiTexCoord4f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4f(target, s, t, r, q); +} + +void gl4_2compat_glMultiTexCoord4dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4dv(target, v); +} + +void gl4_2compat_glMultiTexCoord4d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4d(target, s, t, r, q); +} + +void gl4_2compat_glMultiTexCoord3sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3sv(target, v); +} + +void gl4_2compat_glMultiTexCoord3s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3s(target, s, t, r); +} + +void gl4_2compat_glMultiTexCoord3iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3iv(target, v); +} + +void gl4_2compat_glMultiTexCoord3i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3i(target, s, t, r); +} + +void gl4_2compat_glMultiTexCoord3fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3fv(target, v); +} + +void gl4_2compat_glMultiTexCoord3f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3f(target, s, t, r); +} + +void gl4_2compat_glMultiTexCoord3dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3dv(target, v); +} + +void gl4_2compat_glMultiTexCoord3d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3d(target, s, t, r); +} + +void gl4_2compat_glMultiTexCoord2sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2sv(target, v); +} + +void gl4_2compat_glMultiTexCoord2s(void *_glfuncs, GLenum target, GLshort s, GLshort t) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2s(target, s, t); +} + +void gl4_2compat_glMultiTexCoord2iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2iv(target, v); +} + +void gl4_2compat_glMultiTexCoord2i(void *_glfuncs, GLenum target, GLint s, GLint t) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2i(target, s, t); +} + +void gl4_2compat_glMultiTexCoord2fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2fv(target, v); +} + +void gl4_2compat_glMultiTexCoord2f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2f(target, s, t); +} + +void gl4_2compat_glMultiTexCoord2dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2dv(target, v); +} + +void gl4_2compat_glMultiTexCoord2d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2d(target, s, t); +} + +void gl4_2compat_glMultiTexCoord1sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1sv(target, v); +} + +void gl4_2compat_glMultiTexCoord1s(void *_glfuncs, GLenum target, GLshort s) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1s(target, s); +} + +void gl4_2compat_glMultiTexCoord1iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1iv(target, v); +} + +void gl4_2compat_glMultiTexCoord1i(void *_glfuncs, GLenum target, GLint s) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1i(target, s); +} + +void gl4_2compat_glMultiTexCoord1fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1fv(target, v); +} + +void gl4_2compat_glMultiTexCoord1f(void *_glfuncs, GLenum target, GLfloat s) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1f(target, s); +} + +void gl4_2compat_glMultiTexCoord1dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1dv(target, v); +} + +void gl4_2compat_glMultiTexCoord1d(void *_glfuncs, GLenum target, GLdouble s) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1d(target, s); +} + +void gl4_2compat_glClientActiveTexture(void *_glfuncs, GLenum texture) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClientActiveTexture(texture); +} + +void gl4_2compat_glWindowPos3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3sv(v); +} + +void gl4_2compat_glWindowPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3s(x, y, z); +} + +void gl4_2compat_glWindowPos3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3iv(v); +} + +void gl4_2compat_glWindowPos3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3i(x, y, z); +} + +void gl4_2compat_glWindowPos3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3fv(v); +} + +void gl4_2compat_glWindowPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3f(x, y, z); +} + +void gl4_2compat_glWindowPos3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3dv(v); +} + +void gl4_2compat_glWindowPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3d(x, y, z); +} + +void gl4_2compat_glWindowPos2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2sv(v); +} + +void gl4_2compat_glWindowPos2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2s(x, y); +} + +void gl4_2compat_glWindowPos2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2iv(v); +} + +void gl4_2compat_glWindowPos2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2i(x, y); +} + +void gl4_2compat_glWindowPos2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2fv(v); +} + +void gl4_2compat_glWindowPos2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2f(x, y); +} + +void gl4_2compat_glWindowPos2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2dv(v); +} + +void gl4_2compat_glWindowPos2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2d(x, y); +} + +void gl4_2compat_glSecondaryColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColorPointer(size, gltype, stride, pointer); +} + +void gl4_2compat_glSecondaryColor3usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3usv(v); +} + +void gl4_2compat_glSecondaryColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3us(red, green, blue); +} + +void gl4_2compat_glSecondaryColor3uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3uiv(v); +} + +void gl4_2compat_glSecondaryColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3ui(red, green, blue); +} + +void gl4_2compat_glSecondaryColor3ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3ubv(v); +} + +void gl4_2compat_glSecondaryColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3ub(red, green, blue); +} + +void gl4_2compat_glSecondaryColor3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3sv(v); +} + +void gl4_2compat_glSecondaryColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3s(red, green, blue); +} + +void gl4_2compat_glSecondaryColor3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3iv(v); +} + +void gl4_2compat_glSecondaryColor3i(void *_glfuncs, GLint red, GLint green, GLint blue) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3i(red, green, blue); +} + +void gl4_2compat_glSecondaryColor3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3fv(v); +} + +void gl4_2compat_glSecondaryColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3f(red, green, blue); +} + +void gl4_2compat_glSecondaryColor3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3dv(v); +} + +void gl4_2compat_glSecondaryColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3d(red, green, blue); +} + +void gl4_2compat_glSecondaryColor3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3bv(v); +} + +void gl4_2compat_glSecondaryColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3b(red, green, blue); +} + +void gl4_2compat_glFogCoordPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordPointer(gltype, stride, pointer); +} + +void gl4_2compat_glFogCoorddv(void *_glfuncs, const GLdouble* coord) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoorddv(coord); +} + +void gl4_2compat_glFogCoordd(void *_glfuncs, GLdouble coord) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordd(coord); +} + +void gl4_2compat_glFogCoordfv(void *_glfuncs, const GLfloat* coord) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordfv(coord); +} + +void gl4_2compat_glFogCoordf(void *_glfuncs, GLfloat coord) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordf(coord); +} + +void gl4_2compat_glVertexAttrib4usv(void *_glfuncs, GLuint index, const GLushort* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4usv(index, v); +} + +void gl4_2compat_glVertexAttrib4uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4uiv(index, v); +} + +void gl4_2compat_glVertexAttrib4ubv(void *_glfuncs, GLuint index, const GLubyte* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4ubv(index, v); +} + +void gl4_2compat_glVertexAttrib4sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4sv(index, v); +} + +void gl4_2compat_glVertexAttrib4s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4s(index, x, y, z, w); +} + +void gl4_2compat_glVertexAttrib4iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4iv(index, v); +} + +void gl4_2compat_glVertexAttrib4fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4fv(index, v); +} + +void gl4_2compat_glVertexAttrib4f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4f(index, x, y, z, w); +} + +void gl4_2compat_glVertexAttrib4dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4dv(index, v); +} + +void gl4_2compat_glVertexAttrib4d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4d(index, x, y, z, w); +} + +void gl4_2compat_glVertexAttrib4bv(void *_glfuncs, GLuint index, const GLbyte* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4bv(index, v); +} + +void gl4_2compat_glVertexAttrib4Nusv(void *_glfuncs, GLuint index, const GLushort* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nusv(index, v); +} + +void gl4_2compat_glVertexAttrib4Nuiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nuiv(index, v); +} + +void gl4_2compat_glVertexAttrib4Nubv(void *_glfuncs, GLuint index, const GLubyte* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nubv(index, v); +} + +void gl4_2compat_glVertexAttrib4Nub(void *_glfuncs, GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nub(index, x, y, z, w); +} + +void gl4_2compat_glVertexAttrib4Nsv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nsv(index, v); +} + +void gl4_2compat_glVertexAttrib4Niv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Niv(index, v); +} + +void gl4_2compat_glVertexAttrib4Nbv(void *_glfuncs, GLuint index, const GLbyte* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nbv(index, v); +} + +void gl4_2compat_glVertexAttrib3sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3sv(index, v); +} + +void gl4_2compat_glVertexAttrib3s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3s(index, x, y, z); +} + +void gl4_2compat_glVertexAttrib3fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3fv(index, v); +} + +void gl4_2compat_glVertexAttrib3f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3f(index, x, y, z); +} + +void gl4_2compat_glVertexAttrib3dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3dv(index, v); +} + +void gl4_2compat_glVertexAttrib3d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3d(index, x, y, z); +} + +void gl4_2compat_glVertexAttrib2sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2sv(index, v); +} + +void gl4_2compat_glVertexAttrib2s(void *_glfuncs, GLuint index, GLshort x, GLshort y) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2s(index, x, y); +} + +void gl4_2compat_glVertexAttrib2fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2fv(index, v); +} + +void gl4_2compat_glVertexAttrib2f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2f(index, x, y); +} + +void gl4_2compat_glVertexAttrib2dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2dv(index, v); +} + +void gl4_2compat_glVertexAttrib2d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2d(index, x, y); +} + +void gl4_2compat_glVertexAttrib1sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1sv(index, v); +} + +void gl4_2compat_glVertexAttrib1s(void *_glfuncs, GLuint index, GLshort x) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1s(index, x); +} + +void gl4_2compat_glVertexAttrib1fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1fv(index, v); +} + +void gl4_2compat_glVertexAttrib1f(void *_glfuncs, GLuint index, GLfloat x) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1f(index, x); +} + +void gl4_2compat_glVertexAttrib1dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1dv(index, v); +} + +void gl4_2compat_glVertexAttrib1d(void *_glfuncs, GLuint index, GLdouble x) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1d(index, x); +} + +void gl4_2compat_glVertexAttribI4usv(void *_glfuncs, GLuint index, const GLushort* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4usv(index, v); +} + +void gl4_2compat_glVertexAttribI4ubv(void *_glfuncs, GLuint index, const GLubyte* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4ubv(index, v); +} + +void gl4_2compat_glVertexAttribI4sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4sv(index, v); +} + +void gl4_2compat_glVertexAttribI4bv(void *_glfuncs, GLuint index, const GLbyte* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4bv(index, v); +} + +void gl4_2compat_glVertexAttribI4uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4uiv(index, v); +} + +void gl4_2compat_glVertexAttribI3uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI3uiv(index, v); +} + +void gl4_2compat_glVertexAttribI2uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI2uiv(index, v); +} + +void gl4_2compat_glVertexAttribI1uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI1uiv(index, v); +} + +void gl4_2compat_glVertexAttribI4iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4iv(index, v); +} + +void gl4_2compat_glVertexAttribI3iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI3iv(index, v); +} + +void gl4_2compat_glVertexAttribI2iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI2iv(index, v); +} + +void gl4_2compat_glVertexAttribI1iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI1iv(index, v); +} + +void gl4_2compat_glVertexAttribI4ui(void *_glfuncs, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4ui(index, x, y, z, w); +} + +void gl4_2compat_glVertexAttribI3ui(void *_glfuncs, GLuint index, GLuint x, GLuint y, GLuint z) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI3ui(index, x, y, z); +} + +void gl4_2compat_glVertexAttribI2ui(void *_glfuncs, GLuint index, GLuint x, GLuint y) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI2ui(index, x, y); +} + +void gl4_2compat_glVertexAttribI1ui(void *_glfuncs, GLuint index, GLuint x) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI1ui(index, x); +} + +void gl4_2compat_glVertexAttribI4i(void *_glfuncs, GLuint index, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4i(index, x, y, z, w); +} + +void gl4_2compat_glVertexAttribI3i(void *_glfuncs, GLuint index, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI3i(index, x, y, z); +} + +void gl4_2compat_glVertexAttribI2i(void *_glfuncs, GLuint index, GLint x, GLint y) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI2i(index, x, y); +} + +void gl4_2compat_glVertexAttribI1i(void *_glfuncs, GLuint index, GLint x) +{ + QOpenGLFunctions_4_2_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI1i(index, x); +} + diff --git a/gl/4.2compat/funcs.h b/gl/4.2compat/funcs.h new file mode 100644 index 00000000..964194dc --- /dev/null +++ b/gl/4.2compat/funcs.h @@ -0,0 +1,932 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#ifndef __cplusplus +#include +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef char GLchar; +typedef signed char GLbyte; /* 1-byte signed */ +typedef short GLshort; /* 2-byte signed */ +typedef int GLint; /* 4-byte signed */ +typedef unsigned char GLubyte; /* 1-byte unsigned */ +typedef unsigned short GLushort; /* 2-byte unsigned */ +typedef unsigned int GLuint; /* 4-byte unsigned */ +typedef int GLsizei; /* 4-byte signed */ +typedef float GLfloat; /* single precision float */ +typedef float GLclampf; /* single precision float in [0,1] */ +typedef double GLdouble; /* double precision float */ +typedef double GLclampd; /* double precision float in [0,1] */ +typedef int64_t GLint64; +typedef uint64_t GLuint64; +typedef ptrdiff_t GLintptr; +typedef ptrdiff_t GLsizeiptr; +typedef ptrdiff_t GLintptrARB; +typedef ptrdiff_t GLsizeiptrARB; +typedef struct __GLsync *GLsync; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +void *gl4_2compat_funcs(); + +void gl4_2compat_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_2compat_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal); +GLboolean gl4_2compat_glIsEnabled(void *_glfuncs, GLenum cap); +void gl4_2compat_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params); +void gl4_2compat_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params); +void gl4_2compat_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_2compat_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl4_2compat_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels); +void gl4_2compat_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params); +void gl4_2compat_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params); +GLenum gl4_2compat_glGetError(void *_glfuncs); +void gl4_2compat_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params); +void gl4_2compat_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params); +void gl4_2compat_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels); +void gl4_2compat_glReadBuffer(void *_glfuncs, GLenum mode); +void gl4_2compat_glPixelStorei(void *_glfuncs, GLenum pname, GLint param); +void gl4_2compat_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param); +void gl4_2compat_glDepthFunc(void *_glfuncs, GLenum glfunc); +void gl4_2compat_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass); +void gl4_2compat_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask); +void gl4_2compat_glLogicOp(void *_glfuncs, GLenum opcode); +void gl4_2compat_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor); +void gl4_2compat_glFlush(void *_glfuncs); +void gl4_2compat_glFinish(void *_glfuncs); +void gl4_2compat_glEnable(void *_glfuncs, GLenum cap); +void gl4_2compat_glDisable(void *_glfuncs, GLenum cap); +void gl4_2compat_glDepthMask(void *_glfuncs, GLboolean flag); +void gl4_2compat_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +void gl4_2compat_glStencilMask(void *_glfuncs, GLuint mask); +void gl4_2compat_glClearDepth(void *_glfuncs, GLdouble depth); +void gl4_2compat_glClearStencil(void *_glfuncs, GLint s); +void gl4_2compat_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl4_2compat_glClear(void *_glfuncs, GLbitfield mask); +void gl4_2compat_glDrawBuffer(void *_glfuncs, GLenum mode); +void gl4_2compat_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_2compat_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_2compat_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl4_2compat_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl4_2compat_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl4_2compat_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl4_2compat_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_2compat_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode); +void gl4_2compat_glPointSize(void *_glfuncs, GLfloat size); +void gl4_2compat_glLineWidth(void *_glfuncs, GLfloat width); +void gl4_2compat_glHint(void *_glfuncs, GLenum target, GLenum mode); +void gl4_2compat_glFrontFace(void *_glfuncs, GLenum mode); +void gl4_2compat_glCullFace(void *_glfuncs, GLenum mode); +void gl4_2compat_glIndexubv(void *_glfuncs, const GLubyte* c); +void gl4_2compat_glIndexub(void *_glfuncs, GLubyte c); +GLboolean gl4_2compat_glIsTexture(void *_glfuncs, GLuint texture); +void gl4_2compat_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures); +void gl4_2compat_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures); +void gl4_2compat_glBindTexture(void *_glfuncs, GLenum target, GLuint texture); +void gl4_2compat_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_2compat_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_2compat_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_2compat_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +void gl4_2compat_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +void gl4_2compat_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border); +void gl4_2compat_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units); +void gl4_2compat_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl4_2compat_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count); +void gl4_2compat_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_2compat_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_2compat_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_2compat_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl4_2compat_glBlendEquation(void *_glfuncs, GLenum mode); +void gl4_2compat_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl4_2compat_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img); +void gl4_2compat_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl4_2compat_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl4_2compat_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl4_2compat_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data); +void gl4_2compat_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data); +void gl4_2compat_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data); +void gl4_2compat_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert); +void gl4_2compat_glActiveTexture(void *_glfuncs, GLenum texture); +void gl4_2compat_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params); +void gl4_2compat_glPointParameteri(void *_glfuncs, GLenum pname, GLint param); +void gl4_2compat_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl4_2compat_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param); +void gl4_2compat_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount); +void gl4_2compat_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +void gl4_2compat_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +GLboolean gl4_2compat_glUnmapBuffer(void *_glfuncs, GLenum target); +void gl4_2compat_glGetBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data); +void gl4_2compat_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data); +void gl4_2compat_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage); +GLboolean gl4_2compat_glIsBuffer(void *_glfuncs, GLuint buffer); +void gl4_2compat_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers); +void gl4_2compat_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers); +void gl4_2compat_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer); +void gl4_2compat_glGetQueryObjectuiv(void *_glfuncs, GLuint id, GLenum pname, GLuint* params); +void gl4_2compat_glGetQueryObjectiv(void *_glfuncs, GLuint id, GLenum pname, GLint* params); +void gl4_2compat_glGetQueryiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_2compat_glEndQuery(void *_glfuncs, GLenum target); +void gl4_2compat_glBeginQuery(void *_glfuncs, GLenum target, GLuint id); +GLboolean gl4_2compat_glIsQuery(void *_glfuncs, GLuint id); +void gl4_2compat_glDeleteQueries(void *_glfuncs, GLsizei n, const GLuint* ids); +void gl4_2compat_glGenQueries(void *_glfuncs, GLsizei n, GLuint* ids); +void gl4_2compat_glVertexAttribPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLboolean normalized, GLsizei stride, const GLvoid* offset); +void gl4_2compat_glValidateProgram(void *_glfuncs, GLuint program); +void gl4_2compat_glUniformMatrix4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_2compat_glUniformMatrix3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_2compat_glUniformMatrix2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_2compat_glUniform4iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl4_2compat_glUniform3iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl4_2compat_glUniform2iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl4_2compat_glUniform1iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl4_2compat_glUniform4fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl4_2compat_glUniform3fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl4_2compat_glUniform2fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl4_2compat_glUniform1fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl4_2compat_glUniform4i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +void gl4_2compat_glUniform3i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2); +void gl4_2compat_glUniform2i(void *_glfuncs, GLint location, GLint v0, GLint v1); +void gl4_2compat_glUniform1i(void *_glfuncs, GLint location, GLint v0); +void gl4_2compat_glUniform4f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +void gl4_2compat_glUniform3f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +void gl4_2compat_glUniform2f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1); +void gl4_2compat_glUniform1f(void *_glfuncs, GLint location, GLfloat v0); +void gl4_2compat_glUseProgram(void *_glfuncs, GLuint program); +void gl4_2compat_glShaderSource(void *_glfuncs, GLuint shader, GLsizei count, const GLchar** source, const GLint* length); +void gl4_2compat_glLinkProgram(void *_glfuncs, GLuint program); +GLboolean gl4_2compat_glIsShader(void *_glfuncs, GLuint shader); +GLboolean gl4_2compat_glIsProgram(void *_glfuncs, GLuint program); +void gl4_2compat_glGetVertexAttribiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params); +void gl4_2compat_glGetVertexAttribfv(void *_glfuncs, GLuint index, GLenum pname, GLfloat* params); +void gl4_2compat_glGetVertexAttribdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params); +void gl4_2compat_glGetUniformiv(void *_glfuncs, GLuint program, GLint location, GLint* params); +void gl4_2compat_glGetUniformfv(void *_glfuncs, GLuint program, GLint location, GLfloat* params); +GLint gl4_2compat_glGetUniformLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl4_2compat_glGetShaderSource(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source); +void gl4_2compat_glGetShaderInfoLog(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl4_2compat_glGetShaderiv(void *_glfuncs, GLuint shader, GLenum pname, GLint* params); +void gl4_2compat_glGetProgramInfoLog(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl4_2compat_glGetProgramiv(void *_glfuncs, GLuint program, GLenum pname, GLint* params); +GLint gl4_2compat_glGetAttribLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl4_2compat_glGetAttachedShaders(void *_glfuncs, GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj); +void gl4_2compat_glGetActiveUniform(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name); +void gl4_2compat_glGetActiveAttrib(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name); +void gl4_2compat_glEnableVertexAttribArray(void *_glfuncs, GLuint index); +void gl4_2compat_glDisableVertexAttribArray(void *_glfuncs, GLuint index); +void gl4_2compat_glDetachShader(void *_glfuncs, GLuint program, GLuint shader); +void gl4_2compat_glDeleteShader(void *_glfuncs, GLuint shader); +void gl4_2compat_glDeleteProgram(void *_glfuncs, GLuint program); +GLuint gl4_2compat_glCreateShader(void *_glfuncs, GLenum gltype); +GLuint gl4_2compat_glCreateProgram(void *_glfuncs); +void gl4_2compat_glCompileShader(void *_glfuncs, GLuint shader); +void gl4_2compat_glBindAttribLocation(void *_glfuncs, GLuint program, GLuint index, const GLchar* name); +void gl4_2compat_glAttachShader(void *_glfuncs, GLuint program, GLuint shader); +void gl4_2compat_glStencilMaskSeparate(void *_glfuncs, GLenum face, GLuint mask); +void gl4_2compat_glStencilFuncSeparate(void *_glfuncs, GLenum face, GLenum glfunc, GLint ref, GLuint mask); +void gl4_2compat_glStencilOpSeparate(void *_glfuncs, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +void gl4_2compat_glDrawBuffers(void *_glfuncs, GLsizei n, const GLenum* bufs); +void gl4_2compat_glBlendEquationSeparate(void *_glfuncs, GLenum modeRGB, GLenum modeAlpha); +void gl4_2compat_glUniformMatrix4x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_2compat_glUniformMatrix3x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_2compat_glUniformMatrix4x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_2compat_glUniformMatrix2x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_2compat_glUniformMatrix3x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_2compat_glUniformMatrix2x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +GLboolean gl4_2compat_glIsVertexArray(void *_glfuncs, GLuint array); +void gl4_2compat_glGenVertexArrays(void *_glfuncs, GLsizei n, GLuint* arrays); +void gl4_2compat_glDeleteVertexArrays(void *_glfuncs, GLsizei n, const GLuint* arrays); +void gl4_2compat_glBindVertexArray(void *_glfuncs, GLuint array); +void gl4_2compat_glFlushMappedBufferRange(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr length); +void gl4_2compat_glFramebufferTextureLayer(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +void gl4_2compat_glRenderbufferStorageMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height); +void gl4_2compat_glBlitFramebuffer(void *_glfuncs, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +void gl4_2compat_glGenerateMipmap(void *_glfuncs, GLenum target); +void gl4_2compat_glGetFramebufferAttachmentParameteriv(void *_glfuncs, GLenum target, GLenum attachment, GLenum pname, GLint* params); +void gl4_2compat_glFramebufferRenderbuffer(void *_glfuncs, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +void gl4_2compat_glFramebufferTexture3D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +void gl4_2compat_glFramebufferTexture2D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +void gl4_2compat_glFramebufferTexture1D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLenum gl4_2compat_glCheckFramebufferStatus(void *_glfuncs, GLenum target); +void gl4_2compat_glGenFramebuffers(void *_glfuncs, GLsizei n, GLuint* framebuffers); +void gl4_2compat_glDeleteFramebuffers(void *_glfuncs, GLsizei n, const GLuint* framebuffers); +void gl4_2compat_glBindFramebuffer(void *_glfuncs, GLenum target, GLuint framebuffer); +GLboolean gl4_2compat_glIsFramebuffer(void *_glfuncs, GLuint framebuffer); +void gl4_2compat_glGetRenderbufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_2compat_glRenderbufferStorage(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height); +void gl4_2compat_glGenRenderbuffers(void *_glfuncs, GLsizei n, GLuint* renderbuffers); +void gl4_2compat_glDeleteRenderbuffers(void *_glfuncs, GLsizei n, const GLuint* renderbuffers); +void gl4_2compat_glBindRenderbuffer(void *_glfuncs, GLenum target, GLuint renderbuffer); +GLboolean gl4_2compat_glIsRenderbuffer(void *_glfuncs, GLuint renderbuffer); +void gl4_2compat_glClearBufferfi(void *_glfuncs, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); +void gl4_2compat_glClearBufferfv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLfloat* value); +void gl4_2compat_glClearBufferuiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLuint* value); +void gl4_2compat_glClearBufferiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLint* value); +void gl4_2compat_glGetTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, GLuint* params); +void gl4_2compat_glGetTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_2compat_glTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, const GLuint* params); +void gl4_2compat_glTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl4_2compat_glUniform4uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl4_2compat_glUniform3uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl4_2compat_glUniform2uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl4_2compat_glUniform1uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl4_2compat_glUniform4ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +void gl4_2compat_glUniform3ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2); +void gl4_2compat_glUniform2ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1); +void gl4_2compat_glUniform1ui(void *_glfuncs, GLint location, GLuint v0); +GLint gl4_2compat_glGetFragDataLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl4_2compat_glBindFragDataLocation(void *_glfuncs, GLuint program, GLuint color, const GLchar* name); +void gl4_2compat_glGetUniformuiv(void *_glfuncs, GLuint program, GLint location, GLuint* params); +void gl4_2compat_glGetVertexAttribIuiv(void *_glfuncs, GLuint index, GLenum pname, GLuint* params); +void gl4_2compat_glGetVertexAttribIiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params); +void gl4_2compat_glVertexAttribIPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_2compat_glEndConditionalRender(void *_glfuncs); +void gl4_2compat_glBeginConditionalRender(void *_glfuncs, GLuint id, GLenum mode); +void gl4_2compat_glClampColor(void *_glfuncs, GLenum target, GLenum clamp); +void gl4_2compat_glGetTransformFeedbackVarying(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* gltype, GLchar* name); +void gl4_2compat_glBindBufferBase(void *_glfuncs, GLenum target, GLuint index, GLuint buffer); +void gl4_2compat_glBindBufferRange(void *_glfuncs, GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +void gl4_2compat_glEndTransformFeedback(void *_glfuncs); +void gl4_2compat_glBeginTransformFeedback(void *_glfuncs, GLenum primitiveMode); +GLboolean gl4_2compat_glIsEnabledi(void *_glfuncs, GLenum target, GLuint index); +void gl4_2compat_glDisablei(void *_glfuncs, GLenum target, GLuint index); +void gl4_2compat_glEnablei(void *_glfuncs, GLenum target, GLuint index); +void gl4_2compat_glGetIntegeri_v(void *_glfuncs, GLenum target, GLuint index, GLint* data); +void gl4_2compat_glGetBooleani_v(void *_glfuncs, GLenum target, GLuint index, GLboolean* data); +void gl4_2compat_glColorMaski(void *_glfuncs, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +void gl4_2compat_glCopyBufferSubData(void *_glfuncs, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +void gl4_2compat_glUniformBlockBinding(void *_glfuncs, GLuint program, GLuint v0, GLuint v1); +void gl4_2compat_glGetActiveUniformBlockName(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName); +void gl4_2compat_glGetActiveUniformBlockiv(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params); +GLuint gl4_2compat_glGetUniformBlockIndex(void *_glfuncs, GLuint program, const GLchar* uniformBlockName); +void gl4_2compat_glGetActiveUniformName(void *_glfuncs, GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName); +void gl4_2compat_glGetActiveUniformsiv(void *_glfuncs, GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params); +void gl4_2compat_glPrimitiveRestartIndex(void *_glfuncs, GLuint index); +void gl4_2compat_glTexBuffer(void *_glfuncs, GLenum target, GLenum internalFormat, GLuint buffer); +void gl4_2compat_glDrawElementsInstanced(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount); +void gl4_2compat_glDrawArraysInstanced(void *_glfuncs, GLenum mode, GLint first, GLsizei count, GLsizei instancecount); +void gl4_2compat_glSampleMaski(void *_glfuncs, GLuint index, GLbitfield mask); +void gl4_2compat_glGetMultisamplefv(void *_glfuncs, GLenum pname, GLuint index, GLfloat* val); +void gl4_2compat_glTexImage3DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); +void gl4_2compat_glTexImage2DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +void gl4_2compat_glGetSynciv(void *_glfuncs, GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values); +void gl4_2compat_glGetInteger64v(void *_glfuncs, GLenum pname, GLint64* params); +void gl4_2compat_glWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout); +GLenum gl4_2compat_glClientWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout); +void gl4_2compat_glDeleteSync(void *_glfuncs, GLsync sync); +GLboolean gl4_2compat_glIsSync(void *_glfuncs, GLsync sync); +GLsync gl4_2compat_glFenceSync(void *_glfuncs, GLenum condition, GLbitfield flags); +void gl4_2compat_glProvokingVertex(void *_glfuncs, GLenum mode); +void gl4_2compat_glDrawElementsInstancedBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLint basevertex); +void gl4_2compat_glDrawRangeElementsBaseVertex(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex); +void gl4_2compat_glDrawElementsBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex); +void gl4_2compat_glFramebufferTexture(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level); +void gl4_2compat_glGetBufferParameteri64v(void *_glfuncs, GLenum target, GLenum pname, GLint64* params); +void gl4_2compat_glGetInteger64i_v(void *_glfuncs, GLenum target, GLuint index, GLint64* data); +void gl4_2compat_glVertexAttribP4uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl4_2compat_glVertexAttribP4ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl4_2compat_glVertexAttribP3uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl4_2compat_glVertexAttribP3ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl4_2compat_glVertexAttribP2uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl4_2compat_glVertexAttribP2ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl4_2compat_glVertexAttribP1uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl4_2compat_glVertexAttribP1ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl4_2compat_glSecondaryColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color); +void gl4_2compat_glSecondaryColorP3ui(void *_glfuncs, GLenum gltype, GLuint color); +void gl4_2compat_glColorP4uiv(void *_glfuncs, GLenum gltype, const GLuint* color); +void gl4_2compat_glColorP4ui(void *_glfuncs, GLenum gltype, GLuint color); +void gl4_2compat_glColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color); +void gl4_2compat_glColorP3ui(void *_glfuncs, GLenum gltype, GLuint color); +void gl4_2compat_glNormalP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_2compat_glNormalP3ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_2compat_glMultiTexCoordP4uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl4_2compat_glMultiTexCoordP4ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl4_2compat_glMultiTexCoordP3uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl4_2compat_glMultiTexCoordP3ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl4_2compat_glMultiTexCoordP2uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl4_2compat_glMultiTexCoordP2ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl4_2compat_glMultiTexCoordP1uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl4_2compat_glMultiTexCoordP1ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl4_2compat_glTexCoordP4uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_2compat_glTexCoordP4ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_2compat_glTexCoordP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_2compat_glTexCoordP3ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_2compat_glTexCoordP2uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_2compat_glTexCoordP2ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_2compat_glTexCoordP1uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_2compat_glTexCoordP1ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_2compat_glVertexP4uiv(void *_glfuncs, GLenum gltype, const GLuint* value); +void gl4_2compat_glVertexP4ui(void *_glfuncs, GLenum gltype, GLuint value); +void gl4_2compat_glVertexP3uiv(void *_glfuncs, GLenum gltype, const GLuint* value); +void gl4_2compat_glVertexP3ui(void *_glfuncs, GLenum gltype, GLuint value); +void gl4_2compat_glVertexP2uiv(void *_glfuncs, GLenum gltype, const GLuint* value); +void gl4_2compat_glVertexP2ui(void *_glfuncs, GLenum gltype, GLuint value); +void gl4_2compat_glGetQueryObjectui64v(void *_glfuncs, GLuint id, GLenum pname, GLuint64* params); +void gl4_2compat_glGetQueryObjecti64v(void *_glfuncs, GLuint id, GLenum pname, GLint64* params); +void gl4_2compat_glQueryCounter(void *_glfuncs, GLuint id, GLenum target); +void gl4_2compat_glGetSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, GLuint* params); +void gl4_2compat_glGetSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat* params); +void gl4_2compat_glGetSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params); +void gl4_2compat_glGetSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params); +void gl4_2compat_glSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLuint* param); +void gl4_2compat_glSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param); +void gl4_2compat_glSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, const GLfloat* param); +void gl4_2compat_glSamplerParameterf(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat param); +void gl4_2compat_glSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param); +void gl4_2compat_glSamplerParameteri(void *_glfuncs, GLuint sampler, GLenum pname, GLint param); +void gl4_2compat_glBindSampler(void *_glfuncs, GLuint unit, GLuint sampler); +GLboolean gl4_2compat_glIsSampler(void *_glfuncs, GLuint sampler); +void gl4_2compat_glDeleteSamplers(void *_glfuncs, GLsizei count, const GLuint* samplers); +void gl4_2compat_glGenSamplers(void *_glfuncs, GLsizei count, GLuint* samplers); +GLint gl4_2compat_glGetFragDataIndex(void *_glfuncs, GLuint program, const GLchar* name); +void gl4_2compat_glBindFragDataLocationIndexed(void *_glfuncs, GLuint program, GLuint colorNumber, GLuint index, const GLchar* name); +void gl4_2compat_glVertexAttribDivisor(void *_glfuncs, GLuint index, GLuint divisor); +void gl4_2compat_glGetQueryIndexediv(void *_glfuncs, GLenum target, GLuint index, GLenum pname, GLint* params); +void gl4_2compat_glEndQueryIndexed(void *_glfuncs, GLenum target, GLuint index); +void gl4_2compat_glBeginQueryIndexed(void *_glfuncs, GLenum target, GLuint index, GLuint id); +void gl4_2compat_glDrawTransformFeedbackStream(void *_glfuncs, GLenum mode, GLuint id, GLuint stream); +void gl4_2compat_glDrawTransformFeedback(void *_glfuncs, GLenum mode, GLuint id); +void gl4_2compat_glResumeTransformFeedback(void *_glfuncs); +void gl4_2compat_glPauseTransformFeedback(void *_glfuncs); +GLboolean gl4_2compat_glIsTransformFeedback(void *_glfuncs, GLuint id); +void gl4_2compat_glGenTransformFeedbacks(void *_glfuncs, GLsizei n, GLuint* ids); +void gl4_2compat_glDeleteTransformFeedbacks(void *_glfuncs, GLsizei n, const GLuint* ids); +void gl4_2compat_glBindTransformFeedback(void *_glfuncs, GLenum target, GLuint id); +void gl4_2compat_glPatchParameterfv(void *_glfuncs, GLenum pname, const GLfloat* values); +void gl4_2compat_glPatchParameteri(void *_glfuncs, GLenum pname, GLint value); +void gl4_2compat_glGetProgramStageiv(void *_glfuncs, GLuint program, GLenum shadertype, GLenum pname, GLint* values); +void gl4_2compat_glGetUniformSubroutineuiv(void *_glfuncs, GLenum shadertype, GLint location, GLuint* params); +void gl4_2compat_glUniformSubroutinesuiv(void *_glfuncs, GLenum shadertype, GLsizei count, const GLuint* value); +void gl4_2compat_glGetActiveSubroutineName(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name); +void gl4_2compat_glGetActiveSubroutineUniformName(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name); +void gl4_2compat_glGetActiveSubroutineUniformiv(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint* values); +GLuint gl4_2compat_glGetSubroutineIndex(void *_glfuncs, GLuint program, GLenum shadertype, const GLchar* name); +GLint gl4_2compat_glGetSubroutineUniformLocation(void *_glfuncs, GLuint program, GLenum shadertype, const GLchar* name); +void gl4_2compat_glGetUniformdv(void *_glfuncs, GLuint program, GLint location, GLdouble* params); +void gl4_2compat_glUniformMatrix4x3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2compat_glUniformMatrix4x2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2compat_glUniformMatrix3x4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2compat_glUniformMatrix3x2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2compat_glUniformMatrix2x4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2compat_glUniformMatrix2x3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2compat_glUniformMatrix4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2compat_glUniformMatrix3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2compat_glUniformMatrix2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2compat_glUniform4dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value); +void gl4_2compat_glUniform3dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value); +void gl4_2compat_glUniform2dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value); +void gl4_2compat_glUniform1dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value); +void gl4_2compat_glUniform4d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3); +void gl4_2compat_glUniform3d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1, GLdouble v2); +void gl4_2compat_glUniform2d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1); +void gl4_2compat_glUniform1d(void *_glfuncs, GLint location, GLdouble v0); +void gl4_2compat_glDrawElementsIndirect(void *_glfuncs, GLenum mode, GLenum gltype, const GLvoid* indirect); +void gl4_2compat_glDrawArraysIndirect(void *_glfuncs, GLenum mode, const GLvoid* indirect); +void gl4_2compat_glBlendFuncSeparatei(void *_glfuncs, GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); +void gl4_2compat_glBlendFunci(void *_glfuncs, GLuint buf, GLenum src, GLenum dst); +void gl4_2compat_glBlendEquationSeparatei(void *_glfuncs, GLuint buf, GLenum modeRGB, GLenum modeAlpha); +void gl4_2compat_glBlendEquationi(void *_glfuncs, GLuint buf, GLenum mode); +void gl4_2compat_glMinSampleShading(void *_glfuncs, GLfloat value); +void gl4_2compat_glGetDoublei_v(void *_glfuncs, GLenum target, GLuint index, GLdouble* data); +void gl4_2compat_glGetFloati_v(void *_glfuncs, GLenum target, GLuint index, GLfloat* data); +void gl4_2compat_glDepthRangeIndexed(void *_glfuncs, GLuint index, GLdouble n, GLdouble f); +void gl4_2compat_glDepthRangeArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLdouble* v); +void gl4_2compat_glScissorIndexedv(void *_glfuncs, GLuint index, const GLint* v); +void gl4_2compat_glScissorIndexed(void *_glfuncs, GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height); +void gl4_2compat_glScissorArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLint* v); +void gl4_2compat_glViewportIndexedfv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl4_2compat_glViewportIndexedf(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h); +void gl4_2compat_glViewportArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLfloat* v); +void gl4_2compat_glGetVertexAttribLdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params); +void gl4_2compat_glVertexAttribLPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_2compat_glVertexAttribL4dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_2compat_glVertexAttribL3dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_2compat_glVertexAttribL2dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_2compat_glVertexAttribL1dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_2compat_glVertexAttribL4d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl4_2compat_glVertexAttribL3d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z); +void gl4_2compat_glVertexAttribL2d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y); +void gl4_2compat_glVertexAttribL1d(void *_glfuncs, GLuint index, GLdouble x); +void gl4_2compat_glGetProgramPipelineInfoLog(void *_glfuncs, GLuint pipeline, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl4_2compat_glValidateProgramPipeline(void *_glfuncs, GLuint pipeline); +void gl4_2compat_glProgramUniformMatrix4x3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2compat_glProgramUniformMatrix3x4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2compat_glProgramUniformMatrix4x2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2compat_glProgramUniformMatrix2x4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2compat_glProgramUniformMatrix3x2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2compat_glProgramUniformMatrix2x3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2compat_glProgramUniformMatrix4x3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_2compat_glProgramUniformMatrix3x4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_2compat_glProgramUniformMatrix4x2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_2compat_glProgramUniformMatrix2x4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_2compat_glProgramUniformMatrix3x2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_2compat_glProgramUniformMatrix2x3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_2compat_glProgramUniformMatrix4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2compat_glProgramUniformMatrix3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2compat_glProgramUniformMatrix2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2compat_glProgramUniformMatrix4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_2compat_glProgramUniformMatrix3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_2compat_glProgramUniformMatrix2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_2compat_glProgramUniform4uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value); +void gl4_2compat_glProgramUniform4ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +void gl4_2compat_glProgramUniform4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value); +void gl4_2compat_glProgramUniform4d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3); +void gl4_2compat_glProgramUniform4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value); +void gl4_2compat_glProgramUniform4f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +void gl4_2compat_glProgramUniform4iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value); +void gl4_2compat_glProgramUniform4i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +void gl4_2compat_glProgramUniform3uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value); +void gl4_2compat_glProgramUniform3ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2); +void gl4_2compat_glProgramUniform3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value); +void gl4_2compat_glProgramUniform3d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2); +void gl4_2compat_glProgramUniform3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value); +void gl4_2compat_glProgramUniform3f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +void gl4_2compat_glProgramUniform3iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value); +void gl4_2compat_glProgramUniform3i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1, GLint v2); +void gl4_2compat_glProgramUniform2uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value); +void gl4_2compat_glProgramUniform2ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1); +void gl4_2compat_glProgramUniform2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value); +void gl4_2compat_glProgramUniform2d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1); +void gl4_2compat_glProgramUniform2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value); +void gl4_2compat_glProgramUniform2f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1); +void gl4_2compat_glProgramUniform2iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value); +void gl4_2compat_glProgramUniform2i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1); +void gl4_2compat_glProgramUniform1uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value); +void gl4_2compat_glProgramUniform1ui(void *_glfuncs, GLuint program, GLint location, GLuint v0); +void gl4_2compat_glProgramUniform1dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value); +void gl4_2compat_glProgramUniform1d(void *_glfuncs, GLuint program, GLint location, GLdouble v0); +void gl4_2compat_glProgramUniform1fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value); +void gl4_2compat_glProgramUniform1f(void *_glfuncs, GLuint program, GLint location, GLfloat v0); +void gl4_2compat_glProgramUniform1iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value); +void gl4_2compat_glProgramUniform1i(void *_glfuncs, GLuint program, GLint location, GLint v0); +void gl4_2compat_glGetProgramPipelineiv(void *_glfuncs, GLuint pipeline, GLenum pname, GLint* params); +GLboolean gl4_2compat_glIsProgramPipeline(void *_glfuncs, GLuint pipeline); +void gl4_2compat_glGenProgramPipelines(void *_glfuncs, GLsizei n, GLuint* pipelines); +void gl4_2compat_glDeleteProgramPipelines(void *_glfuncs, GLsizei n, const GLuint* pipelines); +void gl4_2compat_glBindProgramPipeline(void *_glfuncs, GLuint pipeline); +void gl4_2compat_glActiveShaderProgram(void *_glfuncs, GLuint pipeline, GLuint program); +void gl4_2compat_glUseProgramStages(void *_glfuncs, GLuint pipeline, GLbitfield stages, GLuint program); +void gl4_2compat_glProgramParameteri(void *_glfuncs, GLuint program, GLenum pname, GLint value); +void gl4_2compat_glProgramBinary(void *_glfuncs, GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length); +void gl4_2compat_glGetProgramBinary(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary); +void gl4_2compat_glClearDepthf(void *_glfuncs, GLfloat dd); +void gl4_2compat_glDepthRangef(void *_glfuncs, GLfloat n, GLfloat f); +void gl4_2compat_glGetShaderPrecisionFormat(void *_glfuncs, GLenum shadertype, GLenum precisionType, GLint* range_, GLint* precision); +void gl4_2compat_glShaderBinary(void *_glfuncs, GLsizei count, const GLuint* shaders, GLenum binaryFormat, const GLvoid* binary, GLsizei length); +void gl4_2compat_glReleaseShaderCompiler(void *_glfuncs); +void gl4_2compat_glTexStorage3D(void *_glfuncs, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth); +void gl4_2compat_glTexStorage2D(void *_glfuncs, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height); +void gl4_2compat_glTexStorage1D(void *_glfuncs, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width); +void gl4_2compat_glMemoryBarrier(void *_glfuncs, GLbitfield barriers); +void gl4_2compat_glBindImageTexture(void *_glfuncs, GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format); +void gl4_2compat_glGetActiveAtomicCounterBufferiv(void *_glfuncs, GLuint program, GLuint bufferIndex, GLenum pname, GLint* params); +void gl4_2compat_glGetInternalformativ(void *_glfuncs, GLenum target, GLenum internalFormat, GLenum pname, GLsizei bufSize, GLint* params); +void gl4_2compat_glDrawTransformFeedbackStreamInstanced(void *_glfuncs, GLenum mode, GLuint id, GLuint stream, GLsizei instancecount); +void gl4_2compat_glDrawTransformFeedbackInstanced(void *_glfuncs, GLenum mode, GLuint id, GLsizei instancecount); +void gl4_2compat_glDrawElementsInstancedBaseVertexBaseInstance(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance); +void gl4_2compat_glDrawElementsInstancedBaseInstance(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLuint baseinstance); +void gl4_2compat_glDrawArraysInstancedBaseInstance(void *_glfuncs, GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance); +void gl4_2compat_glTranslatef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl4_2compat_glTranslated(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl4_2compat_glScalef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl4_2compat_glScaled(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl4_2compat_glRotatef(void *_glfuncs, GLfloat angle, GLfloat x, GLfloat y, GLfloat z); +void gl4_2compat_glRotated(void *_glfuncs, GLdouble angle, GLdouble x, GLdouble y, GLdouble z); +void gl4_2compat_glPushMatrix(void *_glfuncs); +void gl4_2compat_glPopMatrix(void *_glfuncs); +void gl4_2compat_glOrtho(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +void gl4_2compat_glMultMatrixd(void *_glfuncs, const GLdouble* m); +void gl4_2compat_glMultMatrixf(void *_glfuncs, const GLfloat* m); +void gl4_2compat_glMatrixMode(void *_glfuncs, GLenum mode); +void gl4_2compat_glLoadMatrixd(void *_glfuncs, const GLdouble* m); +void gl4_2compat_glLoadMatrixf(void *_glfuncs, const GLfloat* m); +void gl4_2compat_glLoadIdentity(void *_glfuncs); +void gl4_2compat_glFrustum(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +GLboolean gl4_2compat_glIsList(void *_glfuncs, GLuint list); +void gl4_2compat_glGetTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, GLint* params); +void gl4_2compat_glGetTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, GLfloat* params); +void gl4_2compat_glGetTexGendv(void *_glfuncs, GLenum coord, GLenum pname, GLdouble* params); +void gl4_2compat_glGetTexEnviv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_2compat_glGetTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl4_2compat_glGetPolygonStipple(void *_glfuncs, GLubyte* mask); +void gl4_2compat_glGetPixelMapusv(void *_glfuncs, GLenum glmap, GLushort* values); +void gl4_2compat_glGetPixelMapuiv(void *_glfuncs, GLenum glmap, GLuint* values); +void gl4_2compat_glGetPixelMapfv(void *_glfuncs, GLenum glmap, GLfloat* values); +void gl4_2compat_glGetMaterialiv(void *_glfuncs, GLenum face, GLenum pname, GLint* params); +void gl4_2compat_glGetMaterialfv(void *_glfuncs, GLenum face, GLenum pname, GLfloat* params); +void gl4_2compat_glGetMapiv(void *_glfuncs, GLenum target, GLenum query, GLint* v); +void gl4_2compat_glGetMapfv(void *_glfuncs, GLenum target, GLenum query, GLfloat* v); +void gl4_2compat_glGetMapdv(void *_glfuncs, GLenum target, GLenum query, GLdouble* v); +void gl4_2compat_glGetLightiv(void *_glfuncs, GLenum light, GLenum pname, GLint* params); +void gl4_2compat_glGetLightfv(void *_glfuncs, GLenum light, GLenum pname, GLfloat* params); +void gl4_2compat_glGetClipPlane(void *_glfuncs, GLenum plane, GLdouble* equation); +void gl4_2compat_glDrawPixels(void *_glfuncs, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_2compat_glCopyPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum gltype); +void gl4_2compat_glPixelMapusv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLushort* values); +void gl4_2compat_glPixelMapuiv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLuint* values); +void gl4_2compat_glPixelMapfv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLfloat* values); +void gl4_2compat_glPixelTransferi(void *_glfuncs, GLenum pname, GLint param); +void gl4_2compat_glPixelTransferf(void *_glfuncs, GLenum pname, GLfloat param); +void gl4_2compat_glPixelZoom(void *_glfuncs, GLfloat xfactor, GLfloat yfactor); +void gl4_2compat_glAlphaFunc(void *_glfuncs, GLenum glfunc, GLfloat ref); +void gl4_2compat_glEvalPoint2(void *_glfuncs, GLint i, GLint j); +void gl4_2compat_glEvalMesh2(void *_glfuncs, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); +void gl4_2compat_glEvalPoint1(void *_glfuncs, GLint i); +void gl4_2compat_glEvalMesh1(void *_glfuncs, GLenum mode, GLint i1, GLint i2); +void gl4_2compat_glEvalCoord2fv(void *_glfuncs, const GLfloat* u); +void gl4_2compat_glEvalCoord2f(void *_glfuncs, GLfloat u, GLfloat v); +void gl4_2compat_glEvalCoord2dv(void *_glfuncs, const GLdouble* u); +void gl4_2compat_glEvalCoord2d(void *_glfuncs, GLdouble u, GLdouble v); +void gl4_2compat_glEvalCoord1fv(void *_glfuncs, const GLfloat* u); +void gl4_2compat_glEvalCoord1f(void *_glfuncs, GLfloat u); +void gl4_2compat_glEvalCoord1dv(void *_glfuncs, const GLdouble* u); +void gl4_2compat_glEvalCoord1d(void *_glfuncs, GLdouble u); +void gl4_2compat_glMapGrid2f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); +void gl4_2compat_glMapGrid2d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); +void gl4_2compat_glMapGrid1f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2); +void gl4_2compat_glMapGrid1d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2); +void gl4_2compat_glMap2f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points); +void gl4_2compat_glMap2d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points); +void gl4_2compat_glMap1f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points); +void gl4_2compat_glMap1d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points); +void gl4_2compat_glPushAttrib(void *_glfuncs, GLbitfield mask); +void gl4_2compat_glPopAttrib(void *_glfuncs); +void gl4_2compat_glAccum(void *_glfuncs, GLenum op, GLfloat value); +void gl4_2compat_glIndexMask(void *_glfuncs, GLuint mask); +void gl4_2compat_glClearIndex(void *_glfuncs, GLfloat c); +void gl4_2compat_glClearAccum(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl4_2compat_glPushName(void *_glfuncs, GLuint name); +void gl4_2compat_glPopName(void *_glfuncs); +void gl4_2compat_glPassThrough(void *_glfuncs, GLfloat token); +void gl4_2compat_glLoadName(void *_glfuncs, GLuint name); +void gl4_2compat_glInitNames(void *_glfuncs); +GLint gl4_2compat_glRenderMode(void *_glfuncs, GLenum mode); +void gl4_2compat_glSelectBuffer(void *_glfuncs, GLsizei size, GLuint* buffer); +void gl4_2compat_glFeedbackBuffer(void *_glfuncs, GLsizei size, GLenum gltype, GLfloat* buffer); +void gl4_2compat_glTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, const GLint* params); +void gl4_2compat_glTexGeni(void *_glfuncs, GLenum coord, GLenum pname, GLint param); +void gl4_2compat_glTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, const GLfloat* params); +void gl4_2compat_glTexGenf(void *_glfuncs, GLenum coord, GLenum pname, GLfloat param); +void gl4_2compat_glTexGendv(void *_glfuncs, GLenum coord, GLenum pname, const GLdouble* params); +void gl4_2compat_glTexGend(void *_glfuncs, GLenum coord, GLenum pname, GLdouble param); +void gl4_2compat_glTexEnviv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl4_2compat_glTexEnvi(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl4_2compat_glTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl4_2compat_glTexEnvf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl4_2compat_glShadeModel(void *_glfuncs, GLenum mode); +void gl4_2compat_glPolygonStipple(void *_glfuncs, const GLubyte* mask); +void gl4_2compat_glMaterialiv(void *_glfuncs, GLenum face, GLenum pname, const GLint* params); +void gl4_2compat_glMateriali(void *_glfuncs, GLenum face, GLenum pname, GLint param); +void gl4_2compat_glMaterialfv(void *_glfuncs, GLenum face, GLenum pname, const GLfloat* params); +void gl4_2compat_glMaterialf(void *_glfuncs, GLenum face, GLenum pname, GLfloat param); +void gl4_2compat_glLineStipple(void *_glfuncs, GLint factor, GLushort pattern); +void gl4_2compat_glLightModeliv(void *_glfuncs, GLenum pname, const GLint* params); +void gl4_2compat_glLightModeli(void *_glfuncs, GLenum pname, GLint param); +void gl4_2compat_glLightModelfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl4_2compat_glLightModelf(void *_glfuncs, GLenum pname, GLfloat param); +void gl4_2compat_glLightiv(void *_glfuncs, GLenum light, GLenum pname, const GLint* params); +void gl4_2compat_glLighti(void *_glfuncs, GLenum light, GLenum pname, GLint param); +void gl4_2compat_glLightfv(void *_glfuncs, GLenum light, GLenum pname, const GLfloat* params); +void gl4_2compat_glLightf(void *_glfuncs, GLenum light, GLenum pname, GLfloat param); +void gl4_2compat_glFogiv(void *_glfuncs, GLenum pname, const GLint* params); +void gl4_2compat_glFogi(void *_glfuncs, GLenum pname, GLint param); +void gl4_2compat_glFogfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl4_2compat_glFogf(void *_glfuncs, GLenum pname, GLfloat param); +void gl4_2compat_glColorMaterial(void *_glfuncs, GLenum face, GLenum mode); +void gl4_2compat_glClipPlane(void *_glfuncs, GLenum plane, const GLdouble* equation); +void gl4_2compat_glVertex4sv(void *_glfuncs, const GLshort* v); +void gl4_2compat_glVertex4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w); +void gl4_2compat_glVertex4iv(void *_glfuncs, const GLint* v); +void gl4_2compat_glVertex4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w); +void gl4_2compat_glVertex4fv(void *_glfuncs, const GLfloat* v); +void gl4_2compat_glVertex4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl4_2compat_glVertex4dv(void *_glfuncs, const GLdouble* v); +void gl4_2compat_glVertex4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl4_2compat_glVertex3sv(void *_glfuncs, const GLshort* v); +void gl4_2compat_glVertex3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl4_2compat_glVertex3iv(void *_glfuncs, const GLint* v); +void gl4_2compat_glVertex3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl4_2compat_glVertex3fv(void *_glfuncs, const GLfloat* v); +void gl4_2compat_glVertex3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl4_2compat_glVertex3dv(void *_glfuncs, const GLdouble* v); +void gl4_2compat_glVertex3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl4_2compat_glVertex2sv(void *_glfuncs, const GLshort* v); +void gl4_2compat_glVertex2s(void *_glfuncs, GLshort x, GLshort y); +void gl4_2compat_glVertex2iv(void *_glfuncs, const GLint* v); +void gl4_2compat_glVertex2i(void *_glfuncs, GLint x, GLint y); +void gl4_2compat_glVertex2fv(void *_glfuncs, const GLfloat* v); +void gl4_2compat_glVertex2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl4_2compat_glVertex2dv(void *_glfuncs, const GLdouble* v); +void gl4_2compat_glVertex2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl4_2compat_glTexCoord4sv(void *_glfuncs, const GLshort* v); +void gl4_2compat_glTexCoord4s(void *_glfuncs, GLshort s, GLshort t, GLshort r, GLshort q); +void gl4_2compat_glTexCoord4iv(void *_glfuncs, const GLint* v); +void gl4_2compat_glTexCoord4i(void *_glfuncs, GLint s, GLint t, GLint r, GLint q); +void gl4_2compat_glTexCoord4fv(void *_glfuncs, const GLfloat* v); +void gl4_2compat_glTexCoord4f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +void gl4_2compat_glTexCoord4dv(void *_glfuncs, const GLdouble* v); +void gl4_2compat_glTexCoord4d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +void gl4_2compat_glTexCoord3sv(void *_glfuncs, const GLshort* v); +void gl4_2compat_glTexCoord3s(void *_glfuncs, GLshort s, GLshort t, GLshort r); +void gl4_2compat_glTexCoord3iv(void *_glfuncs, const GLint* v); +void gl4_2compat_glTexCoord3i(void *_glfuncs, GLint s, GLint t, GLint r); +void gl4_2compat_glTexCoord3fv(void *_glfuncs, const GLfloat* v); +void gl4_2compat_glTexCoord3f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r); +void gl4_2compat_glTexCoord3dv(void *_glfuncs, const GLdouble* v); +void gl4_2compat_glTexCoord3d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r); +void gl4_2compat_glTexCoord2sv(void *_glfuncs, const GLshort* v); +void gl4_2compat_glTexCoord2s(void *_glfuncs, GLshort s, GLshort t); +void gl4_2compat_glTexCoord2iv(void *_glfuncs, const GLint* v); +void gl4_2compat_glTexCoord2i(void *_glfuncs, GLint s, GLint t); +void gl4_2compat_glTexCoord2fv(void *_glfuncs, const GLfloat* v); +void gl4_2compat_glTexCoord2f(void *_glfuncs, GLfloat s, GLfloat t); +void gl4_2compat_glTexCoord2dv(void *_glfuncs, const GLdouble* v); +void gl4_2compat_glTexCoord2d(void *_glfuncs, GLdouble s, GLdouble t); +void gl4_2compat_glTexCoord1sv(void *_glfuncs, const GLshort* v); +void gl4_2compat_glTexCoord1s(void *_glfuncs, GLshort s); +void gl4_2compat_glTexCoord1iv(void *_glfuncs, const GLint* v); +void gl4_2compat_glTexCoord1i(void *_glfuncs, GLint s); +void gl4_2compat_glTexCoord1fv(void *_glfuncs, const GLfloat* v); +void gl4_2compat_glTexCoord1f(void *_glfuncs, GLfloat s); +void gl4_2compat_glTexCoord1dv(void *_glfuncs, const GLdouble* v); +void gl4_2compat_glTexCoord1d(void *_glfuncs, GLdouble s); +void gl4_2compat_glRectsv(void *_glfuncs, const GLshort* v1, const GLshort* v2); +void gl4_2compat_glRects(void *_glfuncs, GLshort x1, GLshort y1, GLshort x2, GLshort y2); +void gl4_2compat_glRectiv(void *_glfuncs, const GLint* v1, const GLint* v2); +void gl4_2compat_glRecti(void *_glfuncs, GLint x1, GLint y1, GLint x2, GLint y2); +void gl4_2compat_glRectfv(void *_glfuncs, const GLfloat* v1, const GLfloat* v2); +void gl4_2compat_glRectf(void *_glfuncs, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); +void gl4_2compat_glRectdv(void *_glfuncs, const GLdouble* v1, const GLdouble* v2); +void gl4_2compat_glRectd(void *_glfuncs, GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); +void gl4_2compat_glRasterPos4sv(void *_glfuncs, const GLshort* v); +void gl4_2compat_glRasterPos4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w); +void gl4_2compat_glRasterPos4iv(void *_glfuncs, const GLint* v); +void gl4_2compat_glRasterPos4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w); +void gl4_2compat_glRasterPos4fv(void *_glfuncs, const GLfloat* v); +void gl4_2compat_glRasterPos4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl4_2compat_glRasterPos4dv(void *_glfuncs, const GLdouble* v); +void gl4_2compat_glRasterPos4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl4_2compat_glRasterPos3sv(void *_glfuncs, const GLshort* v); +void gl4_2compat_glRasterPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl4_2compat_glRasterPos3iv(void *_glfuncs, const GLint* v); +void gl4_2compat_glRasterPos3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl4_2compat_glRasterPos3fv(void *_glfuncs, const GLfloat* v); +void gl4_2compat_glRasterPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl4_2compat_glRasterPos3dv(void *_glfuncs, const GLdouble* v); +void gl4_2compat_glRasterPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl4_2compat_glRasterPos2sv(void *_glfuncs, const GLshort* v); +void gl4_2compat_glRasterPos2s(void *_glfuncs, GLshort x, GLshort y); +void gl4_2compat_glRasterPos2iv(void *_glfuncs, const GLint* v); +void gl4_2compat_glRasterPos2i(void *_glfuncs, GLint x, GLint y); +void gl4_2compat_glRasterPos2fv(void *_glfuncs, const GLfloat* v); +void gl4_2compat_glRasterPos2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl4_2compat_glRasterPos2dv(void *_glfuncs, const GLdouble* v); +void gl4_2compat_glRasterPos2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl4_2compat_glNormal3sv(void *_glfuncs, const GLshort* v); +void gl4_2compat_glNormal3s(void *_glfuncs, GLshort nx, GLshort ny, GLshort nz); +void gl4_2compat_glNormal3iv(void *_glfuncs, const GLint* v); +void gl4_2compat_glNormal3i(void *_glfuncs, GLint nx, GLint ny, GLint nz); +void gl4_2compat_glNormal3fv(void *_glfuncs, const GLfloat* v); +void gl4_2compat_glNormal3f(void *_glfuncs, GLfloat nx, GLfloat ny, GLfloat nz); +void gl4_2compat_glNormal3dv(void *_glfuncs, const GLdouble* v); +void gl4_2compat_glNormal3d(void *_glfuncs, GLdouble nx, GLdouble ny, GLdouble nz); +void gl4_2compat_glNormal3bv(void *_glfuncs, const GLbyte* v); +void gl4_2compat_glNormal3b(void *_glfuncs, GLbyte nx, GLbyte ny, GLbyte nz); +void gl4_2compat_glIndexsv(void *_glfuncs, const GLshort* c); +void gl4_2compat_glIndexs(void *_glfuncs, GLshort c); +void gl4_2compat_glIndexiv(void *_glfuncs, const GLint* c); +void gl4_2compat_glIndexi(void *_glfuncs, GLint c); +void gl4_2compat_glIndexfv(void *_glfuncs, const GLfloat* c); +void gl4_2compat_glIndexf(void *_glfuncs, GLfloat c); +void gl4_2compat_glIndexdv(void *_glfuncs, const GLdouble* c); +void gl4_2compat_glIndexd(void *_glfuncs, GLdouble c); +void gl4_2compat_glEnd(void *_glfuncs); +void gl4_2compat_glEdgeFlagv(void *_glfuncs, const GLboolean* flag); +void gl4_2compat_glEdgeFlag(void *_glfuncs, GLboolean flag); +void gl4_2compat_glColor4usv(void *_glfuncs, const GLushort* v); +void gl4_2compat_glColor4us(void *_glfuncs, GLushort red, GLushort green, GLushort blue, GLushort alpha); +void gl4_2compat_glColor4uiv(void *_glfuncs, const GLuint* v); +void gl4_2compat_glColor4ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue, GLuint alpha); +void gl4_2compat_glColor4ubv(void *_glfuncs, const GLubyte* v); +void gl4_2compat_glColor4ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); +void gl4_2compat_glColor4sv(void *_glfuncs, const GLshort* v); +void gl4_2compat_glColor4s(void *_glfuncs, GLshort red, GLshort green, GLshort blue, GLshort alpha); +void gl4_2compat_glColor4iv(void *_glfuncs, const GLint* v); +void gl4_2compat_glColor4i(void *_glfuncs, GLint red, GLint green, GLint blue, GLint alpha); +void gl4_2compat_glColor4fv(void *_glfuncs, const GLfloat* v); +void gl4_2compat_glColor4f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl4_2compat_glColor4dv(void *_glfuncs, const GLdouble* v); +void gl4_2compat_glColor4d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); +void gl4_2compat_glColor4bv(void *_glfuncs, const GLbyte* v); +void gl4_2compat_glColor4b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); +void gl4_2compat_glColor3usv(void *_glfuncs, const GLushort* v); +void gl4_2compat_glColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue); +void gl4_2compat_glColor3uiv(void *_glfuncs, const GLuint* v); +void gl4_2compat_glColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue); +void gl4_2compat_glColor3ubv(void *_glfuncs, const GLubyte* v); +void gl4_2compat_glColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue); +void gl4_2compat_glColor3sv(void *_glfuncs, const GLshort* v); +void gl4_2compat_glColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue); +void gl4_2compat_glColor3iv(void *_glfuncs, const GLint* v); +void gl4_2compat_glColor3i(void *_glfuncs, GLint red, GLint green, GLint blue); +void gl4_2compat_glColor3fv(void *_glfuncs, const GLfloat* v); +void gl4_2compat_glColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue); +void gl4_2compat_glColor3dv(void *_glfuncs, const GLdouble* v); +void gl4_2compat_glColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue); +void gl4_2compat_glColor3bv(void *_glfuncs, const GLbyte* v); +void gl4_2compat_glColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue); +void gl4_2compat_glBitmap(void *_glfuncs, GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap); +void gl4_2compat_glBegin(void *_glfuncs, GLenum mode); +void gl4_2compat_glListBase(void *_glfuncs, GLuint base); +GLuint gl4_2compat_glGenLists(void *_glfuncs, GLsizei range_); +void gl4_2compat_glDeleteLists(void *_glfuncs, GLuint list, GLsizei range_); +void gl4_2compat_glCallLists(void *_glfuncs, GLsizei n, GLenum gltype, const GLvoid* lists); +void gl4_2compat_glCallList(void *_glfuncs, GLuint list); +void gl4_2compat_glEndList(void *_glfuncs); +void gl4_2compat_glNewList(void *_glfuncs, GLuint list, GLenum mode); +void gl4_2compat_glPushClientAttrib(void *_glfuncs, GLbitfield mask); +void gl4_2compat_glPopClientAttrib(void *_glfuncs); +void gl4_2compat_glPrioritizeTextures(void *_glfuncs, GLsizei n, const GLuint* textures, const GLfloat* priorities); +GLboolean gl4_2compat_glAreTexturesResident(void *_glfuncs, GLsizei n, const GLuint* textures, GLboolean* residences); +void gl4_2compat_glVertexPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_2compat_glTexCoordPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_2compat_glNormalPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_2compat_glInterleavedArrays(void *_glfuncs, GLenum format, GLsizei stride, const GLvoid* pointer); +void gl4_2compat_glIndexPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_2compat_glEnableClientState(void *_glfuncs, GLenum array); +void gl4_2compat_glEdgeFlagPointer(void *_glfuncs, GLsizei stride, const GLvoid* pointer); +void gl4_2compat_glDisableClientState(void *_glfuncs, GLenum array); +void gl4_2compat_glColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_2compat_glArrayElement(void *_glfuncs, GLint i); +void gl4_2compat_glResetMinmax(void *_glfuncs, GLenum target); +void gl4_2compat_glResetHistogram(void *_glfuncs, GLenum target); +void gl4_2compat_glMinmax(void *_glfuncs, GLenum target, GLenum internalFormat, GLboolean sink); +void gl4_2compat_glHistogram(void *_glfuncs, GLenum target, GLsizei width, GLenum internalFormat, GLboolean sink); +void gl4_2compat_glGetMinmaxParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_2compat_glGetMinmaxParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl4_2compat_glGetMinmax(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values); +void gl4_2compat_glGetHistogramParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_2compat_glGetHistogramParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl4_2compat_glGetHistogram(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values); +void gl4_2compat_glSeparableFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* row, const GLvoid* column); +void gl4_2compat_glGetSeparableFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* row, GLvoid* column, GLvoid* span); +void gl4_2compat_glGetConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_2compat_glGetConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl4_2compat_glGetConvolutionFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* image); +void gl4_2compat_glCopyConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_2compat_glCopyConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width); +void gl4_2compat_glConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl4_2compat_glConvolutionParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint params); +void gl4_2compat_glConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl4_2compat_glConvolutionParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat params); +void gl4_2compat_glConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* image); +void gl4_2compat_glConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* image); +void gl4_2compat_glCopyColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); +void gl4_2compat_glColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum gltype, const GLvoid* data); +void gl4_2compat_glGetColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_2compat_glGetColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl4_2compat_glGetColorTable(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* table); +void gl4_2compat_glCopyColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width); +void gl4_2compat_glColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl4_2compat_glColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl4_2compat_glColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* table); +void gl4_2compat_glMultTransposeMatrixd(void *_glfuncs, const GLdouble* m); +void gl4_2compat_glMultTransposeMatrixf(void *_glfuncs, const GLfloat* m); +void gl4_2compat_glLoadTransposeMatrixd(void *_glfuncs, const GLdouble* m); +void gl4_2compat_glLoadTransposeMatrixf(void *_glfuncs, const GLfloat* m); +void gl4_2compat_glMultiTexCoord4sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl4_2compat_glMultiTexCoord4s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); +void gl4_2compat_glMultiTexCoord4iv(void *_glfuncs, GLenum target, const GLint* v); +void gl4_2compat_glMultiTexCoord4i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r, GLint q); +void gl4_2compat_glMultiTexCoord4fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl4_2compat_glMultiTexCoord4f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +void gl4_2compat_glMultiTexCoord4dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl4_2compat_glMultiTexCoord4d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +void gl4_2compat_glMultiTexCoord3sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl4_2compat_glMultiTexCoord3s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r); +void gl4_2compat_glMultiTexCoord3iv(void *_glfuncs, GLenum target, const GLint* v); +void gl4_2compat_glMultiTexCoord3i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r); +void gl4_2compat_glMultiTexCoord3fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl4_2compat_glMultiTexCoord3f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r); +void gl4_2compat_glMultiTexCoord3dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl4_2compat_glMultiTexCoord3d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r); +void gl4_2compat_glMultiTexCoord2sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl4_2compat_glMultiTexCoord2s(void *_glfuncs, GLenum target, GLshort s, GLshort t); +void gl4_2compat_glMultiTexCoord2iv(void *_glfuncs, GLenum target, const GLint* v); +void gl4_2compat_glMultiTexCoord2i(void *_glfuncs, GLenum target, GLint s, GLint t); +void gl4_2compat_glMultiTexCoord2fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl4_2compat_glMultiTexCoord2f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t); +void gl4_2compat_glMultiTexCoord2dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl4_2compat_glMultiTexCoord2d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t); +void gl4_2compat_glMultiTexCoord1sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl4_2compat_glMultiTexCoord1s(void *_glfuncs, GLenum target, GLshort s); +void gl4_2compat_glMultiTexCoord1iv(void *_glfuncs, GLenum target, const GLint* v); +void gl4_2compat_glMultiTexCoord1i(void *_glfuncs, GLenum target, GLint s); +void gl4_2compat_glMultiTexCoord1fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl4_2compat_glMultiTexCoord1f(void *_glfuncs, GLenum target, GLfloat s); +void gl4_2compat_glMultiTexCoord1dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl4_2compat_glMultiTexCoord1d(void *_glfuncs, GLenum target, GLdouble s); +void gl4_2compat_glClientActiveTexture(void *_glfuncs, GLenum texture); +void gl4_2compat_glWindowPos3sv(void *_glfuncs, const GLshort* v); +void gl4_2compat_glWindowPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl4_2compat_glWindowPos3iv(void *_glfuncs, const GLint* v); +void gl4_2compat_glWindowPos3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl4_2compat_glWindowPos3fv(void *_glfuncs, const GLfloat* v); +void gl4_2compat_glWindowPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl4_2compat_glWindowPos3dv(void *_glfuncs, const GLdouble* v); +void gl4_2compat_glWindowPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl4_2compat_glWindowPos2sv(void *_glfuncs, const GLshort* v); +void gl4_2compat_glWindowPos2s(void *_glfuncs, GLshort x, GLshort y); +void gl4_2compat_glWindowPos2iv(void *_glfuncs, const GLint* v); +void gl4_2compat_glWindowPos2i(void *_glfuncs, GLint x, GLint y); +void gl4_2compat_glWindowPos2fv(void *_glfuncs, const GLfloat* v); +void gl4_2compat_glWindowPos2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl4_2compat_glWindowPos2dv(void *_glfuncs, const GLdouble* v); +void gl4_2compat_glWindowPos2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl4_2compat_glSecondaryColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_2compat_glSecondaryColor3usv(void *_glfuncs, const GLushort* v); +void gl4_2compat_glSecondaryColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue); +void gl4_2compat_glSecondaryColor3uiv(void *_glfuncs, const GLuint* v); +void gl4_2compat_glSecondaryColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue); +void gl4_2compat_glSecondaryColor3ubv(void *_glfuncs, const GLubyte* v); +void gl4_2compat_glSecondaryColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue); +void gl4_2compat_glSecondaryColor3sv(void *_glfuncs, const GLshort* v); +void gl4_2compat_glSecondaryColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue); +void gl4_2compat_glSecondaryColor3iv(void *_glfuncs, const GLint* v); +void gl4_2compat_glSecondaryColor3i(void *_glfuncs, GLint red, GLint green, GLint blue); +void gl4_2compat_glSecondaryColor3fv(void *_glfuncs, const GLfloat* v); +void gl4_2compat_glSecondaryColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue); +void gl4_2compat_glSecondaryColor3dv(void *_glfuncs, const GLdouble* v); +void gl4_2compat_glSecondaryColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue); +void gl4_2compat_glSecondaryColor3bv(void *_glfuncs, const GLbyte* v); +void gl4_2compat_glSecondaryColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue); +void gl4_2compat_glFogCoordPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_2compat_glFogCoorddv(void *_glfuncs, const GLdouble* coord); +void gl4_2compat_glFogCoordd(void *_glfuncs, GLdouble coord); +void gl4_2compat_glFogCoordfv(void *_glfuncs, const GLfloat* coord); +void gl4_2compat_glFogCoordf(void *_glfuncs, GLfloat coord); +void gl4_2compat_glVertexAttrib4usv(void *_glfuncs, GLuint index, const GLushort* v); +void gl4_2compat_glVertexAttrib4uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl4_2compat_glVertexAttrib4ubv(void *_glfuncs, GLuint index, const GLubyte* v); +void gl4_2compat_glVertexAttrib4sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl4_2compat_glVertexAttrib4s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +void gl4_2compat_glVertexAttrib4iv(void *_glfuncs, GLuint index, const GLint* v); +void gl4_2compat_glVertexAttrib4fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl4_2compat_glVertexAttrib4f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl4_2compat_glVertexAttrib4dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_2compat_glVertexAttrib4d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl4_2compat_glVertexAttrib4bv(void *_glfuncs, GLuint index, const GLbyte* v); +void gl4_2compat_glVertexAttrib4Nusv(void *_glfuncs, GLuint index, const GLushort* v); +void gl4_2compat_glVertexAttrib4Nuiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl4_2compat_glVertexAttrib4Nubv(void *_glfuncs, GLuint index, const GLubyte* v); +void gl4_2compat_glVertexAttrib4Nub(void *_glfuncs, GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +void gl4_2compat_glVertexAttrib4Nsv(void *_glfuncs, GLuint index, const GLshort* v); +void gl4_2compat_glVertexAttrib4Niv(void *_glfuncs, GLuint index, const GLint* v); +void gl4_2compat_glVertexAttrib4Nbv(void *_glfuncs, GLuint index, const GLbyte* v); +void gl4_2compat_glVertexAttrib3sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl4_2compat_glVertexAttrib3s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z); +void gl4_2compat_glVertexAttrib3fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl4_2compat_glVertexAttrib3f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z); +void gl4_2compat_glVertexAttrib3dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_2compat_glVertexAttrib3d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z); +void gl4_2compat_glVertexAttrib2sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl4_2compat_glVertexAttrib2s(void *_glfuncs, GLuint index, GLshort x, GLshort y); +void gl4_2compat_glVertexAttrib2fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl4_2compat_glVertexAttrib2f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y); +void gl4_2compat_glVertexAttrib2dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_2compat_glVertexAttrib2d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y); +void gl4_2compat_glVertexAttrib1sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl4_2compat_glVertexAttrib1s(void *_glfuncs, GLuint index, GLshort x); +void gl4_2compat_glVertexAttrib1fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl4_2compat_glVertexAttrib1f(void *_glfuncs, GLuint index, GLfloat x); +void gl4_2compat_glVertexAttrib1dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_2compat_glVertexAttrib1d(void *_glfuncs, GLuint index, GLdouble x); +void gl4_2compat_glVertexAttribI4usv(void *_glfuncs, GLuint index, const GLushort* v); +void gl4_2compat_glVertexAttribI4ubv(void *_glfuncs, GLuint index, const GLubyte* v); +void gl4_2compat_glVertexAttribI4sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl4_2compat_glVertexAttribI4bv(void *_glfuncs, GLuint index, const GLbyte* v); +void gl4_2compat_glVertexAttribI4uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl4_2compat_glVertexAttribI3uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl4_2compat_glVertexAttribI2uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl4_2compat_glVertexAttribI1uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl4_2compat_glVertexAttribI4iv(void *_glfuncs, GLuint index, const GLint* v); +void gl4_2compat_glVertexAttribI3iv(void *_glfuncs, GLuint index, const GLint* v); +void gl4_2compat_glVertexAttribI2iv(void *_glfuncs, GLuint index, const GLint* v); +void gl4_2compat_glVertexAttribI1iv(void *_glfuncs, GLuint index, const GLint* v); +void gl4_2compat_glVertexAttribI4ui(void *_glfuncs, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +void gl4_2compat_glVertexAttribI3ui(void *_glfuncs, GLuint index, GLuint x, GLuint y, GLuint z); +void gl4_2compat_glVertexAttribI2ui(void *_glfuncs, GLuint index, GLuint x, GLuint y); +void gl4_2compat_glVertexAttribI1ui(void *_glfuncs, GLuint index, GLuint x); +void gl4_2compat_glVertexAttribI4i(void *_glfuncs, GLuint index, GLint x, GLint y, GLint z, GLint w); +void gl4_2compat_glVertexAttribI3i(void *_glfuncs, GLuint index, GLint x, GLint y, GLint z); +void gl4_2compat_glVertexAttribI2i(void *_glfuncs, GLuint index, GLint x, GLint y); +void gl4_2compat_glVertexAttribI1i(void *_glfuncs, GLuint index, GLint x); + + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/gl/4.2compat/gl.go b/gl/4.2compat/gl.go new file mode 100644 index 00000000..c91fbef6 --- /dev/null +++ b/gl/4.2compat/gl.go @@ -0,0 +1,9386 @@ +// ** file automatically generated by glgen -- do not edit manually ** + +package GL + +// #cgo CXXFLAGS: -std=c++0x -pedantic-errors -Wall -fno-strict-aliasing +// #cgo LDFLAGS: -lstdc++ +// #cgo pkg-config: Qt5Core Qt5OpenGL +// +// #include "funcs.h" +// +// void free(void*); +// +import "C" + +import ( + "fmt" + "reflect" + "unsafe" + + "gopkg.in/qml.v1/gl/glbase" +) + +// API returns a value that offers methods matching the OpenGL version 4.2 API. +// +// The returned API must not be used after the provided OpenGL context becomes invalid. +func API(context glbase.Contexter) *GL { + gl := &GL{} + gl.funcs = C.gl4_2compat_funcs() + if gl.funcs == nil { + panic(fmt.Errorf("OpenGL version 4.2 is not available")) + } + return gl +} + +// GL implements the OpenGL version 4.2 API. Values of this +// type must be created via the API function, and it must not be used after +// the associated OpenGL context becomes invalid. +type GL struct { + funcs unsafe.Pointer +} + +const ( + FALSE = 0 + TRUE = 1 + NONE = 0 + + BYTE = 0x1400 + UNSIGNED_BYTE = 0x1401 + SHORT = 0x1402 + UNSIGNED_SHORT = 0x1403 + INT = 0x1404 + UNSIGNED_INT = 0x1405 + FLOAT = 0x1406 + N2_BYTES = 0x1407 + N3_BYTES = 0x1408 + N4_BYTES = 0x1409 + DOUBLE = 0x140A + HALF_FLOAT = 0x140B + FIXED = 0x140C + + ACCUM = 0x0100 + LOAD = 0x0101 + RETURN = 0x0102 + MULT = 0x0103 + ADD = 0x0104 + + ACCUM_BUFFER_BIT = 0x00000200 + ALL_ATTRIB_BITS = 0xFFFFFFFF + COLOR_BUFFER_BIT = 0x00004000 + CURRENT_BIT = 0x00000001 + DEPTH_BUFFER_BIT = 0x00000100 + ENABLE_BIT = 0x00002000 + EVAL_BIT = 0x00010000 + FOG_BIT = 0x00000080 + HINT_BIT = 0x00008000 + LIGHTING_BIT = 0x00000040 + LINE_BIT = 0x00000004 + LIST_BIT = 0x00020000 + MULTISAMPLE_BIT = 0x20000000 + PIXEL_MODE_BIT = 0x00000020 + POINT_BIT = 0x00000002 + POLYGON_BIT = 0x00000008 + POLYGON_STIPPLE_BIT = 0x00000010 + SCISSOR_BIT = 0x00080000 + STENCIL_BUFFER_BIT = 0x00000400 + TEXTURE_BIT = 0x00040000 + TRANSFORM_BIT = 0x00001000 + VIEWPORT_BIT = 0x00000800 + + ALWAYS = 0x0207 + EQUAL = 0x0202 + GEQUAL = 0x0206 + GREATER = 0x0204 + LEQUAL = 0x0203 + LESS = 0x0201 + NEVER = 0x0200 + NOTEQUAL = 0x0205 + + LOGIC_OP = 0x0BF1 + + DST_ALPHA = 0x0304 + ONE = 1 + ONE_MINUS_DST_ALPHA = 0x0305 + ONE_MINUS_SRC_ALPHA = 0x0303 + ONE_MINUS_SRC_COLOR = 0x0301 + SRC_ALPHA = 0x0302 + SRC_COLOR = 0x0300 + ZERO = 0 + + DST_COLOR = 0x0306 + ONE_MINUS_DST_COLOR = 0x0307 + SRC_ALPHA_SATURATE = 0x0308 + + CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF + CLIENT_PIXEL_STORE_BIT = 0x00000001 + CLIENT_VERTEX_ARRAY_BIT = 0x00000002 + + CLIP_DISTANCE0 = 0x3000 + CLIP_DISTANCE1 = 0x3001 + CLIP_DISTANCE2 = 0x3002 + CLIP_DISTANCE3 = 0x3003 + CLIP_DISTANCE4 = 0x3004 + CLIP_DISTANCE5 = 0x3005 + CLIP_DISTANCE6 = 0x3006 + CLIP_DISTANCE7 = 0x3007 + CLIP_PLANE0 = 0x3000 + CLIP_PLANE1 = 0x3001 + CLIP_PLANE2 = 0x3002 + CLIP_PLANE3 = 0x3003 + CLIP_PLANE4 = 0x3004 + CLIP_PLANE5 = 0x3005 + + BACK = 0x0405 + FRONT = 0x0404 + FRONT_AND_BACK = 0x0408 + + AMBIENT = 0x1200 + AMBIENT_AND_DIFFUSE = 0x1602 + DIFFUSE = 0x1201 + EMISSION = 0x1600 + SPECULAR = 0x1202 + + CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x00000001 + + CONTEXT_COMPATIBILITY_PROFILE_BIT = 0x00000002 + CONTEXT_CORE_PROFILE_BIT = 0x00000001 + + AUX0 = 0x0409 + AUX1 = 0x040A + AUX2 = 0x040B + AUX3 = 0x040C + BACK_LEFT = 0x0402 + BACK_RIGHT = 0x0403 + FRONT_LEFT = 0x0400 + FRONT_RIGHT = 0x0401 + LEFT = 0x0406 + RIGHT = 0x0407 + + ALPHA_TEST = 0x0BC0 + AUTO_NORMAL = 0x0D80 + BLEND = 0x0BE2 + COLOR_ARRAY = 0x8076 + COLOR_LOGIC_OP = 0x0BF2 + COLOR_MATERIAL = 0x0B57 + CULL_FACE = 0x0B44 + DEPTH_TEST = 0x0B71 + DITHER = 0x0BD0 + EDGE_FLAG_ARRAY = 0x8079 + FOG = 0x0B60 + INDEX_ARRAY = 0x8077 + INDEX_LOGIC_OP = 0x0BF1 + LIGHT0 = 0x4000 + LIGHT1 = 0x4001 + LIGHT2 = 0x4002 + LIGHT3 = 0x4003 + LIGHT4 = 0x4004 + LIGHT5 = 0x4005 + LIGHT6 = 0x4006 + LIGHT7 = 0x4007 + LIGHTING = 0x0B50 + LINE_SMOOTH = 0x0B20 + LINE_STIPPLE = 0x0B24 + MAP1_COLOR_4 = 0x0D90 + MAP1_INDEX = 0x0D91 + MAP1_NORMAL = 0x0D92 + MAP1_TEXTURE_COORD_1 = 0x0D93 + MAP1_TEXTURE_COORD_2 = 0x0D94 + MAP1_TEXTURE_COORD_3 = 0x0D95 + MAP1_TEXTURE_COORD_4 = 0x0D96 + MAP1_VERTEX_3 = 0x0D97 + MAP1_VERTEX_4 = 0x0D98 + MAP2_COLOR_4 = 0x0DB0 + MAP2_INDEX = 0x0DB1 + MAP2_NORMAL = 0x0DB2 + MAP2_TEXTURE_COORD_1 = 0x0DB3 + MAP2_TEXTURE_COORD_2 = 0x0DB4 + MAP2_TEXTURE_COORD_3 = 0x0DB5 + MAP2_TEXTURE_COORD_4 = 0x0DB6 + MAP2_VERTEX_3 = 0x0DB7 + MAP2_VERTEX_4 = 0x0DB8 + NORMALIZE = 0x0BA1 + NORMAL_ARRAY = 0x8075 + POINT_SMOOTH = 0x0B10 + POLYGON_OFFSET_FILL = 0x8037 + POLYGON_OFFSET_LINE = 0x2A02 + POLYGON_OFFSET_POINT = 0x2A01 + POLYGON_SMOOTH = 0x0B41 + POLYGON_STIPPLE = 0x0B42 + SCISSOR_TEST = 0x0C11 + STENCIL_TEST = 0x0B90 + TEXTURE_1D = 0x0DE0 + TEXTURE_2D = 0x0DE1 + TEXTURE_COORD_ARRAY = 0x8078 + TEXTURE_GEN_Q = 0x0C63 + TEXTURE_GEN_R = 0x0C62 + TEXTURE_GEN_S = 0x0C60 + TEXTURE_GEN_T = 0x0C61 + VERTEX_ARRAY = 0x8074 + + INVALID_ENUM = 0x0500 + INVALID_FRAMEBUFFER_OPERATION = 0x0506 + INVALID_OPERATION = 0x0502 + INVALID_VALUE = 0x0501 + NO_ERROR = 0 + OUT_OF_MEMORY = 0x0505 + STACK_OVERFLOW = 0x0503 + STACK_UNDERFLOW = 0x0504 + + N2D = 0x0600 + N3D = 0x0601 + N3D_COLOR = 0x0602 + N3D_COLOR_TEXTURE = 0x0603 + N4D_COLOR_TEXTURE = 0x0604 + + BITMAP_TOKEN = 0x0704 + COPY_PIXEL_TOKEN = 0x0706 + DRAW_PIXEL_TOKEN = 0x0705 + LINE_RESET_TOKEN = 0x0707 + LINE_TOKEN = 0x0702 + PASS_THROUGH_TOKEN = 0x0700 + POINT_TOKEN = 0x0701 + POLYGON_TOKEN = 0x0703 + + EXP = 0x0800 + EXP2 = 0x0801 + LINEAR = 0x2601 + + FOG_COLOR = 0x0B66 + FOG_DENSITY = 0x0B62 + FOG_END = 0x0B64 + FOG_INDEX = 0x0B61 + FOG_MODE = 0x0B65 + FOG_START = 0x0B63 + + CCW = 0x0901 + CW = 0x0900 + + COEFF = 0x0A00 + DOMAIN = 0x0A02 + ORDER = 0x0A01 + + PIXEL_MAP_A_TO_A = 0x0C79 + PIXEL_MAP_B_TO_B = 0x0C78 + PIXEL_MAP_G_TO_G = 0x0C77 + PIXEL_MAP_I_TO_A = 0x0C75 + PIXEL_MAP_I_TO_B = 0x0C74 + PIXEL_MAP_I_TO_G = 0x0C73 + PIXEL_MAP_I_TO_I = 0x0C70 + PIXEL_MAP_I_TO_R = 0x0C72 + PIXEL_MAP_R_TO_R = 0x0C76 + PIXEL_MAP_S_TO_S = 0x0C71 + + ACCUM_ALPHA_BITS = 0x0D5B + ACCUM_BLUE_BITS = 0x0D5A + ACCUM_CLEAR_VALUE = 0x0B80 + ACCUM_GREEN_BITS = 0x0D59 + ACCUM_RED_BITS = 0x0D58 + ALIASED_LINE_WIDTH_RANGE = 0x846E + ALIASED_POINT_SIZE_RANGE = 0x846D + ALPHA_BIAS = 0x0D1D + ALPHA_BITS = 0x0D55 + ALPHA_SCALE = 0x0D1C + ALPHA_TEST_FUNC = 0x0BC1 + ALPHA_TEST_REF = 0x0BC2 + ATTRIB_STACK_DEPTH = 0x0BB0 + AUX_BUFFERS = 0x0C00 + BLEND_DST = 0x0BE0 + BLEND_SRC = 0x0BE1 + BLUE_BIAS = 0x0D1B + BLUE_BITS = 0x0D54 + BLUE_SCALE = 0x0D1A + CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1 + COLOR_ARRAY_SIZE = 0x8081 + COLOR_ARRAY_STRIDE = 0x8083 + COLOR_ARRAY_TYPE = 0x8082 + COLOR_CLEAR_VALUE = 0x0C22 + COLOR_MATERIAL_FACE = 0x0B55 + COLOR_MATERIAL_PARAMETER = 0x0B56 + COLOR_WRITEMASK = 0x0C23 + CULL_FACE_MODE = 0x0B45 + CURRENT_COLOR = 0x0B00 + CURRENT_INDEX = 0x0B01 + CURRENT_NORMAL = 0x0B02 + CURRENT_RASTER_COLOR = 0x0B04 + CURRENT_RASTER_DISTANCE = 0x0B09 + CURRENT_RASTER_INDEX = 0x0B05 + CURRENT_RASTER_POSITION = 0x0B07 + CURRENT_RASTER_POSITION_VALID = 0x0B08 + CURRENT_RASTER_TEXTURE_COORDS = 0x0B06 + CURRENT_TEXTURE_COORDS = 0x0B03 + DEPTH_BIAS = 0x0D1F + DEPTH_BITS = 0x0D56 + DEPTH_CLEAR_VALUE = 0x0B73 + DEPTH_FUNC = 0x0B74 + DEPTH_RANGE = 0x0B70 + DEPTH_SCALE = 0x0D1E + DEPTH_WRITEMASK = 0x0B72 + DOUBLEBUFFER = 0x0C32 + DRAW_BUFFER = 0x0C01 + EDGE_FLAG = 0x0B43 + EDGE_FLAG_ARRAY_STRIDE = 0x808C + FEEDBACK_BUFFER_SIZE = 0x0DF1 + FEEDBACK_BUFFER_TYPE = 0x0DF2 + FOG_HINT = 0x0C54 + FRONT_FACE = 0x0B46 + GREEN_BIAS = 0x0D19 + GREEN_BITS = 0x0D53 + GREEN_SCALE = 0x0D18 + INDEX_ARRAY_STRIDE = 0x8086 + INDEX_ARRAY_TYPE = 0x8085 + INDEX_BITS = 0x0D51 + INDEX_CLEAR_VALUE = 0x0C20 + INDEX_MODE = 0x0C30 + INDEX_OFFSET = 0x0D13 + INDEX_SHIFT = 0x0D12 + INDEX_WRITEMASK = 0x0C21 + LIGHT_MODEL_AMBIENT = 0x0B53 + LIGHT_MODEL_COLOR_CONTROL = 0x81F8 + LIGHT_MODEL_LOCAL_VIEWER = 0x0B51 + LIGHT_MODEL_TWO_SIDE = 0x0B52 + LINE_SMOOTH_HINT = 0x0C52 + LINE_STIPPLE_PATTERN = 0x0B25 + LINE_STIPPLE_REPEAT = 0x0B26 + LINE_WIDTH = 0x0B21 + LINE_WIDTH_GRANULARITY = 0x0B23 + LINE_WIDTH_RANGE = 0x0B22 + LIST_BASE = 0x0B32 + LIST_INDEX = 0x0B33 + LIST_MODE = 0x0B30 + LOGIC_OP_MODE = 0x0BF0 + MAP1_GRID_DOMAIN = 0x0DD0 + MAP1_GRID_SEGMENTS = 0x0DD1 + MAP2_GRID_DOMAIN = 0x0DD2 + MAP2_GRID_SEGMENTS = 0x0DD3 + MAP_COLOR = 0x0D10 + MAP_STENCIL = 0x0D11 + MATRIX_MODE = 0x0BA0 + MAX_ATTRIB_STACK_DEPTH = 0x0D35 + MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B + MAX_CLIP_DISTANCES = 0x0D32 + MAX_CLIP_PLANES = 0x0D32 + MAX_EVAL_ORDER = 0x0D30 + MAX_LIGHTS = 0x0D31 + MAX_LIST_NESTING = 0x0B31 + MAX_MODELVIEW_STACK_DEPTH = 0x0D36 + MAX_NAME_STACK_DEPTH = 0x0D37 + MAX_PIXEL_MAP_TABLE = 0x0D34 + MAX_PROJECTION_STACK_DEPTH = 0x0D38 + MAX_TEXTURE_SIZE = 0x0D33 + MAX_TEXTURE_STACK_DEPTH = 0x0D39 + MAX_VIEWPORT_DIMS = 0x0D3A + MODELVIEW_MATRIX = 0x0BA6 + MODELVIEW_STACK_DEPTH = 0x0BA3 + NAME_STACK_DEPTH = 0x0D70 + NORMAL_ARRAY_STRIDE = 0x807F + NORMAL_ARRAY_TYPE = 0x807E + PACK_ALIGNMENT = 0x0D05 + PACK_LSB_FIRST = 0x0D01 + PACK_ROW_LENGTH = 0x0D02 + PACK_SKIP_PIXELS = 0x0D04 + PACK_SKIP_ROWS = 0x0D03 + PACK_SWAP_BYTES = 0x0D00 + PERSPECTIVE_CORRECTION_HINT = 0x0C50 + PIXEL_MAP_A_TO_A_SIZE = 0x0CB9 + PIXEL_MAP_B_TO_B_SIZE = 0x0CB8 + PIXEL_MAP_G_TO_G_SIZE = 0x0CB7 + PIXEL_MAP_I_TO_A_SIZE = 0x0CB5 + PIXEL_MAP_I_TO_B_SIZE = 0x0CB4 + PIXEL_MAP_I_TO_G_SIZE = 0x0CB3 + PIXEL_MAP_I_TO_I_SIZE = 0x0CB0 + PIXEL_MAP_I_TO_R_SIZE = 0x0CB2 + PIXEL_MAP_R_TO_R_SIZE = 0x0CB6 + PIXEL_MAP_S_TO_S_SIZE = 0x0CB1 + POINT_SIZE = 0x0B11 + POINT_SIZE_GRANULARITY = 0x0B13 + POINT_SIZE_RANGE = 0x0B12 + POINT_SMOOTH_HINT = 0x0C51 + POLYGON_MODE = 0x0B40 + POLYGON_OFFSET_FACTOR = 0x8038 + POLYGON_OFFSET_UNITS = 0x2A00 + POLYGON_SMOOTH_HINT = 0x0C53 + PROJECTION_MATRIX = 0x0BA7 + PROJECTION_STACK_DEPTH = 0x0BA4 + READ_BUFFER = 0x0C02 + RED_BIAS = 0x0D15 + RED_BITS = 0x0D52 + RED_SCALE = 0x0D14 + RENDER_MODE = 0x0C40 + RGBA_MODE = 0x0C31 + SCISSOR_BOX = 0x0C10 + SELECTION_BUFFER_SIZE = 0x0DF4 + SHADE_MODEL = 0x0B54 + SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23 + SMOOTH_LINE_WIDTH_RANGE = 0x0B22 + SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13 + SMOOTH_POINT_SIZE_RANGE = 0x0B12 + STENCIL_BITS = 0x0D57 + STENCIL_CLEAR_VALUE = 0x0B91 + STENCIL_FAIL = 0x0B94 + STENCIL_FUNC = 0x0B92 + STENCIL_PASS_DEPTH_FAIL = 0x0B95 + STENCIL_PASS_DEPTH_PASS = 0x0B96 + STENCIL_REF = 0x0B97 + STENCIL_VALUE_MASK = 0x0B93 + STENCIL_WRITEMASK = 0x0B98 + STEREO = 0x0C33 + SUBPIXEL_BITS = 0x0D50 + TEXTURE_BINDING_1D = 0x8068 + TEXTURE_BINDING_2D = 0x8069 + TEXTURE_BINDING_3D = 0x806A + TEXTURE_COORD_ARRAY_SIZE = 0x8088 + TEXTURE_COORD_ARRAY_STRIDE = 0x808A + TEXTURE_COORD_ARRAY_TYPE = 0x8089 + TEXTURE_MATRIX = 0x0BA8 + TEXTURE_STACK_DEPTH = 0x0BA5 + UNPACK_ALIGNMENT = 0x0CF5 + UNPACK_LSB_FIRST = 0x0CF1 + UNPACK_ROW_LENGTH = 0x0CF2 + UNPACK_SKIP_PIXELS = 0x0CF4 + UNPACK_SKIP_ROWS = 0x0CF3 + UNPACK_SWAP_BYTES = 0x0CF0 + VERTEX_ARRAY_SIZE = 0x807A + VERTEX_ARRAY_STRIDE = 0x807C + VERTEX_ARRAY_TYPE = 0x807B + VIEWPORT = 0x0BA2 + ZOOM_X = 0x0D16 + ZOOM_Y = 0x0D17 + + COLOR_ARRAY_POINTER = 0x8090 + EDGE_FLAG_ARRAY_POINTER = 0x8093 + FEEDBACK_BUFFER_POINTER = 0x0DF0 + INDEX_ARRAY_POINTER = 0x8091 + NORMAL_ARRAY_POINTER = 0x808F + SELECTION_BUFFER_POINTER = 0x0DF3 + TEXTURE_COORD_ARRAY_POINTER = 0x8092 + VERTEX_ARRAY_POINTER = 0x808E + + TEXTURE_ALPHA_SIZE = 0x805F + TEXTURE_BLUE_SIZE = 0x805E + TEXTURE_BORDER = 0x1005 + TEXTURE_BORDER_COLOR = 0x1004 + TEXTURE_COMPONENTS = 0x1003 + TEXTURE_GREEN_SIZE = 0x805D + TEXTURE_HEIGHT = 0x1001 + TEXTURE_INTENSITY_SIZE = 0x8061 + TEXTURE_INTERNAL_FORMAT = 0x1003 + TEXTURE_LUMINANCE_SIZE = 0x8060 + TEXTURE_MAG_FILTER = 0x2800 + TEXTURE_MIN_FILTER = 0x2801 + TEXTURE_PRIORITY = 0x8066 + TEXTURE_RED_SIZE = 0x805C + TEXTURE_RESIDENT = 0x8067 + TEXTURE_WIDTH = 0x1000 + TEXTURE_WRAP_S = 0x2802 + TEXTURE_WRAP_T = 0x2803 + + DONT_CARE = 0x1100 + FASTEST = 0x1101 + NICEST = 0x1102 + + FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B + GENERATE_MIPMAP_HINT = 0x8192 + PROGRAM_BINARY_RETRIEVABLE_HINT = 0x8257 + TEXTURE_COMPRESSION_HINT = 0x84EF + + C3F_V3F = 0x2A24 + C4F_N3F_V3F = 0x2A26 + C4UB_V2F = 0x2A22 + C4UB_V3F = 0x2A23 + N3F_V3F = 0x2A25 + T2F_C3F_V3F = 0x2A2A + T2F_C4F_N3F_V3F = 0x2A2C + T2F_C4UB_V3F = 0x2A29 + T2F_N3F_V3F = 0x2A2B + T2F_V3F = 0x2A27 + T4F_C4F_N3F_V4F = 0x2A2D + T4F_V4F = 0x2A28 + V2F = 0x2A20 + V3F = 0x2A21 + + MODULATE = 0x2100 + REPLACE = 0x1E01 + + SEPARATE_SPECULAR_COLOR = 0x81FA + SINGLE_COLOR = 0x81F9 + + CONSTANT_ATTENUATION = 0x1207 + LINEAR_ATTENUATION = 0x1208 + POSITION = 0x1203 + QUADRATIC_ATTENUATION = 0x1209 + SPOT_CUTOFF = 0x1206 + SPOT_DIRECTION = 0x1204 + SPOT_EXPONENT = 0x1205 + + COMPILE = 0x1300 + COMPILE_AND_EXECUTE = 0x1301 + + AND = 0x1501 + AND_INVERTED = 0x1504 + AND_REVERSE = 0x1502 + CLEAR = 0x1500 + COPY = 0x1503 + COPY_INVERTED = 0x150C + EQUIV = 0x1509 + INVERT = 0x150A + NAND = 0x150E + NOOP = 0x1505 + NOR = 0x1508 + OR = 0x1507 + OR_INVERTED = 0x150D + OR_REVERSE = 0x150B + SET = 0x150F + XOR = 0x1506 + + MAP_FLUSH_EXPLICIT_BIT = 0x0010 + MAP_INVALIDATE_BUFFER_BIT = 0x0008 + MAP_INVALIDATE_RANGE_BIT = 0x0004 + MAP_READ_BIT = 0x0001 + MAP_UNSYNCHRONIZED_BIT = 0x0020 + MAP_WRITE_BIT = 0x0002 + + COLOR_INDEXES = 0x1603 + SHININESS = 0x1601 + + MODELVIEW = 0x1700 + PROJECTION = 0x1701 + TEXTURE = 0x1702 + + ALL_BARRIER_BITS = 0xFFFFFFFF + ATOMIC_COUNTER_BARRIER_BIT = 0x00001000 + BUFFER_UPDATE_BARRIER_BIT = 0x00000200 + COMMAND_BARRIER_BIT = 0x00000040 + ELEMENT_ARRAY_BARRIER_BIT = 0x00000002 + FRAMEBUFFER_BARRIER_BIT = 0x00000400 + PIXEL_BUFFER_BARRIER_BIT = 0x00000080 + SHADER_IMAGE_ACCESS_BARRIER_BIT = 0x00000020 + TEXTURE_FETCH_BARRIER_BIT = 0x00000008 + TEXTURE_UPDATE_BARRIER_BIT = 0x00000100 + TRANSFORM_FEEDBACK_BARRIER_BIT = 0x00000800 + UNIFORM_BARRIER_BIT = 0x00000004 + VERTEX_ATTRIB_ARRAY_BARRIER_BIT = 0x00000001 + + LINE = 0x1B01 + POINT = 0x1B00 + + FILL = 0x1B02 + + COLOR = 0x1800 + DEPTH = 0x1801 + STENCIL = 0x1802 + + ALPHA = 0x1906 + BLUE = 0x1905 + COLOR_INDEX = 0x1900 + DEPTH_COMPONENT = 0x1902 + GREEN = 0x1904 + LUMINANCE = 0x1909 + LUMINANCE_ALPHA = 0x190A + RED = 0x1903 + RGB = 0x1907 + RGBA = 0x1908 + STENCIL_INDEX = 0x1901 + + ALPHA12 = 0x803D + ALPHA16 = 0x803E + ALPHA4 = 0x803B + ALPHA8 = 0x803C + INTENSITY = 0x8049 + INTENSITY12 = 0x804C + INTENSITY16 = 0x804D + INTENSITY4 = 0x804A + INTENSITY8 = 0x804B + LUMINANCE12 = 0x8041 + LUMINANCE12_ALPHA12 = 0x8047 + LUMINANCE12_ALPHA4 = 0x8046 + LUMINANCE16 = 0x8042 + LUMINANCE16_ALPHA16 = 0x8048 + LUMINANCE4 = 0x803F + LUMINANCE4_ALPHA4 = 0x8043 + LUMINANCE6_ALPHA2 = 0x8044 + LUMINANCE8 = 0x8040 + LUMINANCE8_ALPHA8 = 0x8045 + R3_G3_B2 = 0x2A10 + RGB10 = 0x8052 + RGB10_A2 = 0x8059 + RGB12 = 0x8053 + RGB16 = 0x8054 + RGB4 = 0x804F + RGB5 = 0x8050 + RGB5_A1 = 0x8057 + RGB8 = 0x8051 + RGBA12 = 0x805A + RGBA16 = 0x805B + RGBA2 = 0x8055 + RGBA4 = 0x8056 + RGBA8 = 0x8058 + + PACK_IMAGE_HEIGHT = 0x806C + PACK_SKIP_IMAGES = 0x806B + UNPACK_IMAGE_HEIGHT = 0x806E + UNPACK_SKIP_IMAGES = 0x806D + + BITMAP = 0x1A00 + UNSIGNED_BYTE_3_3_2 = 0x8032 + UNSIGNED_INT_10_10_10_2 = 0x8036 + UNSIGNED_INT_8_8_8_8 = 0x8035 + UNSIGNED_SHORT_4_4_4_4 = 0x8033 + UNSIGNED_SHORT_5_5_5_1 = 0x8034 + + POINT_DISTANCE_ATTENUATION = 0x8129 + POINT_FADE_THRESHOLD_SIZE = 0x8128 + POINT_SIZE_MAX = 0x8127 + POINT_SIZE_MIN = 0x8126 + + LINES = 0x0001 + LINES_ADJACENCY = 0x000A + LINE_LOOP = 0x0002 + LINE_STRIP = 0x0003 + LINE_STRIP_ADJACENCY = 0x000B + PATCHES = 0x000E + POINTS = 0x0000 + POLYGON = 0x0009 + QUADS = 0x0007 + QUAD_STRIP = 0x0008 + TRIANGLES = 0x0004 + TRIANGLES_ADJACENCY = 0x000C + TRIANGLE_FAN = 0x0006 + TRIANGLE_STRIP = 0x0005 + TRIANGLE_STRIP_ADJACENCY = 0x000D + + FEEDBACK = 0x1C01 + RENDER = 0x1C00 + SELECT = 0x1C02 + + FLAT = 0x1D00 + SMOOTH = 0x1D01 + + DECR = 0x1E03 + INCR = 0x1E02 + KEEP = 0x1E00 + + EXTENSIONS = 0x1F03 + RENDERER = 0x1F01 + VENDOR = 0x1F00 + VERSION = 0x1F02 + + S = 0x2000 + T = 0x2001 + R = 0x2002 + Q = 0x2003 + + DECAL = 0x2101 + + TEXTURE_ENV_COLOR = 0x2201 + TEXTURE_ENV_MODE = 0x2200 + + TEXTURE_ENV = 0x2300 + + EYE_LINEAR = 0x2400 + OBJECT_LINEAR = 0x2401 + SPHERE_MAP = 0x2402 + + EYE_PLANE = 0x2502 + OBJECT_PLANE = 0x2501 + TEXTURE_GEN_MODE = 0x2500 + + NEAREST = 0x2600 + + LINEAR_MIPMAP_LINEAR = 0x2703 + LINEAR_MIPMAP_NEAREST = 0x2701 + NEAREST_MIPMAP_LINEAR = 0x2702 + NEAREST_MIPMAP_NEAREST = 0x2700 + + GENERATE_MIPMAP = 0x8191 + TEXTURE_WRAP_R = 0x8072 + + PROXY_TEXTURE_1D = 0x8063 + PROXY_TEXTURE_2D = 0x8064 + PROXY_TEXTURE_3D = 0x8070 + TEXTURE_3D = 0x806F + TEXTURE_BASE_LEVEL = 0x813C + TEXTURE_MAX_LEVEL = 0x813D + TEXTURE_MAX_LOD = 0x813B + TEXTURE_MIN_LOD = 0x813A + + CLAMP = 0x2900 + CLAMP_TO_BORDER = 0x812D + CLAMP_TO_EDGE = 0x812F + REPEAT = 0x2901 + + VERTEX_SHADER_BIT = 0x00000001 + FRAGMENT_SHADER_BIT = 0x00000002 + GEOMETRY_SHADER_BIT = 0x00000004 + TESS_CONTROL_SHADER_BIT = 0x00000008 + TESS_EVALUATION_SHADER_BIT = 0x00000010 + ALL_SHADER_BITS = 0xFFFFFFFF + + SYNC_FLUSH_COMMANDS_BIT = 0x00000001 + INVALID_INDEX = 0xFFFFFFFF + TIMEOUT_IGNORED = 0xFFFFFFFFFFFFFFFF + CONSTANT_COLOR = 0x8001 + ONE_MINUS_CONSTANT_COLOR = 0x8002 + CONSTANT_ALPHA = 0x8003 + ONE_MINUS_CONSTANT_ALPHA = 0x8004 + FUNC_ADD = 0x8006 + MIN = 0x8007 + MAX = 0x8008 + BLEND_EQUATION_RGB = 0x8009 + FUNC_SUBTRACT = 0x800A + FUNC_REVERSE_SUBTRACT = 0x800B + RESCALE_NORMAL = 0x803A + TEXTURE_DEPTH = 0x8071 + MAX_3D_TEXTURE_SIZE = 0x8073 + MULTISAMPLE = 0x809D + SAMPLE_ALPHA_TO_COVERAGE = 0x809E + SAMPLE_ALPHA_TO_ONE = 0x809F + SAMPLE_COVERAGE = 0x80A0 + SAMPLE_BUFFERS = 0x80A8 + SAMPLES = 0x80A9 + SAMPLE_COVERAGE_VALUE = 0x80AA + SAMPLE_COVERAGE_INVERT = 0x80AB + BLEND_DST_RGB = 0x80C8 + BLEND_SRC_RGB = 0x80C9 + BLEND_DST_ALPHA = 0x80CA + BLEND_SRC_ALPHA = 0x80CB + BGR = 0x80E0 + BGRA = 0x80E1 + MAX_ELEMENTS_VERTICES = 0x80E8 + MAX_ELEMENTS_INDICES = 0x80E9 + DEPTH_COMPONENT16 = 0x81A5 + DEPTH_COMPONENT24 = 0x81A6 + DEPTH_COMPONENT32 = 0x81A7 + FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210 + FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211 + FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212 + FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213 + FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214 + FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215 + FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216 + FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217 + FRAMEBUFFER_DEFAULT = 0x8218 + FRAMEBUFFER_UNDEFINED = 0x8219 + DEPTH_STENCIL_ATTACHMENT = 0x821A + MAJOR_VERSION = 0x821B + MINOR_VERSION = 0x821C + NUM_EXTENSIONS = 0x821D + CONTEXT_FLAGS = 0x821E + INDEX = 0x8222 + COMPRESSED_RED = 0x8225 + COMPRESSED_RG = 0x8226 + RG = 0x8227 + RG_INTEGER = 0x8228 + R8 = 0x8229 + R16 = 0x822A + RG8 = 0x822B + RG16 = 0x822C + R16F = 0x822D + R32F = 0x822E + RG16F = 0x822F + RG32F = 0x8230 + R8I = 0x8231 + R8UI = 0x8232 + R16I = 0x8233 + R16UI = 0x8234 + R32I = 0x8235 + R32UI = 0x8236 + RG8I = 0x8237 + RG8UI = 0x8238 + RG16I = 0x8239 + RG16UI = 0x823A + RG32I = 0x823B + RG32UI = 0x823C + PROGRAM_SEPARABLE = 0x8258 + ACTIVE_PROGRAM = 0x8259 + PROGRAM_PIPELINE_BINDING = 0x825A + MAX_VIEWPORTS = 0x825B + VIEWPORT_SUBPIXEL_BITS = 0x825C + VIEWPORT_BOUNDS_RANGE = 0x825D + LAYER_PROVOKING_VERTEX = 0x825E + VIEWPORT_INDEX_PROVOKING_VERTEX = 0x825F + UNDEFINED_VERTEX = 0x8260 + UNSIGNED_BYTE_2_3_3_REV = 0x8362 + UNSIGNED_SHORT_5_6_5 = 0x8363 + UNSIGNED_SHORT_5_6_5_REV = 0x8364 + UNSIGNED_SHORT_4_4_4_4_REV = 0x8365 + UNSIGNED_SHORT_1_5_5_5_REV = 0x8366 + UNSIGNED_INT_8_8_8_8_REV = 0x8367 + UNSIGNED_INT_2_10_10_10_REV = 0x8368 + MIRRORED_REPEAT = 0x8370 + FOG_COORDINATE_SOURCE = 0x8450 + FOG_COORD_SRC = 0x8450 + FOG_COORDINATE = 0x8451 + FOG_COORD = 0x8451 + FRAGMENT_DEPTH = 0x8452 + CURRENT_FOG_COORDINATE = 0x8453 + CURRENT_FOG_COORD = 0x8453 + FOG_COORDINATE_ARRAY_TYPE = 0x8454 + FOG_COORD_ARRAY_TYPE = 0x8454 + FOG_COORDINATE_ARRAY_STRIDE = 0x8455 + FOG_COORD_ARRAY_STRIDE = 0x8455 + FOG_COORDINATE_ARRAY_POINTER = 0x8456 + FOG_COORD_ARRAY_POINTER = 0x8456 + FOG_COORDINATE_ARRAY = 0x8457 + FOG_COORD_ARRAY = 0x8457 + COLOR_SUM = 0x8458 + CURRENT_SECONDARY_COLOR = 0x8459 + SECONDARY_COLOR_ARRAY_SIZE = 0x845A + SECONDARY_COLOR_ARRAY_TYPE = 0x845B + SECONDARY_COLOR_ARRAY_STRIDE = 0x845C + SECONDARY_COLOR_ARRAY_POINTER = 0x845D + SECONDARY_COLOR_ARRAY = 0x845E + CURRENT_RASTER_SECONDARY_COLOR = 0x845F + TEXTURE0 = 0x84C0 + TEXTURE1 = 0x84C1 + TEXTURE2 = 0x84C2 + TEXTURE3 = 0x84C3 + TEXTURE4 = 0x84C4 + TEXTURE5 = 0x84C5 + TEXTURE6 = 0x84C6 + TEXTURE7 = 0x84C7 + TEXTURE8 = 0x84C8 + TEXTURE9 = 0x84C9 + TEXTURE10 = 0x84CA + TEXTURE11 = 0x84CB + TEXTURE12 = 0x84CC + TEXTURE13 = 0x84CD + TEXTURE14 = 0x84CE + TEXTURE15 = 0x84CF + TEXTURE16 = 0x84D0 + TEXTURE17 = 0x84D1 + TEXTURE18 = 0x84D2 + TEXTURE19 = 0x84D3 + TEXTURE20 = 0x84D4 + TEXTURE21 = 0x84D5 + TEXTURE22 = 0x84D6 + TEXTURE23 = 0x84D7 + TEXTURE24 = 0x84D8 + TEXTURE25 = 0x84D9 + TEXTURE26 = 0x84DA + TEXTURE27 = 0x84DB + TEXTURE28 = 0x84DC + TEXTURE29 = 0x84DD + TEXTURE30 = 0x84DE + TEXTURE31 = 0x84DF + ACTIVE_TEXTURE = 0x84E0 + CLIENT_ACTIVE_TEXTURE = 0x84E1 + MAX_TEXTURE_UNITS = 0x84E2 + TRANSPOSE_MODELVIEW_MATRIX = 0x84E3 + TRANSPOSE_PROJECTION_MATRIX = 0x84E4 + TRANSPOSE_TEXTURE_MATRIX = 0x84E5 + TRANSPOSE_COLOR_MATRIX = 0x84E6 + SUBTRACT = 0x84E7 + MAX_RENDERBUFFER_SIZE = 0x84E8 + COMPRESSED_ALPHA = 0x84E9 + COMPRESSED_LUMINANCE = 0x84EA + COMPRESSED_LUMINANCE_ALPHA = 0x84EB + COMPRESSED_INTENSITY = 0x84EC + COMPRESSED_RGB = 0x84ED + COMPRESSED_RGBA = 0x84EE + UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER = 0x84F0 + UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x84F1 + TEXTURE_RECTANGLE = 0x84F5 + TEXTURE_BINDING_RECTANGLE = 0x84F6 + PROXY_TEXTURE_RECTANGLE = 0x84F7 + MAX_RECTANGLE_TEXTURE_SIZE = 0x84F8 + DEPTH_STENCIL = 0x84F9 + UNSIGNED_INT_24_8 = 0x84FA + MAX_TEXTURE_LOD_BIAS = 0x84FD + TEXTURE_FILTER_CONTROL = 0x8500 + TEXTURE_LOD_BIAS = 0x8501 + INCR_WRAP = 0x8507 + DECR_WRAP = 0x8508 + NORMAL_MAP = 0x8511 + REFLECTION_MAP = 0x8512 + TEXTURE_CUBE_MAP = 0x8513 + TEXTURE_BINDING_CUBE_MAP = 0x8514 + TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515 + TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516 + TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517 + TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518 + TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519 + TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A + PROXY_TEXTURE_CUBE_MAP = 0x851B + MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C + COMBINE = 0x8570 + COMBINE_RGB = 0x8571 + COMBINE_ALPHA = 0x8572 + RGB_SCALE = 0x8573 + ADD_SIGNED = 0x8574 + INTERPOLATE = 0x8575 + CONSTANT = 0x8576 + PRIMARY_COLOR = 0x8577 + PREVIOUS = 0x8578 + SOURCE0_RGB = 0x8580 + SRC0_RGB = 0x8580 + SOURCE1_RGB = 0x8581 + SRC1_RGB = 0x8581 + SOURCE2_RGB = 0x8582 + SRC2_RGB = 0x8582 + SOURCE0_ALPHA = 0x8588 + SRC0_ALPHA = 0x8588 + SOURCE1_ALPHA = 0x8589 + SRC1_ALPHA = 0x8589 + SOURCE2_ALPHA = 0x858A + SRC2_ALPHA = 0x858A + OPERAND0_RGB = 0x8590 + OPERAND1_RGB = 0x8591 + OPERAND2_RGB = 0x8592 + OPERAND0_ALPHA = 0x8598 + OPERAND1_ALPHA = 0x8599 + OPERAND2_ALPHA = 0x859A + VERTEX_ARRAY_BINDING = 0x85B5 + VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622 + VERTEX_ATTRIB_ARRAY_SIZE = 0x8623 + VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624 + VERTEX_ATTRIB_ARRAY_TYPE = 0x8625 + CURRENT_VERTEX_ATTRIB = 0x8626 + VERTEX_PROGRAM_POINT_SIZE = 0x8642 + PROGRAM_POINT_SIZE = 0x8642 + VERTEX_PROGRAM_TWO_SIDE = 0x8643 + VERTEX_ATTRIB_ARRAY_POINTER = 0x8645 + DEPTH_CLAMP = 0x864F + TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0 + TEXTURE_COMPRESSED = 0x86A1 + NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2 + COMPRESSED_TEXTURE_FORMATS = 0x86A3 + DOT3_RGB = 0x86AE + DOT3_RGBA = 0x86AF + PROGRAM_BINARY_LENGTH = 0x8741 + BUFFER_SIZE = 0x8764 + BUFFER_USAGE = 0x8765 + NUM_PROGRAM_BINARY_FORMATS = 0x87FE + PROGRAM_BINARY_FORMATS = 0x87FF + STENCIL_BACK_FUNC = 0x8800 + STENCIL_BACK_FAIL = 0x8801 + STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802 + STENCIL_BACK_PASS_DEPTH_PASS = 0x8803 + RGBA32F = 0x8814 + RGB32F = 0x8815 + RGBA16F = 0x881A + RGB16F = 0x881B + MAX_DRAW_BUFFERS = 0x8824 + DRAW_BUFFER0 = 0x8825 + DRAW_BUFFER1 = 0x8826 + DRAW_BUFFER2 = 0x8827 + DRAW_BUFFER3 = 0x8828 + DRAW_BUFFER4 = 0x8829 + DRAW_BUFFER5 = 0x882A + DRAW_BUFFER6 = 0x882B + DRAW_BUFFER7 = 0x882C + DRAW_BUFFER8 = 0x882D + DRAW_BUFFER9 = 0x882E + DRAW_BUFFER10 = 0x882F + DRAW_BUFFER11 = 0x8830 + DRAW_BUFFER12 = 0x8831 + DRAW_BUFFER13 = 0x8832 + DRAW_BUFFER14 = 0x8833 + DRAW_BUFFER15 = 0x8834 + BLEND_EQUATION_ALPHA = 0x883D + TEXTURE_DEPTH_SIZE = 0x884A + DEPTH_TEXTURE_MODE = 0x884B + TEXTURE_COMPARE_MODE = 0x884C + TEXTURE_COMPARE_FUNC = 0x884D + COMPARE_R_TO_TEXTURE = 0x884E + COMPARE_REF_TO_TEXTURE = 0x884E + TEXTURE_CUBE_MAP_SEAMLESS = 0x884F + POINT_SPRITE = 0x8861 + COORD_REPLACE = 0x8862 + QUERY_COUNTER_BITS = 0x8864 + CURRENT_QUERY = 0x8865 + QUERY_RESULT = 0x8866 + QUERY_RESULT_AVAILABLE = 0x8867 + MAX_VERTEX_ATTRIBS = 0x8869 + VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A + MAX_TESS_CONTROL_INPUT_COMPONENTS = 0x886C + MAX_TESS_EVALUATION_INPUT_COMPONENTS = 0x886D + MAX_TEXTURE_COORDS = 0x8871 + MAX_TEXTURE_IMAGE_UNITS = 0x8872 + GEOMETRY_SHADER_INVOCATIONS = 0x887F + ARRAY_BUFFER = 0x8892 + ELEMENT_ARRAY_BUFFER = 0x8893 + ARRAY_BUFFER_BINDING = 0x8894 + ELEMENT_ARRAY_BUFFER_BINDING = 0x8895 + VERTEX_ARRAY_BUFFER_BINDING = 0x8896 + NORMAL_ARRAY_BUFFER_BINDING = 0x8897 + COLOR_ARRAY_BUFFER_BINDING = 0x8898 + INDEX_ARRAY_BUFFER_BINDING = 0x8899 + TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A + EDGE_FLAG_ARRAY_BUFFER_BINDING = 0x889B + SECONDARY_COLOR_ARRAY_BUFFER_BINDING = 0x889C + FOG_COORDINATE_ARRAY_BUFFER_BINDING = 0x889D + FOG_COORD_ARRAY_BUFFER_BINDING = 0x889D + WEIGHT_ARRAY_BUFFER_BINDING = 0x889E + VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F + READ_ONLY = 0x88B8 + WRITE_ONLY = 0x88B9 + READ_WRITE = 0x88BA + BUFFER_ACCESS = 0x88BB + BUFFER_MAPPED = 0x88BC + BUFFER_MAP_POINTER = 0x88BD + TIME_ELAPSED = 0x88BF + STREAM_DRAW = 0x88E0 + STREAM_READ = 0x88E1 + STREAM_COPY = 0x88E2 + STATIC_DRAW = 0x88E4 + STATIC_READ = 0x88E5 + STATIC_COPY = 0x88E6 + DYNAMIC_DRAW = 0x88E8 + DYNAMIC_READ = 0x88E9 + DYNAMIC_COPY = 0x88EA + PIXEL_PACK_BUFFER = 0x88EB + PIXEL_UNPACK_BUFFER = 0x88EC + PIXEL_PACK_BUFFER_BINDING = 0x88ED + PIXEL_UNPACK_BUFFER_BINDING = 0x88EF + DEPTH24_STENCIL8 = 0x88F0 + TEXTURE_STENCIL_SIZE = 0x88F1 + SRC1_COLOR = 0x88F9 + ONE_MINUS_SRC1_COLOR = 0x88FA + ONE_MINUS_SRC1_ALPHA = 0x88FB + MAX_DUAL_SOURCE_DRAW_BUFFERS = 0x88FC + VERTEX_ATTRIB_ARRAY_INTEGER = 0x88FD + VERTEX_ATTRIB_ARRAY_DIVISOR = 0x88FE + MAX_ARRAY_TEXTURE_LAYERS = 0x88FF + MIN_PROGRAM_TEXEL_OFFSET = 0x8904 + MAX_PROGRAM_TEXEL_OFFSET = 0x8905 + SAMPLES_PASSED = 0x8914 + GEOMETRY_VERTICES_OUT = 0x8916 + GEOMETRY_INPUT_TYPE = 0x8917 + GEOMETRY_OUTPUT_TYPE = 0x8918 + SAMPLER_BINDING = 0x8919 + CLAMP_VERTEX_COLOR = 0x891A + CLAMP_FRAGMENT_COLOR = 0x891B + CLAMP_READ_COLOR = 0x891C + FIXED_ONLY = 0x891D + UNIFORM_BUFFER = 0x8A11 + UNIFORM_BUFFER_BINDING = 0x8A28 + UNIFORM_BUFFER_START = 0x8A29 + UNIFORM_BUFFER_SIZE = 0x8A2A + MAX_VERTEX_UNIFORM_BLOCKS = 0x8A2B + MAX_GEOMETRY_UNIFORM_BLOCKS = 0x8A2C + MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8A2D + MAX_COMBINED_UNIFORM_BLOCKS = 0x8A2E + MAX_UNIFORM_BUFFER_BINDINGS = 0x8A2F + MAX_UNIFORM_BLOCK_SIZE = 0x8A30 + MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31 + MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 0x8A32 + MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33 + UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8A34 + ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35 + ACTIVE_UNIFORM_BLOCKS = 0x8A36 + UNIFORM_TYPE = 0x8A37 + UNIFORM_SIZE = 0x8A38 + UNIFORM_NAME_LENGTH = 0x8A39 + UNIFORM_BLOCK_INDEX = 0x8A3A + UNIFORM_OFFSET = 0x8A3B + UNIFORM_ARRAY_STRIDE = 0x8A3C + UNIFORM_MATRIX_STRIDE = 0x8A3D + UNIFORM_IS_ROW_MAJOR = 0x8A3E + UNIFORM_BLOCK_BINDING = 0x8A3F + UNIFORM_BLOCK_DATA_SIZE = 0x8A40 + UNIFORM_BLOCK_NAME_LENGTH = 0x8A41 + UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8A42 + UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43 + UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44 + UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 0x8A45 + UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46 + FRAGMENT_SHADER = 0x8B30 + VERTEX_SHADER = 0x8B31 + MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49 + MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A + MAX_VARYING_FLOATS = 0x8B4B + MAX_VARYING_COMPONENTS = 0x8B4B + MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C + MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D + SHADER_TYPE = 0x8B4F + FLOAT_VEC2 = 0x8B50 + FLOAT_VEC3 = 0x8B51 + FLOAT_VEC4 = 0x8B52 + INT_VEC2 = 0x8B53 + INT_VEC3 = 0x8B54 + INT_VEC4 = 0x8B55 + BOOL = 0x8B56 + BOOL_VEC2 = 0x8B57 + BOOL_VEC3 = 0x8B58 + BOOL_VEC4 = 0x8B59 + FLOAT_MAT2 = 0x8B5A + FLOAT_MAT3 = 0x8B5B + FLOAT_MAT4 = 0x8B5C + SAMPLER_1D = 0x8B5D + SAMPLER_2D = 0x8B5E + SAMPLER_3D = 0x8B5F + SAMPLER_CUBE = 0x8B60 + SAMPLER_1D_SHADOW = 0x8B61 + SAMPLER_2D_SHADOW = 0x8B62 + SAMPLER_2D_RECT = 0x8B63 + SAMPLER_2D_RECT_SHADOW = 0x8B64 + FLOAT_MAT2x3 = 0x8B65 + FLOAT_MAT2x4 = 0x8B66 + FLOAT_MAT3x2 = 0x8B67 + FLOAT_MAT3x4 = 0x8B68 + FLOAT_MAT4x2 = 0x8B69 + FLOAT_MAT4x3 = 0x8B6A + DELETE_STATUS = 0x8B80 + COMPILE_STATUS = 0x8B81 + LINK_STATUS = 0x8B82 + VALIDATE_STATUS = 0x8B83 + INFO_LOG_LENGTH = 0x8B84 + ATTACHED_SHADERS = 0x8B85 + ACTIVE_UNIFORMS = 0x8B86 + ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87 + SHADER_SOURCE_LENGTH = 0x8B88 + ACTIVE_ATTRIBUTES = 0x8B89 + ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A + SHADING_LANGUAGE_VERSION = 0x8B8C + CURRENT_PROGRAM = 0x8B8D + IMPLEMENTATION_COLOR_READ_TYPE = 0x8B9A + IMPLEMENTATION_COLOR_READ_FORMAT = 0x8B9B + TEXTURE_RED_TYPE = 0x8C10 + TEXTURE_GREEN_TYPE = 0x8C11 + TEXTURE_BLUE_TYPE = 0x8C12 + TEXTURE_ALPHA_TYPE = 0x8C13 + TEXTURE_LUMINANCE_TYPE = 0x8C14 + TEXTURE_INTENSITY_TYPE = 0x8C15 + TEXTURE_DEPTH_TYPE = 0x8C16 + UNSIGNED_NORMALIZED = 0x8C17 + TEXTURE_1D_ARRAY = 0x8C18 + PROXY_TEXTURE_1D_ARRAY = 0x8C19 + TEXTURE_2D_ARRAY = 0x8C1A + PROXY_TEXTURE_2D_ARRAY = 0x8C1B + TEXTURE_BINDING_1D_ARRAY = 0x8C1C + TEXTURE_BINDING_2D_ARRAY = 0x8C1D + MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = 0x8C29 + TEXTURE_BUFFER = 0x8C2A + MAX_TEXTURE_BUFFER_SIZE = 0x8C2B + TEXTURE_BINDING_BUFFER = 0x8C2C + TEXTURE_BUFFER_DATA_STORE_BINDING = 0x8C2D + ANY_SAMPLES_PASSED = 0x8C2F + SAMPLE_SHADING = 0x8C36 + MIN_SAMPLE_SHADING_VALUE = 0x8C37 + R11F_G11F_B10F = 0x8C3A + UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B + RGB9_E5 = 0x8C3D + UNSIGNED_INT_5_9_9_9_REV = 0x8C3E + TEXTURE_SHARED_SIZE = 0x8C3F + SRGB = 0x8C40 + SRGB8 = 0x8C41 + SRGB_ALPHA = 0x8C42 + SRGB8_ALPHA8 = 0x8C43 + SLUMINANCE_ALPHA = 0x8C44 + SLUMINANCE8_ALPHA8 = 0x8C45 + SLUMINANCE = 0x8C46 + SLUMINANCE8 = 0x8C47 + COMPRESSED_SRGB = 0x8C48 + COMPRESSED_SRGB_ALPHA = 0x8C49 + COMPRESSED_SLUMINANCE = 0x8C4A + COMPRESSED_SLUMINANCE_ALPHA = 0x8C4B + TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76 + TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F + MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80 + TRANSFORM_FEEDBACK_VARYINGS = 0x8C83 + TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84 + TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85 + PRIMITIVES_GENERATED = 0x8C87 + TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88 + RASTERIZER_DISCARD = 0x8C89 + MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A + MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B + INTERLEAVED_ATTRIBS = 0x8C8C + SEPARATE_ATTRIBS = 0x8C8D + TRANSFORM_FEEDBACK_BUFFER = 0x8C8E + TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F + POINT_SPRITE_COORD_ORIGIN = 0x8CA0 + LOWER_LEFT = 0x8CA1 + UPPER_LEFT = 0x8CA2 + STENCIL_BACK_REF = 0x8CA3 + STENCIL_BACK_VALUE_MASK = 0x8CA4 + STENCIL_BACK_WRITEMASK = 0x8CA5 + DRAW_FRAMEBUFFER_BINDING = 0x8CA6 + FRAMEBUFFER_BINDING = 0x8CA6 + RENDERBUFFER_BINDING = 0x8CA7 + READ_FRAMEBUFFER = 0x8CA8 + DRAW_FRAMEBUFFER = 0x8CA9 + READ_FRAMEBUFFER_BINDING = 0x8CAA + RENDERBUFFER_SAMPLES = 0x8CAB + DEPTH_COMPONENT32F = 0x8CAC + DEPTH32F_STENCIL8 = 0x8CAD + FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0 + FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1 + FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2 + FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3 + FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4 + FRAMEBUFFER_COMPLETE = 0x8CD5 + FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6 + FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7 + FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB + FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC + FRAMEBUFFER_UNSUPPORTED = 0x8CDD + MAX_COLOR_ATTACHMENTS = 0x8CDF + COLOR_ATTACHMENT0 = 0x8CE0 + COLOR_ATTACHMENT1 = 0x8CE1 + COLOR_ATTACHMENT2 = 0x8CE2 + COLOR_ATTACHMENT3 = 0x8CE3 + COLOR_ATTACHMENT4 = 0x8CE4 + COLOR_ATTACHMENT5 = 0x8CE5 + COLOR_ATTACHMENT6 = 0x8CE6 + COLOR_ATTACHMENT7 = 0x8CE7 + COLOR_ATTACHMENT8 = 0x8CE8 + COLOR_ATTACHMENT9 = 0x8CE9 + COLOR_ATTACHMENT10 = 0x8CEA + COLOR_ATTACHMENT11 = 0x8CEB + COLOR_ATTACHMENT12 = 0x8CEC + COLOR_ATTACHMENT13 = 0x8CED + COLOR_ATTACHMENT14 = 0x8CEE + COLOR_ATTACHMENT15 = 0x8CEF + DEPTH_ATTACHMENT = 0x8D00 + STENCIL_ATTACHMENT = 0x8D20 + FRAMEBUFFER = 0x8D40 + RENDERBUFFER = 0x8D41 + RENDERBUFFER_WIDTH = 0x8D42 + RENDERBUFFER_HEIGHT = 0x8D43 + RENDERBUFFER_INTERNAL_FORMAT = 0x8D44 + STENCIL_INDEX1 = 0x8D46 + STENCIL_INDEX4 = 0x8D47 + STENCIL_INDEX8 = 0x8D48 + STENCIL_INDEX16 = 0x8D49 + RENDERBUFFER_RED_SIZE = 0x8D50 + RENDERBUFFER_GREEN_SIZE = 0x8D51 + RENDERBUFFER_BLUE_SIZE = 0x8D52 + RENDERBUFFER_ALPHA_SIZE = 0x8D53 + RENDERBUFFER_DEPTH_SIZE = 0x8D54 + RENDERBUFFER_STENCIL_SIZE = 0x8D55 + FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56 + MAX_SAMPLES = 0x8D57 + RGB565 = 0x8D62 + RGBA32UI = 0x8D70 + RGB32UI = 0x8D71 + RGBA16UI = 0x8D76 + RGB16UI = 0x8D77 + RGBA8UI = 0x8D7C + RGB8UI = 0x8D7D + RGBA32I = 0x8D82 + RGB32I = 0x8D83 + RGBA16I = 0x8D88 + RGB16I = 0x8D89 + RGBA8I = 0x8D8E + RGB8I = 0x8D8F + RED_INTEGER = 0x8D94 + GREEN_INTEGER = 0x8D95 + BLUE_INTEGER = 0x8D96 + ALPHA_INTEGER = 0x8D97 + RGB_INTEGER = 0x8D98 + RGBA_INTEGER = 0x8D99 + BGR_INTEGER = 0x8D9A + BGRA_INTEGER = 0x8D9B + INT_2_10_10_10_REV = 0x8D9F + FRAMEBUFFER_ATTACHMENT_LAYERED = 0x8DA7 + FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = 0x8DA8 + FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD + FRAMEBUFFER_SRGB = 0x8DB9 + COMPRESSED_RED_RGTC1 = 0x8DBB + COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC + COMPRESSED_RG_RGTC2 = 0x8DBD + COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE + SAMPLER_1D_ARRAY = 0x8DC0 + SAMPLER_2D_ARRAY = 0x8DC1 + SAMPLER_BUFFER = 0x8DC2 + SAMPLER_1D_ARRAY_SHADOW = 0x8DC3 + SAMPLER_2D_ARRAY_SHADOW = 0x8DC4 + SAMPLER_CUBE_SHADOW = 0x8DC5 + UNSIGNED_INT_VEC2 = 0x8DC6 + UNSIGNED_INT_VEC3 = 0x8DC7 + UNSIGNED_INT_VEC4 = 0x8DC8 + INT_SAMPLER_1D = 0x8DC9 + INT_SAMPLER_2D = 0x8DCA + INT_SAMPLER_3D = 0x8DCB + INT_SAMPLER_CUBE = 0x8DCC + INT_SAMPLER_2D_RECT = 0x8DCD + INT_SAMPLER_1D_ARRAY = 0x8DCE + INT_SAMPLER_2D_ARRAY = 0x8DCF + INT_SAMPLER_BUFFER = 0x8DD0 + UNSIGNED_INT_SAMPLER_1D = 0x8DD1 + UNSIGNED_INT_SAMPLER_2D = 0x8DD2 + UNSIGNED_INT_SAMPLER_3D = 0x8DD3 + UNSIGNED_INT_SAMPLER_CUBE = 0x8DD4 + UNSIGNED_INT_SAMPLER_2D_RECT = 0x8DD5 + UNSIGNED_INT_SAMPLER_1D_ARRAY = 0x8DD6 + UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8DD7 + UNSIGNED_INT_SAMPLER_BUFFER = 0x8DD8 + GEOMETRY_SHADER = 0x8DD9 + MAX_GEOMETRY_UNIFORM_COMPONENTS = 0x8DDF + MAX_GEOMETRY_OUTPUT_VERTICES = 0x8DE0 + MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = 0x8DE1 + ACTIVE_SUBROUTINES = 0x8DE5 + ACTIVE_SUBROUTINE_UNIFORMS = 0x8DE6 + MAX_SUBROUTINES = 0x8DE7 + MAX_SUBROUTINE_UNIFORM_LOCATIONS = 0x8DE8 + LOW_FLOAT = 0x8DF0 + MEDIUM_FLOAT = 0x8DF1 + HIGH_FLOAT = 0x8DF2 + LOW_INT = 0x8DF3 + MEDIUM_INT = 0x8DF4 + HIGH_INT = 0x8DF5 + SHADER_BINARY_FORMATS = 0x8DF8 + NUM_SHADER_BINARY_FORMATS = 0x8DF9 + SHADER_COMPILER = 0x8DFA + MAX_VERTEX_UNIFORM_VECTORS = 0x8DFB + MAX_VARYING_VECTORS = 0x8DFC + MAX_FRAGMENT_UNIFORM_VECTORS = 0x8DFD + QUERY_WAIT = 0x8E13 + QUERY_NO_WAIT = 0x8E14 + QUERY_BY_REGION_WAIT = 0x8E15 + QUERY_BY_REGION_NO_WAIT = 0x8E16 + MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E1E + MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E1F + TRANSFORM_FEEDBACK = 0x8E22 + TRANSFORM_FEEDBACK_BUFFER_PAUSED = 0x8E23 + TRANSFORM_FEEDBACK_BUFFER_ACTIVE = 0x8E24 + TRANSFORM_FEEDBACK_BINDING = 0x8E25 + TIMESTAMP = 0x8E28 + TEXTURE_SWIZZLE_R = 0x8E42 + TEXTURE_SWIZZLE_G = 0x8E43 + TEXTURE_SWIZZLE_B = 0x8E44 + TEXTURE_SWIZZLE_A = 0x8E45 + TEXTURE_SWIZZLE_RGBA = 0x8E46 + ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS = 0x8E47 + ACTIVE_SUBROUTINE_MAX_LENGTH = 0x8E48 + ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH = 0x8E49 + NUM_COMPATIBLE_SUBROUTINES = 0x8E4A + COMPATIBLE_SUBROUTINES = 0x8E4B + QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = 0x8E4C + FIRST_VERTEX_CONVENTION = 0x8E4D + LAST_VERTEX_CONVENTION = 0x8E4E + PROVOKING_VERTEX = 0x8E4F + SAMPLE_POSITION = 0x8E50 + SAMPLE_MASK = 0x8E51 + SAMPLE_MASK_VALUE = 0x8E52 + MAX_SAMPLE_MASK_WORDS = 0x8E59 + MAX_GEOMETRY_SHADER_INVOCATIONS = 0x8E5A + MIN_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5B + MAX_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5C + FRAGMENT_INTERPOLATION_OFFSET_BITS = 0x8E5D + MIN_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5E + MAX_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5F + MAX_TRANSFORM_FEEDBACK_BUFFERS = 0x8E70 + MAX_VERTEX_STREAMS = 0x8E71 + PATCH_VERTICES = 0x8E72 + PATCH_DEFAULT_INNER_LEVEL = 0x8E73 + PATCH_DEFAULT_OUTER_LEVEL = 0x8E74 + TESS_CONTROL_OUTPUT_VERTICES = 0x8E75 + TESS_GEN_MODE = 0x8E76 + TESS_GEN_SPACING = 0x8E77 + TESS_GEN_VERTEX_ORDER = 0x8E78 + TESS_GEN_POINT_MODE = 0x8E79 + ISOLINES = 0x8E7A + FRACTIONAL_ODD = 0x8E7B + FRACTIONAL_EVEN = 0x8E7C + MAX_PATCH_VERTICES = 0x8E7D + MAX_TESS_GEN_LEVEL = 0x8E7E + MAX_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E7F + MAX_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E80 + MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS = 0x8E81 + MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS = 0x8E82 + MAX_TESS_CONTROL_OUTPUT_COMPONENTS = 0x8E83 + MAX_TESS_PATCH_COMPONENTS = 0x8E84 + MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS = 0x8E85 + MAX_TESS_EVALUATION_OUTPUT_COMPONENTS = 0x8E86 + TESS_EVALUATION_SHADER = 0x8E87 + TESS_CONTROL_SHADER = 0x8E88 + MAX_TESS_CONTROL_UNIFORM_BLOCKS = 0x8E89 + MAX_TESS_EVALUATION_UNIFORM_BLOCKS = 0x8E8A + COMPRESSED_RGBA_BPTC_UNORM = 0x8E8C + COMPRESSED_SRGB_ALPHA_BPTC_UNORM = 0x8E8D + COMPRESSED_RGB_BPTC_SIGNED_FLOAT = 0x8E8E + COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT = 0x8E8F + COPY_READ_BUFFER = 0x8F36 + COPY_WRITE_BUFFER = 0x8F37 + MAX_IMAGE_UNITS = 0x8F38 + MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS = 0x8F39 + IMAGE_BINDING_NAME = 0x8F3A + IMAGE_BINDING_LEVEL = 0x8F3B + IMAGE_BINDING_LAYERED = 0x8F3C + IMAGE_BINDING_LAYER = 0x8F3D + IMAGE_BINDING_ACCESS = 0x8F3E + DRAW_INDIRECT_BUFFER = 0x8F3F + DRAW_INDIRECT_BUFFER_BINDING = 0x8F43 + DOUBLE_MAT2 = 0x8F46 + DOUBLE_MAT3 = 0x8F47 + DOUBLE_MAT4 = 0x8F48 + DOUBLE_MAT2x3 = 0x8F49 + DOUBLE_MAT2x4 = 0x8F4A + DOUBLE_MAT3x2 = 0x8F4B + DOUBLE_MAT3x4 = 0x8F4C + DOUBLE_MAT4x2 = 0x8F4D + DOUBLE_MAT4x3 = 0x8F4E + R8_SNORM = 0x8F94 + RG8_SNORM = 0x8F95 + RGB8_SNORM = 0x8F96 + RGBA8_SNORM = 0x8F97 + R16_SNORM = 0x8F98 + RG16_SNORM = 0x8F99 + RGB16_SNORM = 0x8F9A + RGBA16_SNORM = 0x8F9B + SIGNED_NORMALIZED = 0x8F9C + PRIMITIVE_RESTART = 0x8F9D + PRIMITIVE_RESTART_INDEX = 0x8F9E + DOUBLE_VEC2 = 0x8FFC + DOUBLE_VEC3 = 0x8FFD + DOUBLE_VEC4 = 0x8FFE + TEXTURE_CUBE_MAP_ARRAY = 0x9009 + TEXTURE_BINDING_CUBE_MAP_ARRAY = 0x900A + PROXY_TEXTURE_CUBE_MAP_ARRAY = 0x900B + SAMPLER_CUBE_MAP_ARRAY = 0x900C + SAMPLER_CUBE_MAP_ARRAY_SHADOW = 0x900D + INT_SAMPLER_CUBE_MAP_ARRAY = 0x900E + UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY = 0x900F + IMAGE_1D = 0x904C + IMAGE_2D = 0x904D + IMAGE_3D = 0x904E + IMAGE_2D_RECT = 0x904F + IMAGE_CUBE = 0x9050 + IMAGE_BUFFER = 0x9051 + IMAGE_1D_ARRAY = 0x9052 + IMAGE_2D_ARRAY = 0x9053 + IMAGE_CUBE_MAP_ARRAY = 0x9054 + IMAGE_2D_MULTISAMPLE = 0x9055 + IMAGE_2D_MULTISAMPLE_ARRAY = 0x9056 + INT_IMAGE_1D = 0x9057 + INT_IMAGE_2D = 0x9058 + INT_IMAGE_3D = 0x9059 + INT_IMAGE_2D_RECT = 0x905A + INT_IMAGE_CUBE = 0x905B + INT_IMAGE_BUFFER = 0x905C + INT_IMAGE_1D_ARRAY = 0x905D + INT_IMAGE_2D_ARRAY = 0x905E + INT_IMAGE_CUBE_MAP_ARRAY = 0x905F + INT_IMAGE_2D_MULTISAMPLE = 0x9060 + INT_IMAGE_2D_MULTISAMPLE_ARRAY = 0x9061 + UNSIGNED_INT_IMAGE_1D = 0x9062 + UNSIGNED_INT_IMAGE_2D = 0x9063 + UNSIGNED_INT_IMAGE_3D = 0x9064 + UNSIGNED_INT_IMAGE_2D_RECT = 0x9065 + UNSIGNED_INT_IMAGE_CUBE = 0x9066 + UNSIGNED_INT_IMAGE_BUFFER = 0x9067 + UNSIGNED_INT_IMAGE_1D_ARRAY = 0x9068 + UNSIGNED_INT_IMAGE_2D_ARRAY = 0x9069 + UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY = 0x906A + UNSIGNED_INT_IMAGE_2D_MULTISAMPLE = 0x906B + UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY = 0x906C + MAX_IMAGE_SAMPLES = 0x906D + IMAGE_BINDING_FORMAT = 0x906E + RGB10_A2UI = 0x906F + MIN_MAP_BUFFER_ALIGNMENT = 0x90BC + IMAGE_FORMAT_COMPATIBILITY_TYPE = 0x90C7 + IMAGE_FORMAT_COMPATIBILITY_BY_SIZE = 0x90C8 + IMAGE_FORMAT_COMPATIBILITY_BY_CLASS = 0x90C9 + MAX_VERTEX_IMAGE_UNIFORMS = 0x90CA + MAX_TESS_CONTROL_IMAGE_UNIFORMS = 0x90CB + MAX_TESS_EVALUATION_IMAGE_UNIFORMS = 0x90CC + MAX_GEOMETRY_IMAGE_UNIFORMS = 0x90CD + MAX_FRAGMENT_IMAGE_UNIFORMS = 0x90CE + MAX_COMBINED_IMAGE_UNIFORMS = 0x90CF + TEXTURE_2D_MULTISAMPLE = 0x9100 + PROXY_TEXTURE_2D_MULTISAMPLE = 0x9101 + TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9102 + PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9103 + TEXTURE_BINDING_2D_MULTISAMPLE = 0x9104 + TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = 0x9105 + TEXTURE_SAMPLES = 0x9106 + TEXTURE_FIXED_SAMPLE_LOCATIONS = 0x9107 + SAMPLER_2D_MULTISAMPLE = 0x9108 + INT_SAMPLER_2D_MULTISAMPLE = 0x9109 + UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = 0x910A + SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910B + INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910C + UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910D + MAX_COLOR_TEXTURE_SAMPLES = 0x910E + MAX_DEPTH_TEXTURE_SAMPLES = 0x910F + MAX_INTEGER_SAMPLES = 0x9110 + MAX_SERVER_WAIT_TIMEOUT = 0x9111 + OBJECT_TYPE = 0x9112 + SYNC_CONDITION = 0x9113 + SYNC_STATUS = 0x9114 + SYNC_FLAGS = 0x9115 + SYNC_FENCE = 0x9116 + SYNC_GPU_COMMANDS_COMPLETE = 0x9117 + UNSIGNALED = 0x9118 + SIGNALED = 0x9119 + ALREADY_SIGNALED = 0x911A + TIMEOUT_EXPIRED = 0x911B + CONDITION_SATISFIED = 0x911C + WAIT_FAILED = 0x911D + BUFFER_ACCESS_FLAGS = 0x911F + BUFFER_MAP_LENGTH = 0x9120 + BUFFER_MAP_OFFSET = 0x9121 + MAX_VERTEX_OUTPUT_COMPONENTS = 0x9122 + MAX_GEOMETRY_INPUT_COMPONENTS = 0x9123 + MAX_GEOMETRY_OUTPUT_COMPONENTS = 0x9124 + MAX_FRAGMENT_INPUT_COMPONENTS = 0x9125 + CONTEXT_PROFILE_MASK = 0x9126 + UNPACK_COMPRESSED_BLOCK_WIDTH = 0x9127 + UNPACK_COMPRESSED_BLOCK_HEIGHT = 0x9128 + UNPACK_COMPRESSED_BLOCK_DEPTH = 0x9129 + UNPACK_COMPRESSED_BLOCK_SIZE = 0x912A + PACK_COMPRESSED_BLOCK_WIDTH = 0x912B + PACK_COMPRESSED_BLOCK_HEIGHT = 0x912C + PACK_COMPRESSED_BLOCK_DEPTH = 0x912D + PACK_COMPRESSED_BLOCK_SIZE = 0x912E + TEXTURE_IMMUTABLE_FORMAT = 0x912F + ATOMIC_COUNTER_BUFFER = 0x92C0 + ATOMIC_COUNTER_BUFFER_BINDING = 0x92C1 + ATOMIC_COUNTER_BUFFER_START = 0x92C2 + ATOMIC_COUNTER_BUFFER_SIZE = 0x92C3 + ATOMIC_COUNTER_BUFFER_DATA_SIZE = 0x92C4 + ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS = 0x92C5 + ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES = 0x92C6 + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER = 0x92C7 + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER = 0x92C8 + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x92C9 + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER = 0x92CA + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER = 0x92CB + MAX_VERTEX_ATOMIC_COUNTER_BUFFERS = 0x92CC + MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS = 0x92CD + MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS = 0x92CE + MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS = 0x92CF + MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS = 0x92D0 + MAX_COMBINED_ATOMIC_COUNTER_BUFFERS = 0x92D1 + MAX_VERTEX_ATOMIC_COUNTERS = 0x92D2 + MAX_TESS_CONTROL_ATOMIC_COUNTERS = 0x92D3 + MAX_TESS_EVALUATION_ATOMIC_COUNTERS = 0x92D4 + MAX_GEOMETRY_ATOMIC_COUNTERS = 0x92D5 + MAX_FRAGMENT_ATOMIC_COUNTERS = 0x92D6 + MAX_COMBINED_ATOMIC_COUNTERS = 0x92D7 + MAX_ATOMIC_COUNTER_BUFFER_SIZE = 0x92D8 + ACTIVE_ATOMIC_COUNTER_BUFFERS = 0x92D9 + UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX = 0x92DA + UNSIGNED_INT_ATOMIC_COUNTER = 0x92DB + MAX_ATOMIC_COUNTER_BUFFER_BINDINGS = 0x92DC + NUM_SAMPLE_COUNTS = 0x9380 +) + +// https://www.opengl.org/sdk/docs/man4/xhtml/glViewport.xml +func (gl *GL) Viewport(x, y, width, height int) { + C.gl4_2compat_glViewport(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// DepthRange specifies the mapping of depth values from normalized device +// coordinates to window coordinates. +// +// Parameter nearVal specifies the mapping of the near clipping plane to window +// coordinates (defaults to 0), while farVal specifies the mapping of the far +// clipping plane to window coordinates (defaults to 1). +// +// After clipping and division by w, depth coordinates range from -1 to 1, +// corresponding to the near and far clipping planes. DepthRange specifies a +// linear mapping of the normalized depth coordinates in this range to window +// depth coordinates. Regardless of the actual depth buffer implementation, +// window coordinate depth values are treated as though they range from 0 through 1 +// (like color components). Thus, the values accepted by DepthRange are both +// clamped to this range before they are accepted. +// +// The default setting of (0, 1) maps the near plane to 0 and the far plane to 1. +// With this mapping, the depth buffer range is fully utilized. +// +// It is not necessary that nearVal be less than farVal. Reverse mappings such as +// nearVal 1, and farVal 0 are acceptable. +// +// GL.INVALID_OPERATION is generated if DepthRange is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) DepthRange(nearVal, farVal float64) { + C.gl4_2compat_glDepthRange(gl.funcs, C.GLdouble(nearVal), C.GLdouble(farVal)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsEnabled.xml +func (gl *GL) IsEnabled(cap glbase.Enum) bool { + glresult := C.gl4_2compat_glIsEnabled(gl.funcs, C.GLenum(cap)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexLevelParameteriv.xml +func (gl *GL) GetTexLevelParameteriv(target glbase.Enum, level int, pname glbase.Enum, params []int32) { + C.gl4_2compat_glGetTexLevelParameteriv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexLevelParameterfv.xml +func (gl *GL) GetTexLevelParameterfv(target glbase.Enum, level int, pname glbase.Enum, params []float32) { + C.gl4_2compat_glGetTexLevelParameterfv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameteriv.xml +func (gl *GL) GetTexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_2compat_glGetTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameterfv.xml +func (gl *GL) GetTexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_2compat_glGetTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexImage.xml +func (gl *GL) GetTexImage(target glbase.Enum, level int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glGetTexImage(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetIntegerv.xml +func (gl *GL) GetIntegerv(pname glbase.Enum, params []int32) { + C.gl4_2compat_glGetIntegerv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFloatv.xml +func (gl *GL) GetFloatv(pname glbase.Enum, params []float32) { + C.gl4_2compat_glGetFloatv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetError.xml +func (gl *GL) GetError() glbase.Enum { + glresult := C.gl4_2compat_glGetError(gl.funcs) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetDoublev.xml +func (gl *GL) GetDoublev(pname glbase.Enum, params []float64) { + C.gl4_2compat_glGetDoublev(gl.funcs, C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBooleanv.xml +func (gl *GL) GetBooleanv(pname glbase.Enum, params []bool) { + C.gl4_2compat_glGetBooleanv(gl.funcs, C.GLenum(pname), (*C.GLboolean)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glReadPixels.xml +func (gl *GL) ReadPixels(x, y, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glReadPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glReadBuffer.xml +func (gl *GL) ReadBuffer(mode glbase.Enum) { + C.gl4_2compat_glReadBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelStorei.xml +func (gl *GL) PixelStorei(pname glbase.Enum, param int32) { + C.gl4_2compat_glPixelStorei(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelStoref.xml +func (gl *GL) PixelStoref(pname glbase.Enum, param float32) { + C.gl4_2compat_glPixelStoref(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDepthFunc.xml +func (gl *GL) DepthFunc(glfunc glbase.Enum) { + C.gl4_2compat_glDepthFunc(gl.funcs, C.GLenum(glfunc)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilOp.xml +func (gl *GL) StencilOp(fail, zfail, zpass glbase.Enum) { + C.gl4_2compat_glStencilOp(gl.funcs, C.GLenum(fail), C.GLenum(zfail), C.GLenum(zpass)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilFunc.xml +func (gl *GL) StencilFunc(glfunc glbase.Enum, ref int32, mask uint32) { + C.gl4_2compat_glStencilFunc(gl.funcs, C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLogicOp.xml +func (gl *GL) LogicOp(opcode glbase.Enum) { + C.gl4_2compat_glLogicOp(gl.funcs, C.GLenum(opcode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFunc.xml +func (gl *GL) BlendFunc(sfactor, dfactor glbase.Enum) { + C.gl4_2compat_glBlendFunc(gl.funcs, C.GLenum(sfactor), C.GLenum(dfactor)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFlush.xml +func (gl *GL) Flush() { + C.gl4_2compat_glFlush(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFinish.xml +func (gl *GL) Finish() { + C.gl4_2compat_glFinish(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEnable.xml +func (gl *GL) Enable(cap glbase.Enum) { + C.gl4_2compat_glEnable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDisable.xml +func (gl *GL) Disable(cap glbase.Enum) { + C.gl4_2compat_glDisable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDepthMask.xml +func (gl *GL) DepthMask(flag bool) { + C.gl4_2compat_glDepthMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorMask.xml +func (gl *GL) ColorMask(red, green, blue, alpha bool) { + C.gl4_2compat_glColorMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&red)), *(*C.GLboolean)(unsafe.Pointer(&green)), *(*C.GLboolean)(unsafe.Pointer(&blue)), *(*C.GLboolean)(unsafe.Pointer(&alpha))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilMask.xml +func (gl *GL) StencilMask(mask uint32) { + C.gl4_2compat_glStencilMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearDepth.xml +func (gl *GL) ClearDepth(depth float64) { + C.gl4_2compat_glClearDepth(gl.funcs, C.GLdouble(depth)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearStencil.xml +func (gl *GL) ClearStencil(s int32) { + C.gl4_2compat_glClearStencil(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearColor.xml +func (gl *GL) ClearColor(red, green, blue, alpha float32) { + C.gl4_2compat_glClearColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClear.xml +func (gl *GL) Clear(mask glbase.Bitfield) { + C.gl4_2compat_glClear(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawBuffer.xml +func (gl *GL) DrawBuffer(mode glbase.Enum) { + C.gl4_2compat_glDrawBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage2D.xml +func (gl *GL) TexImage2D(target glbase.Enum, level int, internalFormat int32, width, height, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage1D.xml +func (gl *GL) TexImage1D(target glbase.Enum, level int, internalFormat int32, width, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameteriv.xml +func (gl *GL) TexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_2compat_glTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameteri.xml +func (gl *GL) TexParameteri(target, pname glbase.Enum, param int32) { + C.gl4_2compat_glTexParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterfv.xml +func (gl *GL) TexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_2compat_glTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterf.xml +func (gl *GL) TexParameterf(target, pname glbase.Enum, param float32) { + C.gl4_2compat_glTexParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glScissor.xml +func (gl *GL) Scissor(x, y, width, height int) { + C.gl4_2compat_glScissor(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPolygonMode.xml +func (gl *GL) PolygonMode(face, mode glbase.Enum) { + C.gl4_2compat_glPolygonMode(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointSize.xml +func (gl *GL) PointSize(size float32) { + C.gl4_2compat_glPointSize(gl.funcs, C.GLfloat(size)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLineWidth.xml +func (gl *GL) LineWidth(width float32) { + C.gl4_2compat_glLineWidth(gl.funcs, C.GLfloat(width)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glHint.xml +func (gl *GL) Hint(target, mode glbase.Enum) { + C.gl4_2compat_glHint(gl.funcs, C.GLenum(target), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFrontFace.xml +func (gl *GL) FrontFace(mode glbase.Enum) { + C.gl4_2compat_glFrontFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCullFace.xml +func (gl *GL) CullFace(mode glbase.Enum) { + C.gl4_2compat_glCullFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexubv.xml +func (gl *GL) Indexubv(c []uint8) { + C.gl4_2compat_glIndexubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexub.xml +func (gl *GL) Indexub(c uint8) { + C.gl4_2compat_glIndexub(gl.funcs, C.GLubyte(c)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsTexture.xml +func (gl *GL) IsTexture(texture glbase.Texture) bool { + glresult := C.gl4_2compat_glIsTexture(gl.funcs, C.GLuint(texture)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenTextures returns n texture names in textures. There is no guarantee +// that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenTextures. +// +// The generated textures have no dimensionality; they assume the +// dimensionality of the texture target to which they are first bound (see +// BindTexture). +// +// Texture names returned by a call to GenTextures are not returned by +// subsequent calls, unless they are first deleted with DeleteTextures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenTextures is available in GL version 2.0 or greater. +func (gl *GL) GenTextures(n int) []glbase.Texture { + if n == 0 { + return nil + } + textures := make([]glbase.Texture, n) + C.gl4_2compat_glGenTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) + return textures +} + +// DeleteTextures deletes the textures objects whose names are stored +// in the textures slice. After a texture is deleted, it has no contents or +// dimensionality, and its name is free for reuse (for example by +// GenTextures). If a texture that is currently bound is deleted, the binding +// reverts to 0 (the default texture). +// +// DeleteTextures silently ignores 0's and names that do not correspond to +// existing textures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteTextures is available in GL version 2.0 or greater. +func (gl *GL) DeleteTextures(textures []glbase.Texture) { + n := len(textures) + if n == 0 { + return + } + C.gl4_2compat_glDeleteTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindTexture.xml +func (gl *GL) BindTexture(target glbase.Enum, texture glbase.Texture) { + C.gl4_2compat_glBindTexture(gl.funcs, C.GLenum(target), C.GLuint(texture)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexSubImage2D.xml +func (gl *GL) TexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexSubImage1D.xml +func (gl *GL) TexSubImage1D(target glbase.Enum, level, xoffset, width int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexSubImage2D.xml +func (gl *GL) CopyTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, x, y, width, height int) { + C.gl4_2compat_glCopyTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexSubImage1D.xml +func (gl *GL) CopyTexSubImage1D(target glbase.Enum, level, xoffset, x, y, width int) { + C.gl4_2compat_glCopyTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexImage2D.xml +func (gl *GL) CopyTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, height, border int) { + C.gl4_2compat_glCopyTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexImage1D.xml +func (gl *GL) CopyTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, border int) { + C.gl4_2compat_glCopyTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPolygonOffset.xml +func (gl *GL) PolygonOffset(factor, units float32) { + C.gl4_2compat_glPolygonOffset(gl.funcs, C.GLfloat(factor), C.GLfloat(units)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElements.xml +func (gl *GL) DrawElements(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glDrawElements(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawArrays.xml +func (gl *GL) DrawArrays(mode glbase.Enum, first, count int) { + C.gl4_2compat_glDrawArrays(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexSubImage3D.xml +func (gl *GL) CopyTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, x, y, width, height int) { + C.gl4_2compat_glCopyTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexSubImage3D.xml +func (gl *GL) TexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage3D.xml +func (gl *GL) TexImage3D(target glbase.Enum, level int, internalFormat int32, width, height int, depth int32, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawRangeElements.xml +func (gl *GL) DrawRangeElements(mode glbase.Enum, start, end uint32, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glDrawRangeElements(gl.funcs, C.GLenum(mode), C.GLuint(start), C.GLuint(end), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendEquation.xml +func (gl *GL) BlendEquation(mode glbase.Enum) { + C.gl4_2compat_glBlendEquation(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendColor.xml +func (gl *GL) BlendColor(red, green, blue, alpha float32) { + C.gl4_2compat_glBlendColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetCompressedTexImage.xml +func (gl *GL) GetCompressedTexImage(target glbase.Enum, level int, img interface{}) { + var img_ptr unsafe.Pointer + var img_v = reflect.ValueOf(img) + if img != nil && img_v.Kind() != reflect.Slice { + panic("parameter img must be a slice") + } + if img != nil { + img_ptr = unsafe.Pointer(img_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glGetCompressedTexImage(gl.funcs, C.GLenum(target), C.GLint(level), img_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexSubImage1D.xml +func (gl *GL) CompressedTexSubImage1D(target glbase.Enum, level, xoffset, width int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glCompressedTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexSubImage2D.xml +func (gl *GL) CompressedTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glCompressedTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexSubImage3D.xml +func (gl *GL) CompressedTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glCompressedTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexImage1D.xml +func (gl *GL) CompressedTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, width, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glCompressedTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexImage2D.xml +func (gl *GL) CompressedTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glCompressedTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexImage3D.xml +func (gl *GL) CompressedTexImage3D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height int, depth int32, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glCompressedTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSampleCoverage.xml +func (gl *GL) SampleCoverage(value float32, invert bool) { + C.gl4_2compat_glSampleCoverage(gl.funcs, C.GLfloat(value), *(*C.GLboolean)(unsafe.Pointer(&invert))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glActiveTexture.xml +func (gl *GL) ActiveTexture(texture glbase.Enum) { + C.gl4_2compat_glActiveTexture(gl.funcs, C.GLenum(texture)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointParameteriv.xml +func (gl *GL) PointParameteriv(pname glbase.Enum, params []int32) { + C.gl4_2compat_glPointParameteriv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointParameteri.xml +func (gl *GL) PointParameteri(pname glbase.Enum, param int32) { + C.gl4_2compat_glPointParameteri(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointParameterfv.xml +func (gl *GL) PointParameterfv(pname glbase.Enum, params []float32) { + C.gl4_2compat_glPointParameterfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointParameterf.xml +func (gl *GL) PointParameterf(pname glbase.Enum, param float32) { + C.gl4_2compat_glPointParameterf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiDrawArrays.xml +func (gl *GL) MultiDrawArrays(mode glbase.Enum, first, count []int, drawcount int32) { + C.gl4_2compat_glMultiDrawArrays(gl.funcs, C.GLenum(mode), (*C.GLint)(unsafe.Pointer(&first[0])), (*C.GLsizei)(unsafe.Pointer(&count[0])), C.GLsizei(drawcount)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFuncSeparate.xml +func (gl *GL) BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha glbase.Enum) { + C.gl4_2compat_glBlendFuncSeparate(gl.funcs, C.GLenum(sfactorRGB), C.GLenum(dfactorRGB), C.GLenum(sfactorAlpha), C.GLenum(dfactorAlpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBufferParameteriv.xml +func (gl *GL) GetBufferParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_2compat_glGetBufferParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUnmapBuffer.xml +func (gl *GL) UnmapBuffer(target glbase.Enum) bool { + glresult := C.gl4_2compat_glUnmapBuffer(gl.funcs, C.GLenum(target)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBufferSubData.xml +func (gl *GL) GetBufferSubData(target glbase.Enum, offset, size int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glGetBufferSubData(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(size), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBufferSubData.xml +func (gl *GL) BufferSubData(target glbase.Enum, offset, size int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glBufferSubData(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(size), data_ptr) +} + +// BufferData creates a new data store for the buffer object currently +// bound to target. Any pre-existing data store is deleted. The new data +// store is created with the specified size in bytes and usage. If data is +// not nil, it must be a slice that is used to initialize the data store. +// In that case the size parameter is ignored and the store size will match +// the slice data size. +// +// In its initial state, the new data store is not mapped, it has a NULL +// mapped pointer, and its mapped access is GL.READ_WRITE. +// +// The target constant must be one of GL.ARRAY_BUFFER, GL.COPY_READ_BUFFER, +// GL.COPY_WRITE_BUFFER, GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER, +// GL.PIXEL_UNPACK_BUFFER, GL.TEXTURE_BUFFER, GL.TRANSFORM_FEEDBACK_BUFFER, +// or GL.UNIFORM_BUFFER. +// +// The usage parameter is a hint to the GL implementation as to how a buffer +// object's data store will be accessed. This enables the GL implementation +// to make more intelligent decisions that may significantly impact buffer +// object performance. It does not, however, constrain the actual usage of +// the data store. usage can be broken down into two parts: first, the +// frequency of access (modification and usage), and second, the nature of +// that access. +// +// A usage frequency of STREAM and nature of DRAW is specified via the +// constant GL.STREAM_DRAW, for example. +// +// The usage frequency of access may be one of: +// +// STREAM +// The data store contents will be modified once and used at most a few times. +// +// STATIC +// The data store contents will be modified once and used many times. +// +// DYNAMIC +// The data store contents will be modified repeatedly and used many times. +// +// The usage nature of access may be one of: +// +// DRAW +// The data store contents are modified by the application, and used as +// the source for GL drawing and image specification commands. +// +// READ +// The data store contents are modified by reading data from the GL, +// and used to return that data when queried by the application. +// +// COPY +// The data store contents are modified by reading data from the GL, +// and used as the source for GL drawing and image specification +// commands. +// +// Clients must align data elements consistent with the requirements of the +// client platform, with an additional base-level requirement that an offset +// within a buffer to a datum comprising N bytes be a multiple of N. +// +// Error GL.INVALID_ENUM is generated if target is not one of the accepted +// buffer targets. GL.INVALID_ENUM is generated if usage is not +// GL.STREAM_DRAW, GL.STREAM_READ, GL.STREAM_COPY, GL.STATIC_DRAW, +// GL.STATIC_READ, GL.STATIC_COPY, GL.DYNAMIC_DRAW, GL.DYNAMIC_READ, or +// GL.DYNAMIC_COPY. GL.INVALID_VALUE is generated if size is negative. +// GL.INVALID_OPERATION is generated if the reserved buffer object name 0 is +// bound to target. GL.OUT_OF_MEMORY is generated if the GL is unable to +// create a data store with the specified size. +func (gl *GL) BufferData(target glbase.Enum, size int, data interface{}, usage glbase.Enum) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + if data != nil { + size = int(data_v.Type().Size()) * data_v.Len() + } + C.gl4_2compat_glBufferData(gl.funcs, C.GLenum(target), C.GLsizeiptr(size), data_ptr, C.GLenum(usage)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsBuffer.xml +func (gl *GL) IsBuffer(buffer glbase.Buffer) bool { + glresult := C.gl4_2compat_glIsBuffer(gl.funcs, C.GLuint(buffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenBuffers returns n buffer object names. There is no guarantee that +// the names form a contiguous set of integers; however, it is guaranteed +// that none of the returned names was in use immediately before the call to +// GenBuffers. +// +// Buffer object names returned by a call to GenBuffers are not returned by +// subsequent calls, unless they are first deleted with DeleteBuffers. +// +// No buffer objects are associated with the returned buffer object names +// until they are first bound by calling BindBuffer. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if GenBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// GenBuffers is available in GL version 1.5 or greater. +func (gl *GL) GenBuffers(n int) []glbase.Buffer { + if n == 0 { + return nil + } + buffers := make([]glbase.Buffer, n) + C.gl4_2compat_glGenBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) + return buffers +} + +// DeleteBuffers deletes the buffer objects whose names are stored in the +// buffers slice. +// +// After a buffer object is deleted, it has no contents, and its name is free +// for reuse (for example by GenBuffers). If a buffer object that is +// currently bound is deleted, the binding reverts to 0 (the absence of any +// buffer object, which reverts to client memory usage). +// +// DeleteBuffers silently ignores 0's and names that do not correspond to +// existing buffer objects. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if DeleteBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// DeleteBuffers is available in GL version 1.5 or greater. +func (gl *GL) DeleteBuffers(buffers []glbase.Buffer) { + n := len(buffers) + if n == 0 { + return + } + C.gl4_2compat_glDeleteBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) +} + +// BindBuffer creates or puts in use a named buffer object. +// Calling BindBuffer with target set to GL.ARRAY_BUFFER, +// GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER or GL.PIXEL_UNPACK_BUFFER +// and buffer set to the name of the new buffer object binds the buffer +// object name to the target. When a buffer object is bound to a target, the +// previous binding for that target is automatically broken. +// +// Buffer object names are unsigned integers. The value zero is reserved, but +// there is no default buffer object for each buffer object target. Instead, +// buffer set to zero effectively unbinds any buffer object previously bound, +// and restores client memory usage for that buffer object target. Buffer +// object names and the corresponding buffer object contents are local to the +// shared display-list space (see XCreateContext) of the current GL rendering +// context; two rendering contexts share buffer object names only if they +// also share display lists. +// +// GenBuffers may be called to generate a set of new buffer object names. +// +// The state of a buffer object immediately after it is first bound is an +// unmapped zero-sized memory buffer with GL.READ_WRITE access and +// GL.STATIC_DRAW usage. +// +// While a non-zero buffer object name is bound, GL operations on the target +// to which it is bound affect the bound buffer object, and queries of the +// target to which it is bound return state from the bound buffer object. +// While buffer object name zero is bound, as in the initial state, attempts +// to modify or query state on the target to which it is bound generates an +// GL.INVALID_OPERATION error. +// +// When vertex array pointer state is changed, for example by a call to +// NormalPointer, the current buffer object binding (GL.ARRAY_BUFFER_BINDING) +// is copied into the corresponding client state for the vertex array type +// being changed, for example GL.NORMAL_ARRAY_BUFFER_BINDING. While a +// non-zero buffer object is bound to the GL.ARRAY_BUFFER target, the vertex +// array pointer parameter that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.ELEMENT_ARRAY_BUFFER +// target, the indices parameter of DrawElements, DrawRangeElements, or +// MultiDrawElements that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_PACK_BUFFER +// target, the following commands are affected: GetCompressedTexImage, +// GetConvolutionFilter, GetHistogram, GetMinmax, GetPixelMap, +// GetPolygonStipple, GetSeparableFilter, GetTexImage, and ReadPixels. The +// pointer parameter that is traditionally interpreted as a pointer to +// client-side memory where the pixels are to be packed is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_UNPACK_BUFFER +// target, the following commands are affected: Bitmap, ColorSubTable, +// ColorTable, CompressedTexImage1D, CompressedTexImage2D, +// CompressedTexImage3D, CompressedTexSubImage1D, CompressedTexSubImage2D, +// CompressedTexSubImage3D, ConvolutionFilter1D, ConvolutionFilter2D, +// DrawPixels, PixelMap, PolygonStipple, SeparableFilter2D, TexImage1D, +// TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, and TexSubImage3D. +// The pointer parameter that is traditionally interpreted as a pointer to +// client-side memory from which the pixels are to be unpacked is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// A buffer object binding created with BindBuffer remains active until a +// different buffer object name is bound to the same target, or until the +// bound buffer object is deleted with DeleteBuffers. +// +// Once created, a named buffer object may be re-bound to any target as often +// as needed. However, the GL implementation may make choices about how to +// optimize the storage of a buffer object based on its initial binding +// target. +// +// Error GL.INVALID_ENUM is generated if target is not one of the allowable +// values. GL.INVALID_OPERATION is generated if BindBuffer is executed +// between the execution of Begin and the corresponding execution of End. +// +// BindBuffer is available in GL version 1.5 or greater. +func (gl *GL) BindBuffer(target glbase.Enum, buffer glbase.Buffer) { + C.gl4_2compat_glBindBuffer(gl.funcs, C.GLenum(target), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryObjectuiv.xml +func (gl *GL) GetQueryObjectuiv(id uint32, pname glbase.Enum, params []uint32) { + C.gl4_2compat_glGetQueryObjectuiv(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryObjectiv.xml +func (gl *GL) GetQueryObjectiv(id uint32, pname glbase.Enum, params []int32) { + C.gl4_2compat_glGetQueryObjectiv(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryiv.xml +func (gl *GL) GetQueryiv(target, pname glbase.Enum, params []int32) { + C.gl4_2compat_glGetQueryiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndQuery.xml +func (gl *GL) EndQuery(target glbase.Enum) { + C.gl4_2compat_glEndQuery(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBeginQuery.xml +func (gl *GL) BeginQuery(target glbase.Enum, id uint32) { + C.gl4_2compat_glBeginQuery(gl.funcs, C.GLenum(target), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsQuery.xml +func (gl *GL) IsQuery(id uint32) bool { + glresult := C.gl4_2compat_glIsQuery(gl.funcs, C.GLuint(id)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteQueries.xml +func (gl *GL) DeleteQueries(n int, ids []uint32) { + C.gl4_2compat_glDeleteQueries(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenQueries.xml +func (gl *GL) GenQueries(n int, ids []uint32) { + C.gl4_2compat_glGenQueries(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// VertexAttribPointer specifies the location and data format of the array +// of generic vertex attributes at index to use when rendering. size +// specifies the number of components per attribute and must be 1, 2, 3, or +// 4. type specifies the data type of each component, and stride specifies +// the byte stride from one attribute to the next, allowing vertices and +// attributes to be packed into a single array or stored in separate arrays. +// normalized indicates whether the values stored in an integer format are +// to be mapped to the range [-1,1] (for signed values) or [0,1] +// (for unsigned values) when they are accessed and converted to floating +// point; otherwise, values will be converted to floats directly without +// normalization. offset is a byte offset into the buffer object's data +// store, which must be bound to the GL.ARRAY_BUFFER target with BindBuffer. +// +// The buffer object binding (GL.ARRAY_BUFFER_BINDING) is saved as +// generic vertex attribute array client-side state +// (GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING) for the provided index. +// +// To enable and disable a generic vertex attribute array, call +// EnableVertexAttribArray and DisableVertexAttribArray with index. If +// enabled, the generic vertex attribute array is used when DrawArrays or +// DrawElements is called. Each generic vertex attribute array is initially +// disabled. +// +// VertexAttribPointer is typically implemented on the client side. +// +// Error GL.INVALID_ENUM is generated if type is not an accepted value. +// GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_VALUE is generated if size is not 1, 2, +// 3, or 4. GL.INVALID_VALUE is generated if stride is negative. +func (gl *GL) VertexAttribPointer(index glbase.Attrib, size int, gltype glbase.Enum, normalized bool, stride int, offset uintptr) { + offset_ptr := unsafe.Pointer(offset) + C.gl4_2compat_glVertexAttribPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLsizei(stride), offset_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glValidateProgram.xml +func (gl *GL) ValidateProgram(program glbase.Program) { + C.gl4_2compat_glValidateProgram(gl.funcs, C.GLuint(program)) +} + +// UniformMatrix4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*4) != 0 { + panic("invalid value length for UniformMatrix4fv") + } + count := len(value) / (4 * 4) + C.gl4_2compat_glUniformMatrix4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*3) != 0 { + panic("invalid value length for UniformMatrix3fv") + } + count := len(value) / (3 * 3) + C.gl4_2compat_glUniformMatrix3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*2) != 0 { + panic("invalid value length for UniformMatrix2fv") + } + count := len(value) / (2 * 2) + C.gl4_2compat_glUniformMatrix2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform4iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4iv") + } + count := len(value) / 4 + C.gl4_2compat_glUniform4iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform3iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3iv") + } + count := len(value) / 3 + C.gl4_2compat_glUniform3iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform2iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2iv") + } + count := len(value) / 2 + C.gl4_2compat_glUniform2iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform1iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl4_2compat_glUniform1iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4fv") + } + count := len(value) / 4 + C.gl4_2compat_glUniform4fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3fv") + } + count := len(value) / 3 + C.gl4_2compat_glUniform3fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2fv") + } + count := len(value) / 2 + C.gl4_2compat_glUniform2fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform1fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl4_2compat_glUniform1fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform4i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4i(location glbase.Uniform, v0, v1, v2, v3 int32) { + C.gl4_2compat_glUniform4i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2), C.GLint(v3)) +} + +// Uniform3i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3i(location glbase.Uniform, v0, v1, v2 int32) { + C.gl4_2compat_glUniform3i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2)) +} + +// Uniform2i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2i(location glbase.Uniform, v0, v1 int32) { + C.gl4_2compat_glUniform2i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1)) +} + +// Uniform1i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1i(location glbase.Uniform, v0 int32) { + C.gl4_2compat_glUniform1i(gl.funcs, C.GLint(location), C.GLint(v0)) +} + +// Uniform4f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4f(location glbase.Uniform, v0, v1, v2, v3 float32) { + C.gl4_2compat_glUniform4f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2), C.GLfloat(v3)) +} + +// Uniform3f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3f(location glbase.Uniform, v0, v1, v2 float32) { + C.gl4_2compat_glUniform3f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2)) +} + +// Uniform2f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2f(location glbase.Uniform, v0, v1 float32) { + C.gl4_2compat_glUniform2f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1)) +} + +// Uniform1f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1f(location glbase.Uniform, v0 float32) { + C.gl4_2compat_glUniform1f(gl.funcs, C.GLint(location), C.GLfloat(v0)) +} + +// UseProgram installs the program object specified by program as part of +// current rendering state. One or more executables are created in a program +// object by successfully attaching shader objects to it with AttachShader, +// successfully compiling the shader objects with CompileShader, and +// successfully linking the program object with LinkProgram. +// +// A program object will contain an executable that will run on the vertex +// processor if it contains one or more shader objects of type +// GL.VERTEX_SHADER that have been successfully compiled and linked. +// Similarly, a program object will contain an executable that will run on +// the fragment processor if it contains one or more shader objects of type +// GL.FRAGMENT_SHADER that have been successfully compiled and linked. +// +// Successfully installing an executable on a programmable processor will +// cause the corresponding fixed functionality of OpenGL to be disabled. +// Specifically, if an executable is installed on the vertex processor, the +// OpenGL fixed functionality will be disabled as follows. +// +// - The modelview matrix is not applied to vertex coordinates. +// +// - The projection matrix is not applied to vertex coordinates. +// +// - The texture matrices are not applied to texture coordinates. +// +// - Normals are not transformed to eye coordinates. +// +// - Normals are not rescaled or normalized. +// +// - Normalization of GL.AUTO_NORMAL evaluated normals is not performed. +// +// - Texture coordinates are not generated automatically. +// +// - Per-vertex lighting is not performed. +// +// - Color material computations are not performed. +// +// - Color index lighting is not performed. +// +// - This list also applies when setting the current raster position. +// +// The executable that is installed on the vertex processor is expected to +// implement any or all of the desired functionality from the preceding list. +// Similarly, if an executable is installed on the fragment processor, the +// OpenGL fixed functionality will be disabled as follows. +// +// - Texture environment and texture functions are not applied. +// +// - Texture application is not applied. +// +// - Color sum is not applied. +// +// - Fog is not applied. +// +// Again, the fragment shader that is installed is expected to implement any +// or all of the desired functionality from the preceding list. +// +// While a program object is in use, applications are free to modify attached +// shader objects, compile attached shader objects, attach additional shader +// objects, and detach or delete shader objects. None of these operations +// will affect the executables that are part of the current state. However, +// relinking the program object that is currently in use will install the +// program object as part of the current rendering state if the link +// operation was successful (see LinkProgram). If the program object +// currently in use is relinked unsuccessfully, its link status will be set +// to GL.FALSE, but the executables and associated state will remain part of +// the current state until a subsequent call to UseProgram removes it from +// use. After it is removed from use, it cannot be made part of current state +// until it has been successfully relinked. +// +// If program contains shader objects of type GL.VERTEX_SHADER but it does +// not contain shader objects of type GL.FRAGMENT_SHADER, an executable will +// be installed on the vertex processor, but fixed functionality will be used +// for fragment processing. Similarly, if program contains shader objects of +// type GL.FRAGMENT_SHADER but it does not contain shader objects of type +// GL.VERTEX_SHADER, an executable will be installed on the fragment +// processor, but fixed functionality will be used for vertex processing. If +// program is 0, the programmable processors will be disabled, and fixed +// functionality will be used for both vertex and fragment processing. +// +// While a program object is in use, the state that controls the disabled +// fixed functionality may also be updated using the normal OpenGL calls. +// +// Like display lists and texture objects, the name space for program objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// Applications are responsible for providing the synchronization across API +// calls when objects are accessed from different execution threads. +// +// Error GL.INVALID_VALUE is generated if program is neither 0 nor a value +// generated by OpenGL. GL.INVALID_OPERATION is generated if program is not +// a program object. GL.INVALID_OPERATION is generated if program could not +// be made part of current state. GL.INVALID_OPERATION is generated if +// UseProgram is executed between the execution of Begin and the +// corresponding execution of End. +// +// UseProgram is available in GL version 2.0 or greater. +func (gl *GL) UseProgram(program glbase.Program) { + C.gl4_2compat_glUseProgram(gl.funcs, C.GLuint(program)) +} + +// ShaderSource sets the source code in shader to the provided source code. Any source +// code previously stored in the shader object is completely replaced. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_VALUE is generated if count is less than 0. +// GL.INVALID_OPERATION is generated if ShaderSource is executed between the +// execution of Begin and the corresponding execution of End. +// +// ShaderSource is available in GL version 2.0 or greater. +func (gl *GL) ShaderSource(shader glbase.Shader, source ...string) { + count := len(source) + length := make([]int32, count) + source_c := make([]unsafe.Pointer, count) + for i, src := range source { + length[i] = int32(len(src)) + if len(src) > 0 { + source_c[i] = *(*unsafe.Pointer)(unsafe.Pointer(&src)) + } else { + source_c[i] = unsafe.Pointer(uintptr(0)) + } + } + C.gl4_2compat_glShaderSource(gl.funcs, C.GLuint(shader), C.GLsizei(count), (**C.GLchar)(unsafe.Pointer(&source_c[0])), (*C.GLint)(unsafe.Pointer(&length[0]))) +} + +// LinkProgram links the program object specified by program. If any shader +// objects of type GL.VERTEX_SHADER are attached to program, they will be +// used to create an executable that will run on the programmable vertex +// processor. If any shader objects of type GL.FRAGMENT_SHADER are attached +// to program, they will be used to create an executable that will run on the +// programmable fragment processor. +// +// The status of the link operation will be stored as part of the program +// object's state. This value will be set to GL.TRUE if the program object +// was linked without errors and is ready for use, and GL.FALSE otherwise. It +// can be queried by calling GetProgramiv with arguments program and +// GL.LINK_STATUS. +// +// As a result of a successful link operation, all active user-defined +// uniform variables belonging to program will be initialized to 0, and each +// of the program object's active uniform variables will be assigned a +// location that can be queried by calling GetUniformLocation. Also, any +// active user-defined attribute variables that have not been bound to a +// generic vertex attribute index will be bound to one at this time. +// +// Linking of a program object can fail for a number of reasons as specified +// in the OpenGL Shading Language Specification. The following lists some of +// the conditions that will cause a link error. +// +// - The number of active attribute variables supported by the +// implementation has been exceeded. +// +// - The storage limit for uniform variables has been exceeded. +// +// - The number of active uniform variables supported by the implementation +// has been exceeded. +// +// - The main function is missing for the vertex shader or the fragment +// shader. +// +// - A varying variable actually used in the fragment shader is not +// declared in the same way (or is not declared at all) in the vertex +// shader. +// +// - A reference to a function or variable name is unresolved. +// +// - A shared global is declared with two different types or two different +// initial values. +// +// - One or more of the attached shader objects has not been successfully +// compiled. +// +// - Binding a generic attribute matrix caused some rows of the matrix to +// fall outside the allowed maximum of GL.MAX_VERTEX_ATTRIBS. +// +// - Not enough contiguous vertex attribute slots could be found to bind +// attribute matrices. +// +// When a program object has been successfully linked, the program object can +// be made part of current state by calling UseProgram. Whether or not the +// link operation was successful, the program object's information log will +// be overwritten. The information log can be retrieved by calling +// GetProgramInfoLog. +// +// LinkProgram will also install the generated executables as part of the +// current rendering state if the link operation was successful and the +// specified program object is already currently in use as a result of a +// previous call to UseProgram. If the program object currently in use is +// relinked unsuccessfully, its link status will be set to GL.FALSE , but the +// executables and associated state will remain part of the current state +// until a subsequent call to UseProgram removes it from use. After it is +// removed from use, it cannot be made part of current state until it has +// been successfully relinked. +// +// If program contains shader objects of type GL.VERTEX_SHADER but does not +// contain shader objects of type GL.FRAGMENT_SHADER, the vertex shader will +// be linked against the implicit interface for fixed functionality fragment +// processing. Similarly, if program contains shader objects of type +// GL.FRAGMENT_SHADER but it does not contain shader objects of type +// GL.VERTEX_SHADER, the fragment shader will be linked against the implicit +// interface for fixed functionality vertex processing. +// +// The program object's information log is updated and the program is +// generated at the time of the link operation. After the link operation, +// applications are free to modify attached shader objects, compile attached +// shader objects, detach shader objects, delete shader objects, and attach +// additional shader objects. None of these operations affects the +// information log or the program that is part of the program object. +// +// If the link operation is unsuccessful, any information about a previous +// link operation on program is lost (a failed link does not restore the +// old state of program). Certain information can still be retrieved +// from program even after an unsuccessful link operation. See for instance +// GetActiveAttrib and GetActiveUniform. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if LinkProgram is executed +// between the execution of Begin and the corresponding execution of End. +// +// LinkProgram is available in GL version 2.0 or greater. +func (gl *GL) LinkProgram(program glbase.Program) { + C.gl4_2compat_glLinkProgram(gl.funcs, C.GLuint(program)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsShader.xml +func (gl *GL) IsShader(shader glbase.Shader) bool { + glresult := C.gl4_2compat_glIsShader(gl.funcs, C.GLuint(shader)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsProgram.xml +func (gl *GL) IsProgram(program glbase.Program) bool { + glresult := C.gl4_2compat_glIsProgram(gl.funcs, C.GLuint(program)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GetVertexAttribiv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribiv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribiv(index glbase.Attrib, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl4_2compat_glGetVertexAttribiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetVertexAttribfv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribfv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribfv(index glbase.Attrib, pname glbase.Enum, params []float32) { + var params_c [4]float32 + C.gl4_2compat_glGetVertexAttribfv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetVertexAttribdv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribdv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribdv(index glbase.Attrib, pname glbase.Enum, params []float64) { + var params_c [4]float64 + C.gl4_2compat_glGetVertexAttribdv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformiv returns in params the value of the specified uniform +// variable. The type of the uniform variable specified by location +// determines the number of values returned. If the uniform variable is +// defined in the shader as a boolean, int, or float, a single value will be +// returned. If it is defined as a vec2, ivec2, or bvec2, two values will be +// returned. If it is defined as a vec3, ivec3, or bvec3, three values will +// be returned, and so on. To query values stored in uniform variables +// declared as arrays, call GetUniformiv for each element of the array. To +// query values stored in uniform variables declared as structures, call +// GetUniformiv for each field in the structure. The values for uniform +// variables declared as a matrix will be returned in column major order. +// +// The locations assigned to uniform variables are not known until the +// program object is linked. After linking has occurred, the command +// GetUniformLocation can be used to obtain the location of a uniform +// variable. This location value can then be passed to GetUniformiv in order +// to query the current value of the uniform variable. After a program object +// has been linked successfully, the index values for uniform variables +// remain fixed until the next link command occurs. The uniform variable +// values can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if program has not been +// successfully linked. GL.INVALID_OPERATION is generated if location does +// not correspond to a valid uniform variable location for the specified +// program object. GL.INVALID_OPERATION is generated if GetUniformiv is +// executed between the execution of Begin and the corresponding execution of +// End. +// +// GetUniformiv is available in GL version 2.0 or greater. +func (gl *GL) GetUniformiv(program glbase.Program, location glbase.Uniform, params []int32) { + var params_c [4]int32 + C.gl4_2compat_glGetUniformiv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformfv returns in params the value of the specified uniform +// variable. The type of the uniform variable specified by location +// determines the number of values returned. If the uniform variable is +// defined in the shader as a boolean, int, or float, a single value will be +// returned. If it is defined as a vec2, ivec2, or bvec2, two values will be +// returned. If it is defined as a vec3, ivec3, or bvec3, three values will +// be returned, and so on. To query values stored in uniform variables +// declared as arrays, call GetUniformfv for each element of the array. To +// query values stored in uniform variables declared as structures, call +// GetUniformfv for each field in the structure. The values for uniform +// variables declared as a matrix will be returned in column major order. +// +// The locations assigned to uniform variables are not known until the +// program object is linked. After linking has occurred, the command +// GetUniformLocation can be used to obtain the location of a uniform +// variable. This location value can then be passed to GetUniformfv in order +// to query the current value of the uniform variable. After a program object +// has been linked successfully, the index values for uniform variables +// remain fixed until the next link command occurs. The uniform variable +// values can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if program has not been +// successfully linked. GL.INVALID_OPERATION is generated if location does +// not correspond to a valid uniform variable location for the specified +// program object. GL.INVALID_OPERATION is generated if GetUniformfv is +// executed between the execution of Begin and the corresponding execution of +// End. +// +// GetUniformfv is available in GL version 2.0 or greater. +func (gl *GL) GetUniformfv(program glbase.Program, location glbase.Uniform, params []float32) { + var params_c [4]float32 + C.gl4_2compat_glGetUniformfv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLfloat)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformLocation returns an integer that represents the location of a +// specific uniform variable within a program object. name must be an active +// uniform variable name in program that is not a structure, an array of +// structures, or a subcomponent of a vector or a matrix. This function +// returns -1 if name does not correspond to an active uniform variable in +// program or if name starts with the reserved prefix "gl_". +// +// Uniform variables that are structures or arrays of structures may be +// queried by calling GetUniformLocation for each field within the +// structure. The array element operator "[]" and the structure field +// operator "." may be used in name in order to select elements within an +// array or fields within a structure. The result of using these operators is +// not allowed to be another structure, an array of structures, or a +// subcomponent of a vector or a matrix. Except if the last part of name +// indicates a uniform variable array, the location of the first element of +// an array can be retrieved by using the name of the array, or by using the +// name appended by "[0]". +// +// The actual locations assigned to uniform variables are not known until the +// program object is linked successfully. After linking has occurred, the +// command GetUniformLocation can be used to obtain the location of a +// uniform variable. This location value can then be passed to Uniform to +// set the value of the uniform variable or to GetUniform in order to query +// the current value of the uniform variable. After a program object has been +// linked successfully, the index values for uniform variables remain fixed +// until the next link command occurs. Uniform variable locations and values +// can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program object. +// GL.INVALID_OPERATION is generated if program has not been successfully +// linked. GL.INVALID_OPERATION is generated if GetUniformLocation is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetUniformLocation is available in GL version 2.0 or greater. +func (gl *GL) GetUniformLocation(program glbase.Program, name string) glbase.Uniform { + name_cstr := C.CString(name) + glresult := C.gl4_2compat_glGetUniformLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) + return glbase.Uniform(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetShaderSource.xml +func (gl *GL) GetShaderSource(shader glbase.Shader, bufSize int32, length []int32, source []byte) { + C.gl4_2compat_glGetShaderSource(gl.funcs, C.GLuint(shader), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&source[0]))) +} + +// GetShaderInfoLog returns the information log for the specified shader +// object. The information log for a shader object is modified when the +// shader is compiled. +// +// The information log for a shader object is a string that may contain +// diagnostic messages, warning messages, and other information about the +// last compile operation. When a shader object is created, its information +// log will be a string of length 0, and the size of the current log can be +// obtained by calling GetShaderiv with the value GL.INFO_LOG_LENGTH. +// +// The information log for a shader object is the OpenGL implementer's +// primary mechanism for conveying information about the compilation process. +// Therefore, the information log can be helpful to application developers +// during the development process, even when compilation is successful. +// Application developers should not expect different OpenGL implementations +// to produce identical information logs. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_VALUE is generated if maxLength is less than 0. +// GL.INVALID_OPERATION is generated if GetShaderInfoLog is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetShaderInfoLog is available in GL version 2.0 or greater. +func (gl *GL) GetShaderInfoLog(shader glbase.Shader) []byte { + var params [1]int32 + var length int32 + gl.GetShaderiv(shader, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + C.gl4_2compat_glGetShaderInfoLog(gl.funcs, C.GLuint(shader), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length)), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) + return infoLog +} + +// GetShaderiv GetShader returns in params the value of a parameter for a specific +// shader object. The following parameters are defined: +// +// GL.SHADER_TYPE +// params returns GL.VERTEX_SHADER if shader is a vertex shader object, +// and GL.FRAGMENT_SHADER if shader is a fragment shader object. +// +// GL.DELETE_STATUS +// params returns GL.TRUE if shader is currently flagged for deletion, +// and GL.FALSE otherwise. +// +// GL.COMPILE_STATUS +// params returns GL.TRUE if the last compile operation on shader was +// successful, and GL.FALSE otherwise. +// +// GL.INFO_LOG_LENGTH +// params returns the number of characters in the information log for +// shader including the null termination character (the size of the +// character buffer required to store the information log). If shader has +// no information log, a value of 0 is returned. +// +// GL.SHADER_SOURCE_LENGTH +// params returns the length of the concatenation of the source strings +// that make up the shader source for the shader, including the null +// termination character. (the size of the character buffer +// required to store the shader source). If no source code exists, 0 is +// returned. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader does not refer to a +// shader object. GL.INVALID_ENUM is generated if pname is not an accepted +// value. GL.INVALID_OPERATION is generated if GetShader is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetShaderiv is available in GL version 2.0 or greater. +func (gl *GL) GetShaderiv(shader glbase.Shader, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl4_2compat_glGetShaderiv(gl.funcs, C.GLuint(shader), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetProgramInfoLog returns the information log for the specified program +// object. The information log for a program object is modified when the +// program object is linked or validated. +// +// The information log for a program object is either an empty string, or a +// string containing information about the last link operation, or a string +// containing information about the last validation operation. It may contain +// diagnostic messages, warning messages, and other information. When a +// program object is created, its information log will be a string of length +// 0, and the size of the current log can be obtained by calling GetProgramiv +// with the value GL.INFO_LOG_LENGTH. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated +// by OpenGL. GL.INVALID_OPERATION is generated if program is not a +// program object. +func (gl *GL) GetProgramInfoLog(program glbase.Program) []byte { + var params [1]int32 + var length int32 + gl.GetProgramiv(program, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + C.gl4_2compat_glGetProgramInfoLog(gl.funcs, C.GLuint(program), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length)), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) + return infoLog +} + +// GetProgramiv returns in params the value of a parameter for a specific +// program object. The following parameters are defined: +// +// GL.DELETE_STATUS +// params returns GL.TRUE if program is currently flagged for deletion, +// and GL.FALSE otherwise. +// +// GL.LINK_STATUS +// params returns GL.TRUE if the last link operation on program was +// successful, and GL.FALSE otherwise. +// +// GL.VALIDATE_STATUS +// params returns GL.TRUE or if the last validation operation on +// program was successful, and GL.FALSE otherwise. +// +// GL.INFO_LOG_LENGTH +// params returns the number of characters in the information log for +// program including the null termination character (the size of +// the character buffer required to store the information log). If +// program has no information log, a value of 0 is returned. +// +// GL.ATTACHED_SHADERS +// params returns the number of shader objects attached to program. +// +// GL.ACTIVE_ATTRIBUTES +// params returns the number of active attribute variables for program. +// +// GL.ACTIVE_ATTRIBUTE_MAX_LENGTH +// params returns the length of the longest active attribute name for +// program, including the null termination character (the size of +// the character buffer required to store the longest attribute name). +// If no active attributes exist, 0 is returned. +// +// GL.ACTIVE_UNIFORMS +// params returns the number of active uniform variables for program. +// +// GL.ACTIVE_UNIFORM_MAX_LENGTH +// params returns the length of the longest active uniform variable +// name for program, including the null termination character (i.e., +// the size of the character buffer required to store the longest +// uniform variable name). If no active uniform variables exist, 0 is +// returned. +// +// GL.TRANSFORM_FEEDBACK_BUFFER_MODE +// params returns a symbolic constant indicating the buffer mode used +// when transform feedback is active. This may be GL.SEPARATE_ATTRIBS +// or GL.INTERLEAVED_ATTRIBS. +// +// GL.TRANSFORM_FEEDBACK_VARYINGS +// params returns the number of varying variables to capture in transform +// feedback mode for the program. +// +// GL.TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH +// params returns the length of the longest variable name to be used for +// transform feedback, including the null-terminator. +// +// GL.GEOMETRY_VERTICES_OUT +// params returns the maximum number of vertices that the geometry shader in +// program will output. +// +// GL.GEOMETRY_INPUT_TYPE +// params returns a symbolic constant indicating the primitive type accepted +// as input to the geometry shader contained in program. +// +// GL.GEOMETRY_OUTPUT_TYPE +// params returns a symbolic constant indicating the primitive type that will +// be output by the geometry shader contained in program. +// +// GL.ACTIVE_UNIFORM_BLOCKS and GL.ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH are +// available only if the GL version 3.1 or greater. +// +// GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE and +// GL.GEOMETRY_OUTPUT_TYPE are accepted only if the GL version is 3.2 or +// greater. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program does not refer to a +// program object. GL.INVALID_OPERATION is generated if pname is +// GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE, or +// GL.GEOMETRY_OUTPUT_TYPE, and program does not contain a geometry shader. +// GL.INVALID_ENUM is generated if pname is not an accepted value. +func (gl *GL) GetProgramiv(program glbase.Program, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl4_2compat_glGetProgramiv(gl.funcs, C.GLuint(program), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetAttribLocation queries the previously linked program object specified +// by program for the attribute variable specified by name and returns the +// index of the generic vertex attribute that is bound to that attribute +// variable. If name is a matrix attribute variable, the index of the first +// column of the matrix is returned. If the named attribute variable is not +// an active attribute in the specified program object or if name starts with +// the reserved prefix "gl_", a value of -1 is returned. +// +// The association between an attribute variable name and a generic attribute +// index can be specified at any time by calling BindAttribLocation. +// Attribute bindings do not go into effect until LinkProgram is called. +// After a program object has been linked successfully, the index values for +// attribute variables remain fixed until the next link command occurs. The +// attribute values can only be queried after a link if the link was +// successful. GetAttribLocation returns the binding that actually went +// into effect the last time LinkProgram was called for the specified +// program object. Attribute bindings that have been specified since the last +// link operation are not returned by GetAttribLocation. +// +// Error GL_INVALID_OPERATION is generated if program is not a value +// generated by OpenGL. GL_INVALID_OPERATION is generated if program is not +// a program object. GL_INVALID_OPERATION is generated if program has not +// been successfully linked. GL_INVALID_OPERATION is generated if +// GetAttribLocation is executed between the execution of Begin and the +// corresponding execution of End. +// +// GetAttribLocation is available in GL version 2.0 or greater. +func (gl *GL) GetAttribLocation(program glbase.Program, name string) glbase.Attrib { + name_cstr := C.CString(name) + glresult := C.gl4_2compat_glGetAttribLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) + return glbase.Attrib(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetAttachedShaders.xml +func (gl *GL) GetAttachedShaders(program glbase.Program, maxCount int32, count []int, obj []uint32) { + C.gl4_2compat_glGetAttachedShaders(gl.funcs, C.GLuint(program), C.GLsizei(maxCount), (*C.GLsizei)(unsafe.Pointer(&count[0])), (*C.GLuint)(unsafe.Pointer(&obj[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniform.xml +func (gl *GL) GetActiveUniform(program glbase.Program, index uint32, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl4_2compat_glGetActiveUniform(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveAttrib.xml +func (gl *GL) GetActiveAttrib(program glbase.Program, index glbase.Attrib, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl4_2compat_glGetActiveAttrib(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEnableVertexAttribArray.xml +func (gl *GL) EnableVertexAttribArray(index glbase.Attrib) { + C.gl4_2compat_glEnableVertexAttribArray(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDisableVertexAttribArray.xml +func (gl *GL) DisableVertexAttribArray(index glbase.Attrib) { + C.gl4_2compat_glDisableVertexAttribArray(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDetachShader.xml +func (gl *GL) DetachShader(program glbase.Program, shader glbase.Shader) { + C.gl4_2compat_glDetachShader(gl.funcs, C.GLuint(program), C.GLuint(shader)) +} + +// DeleteShader frees the memory and invalidates the name associated with +// the shader object specified by shader. This command effectively undoes the +// effects of a call to CreateShader. +// +// If a shader object to be deleted is attached to a program object, it will +// be flagged for deletion, but it will not be deleted until it is no longer +// attached to any program object, for any rendering context (it must +// be detached from wherever it was attached before it will be deleted). A +// value of 0 for shader will be silently ignored. +// +// To determine whether an object has been flagged for deletion, call +// GetShader with arguments shader and GL.DELETE_STATUS. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. +// +// DeleteShader is available in GL version 2.0 or greater. +func (gl *GL) DeleteShader(shader glbase.Shader) { + C.gl4_2compat_glDeleteShader(gl.funcs, C.GLuint(shader)) +} + +// DeleteProgram frees the memory and invalidates the name associated with +// the program object specified by program. This command effectively undoes +// the effects of a call to CreateProgram. +// +// If a program object is in use as part of current rendering state, it will +// be flagged for deletion, but it will not be deleted until it is no longer +// part of current state for any rendering context. If a program object to be +// deleted has shader objects attached to it, those shader objects will be +// automatically detached but not deleted unless they have already been +// flagged for deletion by a previous call to DeleteShader. A value of 0 +// for program will be silently ignored. +// +// To determine whether a program object has been flagged for deletion, call +// GetProgram with arguments program and GL.DELETE_STATUS. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. +// +// DeleteProgram is available in GL version 2.0 or greater. +func (gl *GL) DeleteProgram(program glbase.Program) { + C.gl4_2compat_glDeleteProgram(gl.funcs, C.GLuint(program)) +} + +// CreateShader creates an empty shader object and returns a non-zero value +// by which it can be referenced. A shader object is used to maintain the +// source code strings that define a shader. shaderType indicates the type of +// shader to be created. +// +// Two types of shaders are supported. A shader of type GL.VERTEX_SHADER is a +// shader that is intended to run on the programmable vertex processor and +// replace the fixed functionality vertex processing in OpenGL. A shader of +// type GL.FRAGMENT_SHADER is a shader that is intended to run on the +// programmable fragment processor and replace the fixed functionality +// fragment processing in OpenGL. +// +// When created, a shader object's GL.SHADER_TYPE parameter is set to either +// GL.VERTEX_SHADER or GL.FRAGMENT_SHADER, depending on the value of +// shaderType. +// +// Like display lists and texture objects, the name space for shader objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// This function returns 0 if an error occurs creating the shader object. +// +// Error GL.INVALID_ENUM is generated if shaderType is not an accepted value. +// GL.INVALID_OPERATION is generated if CreateShader is executed between the +// execution of Begin and the corresponding execution of End. +// +// CreateShader is available in GL version 2.0 or greater. +func (gl *GL) CreateShader(gltype glbase.Enum) glbase.Shader { + glresult := C.gl4_2compat_glCreateShader(gl.funcs, C.GLenum(gltype)) + return glbase.Shader(glresult) +} + +// CreateProgram creates an empty program object and returns a non-zero +// value by which it can be referenced. A program object is an object to +// which shader objects can be attached. This provides a mechanism to specify +// the shader objects that will be linked to create a program. It also +// provides a means for checking the compatibility of the shaders that will +// be used to create a program (for instance, checking the compatibility +// between a vertex shader and a fragment shader). When no longer needed as +// part of a program object, shader objects can be detached. +// +// One or more executables are created in a program object by successfully +// attaching shader objects to it with AttachShader, successfully compiling +// the shader objects with CompileShader, and successfully linking the +// program object with LinkProgram. These executables are made part of +// current state when UseProgram is called. Program objects can be deleted +// by calling DeleteProgram. The memory associated with the program object +// will be deleted when it is no longer part of current rendering state for +// any context. +// +// Like display lists and texture objects, the name space for program objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// Applications are responsible for providing the synchronization across API +// calls when objects are accessed from different execution threads. +// +// This function returns 0 if an error occurs creating the program object. +// +// Error GL.INVALID_OPERATION is generated if CreateProgram is executed +// between the execution of Begin and the corresponding execution of End. +// +// CreateProgram is available in GL version 2.0 or greater. +func (gl *GL) CreateProgram() glbase.Program { + glresult := C.gl4_2compat_glCreateProgram(gl.funcs) + return glbase.Program(glresult) +} + +// CompileShader compiles the source code strings that have been stored in +// the shader object specified by shader. +// +// The compilation status will be stored as part of the shader object's +// state. This value will be set to GL.TRUE if the shader was compiled without +// errors and is ready for use, and GL.FALSE otherwise. It can be queried by +// calling GetShaderiv with arguments shader and GL.COMPILE_STATUS. +// +// Compilation of a shader can fail for a number of reasons as specified by +// the OpenGL Shading Language Specification. Whether or not the compilation +// was successful, information about the compilation can be obtained from the +// shader object's information log by calling GetShaderInfoLog. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_OPERATION is generated if CompileShader is executed +// between the execution of Begin and the corresponding execution of End. +// +// CompileShader is available in GL version 2.0 or greater. +func (gl *GL) CompileShader(shader glbase.Shader) { + C.gl4_2compat_glCompileShader(gl.funcs, C.GLuint(shader)) +} + +// BindAttribLocation associates a user-defined attribute variable in the program +// object specified by program with a generic vertex attribute index. The name +// parameter specifies the name of the vertex shader attribute variable to +// which index is to be bound. When program is made part of the current state, +// values provided via the generic vertex attribute index will modify the +// value of the user-defined attribute variable specified by name. +// +// If name refers to a matrix attribute variable, index refers to the first +// column of the matrix. Other matrix columns are then automatically bound to +// locations index+1 for a matrix of type mat2; index+1 and index+2 for a +// matrix of type mat3; and index+1, index+2, and index+3 for a matrix of +// type mat4. +// +// This command makes it possible for vertex shaders to use descriptive names +// for attribute variables rather than generic variables that are numbered +// from 0 to GL.MAX_VERTEX_ATTRIBS-1. The values sent to each generic +// attribute index are part of current state, just like standard vertex +// attributes such as color, normal, and vertex position. If a different +// program object is made current by calling UseProgram, the generic vertex +// attributes are tracked in such a way that the same values will be observed +// by attributes in the new program object that are also bound to index. +// +// Attribute variable name-to-generic attribute index bindings for a program +// object can be explicitly assigned at any time by calling +// BindAttribLocation. Attribute bindings do not go into effect until +// LinkProgram is called. After a program object has been linked +// successfully, the index values for generic attributes remain fixed (and +// their values can be queried) until the next link command occurs. +// +// Applications are not allowed to bind any of the standard OpenGL vertex +// attributes using this command, as they are bound automatically when +// needed. Any attribute binding that occurs after the program object has +// been linked will not take effect until the next time the program object is +// linked. +// +// If name was bound previously, that information is lost. Thus you cannot +// bind one user-defined attribute variable to multiple indices, but you can +// bind multiple user-defined attribute variables to the same index. +// +// Applications are allowed to bind more than one user-defined attribute +// variable to the same generic vertex attribute index. This is called +// aliasing, and it is allowed only if just one of the aliased attributes is +// active in the executable program, or if no path through the shader +// consumes more than one attribute of a set of attributes aliased to the +// same location. The compiler and linker are allowed to assume that no +// aliasing is done and are free to employ optimizations that work only in +// the absence of aliasing. OpenGL implementations are not required to do +// error checking to detect aliasing. Because there is no way to bind +// standard attributes, it is not possible to alias generic attributes with +// conventional ones (except for generic attribute 0). +// +// BindAttribLocation can be called before any vertex shader objects are +// bound to the specified program object. It is also permissible to bind a +// generic attribute index to an attribute variable name that is never used +// in a vertex shader. +// +// Active attributes that are not explicitly bound will be bound by the +// linker when LinkProgram is called. The locations assigned can be queried +// by calling GetAttribLocation. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. +// GL.INVALID_OPERATION is generated if name starts with the reserved prefix "gl_". +// GL.INVALID_VALUE is generated if program is not a value generated by OpenGL. +// GL.INVALID_OPERATION is generated if program is not a program object. +// GL.INVALID_OPERATION is generated if BindAttribLocation is executed +// between the execution of Begin and the corresponding execution of End. +// +// BindAttribLocation is available in GL version 2.0 or greater. +func (gl *GL) BindAttribLocation(program glbase.Program, index glbase.Attrib, name string) { + name_cstr := C.CString(name) + C.gl4_2compat_glBindAttribLocation(gl.funcs, C.GLuint(program), C.GLuint(index), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) +} + +// AttachShader attaches a shader object to a program object. +// +// In order to create an executable, there must be a way to specify the list +// of things that will be linked together. Program objects provide this +// mechanism. Shaders that are to be linked together in a program object must +// first be attached to that program object. This indicates that shader will +// be included in link operations that will be performed on program. +// +// All operations that can be performed on a shader object are valid whether +// or not the shader object is attached to a program object. It is +// permissible to attach a shader object to a program object before source +// code has been loaded into the shader object or before the shader object +// has been compiled. It is permissible to attach multiple shader objects of +// the same type because each may contain a portion of the complete shader. +// It is also permissible to attach a shader object to more than one program +// object. If a shader object is deleted while it is attached to a program +// object, it will be flagged for deletion, and deletion will not occur until +// DetachShader is called to detach it from all program objects to which it +// is attached. +// +// Error GL.INVALID_VALUE is generated if either program or shader is not a +// value generated by OpenGL. GL.INVALID_OPERATION is generated if program +// is not a program object. GL.INVALID_OPERATION is generated if shader is +// not a shader object. GL.INVALID_OPERATION is generated if shader is +// already attached to program. GL.INVALID_OPERATION is generated if +// AttachShader is executed between the execution of Begin and the +// corresponding execution of End. +// +// AttachShader is available in GL version 2.0 or greater. +func (gl *GL) AttachShader(program glbase.Program, shader glbase.Shader) { + C.gl4_2compat_glAttachShader(gl.funcs, C.GLuint(program), C.GLuint(shader)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilMaskSeparate.xml +func (gl *GL) StencilMaskSeparate(face glbase.Enum, mask uint32) { + C.gl4_2compat_glStencilMaskSeparate(gl.funcs, C.GLenum(face), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilFuncSeparate.xml +func (gl *GL) StencilFuncSeparate(face, glfunc glbase.Enum, ref int32, mask uint32) { + C.gl4_2compat_glStencilFuncSeparate(gl.funcs, C.GLenum(face), C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilOpSeparate.xml +func (gl *GL) StencilOpSeparate(face, sfail, dpfail, dppass glbase.Enum) { + C.gl4_2compat_glStencilOpSeparate(gl.funcs, C.GLenum(face), C.GLenum(sfail), C.GLenum(dpfail), C.GLenum(dppass)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawBuffers.xml +func (gl *GL) DrawBuffers(n int, bufs []glbase.Enum) { + C.gl4_2compat_glDrawBuffers(gl.funcs, C.GLsizei(n), (*C.GLenum)(unsafe.Pointer(&bufs[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendEquationSeparate.xml +func (gl *GL) BlendEquationSeparate(modeRGB, modeAlpha glbase.Enum) { + C.gl4_2compat_glBlendEquationSeparate(gl.funcs, C.GLenum(modeRGB), C.GLenum(modeAlpha)) +} + +// UniformMatrix4x3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4x3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4x3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*3) != 0 { + panic("invalid value length for UniformMatrix4x3fv") + } + count := len(value) / (4 * 3) + C.gl4_2compat_glUniformMatrix4x3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3x4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3x4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3x4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*4) != 0 { + panic("invalid value length for UniformMatrix3x4fv") + } + count := len(value) / (3 * 4) + C.gl4_2compat_glUniformMatrix3x4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix4x2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4x2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4x2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*2) != 0 { + panic("invalid value length for UniformMatrix4x2fv") + } + count := len(value) / (4 * 2) + C.gl4_2compat_glUniformMatrix4x2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2x4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2x4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2x4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*4) != 0 { + panic("invalid value length for UniformMatrix2x4fv") + } + count := len(value) / (2 * 4) + C.gl4_2compat_glUniformMatrix2x4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3x2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3x2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3x2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*2) != 0 { + panic("invalid value length for UniformMatrix3x2fv") + } + count := len(value) / (3 * 2) + C.gl4_2compat_glUniformMatrix3x2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2x3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2x3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2x3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*3) != 0 { + panic("invalid value length for UniformMatrix2x3fv") + } + count := len(value) / (2 * 3) + C.gl4_2compat_glUniformMatrix2x3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsVertexArray.xml +func (gl *GL) IsVertexArray(array uint32) bool { + glresult := C.gl4_2compat_glIsVertexArray(gl.funcs, C.GLuint(array)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenVertexArrays.xml +func (gl *GL) GenVertexArrays(n int, arrays []uint32) { + C.gl4_2compat_glGenVertexArrays(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&arrays[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteVertexArrays.xml +func (gl *GL) DeleteVertexArrays(n int, arrays []uint32) { + C.gl4_2compat_glDeleteVertexArrays(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&arrays[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindVertexArray.xml +func (gl *GL) BindVertexArray(array uint32) { + C.gl4_2compat_glBindVertexArray(gl.funcs, C.GLuint(array)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFlushMappedBufferRange.xml +func (gl *GL) FlushMappedBufferRange(target glbase.Enum, offset, length int) { + C.gl4_2compat_glFlushMappedBufferRange(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(length)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTextureLayer.xml +func (gl *GL) FramebufferTextureLayer(target, attachment glbase.Enum, texture glbase.Texture, level int, layer int32) { + C.gl4_2compat_glFramebufferTextureLayer(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLuint(texture), C.GLint(level), C.GLint(layer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRenderbufferStorageMultisample.xml +func (gl *GL) RenderbufferStorageMultisample(target glbase.Enum, samples int32, internalFormat glbase.Enum, width, height int) { + C.gl4_2compat_glRenderbufferStorageMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlitFramebuffer.xml +func (gl *GL) BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1 int32, mask glbase.Bitfield, filter glbase.Enum) { + C.gl4_2compat_glBlitFramebuffer(gl.funcs, C.GLint(srcX0), C.GLint(srcY0), C.GLint(srcX1), C.GLint(srcY1), C.GLint(dstX0), C.GLint(dstY0), C.GLint(dstX1), C.GLint(dstY1), C.GLbitfield(mask), C.GLenum(filter)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenerateMipmap.xml +func (gl *GL) GenerateMipmap(target glbase.Enum) { + C.gl4_2compat_glGenerateMipmap(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFramebufferAttachmentParameteriv.xml +func (gl *GL) GetFramebufferAttachmentParameteriv(target, attachment, pname glbase.Enum, params []int32) { + C.gl4_2compat_glGetFramebufferAttachmentParameteriv(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferRenderbuffer.xml +func (gl *GL) FramebufferRenderbuffer(target, attachment, renderbuffertarget glbase.Enum, renderbuffer glbase.Renderbuffer) { + C.gl4_2compat_glFramebufferRenderbuffer(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(renderbuffertarget), C.GLuint(renderbuffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture3D.xml +func (gl *GL) FramebufferTexture3D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int, zoffset int32) { + C.gl4_2compat_glFramebufferTexture3D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level), C.GLint(zoffset)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture2D.xml +func (gl *GL) FramebufferTexture2D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int) { + C.gl4_2compat_glFramebufferTexture2D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture1D.xml +func (gl *GL) FramebufferTexture1D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int) { + C.gl4_2compat_glFramebufferTexture1D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCheckFramebufferStatus.xml +func (gl *GL) CheckFramebufferStatus(target glbase.Enum) glbase.Enum { + glresult := C.gl4_2compat_glCheckFramebufferStatus(gl.funcs, C.GLenum(target)) + return glbase.Enum(glresult) +} + +// GenFramebuffers returns n framebuffer object names in ids. There is no +// guarantee that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenFramebuffers. +// +// Framebuffer object names returned by a call to GenFramebuffers are not +// returned by subsequent calls, unless they are first deleted with +// DeleteFramebuffers. +// +// The names returned in ids are marked as used, for the purposes of +// GenFramebuffers only, but they acquire state and type only when they are +// first bound. +// +// Error GL.INVALID_VALUE is generated if n is negative. +func (gl *GL) GenFramebuffers(n int) []glbase.Framebuffer { + if n == 0 { + return nil + } + framebuffers := make([]glbase.Framebuffer, n) + C.gl4_2compat_glGenFramebuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&framebuffers[0]))) + return framebuffers +} + +// DeleteFramebuffers deletes the framebuffer objects whose names are +// stored in the framebuffers slice. The name zero is reserved by the GL and +// is silently ignored, should it occur in framebuffers, as are other unused +// names. Once a framebuffer object is deleted, its name is again unused and +// it has no attachments. If a framebuffer that is currently bound to one or +// more of the targets GL.DRAW_FRAMEBUFFER or GL.READ_FRAMEBUFFER is deleted, +// it is as though BindFramebuffer had been executed with the corresponding +// target and framebuffer zero. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteFramebuffers is available in GL version 3.0 or greater. +func (gl *GL) DeleteFramebuffers(framebuffers []glbase.Framebuffer) { + n := len(framebuffers) + if n == 0 { + return + } + C.gl4_2compat_glDeleteFramebuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&framebuffers[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindFramebuffer.xml +func (gl *GL) BindFramebuffer(target glbase.Enum, framebuffer glbase.Framebuffer) { + C.gl4_2compat_glBindFramebuffer(gl.funcs, C.GLenum(target), C.GLuint(framebuffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsFramebuffer.xml +func (gl *GL) IsFramebuffer(framebuffer glbase.Framebuffer) bool { + glresult := C.gl4_2compat_glIsFramebuffer(gl.funcs, C.GLuint(framebuffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetRenderbufferParameteriv.xml +func (gl *GL) GetRenderbufferParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_2compat_glGetRenderbufferParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRenderbufferStorage.xml +func (gl *GL) RenderbufferStorage(target, internalFormat glbase.Enum, width, height int) { + C.gl4_2compat_glRenderbufferStorage(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) +} + +// GenRenderbuffers returns n renderbuffer object names in renderbuffers. +// There is no guarantee that the names form a contiguous set of integers; +// however, it is guaranteed that none of the returned names was in use +// immediately before the call to GenRenderbuffers. +// +// Renderbuffer object names returned by a call to GenRenderbuffers are not +// returned by subsequent calls, unless they are first deleted with +// DeleteRenderbuffers. +// +// The names returned in renderbuffers are marked as used, for the purposes +// of GenRenderbuffers only, but they acquire state and type only when they +// are first bound. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenRenderbuffers is available in GL version 3.0 or greater. +func (gl *GL) GenRenderbuffers(n int) []glbase.Renderbuffer { + if n == 0 { + return nil + } + renderbuffers := make([]glbase.Renderbuffer, n) + C.gl4_2compat_glGenRenderbuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&renderbuffers[0]))) + return renderbuffers +} + +// DeleteRenderbuffers deletes the renderbuffer objects whose names are stored +// in the renderbuffers slice. The name zero is reserved by the GL and +// is silently ignored, should it occur in renderbuffers, as are other unused +// names. Once a renderbuffer object is deleted, its name is again unused and +// it has no contents. If a renderbuffer that is currently bound to the +// target GL.RENDERBUFFER is deleted, it is as though BindRenderbuffer had +// been executed with a target of GL.RENDERBUFFER and a name of zero. +// +// If a renderbuffer object is attached to one or more attachment points in +// the currently bound framebuffer, then it as if FramebufferRenderbuffer +// had been called, with a renderbuffer of zero for each attachment point to +// which this image was attached in the currently bound framebuffer. In other +// words, this renderbuffer object is first detached from all attachment +// ponits in the currently bound framebuffer. Note that the renderbuffer +// image is specifically not detached from any non-bound framebuffers. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteRenderbuffers is available in GL version 3.0 or greater. +func (gl *GL) DeleteRenderbuffers(renderbuffers []glbase.Renderbuffer) { + n := len(renderbuffers) + if n == 0 { + return + } + C.gl4_2compat_glDeleteRenderbuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&renderbuffers[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindRenderbuffer.xml +func (gl *GL) BindRenderbuffer(target glbase.Enum, renderbuffer glbase.Renderbuffer) { + C.gl4_2compat_glBindRenderbuffer(gl.funcs, C.GLenum(target), C.GLuint(renderbuffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsRenderbuffer.xml +func (gl *GL) IsRenderbuffer(renderbuffer glbase.Renderbuffer) bool { + glresult := C.gl4_2compat_glIsRenderbuffer(gl.funcs, C.GLuint(renderbuffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferfi.xml +func (gl *GL) ClearBufferfi(buffer glbase.Enum, drawbuffer int32, depth float32, stencil int32) { + C.gl4_2compat_glClearBufferfi(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), C.GLfloat(depth), C.GLint(stencil)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferfv.xml +func (gl *GL) ClearBufferfv(buffer glbase.Enum, drawbuffer int32, value []float32) { + C.gl4_2compat_glClearBufferfv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferuiv.xml +func (gl *GL) ClearBufferuiv(buffer glbase.Enum, drawbuffer int32, value []uint32) { + C.gl4_2compat_glClearBufferuiv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferiv.xml +func (gl *GL) ClearBufferiv(buffer glbase.Enum, drawbuffer int32, value []int32) { + C.gl4_2compat_glClearBufferiv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameterIuiv.xml +func (gl *GL) GetTexParameterIuiv(target, pname glbase.Enum, params []uint32) { + C.gl4_2compat_glGetTexParameterIuiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameterIiv.xml +func (gl *GL) GetTexParameterIiv(target, pname glbase.Enum, params []int32) { + C.gl4_2compat_glGetTexParameterIiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterIuiv.xml +func (gl *GL) TexParameterIuiv(target, pname glbase.Enum, params []uint32) { + C.gl4_2compat_glTexParameterIuiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterIiv.xml +func (gl *GL) TexParameterIiv(target, pname glbase.Enum, params []int32) { + C.gl4_2compat_glTexParameterIiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// Uniform4uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4uiv") + } + count := len(value) / 4 + C.gl4_2compat_glUniform4uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform3uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3uiv") + } + count := len(value) / 3 + C.gl4_2compat_glUniform3uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform2uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2uiv") + } + count := len(value) / 2 + C.gl4_2compat_glUniform2uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform1uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl4_2compat_glUniform1uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform4ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4ui(location glbase.Uniform, v0, v1, v2, v3 uint32) { + C.gl4_2compat_glUniform4ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2), C.GLuint(v3)) +} + +// Uniform3ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3ui(location glbase.Uniform, v0, v1, v2 uint32) { + C.gl4_2compat_glUniform3ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2)) +} + +// Uniform2ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2ui(location glbase.Uniform, v0, v1 uint32) { + C.gl4_2compat_glUniform2ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1)) +} + +// Uniform1ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1ui(location glbase.Uniform, v0 uint32) { + C.gl4_2compat_glUniform1ui(gl.funcs, C.GLint(location), C.GLuint(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFragDataLocation.xml +func (gl *GL) GetFragDataLocation(program glbase.Program, name []byte) int32 { + glresult := C.gl4_2compat_glGetFragDataLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindFragDataLocation.xml +func (gl *GL) BindFragDataLocation(program glbase.Program, color uint32, name []byte) { + C.gl4_2compat_glBindFragDataLocation(gl.funcs, C.GLuint(program), C.GLuint(color), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetUniformuiv.xml +func (gl *GL) GetUniformuiv(program glbase.Program, location glbase.Uniform, params []uint32) { + C.gl4_2compat_glGetUniformuiv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetVertexAttribIuiv.xml +func (gl *GL) GetVertexAttribIuiv(index glbase.Attrib, pname glbase.Enum, params []uint32) { + C.gl4_2compat_glGetVertexAttribIuiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetVertexAttribIiv.xml +func (gl *GL) GetVertexAttribIiv(index glbase.Attrib, pname glbase.Enum, params []int32) { + C.gl4_2compat_glGetVertexAttribIiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribIPointer.xml +func (gl *GL) VertexAttribIPointer(index glbase.Attrib, size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glVertexAttribIPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndConditionalRender.xml +func (gl *GL) EndConditionalRender() { + C.gl4_2compat_glEndConditionalRender(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBeginConditionalRender.xml +func (gl *GL) BeginConditionalRender(id uint32, mode glbase.Enum) { + C.gl4_2compat_glBeginConditionalRender(gl.funcs, C.GLuint(id), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClampColor.xml +func (gl *GL) ClampColor(target, clamp glbase.Enum) { + C.gl4_2compat_glClampColor(gl.funcs, C.GLenum(target), C.GLenum(clamp)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTransformFeedbackVarying.xml +func (gl *GL) GetTransformFeedbackVarying(program glbase.Program, index uint32, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl4_2compat_glGetTransformFeedbackVarying(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLsizei)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindBufferBase.xml +func (gl *GL) BindBufferBase(target glbase.Enum, index uint32, buffer glbase.Buffer) { + C.gl4_2compat_glBindBufferBase(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindBufferRange.xml +func (gl *GL) BindBufferRange(target glbase.Enum, index uint32, buffer glbase.Buffer, offset, size int) { + C.gl4_2compat_glBindBufferRange(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(buffer), C.GLintptr(offset), C.GLsizeiptr(size)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndTransformFeedback.xml +func (gl *GL) EndTransformFeedback() { + C.gl4_2compat_glEndTransformFeedback(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBeginTransformFeedback.xml +func (gl *GL) BeginTransformFeedback(primitiveMode glbase.Enum) { + C.gl4_2compat_glBeginTransformFeedback(gl.funcs, C.GLenum(primitiveMode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsEnabledi.xml +func (gl *GL) IsEnabledi(target glbase.Enum, index uint32) bool { + glresult := C.gl4_2compat_glIsEnabledi(gl.funcs, C.GLenum(target), C.GLuint(index)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDisablei.xml +func (gl *GL) Disablei(target glbase.Enum, index uint32) { + C.gl4_2compat_glDisablei(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEnablei.xml +func (gl *GL) Enablei(target glbase.Enum, index uint32) { + C.gl4_2compat_glEnablei(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetIntegeri_v.xml +func (gl *GL) GetIntegeri_v(target glbase.Enum, index uint32, data []int32) { + C.gl4_2compat_glGetIntegeri_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLint)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBooleani_v.xml +func (gl *GL) GetBooleani_v(target glbase.Enum, index uint32, data []bool) { + C.gl4_2compat_glGetBooleani_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLboolean)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorMaski.xml +func (gl *GL) ColorMaski(index uint32, r, g, b, a bool) { + C.gl4_2compat_glColorMaski(gl.funcs, C.GLuint(index), *(*C.GLboolean)(unsafe.Pointer(&r)), *(*C.GLboolean)(unsafe.Pointer(&g)), *(*C.GLboolean)(unsafe.Pointer(&b)), *(*C.GLboolean)(unsafe.Pointer(&a))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyBufferSubData.xml +func (gl *GL) CopyBufferSubData(readTarget, writeTarget glbase.Enum, readOffset, writeOffset, size int) { + C.gl4_2compat_glCopyBufferSubData(gl.funcs, C.GLenum(readTarget), C.GLenum(writeTarget), C.GLintptr(readOffset), C.GLintptr(writeOffset), C.GLsizeiptr(size)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformBlockBinding.xml +func (gl *GL) UniformBlockBinding(program glbase.Program, v0, v1 uint32) { + C.gl4_2compat_glUniformBlockBinding(gl.funcs, C.GLuint(program), C.GLuint(v0), C.GLuint(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformBlockName.xml +func (gl *GL) GetActiveUniformBlockName(program glbase.Program, uniformBlockIndex uint32, bufSize int32, length []int32, uniformBlockName []byte) { + C.gl4_2compat_glGetActiveUniformBlockName(gl.funcs, C.GLuint(program), C.GLuint(uniformBlockIndex), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&uniformBlockName[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformBlockiv.xml +func (gl *GL) GetActiveUniformBlockiv(program glbase.Program, uniformBlockIndex uint32, pname glbase.Enum, params []int32) { + C.gl4_2compat_glGetActiveUniformBlockiv(gl.funcs, C.GLuint(program), C.GLuint(uniformBlockIndex), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetUniformBlockIndex.xml +func (gl *GL) GetUniformBlockIndex(program glbase.Program, uniformBlockName []byte) uint32 { + glresult := C.gl4_2compat_glGetUniformBlockIndex(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&uniformBlockName[0]))) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformName.xml +func (gl *GL) GetActiveUniformName(program glbase.Program, uniformIndex uint32, bufSize int32, length []int32, uniformName []byte) { + C.gl4_2compat_glGetActiveUniformName(gl.funcs, C.GLuint(program), C.GLuint(uniformIndex), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&uniformName[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformsiv.xml +func (gl *GL) GetActiveUniformsiv(program glbase.Program, uniformCount int32, uniformIndices []uint32, pname glbase.Enum, params []int32) { + C.gl4_2compat_glGetActiveUniformsiv(gl.funcs, C.GLuint(program), C.GLsizei(uniformCount), (*C.GLuint)(unsafe.Pointer(&uniformIndices[0])), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPrimitiveRestartIndex.xml +func (gl *GL) PrimitiveRestartIndex(index uint32) { + C.gl4_2compat_glPrimitiveRestartIndex(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexBuffer.xml +func (gl *GL) TexBuffer(target, internalFormat glbase.Enum, buffer glbase.Buffer) { + C.gl4_2compat_glTexBuffer(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsInstanced.xml +func (gl *GL) DrawElementsInstanced(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, instancecount int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glDrawElementsInstanced(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLsizei(instancecount)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawArraysInstanced.xml +func (gl *GL) DrawArraysInstanced(mode glbase.Enum, first, count int, instancecount int32) { + C.gl4_2compat_glDrawArraysInstanced(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count), C.GLsizei(instancecount)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSampleMaski.xml +func (gl *GL) SampleMaski(index uint32, mask glbase.Bitfield) { + C.gl4_2compat_glSampleMaski(gl.funcs, C.GLuint(index), C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMultisamplefv.xml +func (gl *GL) GetMultisamplefv(pname glbase.Enum, index uint32, val []float32) { + C.gl4_2compat_glGetMultisamplefv(gl.funcs, C.GLenum(pname), C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&val[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage3DMultisample.xml +func (gl *GL) TexImage3DMultisample(target glbase.Enum, samples, internalFormat int32, width, height int, depth int32, fixedsamplelocations bool) { + C.gl4_2compat_glTexImage3DMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), *(*C.GLboolean)(unsafe.Pointer(&fixedsamplelocations))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage2DMultisample.xml +func (gl *GL) TexImage2DMultisample(target glbase.Enum, samples, internalFormat int32, width, height int, fixedsamplelocations bool) { + C.gl4_2compat_glTexImage2DMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), *(*C.GLboolean)(unsafe.Pointer(&fixedsamplelocations))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSynciv.xml +func (gl *GL) GetSynciv(sync glbase.Sync, pname glbase.Enum, bufSize int32, length, values []int32) { + C.gl4_2compat_glGetSynciv(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLenum(pname), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetInteger64v.xml +func (gl *GL) GetInteger64v(pname glbase.Enum, params []int64) { + C.gl4_2compat_glGetInteger64v(gl.funcs, C.GLenum(pname), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWaitSync.xml +func (gl *GL) WaitSync(sync glbase.Sync, flags glbase.Bitfield, timeout uint64) { + C.gl4_2compat_glWaitSync(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLbitfield(flags), C.GLuint64(timeout)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClientWaitSync.xml +func (gl *GL) ClientWaitSync(sync glbase.Sync, flags glbase.Bitfield, timeout uint64) glbase.Enum { + glresult := C.gl4_2compat_glClientWaitSync(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLbitfield(flags), C.GLuint64(timeout)) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteSync.xml +func (gl *GL) DeleteSync(sync glbase.Sync) { + C.gl4_2compat_glDeleteSync(gl.funcs, C.GLsync(unsafe.Pointer(sync))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsSync.xml +func (gl *GL) IsSync(sync glbase.Sync) bool { + glresult := C.gl4_2compat_glIsSync(gl.funcs, C.GLsync(unsafe.Pointer(sync))) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFenceSync.xml +func (gl *GL) FenceSync(condition glbase.Enum, flags glbase.Bitfield) glbase.Sync { + glresult := C.gl4_2compat_glFenceSync(gl.funcs, C.GLenum(condition), C.GLbitfield(flags)) + return glbase.Sync(unsafe.Pointer(glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProvokingVertex.xml +func (gl *GL) ProvokingVertex(mode glbase.Enum) { + C.gl4_2compat_glProvokingVertex(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsInstancedBaseVertex.xml +func (gl *GL) DrawElementsInstancedBaseVertex(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, instancecount, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glDrawElementsInstancedBaseVertex(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLsizei(instancecount), C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawRangeElementsBaseVertex.xml +func (gl *GL) DrawRangeElementsBaseVertex(mode glbase.Enum, start, end uint32, count int, gltype glbase.Enum, indices interface{}, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glDrawRangeElementsBaseVertex(gl.funcs, C.GLenum(mode), C.GLuint(start), C.GLuint(end), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsBaseVertex.xml +func (gl *GL) DrawElementsBaseVertex(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glDrawElementsBaseVertex(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture.xml +func (gl *GL) FramebufferTexture(target, attachment glbase.Enum, texture glbase.Texture, level int) { + C.gl4_2compat_glFramebufferTexture(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBufferParameteri64v.xml +func (gl *GL) GetBufferParameteri64v(target, pname glbase.Enum, params []int64) { + C.gl4_2compat_glGetBufferParameteri64v(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetInteger64i_v.xml +func (gl *GL) GetInteger64i_v(target glbase.Enum, index uint32, data []int64) { + C.gl4_2compat_glGetInteger64i_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLint64)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP4uiv.xml +func (gl *GL) VertexAttribP4uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl4_2compat_glVertexAttribP4uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP4ui.xml +func (gl *GL) VertexAttribP4ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl4_2compat_glVertexAttribP4ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP3uiv.xml +func (gl *GL) VertexAttribP3uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl4_2compat_glVertexAttribP3uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP3ui.xml +func (gl *GL) VertexAttribP3ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl4_2compat_glVertexAttribP3ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP2uiv.xml +func (gl *GL) VertexAttribP2uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl4_2compat_glVertexAttribP2uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP2ui.xml +func (gl *GL) VertexAttribP2ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl4_2compat_glVertexAttribP2ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP1uiv.xml +func (gl *GL) VertexAttribP1uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl4_2compat_glVertexAttribP1uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP1ui.xml +func (gl *GL) VertexAttribP1ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl4_2compat_glVertexAttribP1ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColorP3uiv.xml +func (gl *GL) SecondaryColorP3uiv(gltype glbase.Enum, color []uint32) { + C.gl4_2compat_glSecondaryColorP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&color[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColorP3ui.xml +func (gl *GL) SecondaryColorP3ui(gltype glbase.Enum, color uint32) { + C.gl4_2compat_glSecondaryColorP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(color)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorP4uiv.xml +func (gl *GL) ColorP4uiv(gltype glbase.Enum, color []uint32) { + C.gl4_2compat_glColorP4uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&color[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorP4ui.xml +func (gl *GL) ColorP4ui(gltype glbase.Enum, color uint32) { + C.gl4_2compat_glColorP4ui(gl.funcs, C.GLenum(gltype), C.GLuint(color)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorP3uiv.xml +func (gl *GL) ColorP3uiv(gltype glbase.Enum, color []uint32) { + C.gl4_2compat_glColorP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&color[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorP3ui.xml +func (gl *GL) ColorP3ui(gltype glbase.Enum, color uint32) { + C.gl4_2compat_glColorP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(color)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormalP3uiv.xml +func (gl *GL) NormalP3uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_2compat_glNormalP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormalP3ui.xml +func (gl *GL) NormalP3ui(gltype glbase.Enum, coords uint32) { + C.gl4_2compat_glNormalP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP4uiv.xml +func (gl *GL) MultiTexCoordP4uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl4_2compat_glMultiTexCoordP4uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP4ui.xml +func (gl *GL) MultiTexCoordP4ui(texture, gltype glbase.Enum, coords uint32) { + C.gl4_2compat_glMultiTexCoordP4ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP3uiv.xml +func (gl *GL) MultiTexCoordP3uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl4_2compat_glMultiTexCoordP3uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP3ui.xml +func (gl *GL) MultiTexCoordP3ui(texture, gltype glbase.Enum, coords uint32) { + C.gl4_2compat_glMultiTexCoordP3ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP2uiv.xml +func (gl *GL) MultiTexCoordP2uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl4_2compat_glMultiTexCoordP2uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP2ui.xml +func (gl *GL) MultiTexCoordP2ui(texture, gltype glbase.Enum, coords uint32) { + C.gl4_2compat_glMultiTexCoordP2ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP1uiv.xml +func (gl *GL) MultiTexCoordP1uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl4_2compat_glMultiTexCoordP1uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP1ui.xml +func (gl *GL) MultiTexCoordP1ui(texture, gltype glbase.Enum, coords uint32) { + C.gl4_2compat_glMultiTexCoordP1ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP4uiv.xml +func (gl *GL) TexCoordP4uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_2compat_glTexCoordP4uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP4ui.xml +func (gl *GL) TexCoordP4ui(gltype glbase.Enum, coords uint32) { + C.gl4_2compat_glTexCoordP4ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP3uiv.xml +func (gl *GL) TexCoordP3uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_2compat_glTexCoordP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP3ui.xml +func (gl *GL) TexCoordP3ui(gltype glbase.Enum, coords uint32) { + C.gl4_2compat_glTexCoordP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP2uiv.xml +func (gl *GL) TexCoordP2uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_2compat_glTexCoordP2uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP2ui.xml +func (gl *GL) TexCoordP2ui(gltype glbase.Enum, coords uint32) { + C.gl4_2compat_glTexCoordP2ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP1uiv.xml +func (gl *GL) TexCoordP1uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_2compat_glTexCoordP1uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP1ui.xml +func (gl *GL) TexCoordP1ui(gltype glbase.Enum, coords uint32) { + C.gl4_2compat_glTexCoordP1ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP4uiv.xml +func (gl *GL) VertexP4uiv(gltype glbase.Enum, value []uint32) { + C.gl4_2compat_glVertexP4uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP4ui.xml +func (gl *GL) VertexP4ui(gltype glbase.Enum, value uint32) { + C.gl4_2compat_glVertexP4ui(gl.funcs, C.GLenum(gltype), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP3uiv.xml +func (gl *GL) VertexP3uiv(gltype glbase.Enum, value []uint32) { + C.gl4_2compat_glVertexP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP3ui.xml +func (gl *GL) VertexP3ui(gltype glbase.Enum, value uint32) { + C.gl4_2compat_glVertexP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP2uiv.xml +func (gl *GL) VertexP2uiv(gltype glbase.Enum, value []uint32) { + C.gl4_2compat_glVertexP2uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP2ui.xml +func (gl *GL) VertexP2ui(gltype glbase.Enum, value uint32) { + C.gl4_2compat_glVertexP2ui(gl.funcs, C.GLenum(gltype), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryObjectui64v.xml +func (gl *GL) GetQueryObjectui64v(id uint32, pname glbase.Enum, params []uint64) { + C.gl4_2compat_glGetQueryObjectui64v(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLuint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryObjecti64v.xml +func (gl *GL) GetQueryObjecti64v(id uint32, pname glbase.Enum, params []int64) { + C.gl4_2compat_glGetQueryObjecti64v(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glQueryCounter.xml +func (gl *GL) QueryCounter(id uint32, target glbase.Enum) { + C.gl4_2compat_glQueryCounter(gl.funcs, C.GLuint(id), C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSamplerParameterIuiv.xml +func (gl *GL) GetSamplerParameterIuiv(sampler uint32, pname glbase.Enum, params []uint32) { + C.gl4_2compat_glGetSamplerParameterIuiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSamplerParameterfv.xml +func (gl *GL) GetSamplerParameterfv(sampler uint32, pname glbase.Enum, params []float32) { + C.gl4_2compat_glGetSamplerParameterfv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSamplerParameterIiv.xml +func (gl *GL) GetSamplerParameterIiv(sampler uint32, pname glbase.Enum, params []int32) { + C.gl4_2compat_glGetSamplerParameterIiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSamplerParameteriv.xml +func (gl *GL) GetSamplerParameteriv(sampler uint32, pname glbase.Enum, params []int32) { + C.gl4_2compat_glGetSamplerParameteriv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameterIuiv.xml +func (gl *GL) SamplerParameterIuiv(sampler uint32, pname glbase.Enum, param []uint32) { + C.gl4_2compat_glSamplerParameterIuiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameterIiv.xml +func (gl *GL) SamplerParameterIiv(sampler uint32, pname glbase.Enum, param []int32) { + C.gl4_2compat_glSamplerParameterIiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameterfv.xml +func (gl *GL) SamplerParameterfv(sampler uint32, pname glbase.Enum, param []float32) { + C.gl4_2compat_glSamplerParameterfv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameterf.xml +func (gl *GL) SamplerParameterf(sampler uint32, pname glbase.Enum, param float32) { + C.gl4_2compat_glSamplerParameterf(gl.funcs, C.GLuint(sampler), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameteriv.xml +func (gl *GL) SamplerParameteriv(sampler uint32, pname glbase.Enum, param []int32) { + C.gl4_2compat_glSamplerParameteriv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameteri.xml +func (gl *GL) SamplerParameteri(sampler uint32, pname glbase.Enum, param int32) { + C.gl4_2compat_glSamplerParameteri(gl.funcs, C.GLuint(sampler), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindSampler.xml +func (gl *GL) BindSampler(unit, sampler uint32) { + C.gl4_2compat_glBindSampler(gl.funcs, C.GLuint(unit), C.GLuint(sampler)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsSampler.xml +func (gl *GL) IsSampler(sampler uint32) bool { + glresult := C.gl4_2compat_glIsSampler(gl.funcs, C.GLuint(sampler)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteSamplers.xml +func (gl *GL) DeleteSamplers(count int, samplers []uint32) { + C.gl4_2compat_glDeleteSamplers(gl.funcs, C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&samplers[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenSamplers.xml +func (gl *GL) GenSamplers(count int, samplers []uint32) { + C.gl4_2compat_glGenSamplers(gl.funcs, C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&samplers[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFragDataIndex.xml +func (gl *GL) GetFragDataIndex(program glbase.Program, name []byte) int32 { + glresult := C.gl4_2compat_glGetFragDataIndex(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindFragDataLocationIndexed.xml +func (gl *GL) BindFragDataLocationIndexed(program glbase.Program, colorNumber, index uint32, name []byte) { + C.gl4_2compat_glBindFragDataLocationIndexed(gl.funcs, C.GLuint(program), C.GLuint(colorNumber), C.GLuint(index), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribDivisor.xml +func (gl *GL) VertexAttribDivisor(index glbase.Attrib, divisor uint32) { + C.gl4_2compat_glVertexAttribDivisor(gl.funcs, C.GLuint(index), C.GLuint(divisor)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryIndexediv.xml +func (gl *GL) GetQueryIndexediv(target glbase.Enum, index uint32, pname glbase.Enum, params []int32) { + C.gl4_2compat_glGetQueryIndexediv(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndQueryIndexed.xml +func (gl *GL) EndQueryIndexed(target glbase.Enum, index uint32) { + C.gl4_2compat_glEndQueryIndexed(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBeginQueryIndexed.xml +func (gl *GL) BeginQueryIndexed(target glbase.Enum, index, id uint32) { + C.gl4_2compat_glBeginQueryIndexed(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawTransformFeedbackStream.xml +func (gl *GL) DrawTransformFeedbackStream(mode glbase.Enum, id, stream uint32) { + C.gl4_2compat_glDrawTransformFeedbackStream(gl.funcs, C.GLenum(mode), C.GLuint(id), C.GLuint(stream)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawTransformFeedback.xml +func (gl *GL) DrawTransformFeedback(mode glbase.Enum, id uint32) { + C.gl4_2compat_glDrawTransformFeedback(gl.funcs, C.GLenum(mode), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glResumeTransformFeedback.xml +func (gl *GL) ResumeTransformFeedback() { + C.gl4_2compat_glResumeTransformFeedback(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPauseTransformFeedback.xml +func (gl *GL) PauseTransformFeedback() { + C.gl4_2compat_glPauseTransformFeedback(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsTransformFeedback.xml +func (gl *GL) IsTransformFeedback(id uint32) bool { + glresult := C.gl4_2compat_glIsTransformFeedback(gl.funcs, C.GLuint(id)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenTransformFeedbacks.xml +func (gl *GL) GenTransformFeedbacks(n int, ids []uint32) { + C.gl4_2compat_glGenTransformFeedbacks(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteTransformFeedbacks.xml +func (gl *GL) DeleteTransformFeedbacks(n int, ids []uint32) { + C.gl4_2compat_glDeleteTransformFeedbacks(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindTransformFeedback.xml +func (gl *GL) BindTransformFeedback(target glbase.Enum, id uint32) { + C.gl4_2compat_glBindTransformFeedback(gl.funcs, C.GLenum(target), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPatchParameterfv.xml +func (gl *GL) PatchParameterfv(pname glbase.Enum, values []float32) { + C.gl4_2compat_glPatchParameterfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPatchParameteri.xml +func (gl *GL) PatchParameteri(pname glbase.Enum, value int32) { + C.gl4_2compat_glPatchParameteri(gl.funcs, C.GLenum(pname), C.GLint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramStageiv.xml +func (gl *GL) GetProgramStageiv(program glbase.Program, shadertype, pname glbase.Enum, values []int32) { + C.gl4_2compat_glGetProgramStageiv(gl.funcs, C.GLuint(program), C.GLenum(shadertype), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetUniformSubroutineuiv.xml +func (gl *GL) GetUniformSubroutineuiv(shadertype glbase.Enum, location glbase.Uniform, params []uint32) { + C.gl4_2compat_glGetUniformSubroutineuiv(gl.funcs, C.GLenum(shadertype), C.GLint(location), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformSubroutinesuiv.xml +func (gl *GL) UniformSubroutinesuiv(shadertype glbase.Enum, count int, value []uint32) { + C.gl4_2compat_glUniformSubroutinesuiv(gl.funcs, C.GLenum(shadertype), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveSubroutineName.xml +func (gl *GL) GetActiveSubroutineName(program glbase.Program, shadertype glbase.Enum, index uint32, bufSize int32, length []int32, name []byte) { + C.gl4_2compat_glGetActiveSubroutineName(gl.funcs, C.GLuint(program), C.GLenum(shadertype), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveSubroutineUniformName.xml +func (gl *GL) GetActiveSubroutineUniformName(program glbase.Program, shadertype glbase.Enum, index uint32, bufSize int32, length []int32, name []byte) { + C.gl4_2compat_glGetActiveSubroutineUniformName(gl.funcs, C.GLuint(program), C.GLenum(shadertype), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveSubroutineUniformiv.xml +func (gl *GL) GetActiveSubroutineUniformiv(program glbase.Program, shadertype glbase.Enum, index uint32, pname glbase.Enum, values []int32) { + C.gl4_2compat_glGetActiveSubroutineUniformiv(gl.funcs, C.GLuint(program), C.GLenum(shadertype), C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSubroutineIndex.xml +func (gl *GL) GetSubroutineIndex(program glbase.Program, shadertype glbase.Enum, name []byte) uint32 { + glresult := C.gl4_2compat_glGetSubroutineIndex(gl.funcs, C.GLuint(program), C.GLenum(shadertype), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSubroutineUniformLocation.xml +func (gl *GL) GetSubroutineUniformLocation(program glbase.Program, shadertype glbase.Enum, name []byte) int32 { + glresult := C.gl4_2compat_glGetSubroutineUniformLocation(gl.funcs, C.GLuint(program), C.GLenum(shadertype), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetUniformdv.xml +func (gl *GL) GetUniformdv(program glbase.Program, location glbase.Uniform, params []float64) { + C.gl4_2compat_glGetUniformdv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix4x3dv.xml +func (gl *GL) UniformMatrix4x3dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_2compat_glUniformMatrix4x3dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix4x2dv.xml +func (gl *GL) UniformMatrix4x2dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_2compat_glUniformMatrix4x2dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix3x4dv.xml +func (gl *GL) UniformMatrix3x4dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_2compat_glUniformMatrix3x4dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix3x2dv.xml +func (gl *GL) UniformMatrix3x2dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_2compat_glUniformMatrix3x2dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix2x4dv.xml +func (gl *GL) UniformMatrix2x4dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_2compat_glUniformMatrix2x4dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix2x3dv.xml +func (gl *GL) UniformMatrix2x3dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_2compat_glUniformMatrix2x3dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix4dv.xml +func (gl *GL) UniformMatrix4dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_2compat_glUniformMatrix4dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix3dv.xml +func (gl *GL) UniformMatrix3dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_2compat_glUniformMatrix3dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix2dv.xml +func (gl *GL) UniformMatrix2dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_2compat_glUniformMatrix2dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform4dv.xml +func (gl *GL) Uniform4dv(location glbase.Uniform, count int, value []float64) { + C.gl4_2compat_glUniform4dv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform3dv.xml +func (gl *GL) Uniform3dv(location glbase.Uniform, count int, value []float64) { + C.gl4_2compat_glUniform3dv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform2dv.xml +func (gl *GL) Uniform2dv(location glbase.Uniform, count int, value []float64) { + C.gl4_2compat_glUniform2dv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform1dv.xml +func (gl *GL) Uniform1dv(location glbase.Uniform, count int, value []float64) { + C.gl4_2compat_glUniform1dv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform4d.xml +func (gl *GL) Uniform4d(location glbase.Uniform, v0, v1, v2, v3 float64) { + C.gl4_2compat_glUniform4d(gl.funcs, C.GLint(location), C.GLdouble(v0), C.GLdouble(v1), C.GLdouble(v2), C.GLdouble(v3)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform3d.xml +func (gl *GL) Uniform3d(location glbase.Uniform, v0, v1, v2 float64) { + C.gl4_2compat_glUniform3d(gl.funcs, C.GLint(location), C.GLdouble(v0), C.GLdouble(v1), C.GLdouble(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform2d.xml +func (gl *GL) Uniform2d(location glbase.Uniform, v0, v1 float64) { + C.gl4_2compat_glUniform2d(gl.funcs, C.GLint(location), C.GLdouble(v0), C.GLdouble(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform1d.xml +func (gl *GL) Uniform1d(location glbase.Uniform, v0 float64) { + C.gl4_2compat_glUniform1d(gl.funcs, C.GLint(location), C.GLdouble(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsIndirect.xml +func (gl *GL) DrawElementsIndirect(mode, gltype glbase.Enum, indirect interface{}) { + var indirect_ptr unsafe.Pointer + var indirect_v = reflect.ValueOf(indirect) + if indirect != nil && indirect_v.Kind() != reflect.Slice { + panic("parameter indirect must be a slice") + } + if indirect != nil { + indirect_ptr = unsafe.Pointer(indirect_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glDrawElementsIndirect(gl.funcs, C.GLenum(mode), C.GLenum(gltype), indirect_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawArraysIndirect.xml +func (gl *GL) DrawArraysIndirect(mode glbase.Enum, indirect interface{}) { + var indirect_ptr unsafe.Pointer + var indirect_v = reflect.ValueOf(indirect) + if indirect != nil && indirect_v.Kind() != reflect.Slice { + panic("parameter indirect must be a slice") + } + if indirect != nil { + indirect_ptr = unsafe.Pointer(indirect_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glDrawArraysIndirect(gl.funcs, C.GLenum(mode), indirect_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFuncSeparatei.xml +func (gl *GL) BlendFuncSeparatei(buf uint32, srcRGB, dstRGB, srcAlpha, dstAlpha glbase.Enum) { + C.gl4_2compat_glBlendFuncSeparatei(gl.funcs, C.GLuint(buf), C.GLenum(srcRGB), C.GLenum(dstRGB), C.GLenum(srcAlpha), C.GLenum(dstAlpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFunci.xml +func (gl *GL) BlendFunci(buf uint32, src, dst glbase.Enum) { + C.gl4_2compat_glBlendFunci(gl.funcs, C.GLuint(buf), C.GLenum(src), C.GLenum(dst)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendEquationSeparatei.xml +func (gl *GL) BlendEquationSeparatei(buf uint32, modeRGB, modeAlpha glbase.Enum) { + C.gl4_2compat_glBlendEquationSeparatei(gl.funcs, C.GLuint(buf), C.GLenum(modeRGB), C.GLenum(modeAlpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendEquationi.xml +func (gl *GL) BlendEquationi(buf uint32, mode glbase.Enum) { + C.gl4_2compat_glBlendEquationi(gl.funcs, C.GLuint(buf), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMinSampleShading.xml +func (gl *GL) MinSampleShading(value float32) { + C.gl4_2compat_glMinSampleShading(gl.funcs, C.GLfloat(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetDoublei_v.xml +func (gl *GL) GetDoublei_v(target glbase.Enum, index uint32, data []float64) { + C.gl4_2compat_glGetDoublei_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFloati_v.xml +func (gl *GL) GetFloati_v(target glbase.Enum, index uint32, data []float32) { + C.gl4_2compat_glGetFloati_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDepthRangeIndexed.xml +func (gl *GL) DepthRangeIndexed(index uint32, n, f float64) { + C.gl4_2compat_glDepthRangeIndexed(gl.funcs, C.GLuint(index), C.GLdouble(n), C.GLdouble(f)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDepthRangeArrayv.xml +func (gl *GL) DepthRangeArrayv(first uint32, count int, v []float64) { + C.gl4_2compat_glDepthRangeArrayv(gl.funcs, C.GLuint(first), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glScissorIndexedv.xml +func (gl *GL) ScissorIndexedv(index uint32, v []int32) { + C.gl4_2compat_glScissorIndexedv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glScissorIndexed.xml +func (gl *GL) ScissorIndexed(index uint32, left, bottom int32, width, height int) { + C.gl4_2compat_glScissorIndexed(gl.funcs, C.GLuint(index), C.GLint(left), C.GLint(bottom), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glScissorArrayv.xml +func (gl *GL) ScissorArrayv(first uint32, count int, v []int32) { + C.gl4_2compat_glScissorArrayv(gl.funcs, C.GLuint(first), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glViewportIndexedfv.xml +func (gl *GL) ViewportIndexedfv(index uint32, v []float32) { + C.gl4_2compat_glViewportIndexedfv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glViewportIndexedf.xml +func (gl *GL) ViewportIndexedf(index uint32, x, y, w, h float32) { + C.gl4_2compat_glViewportIndexedf(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y), C.GLfloat(w), C.GLfloat(h)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glViewportArrayv.xml +func (gl *GL) ViewportArrayv(first uint32, count int, v []float32) { + C.gl4_2compat_glViewportArrayv(gl.funcs, C.GLuint(first), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetVertexAttribLdv.xml +func (gl *GL) GetVertexAttribLdv(index glbase.Attrib, pname glbase.Enum, params []float64) { + C.gl4_2compat_glGetVertexAttribLdv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribLPointer.xml +func (gl *GL) VertexAttribLPointer(index glbase.Attrib, size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glVertexAttribLPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL4dv.xml +func (gl *GL) VertexAttribL4dv(index glbase.Attrib, v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glVertexAttribL4dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL3dv.xml +func (gl *GL) VertexAttribL3dv(index glbase.Attrib, v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glVertexAttribL3dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL2dv.xml +func (gl *GL) VertexAttribL2dv(index glbase.Attrib, v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glVertexAttribL2dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL1dv.xml +func (gl *GL) VertexAttribL1dv(index glbase.Attrib, v []float64) { + C.gl4_2compat_glVertexAttribL1dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL4d.xml +func (gl *GL) VertexAttribL4d(index glbase.Attrib, x, y, z, w float64) { + C.gl4_2compat_glVertexAttribL4d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL3d.xml +func (gl *GL) VertexAttribL3d(index glbase.Attrib, x, y, z float64) { + C.gl4_2compat_glVertexAttribL3d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL2d.xml +func (gl *GL) VertexAttribL2d(index glbase.Attrib, x, y float64) { + C.gl4_2compat_glVertexAttribL2d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL1d.xml +func (gl *GL) VertexAttribL1d(index glbase.Attrib, x float64) { + C.gl4_2compat_glVertexAttribL1d(gl.funcs, C.GLuint(index), C.GLdouble(x)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramPipelineInfoLog.xml +func (gl *GL) GetProgramPipelineInfoLog(pipeline uint32, bufSize int32, length []int32, infoLog []byte) { + C.gl4_2compat_glGetProgramPipelineInfoLog(gl.funcs, C.GLuint(pipeline), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glValidateProgramPipeline.xml +func (gl *GL) ValidateProgramPipeline(pipeline uint32) { + C.gl4_2compat_glValidateProgramPipeline(gl.funcs, C.GLuint(pipeline)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4x3dv.xml +func (gl *GL) ProgramUniformMatrix4x3dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_2compat_glProgramUniformMatrix4x3dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3x4dv.xml +func (gl *GL) ProgramUniformMatrix3x4dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_2compat_glProgramUniformMatrix3x4dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4x2dv.xml +func (gl *GL) ProgramUniformMatrix4x2dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_2compat_glProgramUniformMatrix4x2dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2x4dv.xml +func (gl *GL) ProgramUniformMatrix2x4dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_2compat_glProgramUniformMatrix2x4dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3x2dv.xml +func (gl *GL) ProgramUniformMatrix3x2dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_2compat_glProgramUniformMatrix3x2dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2x3dv.xml +func (gl *GL) ProgramUniformMatrix2x3dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_2compat_glProgramUniformMatrix2x3dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4x3fv.xml +func (gl *GL) ProgramUniformMatrix4x3fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_2compat_glProgramUniformMatrix4x3fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3x4fv.xml +func (gl *GL) ProgramUniformMatrix3x4fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_2compat_glProgramUniformMatrix3x4fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4x2fv.xml +func (gl *GL) ProgramUniformMatrix4x2fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_2compat_glProgramUniformMatrix4x2fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2x4fv.xml +func (gl *GL) ProgramUniformMatrix2x4fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_2compat_glProgramUniformMatrix2x4fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3x2fv.xml +func (gl *GL) ProgramUniformMatrix3x2fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_2compat_glProgramUniformMatrix3x2fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2x3fv.xml +func (gl *GL) ProgramUniformMatrix2x3fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_2compat_glProgramUniformMatrix2x3fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4dv.xml +func (gl *GL) ProgramUniformMatrix4dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_2compat_glProgramUniformMatrix4dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3dv.xml +func (gl *GL) ProgramUniformMatrix3dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_2compat_glProgramUniformMatrix3dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2dv.xml +func (gl *GL) ProgramUniformMatrix2dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_2compat_glProgramUniformMatrix2dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4fv.xml +func (gl *GL) ProgramUniformMatrix4fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_2compat_glProgramUniformMatrix4fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3fv.xml +func (gl *GL) ProgramUniformMatrix3fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_2compat_glProgramUniformMatrix3fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2fv.xml +func (gl *GL) ProgramUniformMatrix2fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_2compat_glProgramUniformMatrix2fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4uiv.xml +func (gl *GL) ProgramUniform4uiv(program glbase.Program, location glbase.Uniform, count int, value []uint32) { + C.gl4_2compat_glProgramUniform4uiv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4ui.xml +func (gl *GL) ProgramUniform4ui(program glbase.Program, location glbase.Uniform, v0, v1, v2, v3 uint32) { + C.gl4_2compat_glProgramUniform4ui(gl.funcs, C.GLuint(program), C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2), C.GLuint(v3)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4dv.xml +func (gl *GL) ProgramUniform4dv(program glbase.Program, location glbase.Uniform, count int, value []float64) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_2compat_glProgramUniform4dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4d.xml +func (gl *GL) ProgramUniform4d(program glbase.Program, location glbase.Uniform, v0, v1, v2, v3 float64) { + C.gl4_2compat_glProgramUniform4d(gl.funcs, C.GLuint(program), C.GLint(location), C.GLdouble(v0), C.GLdouble(v1), C.GLdouble(v2), C.GLdouble(v3)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4fv.xml +func (gl *GL) ProgramUniform4fv(program glbase.Program, location glbase.Uniform, count int, value []float32) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_2compat_glProgramUniform4fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4f.xml +func (gl *GL) ProgramUniform4f(program glbase.Program, location glbase.Uniform, v0, v1, v2, v3 float32) { + C.gl4_2compat_glProgramUniform4f(gl.funcs, C.GLuint(program), C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2), C.GLfloat(v3)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4iv.xml +func (gl *GL) ProgramUniform4iv(program glbase.Program, location glbase.Uniform, count int, value []int32) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_2compat_glProgramUniform4iv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4i.xml +func (gl *GL) ProgramUniform4i(program glbase.Program, location glbase.Uniform, v0, v1, v2, v3 int32) { + C.gl4_2compat_glProgramUniform4i(gl.funcs, C.GLuint(program), C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2), C.GLint(v3)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3uiv.xml +func (gl *GL) ProgramUniform3uiv(program glbase.Program, location glbase.Uniform, count int, value []uint32) { + C.gl4_2compat_glProgramUniform3uiv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3ui.xml +func (gl *GL) ProgramUniform3ui(program glbase.Program, location glbase.Uniform, v0, v1, v2 uint32) { + C.gl4_2compat_glProgramUniform3ui(gl.funcs, C.GLuint(program), C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3dv.xml +func (gl *GL) ProgramUniform3dv(program glbase.Program, location glbase.Uniform, count int, value []float64) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_2compat_glProgramUniform3dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3d.xml +func (gl *GL) ProgramUniform3d(program glbase.Program, location glbase.Uniform, v0, v1, v2 float64) { + C.gl4_2compat_glProgramUniform3d(gl.funcs, C.GLuint(program), C.GLint(location), C.GLdouble(v0), C.GLdouble(v1), C.GLdouble(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3fv.xml +func (gl *GL) ProgramUniform3fv(program glbase.Program, location glbase.Uniform, count int, value []float32) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_2compat_glProgramUniform3fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3f.xml +func (gl *GL) ProgramUniform3f(program glbase.Program, location glbase.Uniform, v0, v1, v2 float32) { + C.gl4_2compat_glProgramUniform3f(gl.funcs, C.GLuint(program), C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3iv.xml +func (gl *GL) ProgramUniform3iv(program glbase.Program, location glbase.Uniform, count int, value []int32) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_2compat_glProgramUniform3iv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3i.xml +func (gl *GL) ProgramUniform3i(program glbase.Program, location glbase.Uniform, v0, v1, v2 int32) { + C.gl4_2compat_glProgramUniform3i(gl.funcs, C.GLuint(program), C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2uiv.xml +func (gl *GL) ProgramUniform2uiv(program glbase.Program, location glbase.Uniform, count int, value []uint32) { + C.gl4_2compat_glProgramUniform2uiv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2ui.xml +func (gl *GL) ProgramUniform2ui(program glbase.Program, location glbase.Uniform, v0, v1 uint32) { + C.gl4_2compat_glProgramUniform2ui(gl.funcs, C.GLuint(program), C.GLint(location), C.GLuint(v0), C.GLuint(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2dv.xml +func (gl *GL) ProgramUniform2dv(program glbase.Program, location glbase.Uniform, count int, value []float64) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_2compat_glProgramUniform2dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2d.xml +func (gl *GL) ProgramUniform2d(program glbase.Program, location glbase.Uniform, v0, v1 float64) { + C.gl4_2compat_glProgramUniform2d(gl.funcs, C.GLuint(program), C.GLint(location), C.GLdouble(v0), C.GLdouble(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2fv.xml +func (gl *GL) ProgramUniform2fv(program glbase.Program, location glbase.Uniform, count int, value []float32) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_2compat_glProgramUniform2fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2f.xml +func (gl *GL) ProgramUniform2f(program glbase.Program, location glbase.Uniform, v0, v1 float32) { + C.gl4_2compat_glProgramUniform2f(gl.funcs, C.GLuint(program), C.GLint(location), C.GLfloat(v0), C.GLfloat(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2iv.xml +func (gl *GL) ProgramUniform2iv(program glbase.Program, location glbase.Uniform, count int, value []int32) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_2compat_glProgramUniform2iv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2i.xml +func (gl *GL) ProgramUniform2i(program glbase.Program, location glbase.Uniform, v0, v1 int32) { + C.gl4_2compat_glProgramUniform2i(gl.funcs, C.GLuint(program), C.GLint(location), C.GLint(v0), C.GLint(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1uiv.xml +func (gl *GL) ProgramUniform1uiv(program glbase.Program, location glbase.Uniform, count int, value []uint32) { + C.gl4_2compat_glProgramUniform1uiv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1ui.xml +func (gl *GL) ProgramUniform1ui(program glbase.Program, location glbase.Uniform, v0 uint32) { + C.gl4_2compat_glProgramUniform1ui(gl.funcs, C.GLuint(program), C.GLint(location), C.GLuint(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1dv.xml +func (gl *GL) ProgramUniform1dv(program glbase.Program, location glbase.Uniform, count int, value []float64) { + C.gl4_2compat_glProgramUniform1dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1d.xml +func (gl *GL) ProgramUniform1d(program glbase.Program, location glbase.Uniform, v0 float64) { + C.gl4_2compat_glProgramUniform1d(gl.funcs, C.GLuint(program), C.GLint(location), C.GLdouble(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1fv.xml +func (gl *GL) ProgramUniform1fv(program glbase.Program, location glbase.Uniform, count int, value []float32) { + C.gl4_2compat_glProgramUniform1fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1f.xml +func (gl *GL) ProgramUniform1f(program glbase.Program, location glbase.Uniform, v0 float32) { + C.gl4_2compat_glProgramUniform1f(gl.funcs, C.GLuint(program), C.GLint(location), C.GLfloat(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1iv.xml +func (gl *GL) ProgramUniform1iv(program glbase.Program, location glbase.Uniform, count int, value []int32) { + C.gl4_2compat_glProgramUniform1iv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1i.xml +func (gl *GL) ProgramUniform1i(program glbase.Program, location glbase.Uniform, v0 int32) { + C.gl4_2compat_glProgramUniform1i(gl.funcs, C.GLuint(program), C.GLint(location), C.GLint(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramPipelineiv.xml +func (gl *GL) GetProgramPipelineiv(pipeline uint32, pname glbase.Enum, params []int32) { + C.gl4_2compat_glGetProgramPipelineiv(gl.funcs, C.GLuint(pipeline), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsProgramPipeline.xml +func (gl *GL) IsProgramPipeline(pipeline uint32) bool { + glresult := C.gl4_2compat_glIsProgramPipeline(gl.funcs, C.GLuint(pipeline)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenProgramPipelines.xml +func (gl *GL) GenProgramPipelines(n int, pipelines []uint32) { + C.gl4_2compat_glGenProgramPipelines(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&pipelines[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteProgramPipelines.xml +func (gl *GL) DeleteProgramPipelines(n int, pipelines []uint32) { + C.gl4_2compat_glDeleteProgramPipelines(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&pipelines[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindProgramPipeline.xml +func (gl *GL) BindProgramPipeline(pipeline uint32) { + C.gl4_2compat_glBindProgramPipeline(gl.funcs, C.GLuint(pipeline)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glActiveShaderProgram.xml +func (gl *GL) ActiveShaderProgram(pipeline uint32, program glbase.Program) { + C.gl4_2compat_glActiveShaderProgram(gl.funcs, C.GLuint(pipeline), C.GLuint(program)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUseProgramStages.xml +func (gl *GL) UseProgramStages(pipeline uint32, stages glbase.Bitfield, program glbase.Program) { + C.gl4_2compat_glUseProgramStages(gl.funcs, C.GLuint(pipeline), C.GLbitfield(stages), C.GLuint(program)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramParameteri.xml +func (gl *GL) ProgramParameteri(program glbase.Program, pname glbase.Enum, value int32) { + C.gl4_2compat_glProgramParameteri(gl.funcs, C.GLuint(program), C.GLenum(pname), C.GLint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramBinary.xml +func (gl *GL) ProgramBinary(program glbase.Program, binaryFormat glbase.Enum, binary interface{}, length int32) { + var binary_ptr unsafe.Pointer + var binary_v = reflect.ValueOf(binary) + if binary != nil && binary_v.Kind() != reflect.Slice { + panic("parameter binary must be a slice") + } + if binary != nil { + binary_ptr = unsafe.Pointer(binary_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glProgramBinary(gl.funcs, C.GLuint(program), C.GLenum(binaryFormat), binary_ptr, C.GLsizei(length)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramBinary.xml +func (gl *GL) GetProgramBinary(program glbase.Program, bufSize int32, length []int32, binaryFormat []glbase.Enum, binary interface{}) { + var binary_ptr unsafe.Pointer + var binary_v = reflect.ValueOf(binary) + if binary != nil && binary_v.Kind() != reflect.Slice { + panic("parameter binary must be a slice") + } + if binary != nil { + binary_ptr = unsafe.Pointer(binary_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glGetProgramBinary(gl.funcs, C.GLuint(program), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLenum)(unsafe.Pointer(&binaryFormat[0])), binary_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearDepthf.xml +func (gl *GL) ClearDepthf(dd float32) { + C.gl4_2compat_glClearDepthf(gl.funcs, C.GLfloat(dd)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDepthRangef.xml +func (gl *GL) DepthRangef(n, f float32) { + C.gl4_2compat_glDepthRangef(gl.funcs, C.GLfloat(n), C.GLfloat(f)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetShaderPrecisionFormat.xml +func (gl *GL) GetShaderPrecisionFormat(shadertype, precisionType glbase.Enum, range_, precision []int32) { + C.gl4_2compat_glGetShaderPrecisionFormat(gl.funcs, C.GLenum(shadertype), C.GLenum(precisionType), (*C.GLint)(unsafe.Pointer(&range_[0])), (*C.GLint)(unsafe.Pointer(&precision[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glShaderBinary.xml +func (gl *GL) ShaderBinary(count int, shaders []glbase.Shader, binaryFormat glbase.Enum, binary interface{}, length int32) { + var binary_ptr unsafe.Pointer + var binary_v = reflect.ValueOf(binary) + if binary != nil && binary_v.Kind() != reflect.Slice { + panic("parameter binary must be a slice") + } + if binary != nil { + binary_ptr = unsafe.Pointer(binary_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glShaderBinary(gl.funcs, C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&shaders[0])), C.GLenum(binaryFormat), binary_ptr, C.GLsizei(length)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glReleaseShaderCompiler.xml +func (gl *GL) ReleaseShaderCompiler() { + C.gl4_2compat_glReleaseShaderCompiler(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexStorage3D.xml +func (gl *GL) TexStorage3D(target glbase.Enum, levels int32, internalFormat glbase.Enum, width, height int, depth int32) { + C.gl4_2compat_glTexStorage3D(gl.funcs, C.GLenum(target), C.GLsizei(levels), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexStorage2D.xml +func (gl *GL) TexStorage2D(target glbase.Enum, levels int32, internalFormat glbase.Enum, width, height int) { + C.gl4_2compat_glTexStorage2D(gl.funcs, C.GLenum(target), C.GLsizei(levels), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexStorage1D.xml +func (gl *GL) TexStorage1D(target glbase.Enum, levels int32, internalFormat glbase.Enum, width int) { + C.gl4_2compat_glTexStorage1D(gl.funcs, C.GLenum(target), C.GLsizei(levels), C.GLenum(internalFormat), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMemoryBarrier.xml +func (gl *GL) MemoryBarrier(barriers glbase.Bitfield) { + C.gl4_2compat_glMemoryBarrier(gl.funcs, C.GLbitfield(barriers)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindImageTexture.xml +func (gl *GL) BindImageTexture(unit uint32, texture glbase.Texture, level int, layered bool, layer int32, access, format glbase.Enum) { + C.gl4_2compat_glBindImageTexture(gl.funcs, C.GLuint(unit), C.GLuint(texture), C.GLint(level), *(*C.GLboolean)(unsafe.Pointer(&layered)), C.GLint(layer), C.GLenum(access), C.GLenum(format)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveAtomicCounterBufferiv.xml +func (gl *GL) GetActiveAtomicCounterBufferiv(program glbase.Program, bufferIndex uint32, pname glbase.Enum, params []int32) { + C.gl4_2compat_glGetActiveAtomicCounterBufferiv(gl.funcs, C.GLuint(program), C.GLuint(bufferIndex), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetInternalformativ.xml +func (gl *GL) GetInternalformativ(target, internalFormat, pname glbase.Enum, bufSize int32, params []int32) { + C.gl4_2compat_glGetInternalformativ(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLenum(pname), C.GLsizei(bufSize), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawTransformFeedbackStreamInstanced.xml +func (gl *GL) DrawTransformFeedbackStreamInstanced(mode glbase.Enum, id, stream uint32, instancecount int32) { + C.gl4_2compat_glDrawTransformFeedbackStreamInstanced(gl.funcs, C.GLenum(mode), C.GLuint(id), C.GLuint(stream), C.GLsizei(instancecount)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawTransformFeedbackInstanced.xml +func (gl *GL) DrawTransformFeedbackInstanced(mode glbase.Enum, id uint32, instancecount int32) { + C.gl4_2compat_glDrawTransformFeedbackInstanced(gl.funcs, C.GLenum(mode), C.GLuint(id), C.GLsizei(instancecount)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsInstancedBaseVertexBaseInstance.xml +func (gl *GL) DrawElementsInstancedBaseVertexBaseInstance(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, instancecount, basevertex int32, baseinstance uint32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glDrawElementsInstancedBaseVertexBaseInstance(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLsizei(instancecount), C.GLint(basevertex), C.GLuint(baseinstance)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsInstancedBaseInstance.xml +func (gl *GL) DrawElementsInstancedBaseInstance(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, instancecount int32, baseinstance uint32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glDrawElementsInstancedBaseInstance(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLsizei(instancecount), C.GLuint(baseinstance)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawArraysInstancedBaseInstance.xml +func (gl *GL) DrawArraysInstancedBaseInstance(mode glbase.Enum, first, count int, instancecount int32, baseinstance uint32) { + C.gl4_2compat_glDrawArraysInstancedBaseInstance(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count), C.GLsizei(instancecount), C.GLuint(baseinstance)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTranslatef.xml +func (gl *GL) Translatef(x, y, z float32) { + C.gl4_2compat_glTranslatef(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTranslated.xml +func (gl *GL) Translated(x, y, z float64) { + C.gl4_2compat_glTranslated(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glScalef.xml +func (gl *GL) Scalef(x, y, z float32) { + C.gl4_2compat_glScalef(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glScaled.xml +func (gl *GL) Scaled(x, y, z float64) { + C.gl4_2compat_glScaled(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRotatef.xml +func (gl *GL) Rotatef(angle, x, y, z float32) { + C.gl4_2compat_glRotatef(gl.funcs, C.GLfloat(angle), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRotated.xml +func (gl *GL) Rotated(angle, x, y, z float64) { + C.gl4_2compat_glRotated(gl.funcs, C.GLdouble(angle), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPushMatrix.xml +func (gl *GL) PushMatrix() { + C.gl4_2compat_glPushMatrix(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPopMatrix.xml +func (gl *GL) PopMatrix() { + C.gl4_2compat_glPopMatrix(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glOrtho.xml +func (gl *GL) Ortho(left, right, bottom, top, zNear, zFar float64) { + C.gl4_2compat_glOrtho(gl.funcs, C.GLdouble(left), C.GLdouble(right), C.GLdouble(bottom), C.GLdouble(top), C.GLdouble(zNear), C.GLdouble(zFar)) +} + +// MultMatrixd multiplies the current matrix with the provided matrix. +// +// The m parameter must hold 16 consecutive elements of a 4x4 column-major matrix. +// +// The current matrix is determined by the current matrix mode (see +// MatrixMode). It is either the projection matrix, modelview matrix, or the +// texture matrix. +// +// For example, if the current matrix is C and the coordinates to be transformed +// are v = (v[0], v[1], v[2], v[3]), then the current transformation is C × v, or +// +// c[0] c[4] c[8] c[12] v[0] +// c[1] c[5] c[9] c[13] v[1] +// c[2] c[6] c[10] c[14] X v[2] +// c[3] c[7] c[11] c[15] v[3] +// +// Calling MultMatrix with an argument of m = m[0], m[1], ..., m[15] +// replaces the current transformation with (C X M) x v, or +// +// c[0] c[4] c[8] c[12] m[0] m[4] m[8] m[12] v[0] +// c[1] c[5] c[9] c[13] m[1] m[5] m[9] m[13] v[1] +// c[2] c[6] c[10] c[14] X m[2] m[6] m[10] m[14] X v[2] +// c[3] c[7] c[11] c[15] m[3] m[7] m[11] m[15] v[3] +// +// Where 'X' denotes matrix multiplication, and v is represented as a 4x1 matrix. +// +// While the elements of the matrix may be specified with single or double +// precision, the GL may store or operate on these values in less-than-single +// precision. +// +// In many computer languages, 4×4 arrays are represented in row-major +// order. The transformations just described represent these matrices in +// column-major order. The order of the multiplication is important. For +// example, if the current transformation is a rotation, and MultMatrix is +// called with a translation matrix, the translation is done directly on the +// coordinates to be transformed, while the rotation is done on the results +// of that translation. +// +// GL.INVALID_OPERATION is generated if MultMatrix is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) MultMatrixd(m []float64) { + if len(m) != 16 { + panic("parameter m must have length 16 for the 4x4 matrix") + } + C.gl4_2compat_glMultMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// MultMatrixf multiplies the current matrix with the provided matrix. +// +// The m parameter must hold 16 consecutive elements of a 4x4 column-major matrix. +// +// The current matrix is determined by the current matrix mode (see +// MatrixMode). It is either the projection matrix, modelview matrix, or the +// texture matrix. +// +// For example, if the current matrix is C and the coordinates to be transformed +// are v = (v[0], v[1], v[2], v[3]), then the current transformation is C × v, or +// +// c[0] c[4] c[8] c[12] v[0] +// c[1] c[5] c[9] c[13] v[1] +// c[2] c[6] c[10] c[14] X v[2] +// c[3] c[7] c[11] c[15] v[3] +// +// Calling MultMatrix with an argument of m = m[0], m[1], ..., m[15] +// replaces the current transformation with (C X M) x v, or +// +// c[0] c[4] c[8] c[12] m[0] m[4] m[8] m[12] v[0] +// c[1] c[5] c[9] c[13] m[1] m[5] m[9] m[13] v[1] +// c[2] c[6] c[10] c[14] X m[2] m[6] m[10] m[14] X v[2] +// c[3] c[7] c[11] c[15] m[3] m[7] m[11] m[15] v[3] +// +// Where 'X' denotes matrix multiplication, and v is represented as a 4x1 matrix. +// +// While the elements of the matrix may be specified with single or double +// precision, the GL may store or operate on these values in less-than-single +// precision. +// +// In many computer languages, 4×4 arrays are represented in row-major +// order. The transformations just described represent these matrices in +// column-major order. The order of the multiplication is important. For +// example, if the current transformation is a rotation, and MultMatrix is +// called with a translation matrix, the translation is done directly on the +// coordinates to be transformed, while the rotation is done on the results +// of that translation. +// +// GL.INVALID_OPERATION is generated if MultMatrix is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) MultMatrixf(m []float32) { + if len(m) != 16 { + panic("parameter m must have length 16 for the 4x4 matrix") + } + C.gl4_2compat_glMultMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMatrixMode.xml +func (gl *GL) MatrixMode(mode glbase.Enum) { + C.gl4_2compat_glMatrixMode(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLoadMatrixd.xml +func (gl *GL) LoadMatrixd(m []float64) { + C.gl4_2compat_glLoadMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLoadMatrixf.xml +func (gl *GL) LoadMatrixf(m []float32) { + C.gl4_2compat_glLoadMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLoadIdentity.xml +func (gl *GL) LoadIdentity() { + C.gl4_2compat_glLoadIdentity(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFrustum.xml +func (gl *GL) Frustum(left, right, bottom, top, zNear, zFar float64) { + C.gl4_2compat_glFrustum(gl.funcs, C.GLdouble(left), C.GLdouble(right), C.GLdouble(bottom), C.GLdouble(top), C.GLdouble(zNear), C.GLdouble(zFar)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsList.xml +func (gl *GL) IsList(list uint32) bool { + glresult := C.gl4_2compat_glIsList(gl.funcs, C.GLuint(list)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexGeniv.xml +func (gl *GL) GetTexGeniv(coord, pname glbase.Enum, params []int32) { + C.gl4_2compat_glGetTexGeniv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexGenfv.xml +func (gl *GL) GetTexGenfv(coord, pname glbase.Enum, params []float32) { + C.gl4_2compat_glGetTexGenfv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexGendv.xml +func (gl *GL) GetTexGendv(coord, pname glbase.Enum, params []float64) { + C.gl4_2compat_glGetTexGendv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexEnviv.xml +func (gl *GL) GetTexEnviv(target, pname glbase.Enum, params []int32) { + C.gl4_2compat_glGetTexEnviv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexEnvfv.xml +func (gl *GL) GetTexEnvfv(target, pname glbase.Enum, params []float32) { + C.gl4_2compat_glGetTexEnvfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetPolygonStipple.xml +func (gl *GL) GetPolygonStipple(mask []uint8) { + C.gl4_2compat_glGetPolygonStipple(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&mask[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetPixelMapusv.xml +func (gl *GL) GetPixelMapusv(glmap glbase.Enum, values []uint16) { + C.gl4_2compat_glGetPixelMapusv(gl.funcs, C.GLenum(glmap), (*C.GLushort)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetPixelMapuiv.xml +func (gl *GL) GetPixelMapuiv(glmap glbase.Enum, values []uint32) { + C.gl4_2compat_glGetPixelMapuiv(gl.funcs, C.GLenum(glmap), (*C.GLuint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetPixelMapfv.xml +func (gl *GL) GetPixelMapfv(glmap glbase.Enum, values []float32) { + C.gl4_2compat_glGetPixelMapfv(gl.funcs, C.GLenum(glmap), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMaterialiv.xml +func (gl *GL) GetMaterialiv(face, pname glbase.Enum, params []int32) { + C.gl4_2compat_glGetMaterialiv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMaterialfv.xml +func (gl *GL) GetMaterialfv(face, pname glbase.Enum, params []float32) { + C.gl4_2compat_glGetMaterialfv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMapiv.xml +func (gl *GL) GetMapiv(target, query glbase.Enum, v []int32) { + C.gl4_2compat_glGetMapiv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMapfv.xml +func (gl *GL) GetMapfv(target, query glbase.Enum, v []float32) { + C.gl4_2compat_glGetMapfv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMapdv.xml +func (gl *GL) GetMapdv(target, query glbase.Enum, v []float64) { + C.gl4_2compat_glGetMapdv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetLightiv.xml +func (gl *GL) GetLightiv(light, pname glbase.Enum, params []int32) { + C.gl4_2compat_glGetLightiv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetLightfv.xml +func (gl *GL) GetLightfv(light, pname glbase.Enum, params []float32) { + C.gl4_2compat_glGetLightfv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetClipPlane.xml +func (gl *GL) GetClipPlane(plane glbase.Enum, equation []float64) { + C.gl4_2compat_glGetClipPlane(gl.funcs, C.GLenum(plane), (*C.GLdouble)(unsafe.Pointer(&equation[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawPixels.xml +func (gl *GL) DrawPixels(width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glDrawPixels(gl.funcs, C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyPixels.xml +func (gl *GL) CopyPixels(x, y, width, height int, gltype glbase.Enum) { + C.gl4_2compat_glCopyPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(gltype)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelMapusv.xml +func (gl *GL) PixelMapusv(glmap glbase.Enum, mapsize int32, values []uint16) { + C.gl4_2compat_glPixelMapusv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLushort)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelMapuiv.xml +func (gl *GL) PixelMapuiv(glmap glbase.Enum, mapsize int32, values []uint32) { + C.gl4_2compat_glPixelMapuiv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLuint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelMapfv.xml +func (gl *GL) PixelMapfv(glmap glbase.Enum, mapsize int32, values []float32) { + C.gl4_2compat_glPixelMapfv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelTransferi.xml +func (gl *GL) PixelTransferi(pname glbase.Enum, param int32) { + C.gl4_2compat_glPixelTransferi(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelTransferf.xml +func (gl *GL) PixelTransferf(pname glbase.Enum, param float32) { + C.gl4_2compat_glPixelTransferf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelZoom.xml +func (gl *GL) PixelZoom(xfactor, yfactor float32) { + C.gl4_2compat_glPixelZoom(gl.funcs, C.GLfloat(xfactor), C.GLfloat(yfactor)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glAlphaFunc.xml +func (gl *GL) AlphaFunc(glfunc glbase.Enum, ref float32) { + C.gl4_2compat_glAlphaFunc(gl.funcs, C.GLenum(glfunc), C.GLfloat(ref)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalPoint2.xml +func (gl *GL) EvalPoint2(i, j int32) { + C.gl4_2compat_glEvalPoint2(gl.funcs, C.GLint(i), C.GLint(j)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalMesh2.xml +func (gl *GL) EvalMesh2(mode glbase.Enum, i1, i2, j1, j2 int32) { + C.gl4_2compat_glEvalMesh2(gl.funcs, C.GLenum(mode), C.GLint(i1), C.GLint(i2), C.GLint(j1), C.GLint(j2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalPoint1.xml +func (gl *GL) EvalPoint1(i int32) { + C.gl4_2compat_glEvalPoint1(gl.funcs, C.GLint(i)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalMesh1.xml +func (gl *GL) EvalMesh1(mode glbase.Enum, i1, i2 int32) { + C.gl4_2compat_glEvalMesh1(gl.funcs, C.GLenum(mode), C.GLint(i1), C.GLint(i2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalCoord2fv.xml +func (gl *GL) EvalCoord2fv(u []float32) { + if len(u) != 2 { + panic("parameter u has incorrect length") + } + C.gl4_2compat_glEvalCoord2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalCoord2f.xml +func (gl *GL) EvalCoord2f(u, v float32) { + C.gl4_2compat_glEvalCoord2f(gl.funcs, C.GLfloat(u), C.GLfloat(v)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalCoord2dv.xml +func (gl *GL) EvalCoord2dv(u []float64) { + if len(u) != 2 { + panic("parameter u has incorrect length") + } + C.gl4_2compat_glEvalCoord2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalCoord2d.xml +func (gl *GL) EvalCoord2d(u, v float64) { + C.gl4_2compat_glEvalCoord2d(gl.funcs, C.GLdouble(u), C.GLdouble(v)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalCoord1fv.xml +func (gl *GL) EvalCoord1fv(u []float32) { + C.gl4_2compat_glEvalCoord1fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalCoord1f.xml +func (gl *GL) EvalCoord1f(u float32) { + C.gl4_2compat_glEvalCoord1f(gl.funcs, C.GLfloat(u)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalCoord1dv.xml +func (gl *GL) EvalCoord1dv(u []float64) { + C.gl4_2compat_glEvalCoord1dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalCoord1d.xml +func (gl *GL) EvalCoord1d(u float64) { + C.gl4_2compat_glEvalCoord1d(gl.funcs, C.GLdouble(u)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMapGrid2f.xml +func (gl *GL) MapGrid2f(un int32, u1, u2 float32, vn int32, v1, v2 float32) { + C.gl4_2compat_glMapGrid2f(gl.funcs, C.GLint(un), C.GLfloat(u1), C.GLfloat(u2), C.GLint(vn), C.GLfloat(v1), C.GLfloat(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMapGrid2d.xml +func (gl *GL) MapGrid2d(un int32, u1, u2 float64, vn int32, v1, v2 float64) { + C.gl4_2compat_glMapGrid2d(gl.funcs, C.GLint(un), C.GLdouble(u1), C.GLdouble(u2), C.GLint(vn), C.GLdouble(v1), C.GLdouble(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMapGrid1f.xml +func (gl *GL) MapGrid1f(un int32, u1, u2 float32) { + C.gl4_2compat_glMapGrid1f(gl.funcs, C.GLint(un), C.GLfloat(u1), C.GLfloat(u2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMapGrid1d.xml +func (gl *GL) MapGrid1d(un int32, u1, u2 float64) { + C.gl4_2compat_glMapGrid1d(gl.funcs, C.GLint(un), C.GLdouble(u1), C.GLdouble(u2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMap2f.xml +func (gl *GL) Map2f(target glbase.Enum, u1, u2 float32, ustride, uorder int32, v1, v2 float32, vstride, vorder int32, points []float32) { + C.gl4_2compat_glMap2f(gl.funcs, C.GLenum(target), C.GLfloat(u1), C.GLfloat(u2), C.GLint(ustride), C.GLint(uorder), C.GLfloat(v1), C.GLfloat(v2), C.GLint(vstride), C.GLint(vorder), (*C.GLfloat)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMap2d.xml +func (gl *GL) Map2d(target glbase.Enum, u1, u2 float64, ustride, uorder int32, v1, v2 float64, vstride, vorder int32, points []float64) { + C.gl4_2compat_glMap2d(gl.funcs, C.GLenum(target), C.GLdouble(u1), C.GLdouble(u2), C.GLint(ustride), C.GLint(uorder), C.GLdouble(v1), C.GLdouble(v2), C.GLint(vstride), C.GLint(vorder), (*C.GLdouble)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMap1f.xml +func (gl *GL) Map1f(target glbase.Enum, u1, u2 float32, stride, order int, points []float32) { + C.gl4_2compat_glMap1f(gl.funcs, C.GLenum(target), C.GLfloat(u1), C.GLfloat(u2), C.GLint(stride), C.GLint(order), (*C.GLfloat)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMap1d.xml +func (gl *GL) Map1d(target glbase.Enum, u1, u2 float64, stride, order int, points []float64) { + C.gl4_2compat_glMap1d(gl.funcs, C.GLenum(target), C.GLdouble(u1), C.GLdouble(u2), C.GLint(stride), C.GLint(order), (*C.GLdouble)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPushAttrib.xml +func (gl *GL) PushAttrib(mask glbase.Bitfield) { + C.gl4_2compat_glPushAttrib(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPopAttrib.xml +func (gl *GL) PopAttrib() { + C.gl4_2compat_glPopAttrib(gl.funcs) +} + +// Accum executes an operation on the accumulation buffer. +// +// Parameter op defines the accumulation buffer operation (GL.ACCUM, GL.LOAD, +// GL.ADD, GL.MULT, or GL.RETURN) and specifies how the value parameter is +// used. +// +// The accumulation buffer is an extended-range color buffer. Images are not +// rendered into it. Rather, images rendered into one of the color buffers +// are added to the contents of the accumulation buffer after rendering. +// Effects such as antialiasing (of points, lines, and polygons), motion +// blur, and depth of field can be created by accumulating images generated +// with different transformation matrices. +// +// Each pixel in the accumulation buffer consists of red, green, blue, and +// alpha values. The number of bits per component in the accumulation buffer +// depends on the implementation. You can examine this number by calling +// GetIntegerv four times, with arguments GL.ACCUM_RED_BITS, +// GL.ACCUM_GREEN_BITS, GL.ACCUM_BLUE_BITS, and GL.ACCUM_ALPHA_BITS. +// Regardless of the number of bits per component, the range of values stored +// by each component is (-1, 1). The accumulation buffer pixels are mapped +// one-to-one with frame buffer pixels. +// +// All accumulation buffer operations are limited to the area of the current +// scissor box and applied identically to the red, green, blue, and alpha +// components of each pixel. If a Accum operation results in a value outside +// the range (-1, 1), the contents of an accumulation buffer pixel component +// are undefined. +// +// The operations are as follows: +// +// GL.ACCUM +// Obtains R, G, B, and A values from the buffer currently selected for +// reading (see ReadBuffer). Each component value is divided by 2 n - +// 1 , where n is the number of bits allocated to each color component +// in the currently selected buffer. The result is a floating-point +// value in the range 0 1 , which is multiplied by value and added to +// the corresponding pixel component in the accumulation buffer, +// thereby updating the accumulation buffer. +// +// GL.LOAD +// Similar to GL.ACCUM, except that the current value in the +// accumulation buffer is not used in the calculation of the new value. +// That is, the R, G, B, and A values from the currently selected +// buffer are divided by 2 n - 1 , multiplied by value, and then stored +// in the corresponding accumulation buffer cell, overwriting the +// current value. +// +// GL.ADD +// Adds value to each R, G, B, and A in the accumulation buffer. +// +// GL.MULT +// Multiplies each R, G, B, and A in the accumulation buffer by value +// and returns the scaled component to its corresponding accumulation +// buffer location. +// +// GL.RETURN +// Transfers accumulation buffer values to the color buffer or buffers +// currently selected for writing. Each R, G, B, and A component is +// multiplied by value, then multiplied by 2 n - 1 , clamped to the +// range 0 2 n - 1 , and stored in the corresponding display buffer +// cell. The only fragment operations that are applied to this transfer +// are pixel ownership, scissor, dithering, and color writemasks. +// +// To clear the accumulation buffer, call ClearAccum with R, G, B, and A +// values to set it to, then call Clear with the accumulation buffer +// enabled. +// +// Error GL.INVALID_ENUM is generated if op is not an accepted value. +// GL.INVALID_OPERATION is generated if there is no accumulation buffer. +// GL.INVALID_OPERATION is generated if Accum is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) Accum(op glbase.Enum, value float32) { + C.gl4_2compat_glAccum(gl.funcs, C.GLenum(op), C.GLfloat(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexMask.xml +func (gl *GL) IndexMask(mask uint32) { + C.gl4_2compat_glIndexMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearIndex.xml +func (gl *GL) ClearIndex(c float32) { + C.gl4_2compat_glClearIndex(gl.funcs, C.GLfloat(c)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearAccum.xml +func (gl *GL) ClearAccum(red, green, blue, alpha float32) { + C.gl4_2compat_glClearAccum(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPushName.xml +func (gl *GL) PushName(name uint32) { + C.gl4_2compat_glPushName(gl.funcs, C.GLuint(name)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPopName.xml +func (gl *GL) PopName() { + C.gl4_2compat_glPopName(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPassThrough.xml +func (gl *GL) PassThrough(token float32) { + C.gl4_2compat_glPassThrough(gl.funcs, C.GLfloat(token)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLoadName.xml +func (gl *GL) LoadName(name uint32) { + C.gl4_2compat_glLoadName(gl.funcs, C.GLuint(name)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glInitNames.xml +func (gl *GL) InitNames() { + C.gl4_2compat_glInitNames(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRenderMode.xml +func (gl *GL) RenderMode(mode glbase.Enum) int32 { + glresult := C.gl4_2compat_glRenderMode(gl.funcs, C.GLenum(mode)) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSelectBuffer.xml +func (gl *GL) SelectBuffer(size int, buffer []glbase.Buffer) { + C.gl4_2compat_glSelectBuffer(gl.funcs, C.GLsizei(size), (*C.GLuint)(unsafe.Pointer(&buffer[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFeedbackBuffer.xml +func (gl *GL) FeedbackBuffer(size int, gltype glbase.Enum, buffer []float32) { + C.gl4_2compat_glFeedbackBuffer(gl.funcs, C.GLsizei(size), C.GLenum(gltype), (*C.GLfloat)(unsafe.Pointer(&buffer[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexGeniv.xml +func (gl *GL) TexGeniv(coord, pname glbase.Enum, params []int32) { + C.gl4_2compat_glTexGeniv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexGeni.xml +func (gl *GL) TexGeni(coord, pname glbase.Enum, param int32) { + C.gl4_2compat_glTexGeni(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexGenfv.xml +func (gl *GL) TexGenfv(coord, pname glbase.Enum, params []float32) { + C.gl4_2compat_glTexGenfv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexGenf.xml +func (gl *GL) TexGenf(coord, pname glbase.Enum, param float32) { + C.gl4_2compat_glTexGenf(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexGendv.xml +func (gl *GL) TexGendv(coord, pname glbase.Enum, params []float64) { + C.gl4_2compat_glTexGendv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexGend.xml +func (gl *GL) TexGend(coord, pname glbase.Enum, param float64) { + C.gl4_2compat_glTexGend(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLdouble(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexEnviv.xml +func (gl *GL) TexEnviv(target, pname glbase.Enum, params []int32) { + C.gl4_2compat_glTexEnviv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexEnvi.xml +func (gl *GL) TexEnvi(target, pname glbase.Enum, param int32) { + C.gl4_2compat_glTexEnvi(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexEnvfv.xml +func (gl *GL) TexEnvfv(target, pname glbase.Enum, params []float32) { + C.gl4_2compat_glTexEnvfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexEnvf.xml +func (gl *GL) TexEnvf(target, pname glbase.Enum, param float32) { + C.gl4_2compat_glTexEnvf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glShadeModel.xml +func (gl *GL) ShadeModel(mode glbase.Enum) { + C.gl4_2compat_glShadeModel(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPolygonStipple.xml +func (gl *GL) PolygonStipple(mask []uint8) { + C.gl4_2compat_glPolygonStipple(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&mask[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMaterialiv.xml +func (gl *GL) Materialiv(face, pname glbase.Enum, params []int32) { + C.gl4_2compat_glMaterialiv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMateriali.xml +func (gl *GL) Materiali(face, pname glbase.Enum, param int32) { + C.gl4_2compat_glMateriali(gl.funcs, C.GLenum(face), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMaterialfv.xml +func (gl *GL) Materialfv(face, pname glbase.Enum, params []float32) { + C.gl4_2compat_glMaterialfv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMaterialf.xml +func (gl *GL) Materialf(face, pname glbase.Enum, param float32) { + C.gl4_2compat_glMaterialf(gl.funcs, C.GLenum(face), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLineStipple.xml +func (gl *GL) LineStipple(factor int32, pattern uint16) { + C.gl4_2compat_glLineStipple(gl.funcs, C.GLint(factor), C.GLushort(pattern)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLightModeliv.xml +func (gl *GL) LightModeliv(pname glbase.Enum, params []int32) { + C.gl4_2compat_glLightModeliv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLightModeli.xml +func (gl *GL) LightModeli(pname glbase.Enum, param int32) { + C.gl4_2compat_glLightModeli(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLightModelfv.xml +func (gl *GL) LightModelfv(pname glbase.Enum, params []float32) { + C.gl4_2compat_glLightModelfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLightModelf.xml +func (gl *GL) LightModelf(pname glbase.Enum, param float32) { + C.gl4_2compat_glLightModelf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLightiv.xml +func (gl *GL) Lightiv(light, pname glbase.Enum, params []int32) { + C.gl4_2compat_glLightiv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLighti.xml +func (gl *GL) Lighti(light, pname glbase.Enum, param int32) { + C.gl4_2compat_glLighti(gl.funcs, C.GLenum(light), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLightfv.xml +func (gl *GL) Lightfv(light, pname glbase.Enum, params []float32) { + C.gl4_2compat_glLightfv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLightf.xml +func (gl *GL) Lightf(light, pname glbase.Enum, param float32) { + C.gl4_2compat_glLightf(gl.funcs, C.GLenum(light), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogiv.xml +func (gl *GL) Fogiv(pname glbase.Enum, params []int32) { + C.gl4_2compat_glFogiv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogi.xml +func (gl *GL) Fogi(pname glbase.Enum, param int32) { + C.gl4_2compat_glFogi(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogfv.xml +func (gl *GL) Fogfv(pname glbase.Enum, params []float32) { + C.gl4_2compat_glFogfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogf.xml +func (gl *GL) Fogf(pname glbase.Enum, param float32) { + C.gl4_2compat_glFogf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorMaterial.xml +func (gl *GL) ColorMaterial(face, mode glbase.Enum) { + C.gl4_2compat_glColorMaterial(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClipPlane.xml +func (gl *GL) ClipPlane(plane glbase.Enum, equation []float64) { + C.gl4_2compat_glClipPlane(gl.funcs, C.GLenum(plane), (*C.GLdouble)(unsafe.Pointer(&equation[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex4sv.xml +func (gl *GL) Vertex4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glVertex4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex4s.xml +func (gl *GL) Vertex4s(x, y, z, w int16) { + C.gl4_2compat_glVertex4s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex4iv.xml +func (gl *GL) Vertex4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glVertex4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex4i.xml +func (gl *GL) Vertex4i(x, y, z, w int) { + C.gl4_2compat_glVertex4i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex4fv.xml +func (gl *GL) Vertex4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glVertex4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex4f.xml +func (gl *GL) Vertex4f(x, y, z, w float32) { + C.gl4_2compat_glVertex4f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex4dv.xml +func (gl *GL) Vertex4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glVertex4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex4d.xml +func (gl *GL) Vertex4d(x, y, z, w float64) { + C.gl4_2compat_glVertex4d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex3sv.xml +func (gl *GL) Vertex3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glVertex3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex3s.xml +func (gl *GL) Vertex3s(x, y, z int16) { + C.gl4_2compat_glVertex3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex3iv.xml +func (gl *GL) Vertex3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glVertex3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex3i.xml +func (gl *GL) Vertex3i(x, y, z int) { + C.gl4_2compat_glVertex3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex3fv.xml +func (gl *GL) Vertex3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glVertex3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex3f.xml +func (gl *GL) Vertex3f(x, y, z float32) { + C.gl4_2compat_glVertex3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex3dv.xml +func (gl *GL) Vertex3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glVertex3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex3d.xml +func (gl *GL) Vertex3d(x, y, z float64) { + C.gl4_2compat_glVertex3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex2sv.xml +func (gl *GL) Vertex2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glVertex2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex2s.xml +func (gl *GL) Vertex2s(x, y int16) { + C.gl4_2compat_glVertex2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex2iv.xml +func (gl *GL) Vertex2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glVertex2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex2i.xml +func (gl *GL) Vertex2i(x, y int) { + C.gl4_2compat_glVertex2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex2fv.xml +func (gl *GL) Vertex2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glVertex2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex2f.xml +func (gl *GL) Vertex2f(x, y float32) { + C.gl4_2compat_glVertex2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex2dv.xml +func (gl *GL) Vertex2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glVertex2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex2d.xml +func (gl *GL) Vertex2d(x, y float64) { + C.gl4_2compat_glVertex2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord4sv.xml +func (gl *GL) TexCoord4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glTexCoord4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord4s.xml +func (gl *GL) TexCoord4s(s, t, r, q int16) { + C.gl4_2compat_glTexCoord4s(gl.funcs, C.GLshort(s), C.GLshort(t), C.GLshort(r), C.GLshort(q)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord4iv.xml +func (gl *GL) TexCoord4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glTexCoord4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord4i.xml +func (gl *GL) TexCoord4i(s, t, r, q int32) { + C.gl4_2compat_glTexCoord4i(gl.funcs, C.GLint(s), C.GLint(t), C.GLint(r), C.GLint(q)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord4fv.xml +func (gl *GL) TexCoord4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glTexCoord4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord4f.xml +func (gl *GL) TexCoord4f(s, t, r, q float32) { + C.gl4_2compat_glTexCoord4f(gl.funcs, C.GLfloat(s), C.GLfloat(t), C.GLfloat(r), C.GLfloat(q)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord4dv.xml +func (gl *GL) TexCoord4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glTexCoord4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord4d.xml +func (gl *GL) TexCoord4d(s, t, r, q float64) { + C.gl4_2compat_glTexCoord4d(gl.funcs, C.GLdouble(s), C.GLdouble(t), C.GLdouble(r), C.GLdouble(q)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord3sv.xml +func (gl *GL) TexCoord3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glTexCoord3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord3s.xml +func (gl *GL) TexCoord3s(s, t, r int16) { + C.gl4_2compat_glTexCoord3s(gl.funcs, C.GLshort(s), C.GLshort(t), C.GLshort(r)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord3iv.xml +func (gl *GL) TexCoord3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glTexCoord3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord3i.xml +func (gl *GL) TexCoord3i(s, t, r int32) { + C.gl4_2compat_glTexCoord3i(gl.funcs, C.GLint(s), C.GLint(t), C.GLint(r)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord3fv.xml +func (gl *GL) TexCoord3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glTexCoord3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord3f.xml +func (gl *GL) TexCoord3f(s, t, r float32) { + C.gl4_2compat_glTexCoord3f(gl.funcs, C.GLfloat(s), C.GLfloat(t), C.GLfloat(r)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord3dv.xml +func (gl *GL) TexCoord3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glTexCoord3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord3d.xml +func (gl *GL) TexCoord3d(s, t, r float64) { + C.gl4_2compat_glTexCoord3d(gl.funcs, C.GLdouble(s), C.GLdouble(t), C.GLdouble(r)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord2sv.xml +func (gl *GL) TexCoord2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glTexCoord2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord2s.xml +func (gl *GL) TexCoord2s(s, t int16) { + C.gl4_2compat_glTexCoord2s(gl.funcs, C.GLshort(s), C.GLshort(t)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord2iv.xml +func (gl *GL) TexCoord2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glTexCoord2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord2i.xml +func (gl *GL) TexCoord2i(s, t int32) { + C.gl4_2compat_glTexCoord2i(gl.funcs, C.GLint(s), C.GLint(t)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord2fv.xml +func (gl *GL) TexCoord2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glTexCoord2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord2f.xml +func (gl *GL) TexCoord2f(s, t float32) { + C.gl4_2compat_glTexCoord2f(gl.funcs, C.GLfloat(s), C.GLfloat(t)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord2dv.xml +func (gl *GL) TexCoord2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glTexCoord2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord2d.xml +func (gl *GL) TexCoord2d(s, t float64) { + C.gl4_2compat_glTexCoord2d(gl.funcs, C.GLdouble(s), C.GLdouble(t)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord1sv.xml +func (gl *GL) TexCoord1sv(v []int16) { + C.gl4_2compat_glTexCoord1sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord1s.xml +func (gl *GL) TexCoord1s(s int16) { + C.gl4_2compat_glTexCoord1s(gl.funcs, C.GLshort(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord1iv.xml +func (gl *GL) TexCoord1iv(v []int32) { + C.gl4_2compat_glTexCoord1iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord1i.xml +func (gl *GL) TexCoord1i(s int32) { + C.gl4_2compat_glTexCoord1i(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord1fv.xml +func (gl *GL) TexCoord1fv(v []float32) { + C.gl4_2compat_glTexCoord1fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord1f.xml +func (gl *GL) TexCoord1f(s float32) { + C.gl4_2compat_glTexCoord1f(gl.funcs, C.GLfloat(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord1dv.xml +func (gl *GL) TexCoord1dv(v []float64) { + C.gl4_2compat_glTexCoord1dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord1d.xml +func (gl *GL) TexCoord1d(s float64) { + C.gl4_2compat_glTexCoord1d(gl.funcs, C.GLdouble(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRectsv.xml +func (gl *GL) Rectsv(v1, v2 []int16) { + C.gl4_2compat_glRectsv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v1[0])), (*C.GLshort)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRects.xml +func (gl *GL) Rects(x1, y1, x2, y2 int16) { + C.gl4_2compat_glRects(gl.funcs, C.GLshort(x1), C.GLshort(y1), C.GLshort(x2), C.GLshort(y2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRectiv.xml +func (gl *GL) Rectiv(v1, v2 []int32) { + C.gl4_2compat_glRectiv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v1[0])), (*C.GLint)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRecti.xml +func (gl *GL) Recti(x1, y1, x2, y2 int32) { + C.gl4_2compat_glRecti(gl.funcs, C.GLint(x1), C.GLint(y1), C.GLint(x2), C.GLint(y2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRectfv.xml +func (gl *GL) Rectfv(v1, v2 []float32) { + C.gl4_2compat_glRectfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v1[0])), (*C.GLfloat)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRectf.xml +func (gl *GL) Rectf(x1, y1, x2, y2 float32) { + C.gl4_2compat_glRectf(gl.funcs, C.GLfloat(x1), C.GLfloat(y1), C.GLfloat(x2), C.GLfloat(y2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRectdv.xml +func (gl *GL) Rectdv(v1, v2 []float64) { + C.gl4_2compat_glRectdv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v1[0])), (*C.GLdouble)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRectd.xml +func (gl *GL) Rectd(x1, y1, x2, y2 float64) { + C.gl4_2compat_glRectd(gl.funcs, C.GLdouble(x1), C.GLdouble(y1), C.GLdouble(x2), C.GLdouble(y2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos4sv.xml +func (gl *GL) RasterPos4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glRasterPos4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos4s.xml +func (gl *GL) RasterPos4s(x, y, z, w int16) { + C.gl4_2compat_glRasterPos4s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos4iv.xml +func (gl *GL) RasterPos4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glRasterPos4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos4i.xml +func (gl *GL) RasterPos4i(x, y, z, w int) { + C.gl4_2compat_glRasterPos4i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos4fv.xml +func (gl *GL) RasterPos4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glRasterPos4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos4f.xml +func (gl *GL) RasterPos4f(x, y, z, w float32) { + C.gl4_2compat_glRasterPos4f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos4dv.xml +func (gl *GL) RasterPos4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glRasterPos4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos4d.xml +func (gl *GL) RasterPos4d(x, y, z, w float64) { + C.gl4_2compat_glRasterPos4d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos3sv.xml +func (gl *GL) RasterPos3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glRasterPos3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos3s.xml +func (gl *GL) RasterPos3s(x, y, z int16) { + C.gl4_2compat_glRasterPos3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos3iv.xml +func (gl *GL) RasterPos3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glRasterPos3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos3i.xml +func (gl *GL) RasterPos3i(x, y, z int) { + C.gl4_2compat_glRasterPos3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos3fv.xml +func (gl *GL) RasterPos3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glRasterPos3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos3f.xml +func (gl *GL) RasterPos3f(x, y, z float32) { + C.gl4_2compat_glRasterPos3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos3dv.xml +func (gl *GL) RasterPos3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glRasterPos3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos3d.xml +func (gl *GL) RasterPos3d(x, y, z float64) { + C.gl4_2compat_glRasterPos3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos2sv.xml +func (gl *GL) RasterPos2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glRasterPos2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos2s.xml +func (gl *GL) RasterPos2s(x, y int16) { + C.gl4_2compat_glRasterPos2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos2iv.xml +func (gl *GL) RasterPos2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glRasterPos2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos2i.xml +func (gl *GL) RasterPos2i(x, y int) { + C.gl4_2compat_glRasterPos2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos2fv.xml +func (gl *GL) RasterPos2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glRasterPos2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos2f.xml +func (gl *GL) RasterPos2f(x, y float32) { + C.gl4_2compat_glRasterPos2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos2dv.xml +func (gl *GL) RasterPos2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glRasterPos2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos2d.xml +func (gl *GL) RasterPos2d(x, y float64) { + C.gl4_2compat_glRasterPos2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3sv.xml +func (gl *GL) Normal3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glNormal3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3s.xml +func (gl *GL) Normal3s(nx, ny, nz int16) { + C.gl4_2compat_glNormal3s(gl.funcs, C.GLshort(nx), C.GLshort(ny), C.GLshort(nz)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3iv.xml +func (gl *GL) Normal3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glNormal3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3i.xml +func (gl *GL) Normal3i(nx, ny, nz int32) { + C.gl4_2compat_glNormal3i(gl.funcs, C.GLint(nx), C.GLint(ny), C.GLint(nz)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3fv.xml +func (gl *GL) Normal3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glNormal3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3f.xml +func (gl *GL) Normal3f(nx, ny, nz float32) { + C.gl4_2compat_glNormal3f(gl.funcs, C.GLfloat(nx), C.GLfloat(ny), C.GLfloat(nz)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3dv.xml +func (gl *GL) Normal3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glNormal3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3d.xml +func (gl *GL) Normal3d(nx, ny, nz float64) { + C.gl4_2compat_glNormal3d(gl.funcs, C.GLdouble(nx), C.GLdouble(ny), C.GLdouble(nz)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3bv.xml +func (gl *GL) Normal3bv(v []byte) { + C.gl4_2compat_glNormal3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3b.xml +func (gl *GL) Normal3b(nx, ny, nz byte) { + C.gl4_2compat_glNormal3b(gl.funcs, C.GLbyte(nx), C.GLbyte(ny), C.GLbyte(nz)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexsv.xml +func (gl *GL) Indexsv(c []int16) { + C.gl4_2compat_glIndexsv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexs.xml +func (gl *GL) Indexs(c int16) { + C.gl4_2compat_glIndexs(gl.funcs, C.GLshort(c)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexiv.xml +func (gl *GL) Indexiv(c []int32) { + C.gl4_2compat_glIndexiv(gl.funcs, (*C.GLint)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexi.xml +func (gl *GL) Indexi(c int32) { + C.gl4_2compat_glIndexi(gl.funcs, C.GLint(c)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexfv.xml +func (gl *GL) Indexfv(c []float32) { + C.gl4_2compat_glIndexfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexf.xml +func (gl *GL) Indexf(c float32) { + C.gl4_2compat_glIndexf(gl.funcs, C.GLfloat(c)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexdv.xml +func (gl *GL) Indexdv(c []float64) { + C.gl4_2compat_glIndexdv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexd.xml +func (gl *GL) Indexd(c float64) { + C.gl4_2compat_glIndexd(gl.funcs, C.GLdouble(c)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEnd.xml +func (gl *GL) End() { + C.gl4_2compat_glEnd(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEdgeFlagv.xml +func (gl *GL) EdgeFlagv(flag []bool) { + C.gl4_2compat_glEdgeFlagv(gl.funcs, (*C.GLboolean)(unsafe.Pointer(&flag[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEdgeFlag.xml +func (gl *GL) EdgeFlag(flag bool) { + C.gl4_2compat_glEdgeFlag(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4usv.xml +func (gl *GL) Color4usv(v []uint16) { + C.gl4_2compat_glColor4usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4us.xml +func (gl *GL) Color4us(red, green, blue, alpha uint16) { + C.gl4_2compat_glColor4us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue), C.GLushort(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4uiv.xml +func (gl *GL) Color4uiv(v []uint32) { + C.gl4_2compat_glColor4uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4ui.xml +func (gl *GL) Color4ui(red, green, blue, alpha uint32) { + C.gl4_2compat_glColor4ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue), C.GLuint(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4ubv.xml +func (gl *GL) Color4ubv(v []uint8) { + C.gl4_2compat_glColor4ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4ub.xml +func (gl *GL) Color4ub(red, green, blue, alpha uint8) { + C.gl4_2compat_glColor4ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue), C.GLubyte(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4sv.xml +func (gl *GL) Color4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glColor4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4s.xml +func (gl *GL) Color4s(red, green, blue, alpha int16) { + C.gl4_2compat_glColor4s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue), C.GLshort(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4iv.xml +func (gl *GL) Color4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glColor4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4i.xml +func (gl *GL) Color4i(red, green, blue, alpha int32) { + C.gl4_2compat_glColor4i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue), C.GLint(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4fv.xml +func (gl *GL) Color4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glColor4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4f.xml +func (gl *GL) Color4f(red, green, blue, alpha float32) { + C.gl4_2compat_glColor4f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4dv.xml +func (gl *GL) Color4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glColor4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4d.xml +func (gl *GL) Color4d(red, green, blue, alpha float64) { + C.gl4_2compat_glColor4d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue), C.GLdouble(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4bv.xml +func (gl *GL) Color4bv(v []byte) { + C.gl4_2compat_glColor4bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4b.xml +func (gl *GL) Color4b(red, green, blue, alpha byte) { + C.gl4_2compat_glColor4b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue), C.GLbyte(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3usv.xml +func (gl *GL) Color3usv(v []uint16) { + C.gl4_2compat_glColor3usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3us.xml +func (gl *GL) Color3us(red, green, blue uint16) { + C.gl4_2compat_glColor3us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3uiv.xml +func (gl *GL) Color3uiv(v []uint32) { + C.gl4_2compat_glColor3uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3ui.xml +func (gl *GL) Color3ui(red, green, blue uint32) { + C.gl4_2compat_glColor3ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3ubv.xml +func (gl *GL) Color3ubv(v []uint8) { + C.gl4_2compat_glColor3ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3ub.xml +func (gl *GL) Color3ub(red, green, blue uint8) { + C.gl4_2compat_glColor3ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3sv.xml +func (gl *GL) Color3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glColor3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3s.xml +func (gl *GL) Color3s(red, green, blue int16) { + C.gl4_2compat_glColor3s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3iv.xml +func (gl *GL) Color3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glColor3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3i.xml +func (gl *GL) Color3i(red, green, blue int32) { + C.gl4_2compat_glColor3i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3fv.xml +func (gl *GL) Color3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glColor3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3f.xml +func (gl *GL) Color3f(red, green, blue float32) { + C.gl4_2compat_glColor3f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3dv.xml +func (gl *GL) Color3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glColor3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3d.xml +func (gl *GL) Color3d(red, green, blue float64) { + C.gl4_2compat_glColor3d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3bv.xml +func (gl *GL) Color3bv(v []byte) { + C.gl4_2compat_glColor3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3b.xml +func (gl *GL) Color3b(red, green, blue byte) { + C.gl4_2compat_glColor3b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBitmap.xml +func (gl *GL) Bitmap(width, height int, xorig, yorig, xmove, ymove float32, bitmap []uint8) { + C.gl4_2compat_glBitmap(gl.funcs, C.GLsizei(width), C.GLsizei(height), C.GLfloat(xorig), C.GLfloat(yorig), C.GLfloat(xmove), C.GLfloat(ymove), (*C.GLubyte)(unsafe.Pointer(&bitmap[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBegin.xml +func (gl *GL) Begin(mode glbase.Enum) { + C.gl4_2compat_glBegin(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glListBase.xml +func (gl *GL) ListBase(base uint32) { + C.gl4_2compat_glListBase(gl.funcs, C.GLuint(base)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenLists.xml +func (gl *GL) GenLists(range_ int32) uint32 { + glresult := C.gl4_2compat_glGenLists(gl.funcs, C.GLsizei(range_)) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteLists.xml +func (gl *GL) DeleteLists(list uint32, range_ int32) { + C.gl4_2compat_glDeleteLists(gl.funcs, C.GLuint(list), C.GLsizei(range_)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCallLists.xml +func (gl *GL) CallLists(n int, gltype glbase.Enum, lists interface{}) { + var lists_ptr unsafe.Pointer + var lists_v = reflect.ValueOf(lists) + if lists != nil && lists_v.Kind() != reflect.Slice { + panic("parameter lists must be a slice") + } + if lists != nil { + lists_ptr = unsafe.Pointer(lists_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glCallLists(gl.funcs, C.GLsizei(n), C.GLenum(gltype), lists_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCallList.xml +func (gl *GL) CallList(list uint32) { + C.gl4_2compat_glCallList(gl.funcs, C.GLuint(list)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndList.xml +func (gl *GL) EndList() { + C.gl4_2compat_glEndList(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNewList.xml +func (gl *GL) NewList(list uint32, mode glbase.Enum) { + C.gl4_2compat_glNewList(gl.funcs, C.GLuint(list), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPushClientAttrib.xml +func (gl *GL) PushClientAttrib(mask glbase.Bitfield) { + C.gl4_2compat_glPushClientAttrib(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPopClientAttrib.xml +func (gl *GL) PopClientAttrib() { + C.gl4_2compat_glPopClientAttrib(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPrioritizeTextures.xml +func (gl *GL) PrioritizeTextures(n int, textures []glbase.Texture, priorities []float32) { + C.gl4_2compat_glPrioritizeTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0])), (*C.GLfloat)(unsafe.Pointer(&priorities[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glAreTexturesResident.xml +func (gl *GL) AreTexturesResident(n int, textures []glbase.Texture, residences []bool) bool { + glresult := C.gl4_2compat_glAreTexturesResident(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0])), (*C.GLboolean)(unsafe.Pointer(&residences[0]))) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexPointer.xml +func (gl *GL) VertexPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glVertexPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordPointer.xml +func (gl *GL) TexCoordPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glTexCoordPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormalPointer.xml +func (gl *GL) NormalPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glNormalPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glInterleavedArrays.xml +func (gl *GL) InterleavedArrays(format glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glInterleavedArrays(gl.funcs, C.GLenum(format), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexPointer.xml +func (gl *GL) IndexPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glIndexPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEnableClientState.xml +func (gl *GL) EnableClientState(array glbase.Enum) { + C.gl4_2compat_glEnableClientState(gl.funcs, C.GLenum(array)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEdgeFlagPointer.xml +func (gl *GL) EdgeFlagPointer(stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glEdgeFlagPointer(gl.funcs, C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDisableClientState.xml +func (gl *GL) DisableClientState(array glbase.Enum) { + C.gl4_2compat_glDisableClientState(gl.funcs, C.GLenum(array)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorPointer.xml +func (gl *GL) ColorPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glColorPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glArrayElement.xml +func (gl *GL) ArrayElement(i int32) { + C.gl4_2compat_glArrayElement(gl.funcs, C.GLint(i)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glResetMinmax.xml +func (gl *GL) ResetMinmax(target glbase.Enum) { + C.gl4_2compat_glResetMinmax(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glResetHistogram.xml +func (gl *GL) ResetHistogram(target glbase.Enum) { + C.gl4_2compat_glResetHistogram(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMinmax.xml +func (gl *GL) Minmax(target, internalFormat glbase.Enum, sink bool) { + C.gl4_2compat_glMinmax(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), *(*C.GLboolean)(unsafe.Pointer(&sink))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glHistogram.xml +func (gl *GL) Histogram(target glbase.Enum, width int, internalFormat glbase.Enum, sink bool) { + C.gl4_2compat_glHistogram(gl.funcs, C.GLenum(target), C.GLsizei(width), C.GLenum(internalFormat), *(*C.GLboolean)(unsafe.Pointer(&sink))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMinmaxParameteriv.xml +func (gl *GL) GetMinmaxParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_2compat_glGetMinmaxParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMinmaxParameterfv.xml +func (gl *GL) GetMinmaxParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_2compat_glGetMinmaxParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMinmax.xml +func (gl *GL) GetMinmax(target glbase.Enum, reset bool, format, gltype glbase.Enum, values interface{}) { + var values_ptr unsafe.Pointer + var values_v = reflect.ValueOf(values) + if values != nil && values_v.Kind() != reflect.Slice { + panic("parameter values must be a slice") + } + if values != nil { + values_ptr = unsafe.Pointer(values_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glGetMinmax(gl.funcs, C.GLenum(target), *(*C.GLboolean)(unsafe.Pointer(&reset)), C.GLenum(format), C.GLenum(gltype), values_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetHistogramParameteriv.xml +func (gl *GL) GetHistogramParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_2compat_glGetHistogramParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetHistogramParameterfv.xml +func (gl *GL) GetHistogramParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_2compat_glGetHistogramParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetHistogram.xml +func (gl *GL) GetHistogram(target glbase.Enum, reset bool, format, gltype glbase.Enum, values interface{}) { + var values_ptr unsafe.Pointer + var values_v = reflect.ValueOf(values) + if values != nil && values_v.Kind() != reflect.Slice { + panic("parameter values must be a slice") + } + if values != nil { + values_ptr = unsafe.Pointer(values_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glGetHistogram(gl.funcs, C.GLenum(target), *(*C.GLboolean)(unsafe.Pointer(&reset)), C.GLenum(format), C.GLenum(gltype), values_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSeparableFilter2D.xml +func (gl *GL) SeparableFilter2D(target, internalFormat glbase.Enum, width, height int, format, gltype glbase.Enum, row, column interface{}) { + var row_ptr unsafe.Pointer + var row_v = reflect.ValueOf(row) + if row != nil && row_v.Kind() != reflect.Slice { + panic("parameter row must be a slice") + } + if row != nil { + row_ptr = unsafe.Pointer(row_v.Index(0).Addr().Pointer()) + } + var column_ptr unsafe.Pointer + var column_v = reflect.ValueOf(column) + if column != nil && column_v.Kind() != reflect.Slice { + panic("parameter column must be a slice") + } + if column != nil { + column_ptr = unsafe.Pointer(column_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glSeparableFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), row_ptr, column_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSeparableFilter.xml +func (gl *GL) GetSeparableFilter(target, format, gltype glbase.Enum, row, column, span interface{}) { + var row_ptr unsafe.Pointer + var row_v = reflect.ValueOf(row) + if row != nil && row_v.Kind() != reflect.Slice { + panic("parameter row must be a slice") + } + if row != nil { + row_ptr = unsafe.Pointer(row_v.Index(0).Addr().Pointer()) + } + var column_ptr unsafe.Pointer + var column_v = reflect.ValueOf(column) + if column != nil && column_v.Kind() != reflect.Slice { + panic("parameter column must be a slice") + } + if column != nil { + column_ptr = unsafe.Pointer(column_v.Index(0).Addr().Pointer()) + } + var span_ptr unsafe.Pointer + var span_v = reflect.ValueOf(span) + if span != nil && span_v.Kind() != reflect.Slice { + panic("parameter span must be a slice") + } + if span != nil { + span_ptr = unsafe.Pointer(span_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glGetSeparableFilter(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), row_ptr, column_ptr, span_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetConvolutionParameteriv.xml +func (gl *GL) GetConvolutionParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_2compat_glGetConvolutionParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetConvolutionParameterfv.xml +func (gl *GL) GetConvolutionParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_2compat_glGetConvolutionParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetConvolutionFilter.xml +func (gl *GL) GetConvolutionFilter(target, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glGetConvolutionFilter(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyConvolutionFilter2D.xml +func (gl *GL) CopyConvolutionFilter2D(target, internalFormat glbase.Enum, x, y, width, height int) { + C.gl4_2compat_glCopyConvolutionFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyConvolutionFilter1D.xml +func (gl *GL) CopyConvolutionFilter1D(target, internalFormat glbase.Enum, x, y, width int) { + C.gl4_2compat_glCopyConvolutionFilter1D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glConvolutionParameteriv.xml +func (gl *GL) ConvolutionParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_2compat_glConvolutionParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glConvolutionParameteri.xml +func (gl *GL) ConvolutionParameteri(target, pname glbase.Enum, params int32) { + C.gl4_2compat_glConvolutionParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(params)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glConvolutionParameterfv.xml +func (gl *GL) ConvolutionParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_2compat_glConvolutionParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glConvolutionParameterf.xml +func (gl *GL) ConvolutionParameterf(target, pname glbase.Enum, params float32) { + C.gl4_2compat_glConvolutionParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(params)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glConvolutionFilter2D.xml +func (gl *GL) ConvolutionFilter2D(target, internalFormat glbase.Enum, width, height int, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glConvolutionFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glConvolutionFilter1D.xml +func (gl *GL) ConvolutionFilter1D(target, internalFormat glbase.Enum, width int, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glConvolutionFilter1D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyColorSubTable.xml +func (gl *GL) CopyColorSubTable(target glbase.Enum, start int32, x, y, width int) { + C.gl4_2compat_glCopyColorSubTable(gl.funcs, C.GLenum(target), C.GLsizei(start), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorSubTable.xml +func (gl *GL) ColorSubTable(target glbase.Enum, start int32, count int, format, gltype glbase.Enum, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glColorSubTable(gl.funcs, C.GLenum(target), C.GLsizei(start), C.GLsizei(count), C.GLenum(format), C.GLenum(gltype), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetColorTableParameteriv.xml +func (gl *GL) GetColorTableParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_2compat_glGetColorTableParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetColorTableParameterfv.xml +func (gl *GL) GetColorTableParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_2compat_glGetColorTableParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetColorTable.xml +func (gl *GL) GetColorTable(target, format, gltype glbase.Enum, table interface{}) { + var table_ptr unsafe.Pointer + var table_v = reflect.ValueOf(table) + if table != nil && table_v.Kind() != reflect.Slice { + panic("parameter table must be a slice") + } + if table != nil { + table_ptr = unsafe.Pointer(table_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glGetColorTable(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), table_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyColorTable.xml +func (gl *GL) CopyColorTable(target, internalFormat glbase.Enum, x, y, width int) { + C.gl4_2compat_glCopyColorTable(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorTableParameteriv.xml +func (gl *GL) ColorTableParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_2compat_glColorTableParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorTableParameterfv.xml +func (gl *GL) ColorTableParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_2compat_glColorTableParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorTable.xml +func (gl *GL) ColorTable(target, internalFormat glbase.Enum, width int, format, gltype glbase.Enum, table interface{}) { + var table_ptr unsafe.Pointer + var table_v = reflect.ValueOf(table) + if table != nil && table_v.Kind() != reflect.Slice { + panic("parameter table must be a slice") + } + if table != nil { + table_ptr = unsafe.Pointer(table_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glColorTable(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), table_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultTransposeMatrixd.xml +func (gl *GL) MultTransposeMatrixd(m []float64) { + C.gl4_2compat_glMultTransposeMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultTransposeMatrixf.xml +func (gl *GL) MultTransposeMatrixf(m []float32) { + C.gl4_2compat_glMultTransposeMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLoadTransposeMatrixd.xml +func (gl *GL) LoadTransposeMatrixd(m []float64) { + C.gl4_2compat_glLoadTransposeMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLoadTransposeMatrixf.xml +func (gl *GL) LoadTransposeMatrixf(m []float32) { + C.gl4_2compat_glLoadTransposeMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord4sv.xml +func (gl *GL) MultiTexCoord4sv(target glbase.Enum, v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glMultiTexCoord4sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord4s.xml +func (gl *GL) MultiTexCoord4s(target glbase.Enum, s, t, r, q int16) { + C.gl4_2compat_glMultiTexCoord4s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t), C.GLshort(r), C.GLshort(q)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord4iv.xml +func (gl *GL) MultiTexCoord4iv(target glbase.Enum, v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glMultiTexCoord4iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord4i.xml +func (gl *GL) MultiTexCoord4i(target glbase.Enum, s, t, r, q int32) { + C.gl4_2compat_glMultiTexCoord4i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t), C.GLint(r), C.GLint(q)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord4fv.xml +func (gl *GL) MultiTexCoord4fv(target glbase.Enum, v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glMultiTexCoord4fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord4f.xml +func (gl *GL) MultiTexCoord4f(target glbase.Enum, s, t, r, q float32) { + C.gl4_2compat_glMultiTexCoord4f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t), C.GLfloat(r), C.GLfloat(q)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord4dv.xml +func (gl *GL) MultiTexCoord4dv(target glbase.Enum, v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glMultiTexCoord4dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord4d.xml +func (gl *GL) MultiTexCoord4d(target glbase.Enum, s, t, r, q float64) { + C.gl4_2compat_glMultiTexCoord4d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t), C.GLdouble(r), C.GLdouble(q)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord3sv.xml +func (gl *GL) MultiTexCoord3sv(target glbase.Enum, v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glMultiTexCoord3sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord3s.xml +func (gl *GL) MultiTexCoord3s(target glbase.Enum, s, t, r int16) { + C.gl4_2compat_glMultiTexCoord3s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t), C.GLshort(r)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord3iv.xml +func (gl *GL) MultiTexCoord3iv(target glbase.Enum, v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glMultiTexCoord3iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord3i.xml +func (gl *GL) MultiTexCoord3i(target glbase.Enum, s, t, r int32) { + C.gl4_2compat_glMultiTexCoord3i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t), C.GLint(r)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord3fv.xml +func (gl *GL) MultiTexCoord3fv(target glbase.Enum, v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glMultiTexCoord3fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord3f.xml +func (gl *GL) MultiTexCoord3f(target glbase.Enum, s, t, r float32) { + C.gl4_2compat_glMultiTexCoord3f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t), C.GLfloat(r)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord3dv.xml +func (gl *GL) MultiTexCoord3dv(target glbase.Enum, v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glMultiTexCoord3dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord3d.xml +func (gl *GL) MultiTexCoord3d(target glbase.Enum, s, t, r float64) { + C.gl4_2compat_glMultiTexCoord3d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t), C.GLdouble(r)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord2sv.xml +func (gl *GL) MultiTexCoord2sv(target glbase.Enum, v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glMultiTexCoord2sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord2s.xml +func (gl *GL) MultiTexCoord2s(target glbase.Enum, s, t int16) { + C.gl4_2compat_glMultiTexCoord2s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord2iv.xml +func (gl *GL) MultiTexCoord2iv(target glbase.Enum, v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glMultiTexCoord2iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord2i.xml +func (gl *GL) MultiTexCoord2i(target glbase.Enum, s, t int32) { + C.gl4_2compat_glMultiTexCoord2i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord2fv.xml +func (gl *GL) MultiTexCoord2fv(target glbase.Enum, v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glMultiTexCoord2fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord2f.xml +func (gl *GL) MultiTexCoord2f(target glbase.Enum, s, t float32) { + C.gl4_2compat_glMultiTexCoord2f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord2dv.xml +func (gl *GL) MultiTexCoord2dv(target glbase.Enum, v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glMultiTexCoord2dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord2d.xml +func (gl *GL) MultiTexCoord2d(target glbase.Enum, s, t float64) { + C.gl4_2compat_glMultiTexCoord2d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord1sv.xml +func (gl *GL) MultiTexCoord1sv(target glbase.Enum, v []int16) { + C.gl4_2compat_glMultiTexCoord1sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord1s.xml +func (gl *GL) MultiTexCoord1s(target glbase.Enum, s int16) { + C.gl4_2compat_glMultiTexCoord1s(gl.funcs, C.GLenum(target), C.GLshort(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord1iv.xml +func (gl *GL) MultiTexCoord1iv(target glbase.Enum, v []int32) { + C.gl4_2compat_glMultiTexCoord1iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord1i.xml +func (gl *GL) MultiTexCoord1i(target glbase.Enum, s int32) { + C.gl4_2compat_glMultiTexCoord1i(gl.funcs, C.GLenum(target), C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord1fv.xml +func (gl *GL) MultiTexCoord1fv(target glbase.Enum, v []float32) { + C.gl4_2compat_glMultiTexCoord1fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord1f.xml +func (gl *GL) MultiTexCoord1f(target glbase.Enum, s float32) { + C.gl4_2compat_glMultiTexCoord1f(gl.funcs, C.GLenum(target), C.GLfloat(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord1dv.xml +func (gl *GL) MultiTexCoord1dv(target glbase.Enum, v []float64) { + C.gl4_2compat_glMultiTexCoord1dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord1d.xml +func (gl *GL) MultiTexCoord1d(target glbase.Enum, s float64) { + C.gl4_2compat_glMultiTexCoord1d(gl.funcs, C.GLenum(target), C.GLdouble(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClientActiveTexture.xml +func (gl *GL) ClientActiveTexture(texture glbase.Enum) { + C.gl4_2compat_glClientActiveTexture(gl.funcs, C.GLenum(texture)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos3sv.xml +func (gl *GL) WindowPos3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glWindowPos3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos3s.xml +func (gl *GL) WindowPos3s(x, y, z int16) { + C.gl4_2compat_glWindowPos3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos3iv.xml +func (gl *GL) WindowPos3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glWindowPos3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos3i.xml +func (gl *GL) WindowPos3i(x, y, z int) { + C.gl4_2compat_glWindowPos3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos3fv.xml +func (gl *GL) WindowPos3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glWindowPos3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos3f.xml +func (gl *GL) WindowPos3f(x, y, z float32) { + C.gl4_2compat_glWindowPos3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos3dv.xml +func (gl *GL) WindowPos3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glWindowPos3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos3d.xml +func (gl *GL) WindowPos3d(x, y, z float64) { + C.gl4_2compat_glWindowPos3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos2sv.xml +func (gl *GL) WindowPos2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glWindowPos2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos2s.xml +func (gl *GL) WindowPos2s(x, y int16) { + C.gl4_2compat_glWindowPos2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos2iv.xml +func (gl *GL) WindowPos2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glWindowPos2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos2i.xml +func (gl *GL) WindowPos2i(x, y int) { + C.gl4_2compat_glWindowPos2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos2fv.xml +func (gl *GL) WindowPos2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glWindowPos2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos2f.xml +func (gl *GL) WindowPos2f(x, y float32) { + C.gl4_2compat_glWindowPos2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos2dv.xml +func (gl *GL) WindowPos2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glWindowPos2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos2d.xml +func (gl *GL) WindowPos2d(x, y float64) { + C.gl4_2compat_glWindowPos2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColorPointer.xml +func (gl *GL) SecondaryColorPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glSecondaryColorPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3usv.xml +func (gl *GL) SecondaryColor3usv(v []uint16) { + C.gl4_2compat_glSecondaryColor3usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3us.xml +func (gl *GL) SecondaryColor3us(red, green, blue uint16) { + C.gl4_2compat_glSecondaryColor3us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3uiv.xml +func (gl *GL) SecondaryColor3uiv(v []uint32) { + C.gl4_2compat_glSecondaryColor3uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3ui.xml +func (gl *GL) SecondaryColor3ui(red, green, blue uint32) { + C.gl4_2compat_glSecondaryColor3ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3ubv.xml +func (gl *GL) SecondaryColor3ubv(v []uint8) { + C.gl4_2compat_glSecondaryColor3ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3ub.xml +func (gl *GL) SecondaryColor3ub(red, green, blue uint8) { + C.gl4_2compat_glSecondaryColor3ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3sv.xml +func (gl *GL) SecondaryColor3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glSecondaryColor3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3s.xml +func (gl *GL) SecondaryColor3s(red, green, blue int16) { + C.gl4_2compat_glSecondaryColor3s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3iv.xml +func (gl *GL) SecondaryColor3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glSecondaryColor3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3i.xml +func (gl *GL) SecondaryColor3i(red, green, blue int32) { + C.gl4_2compat_glSecondaryColor3i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3fv.xml +func (gl *GL) SecondaryColor3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glSecondaryColor3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3f.xml +func (gl *GL) SecondaryColor3f(red, green, blue float32) { + C.gl4_2compat_glSecondaryColor3f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3dv.xml +func (gl *GL) SecondaryColor3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glSecondaryColor3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3d.xml +func (gl *GL) SecondaryColor3d(red, green, blue float64) { + C.gl4_2compat_glSecondaryColor3d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3bv.xml +func (gl *GL) SecondaryColor3bv(v []byte) { + C.gl4_2compat_glSecondaryColor3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3b.xml +func (gl *GL) SecondaryColor3b(red, green, blue byte) { + C.gl4_2compat_glSecondaryColor3b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogCoordPointer.xml +func (gl *GL) FogCoordPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_2compat_glFogCoordPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogCoorddv.xml +func (gl *GL) FogCoorddv(coord []float64) { + C.gl4_2compat_glFogCoorddv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&coord[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogCoordd.xml +func (gl *GL) FogCoordd(coord float64) { + C.gl4_2compat_glFogCoordd(gl.funcs, C.GLdouble(coord)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogCoordfv.xml +func (gl *GL) FogCoordfv(coord []float32) { + C.gl4_2compat_glFogCoordfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&coord[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogCoordf.xml +func (gl *GL) FogCoordf(coord float32) { + C.gl4_2compat_glFogCoordf(gl.funcs, C.GLfloat(coord)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4usv.xml +func (gl *GL) VertexAttrib4usv(index glbase.Attrib, v []uint16) { + C.gl4_2compat_glVertexAttrib4usv(gl.funcs, C.GLuint(index), (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4uiv.xml +func (gl *GL) VertexAttrib4uiv(index glbase.Attrib, v []uint32) { + C.gl4_2compat_glVertexAttrib4uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4ubv.xml +func (gl *GL) VertexAttrib4ubv(index glbase.Attrib, v []uint8) { + C.gl4_2compat_glVertexAttrib4ubv(gl.funcs, C.GLuint(index), (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4sv.xml +func (gl *GL) VertexAttrib4sv(index glbase.Attrib, v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glVertexAttrib4sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4s.xml +func (gl *GL) VertexAttrib4s(index glbase.Attrib, x, y, z, w int16) { + C.gl4_2compat_glVertexAttrib4s(gl.funcs, C.GLuint(index), C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4iv.xml +func (gl *GL) VertexAttrib4iv(index glbase.Attrib, v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glVertexAttrib4iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4fv.xml +func (gl *GL) VertexAttrib4fv(index glbase.Attrib, v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glVertexAttrib4fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4f.xml +func (gl *GL) VertexAttrib4f(index glbase.Attrib, x, y, z, w float32) { + C.gl4_2compat_glVertexAttrib4f(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4dv.xml +func (gl *GL) VertexAttrib4dv(index glbase.Attrib, v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glVertexAttrib4dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4d.xml +func (gl *GL) VertexAttrib4d(index glbase.Attrib, x, y, z, w float64) { + C.gl4_2compat_glVertexAttrib4d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4bv.xml +func (gl *GL) VertexAttrib4bv(index glbase.Attrib, v []byte) { + C.gl4_2compat_glVertexAttrib4bv(gl.funcs, C.GLuint(index), (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4Nusv.xml +func (gl *GL) VertexAttrib4Nusv(index glbase.Attrib, v []uint16) { + C.gl4_2compat_glVertexAttrib4Nusv(gl.funcs, C.GLuint(index), (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4Nuiv.xml +func (gl *GL) VertexAttrib4Nuiv(index glbase.Attrib, v []uint32) { + C.gl4_2compat_glVertexAttrib4Nuiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4Nubv.xml +func (gl *GL) VertexAttrib4Nubv(index glbase.Attrib, v []uint8) { + C.gl4_2compat_glVertexAttrib4Nubv(gl.funcs, C.GLuint(index), (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4Nub.xml +func (gl *GL) VertexAttrib4Nub(index glbase.Attrib, x, y, z, w uint8) { + C.gl4_2compat_glVertexAttrib4Nub(gl.funcs, C.GLuint(index), C.GLubyte(x), C.GLubyte(y), C.GLubyte(z), C.GLubyte(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4Nsv.xml +func (gl *GL) VertexAttrib4Nsv(index glbase.Attrib, v []int16) { + C.gl4_2compat_glVertexAttrib4Nsv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4Niv.xml +func (gl *GL) VertexAttrib4Niv(index glbase.Attrib, v []int32) { + C.gl4_2compat_glVertexAttrib4Niv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4Nbv.xml +func (gl *GL) VertexAttrib4Nbv(index glbase.Attrib, v []byte) { + C.gl4_2compat_glVertexAttrib4Nbv(gl.funcs, C.GLuint(index), (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib3sv.xml +func (gl *GL) VertexAttrib3sv(index glbase.Attrib, v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glVertexAttrib3sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib3s.xml +func (gl *GL) VertexAttrib3s(index glbase.Attrib, x, y, z int16) { + C.gl4_2compat_glVertexAttrib3s(gl.funcs, C.GLuint(index), C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib3fv.xml +func (gl *GL) VertexAttrib3fv(index glbase.Attrib, v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glVertexAttrib3fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib3f.xml +func (gl *GL) VertexAttrib3f(index glbase.Attrib, x, y, z float32) { + C.gl4_2compat_glVertexAttrib3f(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib3dv.xml +func (gl *GL) VertexAttrib3dv(index glbase.Attrib, v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glVertexAttrib3dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib3d.xml +func (gl *GL) VertexAttrib3d(index glbase.Attrib, x, y, z float64) { + C.gl4_2compat_glVertexAttrib3d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib2sv.xml +func (gl *GL) VertexAttrib2sv(index glbase.Attrib, v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glVertexAttrib2sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib2s.xml +func (gl *GL) VertexAttrib2s(index glbase.Attrib, x, y int16) { + C.gl4_2compat_glVertexAttrib2s(gl.funcs, C.GLuint(index), C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib2fv.xml +func (gl *GL) VertexAttrib2fv(index glbase.Attrib, v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glVertexAttrib2fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib2f.xml +func (gl *GL) VertexAttrib2f(index glbase.Attrib, x, y float32) { + C.gl4_2compat_glVertexAttrib2f(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib2dv.xml +func (gl *GL) VertexAttrib2dv(index glbase.Attrib, v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glVertexAttrib2dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib2d.xml +func (gl *GL) VertexAttrib2d(index glbase.Attrib, x, y float64) { + C.gl4_2compat_glVertexAttrib2d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib1sv.xml +func (gl *GL) VertexAttrib1sv(index glbase.Attrib, v []int16) { + C.gl4_2compat_glVertexAttrib1sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib1s.xml +func (gl *GL) VertexAttrib1s(index glbase.Attrib, x int16) { + C.gl4_2compat_glVertexAttrib1s(gl.funcs, C.GLuint(index), C.GLshort(x)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib1fv.xml +func (gl *GL) VertexAttrib1fv(index glbase.Attrib, v []float32) { + C.gl4_2compat_glVertexAttrib1fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib1f.xml +func (gl *GL) VertexAttrib1f(index glbase.Attrib, x float32) { + C.gl4_2compat_glVertexAttrib1f(gl.funcs, C.GLuint(index), C.GLfloat(x)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib1dv.xml +func (gl *GL) VertexAttrib1dv(index glbase.Attrib, v []float64) { + C.gl4_2compat_glVertexAttrib1dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib1d.xml +func (gl *GL) VertexAttrib1d(index glbase.Attrib, x float64) { + C.gl4_2compat_glVertexAttrib1d(gl.funcs, C.GLuint(index), C.GLdouble(x)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI4usv.xml +func (gl *GL) VertexAttribI4usv(index glbase.Attrib, v []uint16) { + C.gl4_2compat_glVertexAttribI4usv(gl.funcs, C.GLuint(index), (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI4ubv.xml +func (gl *GL) VertexAttribI4ubv(index glbase.Attrib, v []uint8) { + C.gl4_2compat_glVertexAttribI4ubv(gl.funcs, C.GLuint(index), (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI4sv.xml +func (gl *GL) VertexAttribI4sv(index glbase.Attrib, v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glVertexAttribI4sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI4bv.xml +func (gl *GL) VertexAttribI4bv(index glbase.Attrib, v []byte) { + C.gl4_2compat_glVertexAttribI4bv(gl.funcs, C.GLuint(index), (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI4uiv.xml +func (gl *GL) VertexAttribI4uiv(index glbase.Attrib, v []uint32) { + C.gl4_2compat_glVertexAttribI4uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI3uiv.xml +func (gl *GL) VertexAttribI3uiv(index glbase.Attrib, v []uint32) { + C.gl4_2compat_glVertexAttribI3uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI2uiv.xml +func (gl *GL) VertexAttribI2uiv(index glbase.Attrib, v []uint32) { + C.gl4_2compat_glVertexAttribI2uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI1uiv.xml +func (gl *GL) VertexAttribI1uiv(index glbase.Attrib, v []uint32) { + C.gl4_2compat_glVertexAttribI1uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI4iv.xml +func (gl *GL) VertexAttribI4iv(index glbase.Attrib, v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glVertexAttribI4iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI3iv.xml +func (gl *GL) VertexAttribI3iv(index glbase.Attrib, v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glVertexAttribI3iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI2iv.xml +func (gl *GL) VertexAttribI2iv(index glbase.Attrib, v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_2compat_glVertexAttribI2iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI1iv.xml +func (gl *GL) VertexAttribI1iv(index glbase.Attrib, v []int32) { + C.gl4_2compat_glVertexAttribI1iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI4ui.xml +func (gl *GL) VertexAttribI4ui(index glbase.Attrib, x, y, z, w uint32) { + C.gl4_2compat_glVertexAttribI4ui(gl.funcs, C.GLuint(index), C.GLuint(x), C.GLuint(y), C.GLuint(z), C.GLuint(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI3ui.xml +func (gl *GL) VertexAttribI3ui(index glbase.Attrib, x, y, z uint32) { + C.gl4_2compat_glVertexAttribI3ui(gl.funcs, C.GLuint(index), C.GLuint(x), C.GLuint(y), C.GLuint(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI2ui.xml +func (gl *GL) VertexAttribI2ui(index glbase.Attrib, x, y uint32) { + C.gl4_2compat_glVertexAttribI2ui(gl.funcs, C.GLuint(index), C.GLuint(x), C.GLuint(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI1ui.xml +func (gl *GL) VertexAttribI1ui(index glbase.Attrib, x uint32) { + C.gl4_2compat_glVertexAttribI1ui(gl.funcs, C.GLuint(index), C.GLuint(x)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI4i.xml +func (gl *GL) VertexAttribI4i(index glbase.Attrib, x, y, z, w int) { + C.gl4_2compat_glVertexAttribI4i(gl.funcs, C.GLuint(index), C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI3i.xml +func (gl *GL) VertexAttribI3i(index glbase.Attrib, x, y, z int) { + C.gl4_2compat_glVertexAttribI3i(gl.funcs, C.GLuint(index), C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI2i.xml +func (gl *GL) VertexAttribI2i(index glbase.Attrib, x, y int) { + C.gl4_2compat_glVertexAttribI2i(gl.funcs, C.GLuint(index), C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI1i.xml +func (gl *GL) VertexAttribI1i(index glbase.Attrib, x int) { + C.gl4_2compat_glVertexAttribI1i(gl.funcs, C.GLuint(index), C.GLint(x)) +} diff --git a/gl/4.2core/funcs.cpp b/gl/4.2core/funcs.cpp new file mode 100644 index 00000000..567e39b3 --- /dev/null +++ b/gl/4.2core/funcs.cpp @@ -0,0 +1,2748 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#include +#include + +#include "funcs.h" + +void *gl4_2core_funcs() { + QOpenGLFunctions_4_2_Core* funcs = QOpenGLContext::currentContext()->versionFunctions(); + if (!funcs) { + return 0; + } + funcs->initializeOpenGLFunctions(); + return funcs; +} + + +void gl4_2core_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewport(x, y, width, height); +} + +void gl4_2core_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRange(nearVal, farVal); +} + +GLboolean gl4_2core_glIsEnabled(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabled(cap); +} + +void gl4_2core_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameteriv(target, level, pname, params); +} + +void gl4_2core_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameterfv(target, level, pname, params); +} + +void gl4_2core_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameteriv(target, pname, params); +} + +void gl4_2core_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterfv(target, pname, params); +} + +void gl4_2core_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexImage(target, level, format, gltype, pixels); +} + +void gl4_2core_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegerv(pname, params); +} + +void gl4_2core_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFloatv(pname, params); +} + +GLenum gl4_2core_glGetError(void *_glfuncs) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetError(); +} + +void gl4_2core_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetDoublev(pname, params); +} + +void gl4_2core_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleanv(pname, params); +} + +void gl4_2core_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadPixels(x, y, width, height, format, gltype, pixels); +} + +void gl4_2core_glReadBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadBuffer(mode); +} + +void gl4_2core_glPixelStorei(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStorei(pname, param); +} + +void gl4_2core_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStoref(pname, param); +} + +void gl4_2core_glDepthFunc(void *_glfuncs, GLenum glfunc) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthFunc(glfunc); +} + +void gl4_2core_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOp(fail, zfail, zpass); +} + +void gl4_2core_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFunc(glfunc, ref, mask); +} + +void gl4_2core_glLogicOp(void *_glfuncs, GLenum opcode) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLogicOp(opcode); +} + +void gl4_2core_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFunc(sfactor, dfactor); +} + +void gl4_2core_glFlush(void *_glfuncs) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlush(); +} + +void gl4_2core_glFinish(void *_glfuncs) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFinish(); +} + +void gl4_2core_glEnable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnable(cap); +} + +void gl4_2core_glDisable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisable(cap); +} + +void gl4_2core_glDepthMask(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthMask(flag); +} + +void gl4_2core_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMask(red, green, blue, alpha); +} + +void gl4_2core_glStencilMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMask(mask); +} + +void gl4_2core_glClearDepth(void *_glfuncs, GLdouble depth) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearDepth(depth); +} + +void gl4_2core_glClearStencil(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearStencil(s); +} + +void gl4_2core_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearColor(red, green, blue, alpha); +} + +void gl4_2core_glClear(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClear(mask); +} + +void gl4_2core_glDrawBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffer(mode); +} + +void gl4_2core_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage2D(target, level, internalFormat, width, height, border, format, gltype, pixels); +} + +void gl4_2core_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage1D(target, level, internalFormat, width, border, format, gltype, pixels); +} + +void gl4_2core_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteriv(target, pname, params); +} + +void gl4_2core_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteri(target, pname, param); +} + +void gl4_2core_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterfv(target, pname, params); +} + +void gl4_2core_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterf(target, pname, param); +} + +void gl4_2core_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissor(x, y, width, height); +} + +void gl4_2core_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonMode(face, mode); +} + +void gl4_2core_glPointSize(void *_glfuncs, GLfloat size) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointSize(size); +} + +void gl4_2core_glLineWidth(void *_glfuncs, GLfloat width) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineWidth(width); +} + +void gl4_2core_glHint(void *_glfuncs, GLenum target, GLenum mode) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glHint(target, mode); +} + +void gl4_2core_glFrontFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrontFace(mode); +} + +void gl4_2core_glCullFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCullFace(mode); +} + +void gl4_2core_glIndexubv(void *_glfuncs, const GLubyte* c) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexubv(c); +} + +void gl4_2core_glIndexub(void *_glfuncs, GLubyte c) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexub(c); +} + +GLboolean gl4_2core_glIsTexture(void *_glfuncs, GLuint texture) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsTexture(texture); +} + +void gl4_2core_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenTextures(n, textures); +} + +void gl4_2core_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteTextures(n, textures); +} + +void gl4_2core_glBindTexture(void *_glfuncs, GLenum target, GLuint texture) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindTexture(target, texture); +} + +void gl4_2core_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, gltype, pixels); +} + +void gl4_2core_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage1D(target, level, xoffset, width, format, gltype, pixels); +} + +void gl4_2core_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); +} + +void gl4_2core_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage1D(target, level, xoffset, x, y, width); +} + +void gl4_2core_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage2D(target, level, internalFormat, x, y, width, height, border); +} + +void gl4_2core_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage1D(target, level, internalFormat, x, y, width, border); +} + +void gl4_2core_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonOffset(factor, units); +} + +void gl4_2core_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElements(mode, count, gltype, indices); +} + +void gl4_2core_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArrays(mode, first, count); +} + +void gl4_2core_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); +} + +void gl4_2core_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, gltype, pixels); +} + +void gl4_2core_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage3D(target, level, internalFormat, width, height, depth, border, format, gltype, pixels); +} + +void gl4_2core_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawRangeElements(mode, start, end, count, gltype, indices); +} + +void gl4_2core_glBlendEquation(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquation(mode); +} + +void gl4_2core_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendColor(red, green, blue, alpha); +} + +void gl4_2core_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetCompressedTexImage(target, level, img); +} + +void gl4_2core_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data); +} + +void gl4_2core_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); +} + +void gl4_2core_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); +} + +void gl4_2core_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage1D(target, level, internalFormat, width, border, imageSize, data); +} + +void gl4_2core_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data); +} + +void gl4_2core_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage3D(target, level, internalFormat, width, height, depth, border, imageSize, data); +} + +void gl4_2core_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSampleCoverage(value, invert); +} + +void gl4_2core_glActiveTexture(void *_glfuncs, GLenum texture) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glActiveTexture(texture); +} + +void gl4_2core_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteriv(pname, params); +} + +void gl4_2core_glPointParameteri(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteri(pname, param); +} + +void gl4_2core_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterfv(pname, params); +} + +void gl4_2core_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterf(pname, param); +} + +void gl4_2core_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiDrawArrays(mode, first, count, drawcount); +} + +void gl4_2core_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); +} + +void gl4_2core_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferParameteriv(target, pname, params); +} + +GLboolean gl4_2core_glUnmapBuffer(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glUnmapBuffer(target); +} + +void gl4_2core_glGetBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferSubData(target, offset, size, data); +} + +void gl4_2core_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferSubData(target, offset, size, data); +} + +void gl4_2core_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferData(target, size, data, usage); +} + +GLboolean gl4_2core_glIsBuffer(void *_glfuncs, GLuint buffer) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsBuffer(buffer); +} + +void gl4_2core_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenBuffers(n, buffers); +} + +void gl4_2core_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteBuffers(n, buffers); +} + +void gl4_2core_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBuffer(target, buffer); +} + +void gl4_2core_glGetQueryObjectuiv(void *_glfuncs, GLuint id, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectuiv(id, pname, params); +} + +void gl4_2core_glGetQueryObjectiv(void *_glfuncs, GLuint id, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectiv(id, pname, params); +} + +void gl4_2core_glGetQueryiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryiv(target, pname, params); +} + +void gl4_2core_glEndQuery(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndQuery(target); +} + +void gl4_2core_glBeginQuery(void *_glfuncs, GLenum target, GLuint id) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginQuery(target, id); +} + +GLboolean gl4_2core_glIsQuery(void *_glfuncs, GLuint id) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsQuery(id); +} + +void gl4_2core_glDeleteQueries(void *_glfuncs, GLsizei n, const GLuint* ids) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteQueries(n, ids); +} + +void gl4_2core_glGenQueries(void *_glfuncs, GLsizei n, GLuint* ids) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenQueries(n, ids); +} + +void gl4_2core_glVertexAttribPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLboolean normalized, GLsizei stride, const GLvoid* offset) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribPointer(index, size, gltype, normalized, stride, offset); +} + +void gl4_2core_glValidateProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glValidateProgram(program); +} + +void gl4_2core_glUniformMatrix4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4fv(location, count, transpose, value); +} + +void gl4_2core_glUniformMatrix3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3fv(location, count, transpose, value); +} + +void gl4_2core_glUniformMatrix2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2fv(location, count, transpose, value); +} + +void gl4_2core_glUniform4iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4iv(location, count, value); +} + +void gl4_2core_glUniform3iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3iv(location, count, value); +} + +void gl4_2core_glUniform2iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2iv(location, count, value); +} + +void gl4_2core_glUniform1iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1iv(location, count, value); +} + +void gl4_2core_glUniform4fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4fv(location, count, value); +} + +void gl4_2core_glUniform3fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3fv(location, count, value); +} + +void gl4_2core_glUniform2fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2fv(location, count, value); +} + +void gl4_2core_glUniform1fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1fv(location, count, value); +} + +void gl4_2core_glUniform4i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4i(location, v0, v1, v2, v3); +} + +void gl4_2core_glUniform3i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3i(location, v0, v1, v2); +} + +void gl4_2core_glUniform2i(void *_glfuncs, GLint location, GLint v0, GLint v1) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2i(location, v0, v1); +} + +void gl4_2core_glUniform1i(void *_glfuncs, GLint location, GLint v0) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1i(location, v0); +} + +void gl4_2core_glUniform4f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4f(location, v0, v1, v2, v3); +} + +void gl4_2core_glUniform3f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3f(location, v0, v1, v2); +} + +void gl4_2core_glUniform2f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2f(location, v0, v1); +} + +void gl4_2core_glUniform1f(void *_glfuncs, GLint location, GLfloat v0) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1f(location, v0); +} + +void gl4_2core_glUseProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUseProgram(program); +} + +void gl4_2core_glShaderSource(void *_glfuncs, GLuint shader, GLsizei count, const GLchar** source, const GLint* length) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShaderSource(shader, count, source, length); +} + +void gl4_2core_glLinkProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLinkProgram(program); +} + +GLboolean gl4_2core_glIsShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsShader(shader); +} + +GLboolean gl4_2core_glIsProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsProgram(program); +} + +void gl4_2core_glGetVertexAttribiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribiv(index, pname, params); +} + +void gl4_2core_glGetVertexAttribfv(void *_glfuncs, GLuint index, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribfv(index, pname, params); +} + +void gl4_2core_glGetVertexAttribdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribdv(index, pname, params); +} + +void gl4_2core_glGetUniformiv(void *_glfuncs, GLuint program, GLint location, GLint* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformiv(program, location, params); +} + +void gl4_2core_glGetUniformfv(void *_glfuncs, GLuint program, GLint location, GLfloat* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformfv(program, location, params); +} + +GLint gl4_2core_glGetUniformLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetUniformLocation(program, name); +} + +void gl4_2core_glGetShaderSource(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderSource(shader, bufSize, length, source); +} + +void gl4_2core_glGetShaderInfoLog(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderInfoLog(shader, bufSize, length, infoLog); +} + +void gl4_2core_glGetShaderiv(void *_glfuncs, GLuint shader, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderiv(shader, pname, params); +} + +void gl4_2core_glGetProgramInfoLog(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramInfoLog(program, bufSize, length, infoLog); +} + +void gl4_2core_glGetProgramiv(void *_glfuncs, GLuint program, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramiv(program, pname, params); +} + +GLint gl4_2core_glGetAttribLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetAttribLocation(program, name); +} + +void gl4_2core_glGetAttachedShaders(void *_glfuncs, GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetAttachedShaders(program, maxCount, count, obj); +} + +void gl4_2core_glGetActiveUniform(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniform(program, index, bufSize, length, size, gltype, name); +} + +void gl4_2core_glGetActiveAttrib(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveAttrib(program, index, bufSize, length, size, gltype, name); +} + +void gl4_2core_glEnableVertexAttribArray(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnableVertexAttribArray(index); +} + +void gl4_2core_glDisableVertexAttribArray(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisableVertexAttribArray(index); +} + +void gl4_2core_glDetachShader(void *_glfuncs, GLuint program, GLuint shader) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDetachShader(program, shader); +} + +void gl4_2core_glDeleteShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteShader(shader); +} + +void gl4_2core_glDeleteProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteProgram(program); +} + +GLuint gl4_2core_glCreateShader(void *_glfuncs, GLenum gltype) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCreateShader(gltype); +} + +GLuint gl4_2core_glCreateProgram(void *_glfuncs) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCreateProgram(); +} + +void gl4_2core_glCompileShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompileShader(shader); +} + +void gl4_2core_glBindAttribLocation(void *_glfuncs, GLuint program, GLuint index, const GLchar* name) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindAttribLocation(program, index, name); +} + +void gl4_2core_glAttachShader(void *_glfuncs, GLuint program, GLuint shader) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAttachShader(program, shader); +} + +void gl4_2core_glStencilMaskSeparate(void *_glfuncs, GLenum face, GLuint mask) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMaskSeparate(face, mask); +} + +void gl4_2core_glStencilFuncSeparate(void *_glfuncs, GLenum face, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFuncSeparate(face, glfunc, ref, mask); +} + +void gl4_2core_glStencilOpSeparate(void *_glfuncs, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOpSeparate(face, sfail, dpfail, dppass); +} + +void gl4_2core_glDrawBuffers(void *_glfuncs, GLsizei n, const GLenum* bufs) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffers(n, bufs); +} + +void gl4_2core_glBlendEquationSeparate(void *_glfuncs, GLenum modeRGB, GLenum modeAlpha) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquationSeparate(modeRGB, modeAlpha); +} + +void gl4_2core_glUniformMatrix4x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x3fv(location, count, transpose, value); +} + +void gl4_2core_glUniformMatrix3x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x4fv(location, count, transpose, value); +} + +void gl4_2core_glUniformMatrix4x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x2fv(location, count, transpose, value); +} + +void gl4_2core_glUniformMatrix2x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x4fv(location, count, transpose, value); +} + +void gl4_2core_glUniformMatrix3x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x2fv(location, count, transpose, value); +} + +void gl4_2core_glUniformMatrix2x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x3fv(location, count, transpose, value); +} + +GLboolean gl4_2core_glIsVertexArray(void *_glfuncs, GLuint array) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsVertexArray(array); +} + +void gl4_2core_glGenVertexArrays(void *_glfuncs, GLsizei n, GLuint* arrays) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenVertexArrays(n, arrays); +} + +void gl4_2core_glDeleteVertexArrays(void *_glfuncs, GLsizei n, const GLuint* arrays) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteVertexArrays(n, arrays); +} + +void gl4_2core_glBindVertexArray(void *_glfuncs, GLuint array) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindVertexArray(array); +} + +void gl4_2core_glFlushMappedBufferRange(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr length) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlushMappedBufferRange(target, offset, length); +} + +void gl4_2core_glFramebufferTextureLayer(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTextureLayer(target, attachment, texture, level, layer); +} + +void gl4_2core_glRenderbufferStorageMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRenderbufferStorageMultisample(target, samples, internalFormat, width, height); +} + +void gl4_2core_glBlitFramebuffer(void *_glfuncs, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); +} + +void gl4_2core_glGenerateMipmap(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenerateMipmap(target); +} + +void gl4_2core_glGetFramebufferAttachmentParameteriv(void *_glfuncs, GLenum target, GLenum attachment, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFramebufferAttachmentParameteriv(target, attachment, pname, params); +} + +void gl4_2core_glFramebufferRenderbuffer(void *_glfuncs, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer); +} + +void gl4_2core_glFramebufferTexture3D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset); +} + +void gl4_2core_glFramebufferTexture2D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture2D(target, attachment, textarget, texture, level); +} + +void gl4_2core_glFramebufferTexture1D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture1D(target, attachment, textarget, texture, level); +} + +GLenum gl4_2core_glCheckFramebufferStatus(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCheckFramebufferStatus(target); +} + +void gl4_2core_glGenFramebuffers(void *_glfuncs, GLsizei n, GLuint* framebuffers) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenFramebuffers(n, framebuffers); +} + +void gl4_2core_glDeleteFramebuffers(void *_glfuncs, GLsizei n, const GLuint* framebuffers) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteFramebuffers(n, framebuffers); +} + +void gl4_2core_glBindFramebuffer(void *_glfuncs, GLenum target, GLuint framebuffer) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFramebuffer(target, framebuffer); +} + +GLboolean gl4_2core_glIsFramebuffer(void *_glfuncs, GLuint framebuffer) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsFramebuffer(framebuffer); +} + +void gl4_2core_glGetRenderbufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetRenderbufferParameteriv(target, pname, params); +} + +void gl4_2core_glRenderbufferStorage(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRenderbufferStorage(target, internalFormat, width, height); +} + +void gl4_2core_glGenRenderbuffers(void *_glfuncs, GLsizei n, GLuint* renderbuffers) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenRenderbuffers(n, renderbuffers); +} + +void gl4_2core_glDeleteRenderbuffers(void *_glfuncs, GLsizei n, const GLuint* renderbuffers) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteRenderbuffers(n, renderbuffers); +} + +void gl4_2core_glBindRenderbuffer(void *_glfuncs, GLenum target, GLuint renderbuffer) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindRenderbuffer(target, renderbuffer); +} + +GLboolean gl4_2core_glIsRenderbuffer(void *_glfuncs, GLuint renderbuffer) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsRenderbuffer(renderbuffer); +} + +void gl4_2core_glClearBufferfi(void *_glfuncs, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferfi(buffer, drawbuffer, depth, stencil); +} + +void gl4_2core_glClearBufferfv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferfv(buffer, drawbuffer, value); +} + +void gl4_2core_glClearBufferuiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLuint* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferuiv(buffer, drawbuffer, value); +} + +void gl4_2core_glClearBufferiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLint* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferiv(buffer, drawbuffer, value); +} + +void gl4_2core_glGetTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterIuiv(target, pname, params); +} + +void gl4_2core_glGetTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterIiv(target, pname, params); +} + +void gl4_2core_glTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, const GLuint* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterIuiv(target, pname, params); +} + +void gl4_2core_glTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterIiv(target, pname, params); +} + +void gl4_2core_glUniform4uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4uiv(location, count, value); +} + +void gl4_2core_glUniform3uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3uiv(location, count, value); +} + +void gl4_2core_glUniform2uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2uiv(location, count, value); +} + +void gl4_2core_glUniform1uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1uiv(location, count, value); +} + +void gl4_2core_glUniform4ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4ui(location, v0, v1, v2, v3); +} + +void gl4_2core_glUniform3ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3ui(location, v0, v1, v2); +} + +void gl4_2core_glUniform2ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2ui(location, v0, v1); +} + +void gl4_2core_glUniform1ui(void *_glfuncs, GLint location, GLuint v0) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1ui(location, v0); +} + +GLint gl4_2core_glGetFragDataLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetFragDataLocation(program, name); +} + +void gl4_2core_glBindFragDataLocation(void *_glfuncs, GLuint program, GLuint color, const GLchar* name) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFragDataLocation(program, color, name); +} + +void gl4_2core_glGetUniformuiv(void *_glfuncs, GLuint program, GLint location, GLuint* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformuiv(program, location, params); +} + +void gl4_2core_glGetVertexAttribIuiv(void *_glfuncs, GLuint index, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribIuiv(index, pname, params); +} + +void gl4_2core_glGetVertexAttribIiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribIiv(index, pname, params); +} + +void gl4_2core_glVertexAttribIPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribIPointer(index, size, gltype, stride, pointer); +} + +void gl4_2core_glEndConditionalRender(void *_glfuncs) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndConditionalRender(); +} + +void gl4_2core_glBeginConditionalRender(void *_glfuncs, GLuint id, GLenum mode) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginConditionalRender(id, mode); +} + +void gl4_2core_glClampColor(void *_glfuncs, GLenum target, GLenum clamp) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClampColor(target, clamp); +} + +void gl4_2core_glGetTransformFeedbackVarying(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTransformFeedbackVarying(program, index, bufSize, length, size, gltype, name); +} + +void gl4_2core_glBindBufferBase(void *_glfuncs, GLenum target, GLuint index, GLuint buffer) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBufferBase(target, index, buffer); +} + +void gl4_2core_glBindBufferRange(void *_glfuncs, GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBufferRange(target, index, buffer, offset, size); +} + +void gl4_2core_glEndTransformFeedback(void *_glfuncs) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndTransformFeedback(); +} + +void gl4_2core_glBeginTransformFeedback(void *_glfuncs, GLenum primitiveMode) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginTransformFeedback(primitiveMode); +} + +GLboolean gl4_2core_glIsEnabledi(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabledi(target, index); +} + +void gl4_2core_glDisablei(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisablei(target, index); +} + +void gl4_2core_glEnablei(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnablei(target, index); +} + +void gl4_2core_glGetIntegeri_v(void *_glfuncs, GLenum target, GLuint index, GLint* data) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegeri_v(target, index, data); +} + +void gl4_2core_glGetBooleani_v(void *_glfuncs, GLenum target, GLuint index, GLboolean* data) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleani_v(target, index, data); +} + +void gl4_2core_glColorMaski(void *_glfuncs, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMaski(index, r, g, b, a); +} + +void gl4_2core_glCopyBufferSubData(void *_glfuncs, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); +} + +void gl4_2core_glUniformBlockBinding(void *_glfuncs, GLuint program, GLuint v0, GLuint v1) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformBlockBinding(program, v0, v1); +} + +void gl4_2core_glGetActiveUniformBlockName(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName); +} + +void gl4_2core_glGetActiveUniformBlockiv(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params); +} + +GLuint gl4_2core_glGetUniformBlockIndex(void *_glfuncs, GLuint program, const GLchar* uniformBlockName) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetUniformBlockIndex(program, uniformBlockName); +} + +void gl4_2core_glGetActiveUniformName(void *_glfuncs, GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformName(program, uniformIndex, bufSize, length, uniformName); +} + +void gl4_2core_glGetActiveUniformsiv(void *_glfuncs, GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params); +} + +void gl4_2core_glPrimitiveRestartIndex(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPrimitiveRestartIndex(index); +} + +void gl4_2core_glTexBuffer(void *_glfuncs, GLenum target, GLenum internalFormat, GLuint buffer) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexBuffer(target, internalFormat, buffer); +} + +void gl4_2core_glDrawElementsInstanced(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsInstanced(mode, count, gltype, indices, instancecount); +} + +void gl4_2core_glDrawArraysInstanced(void *_glfuncs, GLenum mode, GLint first, GLsizei count, GLsizei instancecount) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArraysInstanced(mode, first, count, instancecount); +} + +void gl4_2core_glSampleMaski(void *_glfuncs, GLuint index, GLbitfield mask) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSampleMaski(index, mask); +} + +void gl4_2core_glGetMultisamplefv(void *_glfuncs, GLenum pname, GLuint index, GLfloat* val) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMultisamplefv(pname, index, val); +} + +void gl4_2core_glTexImage3DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage3DMultisample(target, samples, internalFormat, width, height, depth, fixedsamplelocations); +} + +void gl4_2core_glTexImage2DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage2DMultisample(target, samples, internalFormat, width, height, fixedsamplelocations); +} + +void gl4_2core_glGetSynciv(void *_glfuncs, GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSynciv(sync, pname, bufSize, length, values); +} + +void gl4_2core_glGetInteger64v(void *_glfuncs, GLenum pname, GLint64* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetInteger64v(pname, params); +} + +void gl4_2core_glWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWaitSync(sync, flags, timeout); +} + +GLenum gl4_2core_glClientWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glClientWaitSync(sync, flags, timeout); +} + +void gl4_2core_glDeleteSync(void *_glfuncs, GLsync sync) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteSync(sync); +} + +GLboolean gl4_2core_glIsSync(void *_glfuncs, GLsync sync) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsSync(sync); +} + +GLsync gl4_2core_glFenceSync(void *_glfuncs, GLenum condition, GLbitfield flags) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glFenceSync(condition, flags); +} + +void gl4_2core_glProvokingVertex(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProvokingVertex(mode); +} + +void gl4_2core_glDrawElementsInstancedBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLint basevertex) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsInstancedBaseVertex(mode, count, gltype, indices, instancecount, basevertex); +} + +void gl4_2core_glDrawRangeElementsBaseVertex(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawRangeElementsBaseVertex(mode, start, end, count, gltype, indices, basevertex); +} + +void gl4_2core_glDrawElementsBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsBaseVertex(mode, count, gltype, indices, basevertex); +} + +void gl4_2core_glFramebufferTexture(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture(target, attachment, texture, level); +} + +void gl4_2core_glGetBufferParameteri64v(void *_glfuncs, GLenum target, GLenum pname, GLint64* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferParameteri64v(target, pname, params); +} + +void gl4_2core_glGetInteger64i_v(void *_glfuncs, GLenum target, GLuint index, GLint64* data) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetInteger64i_v(target, index, data); +} + +void gl4_2core_glVertexAttribP4uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP4uiv(index, gltype, normalized, value); +} + +void gl4_2core_glVertexAttribP4ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP4ui(index, gltype, normalized, value); +} + +void gl4_2core_glVertexAttribP3uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP3uiv(index, gltype, normalized, value); +} + +void gl4_2core_glVertexAttribP3ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP3ui(index, gltype, normalized, value); +} + +void gl4_2core_glVertexAttribP2uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP2uiv(index, gltype, normalized, value); +} + +void gl4_2core_glVertexAttribP2ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP2ui(index, gltype, normalized, value); +} + +void gl4_2core_glVertexAttribP1uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP1uiv(index, gltype, normalized, value); +} + +void gl4_2core_glVertexAttribP1ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP1ui(index, gltype, normalized, value); +} + +void gl4_2core_glSecondaryColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColorP3uiv(gltype, color); +} + +void gl4_2core_glSecondaryColorP3ui(void *_glfuncs, GLenum gltype, GLuint color) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColorP3ui(gltype, color); +} + +void gl4_2core_glColorP4uiv(void *_glfuncs, GLenum gltype, const GLuint* color) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP4uiv(gltype, color); +} + +void gl4_2core_glColorP4ui(void *_glfuncs, GLenum gltype, GLuint color) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP4ui(gltype, color); +} + +void gl4_2core_glColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP3uiv(gltype, color); +} + +void gl4_2core_glColorP3ui(void *_glfuncs, GLenum gltype, GLuint color) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP3ui(gltype, color); +} + +void gl4_2core_glNormalP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormalP3uiv(gltype, coords); +} + +void gl4_2core_glNormalP3ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormalP3ui(gltype, coords); +} + +void gl4_2core_glMultiTexCoordP4uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP4uiv(texture, gltype, coords); +} + +void gl4_2core_glMultiTexCoordP4ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP4ui(texture, gltype, coords); +} + +void gl4_2core_glMultiTexCoordP3uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP3uiv(texture, gltype, coords); +} + +void gl4_2core_glMultiTexCoordP3ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP3ui(texture, gltype, coords); +} + +void gl4_2core_glMultiTexCoordP2uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP2uiv(texture, gltype, coords); +} + +void gl4_2core_glMultiTexCoordP2ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP2ui(texture, gltype, coords); +} + +void gl4_2core_glMultiTexCoordP1uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP1uiv(texture, gltype, coords); +} + +void gl4_2core_glMultiTexCoordP1ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP1ui(texture, gltype, coords); +} + +void gl4_2core_glTexCoordP4uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP4uiv(gltype, coords); +} + +void gl4_2core_glTexCoordP4ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP4ui(gltype, coords); +} + +void gl4_2core_glTexCoordP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP3uiv(gltype, coords); +} + +void gl4_2core_glTexCoordP3ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP3ui(gltype, coords); +} + +void gl4_2core_glTexCoordP2uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP2uiv(gltype, coords); +} + +void gl4_2core_glTexCoordP2ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP2ui(gltype, coords); +} + +void gl4_2core_glTexCoordP1uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP1uiv(gltype, coords); +} + +void gl4_2core_glTexCoordP1ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP1ui(gltype, coords); +} + +void gl4_2core_glVertexP4uiv(void *_glfuncs, GLenum gltype, const GLuint* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP4uiv(gltype, value); +} + +void gl4_2core_glVertexP4ui(void *_glfuncs, GLenum gltype, GLuint value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP4ui(gltype, value); +} + +void gl4_2core_glVertexP3uiv(void *_glfuncs, GLenum gltype, const GLuint* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP3uiv(gltype, value); +} + +void gl4_2core_glVertexP3ui(void *_glfuncs, GLenum gltype, GLuint value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP3ui(gltype, value); +} + +void gl4_2core_glVertexP2uiv(void *_glfuncs, GLenum gltype, const GLuint* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP2uiv(gltype, value); +} + +void gl4_2core_glVertexP2ui(void *_glfuncs, GLenum gltype, GLuint value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP2ui(gltype, value); +} + +void gl4_2core_glGetQueryObjectui64v(void *_glfuncs, GLuint id, GLenum pname, GLuint64* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectui64v(id, pname, params); +} + +void gl4_2core_glGetQueryObjecti64v(void *_glfuncs, GLuint id, GLenum pname, GLint64* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjecti64v(id, pname, params); +} + +void gl4_2core_glQueryCounter(void *_glfuncs, GLuint id, GLenum target) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glQueryCounter(id, target); +} + +void gl4_2core_glGetSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameterIuiv(sampler, pname, params); +} + +void gl4_2core_glGetSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameterfv(sampler, pname, params); +} + +void gl4_2core_glGetSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameterIiv(sampler, pname, params); +} + +void gl4_2core_glGetSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameteriv(sampler, pname, params); +} + +void gl4_2core_glSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLuint* param) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterIuiv(sampler, pname, param); +} + +void gl4_2core_glSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterIiv(sampler, pname, param); +} + +void gl4_2core_glSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, const GLfloat* param) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterfv(sampler, pname, param); +} + +void gl4_2core_glSamplerParameterf(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterf(sampler, pname, param); +} + +void gl4_2core_glSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameteriv(sampler, pname, param); +} + +void gl4_2core_glSamplerParameteri(void *_glfuncs, GLuint sampler, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameteri(sampler, pname, param); +} + +void gl4_2core_glBindSampler(void *_glfuncs, GLuint unit, GLuint sampler) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindSampler(unit, sampler); +} + +GLboolean gl4_2core_glIsSampler(void *_glfuncs, GLuint sampler) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsSampler(sampler); +} + +void gl4_2core_glDeleteSamplers(void *_glfuncs, GLsizei count, const GLuint* samplers) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteSamplers(count, samplers); +} + +void gl4_2core_glGenSamplers(void *_glfuncs, GLsizei count, GLuint* samplers) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenSamplers(count, samplers); +} + +GLint gl4_2core_glGetFragDataIndex(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetFragDataIndex(program, name); +} + +void gl4_2core_glBindFragDataLocationIndexed(void *_glfuncs, GLuint program, GLuint colorNumber, GLuint index, const GLchar* name) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFragDataLocationIndexed(program, colorNumber, index, name); +} + +void gl4_2core_glVertexAttribDivisor(void *_glfuncs, GLuint index, GLuint divisor) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribDivisor(index, divisor); +} + +void gl4_2core_glGetQueryIndexediv(void *_glfuncs, GLenum target, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryIndexediv(target, index, pname, params); +} + +void gl4_2core_glEndQueryIndexed(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndQueryIndexed(target, index); +} + +void gl4_2core_glBeginQueryIndexed(void *_glfuncs, GLenum target, GLuint index, GLuint id) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginQueryIndexed(target, index, id); +} + +void gl4_2core_glDrawTransformFeedbackStream(void *_glfuncs, GLenum mode, GLuint id, GLuint stream) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawTransformFeedbackStream(mode, id, stream); +} + +void gl4_2core_glDrawTransformFeedback(void *_glfuncs, GLenum mode, GLuint id) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawTransformFeedback(mode, id); +} + +void gl4_2core_glResumeTransformFeedback(void *_glfuncs) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glResumeTransformFeedback(); +} + +void gl4_2core_glPauseTransformFeedback(void *_glfuncs) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPauseTransformFeedback(); +} + +GLboolean gl4_2core_glIsTransformFeedback(void *_glfuncs, GLuint id) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsTransformFeedback(id); +} + +void gl4_2core_glGenTransformFeedbacks(void *_glfuncs, GLsizei n, GLuint* ids) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenTransformFeedbacks(n, ids); +} + +void gl4_2core_glDeleteTransformFeedbacks(void *_glfuncs, GLsizei n, const GLuint* ids) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteTransformFeedbacks(n, ids); +} + +void gl4_2core_glBindTransformFeedback(void *_glfuncs, GLenum target, GLuint id) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindTransformFeedback(target, id); +} + +void gl4_2core_glPatchParameterfv(void *_glfuncs, GLenum pname, const GLfloat* values) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPatchParameterfv(pname, values); +} + +void gl4_2core_glPatchParameteri(void *_glfuncs, GLenum pname, GLint value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPatchParameteri(pname, value); +} + +void gl4_2core_glGetProgramStageiv(void *_glfuncs, GLuint program, GLenum shadertype, GLenum pname, GLint* values) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramStageiv(program, shadertype, pname, values); +} + +void gl4_2core_glGetUniformSubroutineuiv(void *_glfuncs, GLenum shadertype, GLint location, GLuint* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformSubroutineuiv(shadertype, location, params); +} + +void gl4_2core_glUniformSubroutinesuiv(void *_glfuncs, GLenum shadertype, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformSubroutinesuiv(shadertype, count, value); +} + +void gl4_2core_glGetActiveSubroutineName(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveSubroutineName(program, shadertype, index, bufSize, length, name); +} + +void gl4_2core_glGetActiveSubroutineUniformName(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveSubroutineUniformName(program, shadertype, index, bufSize, length, name); +} + +void gl4_2core_glGetActiveSubroutineUniformiv(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint* values) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveSubroutineUniformiv(program, shadertype, index, pname, values); +} + +GLuint gl4_2core_glGetSubroutineIndex(void *_glfuncs, GLuint program, GLenum shadertype, const GLchar* name) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetSubroutineIndex(program, shadertype, name); +} + +GLint gl4_2core_glGetSubroutineUniformLocation(void *_glfuncs, GLuint program, GLenum shadertype, const GLchar* name) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetSubroutineUniformLocation(program, shadertype, name); +} + +void gl4_2core_glGetUniformdv(void *_glfuncs, GLuint program, GLint location, GLdouble* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformdv(program, location, params); +} + +void gl4_2core_glUniformMatrix4x3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x3dv(location, count, transpose, value); +} + +void gl4_2core_glUniformMatrix4x2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x2dv(location, count, transpose, value); +} + +void gl4_2core_glUniformMatrix3x4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x4dv(location, count, transpose, value); +} + +void gl4_2core_glUniformMatrix3x2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x2dv(location, count, transpose, value); +} + +void gl4_2core_glUniformMatrix2x4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x4dv(location, count, transpose, value); +} + +void gl4_2core_glUniformMatrix2x3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x3dv(location, count, transpose, value); +} + +void gl4_2core_glUniformMatrix4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4dv(location, count, transpose, value); +} + +void gl4_2core_glUniformMatrix3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3dv(location, count, transpose, value); +} + +void gl4_2core_glUniformMatrix2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2dv(location, count, transpose, value); +} + +void gl4_2core_glUniform4dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4dv(location, count, value); +} + +void gl4_2core_glUniform3dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3dv(location, count, value); +} + +void gl4_2core_glUniform2dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2dv(location, count, value); +} + +void gl4_2core_glUniform1dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1dv(location, count, value); +} + +void gl4_2core_glUniform4d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4d(location, v0, v1, v2, v3); +} + +void gl4_2core_glUniform3d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1, GLdouble v2) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3d(location, v0, v1, v2); +} + +void gl4_2core_glUniform2d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2d(location, v0, v1); +} + +void gl4_2core_glUniform1d(void *_glfuncs, GLint location, GLdouble v0) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1d(location, v0); +} + +void gl4_2core_glDrawElementsIndirect(void *_glfuncs, GLenum mode, GLenum gltype, const GLvoid* indirect) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsIndirect(mode, gltype, indirect); +} + +void gl4_2core_glDrawArraysIndirect(void *_glfuncs, GLenum mode, const GLvoid* indirect) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArraysIndirect(mode, indirect); +} + +void gl4_2core_glBlendFuncSeparatei(void *_glfuncs, GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha); +} + +void gl4_2core_glBlendFunci(void *_glfuncs, GLuint buf, GLenum src, GLenum dst) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFunci(buf, src, dst); +} + +void gl4_2core_glBlendEquationSeparatei(void *_glfuncs, GLuint buf, GLenum modeRGB, GLenum modeAlpha) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquationSeparatei(buf, modeRGB, modeAlpha); +} + +void gl4_2core_glBlendEquationi(void *_glfuncs, GLuint buf, GLenum mode) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquationi(buf, mode); +} + +void gl4_2core_glMinSampleShading(void *_glfuncs, GLfloat value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMinSampleShading(value); +} + +void gl4_2core_glGetDoublei_v(void *_glfuncs, GLenum target, GLuint index, GLdouble* data) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetDoublei_v(target, index, data); +} + +void gl4_2core_glGetFloati_v(void *_glfuncs, GLenum target, GLuint index, GLfloat* data) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFloati_v(target, index, data); +} + +void gl4_2core_glDepthRangeIndexed(void *_glfuncs, GLuint index, GLdouble n, GLdouble f) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRangeIndexed(index, n, f); +} + +void gl4_2core_glDepthRangeArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLdouble* v) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRangeArrayv(first, count, v); +} + +void gl4_2core_glScissorIndexedv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissorIndexedv(index, v); +} + +void gl4_2core_glScissorIndexed(void *_glfuncs, GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissorIndexed(index, left, bottom, width, height); +} + +void gl4_2core_glScissorArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLint* v) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissorArrayv(first, count, v); +} + +void gl4_2core_glViewportIndexedfv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewportIndexedfv(index, v); +} + +void gl4_2core_glViewportIndexedf(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewportIndexedf(index, x, y, w, h); +} + +void gl4_2core_glViewportArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLfloat* v) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewportArrayv(first, count, v); +} + +void gl4_2core_glGetVertexAttribLdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribLdv(index, pname, params); +} + +void gl4_2core_glVertexAttribLPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribLPointer(index, size, gltype, stride, pointer); +} + +void gl4_2core_glVertexAttribL4dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL4dv(index, v); +} + +void gl4_2core_glVertexAttribL3dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL3dv(index, v); +} + +void gl4_2core_glVertexAttribL2dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL2dv(index, v); +} + +void gl4_2core_glVertexAttribL1dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL1dv(index, v); +} + +void gl4_2core_glVertexAttribL4d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL4d(index, x, y, z, w); +} + +void gl4_2core_glVertexAttribL3d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL3d(index, x, y, z); +} + +void gl4_2core_glVertexAttribL2d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL2d(index, x, y); +} + +void gl4_2core_glVertexAttribL1d(void *_glfuncs, GLuint index, GLdouble x) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL1d(index, x); +} + +void gl4_2core_glGetProgramPipelineInfoLog(void *_glfuncs, GLuint pipeline, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog); +} + +void gl4_2core_glValidateProgramPipeline(void *_glfuncs, GLuint pipeline) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glValidateProgramPipeline(pipeline); +} + +void gl4_2core_glProgramUniformMatrix4x3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4x3dv(program, location, count, transpose, value); +} + +void gl4_2core_glProgramUniformMatrix3x4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3x4dv(program, location, count, transpose, value); +} + +void gl4_2core_glProgramUniformMatrix4x2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4x2dv(program, location, count, transpose, value); +} + +void gl4_2core_glProgramUniformMatrix2x4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2x4dv(program, location, count, transpose, value); +} + +void gl4_2core_glProgramUniformMatrix3x2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3x2dv(program, location, count, transpose, value); +} + +void gl4_2core_glProgramUniformMatrix2x3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2x3dv(program, location, count, transpose, value); +} + +void gl4_2core_glProgramUniformMatrix4x3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4x3fv(program, location, count, transpose, value); +} + +void gl4_2core_glProgramUniformMatrix3x4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3x4fv(program, location, count, transpose, value); +} + +void gl4_2core_glProgramUniformMatrix4x2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4x2fv(program, location, count, transpose, value); +} + +void gl4_2core_glProgramUniformMatrix2x4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2x4fv(program, location, count, transpose, value); +} + +void gl4_2core_glProgramUniformMatrix3x2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3x2fv(program, location, count, transpose, value); +} + +void gl4_2core_glProgramUniformMatrix2x3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2x3fv(program, location, count, transpose, value); +} + +void gl4_2core_glProgramUniformMatrix4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4dv(program, location, count, transpose, value); +} + +void gl4_2core_glProgramUniformMatrix3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3dv(program, location, count, transpose, value); +} + +void gl4_2core_glProgramUniformMatrix2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2dv(program, location, count, transpose, value); +} + +void gl4_2core_glProgramUniformMatrix4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4fv(program, location, count, transpose, value); +} + +void gl4_2core_glProgramUniformMatrix3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3fv(program, location, count, transpose, value); +} + +void gl4_2core_glProgramUniformMatrix2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2fv(program, location, count, transpose, value); +} + +void gl4_2core_glProgramUniform4uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4uiv(program, location, count, value); +} + +void gl4_2core_glProgramUniform4ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4ui(program, location, v0, v1, v2, v3); +} + +void gl4_2core_glProgramUniform4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4dv(program, location, count, value); +} + +void gl4_2core_glProgramUniform4d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4d(program, location, v0, v1, v2, v3); +} + +void gl4_2core_glProgramUniform4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4fv(program, location, count, value); +} + +void gl4_2core_glProgramUniform4f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4f(program, location, v0, v1, v2, v3); +} + +void gl4_2core_glProgramUniform4iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4iv(program, location, count, value); +} + +void gl4_2core_glProgramUniform4i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4i(program, location, v0, v1, v2, v3); +} + +void gl4_2core_glProgramUniform3uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3uiv(program, location, count, value); +} + +void gl4_2core_glProgramUniform3ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3ui(program, location, v0, v1, v2); +} + +void gl4_2core_glProgramUniform3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3dv(program, location, count, value); +} + +void gl4_2core_glProgramUniform3d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3d(program, location, v0, v1, v2); +} + +void gl4_2core_glProgramUniform3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3fv(program, location, count, value); +} + +void gl4_2core_glProgramUniform3f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3f(program, location, v0, v1, v2); +} + +void gl4_2core_glProgramUniform3iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3iv(program, location, count, value); +} + +void gl4_2core_glProgramUniform3i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1, GLint v2) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3i(program, location, v0, v1, v2); +} + +void gl4_2core_glProgramUniform2uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2uiv(program, location, count, value); +} + +void gl4_2core_glProgramUniform2ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2ui(program, location, v0, v1); +} + +void gl4_2core_glProgramUniform2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2dv(program, location, count, value); +} + +void gl4_2core_glProgramUniform2d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2d(program, location, v0, v1); +} + +void gl4_2core_glProgramUniform2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2fv(program, location, count, value); +} + +void gl4_2core_glProgramUniform2f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2f(program, location, v0, v1); +} + +void gl4_2core_glProgramUniform2iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2iv(program, location, count, value); +} + +void gl4_2core_glProgramUniform2i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2i(program, location, v0, v1); +} + +void gl4_2core_glProgramUniform1uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1uiv(program, location, count, value); +} + +void gl4_2core_glProgramUniform1ui(void *_glfuncs, GLuint program, GLint location, GLuint v0) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1ui(program, location, v0); +} + +void gl4_2core_glProgramUniform1dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1dv(program, location, count, value); +} + +void gl4_2core_glProgramUniform1d(void *_glfuncs, GLuint program, GLint location, GLdouble v0) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1d(program, location, v0); +} + +void gl4_2core_glProgramUniform1fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1fv(program, location, count, value); +} + +void gl4_2core_glProgramUniform1f(void *_glfuncs, GLuint program, GLint location, GLfloat v0) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1f(program, location, v0); +} + +void gl4_2core_glProgramUniform1iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1iv(program, location, count, value); +} + +void gl4_2core_glProgramUniform1i(void *_glfuncs, GLuint program, GLint location, GLint v0) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1i(program, location, v0); +} + +void gl4_2core_glGetProgramPipelineiv(void *_glfuncs, GLuint pipeline, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramPipelineiv(pipeline, pname, params); +} + +GLboolean gl4_2core_glIsProgramPipeline(void *_glfuncs, GLuint pipeline) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsProgramPipeline(pipeline); +} + +void gl4_2core_glGenProgramPipelines(void *_glfuncs, GLsizei n, GLuint* pipelines) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenProgramPipelines(n, pipelines); +} + +void gl4_2core_glDeleteProgramPipelines(void *_glfuncs, GLsizei n, const GLuint* pipelines) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteProgramPipelines(n, pipelines); +} + +void gl4_2core_glBindProgramPipeline(void *_glfuncs, GLuint pipeline) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindProgramPipeline(pipeline); +} + +void gl4_2core_glActiveShaderProgram(void *_glfuncs, GLuint pipeline, GLuint program) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glActiveShaderProgram(pipeline, program); +} + +void gl4_2core_glUseProgramStages(void *_glfuncs, GLuint pipeline, GLbitfield stages, GLuint program) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUseProgramStages(pipeline, stages, program); +} + +void gl4_2core_glProgramParameteri(void *_glfuncs, GLuint program, GLenum pname, GLint value) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramParameteri(program, pname, value); +} + +void gl4_2core_glProgramBinary(void *_glfuncs, GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramBinary(program, binaryFormat, binary, length); +} + +void gl4_2core_glGetProgramBinary(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramBinary(program, bufSize, length, binaryFormat, binary); +} + +void gl4_2core_glClearDepthf(void *_glfuncs, GLfloat dd) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearDepthf(dd); +} + +void gl4_2core_glDepthRangef(void *_glfuncs, GLfloat n, GLfloat f) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRangef(n, f); +} + +void gl4_2core_glGetShaderPrecisionFormat(void *_glfuncs, GLenum shadertype, GLenum precisionType, GLint* range_, GLint* precision) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderPrecisionFormat(shadertype, precisionType, range_, precision); +} + +void gl4_2core_glShaderBinary(void *_glfuncs, GLsizei count, const GLuint* shaders, GLenum binaryFormat, const GLvoid* binary, GLsizei length) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShaderBinary(count, shaders, binaryFormat, binary, length); +} + +void gl4_2core_glReleaseShaderCompiler(void *_glfuncs) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReleaseShaderCompiler(); +} + +void gl4_2core_glTexStorage3D(void *_glfuncs, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexStorage3D(target, levels, internalFormat, width, height, depth); +} + +void gl4_2core_glTexStorage2D(void *_glfuncs, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexStorage2D(target, levels, internalFormat, width, height); +} + +void gl4_2core_glTexStorage1D(void *_glfuncs, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexStorage1D(target, levels, internalFormat, width); +} + +void gl4_2core_glMemoryBarrier(void *_glfuncs, GLbitfield barriers) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMemoryBarrier(barriers); +} + +void gl4_2core_glBindImageTexture(void *_glfuncs, GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindImageTexture(unit, texture, level, layered, layer, access, format); +} + +void gl4_2core_glGetActiveAtomicCounterBufferiv(void *_glfuncs, GLuint program, GLuint bufferIndex, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params); +} + +void gl4_2core_glGetInternalformativ(void *_glfuncs, GLenum target, GLenum internalFormat, GLenum pname, GLsizei bufSize, GLint* params) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetInternalformativ(target, internalFormat, pname, bufSize, params); +} + +void gl4_2core_glDrawTransformFeedbackStreamInstanced(void *_glfuncs, GLenum mode, GLuint id, GLuint stream, GLsizei instancecount) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount); +} + +void gl4_2core_glDrawTransformFeedbackInstanced(void *_glfuncs, GLenum mode, GLuint id, GLsizei instancecount) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawTransformFeedbackInstanced(mode, id, instancecount); +} + +void gl4_2core_glDrawElementsInstancedBaseVertexBaseInstance(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsInstancedBaseVertexBaseInstance(mode, count, gltype, indices, instancecount, basevertex, baseinstance); +} + +void gl4_2core_glDrawElementsInstancedBaseInstance(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLuint baseinstance) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsInstancedBaseInstance(mode, count, gltype, indices, instancecount, baseinstance); +} + +void gl4_2core_glDrawArraysInstancedBaseInstance(void *_glfuncs, GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance) +{ + QOpenGLFunctions_4_2_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance); +} + diff --git a/gl/4.2core/funcs.h b/gl/4.2core/funcs.h new file mode 100644 index 00000000..969f03fd --- /dev/null +++ b/gl/4.2core/funcs.h @@ -0,0 +1,497 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#ifndef __cplusplus +#include +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef char GLchar; +typedef signed char GLbyte; /* 1-byte signed */ +typedef short GLshort; /* 2-byte signed */ +typedef int GLint; /* 4-byte signed */ +typedef unsigned char GLubyte; /* 1-byte unsigned */ +typedef unsigned short GLushort; /* 2-byte unsigned */ +typedef unsigned int GLuint; /* 4-byte unsigned */ +typedef int GLsizei; /* 4-byte signed */ +typedef float GLfloat; /* single precision float */ +typedef float GLclampf; /* single precision float in [0,1] */ +typedef double GLdouble; /* double precision float */ +typedef double GLclampd; /* double precision float in [0,1] */ +typedef int64_t GLint64; +typedef uint64_t GLuint64; +typedef ptrdiff_t GLintptr; +typedef ptrdiff_t GLsizeiptr; +typedef ptrdiff_t GLintptrARB; +typedef ptrdiff_t GLsizeiptrARB; +typedef struct __GLsync *GLsync; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +void *gl4_2core_funcs(); + +void gl4_2core_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_2core_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal); +GLboolean gl4_2core_glIsEnabled(void *_glfuncs, GLenum cap); +void gl4_2core_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params); +void gl4_2core_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params); +void gl4_2core_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_2core_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl4_2core_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels); +void gl4_2core_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params); +void gl4_2core_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params); +GLenum gl4_2core_glGetError(void *_glfuncs); +void gl4_2core_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params); +void gl4_2core_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params); +void gl4_2core_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels); +void gl4_2core_glReadBuffer(void *_glfuncs, GLenum mode); +void gl4_2core_glPixelStorei(void *_glfuncs, GLenum pname, GLint param); +void gl4_2core_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param); +void gl4_2core_glDepthFunc(void *_glfuncs, GLenum glfunc); +void gl4_2core_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass); +void gl4_2core_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask); +void gl4_2core_glLogicOp(void *_glfuncs, GLenum opcode); +void gl4_2core_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor); +void gl4_2core_glFlush(void *_glfuncs); +void gl4_2core_glFinish(void *_glfuncs); +void gl4_2core_glEnable(void *_glfuncs, GLenum cap); +void gl4_2core_glDisable(void *_glfuncs, GLenum cap); +void gl4_2core_glDepthMask(void *_glfuncs, GLboolean flag); +void gl4_2core_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +void gl4_2core_glStencilMask(void *_glfuncs, GLuint mask); +void gl4_2core_glClearDepth(void *_glfuncs, GLdouble depth); +void gl4_2core_glClearStencil(void *_glfuncs, GLint s); +void gl4_2core_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl4_2core_glClear(void *_glfuncs, GLbitfield mask); +void gl4_2core_glDrawBuffer(void *_glfuncs, GLenum mode); +void gl4_2core_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_2core_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_2core_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl4_2core_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl4_2core_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl4_2core_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl4_2core_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_2core_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode); +void gl4_2core_glPointSize(void *_glfuncs, GLfloat size); +void gl4_2core_glLineWidth(void *_glfuncs, GLfloat width); +void gl4_2core_glHint(void *_glfuncs, GLenum target, GLenum mode); +void gl4_2core_glFrontFace(void *_glfuncs, GLenum mode); +void gl4_2core_glCullFace(void *_glfuncs, GLenum mode); +void gl4_2core_glIndexubv(void *_glfuncs, const GLubyte* c); +void gl4_2core_glIndexub(void *_glfuncs, GLubyte c); +GLboolean gl4_2core_glIsTexture(void *_glfuncs, GLuint texture); +void gl4_2core_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures); +void gl4_2core_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures); +void gl4_2core_glBindTexture(void *_glfuncs, GLenum target, GLuint texture); +void gl4_2core_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_2core_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_2core_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_2core_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +void gl4_2core_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +void gl4_2core_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border); +void gl4_2core_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units); +void gl4_2core_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl4_2core_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count); +void gl4_2core_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_2core_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_2core_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_2core_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl4_2core_glBlendEquation(void *_glfuncs, GLenum mode); +void gl4_2core_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl4_2core_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img); +void gl4_2core_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl4_2core_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl4_2core_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl4_2core_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data); +void gl4_2core_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data); +void gl4_2core_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data); +void gl4_2core_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert); +void gl4_2core_glActiveTexture(void *_glfuncs, GLenum texture); +void gl4_2core_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params); +void gl4_2core_glPointParameteri(void *_glfuncs, GLenum pname, GLint param); +void gl4_2core_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl4_2core_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param); +void gl4_2core_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount); +void gl4_2core_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +void gl4_2core_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +GLboolean gl4_2core_glUnmapBuffer(void *_glfuncs, GLenum target); +void gl4_2core_glGetBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data); +void gl4_2core_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data); +void gl4_2core_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage); +GLboolean gl4_2core_glIsBuffer(void *_glfuncs, GLuint buffer); +void gl4_2core_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers); +void gl4_2core_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers); +void gl4_2core_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer); +void gl4_2core_glGetQueryObjectuiv(void *_glfuncs, GLuint id, GLenum pname, GLuint* params); +void gl4_2core_glGetQueryObjectiv(void *_glfuncs, GLuint id, GLenum pname, GLint* params); +void gl4_2core_glGetQueryiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_2core_glEndQuery(void *_glfuncs, GLenum target); +void gl4_2core_glBeginQuery(void *_glfuncs, GLenum target, GLuint id); +GLboolean gl4_2core_glIsQuery(void *_glfuncs, GLuint id); +void gl4_2core_glDeleteQueries(void *_glfuncs, GLsizei n, const GLuint* ids); +void gl4_2core_glGenQueries(void *_glfuncs, GLsizei n, GLuint* ids); +void gl4_2core_glVertexAttribPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLboolean normalized, GLsizei stride, const GLvoid* offset); +void gl4_2core_glValidateProgram(void *_glfuncs, GLuint program); +void gl4_2core_glUniformMatrix4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_2core_glUniformMatrix3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_2core_glUniformMatrix2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_2core_glUniform4iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl4_2core_glUniform3iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl4_2core_glUniform2iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl4_2core_glUniform1iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl4_2core_glUniform4fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl4_2core_glUniform3fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl4_2core_glUniform2fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl4_2core_glUniform1fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl4_2core_glUniform4i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +void gl4_2core_glUniform3i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2); +void gl4_2core_glUniform2i(void *_glfuncs, GLint location, GLint v0, GLint v1); +void gl4_2core_glUniform1i(void *_glfuncs, GLint location, GLint v0); +void gl4_2core_glUniform4f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +void gl4_2core_glUniform3f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +void gl4_2core_glUniform2f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1); +void gl4_2core_glUniform1f(void *_glfuncs, GLint location, GLfloat v0); +void gl4_2core_glUseProgram(void *_glfuncs, GLuint program); +void gl4_2core_glShaderSource(void *_glfuncs, GLuint shader, GLsizei count, const GLchar** source, const GLint* length); +void gl4_2core_glLinkProgram(void *_glfuncs, GLuint program); +GLboolean gl4_2core_glIsShader(void *_glfuncs, GLuint shader); +GLboolean gl4_2core_glIsProgram(void *_glfuncs, GLuint program); +void gl4_2core_glGetVertexAttribiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params); +void gl4_2core_glGetVertexAttribfv(void *_glfuncs, GLuint index, GLenum pname, GLfloat* params); +void gl4_2core_glGetVertexAttribdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params); +void gl4_2core_glGetUniformiv(void *_glfuncs, GLuint program, GLint location, GLint* params); +void gl4_2core_glGetUniformfv(void *_glfuncs, GLuint program, GLint location, GLfloat* params); +GLint gl4_2core_glGetUniformLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl4_2core_glGetShaderSource(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source); +void gl4_2core_glGetShaderInfoLog(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl4_2core_glGetShaderiv(void *_glfuncs, GLuint shader, GLenum pname, GLint* params); +void gl4_2core_glGetProgramInfoLog(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl4_2core_glGetProgramiv(void *_glfuncs, GLuint program, GLenum pname, GLint* params); +GLint gl4_2core_glGetAttribLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl4_2core_glGetAttachedShaders(void *_glfuncs, GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj); +void gl4_2core_glGetActiveUniform(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name); +void gl4_2core_glGetActiveAttrib(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name); +void gl4_2core_glEnableVertexAttribArray(void *_glfuncs, GLuint index); +void gl4_2core_glDisableVertexAttribArray(void *_glfuncs, GLuint index); +void gl4_2core_glDetachShader(void *_glfuncs, GLuint program, GLuint shader); +void gl4_2core_glDeleteShader(void *_glfuncs, GLuint shader); +void gl4_2core_glDeleteProgram(void *_glfuncs, GLuint program); +GLuint gl4_2core_glCreateShader(void *_glfuncs, GLenum gltype); +GLuint gl4_2core_glCreateProgram(void *_glfuncs); +void gl4_2core_glCompileShader(void *_glfuncs, GLuint shader); +void gl4_2core_glBindAttribLocation(void *_glfuncs, GLuint program, GLuint index, const GLchar* name); +void gl4_2core_glAttachShader(void *_glfuncs, GLuint program, GLuint shader); +void gl4_2core_glStencilMaskSeparate(void *_glfuncs, GLenum face, GLuint mask); +void gl4_2core_glStencilFuncSeparate(void *_glfuncs, GLenum face, GLenum glfunc, GLint ref, GLuint mask); +void gl4_2core_glStencilOpSeparate(void *_glfuncs, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +void gl4_2core_glDrawBuffers(void *_glfuncs, GLsizei n, const GLenum* bufs); +void gl4_2core_glBlendEquationSeparate(void *_glfuncs, GLenum modeRGB, GLenum modeAlpha); +void gl4_2core_glUniformMatrix4x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_2core_glUniformMatrix3x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_2core_glUniformMatrix4x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_2core_glUniformMatrix2x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_2core_glUniformMatrix3x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_2core_glUniformMatrix2x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +GLboolean gl4_2core_glIsVertexArray(void *_glfuncs, GLuint array); +void gl4_2core_glGenVertexArrays(void *_glfuncs, GLsizei n, GLuint* arrays); +void gl4_2core_glDeleteVertexArrays(void *_glfuncs, GLsizei n, const GLuint* arrays); +void gl4_2core_glBindVertexArray(void *_glfuncs, GLuint array); +void gl4_2core_glFlushMappedBufferRange(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr length); +void gl4_2core_glFramebufferTextureLayer(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +void gl4_2core_glRenderbufferStorageMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height); +void gl4_2core_glBlitFramebuffer(void *_glfuncs, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +void gl4_2core_glGenerateMipmap(void *_glfuncs, GLenum target); +void gl4_2core_glGetFramebufferAttachmentParameteriv(void *_glfuncs, GLenum target, GLenum attachment, GLenum pname, GLint* params); +void gl4_2core_glFramebufferRenderbuffer(void *_glfuncs, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +void gl4_2core_glFramebufferTexture3D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +void gl4_2core_glFramebufferTexture2D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +void gl4_2core_glFramebufferTexture1D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLenum gl4_2core_glCheckFramebufferStatus(void *_glfuncs, GLenum target); +void gl4_2core_glGenFramebuffers(void *_glfuncs, GLsizei n, GLuint* framebuffers); +void gl4_2core_glDeleteFramebuffers(void *_glfuncs, GLsizei n, const GLuint* framebuffers); +void gl4_2core_glBindFramebuffer(void *_glfuncs, GLenum target, GLuint framebuffer); +GLboolean gl4_2core_glIsFramebuffer(void *_glfuncs, GLuint framebuffer); +void gl4_2core_glGetRenderbufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_2core_glRenderbufferStorage(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height); +void gl4_2core_glGenRenderbuffers(void *_glfuncs, GLsizei n, GLuint* renderbuffers); +void gl4_2core_glDeleteRenderbuffers(void *_glfuncs, GLsizei n, const GLuint* renderbuffers); +void gl4_2core_glBindRenderbuffer(void *_glfuncs, GLenum target, GLuint renderbuffer); +GLboolean gl4_2core_glIsRenderbuffer(void *_glfuncs, GLuint renderbuffer); +void gl4_2core_glClearBufferfi(void *_glfuncs, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); +void gl4_2core_glClearBufferfv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLfloat* value); +void gl4_2core_glClearBufferuiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLuint* value); +void gl4_2core_glClearBufferiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLint* value); +void gl4_2core_glGetTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, GLuint* params); +void gl4_2core_glGetTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_2core_glTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, const GLuint* params); +void gl4_2core_glTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl4_2core_glUniform4uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl4_2core_glUniform3uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl4_2core_glUniform2uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl4_2core_glUniform1uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl4_2core_glUniform4ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +void gl4_2core_glUniform3ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2); +void gl4_2core_glUniform2ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1); +void gl4_2core_glUniform1ui(void *_glfuncs, GLint location, GLuint v0); +GLint gl4_2core_glGetFragDataLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl4_2core_glBindFragDataLocation(void *_glfuncs, GLuint program, GLuint color, const GLchar* name); +void gl4_2core_glGetUniformuiv(void *_glfuncs, GLuint program, GLint location, GLuint* params); +void gl4_2core_glGetVertexAttribIuiv(void *_glfuncs, GLuint index, GLenum pname, GLuint* params); +void gl4_2core_glGetVertexAttribIiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params); +void gl4_2core_glVertexAttribIPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_2core_glEndConditionalRender(void *_glfuncs); +void gl4_2core_glBeginConditionalRender(void *_glfuncs, GLuint id, GLenum mode); +void gl4_2core_glClampColor(void *_glfuncs, GLenum target, GLenum clamp); +void gl4_2core_glGetTransformFeedbackVarying(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* gltype, GLchar* name); +void gl4_2core_glBindBufferBase(void *_glfuncs, GLenum target, GLuint index, GLuint buffer); +void gl4_2core_glBindBufferRange(void *_glfuncs, GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +void gl4_2core_glEndTransformFeedback(void *_glfuncs); +void gl4_2core_glBeginTransformFeedback(void *_glfuncs, GLenum primitiveMode); +GLboolean gl4_2core_glIsEnabledi(void *_glfuncs, GLenum target, GLuint index); +void gl4_2core_glDisablei(void *_glfuncs, GLenum target, GLuint index); +void gl4_2core_glEnablei(void *_glfuncs, GLenum target, GLuint index); +void gl4_2core_glGetIntegeri_v(void *_glfuncs, GLenum target, GLuint index, GLint* data); +void gl4_2core_glGetBooleani_v(void *_glfuncs, GLenum target, GLuint index, GLboolean* data); +void gl4_2core_glColorMaski(void *_glfuncs, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +void gl4_2core_glCopyBufferSubData(void *_glfuncs, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +void gl4_2core_glUniformBlockBinding(void *_glfuncs, GLuint program, GLuint v0, GLuint v1); +void gl4_2core_glGetActiveUniformBlockName(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName); +void gl4_2core_glGetActiveUniformBlockiv(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params); +GLuint gl4_2core_glGetUniformBlockIndex(void *_glfuncs, GLuint program, const GLchar* uniformBlockName); +void gl4_2core_glGetActiveUniformName(void *_glfuncs, GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName); +void gl4_2core_glGetActiveUniformsiv(void *_glfuncs, GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params); +void gl4_2core_glPrimitiveRestartIndex(void *_glfuncs, GLuint index); +void gl4_2core_glTexBuffer(void *_glfuncs, GLenum target, GLenum internalFormat, GLuint buffer); +void gl4_2core_glDrawElementsInstanced(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount); +void gl4_2core_glDrawArraysInstanced(void *_glfuncs, GLenum mode, GLint first, GLsizei count, GLsizei instancecount); +void gl4_2core_glSampleMaski(void *_glfuncs, GLuint index, GLbitfield mask); +void gl4_2core_glGetMultisamplefv(void *_glfuncs, GLenum pname, GLuint index, GLfloat* val); +void gl4_2core_glTexImage3DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); +void gl4_2core_glTexImage2DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +void gl4_2core_glGetSynciv(void *_glfuncs, GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values); +void gl4_2core_glGetInteger64v(void *_glfuncs, GLenum pname, GLint64* params); +void gl4_2core_glWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout); +GLenum gl4_2core_glClientWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout); +void gl4_2core_glDeleteSync(void *_glfuncs, GLsync sync); +GLboolean gl4_2core_glIsSync(void *_glfuncs, GLsync sync); +GLsync gl4_2core_glFenceSync(void *_glfuncs, GLenum condition, GLbitfield flags); +void gl4_2core_glProvokingVertex(void *_glfuncs, GLenum mode); +void gl4_2core_glDrawElementsInstancedBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLint basevertex); +void gl4_2core_glDrawRangeElementsBaseVertex(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex); +void gl4_2core_glDrawElementsBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex); +void gl4_2core_glFramebufferTexture(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level); +void gl4_2core_glGetBufferParameteri64v(void *_glfuncs, GLenum target, GLenum pname, GLint64* params); +void gl4_2core_glGetInteger64i_v(void *_glfuncs, GLenum target, GLuint index, GLint64* data); +void gl4_2core_glVertexAttribP4uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl4_2core_glVertexAttribP4ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl4_2core_glVertexAttribP3uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl4_2core_glVertexAttribP3ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl4_2core_glVertexAttribP2uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl4_2core_glVertexAttribP2ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl4_2core_glVertexAttribP1uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl4_2core_glVertexAttribP1ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl4_2core_glSecondaryColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color); +void gl4_2core_glSecondaryColorP3ui(void *_glfuncs, GLenum gltype, GLuint color); +void gl4_2core_glColorP4uiv(void *_glfuncs, GLenum gltype, const GLuint* color); +void gl4_2core_glColorP4ui(void *_glfuncs, GLenum gltype, GLuint color); +void gl4_2core_glColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color); +void gl4_2core_glColorP3ui(void *_glfuncs, GLenum gltype, GLuint color); +void gl4_2core_glNormalP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_2core_glNormalP3ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_2core_glMultiTexCoordP4uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl4_2core_glMultiTexCoordP4ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl4_2core_glMultiTexCoordP3uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl4_2core_glMultiTexCoordP3ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl4_2core_glMultiTexCoordP2uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl4_2core_glMultiTexCoordP2ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl4_2core_glMultiTexCoordP1uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl4_2core_glMultiTexCoordP1ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl4_2core_glTexCoordP4uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_2core_glTexCoordP4ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_2core_glTexCoordP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_2core_glTexCoordP3ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_2core_glTexCoordP2uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_2core_glTexCoordP2ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_2core_glTexCoordP1uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_2core_glTexCoordP1ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_2core_glVertexP4uiv(void *_glfuncs, GLenum gltype, const GLuint* value); +void gl4_2core_glVertexP4ui(void *_glfuncs, GLenum gltype, GLuint value); +void gl4_2core_glVertexP3uiv(void *_glfuncs, GLenum gltype, const GLuint* value); +void gl4_2core_glVertexP3ui(void *_glfuncs, GLenum gltype, GLuint value); +void gl4_2core_glVertexP2uiv(void *_glfuncs, GLenum gltype, const GLuint* value); +void gl4_2core_glVertexP2ui(void *_glfuncs, GLenum gltype, GLuint value); +void gl4_2core_glGetQueryObjectui64v(void *_glfuncs, GLuint id, GLenum pname, GLuint64* params); +void gl4_2core_glGetQueryObjecti64v(void *_glfuncs, GLuint id, GLenum pname, GLint64* params); +void gl4_2core_glQueryCounter(void *_glfuncs, GLuint id, GLenum target); +void gl4_2core_glGetSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, GLuint* params); +void gl4_2core_glGetSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat* params); +void gl4_2core_glGetSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params); +void gl4_2core_glGetSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params); +void gl4_2core_glSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLuint* param); +void gl4_2core_glSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param); +void gl4_2core_glSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, const GLfloat* param); +void gl4_2core_glSamplerParameterf(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat param); +void gl4_2core_glSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param); +void gl4_2core_glSamplerParameteri(void *_glfuncs, GLuint sampler, GLenum pname, GLint param); +void gl4_2core_glBindSampler(void *_glfuncs, GLuint unit, GLuint sampler); +GLboolean gl4_2core_glIsSampler(void *_glfuncs, GLuint sampler); +void gl4_2core_glDeleteSamplers(void *_glfuncs, GLsizei count, const GLuint* samplers); +void gl4_2core_glGenSamplers(void *_glfuncs, GLsizei count, GLuint* samplers); +GLint gl4_2core_glGetFragDataIndex(void *_glfuncs, GLuint program, const GLchar* name); +void gl4_2core_glBindFragDataLocationIndexed(void *_glfuncs, GLuint program, GLuint colorNumber, GLuint index, const GLchar* name); +void gl4_2core_glVertexAttribDivisor(void *_glfuncs, GLuint index, GLuint divisor); +void gl4_2core_glGetQueryIndexediv(void *_glfuncs, GLenum target, GLuint index, GLenum pname, GLint* params); +void gl4_2core_glEndQueryIndexed(void *_glfuncs, GLenum target, GLuint index); +void gl4_2core_glBeginQueryIndexed(void *_glfuncs, GLenum target, GLuint index, GLuint id); +void gl4_2core_glDrawTransformFeedbackStream(void *_glfuncs, GLenum mode, GLuint id, GLuint stream); +void gl4_2core_glDrawTransformFeedback(void *_glfuncs, GLenum mode, GLuint id); +void gl4_2core_glResumeTransformFeedback(void *_glfuncs); +void gl4_2core_glPauseTransformFeedback(void *_glfuncs); +GLboolean gl4_2core_glIsTransformFeedback(void *_glfuncs, GLuint id); +void gl4_2core_glGenTransformFeedbacks(void *_glfuncs, GLsizei n, GLuint* ids); +void gl4_2core_glDeleteTransformFeedbacks(void *_glfuncs, GLsizei n, const GLuint* ids); +void gl4_2core_glBindTransformFeedback(void *_glfuncs, GLenum target, GLuint id); +void gl4_2core_glPatchParameterfv(void *_glfuncs, GLenum pname, const GLfloat* values); +void gl4_2core_glPatchParameteri(void *_glfuncs, GLenum pname, GLint value); +void gl4_2core_glGetProgramStageiv(void *_glfuncs, GLuint program, GLenum shadertype, GLenum pname, GLint* values); +void gl4_2core_glGetUniformSubroutineuiv(void *_glfuncs, GLenum shadertype, GLint location, GLuint* params); +void gl4_2core_glUniformSubroutinesuiv(void *_glfuncs, GLenum shadertype, GLsizei count, const GLuint* value); +void gl4_2core_glGetActiveSubroutineName(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name); +void gl4_2core_glGetActiveSubroutineUniformName(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name); +void gl4_2core_glGetActiveSubroutineUniformiv(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint* values); +GLuint gl4_2core_glGetSubroutineIndex(void *_glfuncs, GLuint program, GLenum shadertype, const GLchar* name); +GLint gl4_2core_glGetSubroutineUniformLocation(void *_glfuncs, GLuint program, GLenum shadertype, const GLchar* name); +void gl4_2core_glGetUniformdv(void *_glfuncs, GLuint program, GLint location, GLdouble* params); +void gl4_2core_glUniformMatrix4x3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2core_glUniformMatrix4x2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2core_glUniformMatrix3x4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2core_glUniformMatrix3x2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2core_glUniformMatrix2x4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2core_glUniformMatrix2x3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2core_glUniformMatrix4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2core_glUniformMatrix3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2core_glUniformMatrix2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2core_glUniform4dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value); +void gl4_2core_glUniform3dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value); +void gl4_2core_glUniform2dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value); +void gl4_2core_glUniform1dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value); +void gl4_2core_glUniform4d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3); +void gl4_2core_glUniform3d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1, GLdouble v2); +void gl4_2core_glUniform2d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1); +void gl4_2core_glUniform1d(void *_glfuncs, GLint location, GLdouble v0); +void gl4_2core_glDrawElementsIndirect(void *_glfuncs, GLenum mode, GLenum gltype, const GLvoid* indirect); +void gl4_2core_glDrawArraysIndirect(void *_glfuncs, GLenum mode, const GLvoid* indirect); +void gl4_2core_glBlendFuncSeparatei(void *_glfuncs, GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); +void gl4_2core_glBlendFunci(void *_glfuncs, GLuint buf, GLenum src, GLenum dst); +void gl4_2core_glBlendEquationSeparatei(void *_glfuncs, GLuint buf, GLenum modeRGB, GLenum modeAlpha); +void gl4_2core_glBlendEquationi(void *_glfuncs, GLuint buf, GLenum mode); +void gl4_2core_glMinSampleShading(void *_glfuncs, GLfloat value); +void gl4_2core_glGetDoublei_v(void *_glfuncs, GLenum target, GLuint index, GLdouble* data); +void gl4_2core_glGetFloati_v(void *_glfuncs, GLenum target, GLuint index, GLfloat* data); +void gl4_2core_glDepthRangeIndexed(void *_glfuncs, GLuint index, GLdouble n, GLdouble f); +void gl4_2core_glDepthRangeArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLdouble* v); +void gl4_2core_glScissorIndexedv(void *_glfuncs, GLuint index, const GLint* v); +void gl4_2core_glScissorIndexed(void *_glfuncs, GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height); +void gl4_2core_glScissorArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLint* v); +void gl4_2core_glViewportIndexedfv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl4_2core_glViewportIndexedf(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h); +void gl4_2core_glViewportArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLfloat* v); +void gl4_2core_glGetVertexAttribLdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params); +void gl4_2core_glVertexAttribLPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_2core_glVertexAttribL4dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_2core_glVertexAttribL3dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_2core_glVertexAttribL2dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_2core_glVertexAttribL1dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_2core_glVertexAttribL4d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl4_2core_glVertexAttribL3d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z); +void gl4_2core_glVertexAttribL2d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y); +void gl4_2core_glVertexAttribL1d(void *_glfuncs, GLuint index, GLdouble x); +void gl4_2core_glGetProgramPipelineInfoLog(void *_glfuncs, GLuint pipeline, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl4_2core_glValidateProgramPipeline(void *_glfuncs, GLuint pipeline); +void gl4_2core_glProgramUniformMatrix4x3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2core_glProgramUniformMatrix3x4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2core_glProgramUniformMatrix4x2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2core_glProgramUniformMatrix2x4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2core_glProgramUniformMatrix3x2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2core_glProgramUniformMatrix2x3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2core_glProgramUniformMatrix4x3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_2core_glProgramUniformMatrix3x4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_2core_glProgramUniformMatrix4x2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_2core_glProgramUniformMatrix2x4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_2core_glProgramUniformMatrix3x2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_2core_glProgramUniformMatrix2x3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_2core_glProgramUniformMatrix4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2core_glProgramUniformMatrix3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2core_glProgramUniformMatrix2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_2core_glProgramUniformMatrix4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_2core_glProgramUniformMatrix3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_2core_glProgramUniformMatrix2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_2core_glProgramUniform4uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value); +void gl4_2core_glProgramUniform4ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +void gl4_2core_glProgramUniform4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value); +void gl4_2core_glProgramUniform4d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3); +void gl4_2core_glProgramUniform4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value); +void gl4_2core_glProgramUniform4f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +void gl4_2core_glProgramUniform4iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value); +void gl4_2core_glProgramUniform4i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +void gl4_2core_glProgramUniform3uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value); +void gl4_2core_glProgramUniform3ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2); +void gl4_2core_glProgramUniform3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value); +void gl4_2core_glProgramUniform3d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2); +void gl4_2core_glProgramUniform3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value); +void gl4_2core_glProgramUniform3f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +void gl4_2core_glProgramUniform3iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value); +void gl4_2core_glProgramUniform3i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1, GLint v2); +void gl4_2core_glProgramUniform2uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value); +void gl4_2core_glProgramUniform2ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1); +void gl4_2core_glProgramUniform2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value); +void gl4_2core_glProgramUniform2d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1); +void gl4_2core_glProgramUniform2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value); +void gl4_2core_glProgramUniform2f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1); +void gl4_2core_glProgramUniform2iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value); +void gl4_2core_glProgramUniform2i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1); +void gl4_2core_glProgramUniform1uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value); +void gl4_2core_glProgramUniform1ui(void *_glfuncs, GLuint program, GLint location, GLuint v0); +void gl4_2core_glProgramUniform1dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value); +void gl4_2core_glProgramUniform1d(void *_glfuncs, GLuint program, GLint location, GLdouble v0); +void gl4_2core_glProgramUniform1fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value); +void gl4_2core_glProgramUniform1f(void *_glfuncs, GLuint program, GLint location, GLfloat v0); +void gl4_2core_glProgramUniform1iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value); +void gl4_2core_glProgramUniform1i(void *_glfuncs, GLuint program, GLint location, GLint v0); +void gl4_2core_glGetProgramPipelineiv(void *_glfuncs, GLuint pipeline, GLenum pname, GLint* params); +GLboolean gl4_2core_glIsProgramPipeline(void *_glfuncs, GLuint pipeline); +void gl4_2core_glGenProgramPipelines(void *_glfuncs, GLsizei n, GLuint* pipelines); +void gl4_2core_glDeleteProgramPipelines(void *_glfuncs, GLsizei n, const GLuint* pipelines); +void gl4_2core_glBindProgramPipeline(void *_glfuncs, GLuint pipeline); +void gl4_2core_glActiveShaderProgram(void *_glfuncs, GLuint pipeline, GLuint program); +void gl4_2core_glUseProgramStages(void *_glfuncs, GLuint pipeline, GLbitfield stages, GLuint program); +void gl4_2core_glProgramParameteri(void *_glfuncs, GLuint program, GLenum pname, GLint value); +void gl4_2core_glProgramBinary(void *_glfuncs, GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length); +void gl4_2core_glGetProgramBinary(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary); +void gl4_2core_glClearDepthf(void *_glfuncs, GLfloat dd); +void gl4_2core_glDepthRangef(void *_glfuncs, GLfloat n, GLfloat f); +void gl4_2core_glGetShaderPrecisionFormat(void *_glfuncs, GLenum shadertype, GLenum precisionType, GLint* range_, GLint* precision); +void gl4_2core_glShaderBinary(void *_glfuncs, GLsizei count, const GLuint* shaders, GLenum binaryFormat, const GLvoid* binary, GLsizei length); +void gl4_2core_glReleaseShaderCompiler(void *_glfuncs); +void gl4_2core_glTexStorage3D(void *_glfuncs, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth); +void gl4_2core_glTexStorage2D(void *_glfuncs, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height); +void gl4_2core_glTexStorage1D(void *_glfuncs, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width); +void gl4_2core_glMemoryBarrier(void *_glfuncs, GLbitfield barriers); +void gl4_2core_glBindImageTexture(void *_glfuncs, GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format); +void gl4_2core_glGetActiveAtomicCounterBufferiv(void *_glfuncs, GLuint program, GLuint bufferIndex, GLenum pname, GLint* params); +void gl4_2core_glGetInternalformativ(void *_glfuncs, GLenum target, GLenum internalFormat, GLenum pname, GLsizei bufSize, GLint* params); +void gl4_2core_glDrawTransformFeedbackStreamInstanced(void *_glfuncs, GLenum mode, GLuint id, GLuint stream, GLsizei instancecount); +void gl4_2core_glDrawTransformFeedbackInstanced(void *_glfuncs, GLenum mode, GLuint id, GLsizei instancecount); +void gl4_2core_glDrawElementsInstancedBaseVertexBaseInstance(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance); +void gl4_2core_glDrawElementsInstancedBaseInstance(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLuint baseinstance); +void gl4_2core_glDrawArraysInstancedBaseInstance(void *_glfuncs, GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance); + + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/gl/4.2core/gl.go b/gl/4.2core/gl.go new file mode 100644 index 00000000..a452b729 --- /dev/null +++ b/gl/4.2core/gl.go @@ -0,0 +1,6594 @@ +// ** file automatically generated by glgen -- do not edit manually ** + +package GL + +// #cgo CXXFLAGS: -std=c++0x -pedantic-errors -Wall -fno-strict-aliasing +// #cgo LDFLAGS: -lstdc++ +// #cgo pkg-config: Qt5Core Qt5OpenGL +// +// #include "funcs.h" +// +// void free(void*); +// +import "C" + +import ( + "fmt" + "reflect" + "unsafe" + + "gopkg.in/qml.v1/gl/glbase" +) + +// API returns a value that offers methods matching the OpenGL version 4.2 API. +// +// The returned API must not be used after the provided OpenGL context becomes invalid. +func API(context glbase.Contexter) *GL { + gl := &GL{} + gl.funcs = C.gl4_2core_funcs() + if gl.funcs == nil { + panic(fmt.Errorf("OpenGL version 4.2 is not available")) + } + return gl +} + +// GL implements the OpenGL version 4.2 API. Values of this +// type must be created via the API function, and it must not be used after +// the associated OpenGL context becomes invalid. +type GL struct { + funcs unsafe.Pointer +} + +const ( + FALSE = 0 + TRUE = 1 + NONE = 0 + + BYTE = 0x1400 + UNSIGNED_BYTE = 0x1401 + SHORT = 0x1402 + UNSIGNED_SHORT = 0x1403 + INT = 0x1404 + UNSIGNED_INT = 0x1405 + FLOAT = 0x1406 + N2_BYTES = 0x1407 + N3_BYTES = 0x1408 + N4_BYTES = 0x1409 + DOUBLE = 0x140A + HALF_FLOAT = 0x140B + FIXED = 0x140C + + ACCUM = 0x0100 + LOAD = 0x0101 + RETURN = 0x0102 + MULT = 0x0103 + ADD = 0x0104 + + ACCUM_BUFFER_BIT = 0x00000200 + ALL_ATTRIB_BITS = 0xFFFFFFFF + COLOR_BUFFER_BIT = 0x00004000 + CURRENT_BIT = 0x00000001 + DEPTH_BUFFER_BIT = 0x00000100 + ENABLE_BIT = 0x00002000 + EVAL_BIT = 0x00010000 + FOG_BIT = 0x00000080 + HINT_BIT = 0x00008000 + LIGHTING_BIT = 0x00000040 + LINE_BIT = 0x00000004 + LIST_BIT = 0x00020000 + MULTISAMPLE_BIT = 0x20000000 + PIXEL_MODE_BIT = 0x00000020 + POINT_BIT = 0x00000002 + POLYGON_BIT = 0x00000008 + POLYGON_STIPPLE_BIT = 0x00000010 + SCISSOR_BIT = 0x00080000 + STENCIL_BUFFER_BIT = 0x00000400 + TEXTURE_BIT = 0x00040000 + TRANSFORM_BIT = 0x00001000 + VIEWPORT_BIT = 0x00000800 + + ALWAYS = 0x0207 + EQUAL = 0x0202 + GEQUAL = 0x0206 + GREATER = 0x0204 + LEQUAL = 0x0203 + LESS = 0x0201 + NEVER = 0x0200 + NOTEQUAL = 0x0205 + + LOGIC_OP = 0x0BF1 + + DST_ALPHA = 0x0304 + ONE = 1 + ONE_MINUS_DST_ALPHA = 0x0305 + ONE_MINUS_SRC_ALPHA = 0x0303 + ONE_MINUS_SRC_COLOR = 0x0301 + SRC_ALPHA = 0x0302 + SRC_COLOR = 0x0300 + ZERO = 0 + + DST_COLOR = 0x0306 + ONE_MINUS_DST_COLOR = 0x0307 + SRC_ALPHA_SATURATE = 0x0308 + + CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF + CLIENT_PIXEL_STORE_BIT = 0x00000001 + CLIENT_VERTEX_ARRAY_BIT = 0x00000002 + + CLIP_DISTANCE0 = 0x3000 + CLIP_DISTANCE1 = 0x3001 + CLIP_DISTANCE2 = 0x3002 + CLIP_DISTANCE3 = 0x3003 + CLIP_DISTANCE4 = 0x3004 + CLIP_DISTANCE5 = 0x3005 + CLIP_DISTANCE6 = 0x3006 + CLIP_DISTANCE7 = 0x3007 + CLIP_PLANE0 = 0x3000 + CLIP_PLANE1 = 0x3001 + CLIP_PLANE2 = 0x3002 + CLIP_PLANE3 = 0x3003 + CLIP_PLANE4 = 0x3004 + CLIP_PLANE5 = 0x3005 + + BACK = 0x0405 + FRONT = 0x0404 + FRONT_AND_BACK = 0x0408 + + AMBIENT = 0x1200 + AMBIENT_AND_DIFFUSE = 0x1602 + DIFFUSE = 0x1201 + EMISSION = 0x1600 + SPECULAR = 0x1202 + + CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x00000001 + + CONTEXT_COMPATIBILITY_PROFILE_BIT = 0x00000002 + CONTEXT_CORE_PROFILE_BIT = 0x00000001 + + AUX0 = 0x0409 + AUX1 = 0x040A + AUX2 = 0x040B + AUX3 = 0x040C + BACK_LEFT = 0x0402 + BACK_RIGHT = 0x0403 + FRONT_LEFT = 0x0400 + FRONT_RIGHT = 0x0401 + LEFT = 0x0406 + RIGHT = 0x0407 + + ALPHA_TEST = 0x0BC0 + AUTO_NORMAL = 0x0D80 + BLEND = 0x0BE2 + COLOR_ARRAY = 0x8076 + COLOR_LOGIC_OP = 0x0BF2 + COLOR_MATERIAL = 0x0B57 + CULL_FACE = 0x0B44 + DEPTH_TEST = 0x0B71 + DITHER = 0x0BD0 + EDGE_FLAG_ARRAY = 0x8079 + FOG = 0x0B60 + INDEX_ARRAY = 0x8077 + INDEX_LOGIC_OP = 0x0BF1 + LIGHT0 = 0x4000 + LIGHT1 = 0x4001 + LIGHT2 = 0x4002 + LIGHT3 = 0x4003 + LIGHT4 = 0x4004 + LIGHT5 = 0x4005 + LIGHT6 = 0x4006 + LIGHT7 = 0x4007 + LIGHTING = 0x0B50 + LINE_SMOOTH = 0x0B20 + LINE_STIPPLE = 0x0B24 + MAP1_COLOR_4 = 0x0D90 + MAP1_INDEX = 0x0D91 + MAP1_NORMAL = 0x0D92 + MAP1_TEXTURE_COORD_1 = 0x0D93 + MAP1_TEXTURE_COORD_2 = 0x0D94 + MAP1_TEXTURE_COORD_3 = 0x0D95 + MAP1_TEXTURE_COORD_4 = 0x0D96 + MAP1_VERTEX_3 = 0x0D97 + MAP1_VERTEX_4 = 0x0D98 + MAP2_COLOR_4 = 0x0DB0 + MAP2_INDEX = 0x0DB1 + MAP2_NORMAL = 0x0DB2 + MAP2_TEXTURE_COORD_1 = 0x0DB3 + MAP2_TEXTURE_COORD_2 = 0x0DB4 + MAP2_TEXTURE_COORD_3 = 0x0DB5 + MAP2_TEXTURE_COORD_4 = 0x0DB6 + MAP2_VERTEX_3 = 0x0DB7 + MAP2_VERTEX_4 = 0x0DB8 + NORMALIZE = 0x0BA1 + NORMAL_ARRAY = 0x8075 + POINT_SMOOTH = 0x0B10 + POLYGON_OFFSET_FILL = 0x8037 + POLYGON_OFFSET_LINE = 0x2A02 + POLYGON_OFFSET_POINT = 0x2A01 + POLYGON_SMOOTH = 0x0B41 + POLYGON_STIPPLE = 0x0B42 + SCISSOR_TEST = 0x0C11 + STENCIL_TEST = 0x0B90 + TEXTURE_1D = 0x0DE0 + TEXTURE_2D = 0x0DE1 + TEXTURE_COORD_ARRAY = 0x8078 + TEXTURE_GEN_Q = 0x0C63 + TEXTURE_GEN_R = 0x0C62 + TEXTURE_GEN_S = 0x0C60 + TEXTURE_GEN_T = 0x0C61 + VERTEX_ARRAY = 0x8074 + + INVALID_ENUM = 0x0500 + INVALID_FRAMEBUFFER_OPERATION = 0x0506 + INVALID_OPERATION = 0x0502 + INVALID_VALUE = 0x0501 + NO_ERROR = 0 + OUT_OF_MEMORY = 0x0505 + STACK_OVERFLOW = 0x0503 + STACK_UNDERFLOW = 0x0504 + + N2D = 0x0600 + N3D = 0x0601 + N3D_COLOR = 0x0602 + N3D_COLOR_TEXTURE = 0x0603 + N4D_COLOR_TEXTURE = 0x0604 + + BITMAP_TOKEN = 0x0704 + COPY_PIXEL_TOKEN = 0x0706 + DRAW_PIXEL_TOKEN = 0x0705 + LINE_RESET_TOKEN = 0x0707 + LINE_TOKEN = 0x0702 + PASS_THROUGH_TOKEN = 0x0700 + POINT_TOKEN = 0x0701 + POLYGON_TOKEN = 0x0703 + + EXP = 0x0800 + EXP2 = 0x0801 + LINEAR = 0x2601 + + FOG_COLOR = 0x0B66 + FOG_DENSITY = 0x0B62 + FOG_END = 0x0B64 + FOG_INDEX = 0x0B61 + FOG_MODE = 0x0B65 + FOG_START = 0x0B63 + + CCW = 0x0901 + CW = 0x0900 + + COEFF = 0x0A00 + DOMAIN = 0x0A02 + ORDER = 0x0A01 + + PIXEL_MAP_A_TO_A = 0x0C79 + PIXEL_MAP_B_TO_B = 0x0C78 + PIXEL_MAP_G_TO_G = 0x0C77 + PIXEL_MAP_I_TO_A = 0x0C75 + PIXEL_MAP_I_TO_B = 0x0C74 + PIXEL_MAP_I_TO_G = 0x0C73 + PIXEL_MAP_I_TO_I = 0x0C70 + PIXEL_MAP_I_TO_R = 0x0C72 + PIXEL_MAP_R_TO_R = 0x0C76 + PIXEL_MAP_S_TO_S = 0x0C71 + + ACCUM_ALPHA_BITS = 0x0D5B + ACCUM_BLUE_BITS = 0x0D5A + ACCUM_CLEAR_VALUE = 0x0B80 + ACCUM_GREEN_BITS = 0x0D59 + ACCUM_RED_BITS = 0x0D58 + ALIASED_LINE_WIDTH_RANGE = 0x846E + ALIASED_POINT_SIZE_RANGE = 0x846D + ALPHA_BIAS = 0x0D1D + ALPHA_BITS = 0x0D55 + ALPHA_SCALE = 0x0D1C + ALPHA_TEST_FUNC = 0x0BC1 + ALPHA_TEST_REF = 0x0BC2 + ATTRIB_STACK_DEPTH = 0x0BB0 + AUX_BUFFERS = 0x0C00 + BLEND_DST = 0x0BE0 + BLEND_SRC = 0x0BE1 + BLUE_BIAS = 0x0D1B + BLUE_BITS = 0x0D54 + BLUE_SCALE = 0x0D1A + CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1 + COLOR_ARRAY_SIZE = 0x8081 + COLOR_ARRAY_STRIDE = 0x8083 + COLOR_ARRAY_TYPE = 0x8082 + COLOR_CLEAR_VALUE = 0x0C22 + COLOR_MATERIAL_FACE = 0x0B55 + COLOR_MATERIAL_PARAMETER = 0x0B56 + COLOR_WRITEMASK = 0x0C23 + CULL_FACE_MODE = 0x0B45 + CURRENT_COLOR = 0x0B00 + CURRENT_INDEX = 0x0B01 + CURRENT_NORMAL = 0x0B02 + CURRENT_RASTER_COLOR = 0x0B04 + CURRENT_RASTER_DISTANCE = 0x0B09 + CURRENT_RASTER_INDEX = 0x0B05 + CURRENT_RASTER_POSITION = 0x0B07 + CURRENT_RASTER_POSITION_VALID = 0x0B08 + CURRENT_RASTER_TEXTURE_COORDS = 0x0B06 + CURRENT_TEXTURE_COORDS = 0x0B03 + DEPTH_BIAS = 0x0D1F + DEPTH_BITS = 0x0D56 + DEPTH_CLEAR_VALUE = 0x0B73 + DEPTH_FUNC = 0x0B74 + DEPTH_RANGE = 0x0B70 + DEPTH_SCALE = 0x0D1E + DEPTH_WRITEMASK = 0x0B72 + DOUBLEBUFFER = 0x0C32 + DRAW_BUFFER = 0x0C01 + EDGE_FLAG = 0x0B43 + EDGE_FLAG_ARRAY_STRIDE = 0x808C + FEEDBACK_BUFFER_SIZE = 0x0DF1 + FEEDBACK_BUFFER_TYPE = 0x0DF2 + FOG_HINT = 0x0C54 + FRONT_FACE = 0x0B46 + GREEN_BIAS = 0x0D19 + GREEN_BITS = 0x0D53 + GREEN_SCALE = 0x0D18 + INDEX_ARRAY_STRIDE = 0x8086 + INDEX_ARRAY_TYPE = 0x8085 + INDEX_BITS = 0x0D51 + INDEX_CLEAR_VALUE = 0x0C20 + INDEX_MODE = 0x0C30 + INDEX_OFFSET = 0x0D13 + INDEX_SHIFT = 0x0D12 + INDEX_WRITEMASK = 0x0C21 + LIGHT_MODEL_AMBIENT = 0x0B53 + LIGHT_MODEL_COLOR_CONTROL = 0x81F8 + LIGHT_MODEL_LOCAL_VIEWER = 0x0B51 + LIGHT_MODEL_TWO_SIDE = 0x0B52 + LINE_SMOOTH_HINT = 0x0C52 + LINE_STIPPLE_PATTERN = 0x0B25 + LINE_STIPPLE_REPEAT = 0x0B26 + LINE_WIDTH = 0x0B21 + LINE_WIDTH_GRANULARITY = 0x0B23 + LINE_WIDTH_RANGE = 0x0B22 + LIST_BASE = 0x0B32 + LIST_INDEX = 0x0B33 + LIST_MODE = 0x0B30 + LOGIC_OP_MODE = 0x0BF0 + MAP1_GRID_DOMAIN = 0x0DD0 + MAP1_GRID_SEGMENTS = 0x0DD1 + MAP2_GRID_DOMAIN = 0x0DD2 + MAP2_GRID_SEGMENTS = 0x0DD3 + MAP_COLOR = 0x0D10 + MAP_STENCIL = 0x0D11 + MATRIX_MODE = 0x0BA0 + MAX_ATTRIB_STACK_DEPTH = 0x0D35 + MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B + MAX_CLIP_DISTANCES = 0x0D32 + MAX_CLIP_PLANES = 0x0D32 + MAX_EVAL_ORDER = 0x0D30 + MAX_LIGHTS = 0x0D31 + MAX_LIST_NESTING = 0x0B31 + MAX_MODELVIEW_STACK_DEPTH = 0x0D36 + MAX_NAME_STACK_DEPTH = 0x0D37 + MAX_PIXEL_MAP_TABLE = 0x0D34 + MAX_PROJECTION_STACK_DEPTH = 0x0D38 + MAX_TEXTURE_SIZE = 0x0D33 + MAX_TEXTURE_STACK_DEPTH = 0x0D39 + MAX_VIEWPORT_DIMS = 0x0D3A + MODELVIEW_MATRIX = 0x0BA6 + MODELVIEW_STACK_DEPTH = 0x0BA3 + NAME_STACK_DEPTH = 0x0D70 + NORMAL_ARRAY_STRIDE = 0x807F + NORMAL_ARRAY_TYPE = 0x807E + PACK_ALIGNMENT = 0x0D05 + PACK_LSB_FIRST = 0x0D01 + PACK_ROW_LENGTH = 0x0D02 + PACK_SKIP_PIXELS = 0x0D04 + PACK_SKIP_ROWS = 0x0D03 + PACK_SWAP_BYTES = 0x0D00 + PERSPECTIVE_CORRECTION_HINT = 0x0C50 + PIXEL_MAP_A_TO_A_SIZE = 0x0CB9 + PIXEL_MAP_B_TO_B_SIZE = 0x0CB8 + PIXEL_MAP_G_TO_G_SIZE = 0x0CB7 + PIXEL_MAP_I_TO_A_SIZE = 0x0CB5 + PIXEL_MAP_I_TO_B_SIZE = 0x0CB4 + PIXEL_MAP_I_TO_G_SIZE = 0x0CB3 + PIXEL_MAP_I_TO_I_SIZE = 0x0CB0 + PIXEL_MAP_I_TO_R_SIZE = 0x0CB2 + PIXEL_MAP_R_TO_R_SIZE = 0x0CB6 + PIXEL_MAP_S_TO_S_SIZE = 0x0CB1 + POINT_SIZE = 0x0B11 + POINT_SIZE_GRANULARITY = 0x0B13 + POINT_SIZE_RANGE = 0x0B12 + POINT_SMOOTH_HINT = 0x0C51 + POLYGON_MODE = 0x0B40 + POLYGON_OFFSET_FACTOR = 0x8038 + POLYGON_OFFSET_UNITS = 0x2A00 + POLYGON_SMOOTH_HINT = 0x0C53 + PROJECTION_MATRIX = 0x0BA7 + PROJECTION_STACK_DEPTH = 0x0BA4 + READ_BUFFER = 0x0C02 + RED_BIAS = 0x0D15 + RED_BITS = 0x0D52 + RED_SCALE = 0x0D14 + RENDER_MODE = 0x0C40 + RGBA_MODE = 0x0C31 + SCISSOR_BOX = 0x0C10 + SELECTION_BUFFER_SIZE = 0x0DF4 + SHADE_MODEL = 0x0B54 + SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23 + SMOOTH_LINE_WIDTH_RANGE = 0x0B22 + SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13 + SMOOTH_POINT_SIZE_RANGE = 0x0B12 + STENCIL_BITS = 0x0D57 + STENCIL_CLEAR_VALUE = 0x0B91 + STENCIL_FAIL = 0x0B94 + STENCIL_FUNC = 0x0B92 + STENCIL_PASS_DEPTH_FAIL = 0x0B95 + STENCIL_PASS_DEPTH_PASS = 0x0B96 + STENCIL_REF = 0x0B97 + STENCIL_VALUE_MASK = 0x0B93 + STENCIL_WRITEMASK = 0x0B98 + STEREO = 0x0C33 + SUBPIXEL_BITS = 0x0D50 + TEXTURE_BINDING_1D = 0x8068 + TEXTURE_BINDING_2D = 0x8069 + TEXTURE_BINDING_3D = 0x806A + TEXTURE_COORD_ARRAY_SIZE = 0x8088 + TEXTURE_COORD_ARRAY_STRIDE = 0x808A + TEXTURE_COORD_ARRAY_TYPE = 0x8089 + TEXTURE_MATRIX = 0x0BA8 + TEXTURE_STACK_DEPTH = 0x0BA5 + UNPACK_ALIGNMENT = 0x0CF5 + UNPACK_LSB_FIRST = 0x0CF1 + UNPACK_ROW_LENGTH = 0x0CF2 + UNPACK_SKIP_PIXELS = 0x0CF4 + UNPACK_SKIP_ROWS = 0x0CF3 + UNPACK_SWAP_BYTES = 0x0CF0 + VERTEX_ARRAY_SIZE = 0x807A + VERTEX_ARRAY_STRIDE = 0x807C + VERTEX_ARRAY_TYPE = 0x807B + VIEWPORT = 0x0BA2 + ZOOM_X = 0x0D16 + ZOOM_Y = 0x0D17 + + COLOR_ARRAY_POINTER = 0x8090 + EDGE_FLAG_ARRAY_POINTER = 0x8093 + FEEDBACK_BUFFER_POINTER = 0x0DF0 + INDEX_ARRAY_POINTER = 0x8091 + NORMAL_ARRAY_POINTER = 0x808F + SELECTION_BUFFER_POINTER = 0x0DF3 + TEXTURE_COORD_ARRAY_POINTER = 0x8092 + VERTEX_ARRAY_POINTER = 0x808E + + TEXTURE_ALPHA_SIZE = 0x805F + TEXTURE_BLUE_SIZE = 0x805E + TEXTURE_BORDER = 0x1005 + TEXTURE_BORDER_COLOR = 0x1004 + TEXTURE_COMPONENTS = 0x1003 + TEXTURE_GREEN_SIZE = 0x805D + TEXTURE_HEIGHT = 0x1001 + TEXTURE_INTENSITY_SIZE = 0x8061 + TEXTURE_INTERNAL_FORMAT = 0x1003 + TEXTURE_LUMINANCE_SIZE = 0x8060 + TEXTURE_MAG_FILTER = 0x2800 + TEXTURE_MIN_FILTER = 0x2801 + TEXTURE_PRIORITY = 0x8066 + TEXTURE_RED_SIZE = 0x805C + TEXTURE_RESIDENT = 0x8067 + TEXTURE_WIDTH = 0x1000 + TEXTURE_WRAP_S = 0x2802 + TEXTURE_WRAP_T = 0x2803 + + DONT_CARE = 0x1100 + FASTEST = 0x1101 + NICEST = 0x1102 + + FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B + GENERATE_MIPMAP_HINT = 0x8192 + PROGRAM_BINARY_RETRIEVABLE_HINT = 0x8257 + TEXTURE_COMPRESSION_HINT = 0x84EF + + C3F_V3F = 0x2A24 + C4F_N3F_V3F = 0x2A26 + C4UB_V2F = 0x2A22 + C4UB_V3F = 0x2A23 + N3F_V3F = 0x2A25 + T2F_C3F_V3F = 0x2A2A + T2F_C4F_N3F_V3F = 0x2A2C + T2F_C4UB_V3F = 0x2A29 + T2F_N3F_V3F = 0x2A2B + T2F_V3F = 0x2A27 + T4F_C4F_N3F_V4F = 0x2A2D + T4F_V4F = 0x2A28 + V2F = 0x2A20 + V3F = 0x2A21 + + MODULATE = 0x2100 + REPLACE = 0x1E01 + + SEPARATE_SPECULAR_COLOR = 0x81FA + SINGLE_COLOR = 0x81F9 + + CONSTANT_ATTENUATION = 0x1207 + LINEAR_ATTENUATION = 0x1208 + POSITION = 0x1203 + QUADRATIC_ATTENUATION = 0x1209 + SPOT_CUTOFF = 0x1206 + SPOT_DIRECTION = 0x1204 + SPOT_EXPONENT = 0x1205 + + COMPILE = 0x1300 + COMPILE_AND_EXECUTE = 0x1301 + + AND = 0x1501 + AND_INVERTED = 0x1504 + AND_REVERSE = 0x1502 + CLEAR = 0x1500 + COPY = 0x1503 + COPY_INVERTED = 0x150C + EQUIV = 0x1509 + INVERT = 0x150A + NAND = 0x150E + NOOP = 0x1505 + NOR = 0x1508 + OR = 0x1507 + OR_INVERTED = 0x150D + OR_REVERSE = 0x150B + SET = 0x150F + XOR = 0x1506 + + MAP_FLUSH_EXPLICIT_BIT = 0x0010 + MAP_INVALIDATE_BUFFER_BIT = 0x0008 + MAP_INVALIDATE_RANGE_BIT = 0x0004 + MAP_READ_BIT = 0x0001 + MAP_UNSYNCHRONIZED_BIT = 0x0020 + MAP_WRITE_BIT = 0x0002 + + COLOR_INDEXES = 0x1603 + SHININESS = 0x1601 + + MODELVIEW = 0x1700 + PROJECTION = 0x1701 + TEXTURE = 0x1702 + + ALL_BARRIER_BITS = 0xFFFFFFFF + ATOMIC_COUNTER_BARRIER_BIT = 0x00001000 + BUFFER_UPDATE_BARRIER_BIT = 0x00000200 + COMMAND_BARRIER_BIT = 0x00000040 + ELEMENT_ARRAY_BARRIER_BIT = 0x00000002 + FRAMEBUFFER_BARRIER_BIT = 0x00000400 + PIXEL_BUFFER_BARRIER_BIT = 0x00000080 + SHADER_IMAGE_ACCESS_BARRIER_BIT = 0x00000020 + TEXTURE_FETCH_BARRIER_BIT = 0x00000008 + TEXTURE_UPDATE_BARRIER_BIT = 0x00000100 + TRANSFORM_FEEDBACK_BARRIER_BIT = 0x00000800 + UNIFORM_BARRIER_BIT = 0x00000004 + VERTEX_ATTRIB_ARRAY_BARRIER_BIT = 0x00000001 + + LINE = 0x1B01 + POINT = 0x1B00 + + FILL = 0x1B02 + + COLOR = 0x1800 + DEPTH = 0x1801 + STENCIL = 0x1802 + + ALPHA = 0x1906 + BLUE = 0x1905 + COLOR_INDEX = 0x1900 + DEPTH_COMPONENT = 0x1902 + GREEN = 0x1904 + LUMINANCE = 0x1909 + LUMINANCE_ALPHA = 0x190A + RED = 0x1903 + RGB = 0x1907 + RGBA = 0x1908 + STENCIL_INDEX = 0x1901 + + ALPHA12 = 0x803D + ALPHA16 = 0x803E + ALPHA4 = 0x803B + ALPHA8 = 0x803C + INTENSITY = 0x8049 + INTENSITY12 = 0x804C + INTENSITY16 = 0x804D + INTENSITY4 = 0x804A + INTENSITY8 = 0x804B + LUMINANCE12 = 0x8041 + LUMINANCE12_ALPHA12 = 0x8047 + LUMINANCE12_ALPHA4 = 0x8046 + LUMINANCE16 = 0x8042 + LUMINANCE16_ALPHA16 = 0x8048 + LUMINANCE4 = 0x803F + LUMINANCE4_ALPHA4 = 0x8043 + LUMINANCE6_ALPHA2 = 0x8044 + LUMINANCE8 = 0x8040 + LUMINANCE8_ALPHA8 = 0x8045 + R3_G3_B2 = 0x2A10 + RGB10 = 0x8052 + RGB10_A2 = 0x8059 + RGB12 = 0x8053 + RGB16 = 0x8054 + RGB4 = 0x804F + RGB5 = 0x8050 + RGB5_A1 = 0x8057 + RGB8 = 0x8051 + RGBA12 = 0x805A + RGBA16 = 0x805B + RGBA2 = 0x8055 + RGBA4 = 0x8056 + RGBA8 = 0x8058 + + PACK_IMAGE_HEIGHT = 0x806C + PACK_SKIP_IMAGES = 0x806B + UNPACK_IMAGE_HEIGHT = 0x806E + UNPACK_SKIP_IMAGES = 0x806D + + BITMAP = 0x1A00 + UNSIGNED_BYTE_3_3_2 = 0x8032 + UNSIGNED_INT_10_10_10_2 = 0x8036 + UNSIGNED_INT_8_8_8_8 = 0x8035 + UNSIGNED_SHORT_4_4_4_4 = 0x8033 + UNSIGNED_SHORT_5_5_5_1 = 0x8034 + + POINT_DISTANCE_ATTENUATION = 0x8129 + POINT_FADE_THRESHOLD_SIZE = 0x8128 + POINT_SIZE_MAX = 0x8127 + POINT_SIZE_MIN = 0x8126 + + LINES = 0x0001 + LINES_ADJACENCY = 0x000A + LINE_LOOP = 0x0002 + LINE_STRIP = 0x0003 + LINE_STRIP_ADJACENCY = 0x000B + PATCHES = 0x000E + POINTS = 0x0000 + POLYGON = 0x0009 + QUADS = 0x0007 + QUAD_STRIP = 0x0008 + TRIANGLES = 0x0004 + TRIANGLES_ADJACENCY = 0x000C + TRIANGLE_FAN = 0x0006 + TRIANGLE_STRIP = 0x0005 + TRIANGLE_STRIP_ADJACENCY = 0x000D + + FEEDBACK = 0x1C01 + RENDER = 0x1C00 + SELECT = 0x1C02 + + FLAT = 0x1D00 + SMOOTH = 0x1D01 + + DECR = 0x1E03 + INCR = 0x1E02 + KEEP = 0x1E00 + + EXTENSIONS = 0x1F03 + RENDERER = 0x1F01 + VENDOR = 0x1F00 + VERSION = 0x1F02 + + S = 0x2000 + T = 0x2001 + R = 0x2002 + Q = 0x2003 + + DECAL = 0x2101 + + TEXTURE_ENV_COLOR = 0x2201 + TEXTURE_ENV_MODE = 0x2200 + + TEXTURE_ENV = 0x2300 + + EYE_LINEAR = 0x2400 + OBJECT_LINEAR = 0x2401 + SPHERE_MAP = 0x2402 + + EYE_PLANE = 0x2502 + OBJECT_PLANE = 0x2501 + TEXTURE_GEN_MODE = 0x2500 + + NEAREST = 0x2600 + + LINEAR_MIPMAP_LINEAR = 0x2703 + LINEAR_MIPMAP_NEAREST = 0x2701 + NEAREST_MIPMAP_LINEAR = 0x2702 + NEAREST_MIPMAP_NEAREST = 0x2700 + + GENERATE_MIPMAP = 0x8191 + TEXTURE_WRAP_R = 0x8072 + + PROXY_TEXTURE_1D = 0x8063 + PROXY_TEXTURE_2D = 0x8064 + PROXY_TEXTURE_3D = 0x8070 + TEXTURE_3D = 0x806F + TEXTURE_BASE_LEVEL = 0x813C + TEXTURE_MAX_LEVEL = 0x813D + TEXTURE_MAX_LOD = 0x813B + TEXTURE_MIN_LOD = 0x813A + + CLAMP = 0x2900 + CLAMP_TO_BORDER = 0x812D + CLAMP_TO_EDGE = 0x812F + REPEAT = 0x2901 + + VERTEX_SHADER_BIT = 0x00000001 + FRAGMENT_SHADER_BIT = 0x00000002 + GEOMETRY_SHADER_BIT = 0x00000004 + TESS_CONTROL_SHADER_BIT = 0x00000008 + TESS_EVALUATION_SHADER_BIT = 0x00000010 + ALL_SHADER_BITS = 0xFFFFFFFF + + SYNC_FLUSH_COMMANDS_BIT = 0x00000001 + INVALID_INDEX = 0xFFFFFFFF + TIMEOUT_IGNORED = 0xFFFFFFFFFFFFFFFF + CONSTANT_COLOR = 0x8001 + ONE_MINUS_CONSTANT_COLOR = 0x8002 + CONSTANT_ALPHA = 0x8003 + ONE_MINUS_CONSTANT_ALPHA = 0x8004 + FUNC_ADD = 0x8006 + MIN = 0x8007 + MAX = 0x8008 + BLEND_EQUATION_RGB = 0x8009 + FUNC_SUBTRACT = 0x800A + FUNC_REVERSE_SUBTRACT = 0x800B + RESCALE_NORMAL = 0x803A + TEXTURE_DEPTH = 0x8071 + MAX_3D_TEXTURE_SIZE = 0x8073 + MULTISAMPLE = 0x809D + SAMPLE_ALPHA_TO_COVERAGE = 0x809E + SAMPLE_ALPHA_TO_ONE = 0x809F + SAMPLE_COVERAGE = 0x80A0 + SAMPLE_BUFFERS = 0x80A8 + SAMPLES = 0x80A9 + SAMPLE_COVERAGE_VALUE = 0x80AA + SAMPLE_COVERAGE_INVERT = 0x80AB + BLEND_DST_RGB = 0x80C8 + BLEND_SRC_RGB = 0x80C9 + BLEND_DST_ALPHA = 0x80CA + BLEND_SRC_ALPHA = 0x80CB + BGR = 0x80E0 + BGRA = 0x80E1 + MAX_ELEMENTS_VERTICES = 0x80E8 + MAX_ELEMENTS_INDICES = 0x80E9 + DEPTH_COMPONENT16 = 0x81A5 + DEPTH_COMPONENT24 = 0x81A6 + DEPTH_COMPONENT32 = 0x81A7 + FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210 + FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211 + FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212 + FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213 + FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214 + FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215 + FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216 + FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217 + FRAMEBUFFER_DEFAULT = 0x8218 + FRAMEBUFFER_UNDEFINED = 0x8219 + DEPTH_STENCIL_ATTACHMENT = 0x821A + MAJOR_VERSION = 0x821B + MINOR_VERSION = 0x821C + NUM_EXTENSIONS = 0x821D + CONTEXT_FLAGS = 0x821E + COMPRESSED_RED = 0x8225 + COMPRESSED_RG = 0x8226 + RG = 0x8227 + RG_INTEGER = 0x8228 + R8 = 0x8229 + R16 = 0x822A + RG8 = 0x822B + RG16 = 0x822C + R16F = 0x822D + R32F = 0x822E + RG16F = 0x822F + RG32F = 0x8230 + R8I = 0x8231 + R8UI = 0x8232 + R16I = 0x8233 + R16UI = 0x8234 + R32I = 0x8235 + R32UI = 0x8236 + RG8I = 0x8237 + RG8UI = 0x8238 + RG16I = 0x8239 + RG16UI = 0x823A + RG32I = 0x823B + RG32UI = 0x823C + PROGRAM_SEPARABLE = 0x8258 + ACTIVE_PROGRAM = 0x8259 + PROGRAM_PIPELINE_BINDING = 0x825A + MAX_VIEWPORTS = 0x825B + VIEWPORT_SUBPIXEL_BITS = 0x825C + VIEWPORT_BOUNDS_RANGE = 0x825D + LAYER_PROVOKING_VERTEX = 0x825E + VIEWPORT_INDEX_PROVOKING_VERTEX = 0x825F + UNDEFINED_VERTEX = 0x8260 + UNSIGNED_BYTE_2_3_3_REV = 0x8362 + UNSIGNED_SHORT_5_6_5 = 0x8363 + UNSIGNED_SHORT_5_6_5_REV = 0x8364 + UNSIGNED_SHORT_4_4_4_4_REV = 0x8365 + UNSIGNED_SHORT_1_5_5_5_REV = 0x8366 + UNSIGNED_INT_8_8_8_8_REV = 0x8367 + UNSIGNED_INT_2_10_10_10_REV = 0x8368 + MIRRORED_REPEAT = 0x8370 + FOG_COORDINATE_SOURCE = 0x8450 + FOG_COORD_SRC = 0x8450 + FOG_COORDINATE = 0x8451 + FOG_COORD = 0x8451 + FRAGMENT_DEPTH = 0x8452 + CURRENT_FOG_COORDINATE = 0x8453 + CURRENT_FOG_COORD = 0x8453 + FOG_COORDINATE_ARRAY_TYPE = 0x8454 + FOG_COORD_ARRAY_TYPE = 0x8454 + FOG_COORDINATE_ARRAY_STRIDE = 0x8455 + FOG_COORD_ARRAY_STRIDE = 0x8455 + FOG_COORDINATE_ARRAY_POINTER = 0x8456 + FOG_COORD_ARRAY_POINTER = 0x8456 + FOG_COORDINATE_ARRAY = 0x8457 + FOG_COORD_ARRAY = 0x8457 + COLOR_SUM = 0x8458 + CURRENT_SECONDARY_COLOR = 0x8459 + SECONDARY_COLOR_ARRAY_SIZE = 0x845A + SECONDARY_COLOR_ARRAY_TYPE = 0x845B + SECONDARY_COLOR_ARRAY_STRIDE = 0x845C + SECONDARY_COLOR_ARRAY_POINTER = 0x845D + SECONDARY_COLOR_ARRAY = 0x845E + CURRENT_RASTER_SECONDARY_COLOR = 0x845F + TEXTURE0 = 0x84C0 + TEXTURE1 = 0x84C1 + TEXTURE2 = 0x84C2 + TEXTURE3 = 0x84C3 + TEXTURE4 = 0x84C4 + TEXTURE5 = 0x84C5 + TEXTURE6 = 0x84C6 + TEXTURE7 = 0x84C7 + TEXTURE8 = 0x84C8 + TEXTURE9 = 0x84C9 + TEXTURE10 = 0x84CA + TEXTURE11 = 0x84CB + TEXTURE12 = 0x84CC + TEXTURE13 = 0x84CD + TEXTURE14 = 0x84CE + TEXTURE15 = 0x84CF + TEXTURE16 = 0x84D0 + TEXTURE17 = 0x84D1 + TEXTURE18 = 0x84D2 + TEXTURE19 = 0x84D3 + TEXTURE20 = 0x84D4 + TEXTURE21 = 0x84D5 + TEXTURE22 = 0x84D6 + TEXTURE23 = 0x84D7 + TEXTURE24 = 0x84D8 + TEXTURE25 = 0x84D9 + TEXTURE26 = 0x84DA + TEXTURE27 = 0x84DB + TEXTURE28 = 0x84DC + TEXTURE29 = 0x84DD + TEXTURE30 = 0x84DE + TEXTURE31 = 0x84DF + ACTIVE_TEXTURE = 0x84E0 + CLIENT_ACTIVE_TEXTURE = 0x84E1 + MAX_TEXTURE_UNITS = 0x84E2 + TRANSPOSE_MODELVIEW_MATRIX = 0x84E3 + TRANSPOSE_PROJECTION_MATRIX = 0x84E4 + TRANSPOSE_TEXTURE_MATRIX = 0x84E5 + TRANSPOSE_COLOR_MATRIX = 0x84E6 + SUBTRACT = 0x84E7 + MAX_RENDERBUFFER_SIZE = 0x84E8 + COMPRESSED_ALPHA = 0x84E9 + COMPRESSED_LUMINANCE = 0x84EA + COMPRESSED_LUMINANCE_ALPHA = 0x84EB + COMPRESSED_INTENSITY = 0x84EC + COMPRESSED_RGB = 0x84ED + COMPRESSED_RGBA = 0x84EE + UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER = 0x84F0 + UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x84F1 + TEXTURE_RECTANGLE = 0x84F5 + TEXTURE_BINDING_RECTANGLE = 0x84F6 + PROXY_TEXTURE_RECTANGLE = 0x84F7 + MAX_RECTANGLE_TEXTURE_SIZE = 0x84F8 + DEPTH_STENCIL = 0x84F9 + UNSIGNED_INT_24_8 = 0x84FA + MAX_TEXTURE_LOD_BIAS = 0x84FD + TEXTURE_FILTER_CONTROL = 0x8500 + TEXTURE_LOD_BIAS = 0x8501 + INCR_WRAP = 0x8507 + DECR_WRAP = 0x8508 + NORMAL_MAP = 0x8511 + REFLECTION_MAP = 0x8512 + TEXTURE_CUBE_MAP = 0x8513 + TEXTURE_BINDING_CUBE_MAP = 0x8514 + TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515 + TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516 + TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517 + TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518 + TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519 + TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A + PROXY_TEXTURE_CUBE_MAP = 0x851B + MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C + COMBINE = 0x8570 + COMBINE_RGB = 0x8571 + COMBINE_ALPHA = 0x8572 + RGB_SCALE = 0x8573 + ADD_SIGNED = 0x8574 + INTERPOLATE = 0x8575 + CONSTANT = 0x8576 + PRIMARY_COLOR = 0x8577 + PREVIOUS = 0x8578 + SOURCE0_RGB = 0x8580 + SRC0_RGB = 0x8580 + SOURCE1_RGB = 0x8581 + SRC1_RGB = 0x8581 + SOURCE2_RGB = 0x8582 + SRC2_RGB = 0x8582 + SOURCE0_ALPHA = 0x8588 + SRC0_ALPHA = 0x8588 + SOURCE1_ALPHA = 0x8589 + SRC1_ALPHA = 0x8589 + SOURCE2_ALPHA = 0x858A + SRC2_ALPHA = 0x858A + OPERAND0_RGB = 0x8590 + OPERAND1_RGB = 0x8591 + OPERAND2_RGB = 0x8592 + OPERAND0_ALPHA = 0x8598 + OPERAND1_ALPHA = 0x8599 + OPERAND2_ALPHA = 0x859A + VERTEX_ARRAY_BINDING = 0x85B5 + VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622 + VERTEX_ATTRIB_ARRAY_SIZE = 0x8623 + VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624 + VERTEX_ATTRIB_ARRAY_TYPE = 0x8625 + CURRENT_VERTEX_ATTRIB = 0x8626 + VERTEX_PROGRAM_POINT_SIZE = 0x8642 + PROGRAM_POINT_SIZE = 0x8642 + VERTEX_PROGRAM_TWO_SIDE = 0x8643 + VERTEX_ATTRIB_ARRAY_POINTER = 0x8645 + DEPTH_CLAMP = 0x864F + TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0 + TEXTURE_COMPRESSED = 0x86A1 + NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2 + COMPRESSED_TEXTURE_FORMATS = 0x86A3 + DOT3_RGB = 0x86AE + DOT3_RGBA = 0x86AF + PROGRAM_BINARY_LENGTH = 0x8741 + BUFFER_SIZE = 0x8764 + BUFFER_USAGE = 0x8765 + NUM_PROGRAM_BINARY_FORMATS = 0x87FE + PROGRAM_BINARY_FORMATS = 0x87FF + STENCIL_BACK_FUNC = 0x8800 + STENCIL_BACK_FAIL = 0x8801 + STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802 + STENCIL_BACK_PASS_DEPTH_PASS = 0x8803 + RGBA32F = 0x8814 + RGB32F = 0x8815 + RGBA16F = 0x881A + RGB16F = 0x881B + MAX_DRAW_BUFFERS = 0x8824 + DRAW_BUFFER0 = 0x8825 + DRAW_BUFFER1 = 0x8826 + DRAW_BUFFER2 = 0x8827 + DRAW_BUFFER3 = 0x8828 + DRAW_BUFFER4 = 0x8829 + DRAW_BUFFER5 = 0x882A + DRAW_BUFFER6 = 0x882B + DRAW_BUFFER7 = 0x882C + DRAW_BUFFER8 = 0x882D + DRAW_BUFFER9 = 0x882E + DRAW_BUFFER10 = 0x882F + DRAW_BUFFER11 = 0x8830 + DRAW_BUFFER12 = 0x8831 + DRAW_BUFFER13 = 0x8832 + DRAW_BUFFER14 = 0x8833 + DRAW_BUFFER15 = 0x8834 + BLEND_EQUATION_ALPHA = 0x883D + TEXTURE_DEPTH_SIZE = 0x884A + DEPTH_TEXTURE_MODE = 0x884B + TEXTURE_COMPARE_MODE = 0x884C + TEXTURE_COMPARE_FUNC = 0x884D + COMPARE_R_TO_TEXTURE = 0x884E + COMPARE_REF_TO_TEXTURE = 0x884E + TEXTURE_CUBE_MAP_SEAMLESS = 0x884F + POINT_SPRITE = 0x8861 + COORD_REPLACE = 0x8862 + QUERY_COUNTER_BITS = 0x8864 + CURRENT_QUERY = 0x8865 + QUERY_RESULT = 0x8866 + QUERY_RESULT_AVAILABLE = 0x8867 + MAX_VERTEX_ATTRIBS = 0x8869 + VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A + MAX_TESS_CONTROL_INPUT_COMPONENTS = 0x886C + MAX_TESS_EVALUATION_INPUT_COMPONENTS = 0x886D + MAX_TEXTURE_COORDS = 0x8871 + MAX_TEXTURE_IMAGE_UNITS = 0x8872 + GEOMETRY_SHADER_INVOCATIONS = 0x887F + ARRAY_BUFFER = 0x8892 + ELEMENT_ARRAY_BUFFER = 0x8893 + ARRAY_BUFFER_BINDING = 0x8894 + ELEMENT_ARRAY_BUFFER_BINDING = 0x8895 + VERTEX_ARRAY_BUFFER_BINDING = 0x8896 + NORMAL_ARRAY_BUFFER_BINDING = 0x8897 + COLOR_ARRAY_BUFFER_BINDING = 0x8898 + INDEX_ARRAY_BUFFER_BINDING = 0x8899 + TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A + EDGE_FLAG_ARRAY_BUFFER_BINDING = 0x889B + SECONDARY_COLOR_ARRAY_BUFFER_BINDING = 0x889C + FOG_COORDINATE_ARRAY_BUFFER_BINDING = 0x889D + FOG_COORD_ARRAY_BUFFER_BINDING = 0x889D + WEIGHT_ARRAY_BUFFER_BINDING = 0x889E + VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F + READ_ONLY = 0x88B8 + WRITE_ONLY = 0x88B9 + READ_WRITE = 0x88BA + BUFFER_ACCESS = 0x88BB + BUFFER_MAPPED = 0x88BC + BUFFER_MAP_POINTER = 0x88BD + TIME_ELAPSED = 0x88BF + STREAM_DRAW = 0x88E0 + STREAM_READ = 0x88E1 + STREAM_COPY = 0x88E2 + STATIC_DRAW = 0x88E4 + STATIC_READ = 0x88E5 + STATIC_COPY = 0x88E6 + DYNAMIC_DRAW = 0x88E8 + DYNAMIC_READ = 0x88E9 + DYNAMIC_COPY = 0x88EA + PIXEL_PACK_BUFFER = 0x88EB + PIXEL_UNPACK_BUFFER = 0x88EC + PIXEL_PACK_BUFFER_BINDING = 0x88ED + PIXEL_UNPACK_BUFFER_BINDING = 0x88EF + DEPTH24_STENCIL8 = 0x88F0 + TEXTURE_STENCIL_SIZE = 0x88F1 + SRC1_COLOR = 0x88F9 + ONE_MINUS_SRC1_COLOR = 0x88FA + ONE_MINUS_SRC1_ALPHA = 0x88FB + MAX_DUAL_SOURCE_DRAW_BUFFERS = 0x88FC + VERTEX_ATTRIB_ARRAY_INTEGER = 0x88FD + VERTEX_ATTRIB_ARRAY_DIVISOR = 0x88FE + MAX_ARRAY_TEXTURE_LAYERS = 0x88FF + MIN_PROGRAM_TEXEL_OFFSET = 0x8904 + MAX_PROGRAM_TEXEL_OFFSET = 0x8905 + SAMPLES_PASSED = 0x8914 + GEOMETRY_VERTICES_OUT = 0x8916 + GEOMETRY_INPUT_TYPE = 0x8917 + GEOMETRY_OUTPUT_TYPE = 0x8918 + SAMPLER_BINDING = 0x8919 + CLAMP_VERTEX_COLOR = 0x891A + CLAMP_FRAGMENT_COLOR = 0x891B + CLAMP_READ_COLOR = 0x891C + FIXED_ONLY = 0x891D + UNIFORM_BUFFER = 0x8A11 + UNIFORM_BUFFER_BINDING = 0x8A28 + UNIFORM_BUFFER_START = 0x8A29 + UNIFORM_BUFFER_SIZE = 0x8A2A + MAX_VERTEX_UNIFORM_BLOCKS = 0x8A2B + MAX_GEOMETRY_UNIFORM_BLOCKS = 0x8A2C + MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8A2D + MAX_COMBINED_UNIFORM_BLOCKS = 0x8A2E + MAX_UNIFORM_BUFFER_BINDINGS = 0x8A2F + MAX_UNIFORM_BLOCK_SIZE = 0x8A30 + MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31 + MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 0x8A32 + MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33 + UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8A34 + ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35 + ACTIVE_UNIFORM_BLOCKS = 0x8A36 + UNIFORM_TYPE = 0x8A37 + UNIFORM_SIZE = 0x8A38 + UNIFORM_NAME_LENGTH = 0x8A39 + UNIFORM_BLOCK_INDEX = 0x8A3A + UNIFORM_OFFSET = 0x8A3B + UNIFORM_ARRAY_STRIDE = 0x8A3C + UNIFORM_MATRIX_STRIDE = 0x8A3D + UNIFORM_IS_ROW_MAJOR = 0x8A3E + UNIFORM_BLOCK_BINDING = 0x8A3F + UNIFORM_BLOCK_DATA_SIZE = 0x8A40 + UNIFORM_BLOCK_NAME_LENGTH = 0x8A41 + UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8A42 + UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43 + UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44 + UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 0x8A45 + UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46 + FRAGMENT_SHADER = 0x8B30 + VERTEX_SHADER = 0x8B31 + MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49 + MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A + MAX_VARYING_FLOATS = 0x8B4B + MAX_VARYING_COMPONENTS = 0x8B4B + MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C + MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D + SHADER_TYPE = 0x8B4F + FLOAT_VEC2 = 0x8B50 + FLOAT_VEC3 = 0x8B51 + FLOAT_VEC4 = 0x8B52 + INT_VEC2 = 0x8B53 + INT_VEC3 = 0x8B54 + INT_VEC4 = 0x8B55 + BOOL = 0x8B56 + BOOL_VEC2 = 0x8B57 + BOOL_VEC3 = 0x8B58 + BOOL_VEC4 = 0x8B59 + FLOAT_MAT2 = 0x8B5A + FLOAT_MAT3 = 0x8B5B + FLOAT_MAT4 = 0x8B5C + SAMPLER_1D = 0x8B5D + SAMPLER_2D = 0x8B5E + SAMPLER_3D = 0x8B5F + SAMPLER_CUBE = 0x8B60 + SAMPLER_1D_SHADOW = 0x8B61 + SAMPLER_2D_SHADOW = 0x8B62 + SAMPLER_2D_RECT = 0x8B63 + SAMPLER_2D_RECT_SHADOW = 0x8B64 + FLOAT_MAT2x3 = 0x8B65 + FLOAT_MAT2x4 = 0x8B66 + FLOAT_MAT3x2 = 0x8B67 + FLOAT_MAT3x4 = 0x8B68 + FLOAT_MAT4x2 = 0x8B69 + FLOAT_MAT4x3 = 0x8B6A + DELETE_STATUS = 0x8B80 + COMPILE_STATUS = 0x8B81 + LINK_STATUS = 0x8B82 + VALIDATE_STATUS = 0x8B83 + INFO_LOG_LENGTH = 0x8B84 + ATTACHED_SHADERS = 0x8B85 + ACTIVE_UNIFORMS = 0x8B86 + ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87 + SHADER_SOURCE_LENGTH = 0x8B88 + ACTIVE_ATTRIBUTES = 0x8B89 + ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A + SHADING_LANGUAGE_VERSION = 0x8B8C + CURRENT_PROGRAM = 0x8B8D + IMPLEMENTATION_COLOR_READ_TYPE = 0x8B9A + IMPLEMENTATION_COLOR_READ_FORMAT = 0x8B9B + TEXTURE_RED_TYPE = 0x8C10 + TEXTURE_GREEN_TYPE = 0x8C11 + TEXTURE_BLUE_TYPE = 0x8C12 + TEXTURE_ALPHA_TYPE = 0x8C13 + TEXTURE_DEPTH_TYPE = 0x8C16 + UNSIGNED_NORMALIZED = 0x8C17 + TEXTURE_1D_ARRAY = 0x8C18 + PROXY_TEXTURE_1D_ARRAY = 0x8C19 + TEXTURE_2D_ARRAY = 0x8C1A + PROXY_TEXTURE_2D_ARRAY = 0x8C1B + TEXTURE_BINDING_1D_ARRAY = 0x8C1C + TEXTURE_BINDING_2D_ARRAY = 0x8C1D + MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = 0x8C29 + TEXTURE_BUFFER = 0x8C2A + MAX_TEXTURE_BUFFER_SIZE = 0x8C2B + TEXTURE_BINDING_BUFFER = 0x8C2C + TEXTURE_BUFFER_DATA_STORE_BINDING = 0x8C2D + ANY_SAMPLES_PASSED = 0x8C2F + SAMPLE_SHADING = 0x8C36 + MIN_SAMPLE_SHADING_VALUE = 0x8C37 + R11F_G11F_B10F = 0x8C3A + UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B + RGB9_E5 = 0x8C3D + UNSIGNED_INT_5_9_9_9_REV = 0x8C3E + TEXTURE_SHARED_SIZE = 0x8C3F + SRGB = 0x8C40 + SRGB8 = 0x8C41 + SRGB_ALPHA = 0x8C42 + SRGB8_ALPHA8 = 0x8C43 + SLUMINANCE_ALPHA = 0x8C44 + SLUMINANCE8_ALPHA8 = 0x8C45 + SLUMINANCE = 0x8C46 + SLUMINANCE8 = 0x8C47 + COMPRESSED_SRGB = 0x8C48 + COMPRESSED_SRGB_ALPHA = 0x8C49 + COMPRESSED_SLUMINANCE = 0x8C4A + COMPRESSED_SLUMINANCE_ALPHA = 0x8C4B + TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76 + TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F + MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80 + TRANSFORM_FEEDBACK_VARYINGS = 0x8C83 + TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84 + TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85 + PRIMITIVES_GENERATED = 0x8C87 + TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88 + RASTERIZER_DISCARD = 0x8C89 + MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A + MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B + INTERLEAVED_ATTRIBS = 0x8C8C + SEPARATE_ATTRIBS = 0x8C8D + TRANSFORM_FEEDBACK_BUFFER = 0x8C8E + TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F + POINT_SPRITE_COORD_ORIGIN = 0x8CA0 + LOWER_LEFT = 0x8CA1 + UPPER_LEFT = 0x8CA2 + STENCIL_BACK_REF = 0x8CA3 + STENCIL_BACK_VALUE_MASK = 0x8CA4 + STENCIL_BACK_WRITEMASK = 0x8CA5 + DRAW_FRAMEBUFFER_BINDING = 0x8CA6 + FRAMEBUFFER_BINDING = 0x8CA6 + RENDERBUFFER_BINDING = 0x8CA7 + READ_FRAMEBUFFER = 0x8CA8 + DRAW_FRAMEBUFFER = 0x8CA9 + READ_FRAMEBUFFER_BINDING = 0x8CAA + RENDERBUFFER_SAMPLES = 0x8CAB + DEPTH_COMPONENT32F = 0x8CAC + DEPTH32F_STENCIL8 = 0x8CAD + FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0 + FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1 + FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2 + FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3 + FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4 + FRAMEBUFFER_COMPLETE = 0x8CD5 + FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6 + FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7 + FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB + FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC + FRAMEBUFFER_UNSUPPORTED = 0x8CDD + MAX_COLOR_ATTACHMENTS = 0x8CDF + COLOR_ATTACHMENT0 = 0x8CE0 + COLOR_ATTACHMENT1 = 0x8CE1 + COLOR_ATTACHMENT2 = 0x8CE2 + COLOR_ATTACHMENT3 = 0x8CE3 + COLOR_ATTACHMENT4 = 0x8CE4 + COLOR_ATTACHMENT5 = 0x8CE5 + COLOR_ATTACHMENT6 = 0x8CE6 + COLOR_ATTACHMENT7 = 0x8CE7 + COLOR_ATTACHMENT8 = 0x8CE8 + COLOR_ATTACHMENT9 = 0x8CE9 + COLOR_ATTACHMENT10 = 0x8CEA + COLOR_ATTACHMENT11 = 0x8CEB + COLOR_ATTACHMENT12 = 0x8CEC + COLOR_ATTACHMENT13 = 0x8CED + COLOR_ATTACHMENT14 = 0x8CEE + COLOR_ATTACHMENT15 = 0x8CEF + DEPTH_ATTACHMENT = 0x8D00 + STENCIL_ATTACHMENT = 0x8D20 + FRAMEBUFFER = 0x8D40 + RENDERBUFFER = 0x8D41 + RENDERBUFFER_WIDTH = 0x8D42 + RENDERBUFFER_HEIGHT = 0x8D43 + RENDERBUFFER_INTERNAL_FORMAT = 0x8D44 + STENCIL_INDEX1 = 0x8D46 + STENCIL_INDEX4 = 0x8D47 + STENCIL_INDEX8 = 0x8D48 + STENCIL_INDEX16 = 0x8D49 + RENDERBUFFER_RED_SIZE = 0x8D50 + RENDERBUFFER_GREEN_SIZE = 0x8D51 + RENDERBUFFER_BLUE_SIZE = 0x8D52 + RENDERBUFFER_ALPHA_SIZE = 0x8D53 + RENDERBUFFER_DEPTH_SIZE = 0x8D54 + RENDERBUFFER_STENCIL_SIZE = 0x8D55 + FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56 + MAX_SAMPLES = 0x8D57 + RGB565 = 0x8D62 + RGBA32UI = 0x8D70 + RGB32UI = 0x8D71 + RGBA16UI = 0x8D76 + RGB16UI = 0x8D77 + RGBA8UI = 0x8D7C + RGB8UI = 0x8D7D + RGBA32I = 0x8D82 + RGB32I = 0x8D83 + RGBA16I = 0x8D88 + RGB16I = 0x8D89 + RGBA8I = 0x8D8E + RGB8I = 0x8D8F + RED_INTEGER = 0x8D94 + GREEN_INTEGER = 0x8D95 + BLUE_INTEGER = 0x8D96 + ALPHA_INTEGER = 0x8D97 + RGB_INTEGER = 0x8D98 + RGBA_INTEGER = 0x8D99 + BGR_INTEGER = 0x8D9A + BGRA_INTEGER = 0x8D9B + INT_2_10_10_10_REV = 0x8D9F + FRAMEBUFFER_ATTACHMENT_LAYERED = 0x8DA7 + FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = 0x8DA8 + FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD + FRAMEBUFFER_SRGB = 0x8DB9 + COMPRESSED_RED_RGTC1 = 0x8DBB + COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC + COMPRESSED_RG_RGTC2 = 0x8DBD + COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE + SAMPLER_1D_ARRAY = 0x8DC0 + SAMPLER_2D_ARRAY = 0x8DC1 + SAMPLER_BUFFER = 0x8DC2 + SAMPLER_1D_ARRAY_SHADOW = 0x8DC3 + SAMPLER_2D_ARRAY_SHADOW = 0x8DC4 + SAMPLER_CUBE_SHADOW = 0x8DC5 + UNSIGNED_INT_VEC2 = 0x8DC6 + UNSIGNED_INT_VEC3 = 0x8DC7 + UNSIGNED_INT_VEC4 = 0x8DC8 + INT_SAMPLER_1D = 0x8DC9 + INT_SAMPLER_2D = 0x8DCA + INT_SAMPLER_3D = 0x8DCB + INT_SAMPLER_CUBE = 0x8DCC + INT_SAMPLER_2D_RECT = 0x8DCD + INT_SAMPLER_1D_ARRAY = 0x8DCE + INT_SAMPLER_2D_ARRAY = 0x8DCF + INT_SAMPLER_BUFFER = 0x8DD0 + UNSIGNED_INT_SAMPLER_1D = 0x8DD1 + UNSIGNED_INT_SAMPLER_2D = 0x8DD2 + UNSIGNED_INT_SAMPLER_3D = 0x8DD3 + UNSIGNED_INT_SAMPLER_CUBE = 0x8DD4 + UNSIGNED_INT_SAMPLER_2D_RECT = 0x8DD5 + UNSIGNED_INT_SAMPLER_1D_ARRAY = 0x8DD6 + UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8DD7 + UNSIGNED_INT_SAMPLER_BUFFER = 0x8DD8 + GEOMETRY_SHADER = 0x8DD9 + MAX_GEOMETRY_UNIFORM_COMPONENTS = 0x8DDF + MAX_GEOMETRY_OUTPUT_VERTICES = 0x8DE0 + MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = 0x8DE1 + ACTIVE_SUBROUTINES = 0x8DE5 + ACTIVE_SUBROUTINE_UNIFORMS = 0x8DE6 + MAX_SUBROUTINES = 0x8DE7 + MAX_SUBROUTINE_UNIFORM_LOCATIONS = 0x8DE8 + LOW_FLOAT = 0x8DF0 + MEDIUM_FLOAT = 0x8DF1 + HIGH_FLOAT = 0x8DF2 + LOW_INT = 0x8DF3 + MEDIUM_INT = 0x8DF4 + HIGH_INT = 0x8DF5 + SHADER_BINARY_FORMATS = 0x8DF8 + NUM_SHADER_BINARY_FORMATS = 0x8DF9 + SHADER_COMPILER = 0x8DFA + MAX_VERTEX_UNIFORM_VECTORS = 0x8DFB + MAX_VARYING_VECTORS = 0x8DFC + MAX_FRAGMENT_UNIFORM_VECTORS = 0x8DFD + QUERY_WAIT = 0x8E13 + QUERY_NO_WAIT = 0x8E14 + QUERY_BY_REGION_WAIT = 0x8E15 + QUERY_BY_REGION_NO_WAIT = 0x8E16 + MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E1E + MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E1F + TRANSFORM_FEEDBACK = 0x8E22 + TRANSFORM_FEEDBACK_BUFFER_PAUSED = 0x8E23 + TRANSFORM_FEEDBACK_BUFFER_ACTIVE = 0x8E24 + TRANSFORM_FEEDBACK_BINDING = 0x8E25 + TIMESTAMP = 0x8E28 + TEXTURE_SWIZZLE_R = 0x8E42 + TEXTURE_SWIZZLE_G = 0x8E43 + TEXTURE_SWIZZLE_B = 0x8E44 + TEXTURE_SWIZZLE_A = 0x8E45 + TEXTURE_SWIZZLE_RGBA = 0x8E46 + ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS = 0x8E47 + ACTIVE_SUBROUTINE_MAX_LENGTH = 0x8E48 + ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH = 0x8E49 + NUM_COMPATIBLE_SUBROUTINES = 0x8E4A + COMPATIBLE_SUBROUTINES = 0x8E4B + QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = 0x8E4C + FIRST_VERTEX_CONVENTION = 0x8E4D + LAST_VERTEX_CONVENTION = 0x8E4E + PROVOKING_VERTEX = 0x8E4F + SAMPLE_POSITION = 0x8E50 + SAMPLE_MASK = 0x8E51 + SAMPLE_MASK_VALUE = 0x8E52 + MAX_SAMPLE_MASK_WORDS = 0x8E59 + MAX_GEOMETRY_SHADER_INVOCATIONS = 0x8E5A + MIN_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5B + MAX_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5C + FRAGMENT_INTERPOLATION_OFFSET_BITS = 0x8E5D + MIN_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5E + MAX_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5F + MAX_TRANSFORM_FEEDBACK_BUFFERS = 0x8E70 + MAX_VERTEX_STREAMS = 0x8E71 + PATCH_VERTICES = 0x8E72 + PATCH_DEFAULT_INNER_LEVEL = 0x8E73 + PATCH_DEFAULT_OUTER_LEVEL = 0x8E74 + TESS_CONTROL_OUTPUT_VERTICES = 0x8E75 + TESS_GEN_MODE = 0x8E76 + TESS_GEN_SPACING = 0x8E77 + TESS_GEN_VERTEX_ORDER = 0x8E78 + TESS_GEN_POINT_MODE = 0x8E79 + ISOLINES = 0x8E7A + FRACTIONAL_ODD = 0x8E7B + FRACTIONAL_EVEN = 0x8E7C + MAX_PATCH_VERTICES = 0x8E7D + MAX_TESS_GEN_LEVEL = 0x8E7E + MAX_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E7F + MAX_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E80 + MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS = 0x8E81 + MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS = 0x8E82 + MAX_TESS_CONTROL_OUTPUT_COMPONENTS = 0x8E83 + MAX_TESS_PATCH_COMPONENTS = 0x8E84 + MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS = 0x8E85 + MAX_TESS_EVALUATION_OUTPUT_COMPONENTS = 0x8E86 + TESS_EVALUATION_SHADER = 0x8E87 + TESS_CONTROL_SHADER = 0x8E88 + MAX_TESS_CONTROL_UNIFORM_BLOCKS = 0x8E89 + MAX_TESS_EVALUATION_UNIFORM_BLOCKS = 0x8E8A + COMPRESSED_RGBA_BPTC_UNORM = 0x8E8C + COMPRESSED_SRGB_ALPHA_BPTC_UNORM = 0x8E8D + COMPRESSED_RGB_BPTC_SIGNED_FLOAT = 0x8E8E + COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT = 0x8E8F + COPY_READ_BUFFER = 0x8F36 + COPY_WRITE_BUFFER = 0x8F37 + MAX_IMAGE_UNITS = 0x8F38 + MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS = 0x8F39 + IMAGE_BINDING_NAME = 0x8F3A + IMAGE_BINDING_LEVEL = 0x8F3B + IMAGE_BINDING_LAYERED = 0x8F3C + IMAGE_BINDING_LAYER = 0x8F3D + IMAGE_BINDING_ACCESS = 0x8F3E + DRAW_INDIRECT_BUFFER = 0x8F3F + DRAW_INDIRECT_BUFFER_BINDING = 0x8F43 + DOUBLE_MAT2 = 0x8F46 + DOUBLE_MAT3 = 0x8F47 + DOUBLE_MAT4 = 0x8F48 + DOUBLE_MAT2x3 = 0x8F49 + DOUBLE_MAT2x4 = 0x8F4A + DOUBLE_MAT3x2 = 0x8F4B + DOUBLE_MAT3x4 = 0x8F4C + DOUBLE_MAT4x2 = 0x8F4D + DOUBLE_MAT4x3 = 0x8F4E + R8_SNORM = 0x8F94 + RG8_SNORM = 0x8F95 + RGB8_SNORM = 0x8F96 + RGBA8_SNORM = 0x8F97 + R16_SNORM = 0x8F98 + RG16_SNORM = 0x8F99 + RGB16_SNORM = 0x8F9A + RGBA16_SNORM = 0x8F9B + SIGNED_NORMALIZED = 0x8F9C + PRIMITIVE_RESTART = 0x8F9D + PRIMITIVE_RESTART_INDEX = 0x8F9E + DOUBLE_VEC2 = 0x8FFC + DOUBLE_VEC3 = 0x8FFD + DOUBLE_VEC4 = 0x8FFE + TEXTURE_CUBE_MAP_ARRAY = 0x9009 + TEXTURE_BINDING_CUBE_MAP_ARRAY = 0x900A + PROXY_TEXTURE_CUBE_MAP_ARRAY = 0x900B + SAMPLER_CUBE_MAP_ARRAY = 0x900C + SAMPLER_CUBE_MAP_ARRAY_SHADOW = 0x900D + INT_SAMPLER_CUBE_MAP_ARRAY = 0x900E + UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY = 0x900F + IMAGE_1D = 0x904C + IMAGE_2D = 0x904D + IMAGE_3D = 0x904E + IMAGE_2D_RECT = 0x904F + IMAGE_CUBE = 0x9050 + IMAGE_BUFFER = 0x9051 + IMAGE_1D_ARRAY = 0x9052 + IMAGE_2D_ARRAY = 0x9053 + IMAGE_CUBE_MAP_ARRAY = 0x9054 + IMAGE_2D_MULTISAMPLE = 0x9055 + IMAGE_2D_MULTISAMPLE_ARRAY = 0x9056 + INT_IMAGE_1D = 0x9057 + INT_IMAGE_2D = 0x9058 + INT_IMAGE_3D = 0x9059 + INT_IMAGE_2D_RECT = 0x905A + INT_IMAGE_CUBE = 0x905B + INT_IMAGE_BUFFER = 0x905C + INT_IMAGE_1D_ARRAY = 0x905D + INT_IMAGE_2D_ARRAY = 0x905E + INT_IMAGE_CUBE_MAP_ARRAY = 0x905F + INT_IMAGE_2D_MULTISAMPLE = 0x9060 + INT_IMAGE_2D_MULTISAMPLE_ARRAY = 0x9061 + UNSIGNED_INT_IMAGE_1D = 0x9062 + UNSIGNED_INT_IMAGE_2D = 0x9063 + UNSIGNED_INT_IMAGE_3D = 0x9064 + UNSIGNED_INT_IMAGE_2D_RECT = 0x9065 + UNSIGNED_INT_IMAGE_CUBE = 0x9066 + UNSIGNED_INT_IMAGE_BUFFER = 0x9067 + UNSIGNED_INT_IMAGE_1D_ARRAY = 0x9068 + UNSIGNED_INT_IMAGE_2D_ARRAY = 0x9069 + UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY = 0x906A + UNSIGNED_INT_IMAGE_2D_MULTISAMPLE = 0x906B + UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY = 0x906C + MAX_IMAGE_SAMPLES = 0x906D + IMAGE_BINDING_FORMAT = 0x906E + RGB10_A2UI = 0x906F + MIN_MAP_BUFFER_ALIGNMENT = 0x90BC + IMAGE_FORMAT_COMPATIBILITY_TYPE = 0x90C7 + IMAGE_FORMAT_COMPATIBILITY_BY_SIZE = 0x90C8 + IMAGE_FORMAT_COMPATIBILITY_BY_CLASS = 0x90C9 + MAX_VERTEX_IMAGE_UNIFORMS = 0x90CA + MAX_TESS_CONTROL_IMAGE_UNIFORMS = 0x90CB + MAX_TESS_EVALUATION_IMAGE_UNIFORMS = 0x90CC + MAX_GEOMETRY_IMAGE_UNIFORMS = 0x90CD + MAX_FRAGMENT_IMAGE_UNIFORMS = 0x90CE + MAX_COMBINED_IMAGE_UNIFORMS = 0x90CF + TEXTURE_2D_MULTISAMPLE = 0x9100 + PROXY_TEXTURE_2D_MULTISAMPLE = 0x9101 + TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9102 + PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9103 + TEXTURE_BINDING_2D_MULTISAMPLE = 0x9104 + TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = 0x9105 + TEXTURE_SAMPLES = 0x9106 + TEXTURE_FIXED_SAMPLE_LOCATIONS = 0x9107 + SAMPLER_2D_MULTISAMPLE = 0x9108 + INT_SAMPLER_2D_MULTISAMPLE = 0x9109 + UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = 0x910A + SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910B + INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910C + UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910D + MAX_COLOR_TEXTURE_SAMPLES = 0x910E + MAX_DEPTH_TEXTURE_SAMPLES = 0x910F + MAX_INTEGER_SAMPLES = 0x9110 + MAX_SERVER_WAIT_TIMEOUT = 0x9111 + OBJECT_TYPE = 0x9112 + SYNC_CONDITION = 0x9113 + SYNC_STATUS = 0x9114 + SYNC_FLAGS = 0x9115 + SYNC_FENCE = 0x9116 + SYNC_GPU_COMMANDS_COMPLETE = 0x9117 + UNSIGNALED = 0x9118 + SIGNALED = 0x9119 + ALREADY_SIGNALED = 0x911A + TIMEOUT_EXPIRED = 0x911B + CONDITION_SATISFIED = 0x911C + WAIT_FAILED = 0x911D + BUFFER_ACCESS_FLAGS = 0x911F + BUFFER_MAP_LENGTH = 0x9120 + BUFFER_MAP_OFFSET = 0x9121 + MAX_VERTEX_OUTPUT_COMPONENTS = 0x9122 + MAX_GEOMETRY_INPUT_COMPONENTS = 0x9123 + MAX_GEOMETRY_OUTPUT_COMPONENTS = 0x9124 + MAX_FRAGMENT_INPUT_COMPONENTS = 0x9125 + CONTEXT_PROFILE_MASK = 0x9126 + UNPACK_COMPRESSED_BLOCK_WIDTH = 0x9127 + UNPACK_COMPRESSED_BLOCK_HEIGHT = 0x9128 + UNPACK_COMPRESSED_BLOCK_DEPTH = 0x9129 + UNPACK_COMPRESSED_BLOCK_SIZE = 0x912A + PACK_COMPRESSED_BLOCK_WIDTH = 0x912B + PACK_COMPRESSED_BLOCK_HEIGHT = 0x912C + PACK_COMPRESSED_BLOCK_DEPTH = 0x912D + PACK_COMPRESSED_BLOCK_SIZE = 0x912E + TEXTURE_IMMUTABLE_FORMAT = 0x912F + ATOMIC_COUNTER_BUFFER = 0x92C0 + ATOMIC_COUNTER_BUFFER_BINDING = 0x92C1 + ATOMIC_COUNTER_BUFFER_START = 0x92C2 + ATOMIC_COUNTER_BUFFER_SIZE = 0x92C3 + ATOMIC_COUNTER_BUFFER_DATA_SIZE = 0x92C4 + ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS = 0x92C5 + ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES = 0x92C6 + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER = 0x92C7 + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER = 0x92C8 + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x92C9 + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER = 0x92CA + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER = 0x92CB + MAX_VERTEX_ATOMIC_COUNTER_BUFFERS = 0x92CC + MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS = 0x92CD + MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS = 0x92CE + MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS = 0x92CF + MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS = 0x92D0 + MAX_COMBINED_ATOMIC_COUNTER_BUFFERS = 0x92D1 + MAX_VERTEX_ATOMIC_COUNTERS = 0x92D2 + MAX_TESS_CONTROL_ATOMIC_COUNTERS = 0x92D3 + MAX_TESS_EVALUATION_ATOMIC_COUNTERS = 0x92D4 + MAX_GEOMETRY_ATOMIC_COUNTERS = 0x92D5 + MAX_FRAGMENT_ATOMIC_COUNTERS = 0x92D6 + MAX_COMBINED_ATOMIC_COUNTERS = 0x92D7 + MAX_ATOMIC_COUNTER_BUFFER_SIZE = 0x92D8 + ACTIVE_ATOMIC_COUNTER_BUFFERS = 0x92D9 + UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX = 0x92DA + UNSIGNED_INT_ATOMIC_COUNTER = 0x92DB + MAX_ATOMIC_COUNTER_BUFFER_BINDINGS = 0x92DC + NUM_SAMPLE_COUNTS = 0x9380 +) + +// https://www.opengl.org/sdk/docs/man4/xhtml/glViewport.xml +func (gl *GL) Viewport(x, y, width, height int) { + C.gl4_2core_glViewport(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// DepthRange specifies the mapping of depth values from normalized device +// coordinates to window coordinates. +// +// Parameter nearVal specifies the mapping of the near clipping plane to window +// coordinates (defaults to 0), while farVal specifies the mapping of the far +// clipping plane to window coordinates (defaults to 1). +// +// After clipping and division by w, depth coordinates range from -1 to 1, +// corresponding to the near and far clipping planes. DepthRange specifies a +// linear mapping of the normalized depth coordinates in this range to window +// depth coordinates. Regardless of the actual depth buffer implementation, +// window coordinate depth values are treated as though they range from 0 through 1 +// (like color components). Thus, the values accepted by DepthRange are both +// clamped to this range before they are accepted. +// +// The default setting of (0, 1) maps the near plane to 0 and the far plane to 1. +// With this mapping, the depth buffer range is fully utilized. +// +// It is not necessary that nearVal be less than farVal. Reverse mappings such as +// nearVal 1, and farVal 0 are acceptable. +// +// GL.INVALID_OPERATION is generated if DepthRange is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) DepthRange(nearVal, farVal float64) { + C.gl4_2core_glDepthRange(gl.funcs, C.GLdouble(nearVal), C.GLdouble(farVal)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsEnabled.xml +func (gl *GL) IsEnabled(cap glbase.Enum) bool { + glresult := C.gl4_2core_glIsEnabled(gl.funcs, C.GLenum(cap)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexLevelParameteriv.xml +func (gl *GL) GetTexLevelParameteriv(target glbase.Enum, level int, pname glbase.Enum, params []int32) { + C.gl4_2core_glGetTexLevelParameteriv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexLevelParameterfv.xml +func (gl *GL) GetTexLevelParameterfv(target glbase.Enum, level int, pname glbase.Enum, params []float32) { + C.gl4_2core_glGetTexLevelParameterfv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameteriv.xml +func (gl *GL) GetTexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_2core_glGetTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameterfv.xml +func (gl *GL) GetTexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_2core_glGetTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexImage.xml +func (gl *GL) GetTexImage(target glbase.Enum, level int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_2core_glGetTexImage(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetIntegerv.xml +func (gl *GL) GetIntegerv(pname glbase.Enum, params []int32) { + C.gl4_2core_glGetIntegerv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFloatv.xml +func (gl *GL) GetFloatv(pname glbase.Enum, params []float32) { + C.gl4_2core_glGetFloatv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetError.xml +func (gl *GL) GetError() glbase.Enum { + glresult := C.gl4_2core_glGetError(gl.funcs) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetDoublev.xml +func (gl *GL) GetDoublev(pname glbase.Enum, params []float64) { + C.gl4_2core_glGetDoublev(gl.funcs, C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBooleanv.xml +func (gl *GL) GetBooleanv(pname glbase.Enum, params []bool) { + C.gl4_2core_glGetBooleanv(gl.funcs, C.GLenum(pname), (*C.GLboolean)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glReadPixels.xml +func (gl *GL) ReadPixels(x, y, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_2core_glReadPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glReadBuffer.xml +func (gl *GL) ReadBuffer(mode glbase.Enum) { + C.gl4_2core_glReadBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelStorei.xml +func (gl *GL) PixelStorei(pname glbase.Enum, param int32) { + C.gl4_2core_glPixelStorei(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelStoref.xml +func (gl *GL) PixelStoref(pname glbase.Enum, param float32) { + C.gl4_2core_glPixelStoref(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDepthFunc.xml +func (gl *GL) DepthFunc(glfunc glbase.Enum) { + C.gl4_2core_glDepthFunc(gl.funcs, C.GLenum(glfunc)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilOp.xml +func (gl *GL) StencilOp(fail, zfail, zpass glbase.Enum) { + C.gl4_2core_glStencilOp(gl.funcs, C.GLenum(fail), C.GLenum(zfail), C.GLenum(zpass)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilFunc.xml +func (gl *GL) StencilFunc(glfunc glbase.Enum, ref int32, mask uint32) { + C.gl4_2core_glStencilFunc(gl.funcs, C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLogicOp.xml +func (gl *GL) LogicOp(opcode glbase.Enum) { + C.gl4_2core_glLogicOp(gl.funcs, C.GLenum(opcode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFunc.xml +func (gl *GL) BlendFunc(sfactor, dfactor glbase.Enum) { + C.gl4_2core_glBlendFunc(gl.funcs, C.GLenum(sfactor), C.GLenum(dfactor)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFlush.xml +func (gl *GL) Flush() { + C.gl4_2core_glFlush(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFinish.xml +func (gl *GL) Finish() { + C.gl4_2core_glFinish(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEnable.xml +func (gl *GL) Enable(cap glbase.Enum) { + C.gl4_2core_glEnable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDisable.xml +func (gl *GL) Disable(cap glbase.Enum) { + C.gl4_2core_glDisable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDepthMask.xml +func (gl *GL) DepthMask(flag bool) { + C.gl4_2core_glDepthMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorMask.xml +func (gl *GL) ColorMask(red, green, blue, alpha bool) { + C.gl4_2core_glColorMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&red)), *(*C.GLboolean)(unsafe.Pointer(&green)), *(*C.GLboolean)(unsafe.Pointer(&blue)), *(*C.GLboolean)(unsafe.Pointer(&alpha))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilMask.xml +func (gl *GL) StencilMask(mask uint32) { + C.gl4_2core_glStencilMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearDepth.xml +func (gl *GL) ClearDepth(depth float64) { + C.gl4_2core_glClearDepth(gl.funcs, C.GLdouble(depth)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearStencil.xml +func (gl *GL) ClearStencil(s int32) { + C.gl4_2core_glClearStencil(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearColor.xml +func (gl *GL) ClearColor(red, green, blue, alpha float32) { + C.gl4_2core_glClearColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClear.xml +func (gl *GL) Clear(mask glbase.Bitfield) { + C.gl4_2core_glClear(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawBuffer.xml +func (gl *GL) DrawBuffer(mode glbase.Enum) { + C.gl4_2core_glDrawBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage2D.xml +func (gl *GL) TexImage2D(target glbase.Enum, level int, internalFormat int32, width, height, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_2core_glTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage1D.xml +func (gl *GL) TexImage1D(target glbase.Enum, level int, internalFormat int32, width, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_2core_glTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameteriv.xml +func (gl *GL) TexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_2core_glTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameteri.xml +func (gl *GL) TexParameteri(target, pname glbase.Enum, param int32) { + C.gl4_2core_glTexParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterfv.xml +func (gl *GL) TexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_2core_glTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterf.xml +func (gl *GL) TexParameterf(target, pname glbase.Enum, param float32) { + C.gl4_2core_glTexParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glScissor.xml +func (gl *GL) Scissor(x, y, width, height int) { + C.gl4_2core_glScissor(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPolygonMode.xml +func (gl *GL) PolygonMode(face, mode glbase.Enum) { + C.gl4_2core_glPolygonMode(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointSize.xml +func (gl *GL) PointSize(size float32) { + C.gl4_2core_glPointSize(gl.funcs, C.GLfloat(size)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLineWidth.xml +func (gl *GL) LineWidth(width float32) { + C.gl4_2core_glLineWidth(gl.funcs, C.GLfloat(width)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glHint.xml +func (gl *GL) Hint(target, mode glbase.Enum) { + C.gl4_2core_glHint(gl.funcs, C.GLenum(target), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFrontFace.xml +func (gl *GL) FrontFace(mode glbase.Enum) { + C.gl4_2core_glFrontFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCullFace.xml +func (gl *GL) CullFace(mode glbase.Enum) { + C.gl4_2core_glCullFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexubv.xml +func (gl *GL) Indexubv(c []uint8) { + C.gl4_2core_glIndexubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexub.xml +func (gl *GL) Indexub(c uint8) { + C.gl4_2core_glIndexub(gl.funcs, C.GLubyte(c)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsTexture.xml +func (gl *GL) IsTexture(texture glbase.Texture) bool { + glresult := C.gl4_2core_glIsTexture(gl.funcs, C.GLuint(texture)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenTextures returns n texture names in textures. There is no guarantee +// that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenTextures. +// +// The generated textures have no dimensionality; they assume the +// dimensionality of the texture target to which they are first bound (see +// BindTexture). +// +// Texture names returned by a call to GenTextures are not returned by +// subsequent calls, unless they are first deleted with DeleteTextures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenTextures is available in GL version 2.0 or greater. +func (gl *GL) GenTextures(n int) []glbase.Texture { + if n == 0 { + return nil + } + textures := make([]glbase.Texture, n) + C.gl4_2core_glGenTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) + return textures +} + +// DeleteTextures deletes the textures objects whose names are stored +// in the textures slice. After a texture is deleted, it has no contents or +// dimensionality, and its name is free for reuse (for example by +// GenTextures). If a texture that is currently bound is deleted, the binding +// reverts to 0 (the default texture). +// +// DeleteTextures silently ignores 0's and names that do not correspond to +// existing textures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteTextures is available in GL version 2.0 or greater. +func (gl *GL) DeleteTextures(textures []glbase.Texture) { + n := len(textures) + if n == 0 { + return + } + C.gl4_2core_glDeleteTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindTexture.xml +func (gl *GL) BindTexture(target glbase.Enum, texture glbase.Texture) { + C.gl4_2core_glBindTexture(gl.funcs, C.GLenum(target), C.GLuint(texture)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexSubImage2D.xml +func (gl *GL) TexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_2core_glTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexSubImage1D.xml +func (gl *GL) TexSubImage1D(target glbase.Enum, level, xoffset, width int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_2core_glTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexSubImage2D.xml +func (gl *GL) CopyTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, x, y, width, height int) { + C.gl4_2core_glCopyTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexSubImage1D.xml +func (gl *GL) CopyTexSubImage1D(target glbase.Enum, level, xoffset, x, y, width int) { + C.gl4_2core_glCopyTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexImage2D.xml +func (gl *GL) CopyTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, height, border int) { + C.gl4_2core_glCopyTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexImage1D.xml +func (gl *GL) CopyTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, border int) { + C.gl4_2core_glCopyTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPolygonOffset.xml +func (gl *GL) PolygonOffset(factor, units float32) { + C.gl4_2core_glPolygonOffset(gl.funcs, C.GLfloat(factor), C.GLfloat(units)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElements.xml +func (gl *GL) DrawElements(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_2core_glDrawElements(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawArrays.xml +func (gl *GL) DrawArrays(mode glbase.Enum, first, count int) { + C.gl4_2core_glDrawArrays(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexSubImage3D.xml +func (gl *GL) CopyTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, x, y, width, height int) { + C.gl4_2core_glCopyTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexSubImage3D.xml +func (gl *GL) TexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_2core_glTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage3D.xml +func (gl *GL) TexImage3D(target glbase.Enum, level int, internalFormat int32, width, height int, depth int32, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_2core_glTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawRangeElements.xml +func (gl *GL) DrawRangeElements(mode glbase.Enum, start, end uint32, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_2core_glDrawRangeElements(gl.funcs, C.GLenum(mode), C.GLuint(start), C.GLuint(end), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendEquation.xml +func (gl *GL) BlendEquation(mode glbase.Enum) { + C.gl4_2core_glBlendEquation(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendColor.xml +func (gl *GL) BlendColor(red, green, blue, alpha float32) { + C.gl4_2core_glBlendColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetCompressedTexImage.xml +func (gl *GL) GetCompressedTexImage(target glbase.Enum, level int, img interface{}) { + var img_ptr unsafe.Pointer + var img_v = reflect.ValueOf(img) + if img != nil && img_v.Kind() != reflect.Slice { + panic("parameter img must be a slice") + } + if img != nil { + img_ptr = unsafe.Pointer(img_v.Index(0).Addr().Pointer()) + } + C.gl4_2core_glGetCompressedTexImage(gl.funcs, C.GLenum(target), C.GLint(level), img_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexSubImage1D.xml +func (gl *GL) CompressedTexSubImage1D(target glbase.Enum, level, xoffset, width int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_2core_glCompressedTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexSubImage2D.xml +func (gl *GL) CompressedTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_2core_glCompressedTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexSubImage3D.xml +func (gl *GL) CompressedTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_2core_glCompressedTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexImage1D.xml +func (gl *GL) CompressedTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, width, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_2core_glCompressedTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexImage2D.xml +func (gl *GL) CompressedTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_2core_glCompressedTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexImage3D.xml +func (gl *GL) CompressedTexImage3D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height int, depth int32, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_2core_glCompressedTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSampleCoverage.xml +func (gl *GL) SampleCoverage(value float32, invert bool) { + C.gl4_2core_glSampleCoverage(gl.funcs, C.GLfloat(value), *(*C.GLboolean)(unsafe.Pointer(&invert))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glActiveTexture.xml +func (gl *GL) ActiveTexture(texture glbase.Enum) { + C.gl4_2core_glActiveTexture(gl.funcs, C.GLenum(texture)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointParameteriv.xml +func (gl *GL) PointParameteriv(pname glbase.Enum, params []int32) { + C.gl4_2core_glPointParameteriv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointParameteri.xml +func (gl *GL) PointParameteri(pname glbase.Enum, param int32) { + C.gl4_2core_glPointParameteri(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointParameterfv.xml +func (gl *GL) PointParameterfv(pname glbase.Enum, params []float32) { + C.gl4_2core_glPointParameterfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointParameterf.xml +func (gl *GL) PointParameterf(pname glbase.Enum, param float32) { + C.gl4_2core_glPointParameterf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiDrawArrays.xml +func (gl *GL) MultiDrawArrays(mode glbase.Enum, first, count []int, drawcount int32) { + C.gl4_2core_glMultiDrawArrays(gl.funcs, C.GLenum(mode), (*C.GLint)(unsafe.Pointer(&first[0])), (*C.GLsizei)(unsafe.Pointer(&count[0])), C.GLsizei(drawcount)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFuncSeparate.xml +func (gl *GL) BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha glbase.Enum) { + C.gl4_2core_glBlendFuncSeparate(gl.funcs, C.GLenum(sfactorRGB), C.GLenum(dfactorRGB), C.GLenum(sfactorAlpha), C.GLenum(dfactorAlpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBufferParameteriv.xml +func (gl *GL) GetBufferParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_2core_glGetBufferParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUnmapBuffer.xml +func (gl *GL) UnmapBuffer(target glbase.Enum) bool { + glresult := C.gl4_2core_glUnmapBuffer(gl.funcs, C.GLenum(target)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBufferSubData.xml +func (gl *GL) GetBufferSubData(target glbase.Enum, offset, size int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_2core_glGetBufferSubData(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(size), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBufferSubData.xml +func (gl *GL) BufferSubData(target glbase.Enum, offset, size int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_2core_glBufferSubData(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(size), data_ptr) +} + +// BufferData creates a new data store for the buffer object currently +// bound to target. Any pre-existing data store is deleted. The new data +// store is created with the specified size in bytes and usage. If data is +// not nil, it must be a slice that is used to initialize the data store. +// In that case the size parameter is ignored and the store size will match +// the slice data size. +// +// In its initial state, the new data store is not mapped, it has a NULL +// mapped pointer, and its mapped access is GL.READ_WRITE. +// +// The target constant must be one of GL.ARRAY_BUFFER, GL.COPY_READ_BUFFER, +// GL.COPY_WRITE_BUFFER, GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER, +// GL.PIXEL_UNPACK_BUFFER, GL.TEXTURE_BUFFER, GL.TRANSFORM_FEEDBACK_BUFFER, +// or GL.UNIFORM_BUFFER. +// +// The usage parameter is a hint to the GL implementation as to how a buffer +// object's data store will be accessed. This enables the GL implementation +// to make more intelligent decisions that may significantly impact buffer +// object performance. It does not, however, constrain the actual usage of +// the data store. usage can be broken down into two parts: first, the +// frequency of access (modification and usage), and second, the nature of +// that access. +// +// A usage frequency of STREAM and nature of DRAW is specified via the +// constant GL.STREAM_DRAW, for example. +// +// The usage frequency of access may be one of: +// +// STREAM +// The data store contents will be modified once and used at most a few times. +// +// STATIC +// The data store contents will be modified once and used many times. +// +// DYNAMIC +// The data store contents will be modified repeatedly and used many times. +// +// The usage nature of access may be one of: +// +// DRAW +// The data store contents are modified by the application, and used as +// the source for GL drawing and image specification commands. +// +// READ +// The data store contents are modified by reading data from the GL, +// and used to return that data when queried by the application. +// +// COPY +// The data store contents are modified by reading data from the GL, +// and used as the source for GL drawing and image specification +// commands. +// +// Clients must align data elements consistent with the requirements of the +// client platform, with an additional base-level requirement that an offset +// within a buffer to a datum comprising N bytes be a multiple of N. +// +// Error GL.INVALID_ENUM is generated if target is not one of the accepted +// buffer targets. GL.INVALID_ENUM is generated if usage is not +// GL.STREAM_DRAW, GL.STREAM_READ, GL.STREAM_COPY, GL.STATIC_DRAW, +// GL.STATIC_READ, GL.STATIC_COPY, GL.DYNAMIC_DRAW, GL.DYNAMIC_READ, or +// GL.DYNAMIC_COPY. GL.INVALID_VALUE is generated if size is negative. +// GL.INVALID_OPERATION is generated if the reserved buffer object name 0 is +// bound to target. GL.OUT_OF_MEMORY is generated if the GL is unable to +// create a data store with the specified size. +func (gl *GL) BufferData(target glbase.Enum, size int, data interface{}, usage glbase.Enum) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + if data != nil { + size = int(data_v.Type().Size()) * data_v.Len() + } + C.gl4_2core_glBufferData(gl.funcs, C.GLenum(target), C.GLsizeiptr(size), data_ptr, C.GLenum(usage)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsBuffer.xml +func (gl *GL) IsBuffer(buffer glbase.Buffer) bool { + glresult := C.gl4_2core_glIsBuffer(gl.funcs, C.GLuint(buffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenBuffers returns n buffer object names. There is no guarantee that +// the names form a contiguous set of integers; however, it is guaranteed +// that none of the returned names was in use immediately before the call to +// GenBuffers. +// +// Buffer object names returned by a call to GenBuffers are not returned by +// subsequent calls, unless they are first deleted with DeleteBuffers. +// +// No buffer objects are associated with the returned buffer object names +// until they are first bound by calling BindBuffer. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if GenBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// GenBuffers is available in GL version 1.5 or greater. +func (gl *GL) GenBuffers(n int) []glbase.Buffer { + if n == 0 { + return nil + } + buffers := make([]glbase.Buffer, n) + C.gl4_2core_glGenBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) + return buffers +} + +// DeleteBuffers deletes the buffer objects whose names are stored in the +// buffers slice. +// +// After a buffer object is deleted, it has no contents, and its name is free +// for reuse (for example by GenBuffers). If a buffer object that is +// currently bound is deleted, the binding reverts to 0 (the absence of any +// buffer object, which reverts to client memory usage). +// +// DeleteBuffers silently ignores 0's and names that do not correspond to +// existing buffer objects. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if DeleteBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// DeleteBuffers is available in GL version 1.5 or greater. +func (gl *GL) DeleteBuffers(buffers []glbase.Buffer) { + n := len(buffers) + if n == 0 { + return + } + C.gl4_2core_glDeleteBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) +} + +// BindBuffer creates or puts in use a named buffer object. +// Calling BindBuffer with target set to GL.ARRAY_BUFFER, +// GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER or GL.PIXEL_UNPACK_BUFFER +// and buffer set to the name of the new buffer object binds the buffer +// object name to the target. When a buffer object is bound to a target, the +// previous binding for that target is automatically broken. +// +// Buffer object names are unsigned integers. The value zero is reserved, but +// there is no default buffer object for each buffer object target. Instead, +// buffer set to zero effectively unbinds any buffer object previously bound, +// and restores client memory usage for that buffer object target. Buffer +// object names and the corresponding buffer object contents are local to the +// shared display-list space (see XCreateContext) of the current GL rendering +// context; two rendering contexts share buffer object names only if they +// also share display lists. +// +// GenBuffers may be called to generate a set of new buffer object names. +// +// The state of a buffer object immediately after it is first bound is an +// unmapped zero-sized memory buffer with GL.READ_WRITE access and +// GL.STATIC_DRAW usage. +// +// While a non-zero buffer object name is bound, GL operations on the target +// to which it is bound affect the bound buffer object, and queries of the +// target to which it is bound return state from the bound buffer object. +// While buffer object name zero is bound, as in the initial state, attempts +// to modify or query state on the target to which it is bound generates an +// GL.INVALID_OPERATION error. +// +// When vertex array pointer state is changed, for example by a call to +// NormalPointer, the current buffer object binding (GL.ARRAY_BUFFER_BINDING) +// is copied into the corresponding client state for the vertex array type +// being changed, for example GL.NORMAL_ARRAY_BUFFER_BINDING. While a +// non-zero buffer object is bound to the GL.ARRAY_BUFFER target, the vertex +// array pointer parameter that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.ELEMENT_ARRAY_BUFFER +// target, the indices parameter of DrawElements, DrawRangeElements, or +// MultiDrawElements that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_PACK_BUFFER +// target, the following commands are affected: GetCompressedTexImage, +// GetConvolutionFilter, GetHistogram, GetMinmax, GetPixelMap, +// GetPolygonStipple, GetSeparableFilter, GetTexImage, and ReadPixels. The +// pointer parameter that is traditionally interpreted as a pointer to +// client-side memory where the pixels are to be packed is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_UNPACK_BUFFER +// target, the following commands are affected: Bitmap, ColorSubTable, +// ColorTable, CompressedTexImage1D, CompressedTexImage2D, +// CompressedTexImage3D, CompressedTexSubImage1D, CompressedTexSubImage2D, +// CompressedTexSubImage3D, ConvolutionFilter1D, ConvolutionFilter2D, +// DrawPixels, PixelMap, PolygonStipple, SeparableFilter2D, TexImage1D, +// TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, and TexSubImage3D. +// The pointer parameter that is traditionally interpreted as a pointer to +// client-side memory from which the pixels are to be unpacked is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// A buffer object binding created with BindBuffer remains active until a +// different buffer object name is bound to the same target, or until the +// bound buffer object is deleted with DeleteBuffers. +// +// Once created, a named buffer object may be re-bound to any target as often +// as needed. However, the GL implementation may make choices about how to +// optimize the storage of a buffer object based on its initial binding +// target. +// +// Error GL.INVALID_ENUM is generated if target is not one of the allowable +// values. GL.INVALID_OPERATION is generated if BindBuffer is executed +// between the execution of Begin and the corresponding execution of End. +// +// BindBuffer is available in GL version 1.5 or greater. +func (gl *GL) BindBuffer(target glbase.Enum, buffer glbase.Buffer) { + C.gl4_2core_glBindBuffer(gl.funcs, C.GLenum(target), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryObjectuiv.xml +func (gl *GL) GetQueryObjectuiv(id uint32, pname glbase.Enum, params []uint32) { + C.gl4_2core_glGetQueryObjectuiv(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryObjectiv.xml +func (gl *GL) GetQueryObjectiv(id uint32, pname glbase.Enum, params []int32) { + C.gl4_2core_glGetQueryObjectiv(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryiv.xml +func (gl *GL) GetQueryiv(target, pname glbase.Enum, params []int32) { + C.gl4_2core_glGetQueryiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndQuery.xml +func (gl *GL) EndQuery(target glbase.Enum) { + C.gl4_2core_glEndQuery(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBeginQuery.xml +func (gl *GL) BeginQuery(target glbase.Enum, id uint32) { + C.gl4_2core_glBeginQuery(gl.funcs, C.GLenum(target), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsQuery.xml +func (gl *GL) IsQuery(id uint32) bool { + glresult := C.gl4_2core_glIsQuery(gl.funcs, C.GLuint(id)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteQueries.xml +func (gl *GL) DeleteQueries(n int, ids []uint32) { + C.gl4_2core_glDeleteQueries(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenQueries.xml +func (gl *GL) GenQueries(n int, ids []uint32) { + C.gl4_2core_glGenQueries(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// VertexAttribPointer specifies the location and data format of the array +// of generic vertex attributes at index to use when rendering. size +// specifies the number of components per attribute and must be 1, 2, 3, or +// 4. type specifies the data type of each component, and stride specifies +// the byte stride from one attribute to the next, allowing vertices and +// attributes to be packed into a single array or stored in separate arrays. +// normalized indicates whether the values stored in an integer format are +// to be mapped to the range [-1,1] (for signed values) or [0,1] +// (for unsigned values) when they are accessed and converted to floating +// point; otherwise, values will be converted to floats directly without +// normalization. offset is a byte offset into the buffer object's data +// store, which must be bound to the GL.ARRAY_BUFFER target with BindBuffer. +// +// The buffer object binding (GL.ARRAY_BUFFER_BINDING) is saved as +// generic vertex attribute array client-side state +// (GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING) for the provided index. +// +// To enable and disable a generic vertex attribute array, call +// EnableVertexAttribArray and DisableVertexAttribArray with index. If +// enabled, the generic vertex attribute array is used when DrawArrays or +// DrawElements is called. Each generic vertex attribute array is initially +// disabled. +// +// VertexAttribPointer is typically implemented on the client side. +// +// Error GL.INVALID_ENUM is generated if type is not an accepted value. +// GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_VALUE is generated if size is not 1, 2, +// 3, or 4. GL.INVALID_VALUE is generated if stride is negative. +func (gl *GL) VertexAttribPointer(index glbase.Attrib, size int, gltype glbase.Enum, normalized bool, stride int, offset uintptr) { + offset_ptr := unsafe.Pointer(offset) + C.gl4_2core_glVertexAttribPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLsizei(stride), offset_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glValidateProgram.xml +func (gl *GL) ValidateProgram(program glbase.Program) { + C.gl4_2core_glValidateProgram(gl.funcs, C.GLuint(program)) +} + +// UniformMatrix4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*4) != 0 { + panic("invalid value length for UniformMatrix4fv") + } + count := len(value) / (4 * 4) + C.gl4_2core_glUniformMatrix4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*3) != 0 { + panic("invalid value length for UniformMatrix3fv") + } + count := len(value) / (3 * 3) + C.gl4_2core_glUniformMatrix3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*2) != 0 { + panic("invalid value length for UniformMatrix2fv") + } + count := len(value) / (2 * 2) + C.gl4_2core_glUniformMatrix2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform4iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4iv") + } + count := len(value) / 4 + C.gl4_2core_glUniform4iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform3iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3iv") + } + count := len(value) / 3 + C.gl4_2core_glUniform3iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform2iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2iv") + } + count := len(value) / 2 + C.gl4_2core_glUniform2iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform1iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl4_2core_glUniform1iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4fv") + } + count := len(value) / 4 + C.gl4_2core_glUniform4fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3fv") + } + count := len(value) / 3 + C.gl4_2core_glUniform3fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2fv") + } + count := len(value) / 2 + C.gl4_2core_glUniform2fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform1fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl4_2core_glUniform1fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform4i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4i(location glbase.Uniform, v0, v1, v2, v3 int32) { + C.gl4_2core_glUniform4i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2), C.GLint(v3)) +} + +// Uniform3i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3i(location glbase.Uniform, v0, v1, v2 int32) { + C.gl4_2core_glUniform3i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2)) +} + +// Uniform2i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2i(location glbase.Uniform, v0, v1 int32) { + C.gl4_2core_glUniform2i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1)) +} + +// Uniform1i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1i(location glbase.Uniform, v0 int32) { + C.gl4_2core_glUniform1i(gl.funcs, C.GLint(location), C.GLint(v0)) +} + +// Uniform4f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4f(location glbase.Uniform, v0, v1, v2, v3 float32) { + C.gl4_2core_glUniform4f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2), C.GLfloat(v3)) +} + +// Uniform3f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3f(location glbase.Uniform, v0, v1, v2 float32) { + C.gl4_2core_glUniform3f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2)) +} + +// Uniform2f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2f(location glbase.Uniform, v0, v1 float32) { + C.gl4_2core_glUniform2f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1)) +} + +// Uniform1f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1f(location glbase.Uniform, v0 float32) { + C.gl4_2core_glUniform1f(gl.funcs, C.GLint(location), C.GLfloat(v0)) +} + +// UseProgram installs the program object specified by program as part of +// current rendering state. One or more executables are created in a program +// object by successfully attaching shader objects to it with AttachShader, +// successfully compiling the shader objects with CompileShader, and +// successfully linking the program object with LinkProgram. +// +// A program object will contain an executable that will run on the vertex +// processor if it contains one or more shader objects of type +// GL.VERTEX_SHADER that have been successfully compiled and linked. +// Similarly, a program object will contain an executable that will run on +// the fragment processor if it contains one or more shader objects of type +// GL.FRAGMENT_SHADER that have been successfully compiled and linked. +// +// Successfully installing an executable on a programmable processor will +// cause the corresponding fixed functionality of OpenGL to be disabled. +// Specifically, if an executable is installed on the vertex processor, the +// OpenGL fixed functionality will be disabled as follows. +// +// - The modelview matrix is not applied to vertex coordinates. +// +// - The projection matrix is not applied to vertex coordinates. +// +// - The texture matrices are not applied to texture coordinates. +// +// - Normals are not transformed to eye coordinates. +// +// - Normals are not rescaled or normalized. +// +// - Normalization of GL.AUTO_NORMAL evaluated normals is not performed. +// +// - Texture coordinates are not generated automatically. +// +// - Per-vertex lighting is not performed. +// +// - Color material computations are not performed. +// +// - Color index lighting is not performed. +// +// - This list also applies when setting the current raster position. +// +// The executable that is installed on the vertex processor is expected to +// implement any or all of the desired functionality from the preceding list. +// Similarly, if an executable is installed on the fragment processor, the +// OpenGL fixed functionality will be disabled as follows. +// +// - Texture environment and texture functions are not applied. +// +// - Texture application is not applied. +// +// - Color sum is not applied. +// +// - Fog is not applied. +// +// Again, the fragment shader that is installed is expected to implement any +// or all of the desired functionality from the preceding list. +// +// While a program object is in use, applications are free to modify attached +// shader objects, compile attached shader objects, attach additional shader +// objects, and detach or delete shader objects. None of these operations +// will affect the executables that are part of the current state. However, +// relinking the program object that is currently in use will install the +// program object as part of the current rendering state if the link +// operation was successful (see LinkProgram). If the program object +// currently in use is relinked unsuccessfully, its link status will be set +// to GL.FALSE, but the executables and associated state will remain part of +// the current state until a subsequent call to UseProgram removes it from +// use. After it is removed from use, it cannot be made part of current state +// until it has been successfully relinked. +// +// If program contains shader objects of type GL.VERTEX_SHADER but it does +// not contain shader objects of type GL.FRAGMENT_SHADER, an executable will +// be installed on the vertex processor, but fixed functionality will be used +// for fragment processing. Similarly, if program contains shader objects of +// type GL.FRAGMENT_SHADER but it does not contain shader objects of type +// GL.VERTEX_SHADER, an executable will be installed on the fragment +// processor, but fixed functionality will be used for vertex processing. If +// program is 0, the programmable processors will be disabled, and fixed +// functionality will be used for both vertex and fragment processing. +// +// While a program object is in use, the state that controls the disabled +// fixed functionality may also be updated using the normal OpenGL calls. +// +// Like display lists and texture objects, the name space for program objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// Applications are responsible for providing the synchronization across API +// calls when objects are accessed from different execution threads. +// +// Error GL.INVALID_VALUE is generated if program is neither 0 nor a value +// generated by OpenGL. GL.INVALID_OPERATION is generated if program is not +// a program object. GL.INVALID_OPERATION is generated if program could not +// be made part of current state. GL.INVALID_OPERATION is generated if +// UseProgram is executed between the execution of Begin and the +// corresponding execution of End. +// +// UseProgram is available in GL version 2.0 or greater. +func (gl *GL) UseProgram(program glbase.Program) { + C.gl4_2core_glUseProgram(gl.funcs, C.GLuint(program)) +} + +// ShaderSource sets the source code in shader to the provided source code. Any source +// code previously stored in the shader object is completely replaced. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_VALUE is generated if count is less than 0. +// GL.INVALID_OPERATION is generated if ShaderSource is executed between the +// execution of Begin and the corresponding execution of End. +// +// ShaderSource is available in GL version 2.0 or greater. +func (gl *GL) ShaderSource(shader glbase.Shader, source ...string) { + count := len(source) + length := make([]int32, count) + source_c := make([]unsafe.Pointer, count) + for i, src := range source { + length[i] = int32(len(src)) + if len(src) > 0 { + source_c[i] = *(*unsafe.Pointer)(unsafe.Pointer(&src)) + } else { + source_c[i] = unsafe.Pointer(uintptr(0)) + } + } + C.gl4_2core_glShaderSource(gl.funcs, C.GLuint(shader), C.GLsizei(count), (**C.GLchar)(unsafe.Pointer(&source_c[0])), (*C.GLint)(unsafe.Pointer(&length[0]))) +} + +// LinkProgram links the program object specified by program. If any shader +// objects of type GL.VERTEX_SHADER are attached to program, they will be +// used to create an executable that will run on the programmable vertex +// processor. If any shader objects of type GL.FRAGMENT_SHADER are attached +// to program, they will be used to create an executable that will run on the +// programmable fragment processor. +// +// The status of the link operation will be stored as part of the program +// object's state. This value will be set to GL.TRUE if the program object +// was linked without errors and is ready for use, and GL.FALSE otherwise. It +// can be queried by calling GetProgramiv with arguments program and +// GL.LINK_STATUS. +// +// As a result of a successful link operation, all active user-defined +// uniform variables belonging to program will be initialized to 0, and each +// of the program object's active uniform variables will be assigned a +// location that can be queried by calling GetUniformLocation. Also, any +// active user-defined attribute variables that have not been bound to a +// generic vertex attribute index will be bound to one at this time. +// +// Linking of a program object can fail for a number of reasons as specified +// in the OpenGL Shading Language Specification. The following lists some of +// the conditions that will cause a link error. +// +// - The number of active attribute variables supported by the +// implementation has been exceeded. +// +// - The storage limit for uniform variables has been exceeded. +// +// - The number of active uniform variables supported by the implementation +// has been exceeded. +// +// - The main function is missing for the vertex shader or the fragment +// shader. +// +// - A varying variable actually used in the fragment shader is not +// declared in the same way (or is not declared at all) in the vertex +// shader. +// +// - A reference to a function or variable name is unresolved. +// +// - A shared global is declared with two different types or two different +// initial values. +// +// - One or more of the attached shader objects has not been successfully +// compiled. +// +// - Binding a generic attribute matrix caused some rows of the matrix to +// fall outside the allowed maximum of GL.MAX_VERTEX_ATTRIBS. +// +// - Not enough contiguous vertex attribute slots could be found to bind +// attribute matrices. +// +// When a program object has been successfully linked, the program object can +// be made part of current state by calling UseProgram. Whether or not the +// link operation was successful, the program object's information log will +// be overwritten. The information log can be retrieved by calling +// GetProgramInfoLog. +// +// LinkProgram will also install the generated executables as part of the +// current rendering state if the link operation was successful and the +// specified program object is already currently in use as a result of a +// previous call to UseProgram. If the program object currently in use is +// relinked unsuccessfully, its link status will be set to GL.FALSE , but the +// executables and associated state will remain part of the current state +// until a subsequent call to UseProgram removes it from use. After it is +// removed from use, it cannot be made part of current state until it has +// been successfully relinked. +// +// If program contains shader objects of type GL.VERTEX_SHADER but does not +// contain shader objects of type GL.FRAGMENT_SHADER, the vertex shader will +// be linked against the implicit interface for fixed functionality fragment +// processing. Similarly, if program contains shader objects of type +// GL.FRAGMENT_SHADER but it does not contain shader objects of type +// GL.VERTEX_SHADER, the fragment shader will be linked against the implicit +// interface for fixed functionality vertex processing. +// +// The program object's information log is updated and the program is +// generated at the time of the link operation. After the link operation, +// applications are free to modify attached shader objects, compile attached +// shader objects, detach shader objects, delete shader objects, and attach +// additional shader objects. None of these operations affects the +// information log or the program that is part of the program object. +// +// If the link operation is unsuccessful, any information about a previous +// link operation on program is lost (a failed link does not restore the +// old state of program). Certain information can still be retrieved +// from program even after an unsuccessful link operation. See for instance +// GetActiveAttrib and GetActiveUniform. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if LinkProgram is executed +// between the execution of Begin and the corresponding execution of End. +// +// LinkProgram is available in GL version 2.0 or greater. +func (gl *GL) LinkProgram(program glbase.Program) { + C.gl4_2core_glLinkProgram(gl.funcs, C.GLuint(program)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsShader.xml +func (gl *GL) IsShader(shader glbase.Shader) bool { + glresult := C.gl4_2core_glIsShader(gl.funcs, C.GLuint(shader)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsProgram.xml +func (gl *GL) IsProgram(program glbase.Program) bool { + glresult := C.gl4_2core_glIsProgram(gl.funcs, C.GLuint(program)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GetVertexAttribiv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribiv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribiv(index glbase.Attrib, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl4_2core_glGetVertexAttribiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetVertexAttribfv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribfv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribfv(index glbase.Attrib, pname glbase.Enum, params []float32) { + var params_c [4]float32 + C.gl4_2core_glGetVertexAttribfv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetVertexAttribdv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribdv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribdv(index glbase.Attrib, pname glbase.Enum, params []float64) { + var params_c [4]float64 + C.gl4_2core_glGetVertexAttribdv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformiv returns in params the value of the specified uniform +// variable. The type of the uniform variable specified by location +// determines the number of values returned. If the uniform variable is +// defined in the shader as a boolean, int, or float, a single value will be +// returned. If it is defined as a vec2, ivec2, or bvec2, two values will be +// returned. If it is defined as a vec3, ivec3, or bvec3, three values will +// be returned, and so on. To query values stored in uniform variables +// declared as arrays, call GetUniformiv for each element of the array. To +// query values stored in uniform variables declared as structures, call +// GetUniformiv for each field in the structure. The values for uniform +// variables declared as a matrix will be returned in column major order. +// +// The locations assigned to uniform variables are not known until the +// program object is linked. After linking has occurred, the command +// GetUniformLocation can be used to obtain the location of a uniform +// variable. This location value can then be passed to GetUniformiv in order +// to query the current value of the uniform variable. After a program object +// has been linked successfully, the index values for uniform variables +// remain fixed until the next link command occurs. The uniform variable +// values can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if program has not been +// successfully linked. GL.INVALID_OPERATION is generated if location does +// not correspond to a valid uniform variable location for the specified +// program object. GL.INVALID_OPERATION is generated if GetUniformiv is +// executed between the execution of Begin and the corresponding execution of +// End. +// +// GetUniformiv is available in GL version 2.0 or greater. +func (gl *GL) GetUniformiv(program glbase.Program, location glbase.Uniform, params []int32) { + var params_c [4]int32 + C.gl4_2core_glGetUniformiv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformfv returns in params the value of the specified uniform +// variable. The type of the uniform variable specified by location +// determines the number of values returned. If the uniform variable is +// defined in the shader as a boolean, int, or float, a single value will be +// returned. If it is defined as a vec2, ivec2, or bvec2, two values will be +// returned. If it is defined as a vec3, ivec3, or bvec3, three values will +// be returned, and so on. To query values stored in uniform variables +// declared as arrays, call GetUniformfv for each element of the array. To +// query values stored in uniform variables declared as structures, call +// GetUniformfv for each field in the structure. The values for uniform +// variables declared as a matrix will be returned in column major order. +// +// The locations assigned to uniform variables are not known until the +// program object is linked. After linking has occurred, the command +// GetUniformLocation can be used to obtain the location of a uniform +// variable. This location value can then be passed to GetUniformfv in order +// to query the current value of the uniform variable. After a program object +// has been linked successfully, the index values for uniform variables +// remain fixed until the next link command occurs. The uniform variable +// values can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if program has not been +// successfully linked. GL.INVALID_OPERATION is generated if location does +// not correspond to a valid uniform variable location for the specified +// program object. GL.INVALID_OPERATION is generated if GetUniformfv is +// executed between the execution of Begin and the corresponding execution of +// End. +// +// GetUniformfv is available in GL version 2.0 or greater. +func (gl *GL) GetUniformfv(program glbase.Program, location glbase.Uniform, params []float32) { + var params_c [4]float32 + C.gl4_2core_glGetUniformfv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLfloat)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformLocation returns an integer that represents the location of a +// specific uniform variable within a program object. name must be an active +// uniform variable name in program that is not a structure, an array of +// structures, or a subcomponent of a vector or a matrix. This function +// returns -1 if name does not correspond to an active uniform variable in +// program or if name starts with the reserved prefix "gl_". +// +// Uniform variables that are structures or arrays of structures may be +// queried by calling GetUniformLocation for each field within the +// structure. The array element operator "[]" and the structure field +// operator "." may be used in name in order to select elements within an +// array or fields within a structure. The result of using these operators is +// not allowed to be another structure, an array of structures, or a +// subcomponent of a vector or a matrix. Except if the last part of name +// indicates a uniform variable array, the location of the first element of +// an array can be retrieved by using the name of the array, or by using the +// name appended by "[0]". +// +// The actual locations assigned to uniform variables are not known until the +// program object is linked successfully. After linking has occurred, the +// command GetUniformLocation can be used to obtain the location of a +// uniform variable. This location value can then be passed to Uniform to +// set the value of the uniform variable or to GetUniform in order to query +// the current value of the uniform variable. After a program object has been +// linked successfully, the index values for uniform variables remain fixed +// until the next link command occurs. Uniform variable locations and values +// can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program object. +// GL.INVALID_OPERATION is generated if program has not been successfully +// linked. GL.INVALID_OPERATION is generated if GetUniformLocation is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetUniformLocation is available in GL version 2.0 or greater. +func (gl *GL) GetUniformLocation(program glbase.Program, name string) glbase.Uniform { + name_cstr := C.CString(name) + glresult := C.gl4_2core_glGetUniformLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) + return glbase.Uniform(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetShaderSource.xml +func (gl *GL) GetShaderSource(shader glbase.Shader, bufSize int32, length []int32, source []byte) { + C.gl4_2core_glGetShaderSource(gl.funcs, C.GLuint(shader), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&source[0]))) +} + +// GetShaderInfoLog returns the information log for the specified shader +// object. The information log for a shader object is modified when the +// shader is compiled. +// +// The information log for a shader object is a string that may contain +// diagnostic messages, warning messages, and other information about the +// last compile operation. When a shader object is created, its information +// log will be a string of length 0, and the size of the current log can be +// obtained by calling GetShaderiv with the value GL.INFO_LOG_LENGTH. +// +// The information log for a shader object is the OpenGL implementer's +// primary mechanism for conveying information about the compilation process. +// Therefore, the information log can be helpful to application developers +// during the development process, even when compilation is successful. +// Application developers should not expect different OpenGL implementations +// to produce identical information logs. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_VALUE is generated if maxLength is less than 0. +// GL.INVALID_OPERATION is generated if GetShaderInfoLog is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetShaderInfoLog is available in GL version 2.0 or greater. +func (gl *GL) GetShaderInfoLog(shader glbase.Shader) []byte { + var params [1]int32 + var length int32 + gl.GetShaderiv(shader, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + C.gl4_2core_glGetShaderInfoLog(gl.funcs, C.GLuint(shader), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length)), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) + return infoLog +} + +// GetShaderiv GetShader returns in params the value of a parameter for a specific +// shader object. The following parameters are defined: +// +// GL.SHADER_TYPE +// params returns GL.VERTEX_SHADER if shader is a vertex shader object, +// and GL.FRAGMENT_SHADER if shader is a fragment shader object. +// +// GL.DELETE_STATUS +// params returns GL.TRUE if shader is currently flagged for deletion, +// and GL.FALSE otherwise. +// +// GL.COMPILE_STATUS +// params returns GL.TRUE if the last compile operation on shader was +// successful, and GL.FALSE otherwise. +// +// GL.INFO_LOG_LENGTH +// params returns the number of characters in the information log for +// shader including the null termination character (the size of the +// character buffer required to store the information log). If shader has +// no information log, a value of 0 is returned. +// +// GL.SHADER_SOURCE_LENGTH +// params returns the length of the concatenation of the source strings +// that make up the shader source for the shader, including the null +// termination character. (the size of the character buffer +// required to store the shader source). If no source code exists, 0 is +// returned. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader does not refer to a +// shader object. GL.INVALID_ENUM is generated if pname is not an accepted +// value. GL.INVALID_OPERATION is generated if GetShader is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetShaderiv is available in GL version 2.0 or greater. +func (gl *GL) GetShaderiv(shader glbase.Shader, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl4_2core_glGetShaderiv(gl.funcs, C.GLuint(shader), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetProgramInfoLog returns the information log for the specified program +// object. The information log for a program object is modified when the +// program object is linked or validated. +// +// The information log for a program object is either an empty string, or a +// string containing information about the last link operation, or a string +// containing information about the last validation operation. It may contain +// diagnostic messages, warning messages, and other information. When a +// program object is created, its information log will be a string of length +// 0, and the size of the current log can be obtained by calling GetProgramiv +// with the value GL.INFO_LOG_LENGTH. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated +// by OpenGL. GL.INVALID_OPERATION is generated if program is not a +// program object. +func (gl *GL) GetProgramInfoLog(program glbase.Program) []byte { + var params [1]int32 + var length int32 + gl.GetProgramiv(program, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + C.gl4_2core_glGetProgramInfoLog(gl.funcs, C.GLuint(program), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length)), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) + return infoLog +} + +// GetProgramiv returns in params the value of a parameter for a specific +// program object. The following parameters are defined: +// +// GL.DELETE_STATUS +// params returns GL.TRUE if program is currently flagged for deletion, +// and GL.FALSE otherwise. +// +// GL.LINK_STATUS +// params returns GL.TRUE if the last link operation on program was +// successful, and GL.FALSE otherwise. +// +// GL.VALIDATE_STATUS +// params returns GL.TRUE or if the last validation operation on +// program was successful, and GL.FALSE otherwise. +// +// GL.INFO_LOG_LENGTH +// params returns the number of characters in the information log for +// program including the null termination character (the size of +// the character buffer required to store the information log). If +// program has no information log, a value of 0 is returned. +// +// GL.ATTACHED_SHADERS +// params returns the number of shader objects attached to program. +// +// GL.ACTIVE_ATTRIBUTES +// params returns the number of active attribute variables for program. +// +// GL.ACTIVE_ATTRIBUTE_MAX_LENGTH +// params returns the length of the longest active attribute name for +// program, including the null termination character (the size of +// the character buffer required to store the longest attribute name). +// If no active attributes exist, 0 is returned. +// +// GL.ACTIVE_UNIFORMS +// params returns the number of active uniform variables for program. +// +// GL.ACTIVE_UNIFORM_MAX_LENGTH +// params returns the length of the longest active uniform variable +// name for program, including the null termination character (i.e., +// the size of the character buffer required to store the longest +// uniform variable name). If no active uniform variables exist, 0 is +// returned. +// +// GL.TRANSFORM_FEEDBACK_BUFFER_MODE +// params returns a symbolic constant indicating the buffer mode used +// when transform feedback is active. This may be GL.SEPARATE_ATTRIBS +// or GL.INTERLEAVED_ATTRIBS. +// +// GL.TRANSFORM_FEEDBACK_VARYINGS +// params returns the number of varying variables to capture in transform +// feedback mode for the program. +// +// GL.TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH +// params returns the length of the longest variable name to be used for +// transform feedback, including the null-terminator. +// +// GL.GEOMETRY_VERTICES_OUT +// params returns the maximum number of vertices that the geometry shader in +// program will output. +// +// GL.GEOMETRY_INPUT_TYPE +// params returns a symbolic constant indicating the primitive type accepted +// as input to the geometry shader contained in program. +// +// GL.GEOMETRY_OUTPUT_TYPE +// params returns a symbolic constant indicating the primitive type that will +// be output by the geometry shader contained in program. +// +// GL.ACTIVE_UNIFORM_BLOCKS and GL.ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH are +// available only if the GL version 3.1 or greater. +// +// GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE and +// GL.GEOMETRY_OUTPUT_TYPE are accepted only if the GL version is 3.2 or +// greater. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program does not refer to a +// program object. GL.INVALID_OPERATION is generated if pname is +// GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE, or +// GL.GEOMETRY_OUTPUT_TYPE, and program does not contain a geometry shader. +// GL.INVALID_ENUM is generated if pname is not an accepted value. +func (gl *GL) GetProgramiv(program glbase.Program, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl4_2core_glGetProgramiv(gl.funcs, C.GLuint(program), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetAttribLocation queries the previously linked program object specified +// by program for the attribute variable specified by name and returns the +// index of the generic vertex attribute that is bound to that attribute +// variable. If name is a matrix attribute variable, the index of the first +// column of the matrix is returned. If the named attribute variable is not +// an active attribute in the specified program object or if name starts with +// the reserved prefix "gl_", a value of -1 is returned. +// +// The association between an attribute variable name and a generic attribute +// index can be specified at any time by calling BindAttribLocation. +// Attribute bindings do not go into effect until LinkProgram is called. +// After a program object has been linked successfully, the index values for +// attribute variables remain fixed until the next link command occurs. The +// attribute values can only be queried after a link if the link was +// successful. GetAttribLocation returns the binding that actually went +// into effect the last time LinkProgram was called for the specified +// program object. Attribute bindings that have been specified since the last +// link operation are not returned by GetAttribLocation. +// +// Error GL_INVALID_OPERATION is generated if program is not a value +// generated by OpenGL. GL_INVALID_OPERATION is generated if program is not +// a program object. GL_INVALID_OPERATION is generated if program has not +// been successfully linked. GL_INVALID_OPERATION is generated if +// GetAttribLocation is executed between the execution of Begin and the +// corresponding execution of End. +// +// GetAttribLocation is available in GL version 2.0 or greater. +func (gl *GL) GetAttribLocation(program glbase.Program, name string) glbase.Attrib { + name_cstr := C.CString(name) + glresult := C.gl4_2core_glGetAttribLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) + return glbase.Attrib(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetAttachedShaders.xml +func (gl *GL) GetAttachedShaders(program glbase.Program, maxCount int32, count []int, obj []uint32) { + C.gl4_2core_glGetAttachedShaders(gl.funcs, C.GLuint(program), C.GLsizei(maxCount), (*C.GLsizei)(unsafe.Pointer(&count[0])), (*C.GLuint)(unsafe.Pointer(&obj[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniform.xml +func (gl *GL) GetActiveUniform(program glbase.Program, index uint32, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl4_2core_glGetActiveUniform(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveAttrib.xml +func (gl *GL) GetActiveAttrib(program glbase.Program, index glbase.Attrib, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl4_2core_glGetActiveAttrib(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEnableVertexAttribArray.xml +func (gl *GL) EnableVertexAttribArray(index glbase.Attrib) { + C.gl4_2core_glEnableVertexAttribArray(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDisableVertexAttribArray.xml +func (gl *GL) DisableVertexAttribArray(index glbase.Attrib) { + C.gl4_2core_glDisableVertexAttribArray(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDetachShader.xml +func (gl *GL) DetachShader(program glbase.Program, shader glbase.Shader) { + C.gl4_2core_glDetachShader(gl.funcs, C.GLuint(program), C.GLuint(shader)) +} + +// DeleteShader frees the memory and invalidates the name associated with +// the shader object specified by shader. This command effectively undoes the +// effects of a call to CreateShader. +// +// If a shader object to be deleted is attached to a program object, it will +// be flagged for deletion, but it will not be deleted until it is no longer +// attached to any program object, for any rendering context (it must +// be detached from wherever it was attached before it will be deleted). A +// value of 0 for shader will be silently ignored. +// +// To determine whether an object has been flagged for deletion, call +// GetShader with arguments shader and GL.DELETE_STATUS. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. +// +// DeleteShader is available in GL version 2.0 or greater. +func (gl *GL) DeleteShader(shader glbase.Shader) { + C.gl4_2core_glDeleteShader(gl.funcs, C.GLuint(shader)) +} + +// DeleteProgram frees the memory and invalidates the name associated with +// the program object specified by program. This command effectively undoes +// the effects of a call to CreateProgram. +// +// If a program object is in use as part of current rendering state, it will +// be flagged for deletion, but it will not be deleted until it is no longer +// part of current state for any rendering context. If a program object to be +// deleted has shader objects attached to it, those shader objects will be +// automatically detached but not deleted unless they have already been +// flagged for deletion by a previous call to DeleteShader. A value of 0 +// for program will be silently ignored. +// +// To determine whether a program object has been flagged for deletion, call +// GetProgram with arguments program and GL.DELETE_STATUS. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. +// +// DeleteProgram is available in GL version 2.0 or greater. +func (gl *GL) DeleteProgram(program glbase.Program) { + C.gl4_2core_glDeleteProgram(gl.funcs, C.GLuint(program)) +} + +// CreateShader creates an empty shader object and returns a non-zero value +// by which it can be referenced. A shader object is used to maintain the +// source code strings that define a shader. shaderType indicates the type of +// shader to be created. +// +// Two types of shaders are supported. A shader of type GL.VERTEX_SHADER is a +// shader that is intended to run on the programmable vertex processor and +// replace the fixed functionality vertex processing in OpenGL. A shader of +// type GL.FRAGMENT_SHADER is a shader that is intended to run on the +// programmable fragment processor and replace the fixed functionality +// fragment processing in OpenGL. +// +// When created, a shader object's GL.SHADER_TYPE parameter is set to either +// GL.VERTEX_SHADER or GL.FRAGMENT_SHADER, depending on the value of +// shaderType. +// +// Like display lists and texture objects, the name space for shader objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// This function returns 0 if an error occurs creating the shader object. +// +// Error GL.INVALID_ENUM is generated if shaderType is not an accepted value. +// GL.INVALID_OPERATION is generated if CreateShader is executed between the +// execution of Begin and the corresponding execution of End. +// +// CreateShader is available in GL version 2.0 or greater. +func (gl *GL) CreateShader(gltype glbase.Enum) glbase.Shader { + glresult := C.gl4_2core_glCreateShader(gl.funcs, C.GLenum(gltype)) + return glbase.Shader(glresult) +} + +// CreateProgram creates an empty program object and returns a non-zero +// value by which it can be referenced. A program object is an object to +// which shader objects can be attached. This provides a mechanism to specify +// the shader objects that will be linked to create a program. It also +// provides a means for checking the compatibility of the shaders that will +// be used to create a program (for instance, checking the compatibility +// between a vertex shader and a fragment shader). When no longer needed as +// part of a program object, shader objects can be detached. +// +// One or more executables are created in a program object by successfully +// attaching shader objects to it with AttachShader, successfully compiling +// the shader objects with CompileShader, and successfully linking the +// program object with LinkProgram. These executables are made part of +// current state when UseProgram is called. Program objects can be deleted +// by calling DeleteProgram. The memory associated with the program object +// will be deleted when it is no longer part of current rendering state for +// any context. +// +// Like display lists and texture objects, the name space for program objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// Applications are responsible for providing the synchronization across API +// calls when objects are accessed from different execution threads. +// +// This function returns 0 if an error occurs creating the program object. +// +// Error GL.INVALID_OPERATION is generated if CreateProgram is executed +// between the execution of Begin and the corresponding execution of End. +// +// CreateProgram is available in GL version 2.0 or greater. +func (gl *GL) CreateProgram() glbase.Program { + glresult := C.gl4_2core_glCreateProgram(gl.funcs) + return glbase.Program(glresult) +} + +// CompileShader compiles the source code strings that have been stored in +// the shader object specified by shader. +// +// The compilation status will be stored as part of the shader object's +// state. This value will be set to GL.TRUE if the shader was compiled without +// errors and is ready for use, and GL.FALSE otherwise. It can be queried by +// calling GetShaderiv with arguments shader and GL.COMPILE_STATUS. +// +// Compilation of a shader can fail for a number of reasons as specified by +// the OpenGL Shading Language Specification. Whether or not the compilation +// was successful, information about the compilation can be obtained from the +// shader object's information log by calling GetShaderInfoLog. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_OPERATION is generated if CompileShader is executed +// between the execution of Begin and the corresponding execution of End. +// +// CompileShader is available in GL version 2.0 or greater. +func (gl *GL) CompileShader(shader glbase.Shader) { + C.gl4_2core_glCompileShader(gl.funcs, C.GLuint(shader)) +} + +// BindAttribLocation associates a user-defined attribute variable in the program +// object specified by program with a generic vertex attribute index. The name +// parameter specifies the name of the vertex shader attribute variable to +// which index is to be bound. When program is made part of the current state, +// values provided via the generic vertex attribute index will modify the +// value of the user-defined attribute variable specified by name. +// +// If name refers to a matrix attribute variable, index refers to the first +// column of the matrix. Other matrix columns are then automatically bound to +// locations index+1 for a matrix of type mat2; index+1 and index+2 for a +// matrix of type mat3; and index+1, index+2, and index+3 for a matrix of +// type mat4. +// +// This command makes it possible for vertex shaders to use descriptive names +// for attribute variables rather than generic variables that are numbered +// from 0 to GL.MAX_VERTEX_ATTRIBS-1. The values sent to each generic +// attribute index are part of current state, just like standard vertex +// attributes such as color, normal, and vertex position. If a different +// program object is made current by calling UseProgram, the generic vertex +// attributes are tracked in such a way that the same values will be observed +// by attributes in the new program object that are also bound to index. +// +// Attribute variable name-to-generic attribute index bindings for a program +// object can be explicitly assigned at any time by calling +// BindAttribLocation. Attribute bindings do not go into effect until +// LinkProgram is called. After a program object has been linked +// successfully, the index values for generic attributes remain fixed (and +// their values can be queried) until the next link command occurs. +// +// Applications are not allowed to bind any of the standard OpenGL vertex +// attributes using this command, as they are bound automatically when +// needed. Any attribute binding that occurs after the program object has +// been linked will not take effect until the next time the program object is +// linked. +// +// If name was bound previously, that information is lost. Thus you cannot +// bind one user-defined attribute variable to multiple indices, but you can +// bind multiple user-defined attribute variables to the same index. +// +// Applications are allowed to bind more than one user-defined attribute +// variable to the same generic vertex attribute index. This is called +// aliasing, and it is allowed only if just one of the aliased attributes is +// active in the executable program, or if no path through the shader +// consumes more than one attribute of a set of attributes aliased to the +// same location. The compiler and linker are allowed to assume that no +// aliasing is done and are free to employ optimizations that work only in +// the absence of aliasing. OpenGL implementations are not required to do +// error checking to detect aliasing. Because there is no way to bind +// standard attributes, it is not possible to alias generic attributes with +// conventional ones (except for generic attribute 0). +// +// BindAttribLocation can be called before any vertex shader objects are +// bound to the specified program object. It is also permissible to bind a +// generic attribute index to an attribute variable name that is never used +// in a vertex shader. +// +// Active attributes that are not explicitly bound will be bound by the +// linker when LinkProgram is called. The locations assigned can be queried +// by calling GetAttribLocation. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. +// GL.INVALID_OPERATION is generated if name starts with the reserved prefix "gl_". +// GL.INVALID_VALUE is generated if program is not a value generated by OpenGL. +// GL.INVALID_OPERATION is generated if program is not a program object. +// GL.INVALID_OPERATION is generated if BindAttribLocation is executed +// between the execution of Begin and the corresponding execution of End. +// +// BindAttribLocation is available in GL version 2.0 or greater. +func (gl *GL) BindAttribLocation(program glbase.Program, index glbase.Attrib, name string) { + name_cstr := C.CString(name) + C.gl4_2core_glBindAttribLocation(gl.funcs, C.GLuint(program), C.GLuint(index), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) +} + +// AttachShader attaches a shader object to a program object. +// +// In order to create an executable, there must be a way to specify the list +// of things that will be linked together. Program objects provide this +// mechanism. Shaders that are to be linked together in a program object must +// first be attached to that program object. This indicates that shader will +// be included in link operations that will be performed on program. +// +// All operations that can be performed on a shader object are valid whether +// or not the shader object is attached to a program object. It is +// permissible to attach a shader object to a program object before source +// code has been loaded into the shader object or before the shader object +// has been compiled. It is permissible to attach multiple shader objects of +// the same type because each may contain a portion of the complete shader. +// It is also permissible to attach a shader object to more than one program +// object. If a shader object is deleted while it is attached to a program +// object, it will be flagged for deletion, and deletion will not occur until +// DetachShader is called to detach it from all program objects to which it +// is attached. +// +// Error GL.INVALID_VALUE is generated if either program or shader is not a +// value generated by OpenGL. GL.INVALID_OPERATION is generated if program +// is not a program object. GL.INVALID_OPERATION is generated if shader is +// not a shader object. GL.INVALID_OPERATION is generated if shader is +// already attached to program. GL.INVALID_OPERATION is generated if +// AttachShader is executed between the execution of Begin and the +// corresponding execution of End. +// +// AttachShader is available in GL version 2.0 or greater. +func (gl *GL) AttachShader(program glbase.Program, shader glbase.Shader) { + C.gl4_2core_glAttachShader(gl.funcs, C.GLuint(program), C.GLuint(shader)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilMaskSeparate.xml +func (gl *GL) StencilMaskSeparate(face glbase.Enum, mask uint32) { + C.gl4_2core_glStencilMaskSeparate(gl.funcs, C.GLenum(face), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilFuncSeparate.xml +func (gl *GL) StencilFuncSeparate(face, glfunc glbase.Enum, ref int32, mask uint32) { + C.gl4_2core_glStencilFuncSeparate(gl.funcs, C.GLenum(face), C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilOpSeparate.xml +func (gl *GL) StencilOpSeparate(face, sfail, dpfail, dppass glbase.Enum) { + C.gl4_2core_glStencilOpSeparate(gl.funcs, C.GLenum(face), C.GLenum(sfail), C.GLenum(dpfail), C.GLenum(dppass)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawBuffers.xml +func (gl *GL) DrawBuffers(n int, bufs []glbase.Enum) { + C.gl4_2core_glDrawBuffers(gl.funcs, C.GLsizei(n), (*C.GLenum)(unsafe.Pointer(&bufs[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendEquationSeparate.xml +func (gl *GL) BlendEquationSeparate(modeRGB, modeAlpha glbase.Enum) { + C.gl4_2core_glBlendEquationSeparate(gl.funcs, C.GLenum(modeRGB), C.GLenum(modeAlpha)) +} + +// UniformMatrix4x3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4x3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4x3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*3) != 0 { + panic("invalid value length for UniformMatrix4x3fv") + } + count := len(value) / (4 * 3) + C.gl4_2core_glUniformMatrix4x3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3x4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3x4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3x4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*4) != 0 { + panic("invalid value length for UniformMatrix3x4fv") + } + count := len(value) / (3 * 4) + C.gl4_2core_glUniformMatrix3x4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix4x2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4x2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4x2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*2) != 0 { + panic("invalid value length for UniformMatrix4x2fv") + } + count := len(value) / (4 * 2) + C.gl4_2core_glUniformMatrix4x2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2x4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2x4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2x4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*4) != 0 { + panic("invalid value length for UniformMatrix2x4fv") + } + count := len(value) / (2 * 4) + C.gl4_2core_glUniformMatrix2x4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3x2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3x2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3x2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*2) != 0 { + panic("invalid value length for UniformMatrix3x2fv") + } + count := len(value) / (3 * 2) + C.gl4_2core_glUniformMatrix3x2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2x3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2x3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2x3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*3) != 0 { + panic("invalid value length for UniformMatrix2x3fv") + } + count := len(value) / (2 * 3) + C.gl4_2core_glUniformMatrix2x3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsVertexArray.xml +func (gl *GL) IsVertexArray(array uint32) bool { + glresult := C.gl4_2core_glIsVertexArray(gl.funcs, C.GLuint(array)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenVertexArrays.xml +func (gl *GL) GenVertexArrays(n int, arrays []uint32) { + C.gl4_2core_glGenVertexArrays(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&arrays[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteVertexArrays.xml +func (gl *GL) DeleteVertexArrays(n int, arrays []uint32) { + C.gl4_2core_glDeleteVertexArrays(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&arrays[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindVertexArray.xml +func (gl *GL) BindVertexArray(array uint32) { + C.gl4_2core_glBindVertexArray(gl.funcs, C.GLuint(array)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFlushMappedBufferRange.xml +func (gl *GL) FlushMappedBufferRange(target glbase.Enum, offset, length int) { + C.gl4_2core_glFlushMappedBufferRange(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(length)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTextureLayer.xml +func (gl *GL) FramebufferTextureLayer(target, attachment glbase.Enum, texture glbase.Texture, level int, layer int32) { + C.gl4_2core_glFramebufferTextureLayer(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLuint(texture), C.GLint(level), C.GLint(layer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRenderbufferStorageMultisample.xml +func (gl *GL) RenderbufferStorageMultisample(target glbase.Enum, samples int32, internalFormat glbase.Enum, width, height int) { + C.gl4_2core_glRenderbufferStorageMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlitFramebuffer.xml +func (gl *GL) BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1 int32, mask glbase.Bitfield, filter glbase.Enum) { + C.gl4_2core_glBlitFramebuffer(gl.funcs, C.GLint(srcX0), C.GLint(srcY0), C.GLint(srcX1), C.GLint(srcY1), C.GLint(dstX0), C.GLint(dstY0), C.GLint(dstX1), C.GLint(dstY1), C.GLbitfield(mask), C.GLenum(filter)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenerateMipmap.xml +func (gl *GL) GenerateMipmap(target glbase.Enum) { + C.gl4_2core_glGenerateMipmap(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFramebufferAttachmentParameteriv.xml +func (gl *GL) GetFramebufferAttachmentParameteriv(target, attachment, pname glbase.Enum, params []int32) { + C.gl4_2core_glGetFramebufferAttachmentParameteriv(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferRenderbuffer.xml +func (gl *GL) FramebufferRenderbuffer(target, attachment, renderbuffertarget glbase.Enum, renderbuffer glbase.Renderbuffer) { + C.gl4_2core_glFramebufferRenderbuffer(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(renderbuffertarget), C.GLuint(renderbuffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture3D.xml +func (gl *GL) FramebufferTexture3D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int, zoffset int32) { + C.gl4_2core_glFramebufferTexture3D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level), C.GLint(zoffset)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture2D.xml +func (gl *GL) FramebufferTexture2D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int) { + C.gl4_2core_glFramebufferTexture2D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture1D.xml +func (gl *GL) FramebufferTexture1D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int) { + C.gl4_2core_glFramebufferTexture1D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCheckFramebufferStatus.xml +func (gl *GL) CheckFramebufferStatus(target glbase.Enum) glbase.Enum { + glresult := C.gl4_2core_glCheckFramebufferStatus(gl.funcs, C.GLenum(target)) + return glbase.Enum(glresult) +} + +// GenFramebuffers returns n framebuffer object names in ids. There is no +// guarantee that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenFramebuffers. +// +// Framebuffer object names returned by a call to GenFramebuffers are not +// returned by subsequent calls, unless they are first deleted with +// DeleteFramebuffers. +// +// The names returned in ids are marked as used, for the purposes of +// GenFramebuffers only, but they acquire state and type only when they are +// first bound. +// +// Error GL.INVALID_VALUE is generated if n is negative. +func (gl *GL) GenFramebuffers(n int) []glbase.Framebuffer { + if n == 0 { + return nil + } + framebuffers := make([]glbase.Framebuffer, n) + C.gl4_2core_glGenFramebuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&framebuffers[0]))) + return framebuffers +} + +// DeleteFramebuffers deletes the framebuffer objects whose names are +// stored in the framebuffers slice. The name zero is reserved by the GL and +// is silently ignored, should it occur in framebuffers, as are other unused +// names. Once a framebuffer object is deleted, its name is again unused and +// it has no attachments. If a framebuffer that is currently bound to one or +// more of the targets GL.DRAW_FRAMEBUFFER or GL.READ_FRAMEBUFFER is deleted, +// it is as though BindFramebuffer had been executed with the corresponding +// target and framebuffer zero. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteFramebuffers is available in GL version 3.0 or greater. +func (gl *GL) DeleteFramebuffers(framebuffers []glbase.Framebuffer) { + n := len(framebuffers) + if n == 0 { + return + } + C.gl4_2core_glDeleteFramebuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&framebuffers[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindFramebuffer.xml +func (gl *GL) BindFramebuffer(target glbase.Enum, framebuffer glbase.Framebuffer) { + C.gl4_2core_glBindFramebuffer(gl.funcs, C.GLenum(target), C.GLuint(framebuffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsFramebuffer.xml +func (gl *GL) IsFramebuffer(framebuffer glbase.Framebuffer) bool { + glresult := C.gl4_2core_glIsFramebuffer(gl.funcs, C.GLuint(framebuffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetRenderbufferParameteriv.xml +func (gl *GL) GetRenderbufferParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_2core_glGetRenderbufferParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRenderbufferStorage.xml +func (gl *GL) RenderbufferStorage(target, internalFormat glbase.Enum, width, height int) { + C.gl4_2core_glRenderbufferStorage(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) +} + +// GenRenderbuffers returns n renderbuffer object names in renderbuffers. +// There is no guarantee that the names form a contiguous set of integers; +// however, it is guaranteed that none of the returned names was in use +// immediately before the call to GenRenderbuffers. +// +// Renderbuffer object names returned by a call to GenRenderbuffers are not +// returned by subsequent calls, unless they are first deleted with +// DeleteRenderbuffers. +// +// The names returned in renderbuffers are marked as used, for the purposes +// of GenRenderbuffers only, but they acquire state and type only when they +// are first bound. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenRenderbuffers is available in GL version 3.0 or greater. +func (gl *GL) GenRenderbuffers(n int) []glbase.Renderbuffer { + if n == 0 { + return nil + } + renderbuffers := make([]glbase.Renderbuffer, n) + C.gl4_2core_glGenRenderbuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&renderbuffers[0]))) + return renderbuffers +} + +// DeleteRenderbuffers deletes the renderbuffer objects whose names are stored +// in the renderbuffers slice. The name zero is reserved by the GL and +// is silently ignored, should it occur in renderbuffers, as are other unused +// names. Once a renderbuffer object is deleted, its name is again unused and +// it has no contents. If a renderbuffer that is currently bound to the +// target GL.RENDERBUFFER is deleted, it is as though BindRenderbuffer had +// been executed with a target of GL.RENDERBUFFER and a name of zero. +// +// If a renderbuffer object is attached to one or more attachment points in +// the currently bound framebuffer, then it as if FramebufferRenderbuffer +// had been called, with a renderbuffer of zero for each attachment point to +// which this image was attached in the currently bound framebuffer. In other +// words, this renderbuffer object is first detached from all attachment +// ponits in the currently bound framebuffer. Note that the renderbuffer +// image is specifically not detached from any non-bound framebuffers. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteRenderbuffers is available in GL version 3.0 or greater. +func (gl *GL) DeleteRenderbuffers(renderbuffers []glbase.Renderbuffer) { + n := len(renderbuffers) + if n == 0 { + return + } + C.gl4_2core_glDeleteRenderbuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&renderbuffers[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindRenderbuffer.xml +func (gl *GL) BindRenderbuffer(target glbase.Enum, renderbuffer glbase.Renderbuffer) { + C.gl4_2core_glBindRenderbuffer(gl.funcs, C.GLenum(target), C.GLuint(renderbuffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsRenderbuffer.xml +func (gl *GL) IsRenderbuffer(renderbuffer glbase.Renderbuffer) bool { + glresult := C.gl4_2core_glIsRenderbuffer(gl.funcs, C.GLuint(renderbuffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferfi.xml +func (gl *GL) ClearBufferfi(buffer glbase.Enum, drawbuffer int32, depth float32, stencil int32) { + C.gl4_2core_glClearBufferfi(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), C.GLfloat(depth), C.GLint(stencil)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferfv.xml +func (gl *GL) ClearBufferfv(buffer glbase.Enum, drawbuffer int32, value []float32) { + C.gl4_2core_glClearBufferfv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferuiv.xml +func (gl *GL) ClearBufferuiv(buffer glbase.Enum, drawbuffer int32, value []uint32) { + C.gl4_2core_glClearBufferuiv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferiv.xml +func (gl *GL) ClearBufferiv(buffer glbase.Enum, drawbuffer int32, value []int32) { + C.gl4_2core_glClearBufferiv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameterIuiv.xml +func (gl *GL) GetTexParameterIuiv(target, pname glbase.Enum, params []uint32) { + C.gl4_2core_glGetTexParameterIuiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameterIiv.xml +func (gl *GL) GetTexParameterIiv(target, pname glbase.Enum, params []int32) { + C.gl4_2core_glGetTexParameterIiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterIuiv.xml +func (gl *GL) TexParameterIuiv(target, pname glbase.Enum, params []uint32) { + C.gl4_2core_glTexParameterIuiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterIiv.xml +func (gl *GL) TexParameterIiv(target, pname glbase.Enum, params []int32) { + C.gl4_2core_glTexParameterIiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// Uniform4uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4uiv") + } + count := len(value) / 4 + C.gl4_2core_glUniform4uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform3uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3uiv") + } + count := len(value) / 3 + C.gl4_2core_glUniform3uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform2uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2uiv") + } + count := len(value) / 2 + C.gl4_2core_glUniform2uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform1uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl4_2core_glUniform1uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform4ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4ui(location glbase.Uniform, v0, v1, v2, v3 uint32) { + C.gl4_2core_glUniform4ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2), C.GLuint(v3)) +} + +// Uniform3ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3ui(location glbase.Uniform, v0, v1, v2 uint32) { + C.gl4_2core_glUniform3ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2)) +} + +// Uniform2ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2ui(location glbase.Uniform, v0, v1 uint32) { + C.gl4_2core_glUniform2ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1)) +} + +// Uniform1ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1ui(location glbase.Uniform, v0 uint32) { + C.gl4_2core_glUniform1ui(gl.funcs, C.GLint(location), C.GLuint(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFragDataLocation.xml +func (gl *GL) GetFragDataLocation(program glbase.Program, name []byte) int32 { + glresult := C.gl4_2core_glGetFragDataLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindFragDataLocation.xml +func (gl *GL) BindFragDataLocation(program glbase.Program, color uint32, name []byte) { + C.gl4_2core_glBindFragDataLocation(gl.funcs, C.GLuint(program), C.GLuint(color), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetUniformuiv.xml +func (gl *GL) GetUniformuiv(program glbase.Program, location glbase.Uniform, params []uint32) { + C.gl4_2core_glGetUniformuiv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetVertexAttribIuiv.xml +func (gl *GL) GetVertexAttribIuiv(index glbase.Attrib, pname glbase.Enum, params []uint32) { + C.gl4_2core_glGetVertexAttribIuiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetVertexAttribIiv.xml +func (gl *GL) GetVertexAttribIiv(index glbase.Attrib, pname glbase.Enum, params []int32) { + C.gl4_2core_glGetVertexAttribIiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribIPointer.xml +func (gl *GL) VertexAttribIPointer(index glbase.Attrib, size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_2core_glVertexAttribIPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndConditionalRender.xml +func (gl *GL) EndConditionalRender() { + C.gl4_2core_glEndConditionalRender(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBeginConditionalRender.xml +func (gl *GL) BeginConditionalRender(id uint32, mode glbase.Enum) { + C.gl4_2core_glBeginConditionalRender(gl.funcs, C.GLuint(id), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClampColor.xml +func (gl *GL) ClampColor(target, clamp glbase.Enum) { + C.gl4_2core_glClampColor(gl.funcs, C.GLenum(target), C.GLenum(clamp)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTransformFeedbackVarying.xml +func (gl *GL) GetTransformFeedbackVarying(program glbase.Program, index uint32, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl4_2core_glGetTransformFeedbackVarying(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLsizei)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindBufferBase.xml +func (gl *GL) BindBufferBase(target glbase.Enum, index uint32, buffer glbase.Buffer) { + C.gl4_2core_glBindBufferBase(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindBufferRange.xml +func (gl *GL) BindBufferRange(target glbase.Enum, index uint32, buffer glbase.Buffer, offset, size int) { + C.gl4_2core_glBindBufferRange(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(buffer), C.GLintptr(offset), C.GLsizeiptr(size)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndTransformFeedback.xml +func (gl *GL) EndTransformFeedback() { + C.gl4_2core_glEndTransformFeedback(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBeginTransformFeedback.xml +func (gl *GL) BeginTransformFeedback(primitiveMode glbase.Enum) { + C.gl4_2core_glBeginTransformFeedback(gl.funcs, C.GLenum(primitiveMode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsEnabledi.xml +func (gl *GL) IsEnabledi(target glbase.Enum, index uint32) bool { + glresult := C.gl4_2core_glIsEnabledi(gl.funcs, C.GLenum(target), C.GLuint(index)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDisablei.xml +func (gl *GL) Disablei(target glbase.Enum, index uint32) { + C.gl4_2core_glDisablei(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEnablei.xml +func (gl *GL) Enablei(target glbase.Enum, index uint32) { + C.gl4_2core_glEnablei(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetIntegeri_v.xml +func (gl *GL) GetIntegeri_v(target glbase.Enum, index uint32, data []int32) { + C.gl4_2core_glGetIntegeri_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLint)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBooleani_v.xml +func (gl *GL) GetBooleani_v(target glbase.Enum, index uint32, data []bool) { + C.gl4_2core_glGetBooleani_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLboolean)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorMaski.xml +func (gl *GL) ColorMaski(index uint32, r, g, b, a bool) { + C.gl4_2core_glColorMaski(gl.funcs, C.GLuint(index), *(*C.GLboolean)(unsafe.Pointer(&r)), *(*C.GLboolean)(unsafe.Pointer(&g)), *(*C.GLboolean)(unsafe.Pointer(&b)), *(*C.GLboolean)(unsafe.Pointer(&a))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyBufferSubData.xml +func (gl *GL) CopyBufferSubData(readTarget, writeTarget glbase.Enum, readOffset, writeOffset, size int) { + C.gl4_2core_glCopyBufferSubData(gl.funcs, C.GLenum(readTarget), C.GLenum(writeTarget), C.GLintptr(readOffset), C.GLintptr(writeOffset), C.GLsizeiptr(size)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformBlockBinding.xml +func (gl *GL) UniformBlockBinding(program glbase.Program, v0, v1 uint32) { + C.gl4_2core_glUniformBlockBinding(gl.funcs, C.GLuint(program), C.GLuint(v0), C.GLuint(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformBlockName.xml +func (gl *GL) GetActiveUniformBlockName(program glbase.Program, uniformBlockIndex uint32, bufSize int32, length []int32, uniformBlockName []byte) { + C.gl4_2core_glGetActiveUniformBlockName(gl.funcs, C.GLuint(program), C.GLuint(uniformBlockIndex), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&uniformBlockName[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformBlockiv.xml +func (gl *GL) GetActiveUniformBlockiv(program glbase.Program, uniformBlockIndex uint32, pname glbase.Enum, params []int32) { + C.gl4_2core_glGetActiveUniformBlockiv(gl.funcs, C.GLuint(program), C.GLuint(uniformBlockIndex), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetUniformBlockIndex.xml +func (gl *GL) GetUniformBlockIndex(program glbase.Program, uniformBlockName []byte) uint32 { + glresult := C.gl4_2core_glGetUniformBlockIndex(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&uniformBlockName[0]))) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformName.xml +func (gl *GL) GetActiveUniformName(program glbase.Program, uniformIndex uint32, bufSize int32, length []int32, uniformName []byte) { + C.gl4_2core_glGetActiveUniformName(gl.funcs, C.GLuint(program), C.GLuint(uniformIndex), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&uniformName[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformsiv.xml +func (gl *GL) GetActiveUniformsiv(program glbase.Program, uniformCount int32, uniformIndices []uint32, pname glbase.Enum, params []int32) { + C.gl4_2core_glGetActiveUniformsiv(gl.funcs, C.GLuint(program), C.GLsizei(uniformCount), (*C.GLuint)(unsafe.Pointer(&uniformIndices[0])), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPrimitiveRestartIndex.xml +func (gl *GL) PrimitiveRestartIndex(index uint32) { + C.gl4_2core_glPrimitiveRestartIndex(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexBuffer.xml +func (gl *GL) TexBuffer(target, internalFormat glbase.Enum, buffer glbase.Buffer) { + C.gl4_2core_glTexBuffer(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsInstanced.xml +func (gl *GL) DrawElementsInstanced(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, instancecount int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_2core_glDrawElementsInstanced(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLsizei(instancecount)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawArraysInstanced.xml +func (gl *GL) DrawArraysInstanced(mode glbase.Enum, first, count int, instancecount int32) { + C.gl4_2core_glDrawArraysInstanced(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count), C.GLsizei(instancecount)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSampleMaski.xml +func (gl *GL) SampleMaski(index uint32, mask glbase.Bitfield) { + C.gl4_2core_glSampleMaski(gl.funcs, C.GLuint(index), C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMultisamplefv.xml +func (gl *GL) GetMultisamplefv(pname glbase.Enum, index uint32, val []float32) { + C.gl4_2core_glGetMultisamplefv(gl.funcs, C.GLenum(pname), C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&val[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage3DMultisample.xml +func (gl *GL) TexImage3DMultisample(target glbase.Enum, samples, internalFormat int32, width, height int, depth int32, fixedsamplelocations bool) { + C.gl4_2core_glTexImage3DMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), *(*C.GLboolean)(unsafe.Pointer(&fixedsamplelocations))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage2DMultisample.xml +func (gl *GL) TexImage2DMultisample(target glbase.Enum, samples, internalFormat int32, width, height int, fixedsamplelocations bool) { + C.gl4_2core_glTexImage2DMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), *(*C.GLboolean)(unsafe.Pointer(&fixedsamplelocations))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSynciv.xml +func (gl *GL) GetSynciv(sync glbase.Sync, pname glbase.Enum, bufSize int32, length, values []int32) { + C.gl4_2core_glGetSynciv(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLenum(pname), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetInteger64v.xml +func (gl *GL) GetInteger64v(pname glbase.Enum, params []int64) { + C.gl4_2core_glGetInteger64v(gl.funcs, C.GLenum(pname), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWaitSync.xml +func (gl *GL) WaitSync(sync glbase.Sync, flags glbase.Bitfield, timeout uint64) { + C.gl4_2core_glWaitSync(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLbitfield(flags), C.GLuint64(timeout)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClientWaitSync.xml +func (gl *GL) ClientWaitSync(sync glbase.Sync, flags glbase.Bitfield, timeout uint64) glbase.Enum { + glresult := C.gl4_2core_glClientWaitSync(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLbitfield(flags), C.GLuint64(timeout)) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteSync.xml +func (gl *GL) DeleteSync(sync glbase.Sync) { + C.gl4_2core_glDeleteSync(gl.funcs, C.GLsync(unsafe.Pointer(sync))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsSync.xml +func (gl *GL) IsSync(sync glbase.Sync) bool { + glresult := C.gl4_2core_glIsSync(gl.funcs, C.GLsync(unsafe.Pointer(sync))) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFenceSync.xml +func (gl *GL) FenceSync(condition glbase.Enum, flags glbase.Bitfield) glbase.Sync { + glresult := C.gl4_2core_glFenceSync(gl.funcs, C.GLenum(condition), C.GLbitfield(flags)) + return glbase.Sync(unsafe.Pointer(glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProvokingVertex.xml +func (gl *GL) ProvokingVertex(mode glbase.Enum) { + C.gl4_2core_glProvokingVertex(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsInstancedBaseVertex.xml +func (gl *GL) DrawElementsInstancedBaseVertex(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, instancecount, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_2core_glDrawElementsInstancedBaseVertex(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLsizei(instancecount), C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawRangeElementsBaseVertex.xml +func (gl *GL) DrawRangeElementsBaseVertex(mode glbase.Enum, start, end uint32, count int, gltype glbase.Enum, indices interface{}, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_2core_glDrawRangeElementsBaseVertex(gl.funcs, C.GLenum(mode), C.GLuint(start), C.GLuint(end), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsBaseVertex.xml +func (gl *GL) DrawElementsBaseVertex(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_2core_glDrawElementsBaseVertex(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture.xml +func (gl *GL) FramebufferTexture(target, attachment glbase.Enum, texture glbase.Texture, level int) { + C.gl4_2core_glFramebufferTexture(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBufferParameteri64v.xml +func (gl *GL) GetBufferParameteri64v(target, pname glbase.Enum, params []int64) { + C.gl4_2core_glGetBufferParameteri64v(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetInteger64i_v.xml +func (gl *GL) GetInteger64i_v(target glbase.Enum, index uint32, data []int64) { + C.gl4_2core_glGetInteger64i_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLint64)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP4uiv.xml +func (gl *GL) VertexAttribP4uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl4_2core_glVertexAttribP4uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP4ui.xml +func (gl *GL) VertexAttribP4ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl4_2core_glVertexAttribP4ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP3uiv.xml +func (gl *GL) VertexAttribP3uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl4_2core_glVertexAttribP3uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP3ui.xml +func (gl *GL) VertexAttribP3ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl4_2core_glVertexAttribP3ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP2uiv.xml +func (gl *GL) VertexAttribP2uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl4_2core_glVertexAttribP2uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP2ui.xml +func (gl *GL) VertexAttribP2ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl4_2core_glVertexAttribP2ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP1uiv.xml +func (gl *GL) VertexAttribP1uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl4_2core_glVertexAttribP1uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP1ui.xml +func (gl *GL) VertexAttribP1ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl4_2core_glVertexAttribP1ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColorP3uiv.xml +func (gl *GL) SecondaryColorP3uiv(gltype glbase.Enum, color []uint32) { + C.gl4_2core_glSecondaryColorP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&color[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColorP3ui.xml +func (gl *GL) SecondaryColorP3ui(gltype glbase.Enum, color uint32) { + C.gl4_2core_glSecondaryColorP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(color)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorP4uiv.xml +func (gl *GL) ColorP4uiv(gltype glbase.Enum, color []uint32) { + C.gl4_2core_glColorP4uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&color[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorP4ui.xml +func (gl *GL) ColorP4ui(gltype glbase.Enum, color uint32) { + C.gl4_2core_glColorP4ui(gl.funcs, C.GLenum(gltype), C.GLuint(color)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorP3uiv.xml +func (gl *GL) ColorP3uiv(gltype glbase.Enum, color []uint32) { + C.gl4_2core_glColorP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&color[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorP3ui.xml +func (gl *GL) ColorP3ui(gltype glbase.Enum, color uint32) { + C.gl4_2core_glColorP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(color)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormalP3uiv.xml +func (gl *GL) NormalP3uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_2core_glNormalP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormalP3ui.xml +func (gl *GL) NormalP3ui(gltype glbase.Enum, coords uint32) { + C.gl4_2core_glNormalP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP4uiv.xml +func (gl *GL) MultiTexCoordP4uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl4_2core_glMultiTexCoordP4uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP4ui.xml +func (gl *GL) MultiTexCoordP4ui(texture, gltype glbase.Enum, coords uint32) { + C.gl4_2core_glMultiTexCoordP4ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP3uiv.xml +func (gl *GL) MultiTexCoordP3uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl4_2core_glMultiTexCoordP3uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP3ui.xml +func (gl *GL) MultiTexCoordP3ui(texture, gltype glbase.Enum, coords uint32) { + C.gl4_2core_glMultiTexCoordP3ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP2uiv.xml +func (gl *GL) MultiTexCoordP2uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl4_2core_glMultiTexCoordP2uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP2ui.xml +func (gl *GL) MultiTexCoordP2ui(texture, gltype glbase.Enum, coords uint32) { + C.gl4_2core_glMultiTexCoordP2ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP1uiv.xml +func (gl *GL) MultiTexCoordP1uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl4_2core_glMultiTexCoordP1uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP1ui.xml +func (gl *GL) MultiTexCoordP1ui(texture, gltype glbase.Enum, coords uint32) { + C.gl4_2core_glMultiTexCoordP1ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP4uiv.xml +func (gl *GL) TexCoordP4uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_2core_glTexCoordP4uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP4ui.xml +func (gl *GL) TexCoordP4ui(gltype glbase.Enum, coords uint32) { + C.gl4_2core_glTexCoordP4ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP3uiv.xml +func (gl *GL) TexCoordP3uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_2core_glTexCoordP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP3ui.xml +func (gl *GL) TexCoordP3ui(gltype glbase.Enum, coords uint32) { + C.gl4_2core_glTexCoordP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP2uiv.xml +func (gl *GL) TexCoordP2uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_2core_glTexCoordP2uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP2ui.xml +func (gl *GL) TexCoordP2ui(gltype glbase.Enum, coords uint32) { + C.gl4_2core_glTexCoordP2ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP1uiv.xml +func (gl *GL) TexCoordP1uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_2core_glTexCoordP1uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP1ui.xml +func (gl *GL) TexCoordP1ui(gltype glbase.Enum, coords uint32) { + C.gl4_2core_glTexCoordP1ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP4uiv.xml +func (gl *GL) VertexP4uiv(gltype glbase.Enum, value []uint32) { + C.gl4_2core_glVertexP4uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP4ui.xml +func (gl *GL) VertexP4ui(gltype glbase.Enum, value uint32) { + C.gl4_2core_glVertexP4ui(gl.funcs, C.GLenum(gltype), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP3uiv.xml +func (gl *GL) VertexP3uiv(gltype glbase.Enum, value []uint32) { + C.gl4_2core_glVertexP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP3ui.xml +func (gl *GL) VertexP3ui(gltype glbase.Enum, value uint32) { + C.gl4_2core_glVertexP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP2uiv.xml +func (gl *GL) VertexP2uiv(gltype glbase.Enum, value []uint32) { + C.gl4_2core_glVertexP2uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP2ui.xml +func (gl *GL) VertexP2ui(gltype glbase.Enum, value uint32) { + C.gl4_2core_glVertexP2ui(gl.funcs, C.GLenum(gltype), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryObjectui64v.xml +func (gl *GL) GetQueryObjectui64v(id uint32, pname glbase.Enum, params []uint64) { + C.gl4_2core_glGetQueryObjectui64v(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLuint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryObjecti64v.xml +func (gl *GL) GetQueryObjecti64v(id uint32, pname glbase.Enum, params []int64) { + C.gl4_2core_glGetQueryObjecti64v(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glQueryCounter.xml +func (gl *GL) QueryCounter(id uint32, target glbase.Enum) { + C.gl4_2core_glQueryCounter(gl.funcs, C.GLuint(id), C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSamplerParameterIuiv.xml +func (gl *GL) GetSamplerParameterIuiv(sampler uint32, pname glbase.Enum, params []uint32) { + C.gl4_2core_glGetSamplerParameterIuiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSamplerParameterfv.xml +func (gl *GL) GetSamplerParameterfv(sampler uint32, pname glbase.Enum, params []float32) { + C.gl4_2core_glGetSamplerParameterfv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSamplerParameterIiv.xml +func (gl *GL) GetSamplerParameterIiv(sampler uint32, pname glbase.Enum, params []int32) { + C.gl4_2core_glGetSamplerParameterIiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSamplerParameteriv.xml +func (gl *GL) GetSamplerParameteriv(sampler uint32, pname glbase.Enum, params []int32) { + C.gl4_2core_glGetSamplerParameteriv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameterIuiv.xml +func (gl *GL) SamplerParameterIuiv(sampler uint32, pname glbase.Enum, param []uint32) { + C.gl4_2core_glSamplerParameterIuiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameterIiv.xml +func (gl *GL) SamplerParameterIiv(sampler uint32, pname glbase.Enum, param []int32) { + C.gl4_2core_glSamplerParameterIiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameterfv.xml +func (gl *GL) SamplerParameterfv(sampler uint32, pname glbase.Enum, param []float32) { + C.gl4_2core_glSamplerParameterfv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameterf.xml +func (gl *GL) SamplerParameterf(sampler uint32, pname glbase.Enum, param float32) { + C.gl4_2core_glSamplerParameterf(gl.funcs, C.GLuint(sampler), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameteriv.xml +func (gl *GL) SamplerParameteriv(sampler uint32, pname glbase.Enum, param []int32) { + C.gl4_2core_glSamplerParameteriv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameteri.xml +func (gl *GL) SamplerParameteri(sampler uint32, pname glbase.Enum, param int32) { + C.gl4_2core_glSamplerParameteri(gl.funcs, C.GLuint(sampler), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindSampler.xml +func (gl *GL) BindSampler(unit, sampler uint32) { + C.gl4_2core_glBindSampler(gl.funcs, C.GLuint(unit), C.GLuint(sampler)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsSampler.xml +func (gl *GL) IsSampler(sampler uint32) bool { + glresult := C.gl4_2core_glIsSampler(gl.funcs, C.GLuint(sampler)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteSamplers.xml +func (gl *GL) DeleteSamplers(count int, samplers []uint32) { + C.gl4_2core_glDeleteSamplers(gl.funcs, C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&samplers[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenSamplers.xml +func (gl *GL) GenSamplers(count int, samplers []uint32) { + C.gl4_2core_glGenSamplers(gl.funcs, C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&samplers[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFragDataIndex.xml +func (gl *GL) GetFragDataIndex(program glbase.Program, name []byte) int32 { + glresult := C.gl4_2core_glGetFragDataIndex(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindFragDataLocationIndexed.xml +func (gl *GL) BindFragDataLocationIndexed(program glbase.Program, colorNumber, index uint32, name []byte) { + C.gl4_2core_glBindFragDataLocationIndexed(gl.funcs, C.GLuint(program), C.GLuint(colorNumber), C.GLuint(index), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribDivisor.xml +func (gl *GL) VertexAttribDivisor(index glbase.Attrib, divisor uint32) { + C.gl4_2core_glVertexAttribDivisor(gl.funcs, C.GLuint(index), C.GLuint(divisor)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryIndexediv.xml +func (gl *GL) GetQueryIndexediv(target glbase.Enum, index uint32, pname glbase.Enum, params []int32) { + C.gl4_2core_glGetQueryIndexediv(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndQueryIndexed.xml +func (gl *GL) EndQueryIndexed(target glbase.Enum, index uint32) { + C.gl4_2core_glEndQueryIndexed(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBeginQueryIndexed.xml +func (gl *GL) BeginQueryIndexed(target glbase.Enum, index, id uint32) { + C.gl4_2core_glBeginQueryIndexed(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawTransformFeedbackStream.xml +func (gl *GL) DrawTransformFeedbackStream(mode glbase.Enum, id, stream uint32) { + C.gl4_2core_glDrawTransformFeedbackStream(gl.funcs, C.GLenum(mode), C.GLuint(id), C.GLuint(stream)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawTransformFeedback.xml +func (gl *GL) DrawTransformFeedback(mode glbase.Enum, id uint32) { + C.gl4_2core_glDrawTransformFeedback(gl.funcs, C.GLenum(mode), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glResumeTransformFeedback.xml +func (gl *GL) ResumeTransformFeedback() { + C.gl4_2core_glResumeTransformFeedback(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPauseTransformFeedback.xml +func (gl *GL) PauseTransformFeedback() { + C.gl4_2core_glPauseTransformFeedback(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsTransformFeedback.xml +func (gl *GL) IsTransformFeedback(id uint32) bool { + glresult := C.gl4_2core_glIsTransformFeedback(gl.funcs, C.GLuint(id)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenTransformFeedbacks.xml +func (gl *GL) GenTransformFeedbacks(n int, ids []uint32) { + C.gl4_2core_glGenTransformFeedbacks(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteTransformFeedbacks.xml +func (gl *GL) DeleteTransformFeedbacks(n int, ids []uint32) { + C.gl4_2core_glDeleteTransformFeedbacks(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindTransformFeedback.xml +func (gl *GL) BindTransformFeedback(target glbase.Enum, id uint32) { + C.gl4_2core_glBindTransformFeedback(gl.funcs, C.GLenum(target), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPatchParameterfv.xml +func (gl *GL) PatchParameterfv(pname glbase.Enum, values []float32) { + C.gl4_2core_glPatchParameterfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPatchParameteri.xml +func (gl *GL) PatchParameteri(pname glbase.Enum, value int32) { + C.gl4_2core_glPatchParameteri(gl.funcs, C.GLenum(pname), C.GLint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramStageiv.xml +func (gl *GL) GetProgramStageiv(program glbase.Program, shadertype, pname glbase.Enum, values []int32) { + C.gl4_2core_glGetProgramStageiv(gl.funcs, C.GLuint(program), C.GLenum(shadertype), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetUniformSubroutineuiv.xml +func (gl *GL) GetUniformSubroutineuiv(shadertype glbase.Enum, location glbase.Uniform, params []uint32) { + C.gl4_2core_glGetUniformSubroutineuiv(gl.funcs, C.GLenum(shadertype), C.GLint(location), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformSubroutinesuiv.xml +func (gl *GL) UniformSubroutinesuiv(shadertype glbase.Enum, count int, value []uint32) { + C.gl4_2core_glUniformSubroutinesuiv(gl.funcs, C.GLenum(shadertype), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveSubroutineName.xml +func (gl *GL) GetActiveSubroutineName(program glbase.Program, shadertype glbase.Enum, index uint32, bufSize int32, length []int32, name []byte) { + C.gl4_2core_glGetActiveSubroutineName(gl.funcs, C.GLuint(program), C.GLenum(shadertype), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveSubroutineUniformName.xml +func (gl *GL) GetActiveSubroutineUniformName(program glbase.Program, shadertype glbase.Enum, index uint32, bufSize int32, length []int32, name []byte) { + C.gl4_2core_glGetActiveSubroutineUniformName(gl.funcs, C.GLuint(program), C.GLenum(shadertype), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveSubroutineUniformiv.xml +func (gl *GL) GetActiveSubroutineUniformiv(program glbase.Program, shadertype glbase.Enum, index uint32, pname glbase.Enum, values []int32) { + C.gl4_2core_glGetActiveSubroutineUniformiv(gl.funcs, C.GLuint(program), C.GLenum(shadertype), C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSubroutineIndex.xml +func (gl *GL) GetSubroutineIndex(program glbase.Program, shadertype glbase.Enum, name []byte) uint32 { + glresult := C.gl4_2core_glGetSubroutineIndex(gl.funcs, C.GLuint(program), C.GLenum(shadertype), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSubroutineUniformLocation.xml +func (gl *GL) GetSubroutineUniformLocation(program glbase.Program, shadertype glbase.Enum, name []byte) int32 { + glresult := C.gl4_2core_glGetSubroutineUniformLocation(gl.funcs, C.GLuint(program), C.GLenum(shadertype), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetUniformdv.xml +func (gl *GL) GetUniformdv(program glbase.Program, location glbase.Uniform, params []float64) { + C.gl4_2core_glGetUniformdv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix4x3dv.xml +func (gl *GL) UniformMatrix4x3dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_2core_glUniformMatrix4x3dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix4x2dv.xml +func (gl *GL) UniformMatrix4x2dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_2core_glUniformMatrix4x2dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix3x4dv.xml +func (gl *GL) UniformMatrix3x4dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_2core_glUniformMatrix3x4dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix3x2dv.xml +func (gl *GL) UniformMatrix3x2dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_2core_glUniformMatrix3x2dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix2x4dv.xml +func (gl *GL) UniformMatrix2x4dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_2core_glUniformMatrix2x4dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix2x3dv.xml +func (gl *GL) UniformMatrix2x3dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_2core_glUniformMatrix2x3dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix4dv.xml +func (gl *GL) UniformMatrix4dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_2core_glUniformMatrix4dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix3dv.xml +func (gl *GL) UniformMatrix3dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_2core_glUniformMatrix3dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix2dv.xml +func (gl *GL) UniformMatrix2dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_2core_glUniformMatrix2dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform4dv.xml +func (gl *GL) Uniform4dv(location glbase.Uniform, count int, value []float64) { + C.gl4_2core_glUniform4dv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform3dv.xml +func (gl *GL) Uniform3dv(location glbase.Uniform, count int, value []float64) { + C.gl4_2core_glUniform3dv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform2dv.xml +func (gl *GL) Uniform2dv(location glbase.Uniform, count int, value []float64) { + C.gl4_2core_glUniform2dv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform1dv.xml +func (gl *GL) Uniform1dv(location glbase.Uniform, count int, value []float64) { + C.gl4_2core_glUniform1dv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform4d.xml +func (gl *GL) Uniform4d(location glbase.Uniform, v0, v1, v2, v3 float64) { + C.gl4_2core_glUniform4d(gl.funcs, C.GLint(location), C.GLdouble(v0), C.GLdouble(v1), C.GLdouble(v2), C.GLdouble(v3)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform3d.xml +func (gl *GL) Uniform3d(location glbase.Uniform, v0, v1, v2 float64) { + C.gl4_2core_glUniform3d(gl.funcs, C.GLint(location), C.GLdouble(v0), C.GLdouble(v1), C.GLdouble(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform2d.xml +func (gl *GL) Uniform2d(location glbase.Uniform, v0, v1 float64) { + C.gl4_2core_glUniform2d(gl.funcs, C.GLint(location), C.GLdouble(v0), C.GLdouble(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform1d.xml +func (gl *GL) Uniform1d(location glbase.Uniform, v0 float64) { + C.gl4_2core_glUniform1d(gl.funcs, C.GLint(location), C.GLdouble(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsIndirect.xml +func (gl *GL) DrawElementsIndirect(mode, gltype glbase.Enum, indirect interface{}) { + var indirect_ptr unsafe.Pointer + var indirect_v = reflect.ValueOf(indirect) + if indirect != nil && indirect_v.Kind() != reflect.Slice { + panic("parameter indirect must be a slice") + } + if indirect != nil { + indirect_ptr = unsafe.Pointer(indirect_v.Index(0).Addr().Pointer()) + } + C.gl4_2core_glDrawElementsIndirect(gl.funcs, C.GLenum(mode), C.GLenum(gltype), indirect_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawArraysIndirect.xml +func (gl *GL) DrawArraysIndirect(mode glbase.Enum, indirect interface{}) { + var indirect_ptr unsafe.Pointer + var indirect_v = reflect.ValueOf(indirect) + if indirect != nil && indirect_v.Kind() != reflect.Slice { + panic("parameter indirect must be a slice") + } + if indirect != nil { + indirect_ptr = unsafe.Pointer(indirect_v.Index(0).Addr().Pointer()) + } + C.gl4_2core_glDrawArraysIndirect(gl.funcs, C.GLenum(mode), indirect_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFuncSeparatei.xml +func (gl *GL) BlendFuncSeparatei(buf uint32, srcRGB, dstRGB, srcAlpha, dstAlpha glbase.Enum) { + C.gl4_2core_glBlendFuncSeparatei(gl.funcs, C.GLuint(buf), C.GLenum(srcRGB), C.GLenum(dstRGB), C.GLenum(srcAlpha), C.GLenum(dstAlpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFunci.xml +func (gl *GL) BlendFunci(buf uint32, src, dst glbase.Enum) { + C.gl4_2core_glBlendFunci(gl.funcs, C.GLuint(buf), C.GLenum(src), C.GLenum(dst)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendEquationSeparatei.xml +func (gl *GL) BlendEquationSeparatei(buf uint32, modeRGB, modeAlpha glbase.Enum) { + C.gl4_2core_glBlendEquationSeparatei(gl.funcs, C.GLuint(buf), C.GLenum(modeRGB), C.GLenum(modeAlpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendEquationi.xml +func (gl *GL) BlendEquationi(buf uint32, mode glbase.Enum) { + C.gl4_2core_glBlendEquationi(gl.funcs, C.GLuint(buf), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMinSampleShading.xml +func (gl *GL) MinSampleShading(value float32) { + C.gl4_2core_glMinSampleShading(gl.funcs, C.GLfloat(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetDoublei_v.xml +func (gl *GL) GetDoublei_v(target glbase.Enum, index uint32, data []float64) { + C.gl4_2core_glGetDoublei_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFloati_v.xml +func (gl *GL) GetFloati_v(target glbase.Enum, index uint32, data []float32) { + C.gl4_2core_glGetFloati_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDepthRangeIndexed.xml +func (gl *GL) DepthRangeIndexed(index uint32, n, f float64) { + C.gl4_2core_glDepthRangeIndexed(gl.funcs, C.GLuint(index), C.GLdouble(n), C.GLdouble(f)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDepthRangeArrayv.xml +func (gl *GL) DepthRangeArrayv(first uint32, count int, v []float64) { + C.gl4_2core_glDepthRangeArrayv(gl.funcs, C.GLuint(first), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glScissorIndexedv.xml +func (gl *GL) ScissorIndexedv(index uint32, v []int32) { + C.gl4_2core_glScissorIndexedv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glScissorIndexed.xml +func (gl *GL) ScissorIndexed(index uint32, left, bottom int32, width, height int) { + C.gl4_2core_glScissorIndexed(gl.funcs, C.GLuint(index), C.GLint(left), C.GLint(bottom), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glScissorArrayv.xml +func (gl *GL) ScissorArrayv(first uint32, count int, v []int32) { + C.gl4_2core_glScissorArrayv(gl.funcs, C.GLuint(first), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glViewportIndexedfv.xml +func (gl *GL) ViewportIndexedfv(index uint32, v []float32) { + C.gl4_2core_glViewportIndexedfv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glViewportIndexedf.xml +func (gl *GL) ViewportIndexedf(index uint32, x, y, w, h float32) { + C.gl4_2core_glViewportIndexedf(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y), C.GLfloat(w), C.GLfloat(h)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glViewportArrayv.xml +func (gl *GL) ViewportArrayv(first uint32, count int, v []float32) { + C.gl4_2core_glViewportArrayv(gl.funcs, C.GLuint(first), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetVertexAttribLdv.xml +func (gl *GL) GetVertexAttribLdv(index glbase.Attrib, pname glbase.Enum, params []float64) { + C.gl4_2core_glGetVertexAttribLdv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribLPointer.xml +func (gl *GL) VertexAttribLPointer(index glbase.Attrib, size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_2core_glVertexAttribLPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL4dv.xml +func (gl *GL) VertexAttribL4dv(index glbase.Attrib, v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_2core_glVertexAttribL4dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL3dv.xml +func (gl *GL) VertexAttribL3dv(index glbase.Attrib, v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_2core_glVertexAttribL3dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL2dv.xml +func (gl *GL) VertexAttribL2dv(index glbase.Attrib, v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_2core_glVertexAttribL2dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL1dv.xml +func (gl *GL) VertexAttribL1dv(index glbase.Attrib, v []float64) { + C.gl4_2core_glVertexAttribL1dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL4d.xml +func (gl *GL) VertexAttribL4d(index glbase.Attrib, x, y, z, w float64) { + C.gl4_2core_glVertexAttribL4d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL3d.xml +func (gl *GL) VertexAttribL3d(index glbase.Attrib, x, y, z float64) { + C.gl4_2core_glVertexAttribL3d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL2d.xml +func (gl *GL) VertexAttribL2d(index glbase.Attrib, x, y float64) { + C.gl4_2core_glVertexAttribL2d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL1d.xml +func (gl *GL) VertexAttribL1d(index glbase.Attrib, x float64) { + C.gl4_2core_glVertexAttribL1d(gl.funcs, C.GLuint(index), C.GLdouble(x)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramPipelineInfoLog.xml +func (gl *GL) GetProgramPipelineInfoLog(pipeline uint32, bufSize int32, length []int32, infoLog []byte) { + C.gl4_2core_glGetProgramPipelineInfoLog(gl.funcs, C.GLuint(pipeline), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glValidateProgramPipeline.xml +func (gl *GL) ValidateProgramPipeline(pipeline uint32) { + C.gl4_2core_glValidateProgramPipeline(gl.funcs, C.GLuint(pipeline)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4x3dv.xml +func (gl *GL) ProgramUniformMatrix4x3dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_2core_glProgramUniformMatrix4x3dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3x4dv.xml +func (gl *GL) ProgramUniformMatrix3x4dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_2core_glProgramUniformMatrix3x4dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4x2dv.xml +func (gl *GL) ProgramUniformMatrix4x2dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_2core_glProgramUniformMatrix4x2dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2x4dv.xml +func (gl *GL) ProgramUniformMatrix2x4dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_2core_glProgramUniformMatrix2x4dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3x2dv.xml +func (gl *GL) ProgramUniformMatrix3x2dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_2core_glProgramUniformMatrix3x2dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2x3dv.xml +func (gl *GL) ProgramUniformMatrix2x3dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_2core_glProgramUniformMatrix2x3dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4x3fv.xml +func (gl *GL) ProgramUniformMatrix4x3fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_2core_glProgramUniformMatrix4x3fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3x4fv.xml +func (gl *GL) ProgramUniformMatrix3x4fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_2core_glProgramUniformMatrix3x4fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4x2fv.xml +func (gl *GL) ProgramUniformMatrix4x2fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_2core_glProgramUniformMatrix4x2fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2x4fv.xml +func (gl *GL) ProgramUniformMatrix2x4fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_2core_glProgramUniformMatrix2x4fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3x2fv.xml +func (gl *GL) ProgramUniformMatrix3x2fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_2core_glProgramUniformMatrix3x2fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2x3fv.xml +func (gl *GL) ProgramUniformMatrix2x3fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_2core_glProgramUniformMatrix2x3fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4dv.xml +func (gl *GL) ProgramUniformMatrix4dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_2core_glProgramUniformMatrix4dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3dv.xml +func (gl *GL) ProgramUniformMatrix3dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_2core_glProgramUniformMatrix3dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2dv.xml +func (gl *GL) ProgramUniformMatrix2dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_2core_glProgramUniformMatrix2dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4fv.xml +func (gl *GL) ProgramUniformMatrix4fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_2core_glProgramUniformMatrix4fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3fv.xml +func (gl *GL) ProgramUniformMatrix3fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_2core_glProgramUniformMatrix3fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2fv.xml +func (gl *GL) ProgramUniformMatrix2fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_2core_glProgramUniformMatrix2fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4uiv.xml +func (gl *GL) ProgramUniform4uiv(program glbase.Program, location glbase.Uniform, count int, value []uint32) { + C.gl4_2core_glProgramUniform4uiv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4ui.xml +func (gl *GL) ProgramUniform4ui(program glbase.Program, location glbase.Uniform, v0, v1, v2, v3 uint32) { + C.gl4_2core_glProgramUniform4ui(gl.funcs, C.GLuint(program), C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2), C.GLuint(v3)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4dv.xml +func (gl *GL) ProgramUniform4dv(program glbase.Program, location glbase.Uniform, count int, value []float64) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_2core_glProgramUniform4dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4d.xml +func (gl *GL) ProgramUniform4d(program glbase.Program, location glbase.Uniform, v0, v1, v2, v3 float64) { + C.gl4_2core_glProgramUniform4d(gl.funcs, C.GLuint(program), C.GLint(location), C.GLdouble(v0), C.GLdouble(v1), C.GLdouble(v2), C.GLdouble(v3)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4fv.xml +func (gl *GL) ProgramUniform4fv(program glbase.Program, location glbase.Uniform, count int, value []float32) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_2core_glProgramUniform4fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4f.xml +func (gl *GL) ProgramUniform4f(program glbase.Program, location glbase.Uniform, v0, v1, v2, v3 float32) { + C.gl4_2core_glProgramUniform4f(gl.funcs, C.GLuint(program), C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2), C.GLfloat(v3)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4iv.xml +func (gl *GL) ProgramUniform4iv(program glbase.Program, location glbase.Uniform, count int, value []int32) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_2core_glProgramUniform4iv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4i.xml +func (gl *GL) ProgramUniform4i(program glbase.Program, location glbase.Uniform, v0, v1, v2, v3 int32) { + C.gl4_2core_glProgramUniform4i(gl.funcs, C.GLuint(program), C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2), C.GLint(v3)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3uiv.xml +func (gl *GL) ProgramUniform3uiv(program glbase.Program, location glbase.Uniform, count int, value []uint32) { + C.gl4_2core_glProgramUniform3uiv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3ui.xml +func (gl *GL) ProgramUniform3ui(program glbase.Program, location glbase.Uniform, v0, v1, v2 uint32) { + C.gl4_2core_glProgramUniform3ui(gl.funcs, C.GLuint(program), C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3dv.xml +func (gl *GL) ProgramUniform3dv(program glbase.Program, location glbase.Uniform, count int, value []float64) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_2core_glProgramUniform3dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3d.xml +func (gl *GL) ProgramUniform3d(program glbase.Program, location glbase.Uniform, v0, v1, v2 float64) { + C.gl4_2core_glProgramUniform3d(gl.funcs, C.GLuint(program), C.GLint(location), C.GLdouble(v0), C.GLdouble(v1), C.GLdouble(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3fv.xml +func (gl *GL) ProgramUniform3fv(program glbase.Program, location glbase.Uniform, count int, value []float32) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_2core_glProgramUniform3fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3f.xml +func (gl *GL) ProgramUniform3f(program glbase.Program, location glbase.Uniform, v0, v1, v2 float32) { + C.gl4_2core_glProgramUniform3f(gl.funcs, C.GLuint(program), C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3iv.xml +func (gl *GL) ProgramUniform3iv(program glbase.Program, location glbase.Uniform, count int, value []int32) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_2core_glProgramUniform3iv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3i.xml +func (gl *GL) ProgramUniform3i(program glbase.Program, location glbase.Uniform, v0, v1, v2 int32) { + C.gl4_2core_glProgramUniform3i(gl.funcs, C.GLuint(program), C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2uiv.xml +func (gl *GL) ProgramUniform2uiv(program glbase.Program, location glbase.Uniform, count int, value []uint32) { + C.gl4_2core_glProgramUniform2uiv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2ui.xml +func (gl *GL) ProgramUniform2ui(program glbase.Program, location glbase.Uniform, v0, v1 uint32) { + C.gl4_2core_glProgramUniform2ui(gl.funcs, C.GLuint(program), C.GLint(location), C.GLuint(v0), C.GLuint(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2dv.xml +func (gl *GL) ProgramUniform2dv(program glbase.Program, location glbase.Uniform, count int, value []float64) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_2core_glProgramUniform2dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2d.xml +func (gl *GL) ProgramUniform2d(program glbase.Program, location glbase.Uniform, v0, v1 float64) { + C.gl4_2core_glProgramUniform2d(gl.funcs, C.GLuint(program), C.GLint(location), C.GLdouble(v0), C.GLdouble(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2fv.xml +func (gl *GL) ProgramUniform2fv(program glbase.Program, location glbase.Uniform, count int, value []float32) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_2core_glProgramUniform2fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2f.xml +func (gl *GL) ProgramUniform2f(program glbase.Program, location glbase.Uniform, v0, v1 float32) { + C.gl4_2core_glProgramUniform2f(gl.funcs, C.GLuint(program), C.GLint(location), C.GLfloat(v0), C.GLfloat(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2iv.xml +func (gl *GL) ProgramUniform2iv(program glbase.Program, location glbase.Uniform, count int, value []int32) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_2core_glProgramUniform2iv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2i.xml +func (gl *GL) ProgramUniform2i(program glbase.Program, location glbase.Uniform, v0, v1 int32) { + C.gl4_2core_glProgramUniform2i(gl.funcs, C.GLuint(program), C.GLint(location), C.GLint(v0), C.GLint(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1uiv.xml +func (gl *GL) ProgramUniform1uiv(program glbase.Program, location glbase.Uniform, count int, value []uint32) { + C.gl4_2core_glProgramUniform1uiv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1ui.xml +func (gl *GL) ProgramUniform1ui(program glbase.Program, location glbase.Uniform, v0 uint32) { + C.gl4_2core_glProgramUniform1ui(gl.funcs, C.GLuint(program), C.GLint(location), C.GLuint(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1dv.xml +func (gl *GL) ProgramUniform1dv(program glbase.Program, location glbase.Uniform, count int, value []float64) { + C.gl4_2core_glProgramUniform1dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1d.xml +func (gl *GL) ProgramUniform1d(program glbase.Program, location glbase.Uniform, v0 float64) { + C.gl4_2core_glProgramUniform1d(gl.funcs, C.GLuint(program), C.GLint(location), C.GLdouble(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1fv.xml +func (gl *GL) ProgramUniform1fv(program glbase.Program, location glbase.Uniform, count int, value []float32) { + C.gl4_2core_glProgramUniform1fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1f.xml +func (gl *GL) ProgramUniform1f(program glbase.Program, location glbase.Uniform, v0 float32) { + C.gl4_2core_glProgramUniform1f(gl.funcs, C.GLuint(program), C.GLint(location), C.GLfloat(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1iv.xml +func (gl *GL) ProgramUniform1iv(program glbase.Program, location glbase.Uniform, count int, value []int32) { + C.gl4_2core_glProgramUniform1iv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1i.xml +func (gl *GL) ProgramUniform1i(program glbase.Program, location glbase.Uniform, v0 int32) { + C.gl4_2core_glProgramUniform1i(gl.funcs, C.GLuint(program), C.GLint(location), C.GLint(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramPipelineiv.xml +func (gl *GL) GetProgramPipelineiv(pipeline uint32, pname glbase.Enum, params []int32) { + C.gl4_2core_glGetProgramPipelineiv(gl.funcs, C.GLuint(pipeline), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsProgramPipeline.xml +func (gl *GL) IsProgramPipeline(pipeline uint32) bool { + glresult := C.gl4_2core_glIsProgramPipeline(gl.funcs, C.GLuint(pipeline)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenProgramPipelines.xml +func (gl *GL) GenProgramPipelines(n int, pipelines []uint32) { + C.gl4_2core_glGenProgramPipelines(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&pipelines[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteProgramPipelines.xml +func (gl *GL) DeleteProgramPipelines(n int, pipelines []uint32) { + C.gl4_2core_glDeleteProgramPipelines(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&pipelines[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindProgramPipeline.xml +func (gl *GL) BindProgramPipeline(pipeline uint32) { + C.gl4_2core_glBindProgramPipeline(gl.funcs, C.GLuint(pipeline)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glActiveShaderProgram.xml +func (gl *GL) ActiveShaderProgram(pipeline uint32, program glbase.Program) { + C.gl4_2core_glActiveShaderProgram(gl.funcs, C.GLuint(pipeline), C.GLuint(program)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUseProgramStages.xml +func (gl *GL) UseProgramStages(pipeline uint32, stages glbase.Bitfield, program glbase.Program) { + C.gl4_2core_glUseProgramStages(gl.funcs, C.GLuint(pipeline), C.GLbitfield(stages), C.GLuint(program)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramParameteri.xml +func (gl *GL) ProgramParameteri(program glbase.Program, pname glbase.Enum, value int32) { + C.gl4_2core_glProgramParameteri(gl.funcs, C.GLuint(program), C.GLenum(pname), C.GLint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramBinary.xml +func (gl *GL) ProgramBinary(program glbase.Program, binaryFormat glbase.Enum, binary interface{}, length int32) { + var binary_ptr unsafe.Pointer + var binary_v = reflect.ValueOf(binary) + if binary != nil && binary_v.Kind() != reflect.Slice { + panic("parameter binary must be a slice") + } + if binary != nil { + binary_ptr = unsafe.Pointer(binary_v.Index(0).Addr().Pointer()) + } + C.gl4_2core_glProgramBinary(gl.funcs, C.GLuint(program), C.GLenum(binaryFormat), binary_ptr, C.GLsizei(length)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramBinary.xml +func (gl *GL) GetProgramBinary(program glbase.Program, bufSize int32, length []int32, binaryFormat []glbase.Enum, binary interface{}) { + var binary_ptr unsafe.Pointer + var binary_v = reflect.ValueOf(binary) + if binary != nil && binary_v.Kind() != reflect.Slice { + panic("parameter binary must be a slice") + } + if binary != nil { + binary_ptr = unsafe.Pointer(binary_v.Index(0).Addr().Pointer()) + } + C.gl4_2core_glGetProgramBinary(gl.funcs, C.GLuint(program), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLenum)(unsafe.Pointer(&binaryFormat[0])), binary_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearDepthf.xml +func (gl *GL) ClearDepthf(dd float32) { + C.gl4_2core_glClearDepthf(gl.funcs, C.GLfloat(dd)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDepthRangef.xml +func (gl *GL) DepthRangef(n, f float32) { + C.gl4_2core_glDepthRangef(gl.funcs, C.GLfloat(n), C.GLfloat(f)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetShaderPrecisionFormat.xml +func (gl *GL) GetShaderPrecisionFormat(shadertype, precisionType glbase.Enum, range_, precision []int32) { + C.gl4_2core_glGetShaderPrecisionFormat(gl.funcs, C.GLenum(shadertype), C.GLenum(precisionType), (*C.GLint)(unsafe.Pointer(&range_[0])), (*C.GLint)(unsafe.Pointer(&precision[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glShaderBinary.xml +func (gl *GL) ShaderBinary(count int, shaders []glbase.Shader, binaryFormat glbase.Enum, binary interface{}, length int32) { + var binary_ptr unsafe.Pointer + var binary_v = reflect.ValueOf(binary) + if binary != nil && binary_v.Kind() != reflect.Slice { + panic("parameter binary must be a slice") + } + if binary != nil { + binary_ptr = unsafe.Pointer(binary_v.Index(0).Addr().Pointer()) + } + C.gl4_2core_glShaderBinary(gl.funcs, C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&shaders[0])), C.GLenum(binaryFormat), binary_ptr, C.GLsizei(length)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glReleaseShaderCompiler.xml +func (gl *GL) ReleaseShaderCompiler() { + C.gl4_2core_glReleaseShaderCompiler(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexStorage3D.xml +func (gl *GL) TexStorage3D(target glbase.Enum, levels int32, internalFormat glbase.Enum, width, height int, depth int32) { + C.gl4_2core_glTexStorage3D(gl.funcs, C.GLenum(target), C.GLsizei(levels), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexStorage2D.xml +func (gl *GL) TexStorage2D(target glbase.Enum, levels int32, internalFormat glbase.Enum, width, height int) { + C.gl4_2core_glTexStorage2D(gl.funcs, C.GLenum(target), C.GLsizei(levels), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexStorage1D.xml +func (gl *GL) TexStorage1D(target glbase.Enum, levels int32, internalFormat glbase.Enum, width int) { + C.gl4_2core_glTexStorage1D(gl.funcs, C.GLenum(target), C.GLsizei(levels), C.GLenum(internalFormat), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMemoryBarrier.xml +func (gl *GL) MemoryBarrier(barriers glbase.Bitfield) { + C.gl4_2core_glMemoryBarrier(gl.funcs, C.GLbitfield(barriers)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindImageTexture.xml +func (gl *GL) BindImageTexture(unit uint32, texture glbase.Texture, level int, layered bool, layer int32, access, format glbase.Enum) { + C.gl4_2core_glBindImageTexture(gl.funcs, C.GLuint(unit), C.GLuint(texture), C.GLint(level), *(*C.GLboolean)(unsafe.Pointer(&layered)), C.GLint(layer), C.GLenum(access), C.GLenum(format)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveAtomicCounterBufferiv.xml +func (gl *GL) GetActiveAtomicCounterBufferiv(program glbase.Program, bufferIndex uint32, pname glbase.Enum, params []int32) { + C.gl4_2core_glGetActiveAtomicCounterBufferiv(gl.funcs, C.GLuint(program), C.GLuint(bufferIndex), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetInternalformativ.xml +func (gl *GL) GetInternalformativ(target, internalFormat, pname glbase.Enum, bufSize int32, params []int32) { + C.gl4_2core_glGetInternalformativ(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLenum(pname), C.GLsizei(bufSize), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawTransformFeedbackStreamInstanced.xml +func (gl *GL) DrawTransformFeedbackStreamInstanced(mode glbase.Enum, id, stream uint32, instancecount int32) { + C.gl4_2core_glDrawTransformFeedbackStreamInstanced(gl.funcs, C.GLenum(mode), C.GLuint(id), C.GLuint(stream), C.GLsizei(instancecount)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawTransformFeedbackInstanced.xml +func (gl *GL) DrawTransformFeedbackInstanced(mode glbase.Enum, id uint32, instancecount int32) { + C.gl4_2core_glDrawTransformFeedbackInstanced(gl.funcs, C.GLenum(mode), C.GLuint(id), C.GLsizei(instancecount)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsInstancedBaseVertexBaseInstance.xml +func (gl *GL) DrawElementsInstancedBaseVertexBaseInstance(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, instancecount, basevertex int32, baseinstance uint32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_2core_glDrawElementsInstancedBaseVertexBaseInstance(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLsizei(instancecount), C.GLint(basevertex), C.GLuint(baseinstance)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsInstancedBaseInstance.xml +func (gl *GL) DrawElementsInstancedBaseInstance(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, instancecount int32, baseinstance uint32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_2core_glDrawElementsInstancedBaseInstance(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLsizei(instancecount), C.GLuint(baseinstance)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawArraysInstancedBaseInstance.xml +func (gl *GL) DrawArraysInstancedBaseInstance(mode glbase.Enum, first, count int, instancecount int32, baseinstance uint32) { + C.gl4_2core_glDrawArraysInstancedBaseInstance(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count), C.GLsizei(instancecount), C.GLuint(baseinstance)) +} diff --git a/gl/4.3compat/funcs.cpp b/gl/4.3compat/funcs.cpp new file mode 100644 index 00000000..04ab8fad --- /dev/null +++ b/gl/4.3compat/funcs.cpp @@ -0,0 +1,5556 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#include +#include + +#include "funcs.h" + +void *gl4_3compat_funcs() { + QOpenGLFunctions_4_3_Compatibility* funcs = QOpenGLContext::currentContext()->versionFunctions(); + if (!funcs) { + return 0; + } + funcs->initializeOpenGLFunctions(); + return funcs; +} + + +void gl4_3compat_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewport(x, y, width, height); +} + +void gl4_3compat_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRange(nearVal, farVal); +} + +GLboolean gl4_3compat_glIsEnabled(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabled(cap); +} + +void gl4_3compat_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameteriv(target, level, pname, params); +} + +void gl4_3compat_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameterfv(target, level, pname, params); +} + +void gl4_3compat_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameteriv(target, pname, params); +} + +void gl4_3compat_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterfv(target, pname, params); +} + +void gl4_3compat_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexImage(target, level, format, gltype, pixels); +} + +void gl4_3compat_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegerv(pname, params); +} + +void gl4_3compat_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFloatv(pname, params); +} + +GLenum gl4_3compat_glGetError(void *_glfuncs) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetError(); +} + +void gl4_3compat_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetDoublev(pname, params); +} + +void gl4_3compat_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleanv(pname, params); +} + +void gl4_3compat_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadPixels(x, y, width, height, format, gltype, pixels); +} + +void gl4_3compat_glReadBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadBuffer(mode); +} + +void gl4_3compat_glPixelStorei(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStorei(pname, param); +} + +void gl4_3compat_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStoref(pname, param); +} + +void gl4_3compat_glDepthFunc(void *_glfuncs, GLenum glfunc) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthFunc(glfunc); +} + +void gl4_3compat_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOp(fail, zfail, zpass); +} + +void gl4_3compat_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFunc(glfunc, ref, mask); +} + +void gl4_3compat_glLogicOp(void *_glfuncs, GLenum opcode) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLogicOp(opcode); +} + +void gl4_3compat_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFunc(sfactor, dfactor); +} + +void gl4_3compat_glFlush(void *_glfuncs) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlush(); +} + +void gl4_3compat_glFinish(void *_glfuncs) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFinish(); +} + +void gl4_3compat_glEnable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnable(cap); +} + +void gl4_3compat_glDisable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisable(cap); +} + +void gl4_3compat_glDepthMask(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthMask(flag); +} + +void gl4_3compat_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMask(red, green, blue, alpha); +} + +void gl4_3compat_glStencilMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMask(mask); +} + +void gl4_3compat_glClearDepth(void *_glfuncs, GLdouble depth) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearDepth(depth); +} + +void gl4_3compat_glClearStencil(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearStencil(s); +} + +void gl4_3compat_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearColor(red, green, blue, alpha); +} + +void gl4_3compat_glClear(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClear(mask); +} + +void gl4_3compat_glDrawBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffer(mode); +} + +void gl4_3compat_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage2D(target, level, internalFormat, width, height, border, format, gltype, pixels); +} + +void gl4_3compat_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage1D(target, level, internalFormat, width, border, format, gltype, pixels); +} + +void gl4_3compat_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteriv(target, pname, params); +} + +void gl4_3compat_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteri(target, pname, param); +} + +void gl4_3compat_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterfv(target, pname, params); +} + +void gl4_3compat_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterf(target, pname, param); +} + +void gl4_3compat_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissor(x, y, width, height); +} + +void gl4_3compat_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonMode(face, mode); +} + +void gl4_3compat_glPointSize(void *_glfuncs, GLfloat size) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointSize(size); +} + +void gl4_3compat_glLineWidth(void *_glfuncs, GLfloat width) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineWidth(width); +} + +void gl4_3compat_glHint(void *_glfuncs, GLenum target, GLenum mode) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glHint(target, mode); +} + +void gl4_3compat_glFrontFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrontFace(mode); +} + +void gl4_3compat_glCullFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCullFace(mode); +} + +void gl4_3compat_glIndexubv(void *_glfuncs, const GLubyte* c) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexubv(c); +} + +void gl4_3compat_glIndexub(void *_glfuncs, GLubyte c) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexub(c); +} + +GLboolean gl4_3compat_glIsTexture(void *_glfuncs, GLuint texture) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsTexture(texture); +} + +void gl4_3compat_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenTextures(n, textures); +} + +void gl4_3compat_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteTextures(n, textures); +} + +void gl4_3compat_glBindTexture(void *_glfuncs, GLenum target, GLuint texture) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindTexture(target, texture); +} + +void gl4_3compat_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, gltype, pixels); +} + +void gl4_3compat_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage1D(target, level, xoffset, width, format, gltype, pixels); +} + +void gl4_3compat_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); +} + +void gl4_3compat_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage1D(target, level, xoffset, x, y, width); +} + +void gl4_3compat_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage2D(target, level, internalFormat, x, y, width, height, border); +} + +void gl4_3compat_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage1D(target, level, internalFormat, x, y, width, border); +} + +void gl4_3compat_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonOffset(factor, units); +} + +void gl4_3compat_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElements(mode, count, gltype, indices); +} + +void gl4_3compat_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArrays(mode, first, count); +} + +void gl4_3compat_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); +} + +void gl4_3compat_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, gltype, pixels); +} + +void gl4_3compat_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage3D(target, level, internalFormat, width, height, depth, border, format, gltype, pixels); +} + +void gl4_3compat_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawRangeElements(mode, start, end, count, gltype, indices); +} + +void gl4_3compat_glBlendEquation(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquation(mode); +} + +void gl4_3compat_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendColor(red, green, blue, alpha); +} + +void gl4_3compat_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetCompressedTexImage(target, level, img); +} + +void gl4_3compat_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data); +} + +void gl4_3compat_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); +} + +void gl4_3compat_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); +} + +void gl4_3compat_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage1D(target, level, internalFormat, width, border, imageSize, data); +} + +void gl4_3compat_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data); +} + +void gl4_3compat_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage3D(target, level, internalFormat, width, height, depth, border, imageSize, data); +} + +void gl4_3compat_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSampleCoverage(value, invert); +} + +void gl4_3compat_glActiveTexture(void *_glfuncs, GLenum texture) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glActiveTexture(texture); +} + +void gl4_3compat_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteriv(pname, params); +} + +void gl4_3compat_glPointParameteri(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteri(pname, param); +} + +void gl4_3compat_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterfv(pname, params); +} + +void gl4_3compat_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterf(pname, param); +} + +void gl4_3compat_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiDrawArrays(mode, first, count, drawcount); +} + +void gl4_3compat_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); +} + +void gl4_3compat_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferParameteriv(target, pname, params); +} + +GLboolean gl4_3compat_glUnmapBuffer(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glUnmapBuffer(target); +} + +void gl4_3compat_glGetBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferSubData(target, offset, size, data); +} + +void gl4_3compat_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferSubData(target, offset, size, data); +} + +void gl4_3compat_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferData(target, size, data, usage); +} + +GLboolean gl4_3compat_glIsBuffer(void *_glfuncs, GLuint buffer) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsBuffer(buffer); +} + +void gl4_3compat_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenBuffers(n, buffers); +} + +void gl4_3compat_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteBuffers(n, buffers); +} + +void gl4_3compat_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBuffer(target, buffer); +} + +void gl4_3compat_glGetQueryObjectuiv(void *_glfuncs, GLuint id, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectuiv(id, pname, params); +} + +void gl4_3compat_glGetQueryObjectiv(void *_glfuncs, GLuint id, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectiv(id, pname, params); +} + +void gl4_3compat_glGetQueryiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryiv(target, pname, params); +} + +void gl4_3compat_glEndQuery(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndQuery(target); +} + +void gl4_3compat_glBeginQuery(void *_glfuncs, GLenum target, GLuint id) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginQuery(target, id); +} + +GLboolean gl4_3compat_glIsQuery(void *_glfuncs, GLuint id) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsQuery(id); +} + +void gl4_3compat_glDeleteQueries(void *_glfuncs, GLsizei n, const GLuint* ids) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteQueries(n, ids); +} + +void gl4_3compat_glGenQueries(void *_glfuncs, GLsizei n, GLuint* ids) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenQueries(n, ids); +} + +void gl4_3compat_glVertexAttribPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLboolean normalized, GLsizei stride, const GLvoid* offset) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribPointer(index, size, gltype, normalized, stride, offset); +} + +void gl4_3compat_glValidateProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glValidateProgram(program); +} + +void gl4_3compat_glUniformMatrix4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4fv(location, count, transpose, value); +} + +void gl4_3compat_glUniformMatrix3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3fv(location, count, transpose, value); +} + +void gl4_3compat_glUniformMatrix2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2fv(location, count, transpose, value); +} + +void gl4_3compat_glUniform4iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4iv(location, count, value); +} + +void gl4_3compat_glUniform3iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3iv(location, count, value); +} + +void gl4_3compat_glUniform2iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2iv(location, count, value); +} + +void gl4_3compat_glUniform1iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1iv(location, count, value); +} + +void gl4_3compat_glUniform4fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4fv(location, count, value); +} + +void gl4_3compat_glUniform3fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3fv(location, count, value); +} + +void gl4_3compat_glUniform2fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2fv(location, count, value); +} + +void gl4_3compat_glUniform1fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1fv(location, count, value); +} + +void gl4_3compat_glUniform4i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4i(location, v0, v1, v2, v3); +} + +void gl4_3compat_glUniform3i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3i(location, v0, v1, v2); +} + +void gl4_3compat_glUniform2i(void *_glfuncs, GLint location, GLint v0, GLint v1) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2i(location, v0, v1); +} + +void gl4_3compat_glUniform1i(void *_glfuncs, GLint location, GLint v0) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1i(location, v0); +} + +void gl4_3compat_glUniform4f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4f(location, v0, v1, v2, v3); +} + +void gl4_3compat_glUniform3f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3f(location, v0, v1, v2); +} + +void gl4_3compat_glUniform2f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2f(location, v0, v1); +} + +void gl4_3compat_glUniform1f(void *_glfuncs, GLint location, GLfloat v0) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1f(location, v0); +} + +void gl4_3compat_glUseProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUseProgram(program); +} + +void gl4_3compat_glShaderSource(void *_glfuncs, GLuint shader, GLsizei count, const GLchar** source, const GLint* length) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShaderSource(shader, count, source, length); +} + +void gl4_3compat_glLinkProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLinkProgram(program); +} + +GLboolean gl4_3compat_glIsShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsShader(shader); +} + +GLboolean gl4_3compat_glIsProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsProgram(program); +} + +void gl4_3compat_glGetVertexAttribiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribiv(index, pname, params); +} + +void gl4_3compat_glGetVertexAttribfv(void *_glfuncs, GLuint index, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribfv(index, pname, params); +} + +void gl4_3compat_glGetVertexAttribdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribdv(index, pname, params); +} + +void gl4_3compat_glGetUniformiv(void *_glfuncs, GLuint program, GLint location, GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformiv(program, location, params); +} + +void gl4_3compat_glGetUniformfv(void *_glfuncs, GLuint program, GLint location, GLfloat* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformfv(program, location, params); +} + +GLint gl4_3compat_glGetUniformLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetUniformLocation(program, name); +} + +void gl4_3compat_glGetShaderSource(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderSource(shader, bufSize, length, source); +} + +void gl4_3compat_glGetShaderInfoLog(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderInfoLog(shader, bufSize, length, infoLog); +} + +void gl4_3compat_glGetShaderiv(void *_glfuncs, GLuint shader, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderiv(shader, pname, params); +} + +void gl4_3compat_glGetProgramInfoLog(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramInfoLog(program, bufSize, length, infoLog); +} + +void gl4_3compat_glGetProgramiv(void *_glfuncs, GLuint program, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramiv(program, pname, params); +} + +GLint gl4_3compat_glGetAttribLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetAttribLocation(program, name); +} + +void gl4_3compat_glGetAttachedShaders(void *_glfuncs, GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetAttachedShaders(program, maxCount, count, obj); +} + +void gl4_3compat_glGetActiveUniform(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniform(program, index, bufSize, length, size, gltype, name); +} + +void gl4_3compat_glGetActiveAttrib(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveAttrib(program, index, bufSize, length, size, gltype, name); +} + +void gl4_3compat_glEnableVertexAttribArray(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnableVertexAttribArray(index); +} + +void gl4_3compat_glDisableVertexAttribArray(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisableVertexAttribArray(index); +} + +void gl4_3compat_glDetachShader(void *_glfuncs, GLuint program, GLuint shader) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDetachShader(program, shader); +} + +void gl4_3compat_glDeleteShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteShader(shader); +} + +void gl4_3compat_glDeleteProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteProgram(program); +} + +GLuint gl4_3compat_glCreateShader(void *_glfuncs, GLenum gltype) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCreateShader(gltype); +} + +GLuint gl4_3compat_glCreateProgram(void *_glfuncs) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCreateProgram(); +} + +void gl4_3compat_glCompileShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompileShader(shader); +} + +void gl4_3compat_glBindAttribLocation(void *_glfuncs, GLuint program, GLuint index, const GLchar* name) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindAttribLocation(program, index, name); +} + +void gl4_3compat_glAttachShader(void *_glfuncs, GLuint program, GLuint shader) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAttachShader(program, shader); +} + +void gl4_3compat_glStencilMaskSeparate(void *_glfuncs, GLenum face, GLuint mask) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMaskSeparate(face, mask); +} + +void gl4_3compat_glStencilFuncSeparate(void *_glfuncs, GLenum face, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFuncSeparate(face, glfunc, ref, mask); +} + +void gl4_3compat_glStencilOpSeparate(void *_glfuncs, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOpSeparate(face, sfail, dpfail, dppass); +} + +void gl4_3compat_glDrawBuffers(void *_glfuncs, GLsizei n, const GLenum* bufs) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffers(n, bufs); +} + +void gl4_3compat_glBlendEquationSeparate(void *_glfuncs, GLenum modeRGB, GLenum modeAlpha) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquationSeparate(modeRGB, modeAlpha); +} + +void gl4_3compat_glUniformMatrix4x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x3fv(location, count, transpose, value); +} + +void gl4_3compat_glUniformMatrix3x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x4fv(location, count, transpose, value); +} + +void gl4_3compat_glUniformMatrix4x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x2fv(location, count, transpose, value); +} + +void gl4_3compat_glUniformMatrix2x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x4fv(location, count, transpose, value); +} + +void gl4_3compat_glUniformMatrix3x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x2fv(location, count, transpose, value); +} + +void gl4_3compat_glUniformMatrix2x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x3fv(location, count, transpose, value); +} + +GLboolean gl4_3compat_glIsVertexArray(void *_glfuncs, GLuint array) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsVertexArray(array); +} + +void gl4_3compat_glGenVertexArrays(void *_glfuncs, GLsizei n, GLuint* arrays) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenVertexArrays(n, arrays); +} + +void gl4_3compat_glDeleteVertexArrays(void *_glfuncs, GLsizei n, const GLuint* arrays) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteVertexArrays(n, arrays); +} + +void gl4_3compat_glBindVertexArray(void *_glfuncs, GLuint array) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindVertexArray(array); +} + +void gl4_3compat_glFlushMappedBufferRange(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr length) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlushMappedBufferRange(target, offset, length); +} + +void gl4_3compat_glFramebufferTextureLayer(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTextureLayer(target, attachment, texture, level, layer); +} + +void gl4_3compat_glRenderbufferStorageMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRenderbufferStorageMultisample(target, samples, internalFormat, width, height); +} + +void gl4_3compat_glBlitFramebuffer(void *_glfuncs, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); +} + +void gl4_3compat_glGenerateMipmap(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenerateMipmap(target); +} + +void gl4_3compat_glGetFramebufferAttachmentParameteriv(void *_glfuncs, GLenum target, GLenum attachment, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFramebufferAttachmentParameteriv(target, attachment, pname, params); +} + +void gl4_3compat_glFramebufferRenderbuffer(void *_glfuncs, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer); +} + +void gl4_3compat_glFramebufferTexture3D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset); +} + +void gl4_3compat_glFramebufferTexture2D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture2D(target, attachment, textarget, texture, level); +} + +void gl4_3compat_glFramebufferTexture1D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture1D(target, attachment, textarget, texture, level); +} + +GLenum gl4_3compat_glCheckFramebufferStatus(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCheckFramebufferStatus(target); +} + +void gl4_3compat_glGenFramebuffers(void *_glfuncs, GLsizei n, GLuint* framebuffers) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenFramebuffers(n, framebuffers); +} + +void gl4_3compat_glDeleteFramebuffers(void *_glfuncs, GLsizei n, const GLuint* framebuffers) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteFramebuffers(n, framebuffers); +} + +void gl4_3compat_glBindFramebuffer(void *_glfuncs, GLenum target, GLuint framebuffer) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFramebuffer(target, framebuffer); +} + +GLboolean gl4_3compat_glIsFramebuffer(void *_glfuncs, GLuint framebuffer) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsFramebuffer(framebuffer); +} + +void gl4_3compat_glGetRenderbufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetRenderbufferParameteriv(target, pname, params); +} + +void gl4_3compat_glRenderbufferStorage(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRenderbufferStorage(target, internalFormat, width, height); +} + +void gl4_3compat_glGenRenderbuffers(void *_glfuncs, GLsizei n, GLuint* renderbuffers) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenRenderbuffers(n, renderbuffers); +} + +void gl4_3compat_glDeleteRenderbuffers(void *_glfuncs, GLsizei n, const GLuint* renderbuffers) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteRenderbuffers(n, renderbuffers); +} + +void gl4_3compat_glBindRenderbuffer(void *_glfuncs, GLenum target, GLuint renderbuffer) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindRenderbuffer(target, renderbuffer); +} + +GLboolean gl4_3compat_glIsRenderbuffer(void *_glfuncs, GLuint renderbuffer) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsRenderbuffer(renderbuffer); +} + +void gl4_3compat_glClearBufferfi(void *_glfuncs, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferfi(buffer, drawbuffer, depth, stencil); +} + +void gl4_3compat_glClearBufferfv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferfv(buffer, drawbuffer, value); +} + +void gl4_3compat_glClearBufferuiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLuint* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferuiv(buffer, drawbuffer, value); +} + +void gl4_3compat_glClearBufferiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLint* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferiv(buffer, drawbuffer, value); +} + +void gl4_3compat_glGetTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterIuiv(target, pname, params); +} + +void gl4_3compat_glGetTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterIiv(target, pname, params); +} + +void gl4_3compat_glTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, const GLuint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterIuiv(target, pname, params); +} + +void gl4_3compat_glTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterIiv(target, pname, params); +} + +void gl4_3compat_glUniform4uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4uiv(location, count, value); +} + +void gl4_3compat_glUniform3uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3uiv(location, count, value); +} + +void gl4_3compat_glUniform2uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2uiv(location, count, value); +} + +void gl4_3compat_glUniform1uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1uiv(location, count, value); +} + +void gl4_3compat_glUniform4ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4ui(location, v0, v1, v2, v3); +} + +void gl4_3compat_glUniform3ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3ui(location, v0, v1, v2); +} + +void gl4_3compat_glUniform2ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2ui(location, v0, v1); +} + +void gl4_3compat_glUniform1ui(void *_glfuncs, GLint location, GLuint v0) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1ui(location, v0); +} + +GLint gl4_3compat_glGetFragDataLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetFragDataLocation(program, name); +} + +void gl4_3compat_glBindFragDataLocation(void *_glfuncs, GLuint program, GLuint color, const GLchar* name) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFragDataLocation(program, color, name); +} + +void gl4_3compat_glGetUniformuiv(void *_glfuncs, GLuint program, GLint location, GLuint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformuiv(program, location, params); +} + +void gl4_3compat_glGetVertexAttribIuiv(void *_glfuncs, GLuint index, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribIuiv(index, pname, params); +} + +void gl4_3compat_glGetVertexAttribIiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribIiv(index, pname, params); +} + +void gl4_3compat_glVertexAttribIPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribIPointer(index, size, gltype, stride, pointer); +} + +void gl4_3compat_glEndConditionalRender(void *_glfuncs) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndConditionalRender(); +} + +void gl4_3compat_glBeginConditionalRender(void *_glfuncs, GLuint id, GLenum mode) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginConditionalRender(id, mode); +} + +void gl4_3compat_glClampColor(void *_glfuncs, GLenum target, GLenum clamp) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClampColor(target, clamp); +} + +void gl4_3compat_glGetTransformFeedbackVarying(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTransformFeedbackVarying(program, index, bufSize, length, size, gltype, name); +} + +void gl4_3compat_glBindBufferBase(void *_glfuncs, GLenum target, GLuint index, GLuint buffer) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBufferBase(target, index, buffer); +} + +void gl4_3compat_glBindBufferRange(void *_glfuncs, GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBufferRange(target, index, buffer, offset, size); +} + +void gl4_3compat_glEndTransformFeedback(void *_glfuncs) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndTransformFeedback(); +} + +void gl4_3compat_glBeginTransformFeedback(void *_glfuncs, GLenum primitiveMode) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginTransformFeedback(primitiveMode); +} + +GLboolean gl4_3compat_glIsEnabledi(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabledi(target, index); +} + +void gl4_3compat_glDisablei(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisablei(target, index); +} + +void gl4_3compat_glEnablei(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnablei(target, index); +} + +void gl4_3compat_glGetIntegeri_v(void *_glfuncs, GLenum target, GLuint index, GLint* data) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegeri_v(target, index, data); +} + +void gl4_3compat_glGetBooleani_v(void *_glfuncs, GLenum target, GLuint index, GLboolean* data) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleani_v(target, index, data); +} + +void gl4_3compat_glColorMaski(void *_glfuncs, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMaski(index, r, g, b, a); +} + +void gl4_3compat_glCopyBufferSubData(void *_glfuncs, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); +} + +void gl4_3compat_glUniformBlockBinding(void *_glfuncs, GLuint program, GLuint v0, GLuint v1) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformBlockBinding(program, v0, v1); +} + +void gl4_3compat_glGetActiveUniformBlockName(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName); +} + +void gl4_3compat_glGetActiveUniformBlockiv(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params); +} + +GLuint gl4_3compat_glGetUniformBlockIndex(void *_glfuncs, GLuint program, const GLchar* uniformBlockName) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetUniformBlockIndex(program, uniformBlockName); +} + +void gl4_3compat_glGetActiveUniformName(void *_glfuncs, GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformName(program, uniformIndex, bufSize, length, uniformName); +} + +void gl4_3compat_glGetActiveUniformsiv(void *_glfuncs, GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params); +} + +void gl4_3compat_glPrimitiveRestartIndex(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPrimitiveRestartIndex(index); +} + +void gl4_3compat_glTexBuffer(void *_glfuncs, GLenum target, GLenum internalFormat, GLuint buffer) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexBuffer(target, internalFormat, buffer); +} + +void gl4_3compat_glDrawElementsInstanced(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsInstanced(mode, count, gltype, indices, instancecount); +} + +void gl4_3compat_glDrawArraysInstanced(void *_glfuncs, GLenum mode, GLint first, GLsizei count, GLsizei instancecount) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArraysInstanced(mode, first, count, instancecount); +} + +void gl4_3compat_glSampleMaski(void *_glfuncs, GLuint index, GLbitfield mask) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSampleMaski(index, mask); +} + +void gl4_3compat_glGetMultisamplefv(void *_glfuncs, GLenum pname, GLuint index, GLfloat* val) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMultisamplefv(pname, index, val); +} + +void gl4_3compat_glTexImage3DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage3DMultisample(target, samples, internalFormat, width, height, depth, fixedsamplelocations); +} + +void gl4_3compat_glTexImage2DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage2DMultisample(target, samples, internalFormat, width, height, fixedsamplelocations); +} + +void gl4_3compat_glGetSynciv(void *_glfuncs, GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSynciv(sync, pname, bufSize, length, values); +} + +void gl4_3compat_glGetInteger64v(void *_glfuncs, GLenum pname, GLint64* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetInteger64v(pname, params); +} + +void gl4_3compat_glWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWaitSync(sync, flags, timeout); +} + +GLenum gl4_3compat_glClientWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glClientWaitSync(sync, flags, timeout); +} + +void gl4_3compat_glDeleteSync(void *_glfuncs, GLsync sync) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteSync(sync); +} + +GLboolean gl4_3compat_glIsSync(void *_glfuncs, GLsync sync) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsSync(sync); +} + +GLsync gl4_3compat_glFenceSync(void *_glfuncs, GLenum condition, GLbitfield flags) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glFenceSync(condition, flags); +} + +void gl4_3compat_glProvokingVertex(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProvokingVertex(mode); +} + +void gl4_3compat_glDrawElementsInstancedBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLint basevertex) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsInstancedBaseVertex(mode, count, gltype, indices, instancecount, basevertex); +} + +void gl4_3compat_glDrawRangeElementsBaseVertex(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawRangeElementsBaseVertex(mode, start, end, count, gltype, indices, basevertex); +} + +void gl4_3compat_glDrawElementsBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsBaseVertex(mode, count, gltype, indices, basevertex); +} + +void gl4_3compat_glFramebufferTexture(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture(target, attachment, texture, level); +} + +void gl4_3compat_glGetBufferParameteri64v(void *_glfuncs, GLenum target, GLenum pname, GLint64* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferParameteri64v(target, pname, params); +} + +void gl4_3compat_glGetInteger64i_v(void *_glfuncs, GLenum target, GLuint index, GLint64* data) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetInteger64i_v(target, index, data); +} + +void gl4_3compat_glVertexAttribP4uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP4uiv(index, gltype, normalized, value); +} + +void gl4_3compat_glVertexAttribP4ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP4ui(index, gltype, normalized, value); +} + +void gl4_3compat_glVertexAttribP3uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP3uiv(index, gltype, normalized, value); +} + +void gl4_3compat_glVertexAttribP3ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP3ui(index, gltype, normalized, value); +} + +void gl4_3compat_glVertexAttribP2uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP2uiv(index, gltype, normalized, value); +} + +void gl4_3compat_glVertexAttribP2ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP2ui(index, gltype, normalized, value); +} + +void gl4_3compat_glVertexAttribP1uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP1uiv(index, gltype, normalized, value); +} + +void gl4_3compat_glVertexAttribP1ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP1ui(index, gltype, normalized, value); +} + +void gl4_3compat_glSecondaryColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColorP3uiv(gltype, color); +} + +void gl4_3compat_glSecondaryColorP3ui(void *_glfuncs, GLenum gltype, GLuint color) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColorP3ui(gltype, color); +} + +void gl4_3compat_glColorP4uiv(void *_glfuncs, GLenum gltype, const GLuint* color) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP4uiv(gltype, color); +} + +void gl4_3compat_glColorP4ui(void *_glfuncs, GLenum gltype, GLuint color) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP4ui(gltype, color); +} + +void gl4_3compat_glColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP3uiv(gltype, color); +} + +void gl4_3compat_glColorP3ui(void *_glfuncs, GLenum gltype, GLuint color) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP3ui(gltype, color); +} + +void gl4_3compat_glNormalP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormalP3uiv(gltype, coords); +} + +void gl4_3compat_glNormalP3ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormalP3ui(gltype, coords); +} + +void gl4_3compat_glMultiTexCoordP4uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP4uiv(texture, gltype, coords); +} + +void gl4_3compat_glMultiTexCoordP4ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP4ui(texture, gltype, coords); +} + +void gl4_3compat_glMultiTexCoordP3uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP3uiv(texture, gltype, coords); +} + +void gl4_3compat_glMultiTexCoordP3ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP3ui(texture, gltype, coords); +} + +void gl4_3compat_glMultiTexCoordP2uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP2uiv(texture, gltype, coords); +} + +void gl4_3compat_glMultiTexCoordP2ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP2ui(texture, gltype, coords); +} + +void gl4_3compat_glMultiTexCoordP1uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP1uiv(texture, gltype, coords); +} + +void gl4_3compat_glMultiTexCoordP1ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP1ui(texture, gltype, coords); +} + +void gl4_3compat_glTexCoordP4uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP4uiv(gltype, coords); +} + +void gl4_3compat_glTexCoordP4ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP4ui(gltype, coords); +} + +void gl4_3compat_glTexCoordP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP3uiv(gltype, coords); +} + +void gl4_3compat_glTexCoordP3ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP3ui(gltype, coords); +} + +void gl4_3compat_glTexCoordP2uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP2uiv(gltype, coords); +} + +void gl4_3compat_glTexCoordP2ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP2ui(gltype, coords); +} + +void gl4_3compat_glTexCoordP1uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP1uiv(gltype, coords); +} + +void gl4_3compat_glTexCoordP1ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP1ui(gltype, coords); +} + +void gl4_3compat_glVertexP4uiv(void *_glfuncs, GLenum gltype, const GLuint* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP4uiv(gltype, value); +} + +void gl4_3compat_glVertexP4ui(void *_glfuncs, GLenum gltype, GLuint value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP4ui(gltype, value); +} + +void gl4_3compat_glVertexP3uiv(void *_glfuncs, GLenum gltype, const GLuint* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP3uiv(gltype, value); +} + +void gl4_3compat_glVertexP3ui(void *_glfuncs, GLenum gltype, GLuint value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP3ui(gltype, value); +} + +void gl4_3compat_glVertexP2uiv(void *_glfuncs, GLenum gltype, const GLuint* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP2uiv(gltype, value); +} + +void gl4_3compat_glVertexP2ui(void *_glfuncs, GLenum gltype, GLuint value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP2ui(gltype, value); +} + +void gl4_3compat_glGetQueryObjectui64v(void *_glfuncs, GLuint id, GLenum pname, GLuint64* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectui64v(id, pname, params); +} + +void gl4_3compat_glGetQueryObjecti64v(void *_glfuncs, GLuint id, GLenum pname, GLint64* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjecti64v(id, pname, params); +} + +void gl4_3compat_glQueryCounter(void *_glfuncs, GLuint id, GLenum target) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glQueryCounter(id, target); +} + +void gl4_3compat_glGetSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameterIuiv(sampler, pname, params); +} + +void gl4_3compat_glGetSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameterfv(sampler, pname, params); +} + +void gl4_3compat_glGetSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameterIiv(sampler, pname, params); +} + +void gl4_3compat_glGetSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameteriv(sampler, pname, params); +} + +void gl4_3compat_glSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLuint* param) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterIuiv(sampler, pname, param); +} + +void gl4_3compat_glSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterIiv(sampler, pname, param); +} + +void gl4_3compat_glSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, const GLfloat* param) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterfv(sampler, pname, param); +} + +void gl4_3compat_glSamplerParameterf(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterf(sampler, pname, param); +} + +void gl4_3compat_glSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameteriv(sampler, pname, param); +} + +void gl4_3compat_glSamplerParameteri(void *_glfuncs, GLuint sampler, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameteri(sampler, pname, param); +} + +void gl4_3compat_glBindSampler(void *_glfuncs, GLuint unit, GLuint sampler) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindSampler(unit, sampler); +} + +GLboolean gl4_3compat_glIsSampler(void *_glfuncs, GLuint sampler) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsSampler(sampler); +} + +void gl4_3compat_glDeleteSamplers(void *_glfuncs, GLsizei count, const GLuint* samplers) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteSamplers(count, samplers); +} + +void gl4_3compat_glGenSamplers(void *_glfuncs, GLsizei count, GLuint* samplers) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenSamplers(count, samplers); +} + +GLint gl4_3compat_glGetFragDataIndex(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetFragDataIndex(program, name); +} + +void gl4_3compat_glBindFragDataLocationIndexed(void *_glfuncs, GLuint program, GLuint colorNumber, GLuint index, const GLchar* name) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFragDataLocationIndexed(program, colorNumber, index, name); +} + +void gl4_3compat_glVertexAttribDivisor(void *_glfuncs, GLuint index, GLuint divisor) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribDivisor(index, divisor); +} + +void gl4_3compat_glGetQueryIndexediv(void *_glfuncs, GLenum target, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryIndexediv(target, index, pname, params); +} + +void gl4_3compat_glEndQueryIndexed(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndQueryIndexed(target, index); +} + +void gl4_3compat_glBeginQueryIndexed(void *_glfuncs, GLenum target, GLuint index, GLuint id) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginQueryIndexed(target, index, id); +} + +void gl4_3compat_glDrawTransformFeedbackStream(void *_glfuncs, GLenum mode, GLuint id, GLuint stream) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawTransformFeedbackStream(mode, id, stream); +} + +void gl4_3compat_glDrawTransformFeedback(void *_glfuncs, GLenum mode, GLuint id) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawTransformFeedback(mode, id); +} + +void gl4_3compat_glResumeTransformFeedback(void *_glfuncs) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glResumeTransformFeedback(); +} + +void gl4_3compat_glPauseTransformFeedback(void *_glfuncs) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPauseTransformFeedback(); +} + +GLboolean gl4_3compat_glIsTransformFeedback(void *_glfuncs, GLuint id) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsTransformFeedback(id); +} + +void gl4_3compat_glGenTransformFeedbacks(void *_glfuncs, GLsizei n, GLuint* ids) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenTransformFeedbacks(n, ids); +} + +void gl4_3compat_glDeleteTransformFeedbacks(void *_glfuncs, GLsizei n, const GLuint* ids) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteTransformFeedbacks(n, ids); +} + +void gl4_3compat_glBindTransformFeedback(void *_glfuncs, GLenum target, GLuint id) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindTransformFeedback(target, id); +} + +void gl4_3compat_glPatchParameterfv(void *_glfuncs, GLenum pname, const GLfloat* values) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPatchParameterfv(pname, values); +} + +void gl4_3compat_glPatchParameteri(void *_glfuncs, GLenum pname, GLint value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPatchParameteri(pname, value); +} + +void gl4_3compat_glGetProgramStageiv(void *_glfuncs, GLuint program, GLenum shadertype, GLenum pname, GLint* values) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramStageiv(program, shadertype, pname, values); +} + +void gl4_3compat_glGetUniformSubroutineuiv(void *_glfuncs, GLenum shadertype, GLint location, GLuint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformSubroutineuiv(shadertype, location, params); +} + +void gl4_3compat_glUniformSubroutinesuiv(void *_glfuncs, GLenum shadertype, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformSubroutinesuiv(shadertype, count, value); +} + +void gl4_3compat_glGetActiveSubroutineName(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveSubroutineName(program, shadertype, index, bufSize, length, name); +} + +void gl4_3compat_glGetActiveSubroutineUniformName(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveSubroutineUniformName(program, shadertype, index, bufSize, length, name); +} + +void gl4_3compat_glGetActiveSubroutineUniformiv(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint* values) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveSubroutineUniformiv(program, shadertype, index, pname, values); +} + +GLuint gl4_3compat_glGetSubroutineIndex(void *_glfuncs, GLuint program, GLenum shadertype, const GLchar* name) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetSubroutineIndex(program, shadertype, name); +} + +GLint gl4_3compat_glGetSubroutineUniformLocation(void *_glfuncs, GLuint program, GLenum shadertype, const GLchar* name) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetSubroutineUniformLocation(program, shadertype, name); +} + +void gl4_3compat_glGetUniformdv(void *_glfuncs, GLuint program, GLint location, GLdouble* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformdv(program, location, params); +} + +void gl4_3compat_glUniformMatrix4x3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x3dv(location, count, transpose, value); +} + +void gl4_3compat_glUniformMatrix4x2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x2dv(location, count, transpose, value); +} + +void gl4_3compat_glUniformMatrix3x4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x4dv(location, count, transpose, value); +} + +void gl4_3compat_glUniformMatrix3x2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x2dv(location, count, transpose, value); +} + +void gl4_3compat_glUniformMatrix2x4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x4dv(location, count, transpose, value); +} + +void gl4_3compat_glUniformMatrix2x3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x3dv(location, count, transpose, value); +} + +void gl4_3compat_glUniformMatrix4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4dv(location, count, transpose, value); +} + +void gl4_3compat_glUniformMatrix3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3dv(location, count, transpose, value); +} + +void gl4_3compat_glUniformMatrix2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2dv(location, count, transpose, value); +} + +void gl4_3compat_glUniform4dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4dv(location, count, value); +} + +void gl4_3compat_glUniform3dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3dv(location, count, value); +} + +void gl4_3compat_glUniform2dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2dv(location, count, value); +} + +void gl4_3compat_glUniform1dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1dv(location, count, value); +} + +void gl4_3compat_glUniform4d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4d(location, v0, v1, v2, v3); +} + +void gl4_3compat_glUniform3d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1, GLdouble v2) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3d(location, v0, v1, v2); +} + +void gl4_3compat_glUniform2d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2d(location, v0, v1); +} + +void gl4_3compat_glUniform1d(void *_glfuncs, GLint location, GLdouble v0) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1d(location, v0); +} + +void gl4_3compat_glDrawElementsIndirect(void *_glfuncs, GLenum mode, GLenum gltype, const GLvoid* indirect) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsIndirect(mode, gltype, indirect); +} + +void gl4_3compat_glDrawArraysIndirect(void *_glfuncs, GLenum mode, const GLvoid* indirect) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArraysIndirect(mode, indirect); +} + +void gl4_3compat_glBlendFuncSeparatei(void *_glfuncs, GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha); +} + +void gl4_3compat_glBlendFunci(void *_glfuncs, GLuint buf, GLenum src, GLenum dst) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFunci(buf, src, dst); +} + +void gl4_3compat_glBlendEquationSeparatei(void *_glfuncs, GLuint buf, GLenum modeRGB, GLenum modeAlpha) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquationSeparatei(buf, modeRGB, modeAlpha); +} + +void gl4_3compat_glBlendEquationi(void *_glfuncs, GLuint buf, GLenum mode) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquationi(buf, mode); +} + +void gl4_3compat_glMinSampleShading(void *_glfuncs, GLfloat value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMinSampleShading(value); +} + +void gl4_3compat_glGetDoublei_v(void *_glfuncs, GLenum target, GLuint index, GLdouble* data) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetDoublei_v(target, index, data); +} + +void gl4_3compat_glGetFloati_v(void *_glfuncs, GLenum target, GLuint index, GLfloat* data) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFloati_v(target, index, data); +} + +void gl4_3compat_glDepthRangeIndexed(void *_glfuncs, GLuint index, GLdouble n, GLdouble f) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRangeIndexed(index, n, f); +} + +void gl4_3compat_glDepthRangeArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLdouble* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRangeArrayv(first, count, v); +} + +void gl4_3compat_glScissorIndexedv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissorIndexedv(index, v); +} + +void gl4_3compat_glScissorIndexed(void *_glfuncs, GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissorIndexed(index, left, bottom, width, height); +} + +void gl4_3compat_glScissorArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissorArrayv(first, count, v); +} + +void gl4_3compat_glViewportIndexedfv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewportIndexedfv(index, v); +} + +void gl4_3compat_glViewportIndexedf(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewportIndexedf(index, x, y, w, h); +} + +void gl4_3compat_glViewportArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLfloat* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewportArrayv(first, count, v); +} + +void gl4_3compat_glGetVertexAttribLdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribLdv(index, pname, params); +} + +void gl4_3compat_glVertexAttribLPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribLPointer(index, size, gltype, stride, pointer); +} + +void gl4_3compat_glVertexAttribL4dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL4dv(index, v); +} + +void gl4_3compat_glVertexAttribL3dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL3dv(index, v); +} + +void gl4_3compat_glVertexAttribL2dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL2dv(index, v); +} + +void gl4_3compat_glVertexAttribL1dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL1dv(index, v); +} + +void gl4_3compat_glVertexAttribL4d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL4d(index, x, y, z, w); +} + +void gl4_3compat_glVertexAttribL3d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL3d(index, x, y, z); +} + +void gl4_3compat_glVertexAttribL2d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL2d(index, x, y); +} + +void gl4_3compat_glVertexAttribL1d(void *_glfuncs, GLuint index, GLdouble x) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL1d(index, x); +} + +void gl4_3compat_glGetProgramPipelineInfoLog(void *_glfuncs, GLuint pipeline, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog); +} + +void gl4_3compat_glValidateProgramPipeline(void *_glfuncs, GLuint pipeline) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glValidateProgramPipeline(pipeline); +} + +void gl4_3compat_glProgramUniformMatrix4x3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4x3dv(program, location, count, transpose, value); +} + +void gl4_3compat_glProgramUniformMatrix3x4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3x4dv(program, location, count, transpose, value); +} + +void gl4_3compat_glProgramUniformMatrix4x2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4x2dv(program, location, count, transpose, value); +} + +void gl4_3compat_glProgramUniformMatrix2x4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2x4dv(program, location, count, transpose, value); +} + +void gl4_3compat_glProgramUniformMatrix3x2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3x2dv(program, location, count, transpose, value); +} + +void gl4_3compat_glProgramUniformMatrix2x3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2x3dv(program, location, count, transpose, value); +} + +void gl4_3compat_glProgramUniformMatrix4x3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4x3fv(program, location, count, transpose, value); +} + +void gl4_3compat_glProgramUniformMatrix3x4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3x4fv(program, location, count, transpose, value); +} + +void gl4_3compat_glProgramUniformMatrix4x2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4x2fv(program, location, count, transpose, value); +} + +void gl4_3compat_glProgramUniformMatrix2x4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2x4fv(program, location, count, transpose, value); +} + +void gl4_3compat_glProgramUniformMatrix3x2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3x2fv(program, location, count, transpose, value); +} + +void gl4_3compat_glProgramUniformMatrix2x3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2x3fv(program, location, count, transpose, value); +} + +void gl4_3compat_glProgramUniformMatrix4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4dv(program, location, count, transpose, value); +} + +void gl4_3compat_glProgramUniformMatrix3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3dv(program, location, count, transpose, value); +} + +void gl4_3compat_glProgramUniformMatrix2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2dv(program, location, count, transpose, value); +} + +void gl4_3compat_glProgramUniformMatrix4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4fv(program, location, count, transpose, value); +} + +void gl4_3compat_glProgramUniformMatrix3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3fv(program, location, count, transpose, value); +} + +void gl4_3compat_glProgramUniformMatrix2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2fv(program, location, count, transpose, value); +} + +void gl4_3compat_glProgramUniform4uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4uiv(program, location, count, value); +} + +void gl4_3compat_glProgramUniform4ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4ui(program, location, v0, v1, v2, v3); +} + +void gl4_3compat_glProgramUniform4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4dv(program, location, count, value); +} + +void gl4_3compat_glProgramUniform4d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4d(program, location, v0, v1, v2, v3); +} + +void gl4_3compat_glProgramUniform4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4fv(program, location, count, value); +} + +void gl4_3compat_glProgramUniform4f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4f(program, location, v0, v1, v2, v3); +} + +void gl4_3compat_glProgramUniform4iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4iv(program, location, count, value); +} + +void gl4_3compat_glProgramUniform4i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4i(program, location, v0, v1, v2, v3); +} + +void gl4_3compat_glProgramUniform3uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3uiv(program, location, count, value); +} + +void gl4_3compat_glProgramUniform3ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3ui(program, location, v0, v1, v2); +} + +void gl4_3compat_glProgramUniform3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3dv(program, location, count, value); +} + +void gl4_3compat_glProgramUniform3d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3d(program, location, v0, v1, v2); +} + +void gl4_3compat_glProgramUniform3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3fv(program, location, count, value); +} + +void gl4_3compat_glProgramUniform3f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3f(program, location, v0, v1, v2); +} + +void gl4_3compat_glProgramUniform3iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3iv(program, location, count, value); +} + +void gl4_3compat_glProgramUniform3i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1, GLint v2) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3i(program, location, v0, v1, v2); +} + +void gl4_3compat_glProgramUniform2uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2uiv(program, location, count, value); +} + +void gl4_3compat_glProgramUniform2ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2ui(program, location, v0, v1); +} + +void gl4_3compat_glProgramUniform2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2dv(program, location, count, value); +} + +void gl4_3compat_glProgramUniform2d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2d(program, location, v0, v1); +} + +void gl4_3compat_glProgramUniform2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2fv(program, location, count, value); +} + +void gl4_3compat_glProgramUniform2f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2f(program, location, v0, v1); +} + +void gl4_3compat_glProgramUniform2iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2iv(program, location, count, value); +} + +void gl4_3compat_glProgramUniform2i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2i(program, location, v0, v1); +} + +void gl4_3compat_glProgramUniform1uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1uiv(program, location, count, value); +} + +void gl4_3compat_glProgramUniform1ui(void *_glfuncs, GLuint program, GLint location, GLuint v0) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1ui(program, location, v0); +} + +void gl4_3compat_glProgramUniform1dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1dv(program, location, count, value); +} + +void gl4_3compat_glProgramUniform1d(void *_glfuncs, GLuint program, GLint location, GLdouble v0) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1d(program, location, v0); +} + +void gl4_3compat_glProgramUniform1fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1fv(program, location, count, value); +} + +void gl4_3compat_glProgramUniform1f(void *_glfuncs, GLuint program, GLint location, GLfloat v0) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1f(program, location, v0); +} + +void gl4_3compat_glProgramUniform1iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1iv(program, location, count, value); +} + +void gl4_3compat_glProgramUniform1i(void *_glfuncs, GLuint program, GLint location, GLint v0) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1i(program, location, v0); +} + +void gl4_3compat_glGetProgramPipelineiv(void *_glfuncs, GLuint pipeline, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramPipelineiv(pipeline, pname, params); +} + +GLboolean gl4_3compat_glIsProgramPipeline(void *_glfuncs, GLuint pipeline) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsProgramPipeline(pipeline); +} + +void gl4_3compat_glGenProgramPipelines(void *_glfuncs, GLsizei n, GLuint* pipelines) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenProgramPipelines(n, pipelines); +} + +void gl4_3compat_glDeleteProgramPipelines(void *_glfuncs, GLsizei n, const GLuint* pipelines) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteProgramPipelines(n, pipelines); +} + +void gl4_3compat_glBindProgramPipeline(void *_glfuncs, GLuint pipeline) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindProgramPipeline(pipeline); +} + +void gl4_3compat_glActiveShaderProgram(void *_glfuncs, GLuint pipeline, GLuint program) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glActiveShaderProgram(pipeline, program); +} + +void gl4_3compat_glUseProgramStages(void *_glfuncs, GLuint pipeline, GLbitfield stages, GLuint program) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUseProgramStages(pipeline, stages, program); +} + +void gl4_3compat_glProgramParameteri(void *_glfuncs, GLuint program, GLenum pname, GLint value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramParameteri(program, pname, value); +} + +void gl4_3compat_glProgramBinary(void *_glfuncs, GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramBinary(program, binaryFormat, binary, length); +} + +void gl4_3compat_glGetProgramBinary(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramBinary(program, bufSize, length, binaryFormat, binary); +} + +void gl4_3compat_glClearDepthf(void *_glfuncs, GLfloat dd) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearDepthf(dd); +} + +void gl4_3compat_glDepthRangef(void *_glfuncs, GLfloat n, GLfloat f) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRangef(n, f); +} + +void gl4_3compat_glGetShaderPrecisionFormat(void *_glfuncs, GLenum shadertype, GLenum precisionType, GLint* range_, GLint* precision) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderPrecisionFormat(shadertype, precisionType, range_, precision); +} + +void gl4_3compat_glShaderBinary(void *_glfuncs, GLsizei count, const GLuint* shaders, GLenum binaryFormat, const GLvoid* binary, GLsizei length) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShaderBinary(count, shaders, binaryFormat, binary, length); +} + +void gl4_3compat_glReleaseShaderCompiler(void *_glfuncs) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReleaseShaderCompiler(); +} + +void gl4_3compat_glTexStorage3D(void *_glfuncs, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexStorage3D(target, levels, internalFormat, width, height, depth); +} + +void gl4_3compat_glTexStorage2D(void *_glfuncs, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexStorage2D(target, levels, internalFormat, width, height); +} + +void gl4_3compat_glTexStorage1D(void *_glfuncs, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexStorage1D(target, levels, internalFormat, width); +} + +void gl4_3compat_glMemoryBarrier(void *_glfuncs, GLbitfield barriers) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMemoryBarrier(barriers); +} + +void gl4_3compat_glBindImageTexture(void *_glfuncs, GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindImageTexture(unit, texture, level, layered, layer, access, format); +} + +void gl4_3compat_glGetActiveAtomicCounterBufferiv(void *_glfuncs, GLuint program, GLuint bufferIndex, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params); +} + +void gl4_3compat_glGetInternalformativ(void *_glfuncs, GLenum target, GLenum internalFormat, GLenum pname, GLsizei bufSize, GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetInternalformativ(target, internalFormat, pname, bufSize, params); +} + +void gl4_3compat_glDrawTransformFeedbackStreamInstanced(void *_glfuncs, GLenum mode, GLuint id, GLuint stream, GLsizei instancecount) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount); +} + +void gl4_3compat_glDrawTransformFeedbackInstanced(void *_glfuncs, GLenum mode, GLuint id, GLsizei instancecount) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawTransformFeedbackInstanced(mode, id, instancecount); +} + +void gl4_3compat_glDrawElementsInstancedBaseVertexBaseInstance(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsInstancedBaseVertexBaseInstance(mode, count, gltype, indices, instancecount, basevertex, baseinstance); +} + +void gl4_3compat_glDrawElementsInstancedBaseInstance(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLuint baseinstance) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsInstancedBaseInstance(mode, count, gltype, indices, instancecount, baseinstance); +} + +void gl4_3compat_glDrawArraysInstancedBaseInstance(void *_glfuncs, GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance); +} + +void gl4_3compat_glTexStorage3DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexStorage3DMultisample(target, samples, internalFormat, width, height, depth, fixedsamplelocations); +} + +void gl4_3compat_glTexStorage2DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexStorage2DMultisample(target, samples, internalFormat, width, height, fixedsamplelocations); +} + +void gl4_3compat_glTexBufferRange(void *_glfuncs, GLenum target, GLenum internalFormat, GLuint buffer, GLintptr offset, GLsizeiptr size) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexBufferRange(target, internalFormat, buffer, offset, size); +} + +void gl4_3compat_glShaderStorageBlockBinding(void *_glfuncs, GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding); +} + +GLint gl4_3compat_glGetProgramResourceLocationIndex(void *_glfuncs, GLuint program, GLenum programInterface, const GLchar* name) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetProgramResourceLocationIndex(program, programInterface, name); +} + +GLint gl4_3compat_glGetProgramResourceLocation(void *_glfuncs, GLuint program, GLenum programInterface, const GLchar* name) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetProgramResourceLocation(program, programInterface, name); +} + +void gl4_3compat_glGetProgramResourceiv(void *_glfuncs, GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum* props, GLsizei bufSize, GLsizei* length, GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params); +} + +void gl4_3compat_glGetProgramResourceName(void *_glfuncs, GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramResourceName(program, programInterface, index, bufSize, length, name); +} + +GLuint gl4_3compat_glGetProgramResourceIndex(void *_glfuncs, GLuint program, GLenum programInterface, const GLchar* name) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetProgramResourceIndex(program, programInterface, name); +} + +void gl4_3compat_glGetProgramInterfaceiv(void *_glfuncs, GLuint program, GLenum programInterface, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramInterfaceiv(program, programInterface, pname, params); +} + +void gl4_3compat_glMultiDrawElementsIndirect(void *_glfuncs, GLenum mode, GLenum gltype, const GLvoid* indirect, GLsizei drawcount, GLsizei stride) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiDrawElementsIndirect(mode, gltype, indirect, drawcount, stride); +} + +void gl4_3compat_glMultiDrawArraysIndirect(void *_glfuncs, GLenum mode, const GLvoid* indirect, GLsizei drawcount, GLsizei stride) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiDrawArraysIndirect(mode, indirect, drawcount, stride); +} + +void gl4_3compat_glInvalidateSubFramebuffer(void *_glfuncs, GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height); +} + +void gl4_3compat_glInvalidateFramebuffer(void *_glfuncs, GLenum target, GLsizei numAttachments, const GLenum* attachments) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInvalidateFramebuffer(target, numAttachments, attachments); +} + +void gl4_3compat_glInvalidateBufferData(void *_glfuncs, GLuint buffer) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInvalidateBufferData(buffer); +} + +void gl4_3compat_glInvalidateBufferSubData(void *_glfuncs, GLuint buffer, GLintptr offset, GLsizeiptr length) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInvalidateBufferSubData(buffer, offset, length); +} + +void gl4_3compat_glInvalidateTexImage(void *_glfuncs, GLuint texture, GLint level) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInvalidateTexImage(texture, level); +} + +void gl4_3compat_glInvalidateTexSubImage(void *_glfuncs, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth); +} + +void gl4_3compat_glGetInternalformati64v(void *_glfuncs, GLenum target, GLenum internalFormat, GLenum pname, GLsizei bufSize, GLint64* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetInternalformati64v(target, internalFormat, pname, bufSize, params); +} + +void gl4_3compat_glGetFramebufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFramebufferParameteriv(target, pname, params); +} + +void gl4_3compat_glFramebufferParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferParameteri(target, pname, param); +} + +void gl4_3compat_glVertexBindingDivisor(void *_glfuncs, GLuint bindingindex, GLuint divisor) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexBindingDivisor(bindingindex, divisor); +} + +void gl4_3compat_glVertexAttribBinding(void *_glfuncs, GLuint attribindex, GLuint bindingindex) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribBinding(attribindex, bindingindex); +} + +void gl4_3compat_glVertexAttribLFormat(void *_glfuncs, GLuint attribindex, GLint size, GLenum gltype, GLuint relativeoffset) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribLFormat(attribindex, size, gltype, relativeoffset); +} + +void gl4_3compat_glVertexAttribIFormat(void *_glfuncs, GLuint attribindex, GLint size, GLenum gltype, GLuint relativeoffset) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribIFormat(attribindex, size, gltype, relativeoffset); +} + +void gl4_3compat_glVertexAttribFormat(void *_glfuncs, GLuint attribindex, GLint size, GLenum gltype, GLboolean normalized, GLuint relativeoffset) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribFormat(attribindex, size, gltype, normalized, relativeoffset); +} + +void gl4_3compat_glBindVertexBuffer(void *_glfuncs, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindVertexBuffer(bindingindex, buffer, offset, stride); +} + +void gl4_3compat_glTextureView(void *_glfuncs, GLuint texture, GLenum target, GLuint origtexture, GLenum internalFormat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTextureView(texture, target, origtexture, internalFormat, minlevel, numlevels, minlayer, numlayers); +} + +void gl4_3compat_glCopyImageSubData(void *_glfuncs, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth); +} + +void gl4_3compat_glDispatchComputeIndirect(void *_glfuncs, GLintptr indirect) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDispatchComputeIndirect(indirect); +} + +void gl4_3compat_glDispatchCompute(void *_glfuncs, GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDispatchCompute(num_groups_x, num_groups_y, num_groups_z); +} + +void gl4_3compat_glClearBufferSubData(void *_glfuncs, GLenum target, GLenum internalFormat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum gltype, const GLvoid* data) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferSubData(target, internalFormat, offset, size, format, gltype, data); +} + +void gl4_3compat_glClearBufferData(void *_glfuncs, GLenum target, GLenum internalFormat, GLenum format, GLenum gltype, const GLvoid* data) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferData(target, internalFormat, format, gltype, data); +} + +void gl4_3compat_glTranslatef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTranslatef(x, y, z); +} + +void gl4_3compat_glTranslated(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTranslated(x, y, z); +} + +void gl4_3compat_glScalef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScalef(x, y, z); +} + +void gl4_3compat_glScaled(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScaled(x, y, z); +} + +void gl4_3compat_glRotatef(void *_glfuncs, GLfloat angle, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRotatef(angle, x, y, z); +} + +void gl4_3compat_glRotated(void *_glfuncs, GLdouble angle, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRotated(angle, x, y, z); +} + +void gl4_3compat_glPushMatrix(void *_glfuncs) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushMatrix(); +} + +void gl4_3compat_glPopMatrix(void *_glfuncs) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopMatrix(); +} + +void gl4_3compat_glOrtho(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glOrtho(left, right, bottom, top, zNear, zFar); +} + +void gl4_3compat_glMultMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultMatrixd(m); +} + +void gl4_3compat_glMultMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultMatrixf(m); +} + +void gl4_3compat_glMatrixMode(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMatrixMode(mode); +} + +void gl4_3compat_glLoadMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadMatrixd(m); +} + +void gl4_3compat_glLoadMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadMatrixf(m); +} + +void gl4_3compat_glLoadIdentity(void *_glfuncs) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadIdentity(); +} + +void gl4_3compat_glFrustum(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrustum(left, right, bottom, top, zNear, zFar); +} + +GLboolean gl4_3compat_glIsList(void *_glfuncs, GLuint list) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsList(list); +} + +void gl4_3compat_glGetTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGeniv(coord, pname, params); +} + +void gl4_3compat_glGetTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGenfv(coord, pname, params); +} + +void gl4_3compat_glGetTexGendv(void *_glfuncs, GLenum coord, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexGendv(coord, pname, params); +} + +void gl4_3compat_glGetTexEnviv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexEnviv(target, pname, params); +} + +void gl4_3compat_glGetTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexEnvfv(target, pname, params); +} + +void gl4_3compat_glGetPolygonStipple(void *_glfuncs, GLubyte* mask) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPolygonStipple(mask); +} + +void gl4_3compat_glGetPixelMapusv(void *_glfuncs, GLenum glmap, GLushort* values) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapusv(glmap, values); +} + +void gl4_3compat_glGetPixelMapuiv(void *_glfuncs, GLenum glmap, GLuint* values) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapuiv(glmap, values); +} + +void gl4_3compat_glGetPixelMapfv(void *_glfuncs, GLenum glmap, GLfloat* values) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetPixelMapfv(glmap, values); +} + +void gl4_3compat_glGetMaterialiv(void *_glfuncs, GLenum face, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMaterialiv(face, pname, params); +} + +void gl4_3compat_glGetMaterialfv(void *_glfuncs, GLenum face, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMaterialfv(face, pname, params); +} + +void gl4_3compat_glGetMapiv(void *_glfuncs, GLenum target, GLenum query, GLint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapiv(target, query, v); +} + +void gl4_3compat_glGetMapfv(void *_glfuncs, GLenum target, GLenum query, GLfloat* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapfv(target, query, v); +} + +void gl4_3compat_glGetMapdv(void *_glfuncs, GLenum target, GLenum query, GLdouble* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMapdv(target, query, v); +} + +void gl4_3compat_glGetLightiv(void *_glfuncs, GLenum light, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetLightiv(light, pname, params); +} + +void gl4_3compat_glGetLightfv(void *_glfuncs, GLenum light, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetLightfv(light, pname, params); +} + +void gl4_3compat_glGetClipPlane(void *_glfuncs, GLenum plane, GLdouble* equation) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetClipPlane(plane, equation); +} + +void gl4_3compat_glDrawPixels(void *_glfuncs, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawPixels(width, height, format, gltype, pixels); +} + +void gl4_3compat_glCopyPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum gltype) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyPixels(x, y, width, height, gltype); +} + +void gl4_3compat_glPixelMapusv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLushort* values) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapusv(glmap, mapsize, values); +} + +void gl4_3compat_glPixelMapuiv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLuint* values) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapuiv(glmap, mapsize, values); +} + +void gl4_3compat_glPixelMapfv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLfloat* values) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelMapfv(glmap, mapsize, values); +} + +void gl4_3compat_glPixelTransferi(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelTransferi(pname, param); +} + +void gl4_3compat_glPixelTransferf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelTransferf(pname, param); +} + +void gl4_3compat_glPixelZoom(void *_glfuncs, GLfloat xfactor, GLfloat yfactor) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelZoom(xfactor, yfactor); +} + +void gl4_3compat_glAlphaFunc(void *_glfuncs, GLenum glfunc, GLfloat ref) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAlphaFunc(glfunc, ref); +} + +void gl4_3compat_glEvalPoint2(void *_glfuncs, GLint i, GLint j) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalPoint2(i, j); +} + +void gl4_3compat_glEvalMesh2(void *_glfuncs, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalMesh2(mode, i1, i2, j1, j2); +} + +void gl4_3compat_glEvalPoint1(void *_glfuncs, GLint i) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalPoint1(i); +} + +void gl4_3compat_glEvalMesh1(void *_glfuncs, GLenum mode, GLint i1, GLint i2) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalMesh1(mode, i1, i2); +} + +void gl4_3compat_glEvalCoord2fv(void *_glfuncs, const GLfloat* u) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2fv(u); +} + +void gl4_3compat_glEvalCoord2f(void *_glfuncs, GLfloat u, GLfloat v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2f(u, v); +} + +void gl4_3compat_glEvalCoord2dv(void *_glfuncs, const GLdouble* u) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2dv(u); +} + +void gl4_3compat_glEvalCoord2d(void *_glfuncs, GLdouble u, GLdouble v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord2d(u, v); +} + +void gl4_3compat_glEvalCoord1fv(void *_glfuncs, const GLfloat* u) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1fv(u); +} + +void gl4_3compat_glEvalCoord1f(void *_glfuncs, GLfloat u) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1f(u); +} + +void gl4_3compat_glEvalCoord1dv(void *_glfuncs, const GLdouble* u) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1dv(u); +} + +void gl4_3compat_glEvalCoord1d(void *_glfuncs, GLdouble u) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEvalCoord1d(u); +} + +void gl4_3compat_glMapGrid2f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid2f(un, u1, u2, vn, v1, v2); +} + +void gl4_3compat_glMapGrid2d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid2d(un, u1, u2, vn, v1, v2); +} + +void gl4_3compat_glMapGrid1f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid1f(un, u1, u2); +} + +void gl4_3compat_glMapGrid1d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMapGrid1d(un, u1, u2); +} + +void gl4_3compat_glMap2f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); +} + +void gl4_3compat_glMap2d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); +} + +void gl4_3compat_glMap1f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap1f(target, u1, u2, stride, order, points); +} + +void gl4_3compat_glMap1d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMap1d(target, u1, u2, stride, order, points); +} + +void gl4_3compat_glPushAttrib(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushAttrib(mask); +} + +void gl4_3compat_glPopAttrib(void *_glfuncs) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopAttrib(); +} + +void gl4_3compat_glAccum(void *_glfuncs, GLenum op, GLfloat value) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAccum(op, value); +} + +void gl4_3compat_glIndexMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexMask(mask); +} + +void gl4_3compat_glClearIndex(void *_glfuncs, GLfloat c) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearIndex(c); +} + +void gl4_3compat_glClearAccum(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearAccum(red, green, blue, alpha); +} + +void gl4_3compat_glPushName(void *_glfuncs, GLuint name) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushName(name); +} + +void gl4_3compat_glPopName(void *_glfuncs) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopName(); +} + +void gl4_3compat_glPassThrough(void *_glfuncs, GLfloat token) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPassThrough(token); +} + +void gl4_3compat_glLoadName(void *_glfuncs, GLuint name) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadName(name); +} + +void gl4_3compat_glInitNames(void *_glfuncs) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInitNames(); +} + +GLint gl4_3compat_glRenderMode(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glRenderMode(mode); +} + +void gl4_3compat_glSelectBuffer(void *_glfuncs, GLsizei size, GLuint* buffer) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSelectBuffer(size, buffer); +} + +void gl4_3compat_glFeedbackBuffer(void *_glfuncs, GLsizei size, GLenum gltype, GLfloat* buffer) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFeedbackBuffer(size, gltype, buffer); +} + +void gl4_3compat_glTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGeniv(coord, pname, params); +} + +void gl4_3compat_glTexGeni(void *_glfuncs, GLenum coord, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGeni(coord, pname, param); +} + +void gl4_3compat_glTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGenfv(coord, pname, params); +} + +void gl4_3compat_glTexGenf(void *_glfuncs, GLenum coord, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGenf(coord, pname, param); +} + +void gl4_3compat_glTexGendv(void *_glfuncs, GLenum coord, GLenum pname, const GLdouble* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGendv(coord, pname, params); +} + +void gl4_3compat_glTexGend(void *_glfuncs, GLenum coord, GLenum pname, GLdouble param) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexGend(coord, pname, param); +} + +void gl4_3compat_glTexEnviv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnviv(target, pname, params); +} + +void gl4_3compat_glTexEnvi(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvi(target, pname, param); +} + +void gl4_3compat_glTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvfv(target, pname, params); +} + +void gl4_3compat_glTexEnvf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexEnvf(target, pname, param); +} + +void gl4_3compat_glShadeModel(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShadeModel(mode); +} + +void gl4_3compat_glPolygonStipple(void *_glfuncs, const GLubyte* mask) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonStipple(mask); +} + +void gl4_3compat_glMaterialiv(void *_glfuncs, GLenum face, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialiv(face, pname, params); +} + +void gl4_3compat_glMateriali(void *_glfuncs, GLenum face, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMateriali(face, pname, param); +} + +void gl4_3compat_glMaterialfv(void *_glfuncs, GLenum face, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialfv(face, pname, params); +} + +void gl4_3compat_glMaterialf(void *_glfuncs, GLenum face, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMaterialf(face, pname, param); +} + +void gl4_3compat_glLineStipple(void *_glfuncs, GLint factor, GLushort pattern) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineStipple(factor, pattern); +} + +void gl4_3compat_glLightModeliv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModeliv(pname, params); +} + +void gl4_3compat_glLightModeli(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModeli(pname, param); +} + +void gl4_3compat_glLightModelfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModelfv(pname, params); +} + +void gl4_3compat_glLightModelf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightModelf(pname, param); +} + +void gl4_3compat_glLightiv(void *_glfuncs, GLenum light, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightiv(light, pname, params); +} + +void gl4_3compat_glLighti(void *_glfuncs, GLenum light, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLighti(light, pname, param); +} + +void gl4_3compat_glLightfv(void *_glfuncs, GLenum light, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightfv(light, pname, params); +} + +void gl4_3compat_glLightf(void *_glfuncs, GLenum light, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLightf(light, pname, param); +} + +void gl4_3compat_glFogiv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogiv(pname, params); +} + +void gl4_3compat_glFogi(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogi(pname, param); +} + +void gl4_3compat_glFogfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogfv(pname, params); +} + +void gl4_3compat_glFogf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogf(pname, param); +} + +void gl4_3compat_glColorMaterial(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMaterial(face, mode); +} + +void gl4_3compat_glClipPlane(void *_glfuncs, GLenum plane, const GLdouble* equation) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClipPlane(plane, equation); +} + +void gl4_3compat_glVertex4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4sv(v); +} + +void gl4_3compat_glVertex4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4s(x, y, z, w); +} + +void gl4_3compat_glVertex4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4iv(v); +} + +void gl4_3compat_glVertex4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4i(x, y, z, w); +} + +void gl4_3compat_glVertex4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4fv(v); +} + +void gl4_3compat_glVertex4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4f(x, y, z, w); +} + +void gl4_3compat_glVertex4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4dv(v); +} + +void gl4_3compat_glVertex4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex4d(x, y, z, w); +} + +void gl4_3compat_glVertex3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3sv(v); +} + +void gl4_3compat_glVertex3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3s(x, y, z); +} + +void gl4_3compat_glVertex3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3iv(v); +} + +void gl4_3compat_glVertex3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3i(x, y, z); +} + +void gl4_3compat_glVertex3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3fv(v); +} + +void gl4_3compat_glVertex3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3f(x, y, z); +} + +void gl4_3compat_glVertex3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3dv(v); +} + +void gl4_3compat_glVertex3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex3d(x, y, z); +} + +void gl4_3compat_glVertex2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2sv(v); +} + +void gl4_3compat_glVertex2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2s(x, y); +} + +void gl4_3compat_glVertex2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2iv(v); +} + +void gl4_3compat_glVertex2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2i(x, y); +} + +void gl4_3compat_glVertex2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2fv(v); +} + +void gl4_3compat_glVertex2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2f(x, y); +} + +void gl4_3compat_glVertex2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2dv(v); +} + +void gl4_3compat_glVertex2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertex2d(x, y); +} + +void gl4_3compat_glTexCoord4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4sv(v); +} + +void gl4_3compat_glTexCoord4s(void *_glfuncs, GLshort s, GLshort t, GLshort r, GLshort q) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4s(s, t, r, q); +} + +void gl4_3compat_glTexCoord4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4iv(v); +} + +void gl4_3compat_glTexCoord4i(void *_glfuncs, GLint s, GLint t, GLint r, GLint q) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4i(s, t, r, q); +} + +void gl4_3compat_glTexCoord4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4fv(v); +} + +void gl4_3compat_glTexCoord4f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4f(s, t, r, q); +} + +void gl4_3compat_glTexCoord4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4dv(v); +} + +void gl4_3compat_glTexCoord4d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r, GLdouble q) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord4d(s, t, r, q); +} + +void gl4_3compat_glTexCoord3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3sv(v); +} + +void gl4_3compat_glTexCoord3s(void *_glfuncs, GLshort s, GLshort t, GLshort r) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3s(s, t, r); +} + +void gl4_3compat_glTexCoord3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3iv(v); +} + +void gl4_3compat_glTexCoord3i(void *_glfuncs, GLint s, GLint t, GLint r) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3i(s, t, r); +} + +void gl4_3compat_glTexCoord3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3fv(v); +} + +void gl4_3compat_glTexCoord3f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3f(s, t, r); +} + +void gl4_3compat_glTexCoord3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3dv(v); +} + +void gl4_3compat_glTexCoord3d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord3d(s, t, r); +} + +void gl4_3compat_glTexCoord2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2sv(v); +} + +void gl4_3compat_glTexCoord2s(void *_glfuncs, GLshort s, GLshort t) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2s(s, t); +} + +void gl4_3compat_glTexCoord2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2iv(v); +} + +void gl4_3compat_glTexCoord2i(void *_glfuncs, GLint s, GLint t) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2i(s, t); +} + +void gl4_3compat_glTexCoord2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2fv(v); +} + +void gl4_3compat_glTexCoord2f(void *_glfuncs, GLfloat s, GLfloat t) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2f(s, t); +} + +void gl4_3compat_glTexCoord2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2dv(v); +} + +void gl4_3compat_glTexCoord2d(void *_glfuncs, GLdouble s, GLdouble t) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord2d(s, t); +} + +void gl4_3compat_glTexCoord1sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1sv(v); +} + +void gl4_3compat_glTexCoord1s(void *_glfuncs, GLshort s) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1s(s); +} + +void gl4_3compat_glTexCoord1iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1iv(v); +} + +void gl4_3compat_glTexCoord1i(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1i(s); +} + +void gl4_3compat_glTexCoord1fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1fv(v); +} + +void gl4_3compat_glTexCoord1f(void *_glfuncs, GLfloat s) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1f(s); +} + +void gl4_3compat_glTexCoord1dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1dv(v); +} + +void gl4_3compat_glTexCoord1d(void *_glfuncs, GLdouble s) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoord1d(s); +} + +void gl4_3compat_glRectsv(void *_glfuncs, const GLshort* v1, const GLshort* v2) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectsv(v1, v2); +} + +void gl4_3compat_glRects(void *_glfuncs, GLshort x1, GLshort y1, GLshort x2, GLshort y2) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRects(x1, y1, x2, y2); +} + +void gl4_3compat_glRectiv(void *_glfuncs, const GLint* v1, const GLint* v2) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectiv(v1, v2); +} + +void gl4_3compat_glRecti(void *_glfuncs, GLint x1, GLint y1, GLint x2, GLint y2) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRecti(x1, y1, x2, y2); +} + +void gl4_3compat_glRectfv(void *_glfuncs, const GLfloat* v1, const GLfloat* v2) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectfv(v1, v2); +} + +void gl4_3compat_glRectf(void *_glfuncs, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectf(x1, y1, x2, y2); +} + +void gl4_3compat_glRectdv(void *_glfuncs, const GLdouble* v1, const GLdouble* v2) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectdv(v1, v2); +} + +void gl4_3compat_glRectd(void *_glfuncs, GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRectd(x1, y1, x2, y2); +} + +void gl4_3compat_glRasterPos4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4sv(v); +} + +void gl4_3compat_glRasterPos4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4s(x, y, z, w); +} + +void gl4_3compat_glRasterPos4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4iv(v); +} + +void gl4_3compat_glRasterPos4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4i(x, y, z, w); +} + +void gl4_3compat_glRasterPos4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4fv(v); +} + +void gl4_3compat_glRasterPos4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4f(x, y, z, w); +} + +void gl4_3compat_glRasterPos4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4dv(v); +} + +void gl4_3compat_glRasterPos4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos4d(x, y, z, w); +} + +void gl4_3compat_glRasterPos3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3sv(v); +} + +void gl4_3compat_glRasterPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3s(x, y, z); +} + +void gl4_3compat_glRasterPos3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3iv(v); +} + +void gl4_3compat_glRasterPos3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3i(x, y, z); +} + +void gl4_3compat_glRasterPos3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3fv(v); +} + +void gl4_3compat_glRasterPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3f(x, y, z); +} + +void gl4_3compat_glRasterPos3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3dv(v); +} + +void gl4_3compat_glRasterPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos3d(x, y, z); +} + +void gl4_3compat_glRasterPos2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2sv(v); +} + +void gl4_3compat_glRasterPos2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2s(x, y); +} + +void gl4_3compat_glRasterPos2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2iv(v); +} + +void gl4_3compat_glRasterPos2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2i(x, y); +} + +void gl4_3compat_glRasterPos2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2fv(v); +} + +void gl4_3compat_glRasterPos2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2f(x, y); +} + +void gl4_3compat_glRasterPos2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2dv(v); +} + +void gl4_3compat_glRasterPos2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRasterPos2d(x, y); +} + +void gl4_3compat_glNormal3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3sv(v); +} + +void gl4_3compat_glNormal3s(void *_glfuncs, GLshort nx, GLshort ny, GLshort nz) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3s(nx, ny, nz); +} + +void gl4_3compat_glNormal3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3iv(v); +} + +void gl4_3compat_glNormal3i(void *_glfuncs, GLint nx, GLint ny, GLint nz) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3i(nx, ny, nz); +} + +void gl4_3compat_glNormal3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3fv(v); +} + +void gl4_3compat_glNormal3f(void *_glfuncs, GLfloat nx, GLfloat ny, GLfloat nz) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3f(nx, ny, nz); +} + +void gl4_3compat_glNormal3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3dv(v); +} + +void gl4_3compat_glNormal3d(void *_glfuncs, GLdouble nx, GLdouble ny, GLdouble nz) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3d(nx, ny, nz); +} + +void gl4_3compat_glNormal3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3bv(v); +} + +void gl4_3compat_glNormal3b(void *_glfuncs, GLbyte nx, GLbyte ny, GLbyte nz) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormal3b(nx, ny, nz); +} + +void gl4_3compat_glIndexsv(void *_glfuncs, const GLshort* c) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexsv(c); +} + +void gl4_3compat_glIndexs(void *_glfuncs, GLshort c) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexs(c); +} + +void gl4_3compat_glIndexiv(void *_glfuncs, const GLint* c) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexiv(c); +} + +void gl4_3compat_glIndexi(void *_glfuncs, GLint c) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexi(c); +} + +void gl4_3compat_glIndexfv(void *_glfuncs, const GLfloat* c) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexfv(c); +} + +void gl4_3compat_glIndexf(void *_glfuncs, GLfloat c) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexf(c); +} + +void gl4_3compat_glIndexdv(void *_glfuncs, const GLdouble* c) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexdv(c); +} + +void gl4_3compat_glIndexd(void *_glfuncs, GLdouble c) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexd(c); +} + +void gl4_3compat_glEnd(void *_glfuncs) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnd(); +} + +void gl4_3compat_glEdgeFlagv(void *_glfuncs, const GLboolean* flag) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlagv(flag); +} + +void gl4_3compat_glEdgeFlag(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlag(flag); +} + +void gl4_3compat_glColor4usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4usv(v); +} + +void gl4_3compat_glColor4us(void *_glfuncs, GLushort red, GLushort green, GLushort blue, GLushort alpha) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4us(red, green, blue, alpha); +} + +void gl4_3compat_glColor4uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4uiv(v); +} + +void gl4_3compat_glColor4ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue, GLuint alpha) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ui(red, green, blue, alpha); +} + +void gl4_3compat_glColor4ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ubv(v); +} + +void gl4_3compat_glColor4ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4ub(red, green, blue, alpha); +} + +void gl4_3compat_glColor4sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4sv(v); +} + +void gl4_3compat_glColor4s(void *_glfuncs, GLshort red, GLshort green, GLshort blue, GLshort alpha) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4s(red, green, blue, alpha); +} + +void gl4_3compat_glColor4iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4iv(v); +} + +void gl4_3compat_glColor4i(void *_glfuncs, GLint red, GLint green, GLint blue, GLint alpha) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4i(red, green, blue, alpha); +} + +void gl4_3compat_glColor4fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4fv(v); +} + +void gl4_3compat_glColor4f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4f(red, green, blue, alpha); +} + +void gl4_3compat_glColor4dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4dv(v); +} + +void gl4_3compat_glColor4d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4d(red, green, blue, alpha); +} + +void gl4_3compat_glColor4bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4bv(v); +} + +void gl4_3compat_glColor4b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor4b(red, green, blue, alpha); +} + +void gl4_3compat_glColor3usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3usv(v); +} + +void gl4_3compat_glColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3us(red, green, blue); +} + +void gl4_3compat_glColor3uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3uiv(v); +} + +void gl4_3compat_glColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ui(red, green, blue); +} + +void gl4_3compat_glColor3ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ubv(v); +} + +void gl4_3compat_glColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3ub(red, green, blue); +} + +void gl4_3compat_glColor3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3sv(v); +} + +void gl4_3compat_glColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3s(red, green, blue); +} + +void gl4_3compat_glColor3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3iv(v); +} + +void gl4_3compat_glColor3i(void *_glfuncs, GLint red, GLint green, GLint blue) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3i(red, green, blue); +} + +void gl4_3compat_glColor3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3fv(v); +} + +void gl4_3compat_glColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3f(red, green, blue); +} + +void gl4_3compat_glColor3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3dv(v); +} + +void gl4_3compat_glColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3d(red, green, blue); +} + +void gl4_3compat_glColor3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3bv(v); +} + +void gl4_3compat_glColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColor3b(red, green, blue); +} + +void gl4_3compat_glBitmap(void *_glfuncs, GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBitmap(width, height, xorig, yorig, xmove, ymove, bitmap); +} + +void gl4_3compat_glBegin(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBegin(mode); +} + +void gl4_3compat_glListBase(void *_glfuncs, GLuint base) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glListBase(base); +} + +GLuint gl4_3compat_glGenLists(void *_glfuncs, GLsizei range_) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGenLists(range_); +} + +void gl4_3compat_glDeleteLists(void *_glfuncs, GLuint list, GLsizei range_) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteLists(list, range_); +} + +void gl4_3compat_glCallLists(void *_glfuncs, GLsizei n, GLenum gltype, const GLvoid* lists) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCallLists(n, gltype, lists); +} + +void gl4_3compat_glCallList(void *_glfuncs, GLuint list) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCallList(list); +} + +void gl4_3compat_glEndList(void *_glfuncs) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndList(); +} + +void gl4_3compat_glNewList(void *_glfuncs, GLuint list, GLenum mode) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNewList(list, mode); +} + +void gl4_3compat_glPushClientAttrib(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPushClientAttrib(mask); +} + +void gl4_3compat_glPopClientAttrib(void *_glfuncs) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPopClientAttrib(); +} + +void gl4_3compat_glPrioritizeTextures(void *_glfuncs, GLsizei n, const GLuint* textures, const GLfloat* priorities) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPrioritizeTextures(n, textures, priorities); +} + +GLboolean gl4_3compat_glAreTexturesResident(void *_glfuncs, GLsizei n, const GLuint* textures, GLboolean* residences) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glAreTexturesResident(n, textures, residences); +} + +void gl4_3compat_glVertexPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexPointer(size, gltype, stride, pointer); +} + +void gl4_3compat_glTexCoordPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordPointer(size, gltype, stride, pointer); +} + +void gl4_3compat_glNormalPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormalPointer(gltype, stride, pointer); +} + +void gl4_3compat_glInterleavedArrays(void *_glfuncs, GLenum format, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInterleavedArrays(format, stride, pointer); +} + +void gl4_3compat_glIndexPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexPointer(gltype, stride, pointer); +} + +void gl4_3compat_glEnableClientState(void *_glfuncs, GLenum array) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnableClientState(array); +} + +void gl4_3compat_glEdgeFlagPointer(void *_glfuncs, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEdgeFlagPointer(stride, pointer); +} + +void gl4_3compat_glDisableClientState(void *_glfuncs, GLenum array) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisableClientState(array); +} + +void gl4_3compat_glColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorPointer(size, gltype, stride, pointer); +} + +void gl4_3compat_glArrayElement(void *_glfuncs, GLint i) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glArrayElement(i); +} + +void gl4_3compat_glResetMinmax(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glResetMinmax(target); +} + +void gl4_3compat_glResetHistogram(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glResetHistogram(target); +} + +void gl4_3compat_glMinmax(void *_glfuncs, GLenum target, GLenum internalFormat, GLboolean sink) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMinmax(target, internalFormat, sink); +} + +void gl4_3compat_glHistogram(void *_glfuncs, GLenum target, GLsizei width, GLenum internalFormat, GLboolean sink) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glHistogram(target, width, internalFormat, sink); +} + +void gl4_3compat_glGetMinmaxParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmaxParameteriv(target, pname, params); +} + +void gl4_3compat_glGetMinmaxParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmaxParameterfv(target, pname, params); +} + +void gl4_3compat_glGetMinmax(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMinmax(target, reset, format, gltype, values); +} + +void gl4_3compat_glGetHistogramParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogramParameteriv(target, pname, params); +} + +void gl4_3compat_glGetHistogramParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogramParameterfv(target, pname, params); +} + +void gl4_3compat_glGetHistogram(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetHistogram(target, reset, format, gltype, values); +} + +void gl4_3compat_glSeparableFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* row, const GLvoid* column) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSeparableFilter2D(target, internalFormat, width, height, format, gltype, row, column); +} + +void gl4_3compat_glGetSeparableFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* row, GLvoid* column, GLvoid* span) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSeparableFilter(target, format, gltype, row, column, span); +} + +void gl4_3compat_glGetConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionParameteriv(target, pname, params); +} + +void gl4_3compat_glGetConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionParameterfv(target, pname, params); +} + +void gl4_3compat_glGetConvolutionFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* image) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetConvolutionFilter(target, format, gltype, image); +} + +void gl4_3compat_glCopyConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyConvolutionFilter2D(target, internalFormat, x, y, width, height); +} + +void gl4_3compat_glCopyConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyConvolutionFilter1D(target, internalFormat, x, y, width); +} + +void gl4_3compat_glConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameteriv(target, pname, params); +} + +void gl4_3compat_glConvolutionParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameteri(target, pname, params); +} + +void gl4_3compat_glConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameterfv(target, pname, params); +} + +void gl4_3compat_glConvolutionParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionParameterf(target, pname, params); +} + +void gl4_3compat_glConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* image) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionFilter2D(target, internalFormat, width, height, format, gltype, image); +} + +void gl4_3compat_glConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* image) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glConvolutionFilter1D(target, internalFormat, width, format, gltype, image); +} + +void gl4_3compat_glCopyColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyColorSubTable(target, start, x, y, width); +} + +void gl4_3compat_glColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum gltype, const GLvoid* data) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorSubTable(target, start, count, format, gltype, data); +} + +void gl4_3compat_glGetColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTableParameteriv(target, pname, params); +} + +void gl4_3compat_glGetColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTableParameterfv(target, pname, params); +} + +void gl4_3compat_glGetColorTable(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* table) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetColorTable(target, format, gltype, table); +} + +void gl4_3compat_glCopyColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyColorTable(target, internalFormat, x, y, width); +} + +void gl4_3compat_glColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTableParameteriv(target, pname, params); +} + +void gl4_3compat_glColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTableParameterfv(target, pname, params); +} + +void gl4_3compat_glColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* table) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorTable(target, internalFormat, width, format, gltype, table); +} + +void gl4_3compat_glMultTransposeMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultTransposeMatrixd(m); +} + +void gl4_3compat_glMultTransposeMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultTransposeMatrixf(m); +} + +void gl4_3compat_glLoadTransposeMatrixd(void *_glfuncs, const GLdouble* m) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadTransposeMatrixd(m); +} + +void gl4_3compat_glLoadTransposeMatrixf(void *_glfuncs, const GLfloat* m) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLoadTransposeMatrixf(m); +} + +void gl4_3compat_glMultiTexCoord4sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4sv(target, v); +} + +void gl4_3compat_glMultiTexCoord4s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r, GLshort q) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4s(target, s, t, r, q); +} + +void gl4_3compat_glMultiTexCoord4iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4iv(target, v); +} + +void gl4_3compat_glMultiTexCoord4i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r, GLint q) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4i(target, s, t, r, q); +} + +void gl4_3compat_glMultiTexCoord4fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4fv(target, v); +} + +void gl4_3compat_glMultiTexCoord4f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4f(target, s, t, r, q); +} + +void gl4_3compat_glMultiTexCoord4dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4dv(target, v); +} + +void gl4_3compat_glMultiTexCoord4d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord4d(target, s, t, r, q); +} + +void gl4_3compat_glMultiTexCoord3sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3sv(target, v); +} + +void gl4_3compat_glMultiTexCoord3s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3s(target, s, t, r); +} + +void gl4_3compat_glMultiTexCoord3iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3iv(target, v); +} + +void gl4_3compat_glMultiTexCoord3i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3i(target, s, t, r); +} + +void gl4_3compat_glMultiTexCoord3fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3fv(target, v); +} + +void gl4_3compat_glMultiTexCoord3f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3f(target, s, t, r); +} + +void gl4_3compat_glMultiTexCoord3dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3dv(target, v); +} + +void gl4_3compat_glMultiTexCoord3d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord3d(target, s, t, r); +} + +void gl4_3compat_glMultiTexCoord2sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2sv(target, v); +} + +void gl4_3compat_glMultiTexCoord2s(void *_glfuncs, GLenum target, GLshort s, GLshort t) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2s(target, s, t); +} + +void gl4_3compat_glMultiTexCoord2iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2iv(target, v); +} + +void gl4_3compat_glMultiTexCoord2i(void *_glfuncs, GLenum target, GLint s, GLint t) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2i(target, s, t); +} + +void gl4_3compat_glMultiTexCoord2fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2fv(target, v); +} + +void gl4_3compat_glMultiTexCoord2f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2f(target, s, t); +} + +void gl4_3compat_glMultiTexCoord2dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2dv(target, v); +} + +void gl4_3compat_glMultiTexCoord2d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord2d(target, s, t); +} + +void gl4_3compat_glMultiTexCoord1sv(void *_glfuncs, GLenum target, const GLshort* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1sv(target, v); +} + +void gl4_3compat_glMultiTexCoord1s(void *_glfuncs, GLenum target, GLshort s) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1s(target, s); +} + +void gl4_3compat_glMultiTexCoord1iv(void *_glfuncs, GLenum target, const GLint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1iv(target, v); +} + +void gl4_3compat_glMultiTexCoord1i(void *_glfuncs, GLenum target, GLint s) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1i(target, s); +} + +void gl4_3compat_glMultiTexCoord1fv(void *_glfuncs, GLenum target, const GLfloat* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1fv(target, v); +} + +void gl4_3compat_glMultiTexCoord1f(void *_glfuncs, GLenum target, GLfloat s) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1f(target, s); +} + +void gl4_3compat_glMultiTexCoord1dv(void *_glfuncs, GLenum target, const GLdouble* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1dv(target, v); +} + +void gl4_3compat_glMultiTexCoord1d(void *_glfuncs, GLenum target, GLdouble s) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoord1d(target, s); +} + +void gl4_3compat_glClientActiveTexture(void *_glfuncs, GLenum texture) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClientActiveTexture(texture); +} + +void gl4_3compat_glWindowPos3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3sv(v); +} + +void gl4_3compat_glWindowPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3s(x, y, z); +} + +void gl4_3compat_glWindowPos3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3iv(v); +} + +void gl4_3compat_glWindowPos3i(void *_glfuncs, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3i(x, y, z); +} + +void gl4_3compat_glWindowPos3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3fv(v); +} + +void gl4_3compat_glWindowPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3f(x, y, z); +} + +void gl4_3compat_glWindowPos3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3dv(v); +} + +void gl4_3compat_glWindowPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos3d(x, y, z); +} + +void gl4_3compat_glWindowPos2sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2sv(v); +} + +void gl4_3compat_glWindowPos2s(void *_glfuncs, GLshort x, GLshort y) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2s(x, y); +} + +void gl4_3compat_glWindowPos2iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2iv(v); +} + +void gl4_3compat_glWindowPos2i(void *_glfuncs, GLint x, GLint y) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2i(x, y); +} + +void gl4_3compat_glWindowPos2fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2fv(v); +} + +void gl4_3compat_glWindowPos2f(void *_glfuncs, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2f(x, y); +} + +void gl4_3compat_glWindowPos2dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2dv(v); +} + +void gl4_3compat_glWindowPos2d(void *_glfuncs, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWindowPos2d(x, y); +} + +void gl4_3compat_glSecondaryColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColorPointer(size, gltype, stride, pointer); +} + +void gl4_3compat_glSecondaryColor3usv(void *_glfuncs, const GLushort* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3usv(v); +} + +void gl4_3compat_glSecondaryColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3us(red, green, blue); +} + +void gl4_3compat_glSecondaryColor3uiv(void *_glfuncs, const GLuint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3uiv(v); +} + +void gl4_3compat_glSecondaryColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3ui(red, green, blue); +} + +void gl4_3compat_glSecondaryColor3ubv(void *_glfuncs, const GLubyte* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3ubv(v); +} + +void gl4_3compat_glSecondaryColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3ub(red, green, blue); +} + +void gl4_3compat_glSecondaryColor3sv(void *_glfuncs, const GLshort* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3sv(v); +} + +void gl4_3compat_glSecondaryColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3s(red, green, blue); +} + +void gl4_3compat_glSecondaryColor3iv(void *_glfuncs, const GLint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3iv(v); +} + +void gl4_3compat_glSecondaryColor3i(void *_glfuncs, GLint red, GLint green, GLint blue) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3i(red, green, blue); +} + +void gl4_3compat_glSecondaryColor3fv(void *_glfuncs, const GLfloat* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3fv(v); +} + +void gl4_3compat_glSecondaryColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3f(red, green, blue); +} + +void gl4_3compat_glSecondaryColor3dv(void *_glfuncs, const GLdouble* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3dv(v); +} + +void gl4_3compat_glSecondaryColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3d(red, green, blue); +} + +void gl4_3compat_glSecondaryColor3bv(void *_glfuncs, const GLbyte* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3bv(v); +} + +void gl4_3compat_glSecondaryColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColor3b(red, green, blue); +} + +void gl4_3compat_glFogCoordPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordPointer(gltype, stride, pointer); +} + +void gl4_3compat_glFogCoorddv(void *_glfuncs, const GLdouble* coord) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoorddv(coord); +} + +void gl4_3compat_glFogCoordd(void *_glfuncs, GLdouble coord) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordd(coord); +} + +void gl4_3compat_glFogCoordfv(void *_glfuncs, const GLfloat* coord) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordfv(coord); +} + +void gl4_3compat_glFogCoordf(void *_glfuncs, GLfloat coord) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFogCoordf(coord); +} + +void gl4_3compat_glVertexAttrib4usv(void *_glfuncs, GLuint index, const GLushort* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4usv(index, v); +} + +void gl4_3compat_glVertexAttrib4uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4uiv(index, v); +} + +void gl4_3compat_glVertexAttrib4ubv(void *_glfuncs, GLuint index, const GLubyte* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4ubv(index, v); +} + +void gl4_3compat_glVertexAttrib4sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4sv(index, v); +} + +void gl4_3compat_glVertexAttrib4s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4s(index, x, y, z, w); +} + +void gl4_3compat_glVertexAttrib4iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4iv(index, v); +} + +void gl4_3compat_glVertexAttrib4fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4fv(index, v); +} + +void gl4_3compat_glVertexAttrib4f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4f(index, x, y, z, w); +} + +void gl4_3compat_glVertexAttrib4dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4dv(index, v); +} + +void gl4_3compat_glVertexAttrib4d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4d(index, x, y, z, w); +} + +void gl4_3compat_glVertexAttrib4bv(void *_glfuncs, GLuint index, const GLbyte* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4bv(index, v); +} + +void gl4_3compat_glVertexAttrib4Nusv(void *_glfuncs, GLuint index, const GLushort* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nusv(index, v); +} + +void gl4_3compat_glVertexAttrib4Nuiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nuiv(index, v); +} + +void gl4_3compat_glVertexAttrib4Nubv(void *_glfuncs, GLuint index, const GLubyte* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nubv(index, v); +} + +void gl4_3compat_glVertexAttrib4Nub(void *_glfuncs, GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nub(index, x, y, z, w); +} + +void gl4_3compat_glVertexAttrib4Nsv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nsv(index, v); +} + +void gl4_3compat_glVertexAttrib4Niv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Niv(index, v); +} + +void gl4_3compat_glVertexAttrib4Nbv(void *_glfuncs, GLuint index, const GLbyte* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4Nbv(index, v); +} + +void gl4_3compat_glVertexAttrib3sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3sv(index, v); +} + +void gl4_3compat_glVertexAttrib3s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3s(index, x, y, z); +} + +void gl4_3compat_glVertexAttrib3fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3fv(index, v); +} + +void gl4_3compat_glVertexAttrib3f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3f(index, x, y, z); +} + +void gl4_3compat_glVertexAttrib3dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3dv(index, v); +} + +void gl4_3compat_glVertexAttrib3d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3d(index, x, y, z); +} + +void gl4_3compat_glVertexAttrib2sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2sv(index, v); +} + +void gl4_3compat_glVertexAttrib2s(void *_glfuncs, GLuint index, GLshort x, GLshort y) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2s(index, x, y); +} + +void gl4_3compat_glVertexAttrib2fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2fv(index, v); +} + +void gl4_3compat_glVertexAttrib2f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2f(index, x, y); +} + +void gl4_3compat_glVertexAttrib2dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2dv(index, v); +} + +void gl4_3compat_glVertexAttrib2d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2d(index, x, y); +} + +void gl4_3compat_glVertexAttrib1sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1sv(index, v); +} + +void gl4_3compat_glVertexAttrib1s(void *_glfuncs, GLuint index, GLshort x) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1s(index, x); +} + +void gl4_3compat_glVertexAttrib1fv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1fv(index, v); +} + +void gl4_3compat_glVertexAttrib1f(void *_glfuncs, GLuint index, GLfloat x) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1f(index, x); +} + +void gl4_3compat_glVertexAttrib1dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1dv(index, v); +} + +void gl4_3compat_glVertexAttrib1d(void *_glfuncs, GLuint index, GLdouble x) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1d(index, x); +} + +void gl4_3compat_glVertexAttribI4usv(void *_glfuncs, GLuint index, const GLushort* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4usv(index, v); +} + +void gl4_3compat_glVertexAttribI4ubv(void *_glfuncs, GLuint index, const GLubyte* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4ubv(index, v); +} + +void gl4_3compat_glVertexAttribI4sv(void *_glfuncs, GLuint index, const GLshort* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4sv(index, v); +} + +void gl4_3compat_glVertexAttribI4bv(void *_glfuncs, GLuint index, const GLbyte* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4bv(index, v); +} + +void gl4_3compat_glVertexAttribI4uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4uiv(index, v); +} + +void gl4_3compat_glVertexAttribI3uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI3uiv(index, v); +} + +void gl4_3compat_glVertexAttribI2uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI2uiv(index, v); +} + +void gl4_3compat_glVertexAttribI1uiv(void *_glfuncs, GLuint index, const GLuint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI1uiv(index, v); +} + +void gl4_3compat_glVertexAttribI4iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4iv(index, v); +} + +void gl4_3compat_glVertexAttribI3iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI3iv(index, v); +} + +void gl4_3compat_glVertexAttribI2iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI2iv(index, v); +} + +void gl4_3compat_glVertexAttribI1iv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI1iv(index, v); +} + +void gl4_3compat_glVertexAttribI4ui(void *_glfuncs, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4ui(index, x, y, z, w); +} + +void gl4_3compat_glVertexAttribI3ui(void *_glfuncs, GLuint index, GLuint x, GLuint y, GLuint z) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI3ui(index, x, y, z); +} + +void gl4_3compat_glVertexAttribI2ui(void *_glfuncs, GLuint index, GLuint x, GLuint y) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI2ui(index, x, y); +} + +void gl4_3compat_glVertexAttribI1ui(void *_glfuncs, GLuint index, GLuint x) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI1ui(index, x); +} + +void gl4_3compat_glVertexAttribI4i(void *_glfuncs, GLuint index, GLint x, GLint y, GLint z, GLint w) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI4i(index, x, y, z, w); +} + +void gl4_3compat_glVertexAttribI3i(void *_glfuncs, GLuint index, GLint x, GLint y, GLint z) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI3i(index, x, y, z); +} + +void gl4_3compat_glVertexAttribI2i(void *_glfuncs, GLuint index, GLint x, GLint y) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI2i(index, x, y); +} + +void gl4_3compat_glVertexAttribI1i(void *_glfuncs, GLuint index, GLint x) +{ + QOpenGLFunctions_4_3_Compatibility* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribI1i(index, x); +} + diff --git a/gl/4.3compat/funcs.h b/gl/4.3compat/funcs.h new file mode 100644 index 00000000..ef3dac79 --- /dev/null +++ b/gl/4.3compat/funcs.h @@ -0,0 +1,965 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#ifndef __cplusplus +#include +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef char GLchar; +typedef signed char GLbyte; /* 1-byte signed */ +typedef short GLshort; /* 2-byte signed */ +typedef int GLint; /* 4-byte signed */ +typedef unsigned char GLubyte; /* 1-byte unsigned */ +typedef unsigned short GLushort; /* 2-byte unsigned */ +typedef unsigned int GLuint; /* 4-byte unsigned */ +typedef int GLsizei; /* 4-byte signed */ +typedef float GLfloat; /* single precision float */ +typedef float GLclampf; /* single precision float in [0,1] */ +typedef double GLdouble; /* double precision float */ +typedef double GLclampd; /* double precision float in [0,1] */ +typedef int64_t GLint64; +typedef uint64_t GLuint64; +typedef ptrdiff_t GLintptr; +typedef ptrdiff_t GLsizeiptr; +typedef ptrdiff_t GLintptrARB; +typedef ptrdiff_t GLsizeiptrARB; +typedef struct __GLsync *GLsync; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +void *gl4_3compat_funcs(); + +void gl4_3compat_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_3compat_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal); +GLboolean gl4_3compat_glIsEnabled(void *_glfuncs, GLenum cap); +void gl4_3compat_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params); +void gl4_3compat_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params); +void gl4_3compat_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_3compat_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl4_3compat_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels); +void gl4_3compat_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params); +void gl4_3compat_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params); +GLenum gl4_3compat_glGetError(void *_glfuncs); +void gl4_3compat_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params); +void gl4_3compat_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params); +void gl4_3compat_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels); +void gl4_3compat_glReadBuffer(void *_glfuncs, GLenum mode); +void gl4_3compat_glPixelStorei(void *_glfuncs, GLenum pname, GLint param); +void gl4_3compat_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param); +void gl4_3compat_glDepthFunc(void *_glfuncs, GLenum glfunc); +void gl4_3compat_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass); +void gl4_3compat_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask); +void gl4_3compat_glLogicOp(void *_glfuncs, GLenum opcode); +void gl4_3compat_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor); +void gl4_3compat_glFlush(void *_glfuncs); +void gl4_3compat_glFinish(void *_glfuncs); +void gl4_3compat_glEnable(void *_glfuncs, GLenum cap); +void gl4_3compat_glDisable(void *_glfuncs, GLenum cap); +void gl4_3compat_glDepthMask(void *_glfuncs, GLboolean flag); +void gl4_3compat_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +void gl4_3compat_glStencilMask(void *_glfuncs, GLuint mask); +void gl4_3compat_glClearDepth(void *_glfuncs, GLdouble depth); +void gl4_3compat_glClearStencil(void *_glfuncs, GLint s); +void gl4_3compat_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl4_3compat_glClear(void *_glfuncs, GLbitfield mask); +void gl4_3compat_glDrawBuffer(void *_glfuncs, GLenum mode); +void gl4_3compat_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_3compat_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_3compat_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl4_3compat_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl4_3compat_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl4_3compat_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl4_3compat_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_3compat_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode); +void gl4_3compat_glPointSize(void *_glfuncs, GLfloat size); +void gl4_3compat_glLineWidth(void *_glfuncs, GLfloat width); +void gl4_3compat_glHint(void *_glfuncs, GLenum target, GLenum mode); +void gl4_3compat_glFrontFace(void *_glfuncs, GLenum mode); +void gl4_3compat_glCullFace(void *_glfuncs, GLenum mode); +void gl4_3compat_glIndexubv(void *_glfuncs, const GLubyte* c); +void gl4_3compat_glIndexub(void *_glfuncs, GLubyte c); +GLboolean gl4_3compat_glIsTexture(void *_glfuncs, GLuint texture); +void gl4_3compat_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures); +void gl4_3compat_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures); +void gl4_3compat_glBindTexture(void *_glfuncs, GLenum target, GLuint texture); +void gl4_3compat_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_3compat_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_3compat_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_3compat_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +void gl4_3compat_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +void gl4_3compat_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border); +void gl4_3compat_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units); +void gl4_3compat_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl4_3compat_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count); +void gl4_3compat_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_3compat_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_3compat_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_3compat_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl4_3compat_glBlendEquation(void *_glfuncs, GLenum mode); +void gl4_3compat_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl4_3compat_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img); +void gl4_3compat_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl4_3compat_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl4_3compat_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl4_3compat_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data); +void gl4_3compat_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data); +void gl4_3compat_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data); +void gl4_3compat_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert); +void gl4_3compat_glActiveTexture(void *_glfuncs, GLenum texture); +void gl4_3compat_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params); +void gl4_3compat_glPointParameteri(void *_glfuncs, GLenum pname, GLint param); +void gl4_3compat_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl4_3compat_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param); +void gl4_3compat_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount); +void gl4_3compat_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +void gl4_3compat_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +GLboolean gl4_3compat_glUnmapBuffer(void *_glfuncs, GLenum target); +void gl4_3compat_glGetBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data); +void gl4_3compat_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data); +void gl4_3compat_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage); +GLboolean gl4_3compat_glIsBuffer(void *_glfuncs, GLuint buffer); +void gl4_3compat_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers); +void gl4_3compat_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers); +void gl4_3compat_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer); +void gl4_3compat_glGetQueryObjectuiv(void *_glfuncs, GLuint id, GLenum pname, GLuint* params); +void gl4_3compat_glGetQueryObjectiv(void *_glfuncs, GLuint id, GLenum pname, GLint* params); +void gl4_3compat_glGetQueryiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_3compat_glEndQuery(void *_glfuncs, GLenum target); +void gl4_3compat_glBeginQuery(void *_glfuncs, GLenum target, GLuint id); +GLboolean gl4_3compat_glIsQuery(void *_glfuncs, GLuint id); +void gl4_3compat_glDeleteQueries(void *_glfuncs, GLsizei n, const GLuint* ids); +void gl4_3compat_glGenQueries(void *_glfuncs, GLsizei n, GLuint* ids); +void gl4_3compat_glVertexAttribPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLboolean normalized, GLsizei stride, const GLvoid* offset); +void gl4_3compat_glValidateProgram(void *_glfuncs, GLuint program); +void gl4_3compat_glUniformMatrix4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_3compat_glUniformMatrix3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_3compat_glUniformMatrix2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_3compat_glUniform4iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl4_3compat_glUniform3iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl4_3compat_glUniform2iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl4_3compat_glUniform1iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl4_3compat_glUniform4fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl4_3compat_glUniform3fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl4_3compat_glUniform2fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl4_3compat_glUniform1fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl4_3compat_glUniform4i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +void gl4_3compat_glUniform3i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2); +void gl4_3compat_glUniform2i(void *_glfuncs, GLint location, GLint v0, GLint v1); +void gl4_3compat_glUniform1i(void *_glfuncs, GLint location, GLint v0); +void gl4_3compat_glUniform4f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +void gl4_3compat_glUniform3f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +void gl4_3compat_glUniform2f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1); +void gl4_3compat_glUniform1f(void *_glfuncs, GLint location, GLfloat v0); +void gl4_3compat_glUseProgram(void *_glfuncs, GLuint program); +void gl4_3compat_glShaderSource(void *_glfuncs, GLuint shader, GLsizei count, const GLchar** source, const GLint* length); +void gl4_3compat_glLinkProgram(void *_glfuncs, GLuint program); +GLboolean gl4_3compat_glIsShader(void *_glfuncs, GLuint shader); +GLboolean gl4_3compat_glIsProgram(void *_glfuncs, GLuint program); +void gl4_3compat_glGetVertexAttribiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params); +void gl4_3compat_glGetVertexAttribfv(void *_glfuncs, GLuint index, GLenum pname, GLfloat* params); +void gl4_3compat_glGetVertexAttribdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params); +void gl4_3compat_glGetUniformiv(void *_glfuncs, GLuint program, GLint location, GLint* params); +void gl4_3compat_glGetUniformfv(void *_glfuncs, GLuint program, GLint location, GLfloat* params); +GLint gl4_3compat_glGetUniformLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl4_3compat_glGetShaderSource(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source); +void gl4_3compat_glGetShaderInfoLog(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl4_3compat_glGetShaderiv(void *_glfuncs, GLuint shader, GLenum pname, GLint* params); +void gl4_3compat_glGetProgramInfoLog(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl4_3compat_glGetProgramiv(void *_glfuncs, GLuint program, GLenum pname, GLint* params); +GLint gl4_3compat_glGetAttribLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl4_3compat_glGetAttachedShaders(void *_glfuncs, GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj); +void gl4_3compat_glGetActiveUniform(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name); +void gl4_3compat_glGetActiveAttrib(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name); +void gl4_3compat_glEnableVertexAttribArray(void *_glfuncs, GLuint index); +void gl4_3compat_glDisableVertexAttribArray(void *_glfuncs, GLuint index); +void gl4_3compat_glDetachShader(void *_glfuncs, GLuint program, GLuint shader); +void gl4_3compat_glDeleteShader(void *_glfuncs, GLuint shader); +void gl4_3compat_glDeleteProgram(void *_glfuncs, GLuint program); +GLuint gl4_3compat_glCreateShader(void *_glfuncs, GLenum gltype); +GLuint gl4_3compat_glCreateProgram(void *_glfuncs); +void gl4_3compat_glCompileShader(void *_glfuncs, GLuint shader); +void gl4_3compat_glBindAttribLocation(void *_glfuncs, GLuint program, GLuint index, const GLchar* name); +void gl4_3compat_glAttachShader(void *_glfuncs, GLuint program, GLuint shader); +void gl4_3compat_glStencilMaskSeparate(void *_glfuncs, GLenum face, GLuint mask); +void gl4_3compat_glStencilFuncSeparate(void *_glfuncs, GLenum face, GLenum glfunc, GLint ref, GLuint mask); +void gl4_3compat_glStencilOpSeparate(void *_glfuncs, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +void gl4_3compat_glDrawBuffers(void *_glfuncs, GLsizei n, const GLenum* bufs); +void gl4_3compat_glBlendEquationSeparate(void *_glfuncs, GLenum modeRGB, GLenum modeAlpha); +void gl4_3compat_glUniformMatrix4x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_3compat_glUniformMatrix3x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_3compat_glUniformMatrix4x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_3compat_glUniformMatrix2x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_3compat_glUniformMatrix3x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_3compat_glUniformMatrix2x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +GLboolean gl4_3compat_glIsVertexArray(void *_glfuncs, GLuint array); +void gl4_3compat_glGenVertexArrays(void *_glfuncs, GLsizei n, GLuint* arrays); +void gl4_3compat_glDeleteVertexArrays(void *_glfuncs, GLsizei n, const GLuint* arrays); +void gl4_3compat_glBindVertexArray(void *_glfuncs, GLuint array); +void gl4_3compat_glFlushMappedBufferRange(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr length); +void gl4_3compat_glFramebufferTextureLayer(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +void gl4_3compat_glRenderbufferStorageMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height); +void gl4_3compat_glBlitFramebuffer(void *_glfuncs, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +void gl4_3compat_glGenerateMipmap(void *_glfuncs, GLenum target); +void gl4_3compat_glGetFramebufferAttachmentParameteriv(void *_glfuncs, GLenum target, GLenum attachment, GLenum pname, GLint* params); +void gl4_3compat_glFramebufferRenderbuffer(void *_glfuncs, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +void gl4_3compat_glFramebufferTexture3D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +void gl4_3compat_glFramebufferTexture2D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +void gl4_3compat_glFramebufferTexture1D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLenum gl4_3compat_glCheckFramebufferStatus(void *_glfuncs, GLenum target); +void gl4_3compat_glGenFramebuffers(void *_glfuncs, GLsizei n, GLuint* framebuffers); +void gl4_3compat_glDeleteFramebuffers(void *_glfuncs, GLsizei n, const GLuint* framebuffers); +void gl4_3compat_glBindFramebuffer(void *_glfuncs, GLenum target, GLuint framebuffer); +GLboolean gl4_3compat_glIsFramebuffer(void *_glfuncs, GLuint framebuffer); +void gl4_3compat_glGetRenderbufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_3compat_glRenderbufferStorage(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height); +void gl4_3compat_glGenRenderbuffers(void *_glfuncs, GLsizei n, GLuint* renderbuffers); +void gl4_3compat_glDeleteRenderbuffers(void *_glfuncs, GLsizei n, const GLuint* renderbuffers); +void gl4_3compat_glBindRenderbuffer(void *_glfuncs, GLenum target, GLuint renderbuffer); +GLboolean gl4_3compat_glIsRenderbuffer(void *_glfuncs, GLuint renderbuffer); +void gl4_3compat_glClearBufferfi(void *_glfuncs, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); +void gl4_3compat_glClearBufferfv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLfloat* value); +void gl4_3compat_glClearBufferuiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLuint* value); +void gl4_3compat_glClearBufferiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLint* value); +void gl4_3compat_glGetTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, GLuint* params); +void gl4_3compat_glGetTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_3compat_glTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, const GLuint* params); +void gl4_3compat_glTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl4_3compat_glUniform4uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl4_3compat_glUniform3uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl4_3compat_glUniform2uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl4_3compat_glUniform1uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl4_3compat_glUniform4ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +void gl4_3compat_glUniform3ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2); +void gl4_3compat_glUniform2ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1); +void gl4_3compat_glUniform1ui(void *_glfuncs, GLint location, GLuint v0); +GLint gl4_3compat_glGetFragDataLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl4_3compat_glBindFragDataLocation(void *_glfuncs, GLuint program, GLuint color, const GLchar* name); +void gl4_3compat_glGetUniformuiv(void *_glfuncs, GLuint program, GLint location, GLuint* params); +void gl4_3compat_glGetVertexAttribIuiv(void *_glfuncs, GLuint index, GLenum pname, GLuint* params); +void gl4_3compat_glGetVertexAttribIiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params); +void gl4_3compat_glVertexAttribIPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_3compat_glEndConditionalRender(void *_glfuncs); +void gl4_3compat_glBeginConditionalRender(void *_glfuncs, GLuint id, GLenum mode); +void gl4_3compat_glClampColor(void *_glfuncs, GLenum target, GLenum clamp); +void gl4_3compat_glGetTransformFeedbackVarying(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* gltype, GLchar* name); +void gl4_3compat_glBindBufferBase(void *_glfuncs, GLenum target, GLuint index, GLuint buffer); +void gl4_3compat_glBindBufferRange(void *_glfuncs, GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +void gl4_3compat_glEndTransformFeedback(void *_glfuncs); +void gl4_3compat_glBeginTransformFeedback(void *_glfuncs, GLenum primitiveMode); +GLboolean gl4_3compat_glIsEnabledi(void *_glfuncs, GLenum target, GLuint index); +void gl4_3compat_glDisablei(void *_glfuncs, GLenum target, GLuint index); +void gl4_3compat_glEnablei(void *_glfuncs, GLenum target, GLuint index); +void gl4_3compat_glGetIntegeri_v(void *_glfuncs, GLenum target, GLuint index, GLint* data); +void gl4_3compat_glGetBooleani_v(void *_glfuncs, GLenum target, GLuint index, GLboolean* data); +void gl4_3compat_glColorMaski(void *_glfuncs, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +void gl4_3compat_glCopyBufferSubData(void *_glfuncs, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +void gl4_3compat_glUniformBlockBinding(void *_glfuncs, GLuint program, GLuint v0, GLuint v1); +void gl4_3compat_glGetActiveUniformBlockName(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName); +void gl4_3compat_glGetActiveUniformBlockiv(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params); +GLuint gl4_3compat_glGetUniformBlockIndex(void *_glfuncs, GLuint program, const GLchar* uniformBlockName); +void gl4_3compat_glGetActiveUniformName(void *_glfuncs, GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName); +void gl4_3compat_glGetActiveUniformsiv(void *_glfuncs, GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params); +void gl4_3compat_glPrimitiveRestartIndex(void *_glfuncs, GLuint index); +void gl4_3compat_glTexBuffer(void *_glfuncs, GLenum target, GLenum internalFormat, GLuint buffer); +void gl4_3compat_glDrawElementsInstanced(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount); +void gl4_3compat_glDrawArraysInstanced(void *_glfuncs, GLenum mode, GLint first, GLsizei count, GLsizei instancecount); +void gl4_3compat_glSampleMaski(void *_glfuncs, GLuint index, GLbitfield mask); +void gl4_3compat_glGetMultisamplefv(void *_glfuncs, GLenum pname, GLuint index, GLfloat* val); +void gl4_3compat_glTexImage3DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); +void gl4_3compat_glTexImage2DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +void gl4_3compat_glGetSynciv(void *_glfuncs, GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values); +void gl4_3compat_glGetInteger64v(void *_glfuncs, GLenum pname, GLint64* params); +void gl4_3compat_glWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout); +GLenum gl4_3compat_glClientWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout); +void gl4_3compat_glDeleteSync(void *_glfuncs, GLsync sync); +GLboolean gl4_3compat_glIsSync(void *_glfuncs, GLsync sync); +GLsync gl4_3compat_glFenceSync(void *_glfuncs, GLenum condition, GLbitfield flags); +void gl4_3compat_glProvokingVertex(void *_glfuncs, GLenum mode); +void gl4_3compat_glDrawElementsInstancedBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLint basevertex); +void gl4_3compat_glDrawRangeElementsBaseVertex(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex); +void gl4_3compat_glDrawElementsBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex); +void gl4_3compat_glFramebufferTexture(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level); +void gl4_3compat_glGetBufferParameteri64v(void *_glfuncs, GLenum target, GLenum pname, GLint64* params); +void gl4_3compat_glGetInteger64i_v(void *_glfuncs, GLenum target, GLuint index, GLint64* data); +void gl4_3compat_glVertexAttribP4uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl4_3compat_glVertexAttribP4ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl4_3compat_glVertexAttribP3uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl4_3compat_glVertexAttribP3ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl4_3compat_glVertexAttribP2uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl4_3compat_glVertexAttribP2ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl4_3compat_glVertexAttribP1uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl4_3compat_glVertexAttribP1ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl4_3compat_glSecondaryColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color); +void gl4_3compat_glSecondaryColorP3ui(void *_glfuncs, GLenum gltype, GLuint color); +void gl4_3compat_glColorP4uiv(void *_glfuncs, GLenum gltype, const GLuint* color); +void gl4_3compat_glColorP4ui(void *_glfuncs, GLenum gltype, GLuint color); +void gl4_3compat_glColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color); +void gl4_3compat_glColorP3ui(void *_glfuncs, GLenum gltype, GLuint color); +void gl4_3compat_glNormalP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_3compat_glNormalP3ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_3compat_glMultiTexCoordP4uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl4_3compat_glMultiTexCoordP4ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl4_3compat_glMultiTexCoordP3uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl4_3compat_glMultiTexCoordP3ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl4_3compat_glMultiTexCoordP2uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl4_3compat_glMultiTexCoordP2ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl4_3compat_glMultiTexCoordP1uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl4_3compat_glMultiTexCoordP1ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl4_3compat_glTexCoordP4uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_3compat_glTexCoordP4ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_3compat_glTexCoordP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_3compat_glTexCoordP3ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_3compat_glTexCoordP2uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_3compat_glTexCoordP2ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_3compat_glTexCoordP1uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_3compat_glTexCoordP1ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_3compat_glVertexP4uiv(void *_glfuncs, GLenum gltype, const GLuint* value); +void gl4_3compat_glVertexP4ui(void *_glfuncs, GLenum gltype, GLuint value); +void gl4_3compat_glVertexP3uiv(void *_glfuncs, GLenum gltype, const GLuint* value); +void gl4_3compat_glVertexP3ui(void *_glfuncs, GLenum gltype, GLuint value); +void gl4_3compat_glVertexP2uiv(void *_glfuncs, GLenum gltype, const GLuint* value); +void gl4_3compat_glVertexP2ui(void *_glfuncs, GLenum gltype, GLuint value); +void gl4_3compat_glGetQueryObjectui64v(void *_glfuncs, GLuint id, GLenum pname, GLuint64* params); +void gl4_3compat_glGetQueryObjecti64v(void *_glfuncs, GLuint id, GLenum pname, GLint64* params); +void gl4_3compat_glQueryCounter(void *_glfuncs, GLuint id, GLenum target); +void gl4_3compat_glGetSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, GLuint* params); +void gl4_3compat_glGetSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat* params); +void gl4_3compat_glGetSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params); +void gl4_3compat_glGetSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params); +void gl4_3compat_glSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLuint* param); +void gl4_3compat_glSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param); +void gl4_3compat_glSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, const GLfloat* param); +void gl4_3compat_glSamplerParameterf(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat param); +void gl4_3compat_glSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param); +void gl4_3compat_glSamplerParameteri(void *_glfuncs, GLuint sampler, GLenum pname, GLint param); +void gl4_3compat_glBindSampler(void *_glfuncs, GLuint unit, GLuint sampler); +GLboolean gl4_3compat_glIsSampler(void *_glfuncs, GLuint sampler); +void gl4_3compat_glDeleteSamplers(void *_glfuncs, GLsizei count, const GLuint* samplers); +void gl4_3compat_glGenSamplers(void *_glfuncs, GLsizei count, GLuint* samplers); +GLint gl4_3compat_glGetFragDataIndex(void *_glfuncs, GLuint program, const GLchar* name); +void gl4_3compat_glBindFragDataLocationIndexed(void *_glfuncs, GLuint program, GLuint colorNumber, GLuint index, const GLchar* name); +void gl4_3compat_glVertexAttribDivisor(void *_glfuncs, GLuint index, GLuint divisor); +void gl4_3compat_glGetQueryIndexediv(void *_glfuncs, GLenum target, GLuint index, GLenum pname, GLint* params); +void gl4_3compat_glEndQueryIndexed(void *_glfuncs, GLenum target, GLuint index); +void gl4_3compat_glBeginQueryIndexed(void *_glfuncs, GLenum target, GLuint index, GLuint id); +void gl4_3compat_glDrawTransformFeedbackStream(void *_glfuncs, GLenum mode, GLuint id, GLuint stream); +void gl4_3compat_glDrawTransformFeedback(void *_glfuncs, GLenum mode, GLuint id); +void gl4_3compat_glResumeTransformFeedback(void *_glfuncs); +void gl4_3compat_glPauseTransformFeedback(void *_glfuncs); +GLboolean gl4_3compat_glIsTransformFeedback(void *_glfuncs, GLuint id); +void gl4_3compat_glGenTransformFeedbacks(void *_glfuncs, GLsizei n, GLuint* ids); +void gl4_3compat_glDeleteTransformFeedbacks(void *_glfuncs, GLsizei n, const GLuint* ids); +void gl4_3compat_glBindTransformFeedback(void *_glfuncs, GLenum target, GLuint id); +void gl4_3compat_glPatchParameterfv(void *_glfuncs, GLenum pname, const GLfloat* values); +void gl4_3compat_glPatchParameteri(void *_glfuncs, GLenum pname, GLint value); +void gl4_3compat_glGetProgramStageiv(void *_glfuncs, GLuint program, GLenum shadertype, GLenum pname, GLint* values); +void gl4_3compat_glGetUniformSubroutineuiv(void *_glfuncs, GLenum shadertype, GLint location, GLuint* params); +void gl4_3compat_glUniformSubroutinesuiv(void *_glfuncs, GLenum shadertype, GLsizei count, const GLuint* value); +void gl4_3compat_glGetActiveSubroutineName(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name); +void gl4_3compat_glGetActiveSubroutineUniformName(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name); +void gl4_3compat_glGetActiveSubroutineUniformiv(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint* values); +GLuint gl4_3compat_glGetSubroutineIndex(void *_glfuncs, GLuint program, GLenum shadertype, const GLchar* name); +GLint gl4_3compat_glGetSubroutineUniformLocation(void *_glfuncs, GLuint program, GLenum shadertype, const GLchar* name); +void gl4_3compat_glGetUniformdv(void *_glfuncs, GLuint program, GLint location, GLdouble* params); +void gl4_3compat_glUniformMatrix4x3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3compat_glUniformMatrix4x2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3compat_glUniformMatrix3x4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3compat_glUniformMatrix3x2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3compat_glUniformMatrix2x4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3compat_glUniformMatrix2x3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3compat_glUniformMatrix4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3compat_glUniformMatrix3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3compat_glUniformMatrix2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3compat_glUniform4dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value); +void gl4_3compat_glUniform3dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value); +void gl4_3compat_glUniform2dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value); +void gl4_3compat_glUniform1dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value); +void gl4_3compat_glUniform4d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3); +void gl4_3compat_glUniform3d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1, GLdouble v2); +void gl4_3compat_glUniform2d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1); +void gl4_3compat_glUniform1d(void *_glfuncs, GLint location, GLdouble v0); +void gl4_3compat_glDrawElementsIndirect(void *_glfuncs, GLenum mode, GLenum gltype, const GLvoid* indirect); +void gl4_3compat_glDrawArraysIndirect(void *_glfuncs, GLenum mode, const GLvoid* indirect); +void gl4_3compat_glBlendFuncSeparatei(void *_glfuncs, GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); +void gl4_3compat_glBlendFunci(void *_glfuncs, GLuint buf, GLenum src, GLenum dst); +void gl4_3compat_glBlendEquationSeparatei(void *_glfuncs, GLuint buf, GLenum modeRGB, GLenum modeAlpha); +void gl4_3compat_glBlendEquationi(void *_glfuncs, GLuint buf, GLenum mode); +void gl4_3compat_glMinSampleShading(void *_glfuncs, GLfloat value); +void gl4_3compat_glGetDoublei_v(void *_glfuncs, GLenum target, GLuint index, GLdouble* data); +void gl4_3compat_glGetFloati_v(void *_glfuncs, GLenum target, GLuint index, GLfloat* data); +void gl4_3compat_glDepthRangeIndexed(void *_glfuncs, GLuint index, GLdouble n, GLdouble f); +void gl4_3compat_glDepthRangeArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLdouble* v); +void gl4_3compat_glScissorIndexedv(void *_glfuncs, GLuint index, const GLint* v); +void gl4_3compat_glScissorIndexed(void *_glfuncs, GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height); +void gl4_3compat_glScissorArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLint* v); +void gl4_3compat_glViewportIndexedfv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl4_3compat_glViewportIndexedf(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h); +void gl4_3compat_glViewportArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLfloat* v); +void gl4_3compat_glGetVertexAttribLdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params); +void gl4_3compat_glVertexAttribLPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_3compat_glVertexAttribL4dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_3compat_glVertexAttribL3dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_3compat_glVertexAttribL2dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_3compat_glVertexAttribL1dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_3compat_glVertexAttribL4d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl4_3compat_glVertexAttribL3d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z); +void gl4_3compat_glVertexAttribL2d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y); +void gl4_3compat_glVertexAttribL1d(void *_glfuncs, GLuint index, GLdouble x); +void gl4_3compat_glGetProgramPipelineInfoLog(void *_glfuncs, GLuint pipeline, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl4_3compat_glValidateProgramPipeline(void *_glfuncs, GLuint pipeline); +void gl4_3compat_glProgramUniformMatrix4x3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3compat_glProgramUniformMatrix3x4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3compat_glProgramUniformMatrix4x2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3compat_glProgramUniformMatrix2x4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3compat_glProgramUniformMatrix3x2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3compat_glProgramUniformMatrix2x3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3compat_glProgramUniformMatrix4x3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_3compat_glProgramUniformMatrix3x4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_3compat_glProgramUniformMatrix4x2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_3compat_glProgramUniformMatrix2x4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_3compat_glProgramUniformMatrix3x2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_3compat_glProgramUniformMatrix2x3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_3compat_glProgramUniformMatrix4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3compat_glProgramUniformMatrix3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3compat_glProgramUniformMatrix2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3compat_glProgramUniformMatrix4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_3compat_glProgramUniformMatrix3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_3compat_glProgramUniformMatrix2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_3compat_glProgramUniform4uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value); +void gl4_3compat_glProgramUniform4ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +void gl4_3compat_glProgramUniform4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value); +void gl4_3compat_glProgramUniform4d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3); +void gl4_3compat_glProgramUniform4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value); +void gl4_3compat_glProgramUniform4f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +void gl4_3compat_glProgramUniform4iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value); +void gl4_3compat_glProgramUniform4i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +void gl4_3compat_glProgramUniform3uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value); +void gl4_3compat_glProgramUniform3ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2); +void gl4_3compat_glProgramUniform3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value); +void gl4_3compat_glProgramUniform3d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2); +void gl4_3compat_glProgramUniform3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value); +void gl4_3compat_glProgramUniform3f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +void gl4_3compat_glProgramUniform3iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value); +void gl4_3compat_glProgramUniform3i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1, GLint v2); +void gl4_3compat_glProgramUniform2uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value); +void gl4_3compat_glProgramUniform2ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1); +void gl4_3compat_glProgramUniform2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value); +void gl4_3compat_glProgramUniform2d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1); +void gl4_3compat_glProgramUniform2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value); +void gl4_3compat_glProgramUniform2f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1); +void gl4_3compat_glProgramUniform2iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value); +void gl4_3compat_glProgramUniform2i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1); +void gl4_3compat_glProgramUniform1uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value); +void gl4_3compat_glProgramUniform1ui(void *_glfuncs, GLuint program, GLint location, GLuint v0); +void gl4_3compat_glProgramUniform1dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value); +void gl4_3compat_glProgramUniform1d(void *_glfuncs, GLuint program, GLint location, GLdouble v0); +void gl4_3compat_glProgramUniform1fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value); +void gl4_3compat_glProgramUniform1f(void *_glfuncs, GLuint program, GLint location, GLfloat v0); +void gl4_3compat_glProgramUniform1iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value); +void gl4_3compat_glProgramUniform1i(void *_glfuncs, GLuint program, GLint location, GLint v0); +void gl4_3compat_glGetProgramPipelineiv(void *_glfuncs, GLuint pipeline, GLenum pname, GLint* params); +GLboolean gl4_3compat_glIsProgramPipeline(void *_glfuncs, GLuint pipeline); +void gl4_3compat_glGenProgramPipelines(void *_glfuncs, GLsizei n, GLuint* pipelines); +void gl4_3compat_glDeleteProgramPipelines(void *_glfuncs, GLsizei n, const GLuint* pipelines); +void gl4_3compat_glBindProgramPipeline(void *_glfuncs, GLuint pipeline); +void gl4_3compat_glActiveShaderProgram(void *_glfuncs, GLuint pipeline, GLuint program); +void gl4_3compat_glUseProgramStages(void *_glfuncs, GLuint pipeline, GLbitfield stages, GLuint program); +void gl4_3compat_glProgramParameteri(void *_glfuncs, GLuint program, GLenum pname, GLint value); +void gl4_3compat_glProgramBinary(void *_glfuncs, GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length); +void gl4_3compat_glGetProgramBinary(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary); +void gl4_3compat_glClearDepthf(void *_glfuncs, GLfloat dd); +void gl4_3compat_glDepthRangef(void *_glfuncs, GLfloat n, GLfloat f); +void gl4_3compat_glGetShaderPrecisionFormat(void *_glfuncs, GLenum shadertype, GLenum precisionType, GLint* range_, GLint* precision); +void gl4_3compat_glShaderBinary(void *_glfuncs, GLsizei count, const GLuint* shaders, GLenum binaryFormat, const GLvoid* binary, GLsizei length); +void gl4_3compat_glReleaseShaderCompiler(void *_glfuncs); +void gl4_3compat_glTexStorage3D(void *_glfuncs, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth); +void gl4_3compat_glTexStorage2D(void *_glfuncs, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height); +void gl4_3compat_glTexStorage1D(void *_glfuncs, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width); +void gl4_3compat_glMemoryBarrier(void *_glfuncs, GLbitfield barriers); +void gl4_3compat_glBindImageTexture(void *_glfuncs, GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format); +void gl4_3compat_glGetActiveAtomicCounterBufferiv(void *_glfuncs, GLuint program, GLuint bufferIndex, GLenum pname, GLint* params); +void gl4_3compat_glGetInternalformativ(void *_glfuncs, GLenum target, GLenum internalFormat, GLenum pname, GLsizei bufSize, GLint* params); +void gl4_3compat_glDrawTransformFeedbackStreamInstanced(void *_glfuncs, GLenum mode, GLuint id, GLuint stream, GLsizei instancecount); +void gl4_3compat_glDrawTransformFeedbackInstanced(void *_glfuncs, GLenum mode, GLuint id, GLsizei instancecount); +void gl4_3compat_glDrawElementsInstancedBaseVertexBaseInstance(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance); +void gl4_3compat_glDrawElementsInstancedBaseInstance(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLuint baseinstance); +void gl4_3compat_glDrawArraysInstancedBaseInstance(void *_glfuncs, GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance); +void gl4_3compat_glTexStorage3DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); +void gl4_3compat_glTexStorage2DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +void gl4_3compat_glTexBufferRange(void *_glfuncs, GLenum target, GLenum internalFormat, GLuint buffer, GLintptr offset, GLsizeiptr size); +void gl4_3compat_glShaderStorageBlockBinding(void *_glfuncs, GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding); +GLint gl4_3compat_glGetProgramResourceLocationIndex(void *_glfuncs, GLuint program, GLenum programInterface, const GLchar* name); +GLint gl4_3compat_glGetProgramResourceLocation(void *_glfuncs, GLuint program, GLenum programInterface, const GLchar* name); +void gl4_3compat_glGetProgramResourceiv(void *_glfuncs, GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum* props, GLsizei bufSize, GLsizei* length, GLint* params); +void gl4_3compat_glGetProgramResourceName(void *_glfuncs, GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name); +GLuint gl4_3compat_glGetProgramResourceIndex(void *_glfuncs, GLuint program, GLenum programInterface, const GLchar* name); +void gl4_3compat_glGetProgramInterfaceiv(void *_glfuncs, GLuint program, GLenum programInterface, GLenum pname, GLint* params); +void gl4_3compat_glMultiDrawElementsIndirect(void *_glfuncs, GLenum mode, GLenum gltype, const GLvoid* indirect, GLsizei drawcount, GLsizei stride); +void gl4_3compat_glMultiDrawArraysIndirect(void *_glfuncs, GLenum mode, const GLvoid* indirect, GLsizei drawcount, GLsizei stride); +void gl4_3compat_glInvalidateSubFramebuffer(void *_glfuncs, GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_3compat_glInvalidateFramebuffer(void *_glfuncs, GLenum target, GLsizei numAttachments, const GLenum* attachments); +void gl4_3compat_glInvalidateBufferData(void *_glfuncs, GLuint buffer); +void gl4_3compat_glInvalidateBufferSubData(void *_glfuncs, GLuint buffer, GLintptr offset, GLsizeiptr length); +void gl4_3compat_glInvalidateTexImage(void *_glfuncs, GLuint texture, GLint level); +void gl4_3compat_glInvalidateTexSubImage(void *_glfuncs, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth); +void gl4_3compat_glGetInternalformati64v(void *_glfuncs, GLenum target, GLenum internalFormat, GLenum pname, GLsizei bufSize, GLint64* params); +void gl4_3compat_glGetFramebufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_3compat_glFramebufferParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl4_3compat_glVertexBindingDivisor(void *_glfuncs, GLuint bindingindex, GLuint divisor); +void gl4_3compat_glVertexAttribBinding(void *_glfuncs, GLuint attribindex, GLuint bindingindex); +void gl4_3compat_glVertexAttribLFormat(void *_glfuncs, GLuint attribindex, GLint size, GLenum gltype, GLuint relativeoffset); +void gl4_3compat_glVertexAttribIFormat(void *_glfuncs, GLuint attribindex, GLint size, GLenum gltype, GLuint relativeoffset); +void gl4_3compat_glVertexAttribFormat(void *_glfuncs, GLuint attribindex, GLint size, GLenum gltype, GLboolean normalized, GLuint relativeoffset); +void gl4_3compat_glBindVertexBuffer(void *_glfuncs, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride); +void gl4_3compat_glTextureView(void *_glfuncs, GLuint texture, GLenum target, GLuint origtexture, GLenum internalFormat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers); +void gl4_3compat_glCopyImageSubData(void *_glfuncs, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth); +void gl4_3compat_glDispatchComputeIndirect(void *_glfuncs, GLintptr indirect); +void gl4_3compat_glDispatchCompute(void *_glfuncs, GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z); +void gl4_3compat_glClearBufferSubData(void *_glfuncs, GLenum target, GLenum internalFormat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum gltype, const GLvoid* data); +void gl4_3compat_glClearBufferData(void *_glfuncs, GLenum target, GLenum internalFormat, GLenum format, GLenum gltype, const GLvoid* data); +void gl4_3compat_glTranslatef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl4_3compat_glTranslated(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl4_3compat_glScalef(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl4_3compat_glScaled(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl4_3compat_glRotatef(void *_glfuncs, GLfloat angle, GLfloat x, GLfloat y, GLfloat z); +void gl4_3compat_glRotated(void *_glfuncs, GLdouble angle, GLdouble x, GLdouble y, GLdouble z); +void gl4_3compat_glPushMatrix(void *_glfuncs); +void gl4_3compat_glPopMatrix(void *_glfuncs); +void gl4_3compat_glOrtho(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +void gl4_3compat_glMultMatrixd(void *_glfuncs, const GLdouble* m); +void gl4_3compat_glMultMatrixf(void *_glfuncs, const GLfloat* m); +void gl4_3compat_glMatrixMode(void *_glfuncs, GLenum mode); +void gl4_3compat_glLoadMatrixd(void *_glfuncs, const GLdouble* m); +void gl4_3compat_glLoadMatrixf(void *_glfuncs, const GLfloat* m); +void gl4_3compat_glLoadIdentity(void *_glfuncs); +void gl4_3compat_glFrustum(void *_glfuncs, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +GLboolean gl4_3compat_glIsList(void *_glfuncs, GLuint list); +void gl4_3compat_glGetTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, GLint* params); +void gl4_3compat_glGetTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, GLfloat* params); +void gl4_3compat_glGetTexGendv(void *_glfuncs, GLenum coord, GLenum pname, GLdouble* params); +void gl4_3compat_glGetTexEnviv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_3compat_glGetTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl4_3compat_glGetPolygonStipple(void *_glfuncs, GLubyte* mask); +void gl4_3compat_glGetPixelMapusv(void *_glfuncs, GLenum glmap, GLushort* values); +void gl4_3compat_glGetPixelMapuiv(void *_glfuncs, GLenum glmap, GLuint* values); +void gl4_3compat_glGetPixelMapfv(void *_glfuncs, GLenum glmap, GLfloat* values); +void gl4_3compat_glGetMaterialiv(void *_glfuncs, GLenum face, GLenum pname, GLint* params); +void gl4_3compat_glGetMaterialfv(void *_glfuncs, GLenum face, GLenum pname, GLfloat* params); +void gl4_3compat_glGetMapiv(void *_glfuncs, GLenum target, GLenum query, GLint* v); +void gl4_3compat_glGetMapfv(void *_glfuncs, GLenum target, GLenum query, GLfloat* v); +void gl4_3compat_glGetMapdv(void *_glfuncs, GLenum target, GLenum query, GLdouble* v); +void gl4_3compat_glGetLightiv(void *_glfuncs, GLenum light, GLenum pname, GLint* params); +void gl4_3compat_glGetLightfv(void *_glfuncs, GLenum light, GLenum pname, GLfloat* params); +void gl4_3compat_glGetClipPlane(void *_glfuncs, GLenum plane, GLdouble* equation); +void gl4_3compat_glDrawPixels(void *_glfuncs, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_3compat_glCopyPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum gltype); +void gl4_3compat_glPixelMapusv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLushort* values); +void gl4_3compat_glPixelMapuiv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLuint* values); +void gl4_3compat_glPixelMapfv(void *_glfuncs, GLenum glmap, GLint mapsize, const GLfloat* values); +void gl4_3compat_glPixelTransferi(void *_glfuncs, GLenum pname, GLint param); +void gl4_3compat_glPixelTransferf(void *_glfuncs, GLenum pname, GLfloat param); +void gl4_3compat_glPixelZoom(void *_glfuncs, GLfloat xfactor, GLfloat yfactor); +void gl4_3compat_glAlphaFunc(void *_glfuncs, GLenum glfunc, GLfloat ref); +void gl4_3compat_glEvalPoint2(void *_glfuncs, GLint i, GLint j); +void gl4_3compat_glEvalMesh2(void *_glfuncs, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); +void gl4_3compat_glEvalPoint1(void *_glfuncs, GLint i); +void gl4_3compat_glEvalMesh1(void *_glfuncs, GLenum mode, GLint i1, GLint i2); +void gl4_3compat_glEvalCoord2fv(void *_glfuncs, const GLfloat* u); +void gl4_3compat_glEvalCoord2f(void *_glfuncs, GLfloat u, GLfloat v); +void gl4_3compat_glEvalCoord2dv(void *_glfuncs, const GLdouble* u); +void gl4_3compat_glEvalCoord2d(void *_glfuncs, GLdouble u, GLdouble v); +void gl4_3compat_glEvalCoord1fv(void *_glfuncs, const GLfloat* u); +void gl4_3compat_glEvalCoord1f(void *_glfuncs, GLfloat u); +void gl4_3compat_glEvalCoord1dv(void *_glfuncs, const GLdouble* u); +void gl4_3compat_glEvalCoord1d(void *_glfuncs, GLdouble u); +void gl4_3compat_glMapGrid2f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); +void gl4_3compat_glMapGrid2d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); +void gl4_3compat_glMapGrid1f(void *_glfuncs, GLint un, GLfloat u1, GLfloat u2); +void gl4_3compat_glMapGrid1d(void *_glfuncs, GLint un, GLdouble u1, GLdouble u2); +void gl4_3compat_glMap2f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points); +void gl4_3compat_glMap2d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points); +void gl4_3compat_glMap1f(void *_glfuncs, GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points); +void gl4_3compat_glMap1d(void *_glfuncs, GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points); +void gl4_3compat_glPushAttrib(void *_glfuncs, GLbitfield mask); +void gl4_3compat_glPopAttrib(void *_glfuncs); +void gl4_3compat_glAccum(void *_glfuncs, GLenum op, GLfloat value); +void gl4_3compat_glIndexMask(void *_glfuncs, GLuint mask); +void gl4_3compat_glClearIndex(void *_glfuncs, GLfloat c); +void gl4_3compat_glClearAccum(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl4_3compat_glPushName(void *_glfuncs, GLuint name); +void gl4_3compat_glPopName(void *_glfuncs); +void gl4_3compat_glPassThrough(void *_glfuncs, GLfloat token); +void gl4_3compat_glLoadName(void *_glfuncs, GLuint name); +void gl4_3compat_glInitNames(void *_glfuncs); +GLint gl4_3compat_glRenderMode(void *_glfuncs, GLenum mode); +void gl4_3compat_glSelectBuffer(void *_glfuncs, GLsizei size, GLuint* buffer); +void gl4_3compat_glFeedbackBuffer(void *_glfuncs, GLsizei size, GLenum gltype, GLfloat* buffer); +void gl4_3compat_glTexGeniv(void *_glfuncs, GLenum coord, GLenum pname, const GLint* params); +void gl4_3compat_glTexGeni(void *_glfuncs, GLenum coord, GLenum pname, GLint param); +void gl4_3compat_glTexGenfv(void *_glfuncs, GLenum coord, GLenum pname, const GLfloat* params); +void gl4_3compat_glTexGenf(void *_glfuncs, GLenum coord, GLenum pname, GLfloat param); +void gl4_3compat_glTexGendv(void *_glfuncs, GLenum coord, GLenum pname, const GLdouble* params); +void gl4_3compat_glTexGend(void *_glfuncs, GLenum coord, GLenum pname, GLdouble param); +void gl4_3compat_glTexEnviv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl4_3compat_glTexEnvi(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl4_3compat_glTexEnvfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl4_3compat_glTexEnvf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl4_3compat_glShadeModel(void *_glfuncs, GLenum mode); +void gl4_3compat_glPolygonStipple(void *_glfuncs, const GLubyte* mask); +void gl4_3compat_glMaterialiv(void *_glfuncs, GLenum face, GLenum pname, const GLint* params); +void gl4_3compat_glMateriali(void *_glfuncs, GLenum face, GLenum pname, GLint param); +void gl4_3compat_glMaterialfv(void *_glfuncs, GLenum face, GLenum pname, const GLfloat* params); +void gl4_3compat_glMaterialf(void *_glfuncs, GLenum face, GLenum pname, GLfloat param); +void gl4_3compat_glLineStipple(void *_glfuncs, GLint factor, GLushort pattern); +void gl4_3compat_glLightModeliv(void *_glfuncs, GLenum pname, const GLint* params); +void gl4_3compat_glLightModeli(void *_glfuncs, GLenum pname, GLint param); +void gl4_3compat_glLightModelfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl4_3compat_glLightModelf(void *_glfuncs, GLenum pname, GLfloat param); +void gl4_3compat_glLightiv(void *_glfuncs, GLenum light, GLenum pname, const GLint* params); +void gl4_3compat_glLighti(void *_glfuncs, GLenum light, GLenum pname, GLint param); +void gl4_3compat_glLightfv(void *_glfuncs, GLenum light, GLenum pname, const GLfloat* params); +void gl4_3compat_glLightf(void *_glfuncs, GLenum light, GLenum pname, GLfloat param); +void gl4_3compat_glFogiv(void *_glfuncs, GLenum pname, const GLint* params); +void gl4_3compat_glFogi(void *_glfuncs, GLenum pname, GLint param); +void gl4_3compat_glFogfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl4_3compat_glFogf(void *_glfuncs, GLenum pname, GLfloat param); +void gl4_3compat_glColorMaterial(void *_glfuncs, GLenum face, GLenum mode); +void gl4_3compat_glClipPlane(void *_glfuncs, GLenum plane, const GLdouble* equation); +void gl4_3compat_glVertex4sv(void *_glfuncs, const GLshort* v); +void gl4_3compat_glVertex4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w); +void gl4_3compat_glVertex4iv(void *_glfuncs, const GLint* v); +void gl4_3compat_glVertex4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w); +void gl4_3compat_glVertex4fv(void *_glfuncs, const GLfloat* v); +void gl4_3compat_glVertex4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl4_3compat_glVertex4dv(void *_glfuncs, const GLdouble* v); +void gl4_3compat_glVertex4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl4_3compat_glVertex3sv(void *_glfuncs, const GLshort* v); +void gl4_3compat_glVertex3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl4_3compat_glVertex3iv(void *_glfuncs, const GLint* v); +void gl4_3compat_glVertex3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl4_3compat_glVertex3fv(void *_glfuncs, const GLfloat* v); +void gl4_3compat_glVertex3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl4_3compat_glVertex3dv(void *_glfuncs, const GLdouble* v); +void gl4_3compat_glVertex3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl4_3compat_glVertex2sv(void *_glfuncs, const GLshort* v); +void gl4_3compat_glVertex2s(void *_glfuncs, GLshort x, GLshort y); +void gl4_3compat_glVertex2iv(void *_glfuncs, const GLint* v); +void gl4_3compat_glVertex2i(void *_glfuncs, GLint x, GLint y); +void gl4_3compat_glVertex2fv(void *_glfuncs, const GLfloat* v); +void gl4_3compat_glVertex2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl4_3compat_glVertex2dv(void *_glfuncs, const GLdouble* v); +void gl4_3compat_glVertex2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl4_3compat_glTexCoord4sv(void *_glfuncs, const GLshort* v); +void gl4_3compat_glTexCoord4s(void *_glfuncs, GLshort s, GLshort t, GLshort r, GLshort q); +void gl4_3compat_glTexCoord4iv(void *_glfuncs, const GLint* v); +void gl4_3compat_glTexCoord4i(void *_glfuncs, GLint s, GLint t, GLint r, GLint q); +void gl4_3compat_glTexCoord4fv(void *_glfuncs, const GLfloat* v); +void gl4_3compat_glTexCoord4f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +void gl4_3compat_glTexCoord4dv(void *_glfuncs, const GLdouble* v); +void gl4_3compat_glTexCoord4d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +void gl4_3compat_glTexCoord3sv(void *_glfuncs, const GLshort* v); +void gl4_3compat_glTexCoord3s(void *_glfuncs, GLshort s, GLshort t, GLshort r); +void gl4_3compat_glTexCoord3iv(void *_glfuncs, const GLint* v); +void gl4_3compat_glTexCoord3i(void *_glfuncs, GLint s, GLint t, GLint r); +void gl4_3compat_glTexCoord3fv(void *_glfuncs, const GLfloat* v); +void gl4_3compat_glTexCoord3f(void *_glfuncs, GLfloat s, GLfloat t, GLfloat r); +void gl4_3compat_glTexCoord3dv(void *_glfuncs, const GLdouble* v); +void gl4_3compat_glTexCoord3d(void *_glfuncs, GLdouble s, GLdouble t, GLdouble r); +void gl4_3compat_glTexCoord2sv(void *_glfuncs, const GLshort* v); +void gl4_3compat_glTexCoord2s(void *_glfuncs, GLshort s, GLshort t); +void gl4_3compat_glTexCoord2iv(void *_glfuncs, const GLint* v); +void gl4_3compat_glTexCoord2i(void *_glfuncs, GLint s, GLint t); +void gl4_3compat_glTexCoord2fv(void *_glfuncs, const GLfloat* v); +void gl4_3compat_glTexCoord2f(void *_glfuncs, GLfloat s, GLfloat t); +void gl4_3compat_glTexCoord2dv(void *_glfuncs, const GLdouble* v); +void gl4_3compat_glTexCoord2d(void *_glfuncs, GLdouble s, GLdouble t); +void gl4_3compat_glTexCoord1sv(void *_glfuncs, const GLshort* v); +void gl4_3compat_glTexCoord1s(void *_glfuncs, GLshort s); +void gl4_3compat_glTexCoord1iv(void *_glfuncs, const GLint* v); +void gl4_3compat_glTexCoord1i(void *_glfuncs, GLint s); +void gl4_3compat_glTexCoord1fv(void *_glfuncs, const GLfloat* v); +void gl4_3compat_glTexCoord1f(void *_glfuncs, GLfloat s); +void gl4_3compat_glTexCoord1dv(void *_glfuncs, const GLdouble* v); +void gl4_3compat_glTexCoord1d(void *_glfuncs, GLdouble s); +void gl4_3compat_glRectsv(void *_glfuncs, const GLshort* v1, const GLshort* v2); +void gl4_3compat_glRects(void *_glfuncs, GLshort x1, GLshort y1, GLshort x2, GLshort y2); +void gl4_3compat_glRectiv(void *_glfuncs, const GLint* v1, const GLint* v2); +void gl4_3compat_glRecti(void *_glfuncs, GLint x1, GLint y1, GLint x2, GLint y2); +void gl4_3compat_glRectfv(void *_glfuncs, const GLfloat* v1, const GLfloat* v2); +void gl4_3compat_glRectf(void *_glfuncs, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); +void gl4_3compat_glRectdv(void *_glfuncs, const GLdouble* v1, const GLdouble* v2); +void gl4_3compat_glRectd(void *_glfuncs, GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); +void gl4_3compat_glRasterPos4sv(void *_glfuncs, const GLshort* v); +void gl4_3compat_glRasterPos4s(void *_glfuncs, GLshort x, GLshort y, GLshort z, GLshort w); +void gl4_3compat_glRasterPos4iv(void *_glfuncs, const GLint* v); +void gl4_3compat_glRasterPos4i(void *_glfuncs, GLint x, GLint y, GLint z, GLint w); +void gl4_3compat_glRasterPos4fv(void *_glfuncs, const GLfloat* v); +void gl4_3compat_glRasterPos4f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl4_3compat_glRasterPos4dv(void *_glfuncs, const GLdouble* v); +void gl4_3compat_glRasterPos4d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl4_3compat_glRasterPos3sv(void *_glfuncs, const GLshort* v); +void gl4_3compat_glRasterPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl4_3compat_glRasterPos3iv(void *_glfuncs, const GLint* v); +void gl4_3compat_glRasterPos3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl4_3compat_glRasterPos3fv(void *_glfuncs, const GLfloat* v); +void gl4_3compat_glRasterPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl4_3compat_glRasterPos3dv(void *_glfuncs, const GLdouble* v); +void gl4_3compat_glRasterPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl4_3compat_glRasterPos2sv(void *_glfuncs, const GLshort* v); +void gl4_3compat_glRasterPos2s(void *_glfuncs, GLshort x, GLshort y); +void gl4_3compat_glRasterPos2iv(void *_glfuncs, const GLint* v); +void gl4_3compat_glRasterPos2i(void *_glfuncs, GLint x, GLint y); +void gl4_3compat_glRasterPos2fv(void *_glfuncs, const GLfloat* v); +void gl4_3compat_glRasterPos2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl4_3compat_glRasterPos2dv(void *_glfuncs, const GLdouble* v); +void gl4_3compat_glRasterPos2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl4_3compat_glNormal3sv(void *_glfuncs, const GLshort* v); +void gl4_3compat_glNormal3s(void *_glfuncs, GLshort nx, GLshort ny, GLshort nz); +void gl4_3compat_glNormal3iv(void *_glfuncs, const GLint* v); +void gl4_3compat_glNormal3i(void *_glfuncs, GLint nx, GLint ny, GLint nz); +void gl4_3compat_glNormal3fv(void *_glfuncs, const GLfloat* v); +void gl4_3compat_glNormal3f(void *_glfuncs, GLfloat nx, GLfloat ny, GLfloat nz); +void gl4_3compat_glNormal3dv(void *_glfuncs, const GLdouble* v); +void gl4_3compat_glNormal3d(void *_glfuncs, GLdouble nx, GLdouble ny, GLdouble nz); +void gl4_3compat_glNormal3bv(void *_glfuncs, const GLbyte* v); +void gl4_3compat_glNormal3b(void *_glfuncs, GLbyte nx, GLbyte ny, GLbyte nz); +void gl4_3compat_glIndexsv(void *_glfuncs, const GLshort* c); +void gl4_3compat_glIndexs(void *_glfuncs, GLshort c); +void gl4_3compat_glIndexiv(void *_glfuncs, const GLint* c); +void gl4_3compat_glIndexi(void *_glfuncs, GLint c); +void gl4_3compat_glIndexfv(void *_glfuncs, const GLfloat* c); +void gl4_3compat_glIndexf(void *_glfuncs, GLfloat c); +void gl4_3compat_glIndexdv(void *_glfuncs, const GLdouble* c); +void gl4_3compat_glIndexd(void *_glfuncs, GLdouble c); +void gl4_3compat_glEnd(void *_glfuncs); +void gl4_3compat_glEdgeFlagv(void *_glfuncs, const GLboolean* flag); +void gl4_3compat_glEdgeFlag(void *_glfuncs, GLboolean flag); +void gl4_3compat_glColor4usv(void *_glfuncs, const GLushort* v); +void gl4_3compat_glColor4us(void *_glfuncs, GLushort red, GLushort green, GLushort blue, GLushort alpha); +void gl4_3compat_glColor4uiv(void *_glfuncs, const GLuint* v); +void gl4_3compat_glColor4ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue, GLuint alpha); +void gl4_3compat_glColor4ubv(void *_glfuncs, const GLubyte* v); +void gl4_3compat_glColor4ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); +void gl4_3compat_glColor4sv(void *_glfuncs, const GLshort* v); +void gl4_3compat_glColor4s(void *_glfuncs, GLshort red, GLshort green, GLshort blue, GLshort alpha); +void gl4_3compat_glColor4iv(void *_glfuncs, const GLint* v); +void gl4_3compat_glColor4i(void *_glfuncs, GLint red, GLint green, GLint blue, GLint alpha); +void gl4_3compat_glColor4fv(void *_glfuncs, const GLfloat* v); +void gl4_3compat_glColor4f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl4_3compat_glColor4dv(void *_glfuncs, const GLdouble* v); +void gl4_3compat_glColor4d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); +void gl4_3compat_glColor4bv(void *_glfuncs, const GLbyte* v); +void gl4_3compat_glColor4b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); +void gl4_3compat_glColor3usv(void *_glfuncs, const GLushort* v); +void gl4_3compat_glColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue); +void gl4_3compat_glColor3uiv(void *_glfuncs, const GLuint* v); +void gl4_3compat_glColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue); +void gl4_3compat_glColor3ubv(void *_glfuncs, const GLubyte* v); +void gl4_3compat_glColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue); +void gl4_3compat_glColor3sv(void *_glfuncs, const GLshort* v); +void gl4_3compat_glColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue); +void gl4_3compat_glColor3iv(void *_glfuncs, const GLint* v); +void gl4_3compat_glColor3i(void *_glfuncs, GLint red, GLint green, GLint blue); +void gl4_3compat_glColor3fv(void *_glfuncs, const GLfloat* v); +void gl4_3compat_glColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue); +void gl4_3compat_glColor3dv(void *_glfuncs, const GLdouble* v); +void gl4_3compat_glColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue); +void gl4_3compat_glColor3bv(void *_glfuncs, const GLbyte* v); +void gl4_3compat_glColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue); +void gl4_3compat_glBitmap(void *_glfuncs, GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap); +void gl4_3compat_glBegin(void *_glfuncs, GLenum mode); +void gl4_3compat_glListBase(void *_glfuncs, GLuint base); +GLuint gl4_3compat_glGenLists(void *_glfuncs, GLsizei range_); +void gl4_3compat_glDeleteLists(void *_glfuncs, GLuint list, GLsizei range_); +void gl4_3compat_glCallLists(void *_glfuncs, GLsizei n, GLenum gltype, const GLvoid* lists); +void gl4_3compat_glCallList(void *_glfuncs, GLuint list); +void gl4_3compat_glEndList(void *_glfuncs); +void gl4_3compat_glNewList(void *_glfuncs, GLuint list, GLenum mode); +void gl4_3compat_glPushClientAttrib(void *_glfuncs, GLbitfield mask); +void gl4_3compat_glPopClientAttrib(void *_glfuncs); +void gl4_3compat_glPrioritizeTextures(void *_glfuncs, GLsizei n, const GLuint* textures, const GLfloat* priorities); +GLboolean gl4_3compat_glAreTexturesResident(void *_glfuncs, GLsizei n, const GLuint* textures, GLboolean* residences); +void gl4_3compat_glVertexPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_3compat_glTexCoordPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_3compat_glNormalPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_3compat_glInterleavedArrays(void *_glfuncs, GLenum format, GLsizei stride, const GLvoid* pointer); +void gl4_3compat_glIndexPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_3compat_glEnableClientState(void *_glfuncs, GLenum array); +void gl4_3compat_glEdgeFlagPointer(void *_glfuncs, GLsizei stride, const GLvoid* pointer); +void gl4_3compat_glDisableClientState(void *_glfuncs, GLenum array); +void gl4_3compat_glColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_3compat_glArrayElement(void *_glfuncs, GLint i); +void gl4_3compat_glResetMinmax(void *_glfuncs, GLenum target); +void gl4_3compat_glResetHistogram(void *_glfuncs, GLenum target); +void gl4_3compat_glMinmax(void *_glfuncs, GLenum target, GLenum internalFormat, GLboolean sink); +void gl4_3compat_glHistogram(void *_glfuncs, GLenum target, GLsizei width, GLenum internalFormat, GLboolean sink); +void gl4_3compat_glGetMinmaxParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_3compat_glGetMinmaxParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl4_3compat_glGetMinmax(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values); +void gl4_3compat_glGetHistogramParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_3compat_glGetHistogramParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl4_3compat_glGetHistogram(void *_glfuncs, GLenum target, GLboolean reset, GLenum format, GLenum gltype, GLvoid* values); +void gl4_3compat_glSeparableFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* row, const GLvoid* column); +void gl4_3compat_glGetSeparableFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* row, GLvoid* column, GLvoid* span); +void gl4_3compat_glGetConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_3compat_glGetConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl4_3compat_glGetConvolutionFilter(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* image); +void gl4_3compat_glCopyConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_3compat_glCopyConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width); +void gl4_3compat_glConvolutionParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl4_3compat_glConvolutionParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint params); +void gl4_3compat_glConvolutionParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl4_3compat_glConvolutionParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat params); +void gl4_3compat_glConvolutionFilter2D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* image); +void gl4_3compat_glConvolutionFilter1D(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* image); +void gl4_3compat_glCopyColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); +void gl4_3compat_glColorSubTable(void *_glfuncs, GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum gltype, const GLvoid* data); +void gl4_3compat_glGetColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_3compat_glGetColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl4_3compat_glGetColorTable(void *_glfuncs, GLenum target, GLenum format, GLenum gltype, GLvoid* table); +void gl4_3compat_glCopyColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width); +void gl4_3compat_glColorTableParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl4_3compat_glColorTableParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl4_3compat_glColorTable(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum gltype, const GLvoid* table); +void gl4_3compat_glMultTransposeMatrixd(void *_glfuncs, const GLdouble* m); +void gl4_3compat_glMultTransposeMatrixf(void *_glfuncs, const GLfloat* m); +void gl4_3compat_glLoadTransposeMatrixd(void *_glfuncs, const GLdouble* m); +void gl4_3compat_glLoadTransposeMatrixf(void *_glfuncs, const GLfloat* m); +void gl4_3compat_glMultiTexCoord4sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl4_3compat_glMultiTexCoord4s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); +void gl4_3compat_glMultiTexCoord4iv(void *_glfuncs, GLenum target, const GLint* v); +void gl4_3compat_glMultiTexCoord4i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r, GLint q); +void gl4_3compat_glMultiTexCoord4fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl4_3compat_glMultiTexCoord4f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +void gl4_3compat_glMultiTexCoord4dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl4_3compat_glMultiTexCoord4d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +void gl4_3compat_glMultiTexCoord3sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl4_3compat_glMultiTexCoord3s(void *_glfuncs, GLenum target, GLshort s, GLshort t, GLshort r); +void gl4_3compat_glMultiTexCoord3iv(void *_glfuncs, GLenum target, const GLint* v); +void gl4_3compat_glMultiTexCoord3i(void *_glfuncs, GLenum target, GLint s, GLint t, GLint r); +void gl4_3compat_glMultiTexCoord3fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl4_3compat_glMultiTexCoord3f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t, GLfloat r); +void gl4_3compat_glMultiTexCoord3dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl4_3compat_glMultiTexCoord3d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t, GLdouble r); +void gl4_3compat_glMultiTexCoord2sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl4_3compat_glMultiTexCoord2s(void *_glfuncs, GLenum target, GLshort s, GLshort t); +void gl4_3compat_glMultiTexCoord2iv(void *_glfuncs, GLenum target, const GLint* v); +void gl4_3compat_glMultiTexCoord2i(void *_glfuncs, GLenum target, GLint s, GLint t); +void gl4_3compat_glMultiTexCoord2fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl4_3compat_glMultiTexCoord2f(void *_glfuncs, GLenum target, GLfloat s, GLfloat t); +void gl4_3compat_glMultiTexCoord2dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl4_3compat_glMultiTexCoord2d(void *_glfuncs, GLenum target, GLdouble s, GLdouble t); +void gl4_3compat_glMultiTexCoord1sv(void *_glfuncs, GLenum target, const GLshort* v); +void gl4_3compat_glMultiTexCoord1s(void *_glfuncs, GLenum target, GLshort s); +void gl4_3compat_glMultiTexCoord1iv(void *_glfuncs, GLenum target, const GLint* v); +void gl4_3compat_glMultiTexCoord1i(void *_glfuncs, GLenum target, GLint s); +void gl4_3compat_glMultiTexCoord1fv(void *_glfuncs, GLenum target, const GLfloat* v); +void gl4_3compat_glMultiTexCoord1f(void *_glfuncs, GLenum target, GLfloat s); +void gl4_3compat_glMultiTexCoord1dv(void *_glfuncs, GLenum target, const GLdouble* v); +void gl4_3compat_glMultiTexCoord1d(void *_glfuncs, GLenum target, GLdouble s); +void gl4_3compat_glClientActiveTexture(void *_glfuncs, GLenum texture); +void gl4_3compat_glWindowPos3sv(void *_glfuncs, const GLshort* v); +void gl4_3compat_glWindowPos3s(void *_glfuncs, GLshort x, GLshort y, GLshort z); +void gl4_3compat_glWindowPos3iv(void *_glfuncs, const GLint* v); +void gl4_3compat_glWindowPos3i(void *_glfuncs, GLint x, GLint y, GLint z); +void gl4_3compat_glWindowPos3fv(void *_glfuncs, const GLfloat* v); +void gl4_3compat_glWindowPos3f(void *_glfuncs, GLfloat x, GLfloat y, GLfloat z); +void gl4_3compat_glWindowPos3dv(void *_glfuncs, const GLdouble* v); +void gl4_3compat_glWindowPos3d(void *_glfuncs, GLdouble x, GLdouble y, GLdouble z); +void gl4_3compat_glWindowPos2sv(void *_glfuncs, const GLshort* v); +void gl4_3compat_glWindowPos2s(void *_glfuncs, GLshort x, GLshort y); +void gl4_3compat_glWindowPos2iv(void *_glfuncs, const GLint* v); +void gl4_3compat_glWindowPos2i(void *_glfuncs, GLint x, GLint y); +void gl4_3compat_glWindowPos2fv(void *_glfuncs, const GLfloat* v); +void gl4_3compat_glWindowPos2f(void *_glfuncs, GLfloat x, GLfloat y); +void gl4_3compat_glWindowPos2dv(void *_glfuncs, const GLdouble* v); +void gl4_3compat_glWindowPos2d(void *_glfuncs, GLdouble x, GLdouble y); +void gl4_3compat_glSecondaryColorPointer(void *_glfuncs, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_3compat_glSecondaryColor3usv(void *_glfuncs, const GLushort* v); +void gl4_3compat_glSecondaryColor3us(void *_glfuncs, GLushort red, GLushort green, GLushort blue); +void gl4_3compat_glSecondaryColor3uiv(void *_glfuncs, const GLuint* v); +void gl4_3compat_glSecondaryColor3ui(void *_glfuncs, GLuint red, GLuint green, GLuint blue); +void gl4_3compat_glSecondaryColor3ubv(void *_glfuncs, const GLubyte* v); +void gl4_3compat_glSecondaryColor3ub(void *_glfuncs, GLubyte red, GLubyte green, GLubyte blue); +void gl4_3compat_glSecondaryColor3sv(void *_glfuncs, const GLshort* v); +void gl4_3compat_glSecondaryColor3s(void *_glfuncs, GLshort red, GLshort green, GLshort blue); +void gl4_3compat_glSecondaryColor3iv(void *_glfuncs, const GLint* v); +void gl4_3compat_glSecondaryColor3i(void *_glfuncs, GLint red, GLint green, GLint blue); +void gl4_3compat_glSecondaryColor3fv(void *_glfuncs, const GLfloat* v); +void gl4_3compat_glSecondaryColor3f(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue); +void gl4_3compat_glSecondaryColor3dv(void *_glfuncs, const GLdouble* v); +void gl4_3compat_glSecondaryColor3d(void *_glfuncs, GLdouble red, GLdouble green, GLdouble blue); +void gl4_3compat_glSecondaryColor3bv(void *_glfuncs, const GLbyte* v); +void gl4_3compat_glSecondaryColor3b(void *_glfuncs, GLbyte red, GLbyte green, GLbyte blue); +void gl4_3compat_glFogCoordPointer(void *_glfuncs, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_3compat_glFogCoorddv(void *_glfuncs, const GLdouble* coord); +void gl4_3compat_glFogCoordd(void *_glfuncs, GLdouble coord); +void gl4_3compat_glFogCoordfv(void *_glfuncs, const GLfloat* coord); +void gl4_3compat_glFogCoordf(void *_glfuncs, GLfloat coord); +void gl4_3compat_glVertexAttrib4usv(void *_glfuncs, GLuint index, const GLushort* v); +void gl4_3compat_glVertexAttrib4uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl4_3compat_glVertexAttrib4ubv(void *_glfuncs, GLuint index, const GLubyte* v); +void gl4_3compat_glVertexAttrib4sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl4_3compat_glVertexAttrib4s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +void gl4_3compat_glVertexAttrib4iv(void *_glfuncs, GLuint index, const GLint* v); +void gl4_3compat_glVertexAttrib4fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl4_3compat_glVertexAttrib4f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gl4_3compat_glVertexAttrib4dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_3compat_glVertexAttrib4d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl4_3compat_glVertexAttrib4bv(void *_glfuncs, GLuint index, const GLbyte* v); +void gl4_3compat_glVertexAttrib4Nusv(void *_glfuncs, GLuint index, const GLushort* v); +void gl4_3compat_glVertexAttrib4Nuiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl4_3compat_glVertexAttrib4Nubv(void *_glfuncs, GLuint index, const GLubyte* v); +void gl4_3compat_glVertexAttrib4Nub(void *_glfuncs, GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +void gl4_3compat_glVertexAttrib4Nsv(void *_glfuncs, GLuint index, const GLshort* v); +void gl4_3compat_glVertexAttrib4Niv(void *_glfuncs, GLuint index, const GLint* v); +void gl4_3compat_glVertexAttrib4Nbv(void *_glfuncs, GLuint index, const GLbyte* v); +void gl4_3compat_glVertexAttrib3sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl4_3compat_glVertexAttrib3s(void *_glfuncs, GLuint index, GLshort x, GLshort y, GLshort z); +void gl4_3compat_glVertexAttrib3fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl4_3compat_glVertexAttrib3f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z); +void gl4_3compat_glVertexAttrib3dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_3compat_glVertexAttrib3d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z); +void gl4_3compat_glVertexAttrib2sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl4_3compat_glVertexAttrib2s(void *_glfuncs, GLuint index, GLshort x, GLshort y); +void gl4_3compat_glVertexAttrib2fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl4_3compat_glVertexAttrib2f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y); +void gl4_3compat_glVertexAttrib2dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_3compat_glVertexAttrib2d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y); +void gl4_3compat_glVertexAttrib1sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl4_3compat_glVertexAttrib1s(void *_glfuncs, GLuint index, GLshort x); +void gl4_3compat_glVertexAttrib1fv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl4_3compat_glVertexAttrib1f(void *_glfuncs, GLuint index, GLfloat x); +void gl4_3compat_glVertexAttrib1dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_3compat_glVertexAttrib1d(void *_glfuncs, GLuint index, GLdouble x); +void gl4_3compat_glVertexAttribI4usv(void *_glfuncs, GLuint index, const GLushort* v); +void gl4_3compat_glVertexAttribI4ubv(void *_glfuncs, GLuint index, const GLubyte* v); +void gl4_3compat_glVertexAttribI4sv(void *_glfuncs, GLuint index, const GLshort* v); +void gl4_3compat_glVertexAttribI4bv(void *_glfuncs, GLuint index, const GLbyte* v); +void gl4_3compat_glVertexAttribI4uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl4_3compat_glVertexAttribI3uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl4_3compat_glVertexAttribI2uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl4_3compat_glVertexAttribI1uiv(void *_glfuncs, GLuint index, const GLuint* v); +void gl4_3compat_glVertexAttribI4iv(void *_glfuncs, GLuint index, const GLint* v); +void gl4_3compat_glVertexAttribI3iv(void *_glfuncs, GLuint index, const GLint* v); +void gl4_3compat_glVertexAttribI2iv(void *_glfuncs, GLuint index, const GLint* v); +void gl4_3compat_glVertexAttribI1iv(void *_glfuncs, GLuint index, const GLint* v); +void gl4_3compat_glVertexAttribI4ui(void *_glfuncs, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +void gl4_3compat_glVertexAttribI3ui(void *_glfuncs, GLuint index, GLuint x, GLuint y, GLuint z); +void gl4_3compat_glVertexAttribI2ui(void *_glfuncs, GLuint index, GLuint x, GLuint y); +void gl4_3compat_glVertexAttribI1ui(void *_glfuncs, GLuint index, GLuint x); +void gl4_3compat_glVertexAttribI4i(void *_glfuncs, GLuint index, GLint x, GLint y, GLint z, GLint w); +void gl4_3compat_glVertexAttribI3i(void *_glfuncs, GLuint index, GLint x, GLint y, GLint z); +void gl4_3compat_glVertexAttribI2i(void *_glfuncs, GLuint index, GLint x, GLint y); +void gl4_3compat_glVertexAttribI1i(void *_glfuncs, GLuint index, GLint x); + + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/gl/4.3compat/gl.go b/gl/4.3compat/gl.go new file mode 100644 index 00000000..4ee8a9ef --- /dev/null +++ b/gl/4.3compat/gl.go @@ -0,0 +1,9845 @@ +// ** file automatically generated by glgen -- do not edit manually ** + +package GL + +// #cgo CXXFLAGS: -std=c++0x -pedantic-errors -Wall -fno-strict-aliasing +// #cgo LDFLAGS: -lstdc++ +// #cgo pkg-config: Qt5Core Qt5OpenGL +// +// #include "funcs.h" +// +// void free(void*); +// +import "C" + +import ( + "fmt" + "reflect" + "unsafe" + + "gopkg.in/qml.v1/gl/glbase" +) + +// API returns a value that offers methods matching the OpenGL version 4.3 API. +// +// The returned API must not be used after the provided OpenGL context becomes invalid. +func API(context glbase.Contexter) *GL { + gl := &GL{} + gl.funcs = C.gl4_3compat_funcs() + if gl.funcs == nil { + panic(fmt.Errorf("OpenGL version 4.3 is not available")) + } + return gl +} + +// GL implements the OpenGL version 4.3 API. Values of this +// type must be created via the API function, and it must not be used after +// the associated OpenGL context becomes invalid. +type GL struct { + funcs unsafe.Pointer +} + +const ( + FALSE = 0 + TRUE = 1 + NONE = 0 + + BYTE = 0x1400 + UNSIGNED_BYTE = 0x1401 + SHORT = 0x1402 + UNSIGNED_SHORT = 0x1403 + INT = 0x1404 + UNSIGNED_INT = 0x1405 + FLOAT = 0x1406 + N2_BYTES = 0x1407 + N3_BYTES = 0x1408 + N4_BYTES = 0x1409 + DOUBLE = 0x140A + HALF_FLOAT = 0x140B + FIXED = 0x140C + + ACCUM = 0x0100 + LOAD = 0x0101 + RETURN = 0x0102 + MULT = 0x0103 + ADD = 0x0104 + + ACCUM_BUFFER_BIT = 0x00000200 + ALL_ATTRIB_BITS = 0xFFFFFFFF + COLOR_BUFFER_BIT = 0x00004000 + CURRENT_BIT = 0x00000001 + DEPTH_BUFFER_BIT = 0x00000100 + ENABLE_BIT = 0x00002000 + EVAL_BIT = 0x00010000 + FOG_BIT = 0x00000080 + HINT_BIT = 0x00008000 + LIGHTING_BIT = 0x00000040 + LINE_BIT = 0x00000004 + LIST_BIT = 0x00020000 + MULTISAMPLE_BIT = 0x20000000 + PIXEL_MODE_BIT = 0x00000020 + POINT_BIT = 0x00000002 + POLYGON_BIT = 0x00000008 + POLYGON_STIPPLE_BIT = 0x00000010 + SCISSOR_BIT = 0x00080000 + STENCIL_BUFFER_BIT = 0x00000400 + TEXTURE_BIT = 0x00040000 + TRANSFORM_BIT = 0x00001000 + VIEWPORT_BIT = 0x00000800 + + ALWAYS = 0x0207 + EQUAL = 0x0202 + GEQUAL = 0x0206 + GREATER = 0x0204 + LEQUAL = 0x0203 + LESS = 0x0201 + NEVER = 0x0200 + NOTEQUAL = 0x0205 + + LOGIC_OP = 0x0BF1 + + DST_ALPHA = 0x0304 + ONE = 1 + ONE_MINUS_DST_ALPHA = 0x0305 + ONE_MINUS_SRC_ALPHA = 0x0303 + ONE_MINUS_SRC_COLOR = 0x0301 + SRC_ALPHA = 0x0302 + SRC_COLOR = 0x0300 + ZERO = 0 + + DST_COLOR = 0x0306 + ONE_MINUS_DST_COLOR = 0x0307 + SRC_ALPHA_SATURATE = 0x0308 + + CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF + CLIENT_PIXEL_STORE_BIT = 0x00000001 + CLIENT_VERTEX_ARRAY_BIT = 0x00000002 + + CLIP_DISTANCE0 = 0x3000 + CLIP_DISTANCE1 = 0x3001 + CLIP_DISTANCE2 = 0x3002 + CLIP_DISTANCE3 = 0x3003 + CLIP_DISTANCE4 = 0x3004 + CLIP_DISTANCE5 = 0x3005 + CLIP_DISTANCE6 = 0x3006 + CLIP_DISTANCE7 = 0x3007 + CLIP_PLANE0 = 0x3000 + CLIP_PLANE1 = 0x3001 + CLIP_PLANE2 = 0x3002 + CLIP_PLANE3 = 0x3003 + CLIP_PLANE4 = 0x3004 + CLIP_PLANE5 = 0x3005 + + BACK = 0x0405 + FRONT = 0x0404 + FRONT_AND_BACK = 0x0408 + + AMBIENT = 0x1200 + AMBIENT_AND_DIFFUSE = 0x1602 + DIFFUSE = 0x1201 + EMISSION = 0x1600 + SPECULAR = 0x1202 + + CONTEXT_FLAG_DEBUG_BIT = 0x00000002 + CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x00000001 + + CONTEXT_COMPATIBILITY_PROFILE_BIT = 0x00000002 + CONTEXT_CORE_PROFILE_BIT = 0x00000001 + + AUX0 = 0x0409 + AUX1 = 0x040A + AUX2 = 0x040B + AUX3 = 0x040C + BACK_LEFT = 0x0402 + BACK_RIGHT = 0x0403 + FRONT_LEFT = 0x0400 + FRONT_RIGHT = 0x0401 + LEFT = 0x0406 + RIGHT = 0x0407 + + ALPHA_TEST = 0x0BC0 + AUTO_NORMAL = 0x0D80 + BLEND = 0x0BE2 + COLOR_ARRAY = 0x8076 + COLOR_LOGIC_OP = 0x0BF2 + COLOR_MATERIAL = 0x0B57 + CULL_FACE = 0x0B44 + DEPTH_TEST = 0x0B71 + DITHER = 0x0BD0 + EDGE_FLAG_ARRAY = 0x8079 + FOG = 0x0B60 + INDEX_ARRAY = 0x8077 + INDEX_LOGIC_OP = 0x0BF1 + LIGHT0 = 0x4000 + LIGHT1 = 0x4001 + LIGHT2 = 0x4002 + LIGHT3 = 0x4003 + LIGHT4 = 0x4004 + LIGHT5 = 0x4005 + LIGHT6 = 0x4006 + LIGHT7 = 0x4007 + LIGHTING = 0x0B50 + LINE_SMOOTH = 0x0B20 + LINE_STIPPLE = 0x0B24 + MAP1_COLOR_4 = 0x0D90 + MAP1_INDEX = 0x0D91 + MAP1_NORMAL = 0x0D92 + MAP1_TEXTURE_COORD_1 = 0x0D93 + MAP1_TEXTURE_COORD_2 = 0x0D94 + MAP1_TEXTURE_COORD_3 = 0x0D95 + MAP1_TEXTURE_COORD_4 = 0x0D96 + MAP1_VERTEX_3 = 0x0D97 + MAP1_VERTEX_4 = 0x0D98 + MAP2_COLOR_4 = 0x0DB0 + MAP2_INDEX = 0x0DB1 + MAP2_NORMAL = 0x0DB2 + MAP2_TEXTURE_COORD_1 = 0x0DB3 + MAP2_TEXTURE_COORD_2 = 0x0DB4 + MAP2_TEXTURE_COORD_3 = 0x0DB5 + MAP2_TEXTURE_COORD_4 = 0x0DB6 + MAP2_VERTEX_3 = 0x0DB7 + MAP2_VERTEX_4 = 0x0DB8 + NORMALIZE = 0x0BA1 + NORMAL_ARRAY = 0x8075 + POINT_SMOOTH = 0x0B10 + POLYGON_OFFSET_FILL = 0x8037 + POLYGON_OFFSET_LINE = 0x2A02 + POLYGON_OFFSET_POINT = 0x2A01 + POLYGON_SMOOTH = 0x0B41 + POLYGON_STIPPLE = 0x0B42 + SCISSOR_TEST = 0x0C11 + STENCIL_TEST = 0x0B90 + TEXTURE_1D = 0x0DE0 + TEXTURE_2D = 0x0DE1 + TEXTURE_COORD_ARRAY = 0x8078 + TEXTURE_GEN_Q = 0x0C63 + TEXTURE_GEN_R = 0x0C62 + TEXTURE_GEN_S = 0x0C60 + TEXTURE_GEN_T = 0x0C61 + VERTEX_ARRAY = 0x8074 + + INVALID_ENUM = 0x0500 + INVALID_FRAMEBUFFER_OPERATION = 0x0506 + INVALID_OPERATION = 0x0502 + INVALID_VALUE = 0x0501 + NO_ERROR = 0 + OUT_OF_MEMORY = 0x0505 + STACK_OVERFLOW = 0x0503 + STACK_UNDERFLOW = 0x0504 + + N2D = 0x0600 + N3D = 0x0601 + N3D_COLOR = 0x0602 + N3D_COLOR_TEXTURE = 0x0603 + N4D_COLOR_TEXTURE = 0x0604 + + BITMAP_TOKEN = 0x0704 + COPY_PIXEL_TOKEN = 0x0706 + DRAW_PIXEL_TOKEN = 0x0705 + LINE_RESET_TOKEN = 0x0707 + LINE_TOKEN = 0x0702 + PASS_THROUGH_TOKEN = 0x0700 + POINT_TOKEN = 0x0701 + POLYGON_TOKEN = 0x0703 + + EXP = 0x0800 + EXP2 = 0x0801 + LINEAR = 0x2601 + + FOG_COLOR = 0x0B66 + FOG_DENSITY = 0x0B62 + FOG_END = 0x0B64 + FOG_INDEX = 0x0B61 + FOG_MODE = 0x0B65 + FOG_START = 0x0B63 + + CCW = 0x0901 + CW = 0x0900 + + COEFF = 0x0A00 + DOMAIN = 0x0A02 + ORDER = 0x0A01 + + PIXEL_MAP_A_TO_A = 0x0C79 + PIXEL_MAP_B_TO_B = 0x0C78 + PIXEL_MAP_G_TO_G = 0x0C77 + PIXEL_MAP_I_TO_A = 0x0C75 + PIXEL_MAP_I_TO_B = 0x0C74 + PIXEL_MAP_I_TO_G = 0x0C73 + PIXEL_MAP_I_TO_I = 0x0C70 + PIXEL_MAP_I_TO_R = 0x0C72 + PIXEL_MAP_R_TO_R = 0x0C76 + PIXEL_MAP_S_TO_S = 0x0C71 + + ACCUM_ALPHA_BITS = 0x0D5B + ACCUM_BLUE_BITS = 0x0D5A + ACCUM_CLEAR_VALUE = 0x0B80 + ACCUM_GREEN_BITS = 0x0D59 + ACCUM_RED_BITS = 0x0D58 + ALIASED_LINE_WIDTH_RANGE = 0x846E + ALIASED_POINT_SIZE_RANGE = 0x846D + ALPHA_BIAS = 0x0D1D + ALPHA_BITS = 0x0D55 + ALPHA_SCALE = 0x0D1C + ALPHA_TEST_FUNC = 0x0BC1 + ALPHA_TEST_REF = 0x0BC2 + ATTRIB_STACK_DEPTH = 0x0BB0 + AUX_BUFFERS = 0x0C00 + BLEND_DST = 0x0BE0 + BLEND_SRC = 0x0BE1 + BLUE_BIAS = 0x0D1B + BLUE_BITS = 0x0D54 + BLUE_SCALE = 0x0D1A + CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1 + COLOR_ARRAY_SIZE = 0x8081 + COLOR_ARRAY_STRIDE = 0x8083 + COLOR_ARRAY_TYPE = 0x8082 + COLOR_CLEAR_VALUE = 0x0C22 + COLOR_MATERIAL_FACE = 0x0B55 + COLOR_MATERIAL_PARAMETER = 0x0B56 + COLOR_WRITEMASK = 0x0C23 + CULL_FACE_MODE = 0x0B45 + CURRENT_COLOR = 0x0B00 + CURRENT_INDEX = 0x0B01 + CURRENT_NORMAL = 0x0B02 + CURRENT_RASTER_COLOR = 0x0B04 + CURRENT_RASTER_DISTANCE = 0x0B09 + CURRENT_RASTER_INDEX = 0x0B05 + CURRENT_RASTER_POSITION = 0x0B07 + CURRENT_RASTER_POSITION_VALID = 0x0B08 + CURRENT_RASTER_TEXTURE_COORDS = 0x0B06 + CURRENT_TEXTURE_COORDS = 0x0B03 + DEPTH_BIAS = 0x0D1F + DEPTH_BITS = 0x0D56 + DEPTH_CLEAR_VALUE = 0x0B73 + DEPTH_FUNC = 0x0B74 + DEPTH_RANGE = 0x0B70 + DEPTH_SCALE = 0x0D1E + DEPTH_WRITEMASK = 0x0B72 + DOUBLEBUFFER = 0x0C32 + DRAW_BUFFER = 0x0C01 + EDGE_FLAG = 0x0B43 + EDGE_FLAG_ARRAY_STRIDE = 0x808C + FEEDBACK_BUFFER_SIZE = 0x0DF1 + FEEDBACK_BUFFER_TYPE = 0x0DF2 + FOG_HINT = 0x0C54 + FRONT_FACE = 0x0B46 + GREEN_BIAS = 0x0D19 + GREEN_BITS = 0x0D53 + GREEN_SCALE = 0x0D18 + INDEX_ARRAY_STRIDE = 0x8086 + INDEX_ARRAY_TYPE = 0x8085 + INDEX_BITS = 0x0D51 + INDEX_CLEAR_VALUE = 0x0C20 + INDEX_MODE = 0x0C30 + INDEX_OFFSET = 0x0D13 + INDEX_SHIFT = 0x0D12 + INDEX_WRITEMASK = 0x0C21 + LIGHT_MODEL_AMBIENT = 0x0B53 + LIGHT_MODEL_COLOR_CONTROL = 0x81F8 + LIGHT_MODEL_LOCAL_VIEWER = 0x0B51 + LIGHT_MODEL_TWO_SIDE = 0x0B52 + LINE_SMOOTH_HINT = 0x0C52 + LINE_STIPPLE_PATTERN = 0x0B25 + LINE_STIPPLE_REPEAT = 0x0B26 + LINE_WIDTH = 0x0B21 + LINE_WIDTH_GRANULARITY = 0x0B23 + LINE_WIDTH_RANGE = 0x0B22 + LIST_BASE = 0x0B32 + LIST_INDEX = 0x0B33 + LIST_MODE = 0x0B30 + LOGIC_OP_MODE = 0x0BF0 + MAP1_GRID_DOMAIN = 0x0DD0 + MAP1_GRID_SEGMENTS = 0x0DD1 + MAP2_GRID_DOMAIN = 0x0DD2 + MAP2_GRID_SEGMENTS = 0x0DD3 + MAP_COLOR = 0x0D10 + MAP_STENCIL = 0x0D11 + MATRIX_MODE = 0x0BA0 + MAX_ATTRIB_STACK_DEPTH = 0x0D35 + MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B + MAX_CLIP_DISTANCES = 0x0D32 + MAX_CLIP_PLANES = 0x0D32 + MAX_EVAL_ORDER = 0x0D30 + MAX_LIGHTS = 0x0D31 + MAX_LIST_NESTING = 0x0B31 + MAX_MODELVIEW_STACK_DEPTH = 0x0D36 + MAX_NAME_STACK_DEPTH = 0x0D37 + MAX_PIXEL_MAP_TABLE = 0x0D34 + MAX_PROJECTION_STACK_DEPTH = 0x0D38 + MAX_TEXTURE_SIZE = 0x0D33 + MAX_TEXTURE_STACK_DEPTH = 0x0D39 + MAX_VIEWPORT_DIMS = 0x0D3A + MODELVIEW_MATRIX = 0x0BA6 + MODELVIEW_STACK_DEPTH = 0x0BA3 + NAME_STACK_DEPTH = 0x0D70 + NORMAL_ARRAY_STRIDE = 0x807F + NORMAL_ARRAY_TYPE = 0x807E + PACK_ALIGNMENT = 0x0D05 + PACK_LSB_FIRST = 0x0D01 + PACK_ROW_LENGTH = 0x0D02 + PACK_SKIP_PIXELS = 0x0D04 + PACK_SKIP_ROWS = 0x0D03 + PACK_SWAP_BYTES = 0x0D00 + PERSPECTIVE_CORRECTION_HINT = 0x0C50 + PIXEL_MAP_A_TO_A_SIZE = 0x0CB9 + PIXEL_MAP_B_TO_B_SIZE = 0x0CB8 + PIXEL_MAP_G_TO_G_SIZE = 0x0CB7 + PIXEL_MAP_I_TO_A_SIZE = 0x0CB5 + PIXEL_MAP_I_TO_B_SIZE = 0x0CB4 + PIXEL_MAP_I_TO_G_SIZE = 0x0CB3 + PIXEL_MAP_I_TO_I_SIZE = 0x0CB0 + PIXEL_MAP_I_TO_R_SIZE = 0x0CB2 + PIXEL_MAP_R_TO_R_SIZE = 0x0CB6 + PIXEL_MAP_S_TO_S_SIZE = 0x0CB1 + POINT_SIZE = 0x0B11 + POINT_SIZE_GRANULARITY = 0x0B13 + POINT_SIZE_RANGE = 0x0B12 + POINT_SMOOTH_HINT = 0x0C51 + POLYGON_MODE = 0x0B40 + POLYGON_OFFSET_FACTOR = 0x8038 + POLYGON_OFFSET_UNITS = 0x2A00 + POLYGON_SMOOTH_HINT = 0x0C53 + PROJECTION_MATRIX = 0x0BA7 + PROJECTION_STACK_DEPTH = 0x0BA4 + READ_BUFFER = 0x0C02 + RED_BIAS = 0x0D15 + RED_BITS = 0x0D52 + RED_SCALE = 0x0D14 + RENDER_MODE = 0x0C40 + RGBA_MODE = 0x0C31 + SCISSOR_BOX = 0x0C10 + SELECTION_BUFFER_SIZE = 0x0DF4 + SHADE_MODEL = 0x0B54 + SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23 + SMOOTH_LINE_WIDTH_RANGE = 0x0B22 + SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13 + SMOOTH_POINT_SIZE_RANGE = 0x0B12 + STENCIL_BITS = 0x0D57 + STENCIL_CLEAR_VALUE = 0x0B91 + STENCIL_FAIL = 0x0B94 + STENCIL_FUNC = 0x0B92 + STENCIL_PASS_DEPTH_FAIL = 0x0B95 + STENCIL_PASS_DEPTH_PASS = 0x0B96 + STENCIL_REF = 0x0B97 + STENCIL_VALUE_MASK = 0x0B93 + STENCIL_WRITEMASK = 0x0B98 + STEREO = 0x0C33 + SUBPIXEL_BITS = 0x0D50 + TEXTURE_BINDING_1D = 0x8068 + TEXTURE_BINDING_2D = 0x8069 + TEXTURE_BINDING_3D = 0x806A + TEXTURE_COORD_ARRAY_SIZE = 0x8088 + TEXTURE_COORD_ARRAY_STRIDE = 0x808A + TEXTURE_COORD_ARRAY_TYPE = 0x8089 + TEXTURE_MATRIX = 0x0BA8 + TEXTURE_STACK_DEPTH = 0x0BA5 + UNPACK_ALIGNMENT = 0x0CF5 + UNPACK_LSB_FIRST = 0x0CF1 + UNPACK_ROW_LENGTH = 0x0CF2 + UNPACK_SKIP_PIXELS = 0x0CF4 + UNPACK_SKIP_ROWS = 0x0CF3 + UNPACK_SWAP_BYTES = 0x0CF0 + VERTEX_ARRAY_SIZE = 0x807A + VERTEX_ARRAY_STRIDE = 0x807C + VERTEX_ARRAY_TYPE = 0x807B + VIEWPORT = 0x0BA2 + ZOOM_X = 0x0D16 + ZOOM_Y = 0x0D17 + + COLOR_ARRAY_POINTER = 0x8090 + EDGE_FLAG_ARRAY_POINTER = 0x8093 + FEEDBACK_BUFFER_POINTER = 0x0DF0 + INDEX_ARRAY_POINTER = 0x8091 + NORMAL_ARRAY_POINTER = 0x808F + SELECTION_BUFFER_POINTER = 0x0DF3 + TEXTURE_COORD_ARRAY_POINTER = 0x8092 + VERTEX_ARRAY_POINTER = 0x808E + + TEXTURE_ALPHA_SIZE = 0x805F + TEXTURE_BLUE_SIZE = 0x805E + TEXTURE_BORDER = 0x1005 + TEXTURE_BORDER_COLOR = 0x1004 + TEXTURE_COMPONENTS = 0x1003 + TEXTURE_GREEN_SIZE = 0x805D + TEXTURE_HEIGHT = 0x1001 + TEXTURE_INTENSITY_SIZE = 0x8061 + TEXTURE_INTERNAL_FORMAT = 0x1003 + TEXTURE_LUMINANCE_SIZE = 0x8060 + TEXTURE_MAG_FILTER = 0x2800 + TEXTURE_MIN_FILTER = 0x2801 + TEXTURE_PRIORITY = 0x8066 + TEXTURE_RED_SIZE = 0x805C + TEXTURE_RESIDENT = 0x8067 + TEXTURE_WIDTH = 0x1000 + TEXTURE_WRAP_S = 0x2802 + TEXTURE_WRAP_T = 0x2803 + + DONT_CARE = 0x1100 + FASTEST = 0x1101 + NICEST = 0x1102 + + FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B + GENERATE_MIPMAP_HINT = 0x8192 + PROGRAM_BINARY_RETRIEVABLE_HINT = 0x8257 + TEXTURE_COMPRESSION_HINT = 0x84EF + + C3F_V3F = 0x2A24 + C4F_N3F_V3F = 0x2A26 + C4UB_V2F = 0x2A22 + C4UB_V3F = 0x2A23 + N3F_V3F = 0x2A25 + T2F_C3F_V3F = 0x2A2A + T2F_C4F_N3F_V3F = 0x2A2C + T2F_C4UB_V3F = 0x2A29 + T2F_N3F_V3F = 0x2A2B + T2F_V3F = 0x2A27 + T4F_C4F_N3F_V4F = 0x2A2D + T4F_V4F = 0x2A28 + V2F = 0x2A20 + V3F = 0x2A21 + + MODULATE = 0x2100 + REPLACE = 0x1E01 + + SEPARATE_SPECULAR_COLOR = 0x81FA + SINGLE_COLOR = 0x81F9 + + CONSTANT_ATTENUATION = 0x1207 + LINEAR_ATTENUATION = 0x1208 + POSITION = 0x1203 + QUADRATIC_ATTENUATION = 0x1209 + SPOT_CUTOFF = 0x1206 + SPOT_DIRECTION = 0x1204 + SPOT_EXPONENT = 0x1205 + + COMPILE = 0x1300 + COMPILE_AND_EXECUTE = 0x1301 + + AND = 0x1501 + AND_INVERTED = 0x1504 + AND_REVERSE = 0x1502 + CLEAR = 0x1500 + COPY = 0x1503 + COPY_INVERTED = 0x150C + EQUIV = 0x1509 + INVERT = 0x150A + NAND = 0x150E + NOOP = 0x1505 + NOR = 0x1508 + OR = 0x1507 + OR_INVERTED = 0x150D + OR_REVERSE = 0x150B + SET = 0x150F + XOR = 0x1506 + + MAP_FLUSH_EXPLICIT_BIT = 0x0010 + MAP_INVALIDATE_BUFFER_BIT = 0x0008 + MAP_INVALIDATE_RANGE_BIT = 0x0004 + MAP_READ_BIT = 0x0001 + MAP_UNSYNCHRONIZED_BIT = 0x0020 + MAP_WRITE_BIT = 0x0002 + + COLOR_INDEXES = 0x1603 + SHININESS = 0x1601 + + MODELVIEW = 0x1700 + PROJECTION = 0x1701 + TEXTURE = 0x1702 + + ALL_BARRIER_BITS = 0xFFFFFFFF + ATOMIC_COUNTER_BARRIER_BIT = 0x00001000 + BUFFER_UPDATE_BARRIER_BIT = 0x00000200 + COMMAND_BARRIER_BIT = 0x00000040 + ELEMENT_ARRAY_BARRIER_BIT = 0x00000002 + FRAMEBUFFER_BARRIER_BIT = 0x00000400 + PIXEL_BUFFER_BARRIER_BIT = 0x00000080 + SHADER_IMAGE_ACCESS_BARRIER_BIT = 0x00000020 + SHADER_STORAGE_BARRIER_BIT = 0x00002000 + TEXTURE_FETCH_BARRIER_BIT = 0x00000008 + TEXTURE_UPDATE_BARRIER_BIT = 0x00000100 + TRANSFORM_FEEDBACK_BARRIER_BIT = 0x00000800 + UNIFORM_BARRIER_BIT = 0x00000004 + VERTEX_ATTRIB_ARRAY_BARRIER_BIT = 0x00000001 + + LINE = 0x1B01 + POINT = 0x1B00 + + FILL = 0x1B02 + + COLOR = 0x1800 + DEPTH = 0x1801 + STENCIL = 0x1802 + + ALPHA = 0x1906 + BLUE = 0x1905 + COLOR_INDEX = 0x1900 + DEPTH_COMPONENT = 0x1902 + GREEN = 0x1904 + LUMINANCE = 0x1909 + LUMINANCE_ALPHA = 0x190A + RED = 0x1903 + RGB = 0x1907 + RGBA = 0x1908 + STENCIL_INDEX = 0x1901 + + ALPHA12 = 0x803D + ALPHA16 = 0x803E + ALPHA4 = 0x803B + ALPHA8 = 0x803C + INTENSITY = 0x8049 + INTENSITY12 = 0x804C + INTENSITY16 = 0x804D + INTENSITY4 = 0x804A + INTENSITY8 = 0x804B + LUMINANCE12 = 0x8041 + LUMINANCE12_ALPHA12 = 0x8047 + LUMINANCE12_ALPHA4 = 0x8046 + LUMINANCE16 = 0x8042 + LUMINANCE16_ALPHA16 = 0x8048 + LUMINANCE4 = 0x803F + LUMINANCE4_ALPHA4 = 0x8043 + LUMINANCE6_ALPHA2 = 0x8044 + LUMINANCE8 = 0x8040 + LUMINANCE8_ALPHA8 = 0x8045 + R3_G3_B2 = 0x2A10 + RGB10 = 0x8052 + RGB10_A2 = 0x8059 + RGB12 = 0x8053 + RGB16 = 0x8054 + RGB4 = 0x804F + RGB5 = 0x8050 + RGB5_A1 = 0x8057 + RGB8 = 0x8051 + RGBA12 = 0x805A + RGBA16 = 0x805B + RGBA2 = 0x8055 + RGBA4 = 0x8056 + RGBA8 = 0x8058 + + PACK_IMAGE_HEIGHT = 0x806C + PACK_SKIP_IMAGES = 0x806B + UNPACK_IMAGE_HEIGHT = 0x806E + UNPACK_SKIP_IMAGES = 0x806D + + BITMAP = 0x1A00 + UNSIGNED_BYTE_3_3_2 = 0x8032 + UNSIGNED_INT_10_10_10_2 = 0x8036 + UNSIGNED_INT_8_8_8_8 = 0x8035 + UNSIGNED_SHORT_4_4_4_4 = 0x8033 + UNSIGNED_SHORT_5_5_5_1 = 0x8034 + + POINT_DISTANCE_ATTENUATION = 0x8129 + POINT_FADE_THRESHOLD_SIZE = 0x8128 + POINT_SIZE_MAX = 0x8127 + POINT_SIZE_MIN = 0x8126 + + LINES = 0x0001 + LINES_ADJACENCY = 0x000A + LINE_LOOP = 0x0002 + LINE_STRIP = 0x0003 + LINE_STRIP_ADJACENCY = 0x000B + PATCHES = 0x000E + POINTS = 0x0000 + POLYGON = 0x0009 + QUADS = 0x0007 + QUAD_STRIP = 0x0008 + TRIANGLES = 0x0004 + TRIANGLES_ADJACENCY = 0x000C + TRIANGLE_FAN = 0x0006 + TRIANGLE_STRIP = 0x0005 + TRIANGLE_STRIP_ADJACENCY = 0x000D + + FEEDBACK = 0x1C01 + RENDER = 0x1C00 + SELECT = 0x1C02 + + FLAT = 0x1D00 + SMOOTH = 0x1D01 + + DECR = 0x1E03 + INCR = 0x1E02 + KEEP = 0x1E00 + + EXTENSIONS = 0x1F03 + RENDERER = 0x1F01 + VENDOR = 0x1F00 + VERSION = 0x1F02 + + S = 0x2000 + T = 0x2001 + R = 0x2002 + Q = 0x2003 + + DECAL = 0x2101 + + TEXTURE_ENV_COLOR = 0x2201 + TEXTURE_ENV_MODE = 0x2200 + + TEXTURE_ENV = 0x2300 + + EYE_LINEAR = 0x2400 + OBJECT_LINEAR = 0x2401 + SPHERE_MAP = 0x2402 + + EYE_PLANE = 0x2502 + OBJECT_PLANE = 0x2501 + TEXTURE_GEN_MODE = 0x2500 + + NEAREST = 0x2600 + + LINEAR_MIPMAP_LINEAR = 0x2703 + LINEAR_MIPMAP_NEAREST = 0x2701 + NEAREST_MIPMAP_LINEAR = 0x2702 + NEAREST_MIPMAP_NEAREST = 0x2700 + + GENERATE_MIPMAP = 0x8191 + TEXTURE_WRAP_R = 0x8072 + + PROXY_TEXTURE_1D = 0x8063 + PROXY_TEXTURE_2D = 0x8064 + PROXY_TEXTURE_3D = 0x8070 + TEXTURE_3D = 0x806F + TEXTURE_BASE_LEVEL = 0x813C + TEXTURE_MAX_LEVEL = 0x813D + TEXTURE_MAX_LOD = 0x813B + TEXTURE_MIN_LOD = 0x813A + + CLAMP = 0x2900 + CLAMP_TO_BORDER = 0x812D + CLAMP_TO_EDGE = 0x812F + REPEAT = 0x2901 + + VERTEX_SHADER_BIT = 0x00000001 + FRAGMENT_SHADER_BIT = 0x00000002 + GEOMETRY_SHADER_BIT = 0x00000004 + TESS_CONTROL_SHADER_BIT = 0x00000008 + TESS_EVALUATION_SHADER_BIT = 0x00000010 + COMPUTE_SHADER_BIT = 0x00000020 + ALL_SHADER_BITS = 0xFFFFFFFF + + SYNC_FLUSH_COMMANDS_BIT = 0x00000001 + INVALID_INDEX = 0xFFFFFFFF + TIMEOUT_IGNORED = 0xFFFFFFFFFFFFFFFF + CONSTANT_COLOR = 0x8001 + ONE_MINUS_CONSTANT_COLOR = 0x8002 + CONSTANT_ALPHA = 0x8003 + ONE_MINUS_CONSTANT_ALPHA = 0x8004 + FUNC_ADD = 0x8006 + MIN = 0x8007 + MAX = 0x8008 + BLEND_EQUATION_RGB = 0x8009 + FUNC_SUBTRACT = 0x800A + FUNC_REVERSE_SUBTRACT = 0x800B + RESCALE_NORMAL = 0x803A + TEXTURE_DEPTH = 0x8071 + MAX_3D_TEXTURE_SIZE = 0x8073 + MULTISAMPLE = 0x809D + SAMPLE_ALPHA_TO_COVERAGE = 0x809E + SAMPLE_ALPHA_TO_ONE = 0x809F + SAMPLE_COVERAGE = 0x80A0 + SAMPLE_BUFFERS = 0x80A8 + SAMPLES = 0x80A9 + SAMPLE_COVERAGE_VALUE = 0x80AA + SAMPLE_COVERAGE_INVERT = 0x80AB + BLEND_DST_RGB = 0x80C8 + BLEND_SRC_RGB = 0x80C9 + BLEND_DST_ALPHA = 0x80CA + BLEND_SRC_ALPHA = 0x80CB + BGR = 0x80E0 + BGRA = 0x80E1 + MAX_ELEMENTS_VERTICES = 0x80E8 + MAX_ELEMENTS_INDICES = 0x80E9 + DEPTH_COMPONENT16 = 0x81A5 + DEPTH_COMPONENT24 = 0x81A6 + DEPTH_COMPONENT32 = 0x81A7 + FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210 + FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211 + FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212 + FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213 + FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214 + FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215 + FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216 + FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217 + FRAMEBUFFER_DEFAULT = 0x8218 + FRAMEBUFFER_UNDEFINED = 0x8219 + DEPTH_STENCIL_ATTACHMENT = 0x821A + MAJOR_VERSION = 0x821B + MINOR_VERSION = 0x821C + NUM_EXTENSIONS = 0x821D + CONTEXT_FLAGS = 0x821E + INDEX = 0x8222 + COMPRESSED_RED = 0x8225 + COMPRESSED_RG = 0x8226 + RG = 0x8227 + RG_INTEGER = 0x8228 + R8 = 0x8229 + R16 = 0x822A + RG8 = 0x822B + RG16 = 0x822C + R16F = 0x822D + R32F = 0x822E + RG16F = 0x822F + RG32F = 0x8230 + R8I = 0x8231 + R8UI = 0x8232 + R16I = 0x8233 + R16UI = 0x8234 + R32I = 0x8235 + R32UI = 0x8236 + RG8I = 0x8237 + RG8UI = 0x8238 + RG16I = 0x8239 + RG16UI = 0x823A + RG32I = 0x823B + RG32UI = 0x823C + DEBUG_OUTPUT_SYNCHRONOUS = 0x8242 + DEBUG_NEXT_LOGGED_MESSAGE_LENGTH = 0x8243 + DEBUG_CALLBACK_FUNCTION = 0x8244 + DEBUG_CALLBACK_USER_PARAM = 0x8245 + DEBUG_SOURCE_API = 0x8246 + DEBUG_SOURCE_WINDOW_SYSTEM = 0x8247 + DEBUG_SOURCE_SHADER_COMPILER = 0x8248 + DEBUG_SOURCE_THIRD_PARTY = 0x8249 + DEBUG_SOURCE_APPLICATION = 0x824A + DEBUG_SOURCE_OTHER = 0x824B + DEBUG_TYPE_ERROR = 0x824C + DEBUG_TYPE_DEPRECATED_BEHAVIOR = 0x824D + DEBUG_TYPE_UNDEFINED_BEHAVIOR = 0x824E + DEBUG_TYPE_PORTABILITY = 0x824F + DEBUG_TYPE_PERFORMANCE = 0x8250 + DEBUG_TYPE_OTHER = 0x8251 + PROGRAM_SEPARABLE = 0x8258 + ACTIVE_PROGRAM = 0x8259 + PROGRAM_PIPELINE_BINDING = 0x825A + MAX_VIEWPORTS = 0x825B + VIEWPORT_SUBPIXEL_BITS = 0x825C + VIEWPORT_BOUNDS_RANGE = 0x825D + LAYER_PROVOKING_VERTEX = 0x825E + VIEWPORT_INDEX_PROVOKING_VERTEX = 0x825F + UNDEFINED_VERTEX = 0x8260 + MAX_COMPUTE_SHARED_MEMORY_SIZE = 0x8262 + MAX_COMPUTE_UNIFORM_COMPONENTS = 0x8263 + MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS = 0x8264 + MAX_COMPUTE_ATOMIC_COUNTERS = 0x8265 + MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS = 0x8266 + COMPUTE_WORK_GROUP_SIZE = 0x8267 + DEBUG_TYPE_MARKER = 0x8268 + DEBUG_TYPE_PUSH_GROUP = 0x8269 + DEBUG_TYPE_POP_GROUP = 0x826A + DEBUG_SEVERITY_NOTIFICATION = 0x826B + MAX_DEBUG_GROUP_STACK_DEPTH = 0x826C + DEBUG_GROUP_STACK_DEPTH = 0x826D + MAX_UNIFORM_LOCATIONS = 0x826E + INTERNALFORMAT_SUPPORTED = 0x826F + INTERNALFORMAT_PREFERRED = 0x8270 + INTERNALFORMAT_RED_SIZE = 0x8271 + INTERNALFORMAT_GREEN_SIZE = 0x8272 + INTERNALFORMAT_BLUE_SIZE = 0x8273 + INTERNALFORMAT_ALPHA_SIZE = 0x8274 + INTERNALFORMAT_DEPTH_SIZE = 0x8275 + INTERNALFORMAT_STENCIL_SIZE = 0x8276 + INTERNALFORMAT_SHARED_SIZE = 0x8277 + INTERNALFORMAT_RED_TYPE = 0x8278 + INTERNALFORMAT_GREEN_TYPE = 0x8279 + INTERNALFORMAT_BLUE_TYPE = 0x827A + INTERNALFORMAT_ALPHA_TYPE = 0x827B + INTERNALFORMAT_DEPTH_TYPE = 0x827C + INTERNALFORMAT_STENCIL_TYPE = 0x827D + MAX_WIDTH = 0x827E + MAX_HEIGHT = 0x827F + MAX_DEPTH = 0x8280 + MAX_LAYERS = 0x8281 + MAX_COMBINED_DIMENSIONS = 0x8282 + COLOR_COMPONENTS = 0x8283 + DEPTH_COMPONENTS = 0x8284 + STENCIL_COMPONENTS = 0x8285 + COLOR_RENDERABLE = 0x8286 + DEPTH_RENDERABLE = 0x8287 + STENCIL_RENDERABLE = 0x8288 + FRAMEBUFFER_RENDERABLE = 0x8289 + FRAMEBUFFER_RENDERABLE_LAYERED = 0x828A + FRAMEBUFFER_BLEND = 0x828B + READ_PIXELS = 0x828C + READ_PIXELS_FORMAT = 0x828D + READ_PIXELS_TYPE = 0x828E + TEXTURE_IMAGE_FORMAT = 0x828F + TEXTURE_IMAGE_TYPE = 0x8290 + GET_TEXTURE_IMAGE_FORMAT = 0x8291 + GET_TEXTURE_IMAGE_TYPE = 0x8292 + MIPMAP = 0x8293 + MANUAL_GENERATE_MIPMAP = 0x8294 + AUTO_GENERATE_MIPMAP = 0x8295 + COLOR_ENCODING = 0x8296 + SRGB_READ = 0x8297 + SRGB_WRITE = 0x8298 + FILTER = 0x829A + VERTEX_TEXTURE = 0x829B + TESS_CONTROL_TEXTURE = 0x829C + TESS_EVALUATION_TEXTURE = 0x829D + GEOMETRY_TEXTURE = 0x829E + FRAGMENT_TEXTURE = 0x829F + COMPUTE_TEXTURE = 0x82A0 + TEXTURE_SHADOW = 0x82A1 + TEXTURE_GATHER = 0x82A2 + TEXTURE_GATHER_SHADOW = 0x82A3 + SHADER_IMAGE_LOAD = 0x82A4 + SHADER_IMAGE_STORE = 0x82A5 + SHADER_IMAGE_ATOMIC = 0x82A6 + IMAGE_TEXEL_SIZE = 0x82A7 + IMAGE_COMPATIBILITY_CLASS = 0x82A8 + IMAGE_PIXEL_FORMAT = 0x82A9 + IMAGE_PIXEL_TYPE = 0x82AA + SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST = 0x82AC + SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST = 0x82AD + SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE = 0x82AE + SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE = 0x82AF + TEXTURE_COMPRESSED_BLOCK_WIDTH = 0x82B1 + TEXTURE_COMPRESSED_BLOCK_HEIGHT = 0x82B2 + TEXTURE_COMPRESSED_BLOCK_SIZE = 0x82B3 + CLEAR_BUFFER = 0x82B4 + TEXTURE_VIEW = 0x82B5 + VIEW_COMPATIBILITY_CLASS = 0x82B6 + FULL_SUPPORT = 0x82B7 + CAVEAT_SUPPORT = 0x82B8 + IMAGE_CLASS_4_X_32 = 0x82B9 + IMAGE_CLASS_2_X_32 = 0x82BA + IMAGE_CLASS_1_X_32 = 0x82BB + IMAGE_CLASS_4_X_16 = 0x82BC + IMAGE_CLASS_2_X_16 = 0x82BD + IMAGE_CLASS_1_X_16 = 0x82BE + IMAGE_CLASS_4_X_8 = 0x82BF + IMAGE_CLASS_2_X_8 = 0x82C0 + IMAGE_CLASS_1_X_8 = 0x82C1 + IMAGE_CLASS_11_11_10 = 0x82C2 + IMAGE_CLASS_10_10_10_2 = 0x82C3 + VIEW_CLASS_128_BITS = 0x82C4 + VIEW_CLASS_96_BITS = 0x82C5 + VIEW_CLASS_64_BITS = 0x82C6 + VIEW_CLASS_48_BITS = 0x82C7 + VIEW_CLASS_32_BITS = 0x82C8 + VIEW_CLASS_24_BITS = 0x82C9 + VIEW_CLASS_16_BITS = 0x82CA + VIEW_CLASS_8_BITS = 0x82CB + VIEW_CLASS_S3TC_DXT1_RGB = 0x82CC + VIEW_CLASS_S3TC_DXT1_RGBA = 0x82CD + VIEW_CLASS_S3TC_DXT3_RGBA = 0x82CE + VIEW_CLASS_S3TC_DXT5_RGBA = 0x82CF + VIEW_CLASS_RGTC1_RED = 0x82D0 + VIEW_CLASS_RGTC2_RG = 0x82D1 + VIEW_CLASS_BPTC_UNORM = 0x82D2 + VIEW_CLASS_BPTC_FLOAT = 0x82D3 + VERTEX_ATTRIB_BINDING = 0x82D4 + VERTEX_ATTRIB_RELATIVE_OFFSET = 0x82D5 + VERTEX_BINDING_DIVISOR = 0x82D6 + VERTEX_BINDING_OFFSET = 0x82D7 + VERTEX_BINDING_STRIDE = 0x82D8 + MAX_VERTEX_ATTRIB_RELATIVE_OFFSET = 0x82D9 + MAX_VERTEX_ATTRIB_BINDINGS = 0x82DA + TEXTURE_VIEW_MIN_LEVEL = 0x82DB + TEXTURE_VIEW_NUM_LEVELS = 0x82DC + TEXTURE_VIEW_MIN_LAYER = 0x82DD + TEXTURE_VIEW_NUM_LAYERS = 0x82DE + TEXTURE_IMMUTABLE_LEVELS = 0x82DF + BUFFER = 0x82E0 + SHADER = 0x82E1 + PROGRAM = 0x82E2 + QUERY = 0x82E3 + PROGRAM_PIPELINE = 0x82E4 + SAMPLER = 0x82E6 + DISPLAY_LIST = 0x82E7 + MAX_LABEL_LENGTH = 0x82E8 + NUM_SHADING_LANGUAGE_VERSIONS = 0x82E9 + UNSIGNED_BYTE_2_3_3_REV = 0x8362 + UNSIGNED_SHORT_5_6_5 = 0x8363 + UNSIGNED_SHORT_5_6_5_REV = 0x8364 + UNSIGNED_SHORT_4_4_4_4_REV = 0x8365 + UNSIGNED_SHORT_1_5_5_5_REV = 0x8366 + UNSIGNED_INT_8_8_8_8_REV = 0x8367 + UNSIGNED_INT_2_10_10_10_REV = 0x8368 + MIRRORED_REPEAT = 0x8370 + FOG_COORDINATE_SOURCE = 0x8450 + FOG_COORD_SRC = 0x8450 + FOG_COORDINATE = 0x8451 + FOG_COORD = 0x8451 + FRAGMENT_DEPTH = 0x8452 + CURRENT_FOG_COORDINATE = 0x8453 + CURRENT_FOG_COORD = 0x8453 + FOG_COORDINATE_ARRAY_TYPE = 0x8454 + FOG_COORD_ARRAY_TYPE = 0x8454 + FOG_COORDINATE_ARRAY_STRIDE = 0x8455 + FOG_COORD_ARRAY_STRIDE = 0x8455 + FOG_COORDINATE_ARRAY_POINTER = 0x8456 + FOG_COORD_ARRAY_POINTER = 0x8456 + FOG_COORDINATE_ARRAY = 0x8457 + FOG_COORD_ARRAY = 0x8457 + COLOR_SUM = 0x8458 + CURRENT_SECONDARY_COLOR = 0x8459 + SECONDARY_COLOR_ARRAY_SIZE = 0x845A + SECONDARY_COLOR_ARRAY_TYPE = 0x845B + SECONDARY_COLOR_ARRAY_STRIDE = 0x845C + SECONDARY_COLOR_ARRAY_POINTER = 0x845D + SECONDARY_COLOR_ARRAY = 0x845E + CURRENT_RASTER_SECONDARY_COLOR = 0x845F + TEXTURE0 = 0x84C0 + TEXTURE1 = 0x84C1 + TEXTURE2 = 0x84C2 + TEXTURE3 = 0x84C3 + TEXTURE4 = 0x84C4 + TEXTURE5 = 0x84C5 + TEXTURE6 = 0x84C6 + TEXTURE7 = 0x84C7 + TEXTURE8 = 0x84C8 + TEXTURE9 = 0x84C9 + TEXTURE10 = 0x84CA + TEXTURE11 = 0x84CB + TEXTURE12 = 0x84CC + TEXTURE13 = 0x84CD + TEXTURE14 = 0x84CE + TEXTURE15 = 0x84CF + TEXTURE16 = 0x84D0 + TEXTURE17 = 0x84D1 + TEXTURE18 = 0x84D2 + TEXTURE19 = 0x84D3 + TEXTURE20 = 0x84D4 + TEXTURE21 = 0x84D5 + TEXTURE22 = 0x84D6 + TEXTURE23 = 0x84D7 + TEXTURE24 = 0x84D8 + TEXTURE25 = 0x84D9 + TEXTURE26 = 0x84DA + TEXTURE27 = 0x84DB + TEXTURE28 = 0x84DC + TEXTURE29 = 0x84DD + TEXTURE30 = 0x84DE + TEXTURE31 = 0x84DF + ACTIVE_TEXTURE = 0x84E0 + CLIENT_ACTIVE_TEXTURE = 0x84E1 + MAX_TEXTURE_UNITS = 0x84E2 + TRANSPOSE_MODELVIEW_MATRIX = 0x84E3 + TRANSPOSE_PROJECTION_MATRIX = 0x84E4 + TRANSPOSE_TEXTURE_MATRIX = 0x84E5 + TRANSPOSE_COLOR_MATRIX = 0x84E6 + SUBTRACT = 0x84E7 + MAX_RENDERBUFFER_SIZE = 0x84E8 + COMPRESSED_ALPHA = 0x84E9 + COMPRESSED_LUMINANCE = 0x84EA + COMPRESSED_LUMINANCE_ALPHA = 0x84EB + COMPRESSED_INTENSITY = 0x84EC + COMPRESSED_RGB = 0x84ED + COMPRESSED_RGBA = 0x84EE + UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER = 0x84F0 + UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x84F1 + TEXTURE_RECTANGLE = 0x84F5 + TEXTURE_BINDING_RECTANGLE = 0x84F6 + PROXY_TEXTURE_RECTANGLE = 0x84F7 + MAX_RECTANGLE_TEXTURE_SIZE = 0x84F8 + DEPTH_STENCIL = 0x84F9 + UNSIGNED_INT_24_8 = 0x84FA + MAX_TEXTURE_LOD_BIAS = 0x84FD + TEXTURE_FILTER_CONTROL = 0x8500 + TEXTURE_LOD_BIAS = 0x8501 + INCR_WRAP = 0x8507 + DECR_WRAP = 0x8508 + NORMAL_MAP = 0x8511 + REFLECTION_MAP = 0x8512 + TEXTURE_CUBE_MAP = 0x8513 + TEXTURE_BINDING_CUBE_MAP = 0x8514 + TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515 + TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516 + TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517 + TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518 + TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519 + TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A + PROXY_TEXTURE_CUBE_MAP = 0x851B + MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C + COMBINE = 0x8570 + COMBINE_RGB = 0x8571 + COMBINE_ALPHA = 0x8572 + RGB_SCALE = 0x8573 + ADD_SIGNED = 0x8574 + INTERPOLATE = 0x8575 + CONSTANT = 0x8576 + PRIMARY_COLOR = 0x8577 + PREVIOUS = 0x8578 + SOURCE0_RGB = 0x8580 + SRC0_RGB = 0x8580 + SOURCE1_RGB = 0x8581 + SRC1_RGB = 0x8581 + SOURCE2_RGB = 0x8582 + SRC2_RGB = 0x8582 + SOURCE0_ALPHA = 0x8588 + SRC0_ALPHA = 0x8588 + SOURCE1_ALPHA = 0x8589 + SRC1_ALPHA = 0x8589 + SOURCE2_ALPHA = 0x858A + SRC2_ALPHA = 0x858A + OPERAND0_RGB = 0x8590 + OPERAND1_RGB = 0x8591 + OPERAND2_RGB = 0x8592 + OPERAND0_ALPHA = 0x8598 + OPERAND1_ALPHA = 0x8599 + OPERAND2_ALPHA = 0x859A + VERTEX_ARRAY_BINDING = 0x85B5 + VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622 + VERTEX_ATTRIB_ARRAY_SIZE = 0x8623 + VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624 + VERTEX_ATTRIB_ARRAY_TYPE = 0x8625 + CURRENT_VERTEX_ATTRIB = 0x8626 + VERTEX_PROGRAM_POINT_SIZE = 0x8642 + PROGRAM_POINT_SIZE = 0x8642 + VERTEX_PROGRAM_TWO_SIDE = 0x8643 + VERTEX_ATTRIB_ARRAY_POINTER = 0x8645 + DEPTH_CLAMP = 0x864F + TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0 + TEXTURE_COMPRESSED = 0x86A1 + NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2 + COMPRESSED_TEXTURE_FORMATS = 0x86A3 + DOT3_RGB = 0x86AE + DOT3_RGBA = 0x86AF + PROGRAM_BINARY_LENGTH = 0x8741 + VERTEX_ATTRIB_ARRAY_LONG = 0x874E + BUFFER_SIZE = 0x8764 + BUFFER_USAGE = 0x8765 + NUM_PROGRAM_BINARY_FORMATS = 0x87FE + PROGRAM_BINARY_FORMATS = 0x87FF + STENCIL_BACK_FUNC = 0x8800 + STENCIL_BACK_FAIL = 0x8801 + STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802 + STENCIL_BACK_PASS_DEPTH_PASS = 0x8803 + RGBA32F = 0x8814 + RGB32F = 0x8815 + RGBA16F = 0x881A + RGB16F = 0x881B + MAX_DRAW_BUFFERS = 0x8824 + DRAW_BUFFER0 = 0x8825 + DRAW_BUFFER1 = 0x8826 + DRAW_BUFFER2 = 0x8827 + DRAW_BUFFER3 = 0x8828 + DRAW_BUFFER4 = 0x8829 + DRAW_BUFFER5 = 0x882A + DRAW_BUFFER6 = 0x882B + DRAW_BUFFER7 = 0x882C + DRAW_BUFFER8 = 0x882D + DRAW_BUFFER9 = 0x882E + DRAW_BUFFER10 = 0x882F + DRAW_BUFFER11 = 0x8830 + DRAW_BUFFER12 = 0x8831 + DRAW_BUFFER13 = 0x8832 + DRAW_BUFFER14 = 0x8833 + DRAW_BUFFER15 = 0x8834 + BLEND_EQUATION_ALPHA = 0x883D + TEXTURE_DEPTH_SIZE = 0x884A + DEPTH_TEXTURE_MODE = 0x884B + TEXTURE_COMPARE_MODE = 0x884C + TEXTURE_COMPARE_FUNC = 0x884D + COMPARE_R_TO_TEXTURE = 0x884E + COMPARE_REF_TO_TEXTURE = 0x884E + TEXTURE_CUBE_MAP_SEAMLESS = 0x884F + POINT_SPRITE = 0x8861 + COORD_REPLACE = 0x8862 + QUERY_COUNTER_BITS = 0x8864 + CURRENT_QUERY = 0x8865 + QUERY_RESULT = 0x8866 + QUERY_RESULT_AVAILABLE = 0x8867 + MAX_VERTEX_ATTRIBS = 0x8869 + VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A + MAX_TESS_CONTROL_INPUT_COMPONENTS = 0x886C + MAX_TESS_EVALUATION_INPUT_COMPONENTS = 0x886D + MAX_TEXTURE_COORDS = 0x8871 + MAX_TEXTURE_IMAGE_UNITS = 0x8872 + GEOMETRY_SHADER_INVOCATIONS = 0x887F + ARRAY_BUFFER = 0x8892 + ELEMENT_ARRAY_BUFFER = 0x8893 + ARRAY_BUFFER_BINDING = 0x8894 + ELEMENT_ARRAY_BUFFER_BINDING = 0x8895 + VERTEX_ARRAY_BUFFER_BINDING = 0x8896 + NORMAL_ARRAY_BUFFER_BINDING = 0x8897 + COLOR_ARRAY_BUFFER_BINDING = 0x8898 + INDEX_ARRAY_BUFFER_BINDING = 0x8899 + TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A + EDGE_FLAG_ARRAY_BUFFER_BINDING = 0x889B + SECONDARY_COLOR_ARRAY_BUFFER_BINDING = 0x889C + FOG_COORDINATE_ARRAY_BUFFER_BINDING = 0x889D + FOG_COORD_ARRAY_BUFFER_BINDING = 0x889D + WEIGHT_ARRAY_BUFFER_BINDING = 0x889E + VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F + READ_ONLY = 0x88B8 + WRITE_ONLY = 0x88B9 + READ_WRITE = 0x88BA + BUFFER_ACCESS = 0x88BB + BUFFER_MAPPED = 0x88BC + BUFFER_MAP_POINTER = 0x88BD + TIME_ELAPSED = 0x88BF + STREAM_DRAW = 0x88E0 + STREAM_READ = 0x88E1 + STREAM_COPY = 0x88E2 + STATIC_DRAW = 0x88E4 + STATIC_READ = 0x88E5 + STATIC_COPY = 0x88E6 + DYNAMIC_DRAW = 0x88E8 + DYNAMIC_READ = 0x88E9 + DYNAMIC_COPY = 0x88EA + PIXEL_PACK_BUFFER = 0x88EB + PIXEL_UNPACK_BUFFER = 0x88EC + PIXEL_PACK_BUFFER_BINDING = 0x88ED + PIXEL_UNPACK_BUFFER_BINDING = 0x88EF + DEPTH24_STENCIL8 = 0x88F0 + TEXTURE_STENCIL_SIZE = 0x88F1 + SRC1_COLOR = 0x88F9 + ONE_MINUS_SRC1_COLOR = 0x88FA + ONE_MINUS_SRC1_ALPHA = 0x88FB + MAX_DUAL_SOURCE_DRAW_BUFFERS = 0x88FC + VERTEX_ATTRIB_ARRAY_INTEGER = 0x88FD + VERTEX_ATTRIB_ARRAY_DIVISOR = 0x88FE + MAX_ARRAY_TEXTURE_LAYERS = 0x88FF + MIN_PROGRAM_TEXEL_OFFSET = 0x8904 + MAX_PROGRAM_TEXEL_OFFSET = 0x8905 + SAMPLES_PASSED = 0x8914 + GEOMETRY_VERTICES_OUT = 0x8916 + GEOMETRY_INPUT_TYPE = 0x8917 + GEOMETRY_OUTPUT_TYPE = 0x8918 + SAMPLER_BINDING = 0x8919 + CLAMP_VERTEX_COLOR = 0x891A + CLAMP_FRAGMENT_COLOR = 0x891B + CLAMP_READ_COLOR = 0x891C + FIXED_ONLY = 0x891D + UNIFORM_BUFFER = 0x8A11 + UNIFORM_BUFFER_BINDING = 0x8A28 + UNIFORM_BUFFER_START = 0x8A29 + UNIFORM_BUFFER_SIZE = 0x8A2A + MAX_VERTEX_UNIFORM_BLOCKS = 0x8A2B + MAX_GEOMETRY_UNIFORM_BLOCKS = 0x8A2C + MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8A2D + MAX_COMBINED_UNIFORM_BLOCKS = 0x8A2E + MAX_UNIFORM_BUFFER_BINDINGS = 0x8A2F + MAX_UNIFORM_BLOCK_SIZE = 0x8A30 + MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31 + MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 0x8A32 + MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33 + UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8A34 + ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35 + ACTIVE_UNIFORM_BLOCKS = 0x8A36 + UNIFORM_TYPE = 0x8A37 + UNIFORM_SIZE = 0x8A38 + UNIFORM_NAME_LENGTH = 0x8A39 + UNIFORM_BLOCK_INDEX = 0x8A3A + UNIFORM_OFFSET = 0x8A3B + UNIFORM_ARRAY_STRIDE = 0x8A3C + UNIFORM_MATRIX_STRIDE = 0x8A3D + UNIFORM_IS_ROW_MAJOR = 0x8A3E + UNIFORM_BLOCK_BINDING = 0x8A3F + UNIFORM_BLOCK_DATA_SIZE = 0x8A40 + UNIFORM_BLOCK_NAME_LENGTH = 0x8A41 + UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8A42 + UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43 + UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44 + UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 0x8A45 + UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46 + FRAGMENT_SHADER = 0x8B30 + VERTEX_SHADER = 0x8B31 + MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49 + MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A + MAX_VARYING_FLOATS = 0x8B4B + MAX_VARYING_COMPONENTS = 0x8B4B + MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C + MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D + SHADER_TYPE = 0x8B4F + FLOAT_VEC2 = 0x8B50 + FLOAT_VEC3 = 0x8B51 + FLOAT_VEC4 = 0x8B52 + INT_VEC2 = 0x8B53 + INT_VEC3 = 0x8B54 + INT_VEC4 = 0x8B55 + BOOL = 0x8B56 + BOOL_VEC2 = 0x8B57 + BOOL_VEC3 = 0x8B58 + BOOL_VEC4 = 0x8B59 + FLOAT_MAT2 = 0x8B5A + FLOAT_MAT3 = 0x8B5B + FLOAT_MAT4 = 0x8B5C + SAMPLER_1D = 0x8B5D + SAMPLER_2D = 0x8B5E + SAMPLER_3D = 0x8B5F + SAMPLER_CUBE = 0x8B60 + SAMPLER_1D_SHADOW = 0x8B61 + SAMPLER_2D_SHADOW = 0x8B62 + SAMPLER_2D_RECT = 0x8B63 + SAMPLER_2D_RECT_SHADOW = 0x8B64 + FLOAT_MAT2x3 = 0x8B65 + FLOAT_MAT2x4 = 0x8B66 + FLOAT_MAT3x2 = 0x8B67 + FLOAT_MAT3x4 = 0x8B68 + FLOAT_MAT4x2 = 0x8B69 + FLOAT_MAT4x3 = 0x8B6A + DELETE_STATUS = 0x8B80 + COMPILE_STATUS = 0x8B81 + LINK_STATUS = 0x8B82 + VALIDATE_STATUS = 0x8B83 + INFO_LOG_LENGTH = 0x8B84 + ATTACHED_SHADERS = 0x8B85 + ACTIVE_UNIFORMS = 0x8B86 + ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87 + SHADER_SOURCE_LENGTH = 0x8B88 + ACTIVE_ATTRIBUTES = 0x8B89 + ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A + SHADING_LANGUAGE_VERSION = 0x8B8C + CURRENT_PROGRAM = 0x8B8D + IMPLEMENTATION_COLOR_READ_TYPE = 0x8B9A + IMPLEMENTATION_COLOR_READ_FORMAT = 0x8B9B + TEXTURE_RED_TYPE = 0x8C10 + TEXTURE_GREEN_TYPE = 0x8C11 + TEXTURE_BLUE_TYPE = 0x8C12 + TEXTURE_ALPHA_TYPE = 0x8C13 + TEXTURE_LUMINANCE_TYPE = 0x8C14 + TEXTURE_INTENSITY_TYPE = 0x8C15 + TEXTURE_DEPTH_TYPE = 0x8C16 + UNSIGNED_NORMALIZED = 0x8C17 + TEXTURE_1D_ARRAY = 0x8C18 + PROXY_TEXTURE_1D_ARRAY = 0x8C19 + TEXTURE_2D_ARRAY = 0x8C1A + PROXY_TEXTURE_2D_ARRAY = 0x8C1B + TEXTURE_BINDING_1D_ARRAY = 0x8C1C + TEXTURE_BINDING_2D_ARRAY = 0x8C1D + MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = 0x8C29 + TEXTURE_BUFFER = 0x8C2A + MAX_TEXTURE_BUFFER_SIZE = 0x8C2B + TEXTURE_BINDING_BUFFER = 0x8C2C + TEXTURE_BUFFER_DATA_STORE_BINDING = 0x8C2D + ANY_SAMPLES_PASSED = 0x8C2F + SAMPLE_SHADING = 0x8C36 + MIN_SAMPLE_SHADING_VALUE = 0x8C37 + R11F_G11F_B10F = 0x8C3A + UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B + RGB9_E5 = 0x8C3D + UNSIGNED_INT_5_9_9_9_REV = 0x8C3E + TEXTURE_SHARED_SIZE = 0x8C3F + SRGB = 0x8C40 + SRGB8 = 0x8C41 + SRGB_ALPHA = 0x8C42 + SRGB8_ALPHA8 = 0x8C43 + SLUMINANCE_ALPHA = 0x8C44 + SLUMINANCE8_ALPHA8 = 0x8C45 + SLUMINANCE = 0x8C46 + SLUMINANCE8 = 0x8C47 + COMPRESSED_SRGB = 0x8C48 + COMPRESSED_SRGB_ALPHA = 0x8C49 + COMPRESSED_SLUMINANCE = 0x8C4A + COMPRESSED_SLUMINANCE_ALPHA = 0x8C4B + TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76 + TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F + MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80 + TRANSFORM_FEEDBACK_VARYINGS = 0x8C83 + TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84 + TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85 + PRIMITIVES_GENERATED = 0x8C87 + TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88 + RASTERIZER_DISCARD = 0x8C89 + MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A + MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B + INTERLEAVED_ATTRIBS = 0x8C8C + SEPARATE_ATTRIBS = 0x8C8D + TRANSFORM_FEEDBACK_BUFFER = 0x8C8E + TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F + POINT_SPRITE_COORD_ORIGIN = 0x8CA0 + LOWER_LEFT = 0x8CA1 + UPPER_LEFT = 0x8CA2 + STENCIL_BACK_REF = 0x8CA3 + STENCIL_BACK_VALUE_MASK = 0x8CA4 + STENCIL_BACK_WRITEMASK = 0x8CA5 + DRAW_FRAMEBUFFER_BINDING = 0x8CA6 + FRAMEBUFFER_BINDING = 0x8CA6 + RENDERBUFFER_BINDING = 0x8CA7 + READ_FRAMEBUFFER = 0x8CA8 + DRAW_FRAMEBUFFER = 0x8CA9 + READ_FRAMEBUFFER_BINDING = 0x8CAA + RENDERBUFFER_SAMPLES = 0x8CAB + DEPTH_COMPONENT32F = 0x8CAC + DEPTH32F_STENCIL8 = 0x8CAD + FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0 + FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1 + FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2 + FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3 + FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4 + FRAMEBUFFER_COMPLETE = 0x8CD5 + FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6 + FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7 + FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB + FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC + FRAMEBUFFER_UNSUPPORTED = 0x8CDD + MAX_COLOR_ATTACHMENTS = 0x8CDF + COLOR_ATTACHMENT0 = 0x8CE0 + COLOR_ATTACHMENT1 = 0x8CE1 + COLOR_ATTACHMENT2 = 0x8CE2 + COLOR_ATTACHMENT3 = 0x8CE3 + COLOR_ATTACHMENT4 = 0x8CE4 + COLOR_ATTACHMENT5 = 0x8CE5 + COLOR_ATTACHMENT6 = 0x8CE6 + COLOR_ATTACHMENT7 = 0x8CE7 + COLOR_ATTACHMENT8 = 0x8CE8 + COLOR_ATTACHMENT9 = 0x8CE9 + COLOR_ATTACHMENT10 = 0x8CEA + COLOR_ATTACHMENT11 = 0x8CEB + COLOR_ATTACHMENT12 = 0x8CEC + COLOR_ATTACHMENT13 = 0x8CED + COLOR_ATTACHMENT14 = 0x8CEE + COLOR_ATTACHMENT15 = 0x8CEF + DEPTH_ATTACHMENT = 0x8D00 + STENCIL_ATTACHMENT = 0x8D20 + FRAMEBUFFER = 0x8D40 + RENDERBUFFER = 0x8D41 + RENDERBUFFER_WIDTH = 0x8D42 + RENDERBUFFER_HEIGHT = 0x8D43 + RENDERBUFFER_INTERNAL_FORMAT = 0x8D44 + STENCIL_INDEX1 = 0x8D46 + STENCIL_INDEX4 = 0x8D47 + STENCIL_INDEX8 = 0x8D48 + STENCIL_INDEX16 = 0x8D49 + RENDERBUFFER_RED_SIZE = 0x8D50 + RENDERBUFFER_GREEN_SIZE = 0x8D51 + RENDERBUFFER_BLUE_SIZE = 0x8D52 + RENDERBUFFER_ALPHA_SIZE = 0x8D53 + RENDERBUFFER_DEPTH_SIZE = 0x8D54 + RENDERBUFFER_STENCIL_SIZE = 0x8D55 + FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56 + MAX_SAMPLES = 0x8D57 + RGB565 = 0x8D62 + PRIMITIVE_RESTART_FIXED_INDEX = 0x8D69 + ANY_SAMPLES_PASSED_CONSERVATIVE = 0x8D6A + MAX_ELEMENT_INDEX = 0x8D6B + RGBA32UI = 0x8D70 + RGB32UI = 0x8D71 + RGBA16UI = 0x8D76 + RGB16UI = 0x8D77 + RGBA8UI = 0x8D7C + RGB8UI = 0x8D7D + RGBA32I = 0x8D82 + RGB32I = 0x8D83 + RGBA16I = 0x8D88 + RGB16I = 0x8D89 + RGBA8I = 0x8D8E + RGB8I = 0x8D8F + RED_INTEGER = 0x8D94 + GREEN_INTEGER = 0x8D95 + BLUE_INTEGER = 0x8D96 + ALPHA_INTEGER = 0x8D97 + RGB_INTEGER = 0x8D98 + RGBA_INTEGER = 0x8D99 + BGR_INTEGER = 0x8D9A + BGRA_INTEGER = 0x8D9B + INT_2_10_10_10_REV = 0x8D9F + FRAMEBUFFER_ATTACHMENT_LAYERED = 0x8DA7 + FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = 0x8DA8 + FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD + FRAMEBUFFER_SRGB = 0x8DB9 + COMPRESSED_RED_RGTC1 = 0x8DBB + COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC + COMPRESSED_RG_RGTC2 = 0x8DBD + COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE + SAMPLER_1D_ARRAY = 0x8DC0 + SAMPLER_2D_ARRAY = 0x8DC1 + SAMPLER_BUFFER = 0x8DC2 + SAMPLER_1D_ARRAY_SHADOW = 0x8DC3 + SAMPLER_2D_ARRAY_SHADOW = 0x8DC4 + SAMPLER_CUBE_SHADOW = 0x8DC5 + UNSIGNED_INT_VEC2 = 0x8DC6 + UNSIGNED_INT_VEC3 = 0x8DC7 + UNSIGNED_INT_VEC4 = 0x8DC8 + INT_SAMPLER_1D = 0x8DC9 + INT_SAMPLER_2D = 0x8DCA + INT_SAMPLER_3D = 0x8DCB + INT_SAMPLER_CUBE = 0x8DCC + INT_SAMPLER_2D_RECT = 0x8DCD + INT_SAMPLER_1D_ARRAY = 0x8DCE + INT_SAMPLER_2D_ARRAY = 0x8DCF + INT_SAMPLER_BUFFER = 0x8DD0 + UNSIGNED_INT_SAMPLER_1D = 0x8DD1 + UNSIGNED_INT_SAMPLER_2D = 0x8DD2 + UNSIGNED_INT_SAMPLER_3D = 0x8DD3 + UNSIGNED_INT_SAMPLER_CUBE = 0x8DD4 + UNSIGNED_INT_SAMPLER_2D_RECT = 0x8DD5 + UNSIGNED_INT_SAMPLER_1D_ARRAY = 0x8DD6 + UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8DD7 + UNSIGNED_INT_SAMPLER_BUFFER = 0x8DD8 + GEOMETRY_SHADER = 0x8DD9 + MAX_GEOMETRY_UNIFORM_COMPONENTS = 0x8DDF + MAX_GEOMETRY_OUTPUT_VERTICES = 0x8DE0 + MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = 0x8DE1 + ACTIVE_SUBROUTINES = 0x8DE5 + ACTIVE_SUBROUTINE_UNIFORMS = 0x8DE6 + MAX_SUBROUTINES = 0x8DE7 + MAX_SUBROUTINE_UNIFORM_LOCATIONS = 0x8DE8 + LOW_FLOAT = 0x8DF0 + MEDIUM_FLOAT = 0x8DF1 + HIGH_FLOAT = 0x8DF2 + LOW_INT = 0x8DF3 + MEDIUM_INT = 0x8DF4 + HIGH_INT = 0x8DF5 + SHADER_BINARY_FORMATS = 0x8DF8 + NUM_SHADER_BINARY_FORMATS = 0x8DF9 + SHADER_COMPILER = 0x8DFA + MAX_VERTEX_UNIFORM_VECTORS = 0x8DFB + MAX_VARYING_VECTORS = 0x8DFC + MAX_FRAGMENT_UNIFORM_VECTORS = 0x8DFD + QUERY_WAIT = 0x8E13 + QUERY_NO_WAIT = 0x8E14 + QUERY_BY_REGION_WAIT = 0x8E15 + QUERY_BY_REGION_NO_WAIT = 0x8E16 + MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E1E + MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E1F + TRANSFORM_FEEDBACK = 0x8E22 + TRANSFORM_FEEDBACK_BUFFER_PAUSED = 0x8E23 + TRANSFORM_FEEDBACK_BUFFER_ACTIVE = 0x8E24 + TRANSFORM_FEEDBACK_BINDING = 0x8E25 + TIMESTAMP = 0x8E28 + TEXTURE_SWIZZLE_R = 0x8E42 + TEXTURE_SWIZZLE_G = 0x8E43 + TEXTURE_SWIZZLE_B = 0x8E44 + TEXTURE_SWIZZLE_A = 0x8E45 + TEXTURE_SWIZZLE_RGBA = 0x8E46 + ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS = 0x8E47 + ACTIVE_SUBROUTINE_MAX_LENGTH = 0x8E48 + ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH = 0x8E49 + NUM_COMPATIBLE_SUBROUTINES = 0x8E4A + COMPATIBLE_SUBROUTINES = 0x8E4B + QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = 0x8E4C + FIRST_VERTEX_CONVENTION = 0x8E4D + LAST_VERTEX_CONVENTION = 0x8E4E + PROVOKING_VERTEX = 0x8E4F + SAMPLE_POSITION = 0x8E50 + SAMPLE_MASK = 0x8E51 + SAMPLE_MASK_VALUE = 0x8E52 + MAX_SAMPLE_MASK_WORDS = 0x8E59 + MAX_GEOMETRY_SHADER_INVOCATIONS = 0x8E5A + MIN_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5B + MAX_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5C + FRAGMENT_INTERPOLATION_OFFSET_BITS = 0x8E5D + MIN_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5E + MAX_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5F + MAX_TRANSFORM_FEEDBACK_BUFFERS = 0x8E70 + MAX_VERTEX_STREAMS = 0x8E71 + PATCH_VERTICES = 0x8E72 + PATCH_DEFAULT_INNER_LEVEL = 0x8E73 + PATCH_DEFAULT_OUTER_LEVEL = 0x8E74 + TESS_CONTROL_OUTPUT_VERTICES = 0x8E75 + TESS_GEN_MODE = 0x8E76 + TESS_GEN_SPACING = 0x8E77 + TESS_GEN_VERTEX_ORDER = 0x8E78 + TESS_GEN_POINT_MODE = 0x8E79 + ISOLINES = 0x8E7A + FRACTIONAL_ODD = 0x8E7B + FRACTIONAL_EVEN = 0x8E7C + MAX_PATCH_VERTICES = 0x8E7D + MAX_TESS_GEN_LEVEL = 0x8E7E + MAX_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E7F + MAX_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E80 + MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS = 0x8E81 + MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS = 0x8E82 + MAX_TESS_CONTROL_OUTPUT_COMPONENTS = 0x8E83 + MAX_TESS_PATCH_COMPONENTS = 0x8E84 + MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS = 0x8E85 + MAX_TESS_EVALUATION_OUTPUT_COMPONENTS = 0x8E86 + TESS_EVALUATION_SHADER = 0x8E87 + TESS_CONTROL_SHADER = 0x8E88 + MAX_TESS_CONTROL_UNIFORM_BLOCKS = 0x8E89 + MAX_TESS_EVALUATION_UNIFORM_BLOCKS = 0x8E8A + COMPRESSED_RGBA_BPTC_UNORM = 0x8E8C + COMPRESSED_SRGB_ALPHA_BPTC_UNORM = 0x8E8D + COMPRESSED_RGB_BPTC_SIGNED_FLOAT = 0x8E8E + COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT = 0x8E8F + COPY_READ_BUFFER = 0x8F36 + COPY_WRITE_BUFFER = 0x8F37 + MAX_IMAGE_UNITS = 0x8F38 + MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS = 0x8F39 + MAX_COMBINED_SHADER_OUTPUT_RESOURCES = 0x8F39 + IMAGE_BINDING_NAME = 0x8F3A + IMAGE_BINDING_LEVEL = 0x8F3B + IMAGE_BINDING_LAYERED = 0x8F3C + IMAGE_BINDING_LAYER = 0x8F3D + IMAGE_BINDING_ACCESS = 0x8F3E + DRAW_INDIRECT_BUFFER = 0x8F3F + DRAW_INDIRECT_BUFFER_BINDING = 0x8F43 + DOUBLE_MAT2 = 0x8F46 + DOUBLE_MAT3 = 0x8F47 + DOUBLE_MAT4 = 0x8F48 + DOUBLE_MAT2x3 = 0x8F49 + DOUBLE_MAT2x4 = 0x8F4A + DOUBLE_MAT3x2 = 0x8F4B + DOUBLE_MAT3x4 = 0x8F4C + DOUBLE_MAT4x2 = 0x8F4D + DOUBLE_MAT4x3 = 0x8F4E + VERTEX_BINDING_BUFFER = 0x8F4F + R8_SNORM = 0x8F94 + RG8_SNORM = 0x8F95 + RGB8_SNORM = 0x8F96 + RGBA8_SNORM = 0x8F97 + R16_SNORM = 0x8F98 + RG16_SNORM = 0x8F99 + RGB16_SNORM = 0x8F9A + RGBA16_SNORM = 0x8F9B + SIGNED_NORMALIZED = 0x8F9C + PRIMITIVE_RESTART = 0x8F9D + PRIMITIVE_RESTART_INDEX = 0x8F9E + DOUBLE_VEC2 = 0x8FFC + DOUBLE_VEC3 = 0x8FFD + DOUBLE_VEC4 = 0x8FFE + TEXTURE_CUBE_MAP_ARRAY = 0x9009 + TEXTURE_BINDING_CUBE_MAP_ARRAY = 0x900A + PROXY_TEXTURE_CUBE_MAP_ARRAY = 0x900B + SAMPLER_CUBE_MAP_ARRAY = 0x900C + SAMPLER_CUBE_MAP_ARRAY_SHADOW = 0x900D + INT_SAMPLER_CUBE_MAP_ARRAY = 0x900E + UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY = 0x900F + IMAGE_1D = 0x904C + IMAGE_2D = 0x904D + IMAGE_3D = 0x904E + IMAGE_2D_RECT = 0x904F + IMAGE_CUBE = 0x9050 + IMAGE_BUFFER = 0x9051 + IMAGE_1D_ARRAY = 0x9052 + IMAGE_2D_ARRAY = 0x9053 + IMAGE_CUBE_MAP_ARRAY = 0x9054 + IMAGE_2D_MULTISAMPLE = 0x9055 + IMAGE_2D_MULTISAMPLE_ARRAY = 0x9056 + INT_IMAGE_1D = 0x9057 + INT_IMAGE_2D = 0x9058 + INT_IMAGE_3D = 0x9059 + INT_IMAGE_2D_RECT = 0x905A + INT_IMAGE_CUBE = 0x905B + INT_IMAGE_BUFFER = 0x905C + INT_IMAGE_1D_ARRAY = 0x905D + INT_IMAGE_2D_ARRAY = 0x905E + INT_IMAGE_CUBE_MAP_ARRAY = 0x905F + INT_IMAGE_2D_MULTISAMPLE = 0x9060 + INT_IMAGE_2D_MULTISAMPLE_ARRAY = 0x9061 + UNSIGNED_INT_IMAGE_1D = 0x9062 + UNSIGNED_INT_IMAGE_2D = 0x9063 + UNSIGNED_INT_IMAGE_3D = 0x9064 + UNSIGNED_INT_IMAGE_2D_RECT = 0x9065 + UNSIGNED_INT_IMAGE_CUBE = 0x9066 + UNSIGNED_INT_IMAGE_BUFFER = 0x9067 + UNSIGNED_INT_IMAGE_1D_ARRAY = 0x9068 + UNSIGNED_INT_IMAGE_2D_ARRAY = 0x9069 + UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY = 0x906A + UNSIGNED_INT_IMAGE_2D_MULTISAMPLE = 0x906B + UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY = 0x906C + MAX_IMAGE_SAMPLES = 0x906D + IMAGE_BINDING_FORMAT = 0x906E + RGB10_A2UI = 0x906F + MIN_MAP_BUFFER_ALIGNMENT = 0x90BC + IMAGE_FORMAT_COMPATIBILITY_TYPE = 0x90C7 + IMAGE_FORMAT_COMPATIBILITY_BY_SIZE = 0x90C8 + IMAGE_FORMAT_COMPATIBILITY_BY_CLASS = 0x90C9 + MAX_VERTEX_IMAGE_UNIFORMS = 0x90CA + MAX_TESS_CONTROL_IMAGE_UNIFORMS = 0x90CB + MAX_TESS_EVALUATION_IMAGE_UNIFORMS = 0x90CC + MAX_GEOMETRY_IMAGE_UNIFORMS = 0x90CD + MAX_FRAGMENT_IMAGE_UNIFORMS = 0x90CE + MAX_COMBINED_IMAGE_UNIFORMS = 0x90CF + SHADER_STORAGE_BUFFER = 0x90D2 + SHADER_STORAGE_BUFFER_BINDING = 0x90D3 + SHADER_STORAGE_BUFFER_START = 0x90D4 + SHADER_STORAGE_BUFFER_SIZE = 0x90D5 + MAX_VERTEX_SHADER_STORAGE_BLOCKS = 0x90D6 + MAX_GEOMETRY_SHADER_STORAGE_BLOCKS = 0x90D7 + MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS = 0x90D8 + MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS = 0x90D9 + MAX_FRAGMENT_SHADER_STORAGE_BLOCKS = 0x90DA + MAX_COMPUTE_SHADER_STORAGE_BLOCKS = 0x90DB + MAX_COMBINED_SHADER_STORAGE_BLOCKS = 0x90DC + MAX_SHADER_STORAGE_BUFFER_BINDINGS = 0x90DD + MAX_SHADER_STORAGE_BLOCK_SIZE = 0x90DE + SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT = 0x90DF + DEPTH_STENCIL_TEXTURE_MODE = 0x90EA + MAX_COMPUTE_WORK_GROUP_INVOCATIONS = 0x90EB + UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER = 0x90EC + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER = 0x90ED + DISPATCH_INDIRECT_BUFFER = 0x90EE + DISPATCH_INDIRECT_BUFFER_BINDING = 0x90EF + TEXTURE_2D_MULTISAMPLE = 0x9100 + PROXY_TEXTURE_2D_MULTISAMPLE = 0x9101 + TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9102 + PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9103 + TEXTURE_BINDING_2D_MULTISAMPLE = 0x9104 + TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = 0x9105 + TEXTURE_SAMPLES = 0x9106 + TEXTURE_FIXED_SAMPLE_LOCATIONS = 0x9107 + SAMPLER_2D_MULTISAMPLE = 0x9108 + INT_SAMPLER_2D_MULTISAMPLE = 0x9109 + UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = 0x910A + SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910B + INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910C + UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910D + MAX_COLOR_TEXTURE_SAMPLES = 0x910E + MAX_DEPTH_TEXTURE_SAMPLES = 0x910F + MAX_INTEGER_SAMPLES = 0x9110 + MAX_SERVER_WAIT_TIMEOUT = 0x9111 + OBJECT_TYPE = 0x9112 + SYNC_CONDITION = 0x9113 + SYNC_STATUS = 0x9114 + SYNC_FLAGS = 0x9115 + SYNC_FENCE = 0x9116 + SYNC_GPU_COMMANDS_COMPLETE = 0x9117 + UNSIGNALED = 0x9118 + SIGNALED = 0x9119 + ALREADY_SIGNALED = 0x911A + TIMEOUT_EXPIRED = 0x911B + CONDITION_SATISFIED = 0x911C + WAIT_FAILED = 0x911D + BUFFER_ACCESS_FLAGS = 0x911F + BUFFER_MAP_LENGTH = 0x9120 + BUFFER_MAP_OFFSET = 0x9121 + MAX_VERTEX_OUTPUT_COMPONENTS = 0x9122 + MAX_GEOMETRY_INPUT_COMPONENTS = 0x9123 + MAX_GEOMETRY_OUTPUT_COMPONENTS = 0x9124 + MAX_FRAGMENT_INPUT_COMPONENTS = 0x9125 + CONTEXT_PROFILE_MASK = 0x9126 + UNPACK_COMPRESSED_BLOCK_WIDTH = 0x9127 + UNPACK_COMPRESSED_BLOCK_HEIGHT = 0x9128 + UNPACK_COMPRESSED_BLOCK_DEPTH = 0x9129 + UNPACK_COMPRESSED_BLOCK_SIZE = 0x912A + PACK_COMPRESSED_BLOCK_WIDTH = 0x912B + PACK_COMPRESSED_BLOCK_HEIGHT = 0x912C + PACK_COMPRESSED_BLOCK_DEPTH = 0x912D + PACK_COMPRESSED_BLOCK_SIZE = 0x912E + TEXTURE_IMMUTABLE_FORMAT = 0x912F + MAX_DEBUG_MESSAGE_LENGTH = 0x9143 + MAX_DEBUG_LOGGED_MESSAGES = 0x9144 + DEBUG_LOGGED_MESSAGES = 0x9145 + DEBUG_SEVERITY_HIGH = 0x9146 + DEBUG_SEVERITY_MEDIUM = 0x9147 + DEBUG_SEVERITY_LOW = 0x9148 + TEXTURE_BUFFER_OFFSET = 0x919D + TEXTURE_BUFFER_SIZE = 0x919E + TEXTURE_BUFFER_OFFSET_ALIGNMENT = 0x919F + COMPUTE_SHADER = 0x91B9 + MAX_COMPUTE_UNIFORM_BLOCKS = 0x91BB + MAX_COMPUTE_TEXTURE_IMAGE_UNITS = 0x91BC + MAX_COMPUTE_IMAGE_UNIFORMS = 0x91BD + MAX_COMPUTE_WORK_GROUP_COUNT = 0x91BE + MAX_COMPUTE_WORK_GROUP_SIZE = 0x91BF + COMPRESSED_R11_EAC = 0x9270 + COMPRESSED_SIGNED_R11_EAC = 0x9271 + COMPRESSED_RG11_EAC = 0x9272 + COMPRESSED_SIGNED_RG11_EAC = 0x9273 + COMPRESSED_RGB8_ETC2 = 0x9274 + COMPRESSED_SRGB8_ETC2 = 0x9275 + COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9276 + COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9277 + COMPRESSED_RGBA8_ETC2_EAC = 0x9278 + COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = 0x9279 + ATOMIC_COUNTER_BUFFER = 0x92C0 + ATOMIC_COUNTER_BUFFER_BINDING = 0x92C1 + ATOMIC_COUNTER_BUFFER_START = 0x92C2 + ATOMIC_COUNTER_BUFFER_SIZE = 0x92C3 + ATOMIC_COUNTER_BUFFER_DATA_SIZE = 0x92C4 + ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS = 0x92C5 + ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES = 0x92C6 + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER = 0x92C7 + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER = 0x92C8 + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x92C9 + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER = 0x92CA + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER = 0x92CB + MAX_VERTEX_ATOMIC_COUNTER_BUFFERS = 0x92CC + MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS = 0x92CD + MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS = 0x92CE + MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS = 0x92CF + MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS = 0x92D0 + MAX_COMBINED_ATOMIC_COUNTER_BUFFERS = 0x92D1 + MAX_VERTEX_ATOMIC_COUNTERS = 0x92D2 + MAX_TESS_CONTROL_ATOMIC_COUNTERS = 0x92D3 + MAX_TESS_EVALUATION_ATOMIC_COUNTERS = 0x92D4 + MAX_GEOMETRY_ATOMIC_COUNTERS = 0x92D5 + MAX_FRAGMENT_ATOMIC_COUNTERS = 0x92D6 + MAX_COMBINED_ATOMIC_COUNTERS = 0x92D7 + MAX_ATOMIC_COUNTER_BUFFER_SIZE = 0x92D8 + ACTIVE_ATOMIC_COUNTER_BUFFERS = 0x92D9 + UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX = 0x92DA + UNSIGNED_INT_ATOMIC_COUNTER = 0x92DB + MAX_ATOMIC_COUNTER_BUFFER_BINDINGS = 0x92DC + DEBUG_OUTPUT = 0x92E0 + UNIFORM = 0x92E1 + UNIFORM_BLOCK = 0x92E2 + PROGRAM_INPUT = 0x92E3 + PROGRAM_OUTPUT = 0x92E4 + BUFFER_VARIABLE = 0x92E5 + SHADER_STORAGE_BLOCK = 0x92E6 + IS_PER_PATCH = 0x92E7 + VERTEX_SUBROUTINE = 0x92E8 + TESS_CONTROL_SUBROUTINE = 0x92E9 + TESS_EVALUATION_SUBROUTINE = 0x92EA + GEOMETRY_SUBROUTINE = 0x92EB + FRAGMENT_SUBROUTINE = 0x92EC + COMPUTE_SUBROUTINE = 0x92ED + VERTEX_SUBROUTINE_UNIFORM = 0x92EE + TESS_CONTROL_SUBROUTINE_UNIFORM = 0x92EF + TESS_EVALUATION_SUBROUTINE_UNIFORM = 0x92F0 + GEOMETRY_SUBROUTINE_UNIFORM = 0x92F1 + FRAGMENT_SUBROUTINE_UNIFORM = 0x92F2 + COMPUTE_SUBROUTINE_UNIFORM = 0x92F3 + TRANSFORM_FEEDBACK_VARYING = 0x92F4 + ACTIVE_RESOURCES = 0x92F5 + MAX_NAME_LENGTH = 0x92F6 + MAX_NUM_ACTIVE_VARIABLES = 0x92F7 + MAX_NUM_COMPATIBLE_SUBROUTINES = 0x92F8 + NAME_LENGTH = 0x92F9 + TYPE = 0x92FA + ARRAY_SIZE = 0x92FB + OFFSET = 0x92FC + BLOCK_INDEX = 0x92FD + ARRAY_STRIDE = 0x92FE + MATRIX_STRIDE = 0x92FF + IS_ROW_MAJOR = 0x9300 + ATOMIC_COUNTER_BUFFER_INDEX = 0x9301 + BUFFER_BINDING = 0x9302 + BUFFER_DATA_SIZE = 0x9303 + NUM_ACTIVE_VARIABLES = 0x9304 + ACTIVE_VARIABLES = 0x9305 + REFERENCED_BY_VERTEX_SHADER = 0x9306 + REFERENCED_BY_TESS_CONTROL_SHADER = 0x9307 + REFERENCED_BY_TESS_EVALUATION_SHADER = 0x9308 + REFERENCED_BY_GEOMETRY_SHADER = 0x9309 + REFERENCED_BY_FRAGMENT_SHADER = 0x930A + REFERENCED_BY_COMPUTE_SHADER = 0x930B + TOP_LEVEL_ARRAY_SIZE = 0x930C + TOP_LEVEL_ARRAY_STRIDE = 0x930D + LOCATION = 0x930E + LOCATION_INDEX = 0x930F + FRAMEBUFFER_DEFAULT_WIDTH = 0x9310 + FRAMEBUFFER_DEFAULT_HEIGHT = 0x9311 + FRAMEBUFFER_DEFAULT_LAYERS = 0x9312 + FRAMEBUFFER_DEFAULT_SAMPLES = 0x9313 + FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS = 0x9314 + MAX_FRAMEBUFFER_WIDTH = 0x9315 + MAX_FRAMEBUFFER_HEIGHT = 0x9316 + MAX_FRAMEBUFFER_LAYERS = 0x9317 + MAX_FRAMEBUFFER_SAMPLES = 0x9318 + NUM_SAMPLE_COUNTS = 0x9380 +) + +// https://www.opengl.org/sdk/docs/man4/xhtml/glViewport.xml +func (gl *GL) Viewport(x, y, width, height int) { + C.gl4_3compat_glViewport(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// DepthRange specifies the mapping of depth values from normalized device +// coordinates to window coordinates. +// +// Parameter nearVal specifies the mapping of the near clipping plane to window +// coordinates (defaults to 0), while farVal specifies the mapping of the far +// clipping plane to window coordinates (defaults to 1). +// +// After clipping and division by w, depth coordinates range from -1 to 1, +// corresponding to the near and far clipping planes. DepthRange specifies a +// linear mapping of the normalized depth coordinates in this range to window +// depth coordinates. Regardless of the actual depth buffer implementation, +// window coordinate depth values are treated as though they range from 0 through 1 +// (like color components). Thus, the values accepted by DepthRange are both +// clamped to this range before they are accepted. +// +// The default setting of (0, 1) maps the near plane to 0 and the far plane to 1. +// With this mapping, the depth buffer range is fully utilized. +// +// It is not necessary that nearVal be less than farVal. Reverse mappings such as +// nearVal 1, and farVal 0 are acceptable. +// +// GL.INVALID_OPERATION is generated if DepthRange is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) DepthRange(nearVal, farVal float64) { + C.gl4_3compat_glDepthRange(gl.funcs, C.GLdouble(nearVal), C.GLdouble(farVal)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsEnabled.xml +func (gl *GL) IsEnabled(cap glbase.Enum) bool { + glresult := C.gl4_3compat_glIsEnabled(gl.funcs, C.GLenum(cap)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexLevelParameteriv.xml +func (gl *GL) GetTexLevelParameteriv(target glbase.Enum, level int, pname glbase.Enum, params []int32) { + C.gl4_3compat_glGetTexLevelParameteriv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexLevelParameterfv.xml +func (gl *GL) GetTexLevelParameterfv(target glbase.Enum, level int, pname glbase.Enum, params []float32) { + C.gl4_3compat_glGetTexLevelParameterfv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameteriv.xml +func (gl *GL) GetTexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_3compat_glGetTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameterfv.xml +func (gl *GL) GetTexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_3compat_glGetTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexImage.xml +func (gl *GL) GetTexImage(target glbase.Enum, level int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glGetTexImage(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetIntegerv.xml +func (gl *GL) GetIntegerv(pname glbase.Enum, params []int32) { + C.gl4_3compat_glGetIntegerv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFloatv.xml +func (gl *GL) GetFloatv(pname glbase.Enum, params []float32) { + C.gl4_3compat_glGetFloatv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetError.xml +func (gl *GL) GetError() glbase.Enum { + glresult := C.gl4_3compat_glGetError(gl.funcs) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetDoublev.xml +func (gl *GL) GetDoublev(pname glbase.Enum, params []float64) { + C.gl4_3compat_glGetDoublev(gl.funcs, C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBooleanv.xml +func (gl *GL) GetBooleanv(pname glbase.Enum, params []bool) { + C.gl4_3compat_glGetBooleanv(gl.funcs, C.GLenum(pname), (*C.GLboolean)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glReadPixels.xml +func (gl *GL) ReadPixels(x, y, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glReadPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glReadBuffer.xml +func (gl *GL) ReadBuffer(mode glbase.Enum) { + C.gl4_3compat_glReadBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelStorei.xml +func (gl *GL) PixelStorei(pname glbase.Enum, param int32) { + C.gl4_3compat_glPixelStorei(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelStoref.xml +func (gl *GL) PixelStoref(pname glbase.Enum, param float32) { + C.gl4_3compat_glPixelStoref(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDepthFunc.xml +func (gl *GL) DepthFunc(glfunc glbase.Enum) { + C.gl4_3compat_glDepthFunc(gl.funcs, C.GLenum(glfunc)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilOp.xml +func (gl *GL) StencilOp(fail, zfail, zpass glbase.Enum) { + C.gl4_3compat_glStencilOp(gl.funcs, C.GLenum(fail), C.GLenum(zfail), C.GLenum(zpass)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilFunc.xml +func (gl *GL) StencilFunc(glfunc glbase.Enum, ref int32, mask uint32) { + C.gl4_3compat_glStencilFunc(gl.funcs, C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLogicOp.xml +func (gl *GL) LogicOp(opcode glbase.Enum) { + C.gl4_3compat_glLogicOp(gl.funcs, C.GLenum(opcode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFunc.xml +func (gl *GL) BlendFunc(sfactor, dfactor glbase.Enum) { + C.gl4_3compat_glBlendFunc(gl.funcs, C.GLenum(sfactor), C.GLenum(dfactor)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFlush.xml +func (gl *GL) Flush() { + C.gl4_3compat_glFlush(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFinish.xml +func (gl *GL) Finish() { + C.gl4_3compat_glFinish(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEnable.xml +func (gl *GL) Enable(cap glbase.Enum) { + C.gl4_3compat_glEnable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDisable.xml +func (gl *GL) Disable(cap glbase.Enum) { + C.gl4_3compat_glDisable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDepthMask.xml +func (gl *GL) DepthMask(flag bool) { + C.gl4_3compat_glDepthMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorMask.xml +func (gl *GL) ColorMask(red, green, blue, alpha bool) { + C.gl4_3compat_glColorMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&red)), *(*C.GLboolean)(unsafe.Pointer(&green)), *(*C.GLboolean)(unsafe.Pointer(&blue)), *(*C.GLboolean)(unsafe.Pointer(&alpha))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilMask.xml +func (gl *GL) StencilMask(mask uint32) { + C.gl4_3compat_glStencilMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearDepth.xml +func (gl *GL) ClearDepth(depth float64) { + C.gl4_3compat_glClearDepth(gl.funcs, C.GLdouble(depth)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearStencil.xml +func (gl *GL) ClearStencil(s int32) { + C.gl4_3compat_glClearStencil(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearColor.xml +func (gl *GL) ClearColor(red, green, blue, alpha float32) { + C.gl4_3compat_glClearColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClear.xml +func (gl *GL) Clear(mask glbase.Bitfield) { + C.gl4_3compat_glClear(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawBuffer.xml +func (gl *GL) DrawBuffer(mode glbase.Enum) { + C.gl4_3compat_glDrawBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage2D.xml +func (gl *GL) TexImage2D(target glbase.Enum, level int, internalFormat int32, width, height, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage1D.xml +func (gl *GL) TexImage1D(target glbase.Enum, level int, internalFormat int32, width, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameteriv.xml +func (gl *GL) TexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_3compat_glTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameteri.xml +func (gl *GL) TexParameteri(target, pname glbase.Enum, param int32) { + C.gl4_3compat_glTexParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterfv.xml +func (gl *GL) TexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_3compat_glTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterf.xml +func (gl *GL) TexParameterf(target, pname glbase.Enum, param float32) { + C.gl4_3compat_glTexParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glScissor.xml +func (gl *GL) Scissor(x, y, width, height int) { + C.gl4_3compat_glScissor(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPolygonMode.xml +func (gl *GL) PolygonMode(face, mode glbase.Enum) { + C.gl4_3compat_glPolygonMode(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointSize.xml +func (gl *GL) PointSize(size float32) { + C.gl4_3compat_glPointSize(gl.funcs, C.GLfloat(size)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLineWidth.xml +func (gl *GL) LineWidth(width float32) { + C.gl4_3compat_glLineWidth(gl.funcs, C.GLfloat(width)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glHint.xml +func (gl *GL) Hint(target, mode glbase.Enum) { + C.gl4_3compat_glHint(gl.funcs, C.GLenum(target), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFrontFace.xml +func (gl *GL) FrontFace(mode glbase.Enum) { + C.gl4_3compat_glFrontFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCullFace.xml +func (gl *GL) CullFace(mode glbase.Enum) { + C.gl4_3compat_glCullFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexubv.xml +func (gl *GL) Indexubv(c []uint8) { + C.gl4_3compat_glIndexubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexub.xml +func (gl *GL) Indexub(c uint8) { + C.gl4_3compat_glIndexub(gl.funcs, C.GLubyte(c)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsTexture.xml +func (gl *GL) IsTexture(texture glbase.Texture) bool { + glresult := C.gl4_3compat_glIsTexture(gl.funcs, C.GLuint(texture)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenTextures returns n texture names in textures. There is no guarantee +// that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenTextures. +// +// The generated textures have no dimensionality; they assume the +// dimensionality of the texture target to which they are first bound (see +// BindTexture). +// +// Texture names returned by a call to GenTextures are not returned by +// subsequent calls, unless they are first deleted with DeleteTextures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenTextures is available in GL version 2.0 or greater. +func (gl *GL) GenTextures(n int) []glbase.Texture { + if n == 0 { + return nil + } + textures := make([]glbase.Texture, n) + C.gl4_3compat_glGenTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) + return textures +} + +// DeleteTextures deletes the textures objects whose names are stored +// in the textures slice. After a texture is deleted, it has no contents or +// dimensionality, and its name is free for reuse (for example by +// GenTextures). If a texture that is currently bound is deleted, the binding +// reverts to 0 (the default texture). +// +// DeleteTextures silently ignores 0's and names that do not correspond to +// existing textures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteTextures is available in GL version 2.0 or greater. +func (gl *GL) DeleteTextures(textures []glbase.Texture) { + n := len(textures) + if n == 0 { + return + } + C.gl4_3compat_glDeleteTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindTexture.xml +func (gl *GL) BindTexture(target glbase.Enum, texture glbase.Texture) { + C.gl4_3compat_glBindTexture(gl.funcs, C.GLenum(target), C.GLuint(texture)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexSubImage2D.xml +func (gl *GL) TexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexSubImage1D.xml +func (gl *GL) TexSubImage1D(target glbase.Enum, level, xoffset, width int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexSubImage2D.xml +func (gl *GL) CopyTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, x, y, width, height int) { + C.gl4_3compat_glCopyTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexSubImage1D.xml +func (gl *GL) CopyTexSubImage1D(target glbase.Enum, level, xoffset, x, y, width int) { + C.gl4_3compat_glCopyTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexImage2D.xml +func (gl *GL) CopyTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, height, border int) { + C.gl4_3compat_glCopyTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexImage1D.xml +func (gl *GL) CopyTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, border int) { + C.gl4_3compat_glCopyTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPolygonOffset.xml +func (gl *GL) PolygonOffset(factor, units float32) { + C.gl4_3compat_glPolygonOffset(gl.funcs, C.GLfloat(factor), C.GLfloat(units)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElements.xml +func (gl *GL) DrawElements(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glDrawElements(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawArrays.xml +func (gl *GL) DrawArrays(mode glbase.Enum, first, count int) { + C.gl4_3compat_glDrawArrays(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexSubImage3D.xml +func (gl *GL) CopyTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, x, y, width, height int) { + C.gl4_3compat_glCopyTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexSubImage3D.xml +func (gl *GL) TexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage3D.xml +func (gl *GL) TexImage3D(target glbase.Enum, level int, internalFormat int32, width, height int, depth int32, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawRangeElements.xml +func (gl *GL) DrawRangeElements(mode glbase.Enum, start, end uint32, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glDrawRangeElements(gl.funcs, C.GLenum(mode), C.GLuint(start), C.GLuint(end), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendEquation.xml +func (gl *GL) BlendEquation(mode glbase.Enum) { + C.gl4_3compat_glBlendEquation(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendColor.xml +func (gl *GL) BlendColor(red, green, blue, alpha float32) { + C.gl4_3compat_glBlendColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetCompressedTexImage.xml +func (gl *GL) GetCompressedTexImage(target glbase.Enum, level int, img interface{}) { + var img_ptr unsafe.Pointer + var img_v = reflect.ValueOf(img) + if img != nil && img_v.Kind() != reflect.Slice { + panic("parameter img must be a slice") + } + if img != nil { + img_ptr = unsafe.Pointer(img_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glGetCompressedTexImage(gl.funcs, C.GLenum(target), C.GLint(level), img_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexSubImage1D.xml +func (gl *GL) CompressedTexSubImage1D(target glbase.Enum, level, xoffset, width int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glCompressedTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexSubImage2D.xml +func (gl *GL) CompressedTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glCompressedTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexSubImage3D.xml +func (gl *GL) CompressedTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glCompressedTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexImage1D.xml +func (gl *GL) CompressedTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, width, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glCompressedTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexImage2D.xml +func (gl *GL) CompressedTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glCompressedTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexImage3D.xml +func (gl *GL) CompressedTexImage3D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height int, depth int32, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glCompressedTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSampleCoverage.xml +func (gl *GL) SampleCoverage(value float32, invert bool) { + C.gl4_3compat_glSampleCoverage(gl.funcs, C.GLfloat(value), *(*C.GLboolean)(unsafe.Pointer(&invert))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glActiveTexture.xml +func (gl *GL) ActiveTexture(texture glbase.Enum) { + C.gl4_3compat_glActiveTexture(gl.funcs, C.GLenum(texture)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointParameteriv.xml +func (gl *GL) PointParameteriv(pname glbase.Enum, params []int32) { + C.gl4_3compat_glPointParameteriv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointParameteri.xml +func (gl *GL) PointParameteri(pname glbase.Enum, param int32) { + C.gl4_3compat_glPointParameteri(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointParameterfv.xml +func (gl *GL) PointParameterfv(pname glbase.Enum, params []float32) { + C.gl4_3compat_glPointParameterfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointParameterf.xml +func (gl *GL) PointParameterf(pname glbase.Enum, param float32) { + C.gl4_3compat_glPointParameterf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiDrawArrays.xml +func (gl *GL) MultiDrawArrays(mode glbase.Enum, first, count []int, drawcount int32) { + C.gl4_3compat_glMultiDrawArrays(gl.funcs, C.GLenum(mode), (*C.GLint)(unsafe.Pointer(&first[0])), (*C.GLsizei)(unsafe.Pointer(&count[0])), C.GLsizei(drawcount)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFuncSeparate.xml +func (gl *GL) BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha glbase.Enum) { + C.gl4_3compat_glBlendFuncSeparate(gl.funcs, C.GLenum(sfactorRGB), C.GLenum(dfactorRGB), C.GLenum(sfactorAlpha), C.GLenum(dfactorAlpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBufferParameteriv.xml +func (gl *GL) GetBufferParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_3compat_glGetBufferParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUnmapBuffer.xml +func (gl *GL) UnmapBuffer(target glbase.Enum) bool { + glresult := C.gl4_3compat_glUnmapBuffer(gl.funcs, C.GLenum(target)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBufferSubData.xml +func (gl *GL) GetBufferSubData(target glbase.Enum, offset, size int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glGetBufferSubData(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(size), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBufferSubData.xml +func (gl *GL) BufferSubData(target glbase.Enum, offset, size int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glBufferSubData(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(size), data_ptr) +} + +// BufferData creates a new data store for the buffer object currently +// bound to target. Any pre-existing data store is deleted. The new data +// store is created with the specified size in bytes and usage. If data is +// not nil, it must be a slice that is used to initialize the data store. +// In that case the size parameter is ignored and the store size will match +// the slice data size. +// +// In its initial state, the new data store is not mapped, it has a NULL +// mapped pointer, and its mapped access is GL.READ_WRITE. +// +// The target constant must be one of GL.ARRAY_BUFFER, GL.COPY_READ_BUFFER, +// GL.COPY_WRITE_BUFFER, GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER, +// GL.PIXEL_UNPACK_BUFFER, GL.TEXTURE_BUFFER, GL.TRANSFORM_FEEDBACK_BUFFER, +// or GL.UNIFORM_BUFFER. +// +// The usage parameter is a hint to the GL implementation as to how a buffer +// object's data store will be accessed. This enables the GL implementation +// to make more intelligent decisions that may significantly impact buffer +// object performance. It does not, however, constrain the actual usage of +// the data store. usage can be broken down into two parts: first, the +// frequency of access (modification and usage), and second, the nature of +// that access. +// +// A usage frequency of STREAM and nature of DRAW is specified via the +// constant GL.STREAM_DRAW, for example. +// +// The usage frequency of access may be one of: +// +// STREAM +// The data store contents will be modified once and used at most a few times. +// +// STATIC +// The data store contents will be modified once and used many times. +// +// DYNAMIC +// The data store contents will be modified repeatedly and used many times. +// +// The usage nature of access may be one of: +// +// DRAW +// The data store contents are modified by the application, and used as +// the source for GL drawing and image specification commands. +// +// READ +// The data store contents are modified by reading data from the GL, +// and used to return that data when queried by the application. +// +// COPY +// The data store contents are modified by reading data from the GL, +// and used as the source for GL drawing and image specification +// commands. +// +// Clients must align data elements consistent with the requirements of the +// client platform, with an additional base-level requirement that an offset +// within a buffer to a datum comprising N bytes be a multiple of N. +// +// Error GL.INVALID_ENUM is generated if target is not one of the accepted +// buffer targets. GL.INVALID_ENUM is generated if usage is not +// GL.STREAM_DRAW, GL.STREAM_READ, GL.STREAM_COPY, GL.STATIC_DRAW, +// GL.STATIC_READ, GL.STATIC_COPY, GL.DYNAMIC_DRAW, GL.DYNAMIC_READ, or +// GL.DYNAMIC_COPY. GL.INVALID_VALUE is generated if size is negative. +// GL.INVALID_OPERATION is generated if the reserved buffer object name 0 is +// bound to target. GL.OUT_OF_MEMORY is generated if the GL is unable to +// create a data store with the specified size. +func (gl *GL) BufferData(target glbase.Enum, size int, data interface{}, usage glbase.Enum) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + if data != nil { + size = int(data_v.Type().Size()) * data_v.Len() + } + C.gl4_3compat_glBufferData(gl.funcs, C.GLenum(target), C.GLsizeiptr(size), data_ptr, C.GLenum(usage)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsBuffer.xml +func (gl *GL) IsBuffer(buffer glbase.Buffer) bool { + glresult := C.gl4_3compat_glIsBuffer(gl.funcs, C.GLuint(buffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenBuffers returns n buffer object names. There is no guarantee that +// the names form a contiguous set of integers; however, it is guaranteed +// that none of the returned names was in use immediately before the call to +// GenBuffers. +// +// Buffer object names returned by a call to GenBuffers are not returned by +// subsequent calls, unless they are first deleted with DeleteBuffers. +// +// No buffer objects are associated with the returned buffer object names +// until they are first bound by calling BindBuffer. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if GenBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// GenBuffers is available in GL version 1.5 or greater. +func (gl *GL) GenBuffers(n int) []glbase.Buffer { + if n == 0 { + return nil + } + buffers := make([]glbase.Buffer, n) + C.gl4_3compat_glGenBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) + return buffers +} + +// DeleteBuffers deletes the buffer objects whose names are stored in the +// buffers slice. +// +// After a buffer object is deleted, it has no contents, and its name is free +// for reuse (for example by GenBuffers). If a buffer object that is +// currently bound is deleted, the binding reverts to 0 (the absence of any +// buffer object, which reverts to client memory usage). +// +// DeleteBuffers silently ignores 0's and names that do not correspond to +// existing buffer objects. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if DeleteBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// DeleteBuffers is available in GL version 1.5 or greater. +func (gl *GL) DeleteBuffers(buffers []glbase.Buffer) { + n := len(buffers) + if n == 0 { + return + } + C.gl4_3compat_glDeleteBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) +} + +// BindBuffer creates or puts in use a named buffer object. +// Calling BindBuffer with target set to GL.ARRAY_BUFFER, +// GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER or GL.PIXEL_UNPACK_BUFFER +// and buffer set to the name of the new buffer object binds the buffer +// object name to the target. When a buffer object is bound to a target, the +// previous binding for that target is automatically broken. +// +// Buffer object names are unsigned integers. The value zero is reserved, but +// there is no default buffer object for each buffer object target. Instead, +// buffer set to zero effectively unbinds any buffer object previously bound, +// and restores client memory usage for that buffer object target. Buffer +// object names and the corresponding buffer object contents are local to the +// shared display-list space (see XCreateContext) of the current GL rendering +// context; two rendering contexts share buffer object names only if they +// also share display lists. +// +// GenBuffers may be called to generate a set of new buffer object names. +// +// The state of a buffer object immediately after it is first bound is an +// unmapped zero-sized memory buffer with GL.READ_WRITE access and +// GL.STATIC_DRAW usage. +// +// While a non-zero buffer object name is bound, GL operations on the target +// to which it is bound affect the bound buffer object, and queries of the +// target to which it is bound return state from the bound buffer object. +// While buffer object name zero is bound, as in the initial state, attempts +// to modify or query state on the target to which it is bound generates an +// GL.INVALID_OPERATION error. +// +// When vertex array pointer state is changed, for example by a call to +// NormalPointer, the current buffer object binding (GL.ARRAY_BUFFER_BINDING) +// is copied into the corresponding client state for the vertex array type +// being changed, for example GL.NORMAL_ARRAY_BUFFER_BINDING. While a +// non-zero buffer object is bound to the GL.ARRAY_BUFFER target, the vertex +// array pointer parameter that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.ELEMENT_ARRAY_BUFFER +// target, the indices parameter of DrawElements, DrawRangeElements, or +// MultiDrawElements that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_PACK_BUFFER +// target, the following commands are affected: GetCompressedTexImage, +// GetConvolutionFilter, GetHistogram, GetMinmax, GetPixelMap, +// GetPolygonStipple, GetSeparableFilter, GetTexImage, and ReadPixels. The +// pointer parameter that is traditionally interpreted as a pointer to +// client-side memory where the pixels are to be packed is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_UNPACK_BUFFER +// target, the following commands are affected: Bitmap, ColorSubTable, +// ColorTable, CompressedTexImage1D, CompressedTexImage2D, +// CompressedTexImage3D, CompressedTexSubImage1D, CompressedTexSubImage2D, +// CompressedTexSubImage3D, ConvolutionFilter1D, ConvolutionFilter2D, +// DrawPixels, PixelMap, PolygonStipple, SeparableFilter2D, TexImage1D, +// TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, and TexSubImage3D. +// The pointer parameter that is traditionally interpreted as a pointer to +// client-side memory from which the pixels are to be unpacked is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// A buffer object binding created with BindBuffer remains active until a +// different buffer object name is bound to the same target, or until the +// bound buffer object is deleted with DeleteBuffers. +// +// Once created, a named buffer object may be re-bound to any target as often +// as needed. However, the GL implementation may make choices about how to +// optimize the storage of a buffer object based on its initial binding +// target. +// +// Error GL.INVALID_ENUM is generated if target is not one of the allowable +// values. GL.INVALID_OPERATION is generated if BindBuffer is executed +// between the execution of Begin and the corresponding execution of End. +// +// BindBuffer is available in GL version 1.5 or greater. +func (gl *GL) BindBuffer(target glbase.Enum, buffer glbase.Buffer) { + C.gl4_3compat_glBindBuffer(gl.funcs, C.GLenum(target), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryObjectuiv.xml +func (gl *GL) GetQueryObjectuiv(id uint32, pname glbase.Enum, params []uint32) { + C.gl4_3compat_glGetQueryObjectuiv(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryObjectiv.xml +func (gl *GL) GetQueryObjectiv(id uint32, pname glbase.Enum, params []int32) { + C.gl4_3compat_glGetQueryObjectiv(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryiv.xml +func (gl *GL) GetQueryiv(target, pname glbase.Enum, params []int32) { + C.gl4_3compat_glGetQueryiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndQuery.xml +func (gl *GL) EndQuery(target glbase.Enum) { + C.gl4_3compat_glEndQuery(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBeginQuery.xml +func (gl *GL) BeginQuery(target glbase.Enum, id uint32) { + C.gl4_3compat_glBeginQuery(gl.funcs, C.GLenum(target), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsQuery.xml +func (gl *GL) IsQuery(id uint32) bool { + glresult := C.gl4_3compat_glIsQuery(gl.funcs, C.GLuint(id)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteQueries.xml +func (gl *GL) DeleteQueries(n int, ids []uint32) { + C.gl4_3compat_glDeleteQueries(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenQueries.xml +func (gl *GL) GenQueries(n int, ids []uint32) { + C.gl4_3compat_glGenQueries(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// VertexAttribPointer specifies the location and data format of the array +// of generic vertex attributes at index to use when rendering. size +// specifies the number of components per attribute and must be 1, 2, 3, or +// 4. type specifies the data type of each component, and stride specifies +// the byte stride from one attribute to the next, allowing vertices and +// attributes to be packed into a single array or stored in separate arrays. +// normalized indicates whether the values stored in an integer format are +// to be mapped to the range [-1,1] (for signed values) or [0,1] +// (for unsigned values) when they are accessed and converted to floating +// point; otherwise, values will be converted to floats directly without +// normalization. offset is a byte offset into the buffer object's data +// store, which must be bound to the GL.ARRAY_BUFFER target with BindBuffer. +// +// The buffer object binding (GL.ARRAY_BUFFER_BINDING) is saved as +// generic vertex attribute array client-side state +// (GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING) for the provided index. +// +// To enable and disable a generic vertex attribute array, call +// EnableVertexAttribArray and DisableVertexAttribArray with index. If +// enabled, the generic vertex attribute array is used when DrawArrays or +// DrawElements is called. Each generic vertex attribute array is initially +// disabled. +// +// VertexAttribPointer is typically implemented on the client side. +// +// Error GL.INVALID_ENUM is generated if type is not an accepted value. +// GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_VALUE is generated if size is not 1, 2, +// 3, or 4. GL.INVALID_VALUE is generated if stride is negative. +func (gl *GL) VertexAttribPointer(index glbase.Attrib, size int, gltype glbase.Enum, normalized bool, stride int, offset uintptr) { + offset_ptr := unsafe.Pointer(offset) + C.gl4_3compat_glVertexAttribPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLsizei(stride), offset_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glValidateProgram.xml +func (gl *GL) ValidateProgram(program glbase.Program) { + C.gl4_3compat_glValidateProgram(gl.funcs, C.GLuint(program)) +} + +// UniformMatrix4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*4) != 0 { + panic("invalid value length for UniformMatrix4fv") + } + count := len(value) / (4 * 4) + C.gl4_3compat_glUniformMatrix4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*3) != 0 { + panic("invalid value length for UniformMatrix3fv") + } + count := len(value) / (3 * 3) + C.gl4_3compat_glUniformMatrix3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*2) != 0 { + panic("invalid value length for UniformMatrix2fv") + } + count := len(value) / (2 * 2) + C.gl4_3compat_glUniformMatrix2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform4iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4iv") + } + count := len(value) / 4 + C.gl4_3compat_glUniform4iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform3iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3iv") + } + count := len(value) / 3 + C.gl4_3compat_glUniform3iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform2iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2iv") + } + count := len(value) / 2 + C.gl4_3compat_glUniform2iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform1iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl4_3compat_glUniform1iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4fv") + } + count := len(value) / 4 + C.gl4_3compat_glUniform4fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3fv") + } + count := len(value) / 3 + C.gl4_3compat_glUniform3fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2fv") + } + count := len(value) / 2 + C.gl4_3compat_glUniform2fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform1fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl4_3compat_glUniform1fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform4i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4i(location glbase.Uniform, v0, v1, v2, v3 int32) { + C.gl4_3compat_glUniform4i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2), C.GLint(v3)) +} + +// Uniform3i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3i(location glbase.Uniform, v0, v1, v2 int32) { + C.gl4_3compat_glUniform3i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2)) +} + +// Uniform2i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2i(location glbase.Uniform, v0, v1 int32) { + C.gl4_3compat_glUniform2i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1)) +} + +// Uniform1i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1i(location glbase.Uniform, v0 int32) { + C.gl4_3compat_glUniform1i(gl.funcs, C.GLint(location), C.GLint(v0)) +} + +// Uniform4f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4f(location glbase.Uniform, v0, v1, v2, v3 float32) { + C.gl4_3compat_glUniform4f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2), C.GLfloat(v3)) +} + +// Uniform3f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3f(location glbase.Uniform, v0, v1, v2 float32) { + C.gl4_3compat_glUniform3f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2)) +} + +// Uniform2f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2f(location glbase.Uniform, v0, v1 float32) { + C.gl4_3compat_glUniform2f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1)) +} + +// Uniform1f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1f(location glbase.Uniform, v0 float32) { + C.gl4_3compat_glUniform1f(gl.funcs, C.GLint(location), C.GLfloat(v0)) +} + +// UseProgram installs the program object specified by program as part of +// current rendering state. One or more executables are created in a program +// object by successfully attaching shader objects to it with AttachShader, +// successfully compiling the shader objects with CompileShader, and +// successfully linking the program object with LinkProgram. +// +// A program object will contain an executable that will run on the vertex +// processor if it contains one or more shader objects of type +// GL.VERTEX_SHADER that have been successfully compiled and linked. +// Similarly, a program object will contain an executable that will run on +// the fragment processor if it contains one or more shader objects of type +// GL.FRAGMENT_SHADER that have been successfully compiled and linked. +// +// Successfully installing an executable on a programmable processor will +// cause the corresponding fixed functionality of OpenGL to be disabled. +// Specifically, if an executable is installed on the vertex processor, the +// OpenGL fixed functionality will be disabled as follows. +// +// - The modelview matrix is not applied to vertex coordinates. +// +// - The projection matrix is not applied to vertex coordinates. +// +// - The texture matrices are not applied to texture coordinates. +// +// - Normals are not transformed to eye coordinates. +// +// - Normals are not rescaled or normalized. +// +// - Normalization of GL.AUTO_NORMAL evaluated normals is not performed. +// +// - Texture coordinates are not generated automatically. +// +// - Per-vertex lighting is not performed. +// +// - Color material computations are not performed. +// +// - Color index lighting is not performed. +// +// - This list also applies when setting the current raster position. +// +// The executable that is installed on the vertex processor is expected to +// implement any or all of the desired functionality from the preceding list. +// Similarly, if an executable is installed on the fragment processor, the +// OpenGL fixed functionality will be disabled as follows. +// +// - Texture environment and texture functions are not applied. +// +// - Texture application is not applied. +// +// - Color sum is not applied. +// +// - Fog is not applied. +// +// Again, the fragment shader that is installed is expected to implement any +// or all of the desired functionality from the preceding list. +// +// While a program object is in use, applications are free to modify attached +// shader objects, compile attached shader objects, attach additional shader +// objects, and detach or delete shader objects. None of these operations +// will affect the executables that are part of the current state. However, +// relinking the program object that is currently in use will install the +// program object as part of the current rendering state if the link +// operation was successful (see LinkProgram). If the program object +// currently in use is relinked unsuccessfully, its link status will be set +// to GL.FALSE, but the executables and associated state will remain part of +// the current state until a subsequent call to UseProgram removes it from +// use. After it is removed from use, it cannot be made part of current state +// until it has been successfully relinked. +// +// If program contains shader objects of type GL.VERTEX_SHADER but it does +// not contain shader objects of type GL.FRAGMENT_SHADER, an executable will +// be installed on the vertex processor, but fixed functionality will be used +// for fragment processing. Similarly, if program contains shader objects of +// type GL.FRAGMENT_SHADER but it does not contain shader objects of type +// GL.VERTEX_SHADER, an executable will be installed on the fragment +// processor, but fixed functionality will be used for vertex processing. If +// program is 0, the programmable processors will be disabled, and fixed +// functionality will be used for both vertex and fragment processing. +// +// While a program object is in use, the state that controls the disabled +// fixed functionality may also be updated using the normal OpenGL calls. +// +// Like display lists and texture objects, the name space for program objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// Applications are responsible for providing the synchronization across API +// calls when objects are accessed from different execution threads. +// +// Error GL.INVALID_VALUE is generated if program is neither 0 nor a value +// generated by OpenGL. GL.INVALID_OPERATION is generated if program is not +// a program object. GL.INVALID_OPERATION is generated if program could not +// be made part of current state. GL.INVALID_OPERATION is generated if +// UseProgram is executed between the execution of Begin and the +// corresponding execution of End. +// +// UseProgram is available in GL version 2.0 or greater. +func (gl *GL) UseProgram(program glbase.Program) { + C.gl4_3compat_glUseProgram(gl.funcs, C.GLuint(program)) +} + +// ShaderSource sets the source code in shader to the provided source code. Any source +// code previously stored in the shader object is completely replaced. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_VALUE is generated if count is less than 0. +// GL.INVALID_OPERATION is generated if ShaderSource is executed between the +// execution of Begin and the corresponding execution of End. +// +// ShaderSource is available in GL version 2.0 or greater. +func (gl *GL) ShaderSource(shader glbase.Shader, source ...string) { + count := len(source) + length := make([]int32, count) + source_c := make([]unsafe.Pointer, count) + for i, src := range source { + length[i] = int32(len(src)) + if len(src) > 0 { + source_c[i] = *(*unsafe.Pointer)(unsafe.Pointer(&src)) + } else { + source_c[i] = unsafe.Pointer(uintptr(0)) + } + } + C.gl4_3compat_glShaderSource(gl.funcs, C.GLuint(shader), C.GLsizei(count), (**C.GLchar)(unsafe.Pointer(&source_c[0])), (*C.GLint)(unsafe.Pointer(&length[0]))) +} + +// LinkProgram links the program object specified by program. If any shader +// objects of type GL.VERTEX_SHADER are attached to program, they will be +// used to create an executable that will run on the programmable vertex +// processor. If any shader objects of type GL.FRAGMENT_SHADER are attached +// to program, they will be used to create an executable that will run on the +// programmable fragment processor. +// +// The status of the link operation will be stored as part of the program +// object's state. This value will be set to GL.TRUE if the program object +// was linked without errors and is ready for use, and GL.FALSE otherwise. It +// can be queried by calling GetProgramiv with arguments program and +// GL.LINK_STATUS. +// +// As a result of a successful link operation, all active user-defined +// uniform variables belonging to program will be initialized to 0, and each +// of the program object's active uniform variables will be assigned a +// location that can be queried by calling GetUniformLocation. Also, any +// active user-defined attribute variables that have not been bound to a +// generic vertex attribute index will be bound to one at this time. +// +// Linking of a program object can fail for a number of reasons as specified +// in the OpenGL Shading Language Specification. The following lists some of +// the conditions that will cause a link error. +// +// - The number of active attribute variables supported by the +// implementation has been exceeded. +// +// - The storage limit for uniform variables has been exceeded. +// +// - The number of active uniform variables supported by the implementation +// has been exceeded. +// +// - The main function is missing for the vertex shader or the fragment +// shader. +// +// - A varying variable actually used in the fragment shader is not +// declared in the same way (or is not declared at all) in the vertex +// shader. +// +// - A reference to a function or variable name is unresolved. +// +// - A shared global is declared with two different types or two different +// initial values. +// +// - One or more of the attached shader objects has not been successfully +// compiled. +// +// - Binding a generic attribute matrix caused some rows of the matrix to +// fall outside the allowed maximum of GL.MAX_VERTEX_ATTRIBS. +// +// - Not enough contiguous vertex attribute slots could be found to bind +// attribute matrices. +// +// When a program object has been successfully linked, the program object can +// be made part of current state by calling UseProgram. Whether or not the +// link operation was successful, the program object's information log will +// be overwritten. The information log can be retrieved by calling +// GetProgramInfoLog. +// +// LinkProgram will also install the generated executables as part of the +// current rendering state if the link operation was successful and the +// specified program object is already currently in use as a result of a +// previous call to UseProgram. If the program object currently in use is +// relinked unsuccessfully, its link status will be set to GL.FALSE , but the +// executables and associated state will remain part of the current state +// until a subsequent call to UseProgram removes it from use. After it is +// removed from use, it cannot be made part of current state until it has +// been successfully relinked. +// +// If program contains shader objects of type GL.VERTEX_SHADER but does not +// contain shader objects of type GL.FRAGMENT_SHADER, the vertex shader will +// be linked against the implicit interface for fixed functionality fragment +// processing. Similarly, if program contains shader objects of type +// GL.FRAGMENT_SHADER but it does not contain shader objects of type +// GL.VERTEX_SHADER, the fragment shader will be linked against the implicit +// interface for fixed functionality vertex processing. +// +// The program object's information log is updated and the program is +// generated at the time of the link operation. After the link operation, +// applications are free to modify attached shader objects, compile attached +// shader objects, detach shader objects, delete shader objects, and attach +// additional shader objects. None of these operations affects the +// information log or the program that is part of the program object. +// +// If the link operation is unsuccessful, any information about a previous +// link operation on program is lost (a failed link does not restore the +// old state of program). Certain information can still be retrieved +// from program even after an unsuccessful link operation. See for instance +// GetActiveAttrib and GetActiveUniform. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if LinkProgram is executed +// between the execution of Begin and the corresponding execution of End. +// +// LinkProgram is available in GL version 2.0 or greater. +func (gl *GL) LinkProgram(program glbase.Program) { + C.gl4_3compat_glLinkProgram(gl.funcs, C.GLuint(program)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsShader.xml +func (gl *GL) IsShader(shader glbase.Shader) bool { + glresult := C.gl4_3compat_glIsShader(gl.funcs, C.GLuint(shader)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsProgram.xml +func (gl *GL) IsProgram(program glbase.Program) bool { + glresult := C.gl4_3compat_glIsProgram(gl.funcs, C.GLuint(program)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GetVertexAttribiv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribiv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribiv(index glbase.Attrib, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl4_3compat_glGetVertexAttribiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetVertexAttribfv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribfv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribfv(index glbase.Attrib, pname glbase.Enum, params []float32) { + var params_c [4]float32 + C.gl4_3compat_glGetVertexAttribfv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetVertexAttribdv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribdv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribdv(index glbase.Attrib, pname glbase.Enum, params []float64) { + var params_c [4]float64 + C.gl4_3compat_glGetVertexAttribdv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformiv returns in params the value of the specified uniform +// variable. The type of the uniform variable specified by location +// determines the number of values returned. If the uniform variable is +// defined in the shader as a boolean, int, or float, a single value will be +// returned. If it is defined as a vec2, ivec2, or bvec2, two values will be +// returned. If it is defined as a vec3, ivec3, or bvec3, three values will +// be returned, and so on. To query values stored in uniform variables +// declared as arrays, call GetUniformiv for each element of the array. To +// query values stored in uniform variables declared as structures, call +// GetUniformiv for each field in the structure. The values for uniform +// variables declared as a matrix will be returned in column major order. +// +// The locations assigned to uniform variables are not known until the +// program object is linked. After linking has occurred, the command +// GetUniformLocation can be used to obtain the location of a uniform +// variable. This location value can then be passed to GetUniformiv in order +// to query the current value of the uniform variable. After a program object +// has been linked successfully, the index values for uniform variables +// remain fixed until the next link command occurs. The uniform variable +// values can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if program has not been +// successfully linked. GL.INVALID_OPERATION is generated if location does +// not correspond to a valid uniform variable location for the specified +// program object. GL.INVALID_OPERATION is generated if GetUniformiv is +// executed between the execution of Begin and the corresponding execution of +// End. +// +// GetUniformiv is available in GL version 2.0 or greater. +func (gl *GL) GetUniformiv(program glbase.Program, location glbase.Uniform, params []int32) { + var params_c [4]int32 + C.gl4_3compat_glGetUniformiv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformfv returns in params the value of the specified uniform +// variable. The type of the uniform variable specified by location +// determines the number of values returned. If the uniform variable is +// defined in the shader as a boolean, int, or float, a single value will be +// returned. If it is defined as a vec2, ivec2, or bvec2, two values will be +// returned. If it is defined as a vec3, ivec3, or bvec3, three values will +// be returned, and so on. To query values stored in uniform variables +// declared as arrays, call GetUniformfv for each element of the array. To +// query values stored in uniform variables declared as structures, call +// GetUniformfv for each field in the structure. The values for uniform +// variables declared as a matrix will be returned in column major order. +// +// The locations assigned to uniform variables are not known until the +// program object is linked. After linking has occurred, the command +// GetUniformLocation can be used to obtain the location of a uniform +// variable. This location value can then be passed to GetUniformfv in order +// to query the current value of the uniform variable. After a program object +// has been linked successfully, the index values for uniform variables +// remain fixed until the next link command occurs. The uniform variable +// values can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if program has not been +// successfully linked. GL.INVALID_OPERATION is generated if location does +// not correspond to a valid uniform variable location for the specified +// program object. GL.INVALID_OPERATION is generated if GetUniformfv is +// executed between the execution of Begin and the corresponding execution of +// End. +// +// GetUniformfv is available in GL version 2.0 or greater. +func (gl *GL) GetUniformfv(program glbase.Program, location glbase.Uniform, params []float32) { + var params_c [4]float32 + C.gl4_3compat_glGetUniformfv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLfloat)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformLocation returns an integer that represents the location of a +// specific uniform variable within a program object. name must be an active +// uniform variable name in program that is not a structure, an array of +// structures, or a subcomponent of a vector or a matrix. This function +// returns -1 if name does not correspond to an active uniform variable in +// program or if name starts with the reserved prefix "gl_". +// +// Uniform variables that are structures or arrays of structures may be +// queried by calling GetUniformLocation for each field within the +// structure. The array element operator "[]" and the structure field +// operator "." may be used in name in order to select elements within an +// array or fields within a structure. The result of using these operators is +// not allowed to be another structure, an array of structures, or a +// subcomponent of a vector or a matrix. Except if the last part of name +// indicates a uniform variable array, the location of the first element of +// an array can be retrieved by using the name of the array, or by using the +// name appended by "[0]". +// +// The actual locations assigned to uniform variables are not known until the +// program object is linked successfully. After linking has occurred, the +// command GetUniformLocation can be used to obtain the location of a +// uniform variable. This location value can then be passed to Uniform to +// set the value of the uniform variable or to GetUniform in order to query +// the current value of the uniform variable. After a program object has been +// linked successfully, the index values for uniform variables remain fixed +// until the next link command occurs. Uniform variable locations and values +// can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program object. +// GL.INVALID_OPERATION is generated if program has not been successfully +// linked. GL.INVALID_OPERATION is generated if GetUniformLocation is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetUniformLocation is available in GL version 2.0 or greater. +func (gl *GL) GetUniformLocation(program glbase.Program, name string) glbase.Uniform { + name_cstr := C.CString(name) + glresult := C.gl4_3compat_glGetUniformLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) + return glbase.Uniform(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetShaderSource.xml +func (gl *GL) GetShaderSource(shader glbase.Shader, bufSize int32, length []int32, source []byte) { + C.gl4_3compat_glGetShaderSource(gl.funcs, C.GLuint(shader), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&source[0]))) +} + +// GetShaderInfoLog returns the information log for the specified shader +// object. The information log for a shader object is modified when the +// shader is compiled. +// +// The information log for a shader object is a string that may contain +// diagnostic messages, warning messages, and other information about the +// last compile operation. When a shader object is created, its information +// log will be a string of length 0, and the size of the current log can be +// obtained by calling GetShaderiv with the value GL.INFO_LOG_LENGTH. +// +// The information log for a shader object is the OpenGL implementer's +// primary mechanism for conveying information about the compilation process. +// Therefore, the information log can be helpful to application developers +// during the development process, even when compilation is successful. +// Application developers should not expect different OpenGL implementations +// to produce identical information logs. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_VALUE is generated if maxLength is less than 0. +// GL.INVALID_OPERATION is generated if GetShaderInfoLog is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetShaderInfoLog is available in GL version 2.0 or greater. +func (gl *GL) GetShaderInfoLog(shader glbase.Shader) []byte { + var params [1]int32 + var length int32 + gl.GetShaderiv(shader, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + C.gl4_3compat_glGetShaderInfoLog(gl.funcs, C.GLuint(shader), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length)), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) + return infoLog +} + +// GetShaderiv GetShader returns in params the value of a parameter for a specific +// shader object. The following parameters are defined: +// +// GL.SHADER_TYPE +// params returns GL.VERTEX_SHADER if shader is a vertex shader object, +// and GL.FRAGMENT_SHADER if shader is a fragment shader object. +// +// GL.DELETE_STATUS +// params returns GL.TRUE if shader is currently flagged for deletion, +// and GL.FALSE otherwise. +// +// GL.COMPILE_STATUS +// params returns GL.TRUE if the last compile operation on shader was +// successful, and GL.FALSE otherwise. +// +// GL.INFO_LOG_LENGTH +// params returns the number of characters in the information log for +// shader including the null termination character (the size of the +// character buffer required to store the information log). If shader has +// no information log, a value of 0 is returned. +// +// GL.SHADER_SOURCE_LENGTH +// params returns the length of the concatenation of the source strings +// that make up the shader source for the shader, including the null +// termination character. (the size of the character buffer +// required to store the shader source). If no source code exists, 0 is +// returned. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader does not refer to a +// shader object. GL.INVALID_ENUM is generated if pname is not an accepted +// value. GL.INVALID_OPERATION is generated if GetShader is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetShaderiv is available in GL version 2.0 or greater. +func (gl *GL) GetShaderiv(shader glbase.Shader, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl4_3compat_glGetShaderiv(gl.funcs, C.GLuint(shader), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetProgramInfoLog returns the information log for the specified program +// object. The information log for a program object is modified when the +// program object is linked or validated. +// +// The information log for a program object is either an empty string, or a +// string containing information about the last link operation, or a string +// containing information about the last validation operation. It may contain +// diagnostic messages, warning messages, and other information. When a +// program object is created, its information log will be a string of length +// 0, and the size of the current log can be obtained by calling GetProgramiv +// with the value GL.INFO_LOG_LENGTH. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated +// by OpenGL. GL.INVALID_OPERATION is generated if program is not a +// program object. +func (gl *GL) GetProgramInfoLog(program glbase.Program) []byte { + var params [1]int32 + var length int32 + gl.GetProgramiv(program, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + C.gl4_3compat_glGetProgramInfoLog(gl.funcs, C.GLuint(program), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length)), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) + return infoLog +} + +// GetProgramiv returns in params the value of a parameter for a specific +// program object. The following parameters are defined: +// +// GL.DELETE_STATUS +// params returns GL.TRUE if program is currently flagged for deletion, +// and GL.FALSE otherwise. +// +// GL.LINK_STATUS +// params returns GL.TRUE if the last link operation on program was +// successful, and GL.FALSE otherwise. +// +// GL.VALIDATE_STATUS +// params returns GL.TRUE or if the last validation operation on +// program was successful, and GL.FALSE otherwise. +// +// GL.INFO_LOG_LENGTH +// params returns the number of characters in the information log for +// program including the null termination character (the size of +// the character buffer required to store the information log). If +// program has no information log, a value of 0 is returned. +// +// GL.ATTACHED_SHADERS +// params returns the number of shader objects attached to program. +// +// GL.ACTIVE_ATTRIBUTES +// params returns the number of active attribute variables for program. +// +// GL.ACTIVE_ATTRIBUTE_MAX_LENGTH +// params returns the length of the longest active attribute name for +// program, including the null termination character (the size of +// the character buffer required to store the longest attribute name). +// If no active attributes exist, 0 is returned. +// +// GL.ACTIVE_UNIFORMS +// params returns the number of active uniform variables for program. +// +// GL.ACTIVE_UNIFORM_MAX_LENGTH +// params returns the length of the longest active uniform variable +// name for program, including the null termination character (i.e., +// the size of the character buffer required to store the longest +// uniform variable name). If no active uniform variables exist, 0 is +// returned. +// +// GL.TRANSFORM_FEEDBACK_BUFFER_MODE +// params returns a symbolic constant indicating the buffer mode used +// when transform feedback is active. This may be GL.SEPARATE_ATTRIBS +// or GL.INTERLEAVED_ATTRIBS. +// +// GL.TRANSFORM_FEEDBACK_VARYINGS +// params returns the number of varying variables to capture in transform +// feedback mode for the program. +// +// GL.TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH +// params returns the length of the longest variable name to be used for +// transform feedback, including the null-terminator. +// +// GL.GEOMETRY_VERTICES_OUT +// params returns the maximum number of vertices that the geometry shader in +// program will output. +// +// GL.GEOMETRY_INPUT_TYPE +// params returns a symbolic constant indicating the primitive type accepted +// as input to the geometry shader contained in program. +// +// GL.GEOMETRY_OUTPUT_TYPE +// params returns a symbolic constant indicating the primitive type that will +// be output by the geometry shader contained in program. +// +// GL.ACTIVE_UNIFORM_BLOCKS and GL.ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH are +// available only if the GL version 3.1 or greater. +// +// GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE and +// GL.GEOMETRY_OUTPUT_TYPE are accepted only if the GL version is 3.2 or +// greater. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program does not refer to a +// program object. GL.INVALID_OPERATION is generated if pname is +// GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE, or +// GL.GEOMETRY_OUTPUT_TYPE, and program does not contain a geometry shader. +// GL.INVALID_ENUM is generated if pname is not an accepted value. +func (gl *GL) GetProgramiv(program glbase.Program, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl4_3compat_glGetProgramiv(gl.funcs, C.GLuint(program), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetAttribLocation queries the previously linked program object specified +// by program for the attribute variable specified by name and returns the +// index of the generic vertex attribute that is bound to that attribute +// variable. If name is a matrix attribute variable, the index of the first +// column of the matrix is returned. If the named attribute variable is not +// an active attribute in the specified program object or if name starts with +// the reserved prefix "gl_", a value of -1 is returned. +// +// The association between an attribute variable name and a generic attribute +// index can be specified at any time by calling BindAttribLocation. +// Attribute bindings do not go into effect until LinkProgram is called. +// After a program object has been linked successfully, the index values for +// attribute variables remain fixed until the next link command occurs. The +// attribute values can only be queried after a link if the link was +// successful. GetAttribLocation returns the binding that actually went +// into effect the last time LinkProgram was called for the specified +// program object. Attribute bindings that have been specified since the last +// link operation are not returned by GetAttribLocation. +// +// Error GL_INVALID_OPERATION is generated if program is not a value +// generated by OpenGL. GL_INVALID_OPERATION is generated if program is not +// a program object. GL_INVALID_OPERATION is generated if program has not +// been successfully linked. GL_INVALID_OPERATION is generated if +// GetAttribLocation is executed between the execution of Begin and the +// corresponding execution of End. +// +// GetAttribLocation is available in GL version 2.0 or greater. +func (gl *GL) GetAttribLocation(program glbase.Program, name string) glbase.Attrib { + name_cstr := C.CString(name) + glresult := C.gl4_3compat_glGetAttribLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) + return glbase.Attrib(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetAttachedShaders.xml +func (gl *GL) GetAttachedShaders(program glbase.Program, maxCount int32, count []int, obj []uint32) { + C.gl4_3compat_glGetAttachedShaders(gl.funcs, C.GLuint(program), C.GLsizei(maxCount), (*C.GLsizei)(unsafe.Pointer(&count[0])), (*C.GLuint)(unsafe.Pointer(&obj[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniform.xml +func (gl *GL) GetActiveUniform(program glbase.Program, index uint32, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl4_3compat_glGetActiveUniform(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveAttrib.xml +func (gl *GL) GetActiveAttrib(program glbase.Program, index glbase.Attrib, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl4_3compat_glGetActiveAttrib(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEnableVertexAttribArray.xml +func (gl *GL) EnableVertexAttribArray(index glbase.Attrib) { + C.gl4_3compat_glEnableVertexAttribArray(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDisableVertexAttribArray.xml +func (gl *GL) DisableVertexAttribArray(index glbase.Attrib) { + C.gl4_3compat_glDisableVertexAttribArray(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDetachShader.xml +func (gl *GL) DetachShader(program glbase.Program, shader glbase.Shader) { + C.gl4_3compat_glDetachShader(gl.funcs, C.GLuint(program), C.GLuint(shader)) +} + +// DeleteShader frees the memory and invalidates the name associated with +// the shader object specified by shader. This command effectively undoes the +// effects of a call to CreateShader. +// +// If a shader object to be deleted is attached to a program object, it will +// be flagged for deletion, but it will not be deleted until it is no longer +// attached to any program object, for any rendering context (it must +// be detached from wherever it was attached before it will be deleted). A +// value of 0 for shader will be silently ignored. +// +// To determine whether an object has been flagged for deletion, call +// GetShader with arguments shader and GL.DELETE_STATUS. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. +// +// DeleteShader is available in GL version 2.0 or greater. +func (gl *GL) DeleteShader(shader glbase.Shader) { + C.gl4_3compat_glDeleteShader(gl.funcs, C.GLuint(shader)) +} + +// DeleteProgram frees the memory and invalidates the name associated with +// the program object specified by program. This command effectively undoes +// the effects of a call to CreateProgram. +// +// If a program object is in use as part of current rendering state, it will +// be flagged for deletion, but it will not be deleted until it is no longer +// part of current state for any rendering context. If a program object to be +// deleted has shader objects attached to it, those shader objects will be +// automatically detached but not deleted unless they have already been +// flagged for deletion by a previous call to DeleteShader. A value of 0 +// for program will be silently ignored. +// +// To determine whether a program object has been flagged for deletion, call +// GetProgram with arguments program and GL.DELETE_STATUS. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. +// +// DeleteProgram is available in GL version 2.0 or greater. +func (gl *GL) DeleteProgram(program glbase.Program) { + C.gl4_3compat_glDeleteProgram(gl.funcs, C.GLuint(program)) +} + +// CreateShader creates an empty shader object and returns a non-zero value +// by which it can be referenced. A shader object is used to maintain the +// source code strings that define a shader. shaderType indicates the type of +// shader to be created. +// +// Two types of shaders are supported. A shader of type GL.VERTEX_SHADER is a +// shader that is intended to run on the programmable vertex processor and +// replace the fixed functionality vertex processing in OpenGL. A shader of +// type GL.FRAGMENT_SHADER is a shader that is intended to run on the +// programmable fragment processor and replace the fixed functionality +// fragment processing in OpenGL. +// +// When created, a shader object's GL.SHADER_TYPE parameter is set to either +// GL.VERTEX_SHADER or GL.FRAGMENT_SHADER, depending on the value of +// shaderType. +// +// Like display lists and texture objects, the name space for shader objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// This function returns 0 if an error occurs creating the shader object. +// +// Error GL.INVALID_ENUM is generated if shaderType is not an accepted value. +// GL.INVALID_OPERATION is generated if CreateShader is executed between the +// execution of Begin and the corresponding execution of End. +// +// CreateShader is available in GL version 2.0 or greater. +func (gl *GL) CreateShader(gltype glbase.Enum) glbase.Shader { + glresult := C.gl4_3compat_glCreateShader(gl.funcs, C.GLenum(gltype)) + return glbase.Shader(glresult) +} + +// CreateProgram creates an empty program object and returns a non-zero +// value by which it can be referenced. A program object is an object to +// which shader objects can be attached. This provides a mechanism to specify +// the shader objects that will be linked to create a program. It also +// provides a means for checking the compatibility of the shaders that will +// be used to create a program (for instance, checking the compatibility +// between a vertex shader and a fragment shader). When no longer needed as +// part of a program object, shader objects can be detached. +// +// One or more executables are created in a program object by successfully +// attaching shader objects to it with AttachShader, successfully compiling +// the shader objects with CompileShader, and successfully linking the +// program object with LinkProgram. These executables are made part of +// current state when UseProgram is called. Program objects can be deleted +// by calling DeleteProgram. The memory associated with the program object +// will be deleted when it is no longer part of current rendering state for +// any context. +// +// Like display lists and texture objects, the name space for program objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// Applications are responsible for providing the synchronization across API +// calls when objects are accessed from different execution threads. +// +// This function returns 0 if an error occurs creating the program object. +// +// Error GL.INVALID_OPERATION is generated if CreateProgram is executed +// between the execution of Begin and the corresponding execution of End. +// +// CreateProgram is available in GL version 2.0 or greater. +func (gl *GL) CreateProgram() glbase.Program { + glresult := C.gl4_3compat_glCreateProgram(gl.funcs) + return glbase.Program(glresult) +} + +// CompileShader compiles the source code strings that have been stored in +// the shader object specified by shader. +// +// The compilation status will be stored as part of the shader object's +// state. This value will be set to GL.TRUE if the shader was compiled without +// errors and is ready for use, and GL.FALSE otherwise. It can be queried by +// calling GetShaderiv with arguments shader and GL.COMPILE_STATUS. +// +// Compilation of a shader can fail for a number of reasons as specified by +// the OpenGL Shading Language Specification. Whether or not the compilation +// was successful, information about the compilation can be obtained from the +// shader object's information log by calling GetShaderInfoLog. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_OPERATION is generated if CompileShader is executed +// between the execution of Begin and the corresponding execution of End. +// +// CompileShader is available in GL version 2.0 or greater. +func (gl *GL) CompileShader(shader glbase.Shader) { + C.gl4_3compat_glCompileShader(gl.funcs, C.GLuint(shader)) +} + +// BindAttribLocation associates a user-defined attribute variable in the program +// object specified by program with a generic vertex attribute index. The name +// parameter specifies the name of the vertex shader attribute variable to +// which index is to be bound. When program is made part of the current state, +// values provided via the generic vertex attribute index will modify the +// value of the user-defined attribute variable specified by name. +// +// If name refers to a matrix attribute variable, index refers to the first +// column of the matrix. Other matrix columns are then automatically bound to +// locations index+1 for a matrix of type mat2; index+1 and index+2 for a +// matrix of type mat3; and index+1, index+2, and index+3 for a matrix of +// type mat4. +// +// This command makes it possible for vertex shaders to use descriptive names +// for attribute variables rather than generic variables that are numbered +// from 0 to GL.MAX_VERTEX_ATTRIBS-1. The values sent to each generic +// attribute index are part of current state, just like standard vertex +// attributes such as color, normal, and vertex position. If a different +// program object is made current by calling UseProgram, the generic vertex +// attributes are tracked in such a way that the same values will be observed +// by attributes in the new program object that are also bound to index. +// +// Attribute variable name-to-generic attribute index bindings for a program +// object can be explicitly assigned at any time by calling +// BindAttribLocation. Attribute bindings do not go into effect until +// LinkProgram is called. After a program object has been linked +// successfully, the index values for generic attributes remain fixed (and +// their values can be queried) until the next link command occurs. +// +// Applications are not allowed to bind any of the standard OpenGL vertex +// attributes using this command, as they are bound automatically when +// needed. Any attribute binding that occurs after the program object has +// been linked will not take effect until the next time the program object is +// linked. +// +// If name was bound previously, that information is lost. Thus you cannot +// bind one user-defined attribute variable to multiple indices, but you can +// bind multiple user-defined attribute variables to the same index. +// +// Applications are allowed to bind more than one user-defined attribute +// variable to the same generic vertex attribute index. This is called +// aliasing, and it is allowed only if just one of the aliased attributes is +// active in the executable program, or if no path through the shader +// consumes more than one attribute of a set of attributes aliased to the +// same location. The compiler and linker are allowed to assume that no +// aliasing is done and are free to employ optimizations that work only in +// the absence of aliasing. OpenGL implementations are not required to do +// error checking to detect aliasing. Because there is no way to bind +// standard attributes, it is not possible to alias generic attributes with +// conventional ones (except for generic attribute 0). +// +// BindAttribLocation can be called before any vertex shader objects are +// bound to the specified program object. It is also permissible to bind a +// generic attribute index to an attribute variable name that is never used +// in a vertex shader. +// +// Active attributes that are not explicitly bound will be bound by the +// linker when LinkProgram is called. The locations assigned can be queried +// by calling GetAttribLocation. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. +// GL.INVALID_OPERATION is generated if name starts with the reserved prefix "gl_". +// GL.INVALID_VALUE is generated if program is not a value generated by OpenGL. +// GL.INVALID_OPERATION is generated if program is not a program object. +// GL.INVALID_OPERATION is generated if BindAttribLocation is executed +// between the execution of Begin and the corresponding execution of End. +// +// BindAttribLocation is available in GL version 2.0 or greater. +func (gl *GL) BindAttribLocation(program glbase.Program, index glbase.Attrib, name string) { + name_cstr := C.CString(name) + C.gl4_3compat_glBindAttribLocation(gl.funcs, C.GLuint(program), C.GLuint(index), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) +} + +// AttachShader attaches a shader object to a program object. +// +// In order to create an executable, there must be a way to specify the list +// of things that will be linked together. Program objects provide this +// mechanism. Shaders that are to be linked together in a program object must +// first be attached to that program object. This indicates that shader will +// be included in link operations that will be performed on program. +// +// All operations that can be performed on a shader object are valid whether +// or not the shader object is attached to a program object. It is +// permissible to attach a shader object to a program object before source +// code has been loaded into the shader object or before the shader object +// has been compiled. It is permissible to attach multiple shader objects of +// the same type because each may contain a portion of the complete shader. +// It is also permissible to attach a shader object to more than one program +// object. If a shader object is deleted while it is attached to a program +// object, it will be flagged for deletion, and deletion will not occur until +// DetachShader is called to detach it from all program objects to which it +// is attached. +// +// Error GL.INVALID_VALUE is generated if either program or shader is not a +// value generated by OpenGL. GL.INVALID_OPERATION is generated if program +// is not a program object. GL.INVALID_OPERATION is generated if shader is +// not a shader object. GL.INVALID_OPERATION is generated if shader is +// already attached to program. GL.INVALID_OPERATION is generated if +// AttachShader is executed between the execution of Begin and the +// corresponding execution of End. +// +// AttachShader is available in GL version 2.0 or greater. +func (gl *GL) AttachShader(program glbase.Program, shader glbase.Shader) { + C.gl4_3compat_glAttachShader(gl.funcs, C.GLuint(program), C.GLuint(shader)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilMaskSeparate.xml +func (gl *GL) StencilMaskSeparate(face glbase.Enum, mask uint32) { + C.gl4_3compat_glStencilMaskSeparate(gl.funcs, C.GLenum(face), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilFuncSeparate.xml +func (gl *GL) StencilFuncSeparate(face, glfunc glbase.Enum, ref int32, mask uint32) { + C.gl4_3compat_glStencilFuncSeparate(gl.funcs, C.GLenum(face), C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilOpSeparate.xml +func (gl *GL) StencilOpSeparate(face, sfail, dpfail, dppass glbase.Enum) { + C.gl4_3compat_glStencilOpSeparate(gl.funcs, C.GLenum(face), C.GLenum(sfail), C.GLenum(dpfail), C.GLenum(dppass)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawBuffers.xml +func (gl *GL) DrawBuffers(n int, bufs []glbase.Enum) { + C.gl4_3compat_glDrawBuffers(gl.funcs, C.GLsizei(n), (*C.GLenum)(unsafe.Pointer(&bufs[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendEquationSeparate.xml +func (gl *GL) BlendEquationSeparate(modeRGB, modeAlpha glbase.Enum) { + C.gl4_3compat_glBlendEquationSeparate(gl.funcs, C.GLenum(modeRGB), C.GLenum(modeAlpha)) +} + +// UniformMatrix4x3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4x3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4x3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*3) != 0 { + panic("invalid value length for UniformMatrix4x3fv") + } + count := len(value) / (4 * 3) + C.gl4_3compat_glUniformMatrix4x3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3x4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3x4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3x4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*4) != 0 { + panic("invalid value length for UniformMatrix3x4fv") + } + count := len(value) / (3 * 4) + C.gl4_3compat_glUniformMatrix3x4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix4x2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4x2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4x2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*2) != 0 { + panic("invalid value length for UniformMatrix4x2fv") + } + count := len(value) / (4 * 2) + C.gl4_3compat_glUniformMatrix4x2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2x4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2x4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2x4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*4) != 0 { + panic("invalid value length for UniformMatrix2x4fv") + } + count := len(value) / (2 * 4) + C.gl4_3compat_glUniformMatrix2x4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3x2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3x2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3x2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*2) != 0 { + panic("invalid value length for UniformMatrix3x2fv") + } + count := len(value) / (3 * 2) + C.gl4_3compat_glUniformMatrix3x2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2x3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2x3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2x3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*3) != 0 { + panic("invalid value length for UniformMatrix2x3fv") + } + count := len(value) / (2 * 3) + C.gl4_3compat_glUniformMatrix2x3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsVertexArray.xml +func (gl *GL) IsVertexArray(array uint32) bool { + glresult := C.gl4_3compat_glIsVertexArray(gl.funcs, C.GLuint(array)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenVertexArrays.xml +func (gl *GL) GenVertexArrays(n int, arrays []uint32) { + C.gl4_3compat_glGenVertexArrays(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&arrays[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteVertexArrays.xml +func (gl *GL) DeleteVertexArrays(n int, arrays []uint32) { + C.gl4_3compat_glDeleteVertexArrays(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&arrays[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindVertexArray.xml +func (gl *GL) BindVertexArray(array uint32) { + C.gl4_3compat_glBindVertexArray(gl.funcs, C.GLuint(array)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFlushMappedBufferRange.xml +func (gl *GL) FlushMappedBufferRange(target glbase.Enum, offset, length int) { + C.gl4_3compat_glFlushMappedBufferRange(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(length)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTextureLayer.xml +func (gl *GL) FramebufferTextureLayer(target, attachment glbase.Enum, texture glbase.Texture, level int, layer int32) { + C.gl4_3compat_glFramebufferTextureLayer(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLuint(texture), C.GLint(level), C.GLint(layer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRenderbufferStorageMultisample.xml +func (gl *GL) RenderbufferStorageMultisample(target glbase.Enum, samples int32, internalFormat glbase.Enum, width, height int) { + C.gl4_3compat_glRenderbufferStorageMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlitFramebuffer.xml +func (gl *GL) BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1 int32, mask glbase.Bitfield, filter glbase.Enum) { + C.gl4_3compat_glBlitFramebuffer(gl.funcs, C.GLint(srcX0), C.GLint(srcY0), C.GLint(srcX1), C.GLint(srcY1), C.GLint(dstX0), C.GLint(dstY0), C.GLint(dstX1), C.GLint(dstY1), C.GLbitfield(mask), C.GLenum(filter)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenerateMipmap.xml +func (gl *GL) GenerateMipmap(target glbase.Enum) { + C.gl4_3compat_glGenerateMipmap(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFramebufferAttachmentParameteriv.xml +func (gl *GL) GetFramebufferAttachmentParameteriv(target, attachment, pname glbase.Enum, params []int32) { + C.gl4_3compat_glGetFramebufferAttachmentParameteriv(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferRenderbuffer.xml +func (gl *GL) FramebufferRenderbuffer(target, attachment, renderbuffertarget glbase.Enum, renderbuffer glbase.Renderbuffer) { + C.gl4_3compat_glFramebufferRenderbuffer(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(renderbuffertarget), C.GLuint(renderbuffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture3D.xml +func (gl *GL) FramebufferTexture3D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int, zoffset int32) { + C.gl4_3compat_glFramebufferTexture3D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level), C.GLint(zoffset)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture2D.xml +func (gl *GL) FramebufferTexture2D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int) { + C.gl4_3compat_glFramebufferTexture2D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture1D.xml +func (gl *GL) FramebufferTexture1D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int) { + C.gl4_3compat_glFramebufferTexture1D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCheckFramebufferStatus.xml +func (gl *GL) CheckFramebufferStatus(target glbase.Enum) glbase.Enum { + glresult := C.gl4_3compat_glCheckFramebufferStatus(gl.funcs, C.GLenum(target)) + return glbase.Enum(glresult) +} + +// GenFramebuffers returns n framebuffer object names in ids. There is no +// guarantee that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenFramebuffers. +// +// Framebuffer object names returned by a call to GenFramebuffers are not +// returned by subsequent calls, unless they are first deleted with +// DeleteFramebuffers. +// +// The names returned in ids are marked as used, for the purposes of +// GenFramebuffers only, but they acquire state and type only when they are +// first bound. +// +// Error GL.INVALID_VALUE is generated if n is negative. +func (gl *GL) GenFramebuffers(n int) []glbase.Framebuffer { + if n == 0 { + return nil + } + framebuffers := make([]glbase.Framebuffer, n) + C.gl4_3compat_glGenFramebuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&framebuffers[0]))) + return framebuffers +} + +// DeleteFramebuffers deletes the framebuffer objects whose names are +// stored in the framebuffers slice. The name zero is reserved by the GL and +// is silently ignored, should it occur in framebuffers, as are other unused +// names. Once a framebuffer object is deleted, its name is again unused and +// it has no attachments. If a framebuffer that is currently bound to one or +// more of the targets GL.DRAW_FRAMEBUFFER or GL.READ_FRAMEBUFFER is deleted, +// it is as though BindFramebuffer had been executed with the corresponding +// target and framebuffer zero. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteFramebuffers is available in GL version 3.0 or greater. +func (gl *GL) DeleteFramebuffers(framebuffers []glbase.Framebuffer) { + n := len(framebuffers) + if n == 0 { + return + } + C.gl4_3compat_glDeleteFramebuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&framebuffers[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindFramebuffer.xml +func (gl *GL) BindFramebuffer(target glbase.Enum, framebuffer glbase.Framebuffer) { + C.gl4_3compat_glBindFramebuffer(gl.funcs, C.GLenum(target), C.GLuint(framebuffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsFramebuffer.xml +func (gl *GL) IsFramebuffer(framebuffer glbase.Framebuffer) bool { + glresult := C.gl4_3compat_glIsFramebuffer(gl.funcs, C.GLuint(framebuffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetRenderbufferParameteriv.xml +func (gl *GL) GetRenderbufferParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_3compat_glGetRenderbufferParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRenderbufferStorage.xml +func (gl *GL) RenderbufferStorage(target, internalFormat glbase.Enum, width, height int) { + C.gl4_3compat_glRenderbufferStorage(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) +} + +// GenRenderbuffers returns n renderbuffer object names in renderbuffers. +// There is no guarantee that the names form a contiguous set of integers; +// however, it is guaranteed that none of the returned names was in use +// immediately before the call to GenRenderbuffers. +// +// Renderbuffer object names returned by a call to GenRenderbuffers are not +// returned by subsequent calls, unless they are first deleted with +// DeleteRenderbuffers. +// +// The names returned in renderbuffers are marked as used, for the purposes +// of GenRenderbuffers only, but they acquire state and type only when they +// are first bound. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenRenderbuffers is available in GL version 3.0 or greater. +func (gl *GL) GenRenderbuffers(n int) []glbase.Renderbuffer { + if n == 0 { + return nil + } + renderbuffers := make([]glbase.Renderbuffer, n) + C.gl4_3compat_glGenRenderbuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&renderbuffers[0]))) + return renderbuffers +} + +// DeleteRenderbuffers deletes the renderbuffer objects whose names are stored +// in the renderbuffers slice. The name zero is reserved by the GL and +// is silently ignored, should it occur in renderbuffers, as are other unused +// names. Once a renderbuffer object is deleted, its name is again unused and +// it has no contents. If a renderbuffer that is currently bound to the +// target GL.RENDERBUFFER is deleted, it is as though BindRenderbuffer had +// been executed with a target of GL.RENDERBUFFER and a name of zero. +// +// If a renderbuffer object is attached to one or more attachment points in +// the currently bound framebuffer, then it as if FramebufferRenderbuffer +// had been called, with a renderbuffer of zero for each attachment point to +// which this image was attached in the currently bound framebuffer. In other +// words, this renderbuffer object is first detached from all attachment +// ponits in the currently bound framebuffer. Note that the renderbuffer +// image is specifically not detached from any non-bound framebuffers. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteRenderbuffers is available in GL version 3.0 or greater. +func (gl *GL) DeleteRenderbuffers(renderbuffers []glbase.Renderbuffer) { + n := len(renderbuffers) + if n == 0 { + return + } + C.gl4_3compat_glDeleteRenderbuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&renderbuffers[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindRenderbuffer.xml +func (gl *GL) BindRenderbuffer(target glbase.Enum, renderbuffer glbase.Renderbuffer) { + C.gl4_3compat_glBindRenderbuffer(gl.funcs, C.GLenum(target), C.GLuint(renderbuffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsRenderbuffer.xml +func (gl *GL) IsRenderbuffer(renderbuffer glbase.Renderbuffer) bool { + glresult := C.gl4_3compat_glIsRenderbuffer(gl.funcs, C.GLuint(renderbuffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferfi.xml +func (gl *GL) ClearBufferfi(buffer glbase.Enum, drawbuffer int32, depth float32, stencil int32) { + C.gl4_3compat_glClearBufferfi(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), C.GLfloat(depth), C.GLint(stencil)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferfv.xml +func (gl *GL) ClearBufferfv(buffer glbase.Enum, drawbuffer int32, value []float32) { + C.gl4_3compat_glClearBufferfv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferuiv.xml +func (gl *GL) ClearBufferuiv(buffer glbase.Enum, drawbuffer int32, value []uint32) { + C.gl4_3compat_glClearBufferuiv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferiv.xml +func (gl *GL) ClearBufferiv(buffer glbase.Enum, drawbuffer int32, value []int32) { + C.gl4_3compat_glClearBufferiv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameterIuiv.xml +func (gl *GL) GetTexParameterIuiv(target, pname glbase.Enum, params []uint32) { + C.gl4_3compat_glGetTexParameterIuiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameterIiv.xml +func (gl *GL) GetTexParameterIiv(target, pname glbase.Enum, params []int32) { + C.gl4_3compat_glGetTexParameterIiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterIuiv.xml +func (gl *GL) TexParameterIuiv(target, pname glbase.Enum, params []uint32) { + C.gl4_3compat_glTexParameterIuiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterIiv.xml +func (gl *GL) TexParameterIiv(target, pname glbase.Enum, params []int32) { + C.gl4_3compat_glTexParameterIiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// Uniform4uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4uiv") + } + count := len(value) / 4 + C.gl4_3compat_glUniform4uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform3uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3uiv") + } + count := len(value) / 3 + C.gl4_3compat_glUniform3uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform2uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2uiv") + } + count := len(value) / 2 + C.gl4_3compat_glUniform2uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform1uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl4_3compat_glUniform1uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform4ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4ui(location glbase.Uniform, v0, v1, v2, v3 uint32) { + C.gl4_3compat_glUniform4ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2), C.GLuint(v3)) +} + +// Uniform3ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3ui(location glbase.Uniform, v0, v1, v2 uint32) { + C.gl4_3compat_glUniform3ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2)) +} + +// Uniform2ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2ui(location glbase.Uniform, v0, v1 uint32) { + C.gl4_3compat_glUniform2ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1)) +} + +// Uniform1ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1ui(location glbase.Uniform, v0 uint32) { + C.gl4_3compat_glUniform1ui(gl.funcs, C.GLint(location), C.GLuint(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFragDataLocation.xml +func (gl *GL) GetFragDataLocation(program glbase.Program, name []byte) int32 { + glresult := C.gl4_3compat_glGetFragDataLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindFragDataLocation.xml +func (gl *GL) BindFragDataLocation(program glbase.Program, color uint32, name []byte) { + C.gl4_3compat_glBindFragDataLocation(gl.funcs, C.GLuint(program), C.GLuint(color), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetUniformuiv.xml +func (gl *GL) GetUniformuiv(program glbase.Program, location glbase.Uniform, params []uint32) { + C.gl4_3compat_glGetUniformuiv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetVertexAttribIuiv.xml +func (gl *GL) GetVertexAttribIuiv(index glbase.Attrib, pname glbase.Enum, params []uint32) { + C.gl4_3compat_glGetVertexAttribIuiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetVertexAttribIiv.xml +func (gl *GL) GetVertexAttribIiv(index glbase.Attrib, pname glbase.Enum, params []int32) { + C.gl4_3compat_glGetVertexAttribIiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribIPointer.xml +func (gl *GL) VertexAttribIPointer(index glbase.Attrib, size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glVertexAttribIPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndConditionalRender.xml +func (gl *GL) EndConditionalRender() { + C.gl4_3compat_glEndConditionalRender(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBeginConditionalRender.xml +func (gl *GL) BeginConditionalRender(id uint32, mode glbase.Enum) { + C.gl4_3compat_glBeginConditionalRender(gl.funcs, C.GLuint(id), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClampColor.xml +func (gl *GL) ClampColor(target, clamp glbase.Enum) { + C.gl4_3compat_glClampColor(gl.funcs, C.GLenum(target), C.GLenum(clamp)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTransformFeedbackVarying.xml +func (gl *GL) GetTransformFeedbackVarying(program glbase.Program, index uint32, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl4_3compat_glGetTransformFeedbackVarying(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLsizei)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindBufferBase.xml +func (gl *GL) BindBufferBase(target glbase.Enum, index uint32, buffer glbase.Buffer) { + C.gl4_3compat_glBindBufferBase(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindBufferRange.xml +func (gl *GL) BindBufferRange(target glbase.Enum, index uint32, buffer glbase.Buffer, offset, size int) { + C.gl4_3compat_glBindBufferRange(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(buffer), C.GLintptr(offset), C.GLsizeiptr(size)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndTransformFeedback.xml +func (gl *GL) EndTransformFeedback() { + C.gl4_3compat_glEndTransformFeedback(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBeginTransformFeedback.xml +func (gl *GL) BeginTransformFeedback(primitiveMode glbase.Enum) { + C.gl4_3compat_glBeginTransformFeedback(gl.funcs, C.GLenum(primitiveMode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsEnabledi.xml +func (gl *GL) IsEnabledi(target glbase.Enum, index uint32) bool { + glresult := C.gl4_3compat_glIsEnabledi(gl.funcs, C.GLenum(target), C.GLuint(index)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDisablei.xml +func (gl *GL) Disablei(target glbase.Enum, index uint32) { + C.gl4_3compat_glDisablei(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEnablei.xml +func (gl *GL) Enablei(target glbase.Enum, index uint32) { + C.gl4_3compat_glEnablei(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetIntegeri_v.xml +func (gl *GL) GetIntegeri_v(target glbase.Enum, index uint32, data []int32) { + C.gl4_3compat_glGetIntegeri_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLint)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBooleani_v.xml +func (gl *GL) GetBooleani_v(target glbase.Enum, index uint32, data []bool) { + C.gl4_3compat_glGetBooleani_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLboolean)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorMaski.xml +func (gl *GL) ColorMaski(index uint32, r, g, b, a bool) { + C.gl4_3compat_glColorMaski(gl.funcs, C.GLuint(index), *(*C.GLboolean)(unsafe.Pointer(&r)), *(*C.GLboolean)(unsafe.Pointer(&g)), *(*C.GLboolean)(unsafe.Pointer(&b)), *(*C.GLboolean)(unsafe.Pointer(&a))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyBufferSubData.xml +func (gl *GL) CopyBufferSubData(readTarget, writeTarget glbase.Enum, readOffset, writeOffset, size int) { + C.gl4_3compat_glCopyBufferSubData(gl.funcs, C.GLenum(readTarget), C.GLenum(writeTarget), C.GLintptr(readOffset), C.GLintptr(writeOffset), C.GLsizeiptr(size)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformBlockBinding.xml +func (gl *GL) UniformBlockBinding(program glbase.Program, v0, v1 uint32) { + C.gl4_3compat_glUniformBlockBinding(gl.funcs, C.GLuint(program), C.GLuint(v0), C.GLuint(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformBlockName.xml +func (gl *GL) GetActiveUniformBlockName(program glbase.Program, uniformBlockIndex uint32, bufSize int32, length []int32, uniformBlockName []byte) { + C.gl4_3compat_glGetActiveUniformBlockName(gl.funcs, C.GLuint(program), C.GLuint(uniformBlockIndex), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&uniformBlockName[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformBlockiv.xml +func (gl *GL) GetActiveUniformBlockiv(program glbase.Program, uniformBlockIndex uint32, pname glbase.Enum, params []int32) { + C.gl4_3compat_glGetActiveUniformBlockiv(gl.funcs, C.GLuint(program), C.GLuint(uniformBlockIndex), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetUniformBlockIndex.xml +func (gl *GL) GetUniformBlockIndex(program glbase.Program, uniformBlockName []byte) uint32 { + glresult := C.gl4_3compat_glGetUniformBlockIndex(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&uniformBlockName[0]))) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformName.xml +func (gl *GL) GetActiveUniformName(program glbase.Program, uniformIndex uint32, bufSize int32, length []int32, uniformName []byte) { + C.gl4_3compat_glGetActiveUniformName(gl.funcs, C.GLuint(program), C.GLuint(uniformIndex), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&uniformName[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformsiv.xml +func (gl *GL) GetActiveUniformsiv(program glbase.Program, uniformCount int32, uniformIndices []uint32, pname glbase.Enum, params []int32) { + C.gl4_3compat_glGetActiveUniformsiv(gl.funcs, C.GLuint(program), C.GLsizei(uniformCount), (*C.GLuint)(unsafe.Pointer(&uniformIndices[0])), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPrimitiveRestartIndex.xml +func (gl *GL) PrimitiveRestartIndex(index uint32) { + C.gl4_3compat_glPrimitiveRestartIndex(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexBuffer.xml +func (gl *GL) TexBuffer(target, internalFormat glbase.Enum, buffer glbase.Buffer) { + C.gl4_3compat_glTexBuffer(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsInstanced.xml +func (gl *GL) DrawElementsInstanced(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, instancecount int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glDrawElementsInstanced(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLsizei(instancecount)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawArraysInstanced.xml +func (gl *GL) DrawArraysInstanced(mode glbase.Enum, first, count int, instancecount int32) { + C.gl4_3compat_glDrawArraysInstanced(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count), C.GLsizei(instancecount)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSampleMaski.xml +func (gl *GL) SampleMaski(index uint32, mask glbase.Bitfield) { + C.gl4_3compat_glSampleMaski(gl.funcs, C.GLuint(index), C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMultisamplefv.xml +func (gl *GL) GetMultisamplefv(pname glbase.Enum, index uint32, val []float32) { + C.gl4_3compat_glGetMultisamplefv(gl.funcs, C.GLenum(pname), C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&val[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage3DMultisample.xml +func (gl *GL) TexImage3DMultisample(target glbase.Enum, samples, internalFormat int32, width, height int, depth int32, fixedsamplelocations bool) { + C.gl4_3compat_glTexImage3DMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), *(*C.GLboolean)(unsafe.Pointer(&fixedsamplelocations))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage2DMultisample.xml +func (gl *GL) TexImage2DMultisample(target glbase.Enum, samples, internalFormat int32, width, height int, fixedsamplelocations bool) { + C.gl4_3compat_glTexImage2DMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), *(*C.GLboolean)(unsafe.Pointer(&fixedsamplelocations))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSynciv.xml +func (gl *GL) GetSynciv(sync glbase.Sync, pname glbase.Enum, bufSize int32, length, values []int32) { + C.gl4_3compat_glGetSynciv(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLenum(pname), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetInteger64v.xml +func (gl *GL) GetInteger64v(pname glbase.Enum, params []int64) { + C.gl4_3compat_glGetInteger64v(gl.funcs, C.GLenum(pname), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWaitSync.xml +func (gl *GL) WaitSync(sync glbase.Sync, flags glbase.Bitfield, timeout uint64) { + C.gl4_3compat_glWaitSync(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLbitfield(flags), C.GLuint64(timeout)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClientWaitSync.xml +func (gl *GL) ClientWaitSync(sync glbase.Sync, flags glbase.Bitfield, timeout uint64) glbase.Enum { + glresult := C.gl4_3compat_glClientWaitSync(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLbitfield(flags), C.GLuint64(timeout)) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteSync.xml +func (gl *GL) DeleteSync(sync glbase.Sync) { + C.gl4_3compat_glDeleteSync(gl.funcs, C.GLsync(unsafe.Pointer(sync))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsSync.xml +func (gl *GL) IsSync(sync glbase.Sync) bool { + glresult := C.gl4_3compat_glIsSync(gl.funcs, C.GLsync(unsafe.Pointer(sync))) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFenceSync.xml +func (gl *GL) FenceSync(condition glbase.Enum, flags glbase.Bitfield) glbase.Sync { + glresult := C.gl4_3compat_glFenceSync(gl.funcs, C.GLenum(condition), C.GLbitfield(flags)) + return glbase.Sync(unsafe.Pointer(glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProvokingVertex.xml +func (gl *GL) ProvokingVertex(mode glbase.Enum) { + C.gl4_3compat_glProvokingVertex(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsInstancedBaseVertex.xml +func (gl *GL) DrawElementsInstancedBaseVertex(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, instancecount, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glDrawElementsInstancedBaseVertex(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLsizei(instancecount), C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawRangeElementsBaseVertex.xml +func (gl *GL) DrawRangeElementsBaseVertex(mode glbase.Enum, start, end uint32, count int, gltype glbase.Enum, indices interface{}, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glDrawRangeElementsBaseVertex(gl.funcs, C.GLenum(mode), C.GLuint(start), C.GLuint(end), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsBaseVertex.xml +func (gl *GL) DrawElementsBaseVertex(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glDrawElementsBaseVertex(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture.xml +func (gl *GL) FramebufferTexture(target, attachment glbase.Enum, texture glbase.Texture, level int) { + C.gl4_3compat_glFramebufferTexture(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBufferParameteri64v.xml +func (gl *GL) GetBufferParameteri64v(target, pname glbase.Enum, params []int64) { + C.gl4_3compat_glGetBufferParameteri64v(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetInteger64i_v.xml +func (gl *GL) GetInteger64i_v(target glbase.Enum, index uint32, data []int64) { + C.gl4_3compat_glGetInteger64i_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLint64)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP4uiv.xml +func (gl *GL) VertexAttribP4uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl4_3compat_glVertexAttribP4uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP4ui.xml +func (gl *GL) VertexAttribP4ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl4_3compat_glVertexAttribP4ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP3uiv.xml +func (gl *GL) VertexAttribP3uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl4_3compat_glVertexAttribP3uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP3ui.xml +func (gl *GL) VertexAttribP3ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl4_3compat_glVertexAttribP3ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP2uiv.xml +func (gl *GL) VertexAttribP2uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl4_3compat_glVertexAttribP2uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP2ui.xml +func (gl *GL) VertexAttribP2ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl4_3compat_glVertexAttribP2ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP1uiv.xml +func (gl *GL) VertexAttribP1uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl4_3compat_glVertexAttribP1uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP1ui.xml +func (gl *GL) VertexAttribP1ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl4_3compat_glVertexAttribP1ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColorP3uiv.xml +func (gl *GL) SecondaryColorP3uiv(gltype glbase.Enum, color []uint32) { + C.gl4_3compat_glSecondaryColorP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&color[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColorP3ui.xml +func (gl *GL) SecondaryColorP3ui(gltype glbase.Enum, color uint32) { + C.gl4_3compat_glSecondaryColorP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(color)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorP4uiv.xml +func (gl *GL) ColorP4uiv(gltype glbase.Enum, color []uint32) { + C.gl4_3compat_glColorP4uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&color[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorP4ui.xml +func (gl *GL) ColorP4ui(gltype glbase.Enum, color uint32) { + C.gl4_3compat_glColorP4ui(gl.funcs, C.GLenum(gltype), C.GLuint(color)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorP3uiv.xml +func (gl *GL) ColorP3uiv(gltype glbase.Enum, color []uint32) { + C.gl4_3compat_glColorP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&color[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorP3ui.xml +func (gl *GL) ColorP3ui(gltype glbase.Enum, color uint32) { + C.gl4_3compat_glColorP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(color)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormalP3uiv.xml +func (gl *GL) NormalP3uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_3compat_glNormalP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormalP3ui.xml +func (gl *GL) NormalP3ui(gltype glbase.Enum, coords uint32) { + C.gl4_3compat_glNormalP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP4uiv.xml +func (gl *GL) MultiTexCoordP4uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl4_3compat_glMultiTexCoordP4uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP4ui.xml +func (gl *GL) MultiTexCoordP4ui(texture, gltype glbase.Enum, coords uint32) { + C.gl4_3compat_glMultiTexCoordP4ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP3uiv.xml +func (gl *GL) MultiTexCoordP3uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl4_3compat_glMultiTexCoordP3uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP3ui.xml +func (gl *GL) MultiTexCoordP3ui(texture, gltype glbase.Enum, coords uint32) { + C.gl4_3compat_glMultiTexCoordP3ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP2uiv.xml +func (gl *GL) MultiTexCoordP2uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl4_3compat_glMultiTexCoordP2uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP2ui.xml +func (gl *GL) MultiTexCoordP2ui(texture, gltype glbase.Enum, coords uint32) { + C.gl4_3compat_glMultiTexCoordP2ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP1uiv.xml +func (gl *GL) MultiTexCoordP1uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl4_3compat_glMultiTexCoordP1uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP1ui.xml +func (gl *GL) MultiTexCoordP1ui(texture, gltype glbase.Enum, coords uint32) { + C.gl4_3compat_glMultiTexCoordP1ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP4uiv.xml +func (gl *GL) TexCoordP4uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_3compat_glTexCoordP4uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP4ui.xml +func (gl *GL) TexCoordP4ui(gltype glbase.Enum, coords uint32) { + C.gl4_3compat_glTexCoordP4ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP3uiv.xml +func (gl *GL) TexCoordP3uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_3compat_glTexCoordP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP3ui.xml +func (gl *GL) TexCoordP3ui(gltype glbase.Enum, coords uint32) { + C.gl4_3compat_glTexCoordP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP2uiv.xml +func (gl *GL) TexCoordP2uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_3compat_glTexCoordP2uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP2ui.xml +func (gl *GL) TexCoordP2ui(gltype glbase.Enum, coords uint32) { + C.gl4_3compat_glTexCoordP2ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP1uiv.xml +func (gl *GL) TexCoordP1uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_3compat_glTexCoordP1uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP1ui.xml +func (gl *GL) TexCoordP1ui(gltype glbase.Enum, coords uint32) { + C.gl4_3compat_glTexCoordP1ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP4uiv.xml +func (gl *GL) VertexP4uiv(gltype glbase.Enum, value []uint32) { + C.gl4_3compat_glVertexP4uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP4ui.xml +func (gl *GL) VertexP4ui(gltype glbase.Enum, value uint32) { + C.gl4_3compat_glVertexP4ui(gl.funcs, C.GLenum(gltype), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP3uiv.xml +func (gl *GL) VertexP3uiv(gltype glbase.Enum, value []uint32) { + C.gl4_3compat_glVertexP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP3ui.xml +func (gl *GL) VertexP3ui(gltype glbase.Enum, value uint32) { + C.gl4_3compat_glVertexP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP2uiv.xml +func (gl *GL) VertexP2uiv(gltype glbase.Enum, value []uint32) { + C.gl4_3compat_glVertexP2uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP2ui.xml +func (gl *GL) VertexP2ui(gltype glbase.Enum, value uint32) { + C.gl4_3compat_glVertexP2ui(gl.funcs, C.GLenum(gltype), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryObjectui64v.xml +func (gl *GL) GetQueryObjectui64v(id uint32, pname glbase.Enum, params []uint64) { + C.gl4_3compat_glGetQueryObjectui64v(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLuint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryObjecti64v.xml +func (gl *GL) GetQueryObjecti64v(id uint32, pname glbase.Enum, params []int64) { + C.gl4_3compat_glGetQueryObjecti64v(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glQueryCounter.xml +func (gl *GL) QueryCounter(id uint32, target glbase.Enum) { + C.gl4_3compat_glQueryCounter(gl.funcs, C.GLuint(id), C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSamplerParameterIuiv.xml +func (gl *GL) GetSamplerParameterIuiv(sampler uint32, pname glbase.Enum, params []uint32) { + C.gl4_3compat_glGetSamplerParameterIuiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSamplerParameterfv.xml +func (gl *GL) GetSamplerParameterfv(sampler uint32, pname glbase.Enum, params []float32) { + C.gl4_3compat_glGetSamplerParameterfv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSamplerParameterIiv.xml +func (gl *GL) GetSamplerParameterIiv(sampler uint32, pname glbase.Enum, params []int32) { + C.gl4_3compat_glGetSamplerParameterIiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSamplerParameteriv.xml +func (gl *GL) GetSamplerParameteriv(sampler uint32, pname glbase.Enum, params []int32) { + C.gl4_3compat_glGetSamplerParameteriv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameterIuiv.xml +func (gl *GL) SamplerParameterIuiv(sampler uint32, pname glbase.Enum, param []uint32) { + C.gl4_3compat_glSamplerParameterIuiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameterIiv.xml +func (gl *GL) SamplerParameterIiv(sampler uint32, pname glbase.Enum, param []int32) { + C.gl4_3compat_glSamplerParameterIiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameterfv.xml +func (gl *GL) SamplerParameterfv(sampler uint32, pname glbase.Enum, param []float32) { + C.gl4_3compat_glSamplerParameterfv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameterf.xml +func (gl *GL) SamplerParameterf(sampler uint32, pname glbase.Enum, param float32) { + C.gl4_3compat_glSamplerParameterf(gl.funcs, C.GLuint(sampler), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameteriv.xml +func (gl *GL) SamplerParameteriv(sampler uint32, pname glbase.Enum, param []int32) { + C.gl4_3compat_glSamplerParameteriv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameteri.xml +func (gl *GL) SamplerParameteri(sampler uint32, pname glbase.Enum, param int32) { + C.gl4_3compat_glSamplerParameteri(gl.funcs, C.GLuint(sampler), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindSampler.xml +func (gl *GL) BindSampler(unit, sampler uint32) { + C.gl4_3compat_glBindSampler(gl.funcs, C.GLuint(unit), C.GLuint(sampler)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsSampler.xml +func (gl *GL) IsSampler(sampler uint32) bool { + glresult := C.gl4_3compat_glIsSampler(gl.funcs, C.GLuint(sampler)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteSamplers.xml +func (gl *GL) DeleteSamplers(count int, samplers []uint32) { + C.gl4_3compat_glDeleteSamplers(gl.funcs, C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&samplers[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenSamplers.xml +func (gl *GL) GenSamplers(count int, samplers []uint32) { + C.gl4_3compat_glGenSamplers(gl.funcs, C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&samplers[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFragDataIndex.xml +func (gl *GL) GetFragDataIndex(program glbase.Program, name []byte) int32 { + glresult := C.gl4_3compat_glGetFragDataIndex(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindFragDataLocationIndexed.xml +func (gl *GL) BindFragDataLocationIndexed(program glbase.Program, colorNumber, index uint32, name []byte) { + C.gl4_3compat_glBindFragDataLocationIndexed(gl.funcs, C.GLuint(program), C.GLuint(colorNumber), C.GLuint(index), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribDivisor.xml +func (gl *GL) VertexAttribDivisor(index glbase.Attrib, divisor uint32) { + C.gl4_3compat_glVertexAttribDivisor(gl.funcs, C.GLuint(index), C.GLuint(divisor)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryIndexediv.xml +func (gl *GL) GetQueryIndexediv(target glbase.Enum, index uint32, pname glbase.Enum, params []int32) { + C.gl4_3compat_glGetQueryIndexediv(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndQueryIndexed.xml +func (gl *GL) EndQueryIndexed(target glbase.Enum, index uint32) { + C.gl4_3compat_glEndQueryIndexed(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBeginQueryIndexed.xml +func (gl *GL) BeginQueryIndexed(target glbase.Enum, index, id uint32) { + C.gl4_3compat_glBeginQueryIndexed(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawTransformFeedbackStream.xml +func (gl *GL) DrawTransformFeedbackStream(mode glbase.Enum, id, stream uint32) { + C.gl4_3compat_glDrawTransformFeedbackStream(gl.funcs, C.GLenum(mode), C.GLuint(id), C.GLuint(stream)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawTransformFeedback.xml +func (gl *GL) DrawTransformFeedback(mode glbase.Enum, id uint32) { + C.gl4_3compat_glDrawTransformFeedback(gl.funcs, C.GLenum(mode), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glResumeTransformFeedback.xml +func (gl *GL) ResumeTransformFeedback() { + C.gl4_3compat_glResumeTransformFeedback(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPauseTransformFeedback.xml +func (gl *GL) PauseTransformFeedback() { + C.gl4_3compat_glPauseTransformFeedback(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsTransformFeedback.xml +func (gl *GL) IsTransformFeedback(id uint32) bool { + glresult := C.gl4_3compat_glIsTransformFeedback(gl.funcs, C.GLuint(id)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenTransformFeedbacks.xml +func (gl *GL) GenTransformFeedbacks(n int, ids []uint32) { + C.gl4_3compat_glGenTransformFeedbacks(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteTransformFeedbacks.xml +func (gl *GL) DeleteTransformFeedbacks(n int, ids []uint32) { + C.gl4_3compat_glDeleteTransformFeedbacks(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindTransformFeedback.xml +func (gl *GL) BindTransformFeedback(target glbase.Enum, id uint32) { + C.gl4_3compat_glBindTransformFeedback(gl.funcs, C.GLenum(target), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPatchParameterfv.xml +func (gl *GL) PatchParameterfv(pname glbase.Enum, values []float32) { + C.gl4_3compat_glPatchParameterfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPatchParameteri.xml +func (gl *GL) PatchParameteri(pname glbase.Enum, value int32) { + C.gl4_3compat_glPatchParameteri(gl.funcs, C.GLenum(pname), C.GLint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramStageiv.xml +func (gl *GL) GetProgramStageiv(program glbase.Program, shadertype, pname glbase.Enum, values []int32) { + C.gl4_3compat_glGetProgramStageiv(gl.funcs, C.GLuint(program), C.GLenum(shadertype), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetUniformSubroutineuiv.xml +func (gl *GL) GetUniformSubroutineuiv(shadertype glbase.Enum, location glbase.Uniform, params []uint32) { + C.gl4_3compat_glGetUniformSubroutineuiv(gl.funcs, C.GLenum(shadertype), C.GLint(location), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformSubroutinesuiv.xml +func (gl *GL) UniformSubroutinesuiv(shadertype glbase.Enum, count int, value []uint32) { + C.gl4_3compat_glUniformSubroutinesuiv(gl.funcs, C.GLenum(shadertype), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveSubroutineName.xml +func (gl *GL) GetActiveSubroutineName(program glbase.Program, shadertype glbase.Enum, index uint32, bufSize int32, length []int32, name []byte) { + C.gl4_3compat_glGetActiveSubroutineName(gl.funcs, C.GLuint(program), C.GLenum(shadertype), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveSubroutineUniformName.xml +func (gl *GL) GetActiveSubroutineUniformName(program glbase.Program, shadertype glbase.Enum, index uint32, bufSize int32, length []int32, name []byte) { + C.gl4_3compat_glGetActiveSubroutineUniformName(gl.funcs, C.GLuint(program), C.GLenum(shadertype), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveSubroutineUniformiv.xml +func (gl *GL) GetActiveSubroutineUniformiv(program glbase.Program, shadertype glbase.Enum, index uint32, pname glbase.Enum, values []int32) { + C.gl4_3compat_glGetActiveSubroutineUniformiv(gl.funcs, C.GLuint(program), C.GLenum(shadertype), C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSubroutineIndex.xml +func (gl *GL) GetSubroutineIndex(program glbase.Program, shadertype glbase.Enum, name []byte) uint32 { + glresult := C.gl4_3compat_glGetSubroutineIndex(gl.funcs, C.GLuint(program), C.GLenum(shadertype), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSubroutineUniformLocation.xml +func (gl *GL) GetSubroutineUniformLocation(program glbase.Program, shadertype glbase.Enum, name []byte) int32 { + glresult := C.gl4_3compat_glGetSubroutineUniformLocation(gl.funcs, C.GLuint(program), C.GLenum(shadertype), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetUniformdv.xml +func (gl *GL) GetUniformdv(program glbase.Program, location glbase.Uniform, params []float64) { + C.gl4_3compat_glGetUniformdv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix4x3dv.xml +func (gl *GL) UniformMatrix4x3dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_3compat_glUniformMatrix4x3dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix4x2dv.xml +func (gl *GL) UniformMatrix4x2dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_3compat_glUniformMatrix4x2dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix3x4dv.xml +func (gl *GL) UniformMatrix3x4dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_3compat_glUniformMatrix3x4dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix3x2dv.xml +func (gl *GL) UniformMatrix3x2dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_3compat_glUniformMatrix3x2dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix2x4dv.xml +func (gl *GL) UniformMatrix2x4dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_3compat_glUniformMatrix2x4dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix2x3dv.xml +func (gl *GL) UniformMatrix2x3dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_3compat_glUniformMatrix2x3dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix4dv.xml +func (gl *GL) UniformMatrix4dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_3compat_glUniformMatrix4dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix3dv.xml +func (gl *GL) UniformMatrix3dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_3compat_glUniformMatrix3dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix2dv.xml +func (gl *GL) UniformMatrix2dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_3compat_glUniformMatrix2dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform4dv.xml +func (gl *GL) Uniform4dv(location glbase.Uniform, count int, value []float64) { + C.gl4_3compat_glUniform4dv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform3dv.xml +func (gl *GL) Uniform3dv(location glbase.Uniform, count int, value []float64) { + C.gl4_3compat_glUniform3dv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform2dv.xml +func (gl *GL) Uniform2dv(location glbase.Uniform, count int, value []float64) { + C.gl4_3compat_glUniform2dv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform1dv.xml +func (gl *GL) Uniform1dv(location glbase.Uniform, count int, value []float64) { + C.gl4_3compat_glUniform1dv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform4d.xml +func (gl *GL) Uniform4d(location glbase.Uniform, v0, v1, v2, v3 float64) { + C.gl4_3compat_glUniform4d(gl.funcs, C.GLint(location), C.GLdouble(v0), C.GLdouble(v1), C.GLdouble(v2), C.GLdouble(v3)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform3d.xml +func (gl *GL) Uniform3d(location glbase.Uniform, v0, v1, v2 float64) { + C.gl4_3compat_glUniform3d(gl.funcs, C.GLint(location), C.GLdouble(v0), C.GLdouble(v1), C.GLdouble(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform2d.xml +func (gl *GL) Uniform2d(location glbase.Uniform, v0, v1 float64) { + C.gl4_3compat_glUniform2d(gl.funcs, C.GLint(location), C.GLdouble(v0), C.GLdouble(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform1d.xml +func (gl *GL) Uniform1d(location glbase.Uniform, v0 float64) { + C.gl4_3compat_glUniform1d(gl.funcs, C.GLint(location), C.GLdouble(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsIndirect.xml +func (gl *GL) DrawElementsIndirect(mode, gltype glbase.Enum, indirect interface{}) { + var indirect_ptr unsafe.Pointer + var indirect_v = reflect.ValueOf(indirect) + if indirect != nil && indirect_v.Kind() != reflect.Slice { + panic("parameter indirect must be a slice") + } + if indirect != nil { + indirect_ptr = unsafe.Pointer(indirect_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glDrawElementsIndirect(gl.funcs, C.GLenum(mode), C.GLenum(gltype), indirect_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawArraysIndirect.xml +func (gl *GL) DrawArraysIndirect(mode glbase.Enum, indirect interface{}) { + var indirect_ptr unsafe.Pointer + var indirect_v = reflect.ValueOf(indirect) + if indirect != nil && indirect_v.Kind() != reflect.Slice { + panic("parameter indirect must be a slice") + } + if indirect != nil { + indirect_ptr = unsafe.Pointer(indirect_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glDrawArraysIndirect(gl.funcs, C.GLenum(mode), indirect_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFuncSeparatei.xml +func (gl *GL) BlendFuncSeparatei(buf uint32, srcRGB, dstRGB, srcAlpha, dstAlpha glbase.Enum) { + C.gl4_3compat_glBlendFuncSeparatei(gl.funcs, C.GLuint(buf), C.GLenum(srcRGB), C.GLenum(dstRGB), C.GLenum(srcAlpha), C.GLenum(dstAlpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFunci.xml +func (gl *GL) BlendFunci(buf uint32, src, dst glbase.Enum) { + C.gl4_3compat_glBlendFunci(gl.funcs, C.GLuint(buf), C.GLenum(src), C.GLenum(dst)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendEquationSeparatei.xml +func (gl *GL) BlendEquationSeparatei(buf uint32, modeRGB, modeAlpha glbase.Enum) { + C.gl4_3compat_glBlendEquationSeparatei(gl.funcs, C.GLuint(buf), C.GLenum(modeRGB), C.GLenum(modeAlpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendEquationi.xml +func (gl *GL) BlendEquationi(buf uint32, mode glbase.Enum) { + C.gl4_3compat_glBlendEquationi(gl.funcs, C.GLuint(buf), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMinSampleShading.xml +func (gl *GL) MinSampleShading(value float32) { + C.gl4_3compat_glMinSampleShading(gl.funcs, C.GLfloat(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetDoublei_v.xml +func (gl *GL) GetDoublei_v(target glbase.Enum, index uint32, data []float64) { + C.gl4_3compat_glGetDoublei_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFloati_v.xml +func (gl *GL) GetFloati_v(target glbase.Enum, index uint32, data []float32) { + C.gl4_3compat_glGetFloati_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDepthRangeIndexed.xml +func (gl *GL) DepthRangeIndexed(index uint32, n, f float64) { + C.gl4_3compat_glDepthRangeIndexed(gl.funcs, C.GLuint(index), C.GLdouble(n), C.GLdouble(f)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDepthRangeArrayv.xml +func (gl *GL) DepthRangeArrayv(first uint32, count int, v []float64) { + C.gl4_3compat_glDepthRangeArrayv(gl.funcs, C.GLuint(first), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glScissorIndexedv.xml +func (gl *GL) ScissorIndexedv(index uint32, v []int32) { + C.gl4_3compat_glScissorIndexedv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glScissorIndexed.xml +func (gl *GL) ScissorIndexed(index uint32, left, bottom int32, width, height int) { + C.gl4_3compat_glScissorIndexed(gl.funcs, C.GLuint(index), C.GLint(left), C.GLint(bottom), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glScissorArrayv.xml +func (gl *GL) ScissorArrayv(first uint32, count int, v []int32) { + C.gl4_3compat_glScissorArrayv(gl.funcs, C.GLuint(first), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glViewportIndexedfv.xml +func (gl *GL) ViewportIndexedfv(index uint32, v []float32) { + C.gl4_3compat_glViewportIndexedfv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glViewportIndexedf.xml +func (gl *GL) ViewportIndexedf(index uint32, x, y, w, h float32) { + C.gl4_3compat_glViewportIndexedf(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y), C.GLfloat(w), C.GLfloat(h)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glViewportArrayv.xml +func (gl *GL) ViewportArrayv(first uint32, count int, v []float32) { + C.gl4_3compat_glViewportArrayv(gl.funcs, C.GLuint(first), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetVertexAttribLdv.xml +func (gl *GL) GetVertexAttribLdv(index glbase.Attrib, pname glbase.Enum, params []float64) { + C.gl4_3compat_glGetVertexAttribLdv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribLPointer.xml +func (gl *GL) VertexAttribLPointer(index glbase.Attrib, size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glVertexAttribLPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL4dv.xml +func (gl *GL) VertexAttribL4dv(index glbase.Attrib, v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glVertexAttribL4dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL3dv.xml +func (gl *GL) VertexAttribL3dv(index glbase.Attrib, v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glVertexAttribL3dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL2dv.xml +func (gl *GL) VertexAttribL2dv(index glbase.Attrib, v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glVertexAttribL2dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL1dv.xml +func (gl *GL) VertexAttribL1dv(index glbase.Attrib, v []float64) { + C.gl4_3compat_glVertexAttribL1dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL4d.xml +func (gl *GL) VertexAttribL4d(index glbase.Attrib, x, y, z, w float64) { + C.gl4_3compat_glVertexAttribL4d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL3d.xml +func (gl *GL) VertexAttribL3d(index glbase.Attrib, x, y, z float64) { + C.gl4_3compat_glVertexAttribL3d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL2d.xml +func (gl *GL) VertexAttribL2d(index glbase.Attrib, x, y float64) { + C.gl4_3compat_glVertexAttribL2d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL1d.xml +func (gl *GL) VertexAttribL1d(index glbase.Attrib, x float64) { + C.gl4_3compat_glVertexAttribL1d(gl.funcs, C.GLuint(index), C.GLdouble(x)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramPipelineInfoLog.xml +func (gl *GL) GetProgramPipelineInfoLog(pipeline uint32, bufSize int32, length []int32, infoLog []byte) { + C.gl4_3compat_glGetProgramPipelineInfoLog(gl.funcs, C.GLuint(pipeline), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glValidateProgramPipeline.xml +func (gl *GL) ValidateProgramPipeline(pipeline uint32) { + C.gl4_3compat_glValidateProgramPipeline(gl.funcs, C.GLuint(pipeline)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4x3dv.xml +func (gl *GL) ProgramUniformMatrix4x3dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_3compat_glProgramUniformMatrix4x3dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3x4dv.xml +func (gl *GL) ProgramUniformMatrix3x4dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_3compat_glProgramUniformMatrix3x4dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4x2dv.xml +func (gl *GL) ProgramUniformMatrix4x2dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_3compat_glProgramUniformMatrix4x2dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2x4dv.xml +func (gl *GL) ProgramUniformMatrix2x4dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_3compat_glProgramUniformMatrix2x4dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3x2dv.xml +func (gl *GL) ProgramUniformMatrix3x2dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_3compat_glProgramUniformMatrix3x2dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2x3dv.xml +func (gl *GL) ProgramUniformMatrix2x3dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_3compat_glProgramUniformMatrix2x3dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4x3fv.xml +func (gl *GL) ProgramUniformMatrix4x3fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_3compat_glProgramUniformMatrix4x3fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3x4fv.xml +func (gl *GL) ProgramUniformMatrix3x4fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_3compat_glProgramUniformMatrix3x4fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4x2fv.xml +func (gl *GL) ProgramUniformMatrix4x2fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_3compat_glProgramUniformMatrix4x2fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2x4fv.xml +func (gl *GL) ProgramUniformMatrix2x4fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_3compat_glProgramUniformMatrix2x4fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3x2fv.xml +func (gl *GL) ProgramUniformMatrix3x2fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_3compat_glProgramUniformMatrix3x2fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2x3fv.xml +func (gl *GL) ProgramUniformMatrix2x3fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_3compat_glProgramUniformMatrix2x3fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4dv.xml +func (gl *GL) ProgramUniformMatrix4dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_3compat_glProgramUniformMatrix4dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3dv.xml +func (gl *GL) ProgramUniformMatrix3dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_3compat_glProgramUniformMatrix3dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2dv.xml +func (gl *GL) ProgramUniformMatrix2dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_3compat_glProgramUniformMatrix2dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4fv.xml +func (gl *GL) ProgramUniformMatrix4fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_3compat_glProgramUniformMatrix4fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3fv.xml +func (gl *GL) ProgramUniformMatrix3fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_3compat_glProgramUniformMatrix3fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2fv.xml +func (gl *GL) ProgramUniformMatrix2fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_3compat_glProgramUniformMatrix2fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4uiv.xml +func (gl *GL) ProgramUniform4uiv(program glbase.Program, location glbase.Uniform, count int, value []uint32) { + C.gl4_3compat_glProgramUniform4uiv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4ui.xml +func (gl *GL) ProgramUniform4ui(program glbase.Program, location glbase.Uniform, v0, v1, v2, v3 uint32) { + C.gl4_3compat_glProgramUniform4ui(gl.funcs, C.GLuint(program), C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2), C.GLuint(v3)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4dv.xml +func (gl *GL) ProgramUniform4dv(program glbase.Program, location glbase.Uniform, count int, value []float64) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_3compat_glProgramUniform4dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4d.xml +func (gl *GL) ProgramUniform4d(program glbase.Program, location glbase.Uniform, v0, v1, v2, v3 float64) { + C.gl4_3compat_glProgramUniform4d(gl.funcs, C.GLuint(program), C.GLint(location), C.GLdouble(v0), C.GLdouble(v1), C.GLdouble(v2), C.GLdouble(v3)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4fv.xml +func (gl *GL) ProgramUniform4fv(program glbase.Program, location glbase.Uniform, count int, value []float32) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_3compat_glProgramUniform4fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4f.xml +func (gl *GL) ProgramUniform4f(program glbase.Program, location glbase.Uniform, v0, v1, v2, v3 float32) { + C.gl4_3compat_glProgramUniform4f(gl.funcs, C.GLuint(program), C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2), C.GLfloat(v3)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4iv.xml +func (gl *GL) ProgramUniform4iv(program glbase.Program, location glbase.Uniform, count int, value []int32) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_3compat_glProgramUniform4iv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4i.xml +func (gl *GL) ProgramUniform4i(program glbase.Program, location glbase.Uniform, v0, v1, v2, v3 int32) { + C.gl4_3compat_glProgramUniform4i(gl.funcs, C.GLuint(program), C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2), C.GLint(v3)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3uiv.xml +func (gl *GL) ProgramUniform3uiv(program glbase.Program, location glbase.Uniform, count int, value []uint32) { + C.gl4_3compat_glProgramUniform3uiv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3ui.xml +func (gl *GL) ProgramUniform3ui(program glbase.Program, location glbase.Uniform, v0, v1, v2 uint32) { + C.gl4_3compat_glProgramUniform3ui(gl.funcs, C.GLuint(program), C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3dv.xml +func (gl *GL) ProgramUniform3dv(program glbase.Program, location glbase.Uniform, count int, value []float64) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_3compat_glProgramUniform3dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3d.xml +func (gl *GL) ProgramUniform3d(program glbase.Program, location glbase.Uniform, v0, v1, v2 float64) { + C.gl4_3compat_glProgramUniform3d(gl.funcs, C.GLuint(program), C.GLint(location), C.GLdouble(v0), C.GLdouble(v1), C.GLdouble(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3fv.xml +func (gl *GL) ProgramUniform3fv(program glbase.Program, location glbase.Uniform, count int, value []float32) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_3compat_glProgramUniform3fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3f.xml +func (gl *GL) ProgramUniform3f(program glbase.Program, location glbase.Uniform, v0, v1, v2 float32) { + C.gl4_3compat_glProgramUniform3f(gl.funcs, C.GLuint(program), C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3iv.xml +func (gl *GL) ProgramUniform3iv(program glbase.Program, location glbase.Uniform, count int, value []int32) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_3compat_glProgramUniform3iv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3i.xml +func (gl *GL) ProgramUniform3i(program glbase.Program, location glbase.Uniform, v0, v1, v2 int32) { + C.gl4_3compat_glProgramUniform3i(gl.funcs, C.GLuint(program), C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2uiv.xml +func (gl *GL) ProgramUniform2uiv(program glbase.Program, location glbase.Uniform, count int, value []uint32) { + C.gl4_3compat_glProgramUniform2uiv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2ui.xml +func (gl *GL) ProgramUniform2ui(program glbase.Program, location glbase.Uniform, v0, v1 uint32) { + C.gl4_3compat_glProgramUniform2ui(gl.funcs, C.GLuint(program), C.GLint(location), C.GLuint(v0), C.GLuint(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2dv.xml +func (gl *GL) ProgramUniform2dv(program glbase.Program, location glbase.Uniform, count int, value []float64) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_3compat_glProgramUniform2dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2d.xml +func (gl *GL) ProgramUniform2d(program glbase.Program, location glbase.Uniform, v0, v1 float64) { + C.gl4_3compat_glProgramUniform2d(gl.funcs, C.GLuint(program), C.GLint(location), C.GLdouble(v0), C.GLdouble(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2fv.xml +func (gl *GL) ProgramUniform2fv(program glbase.Program, location glbase.Uniform, count int, value []float32) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_3compat_glProgramUniform2fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2f.xml +func (gl *GL) ProgramUniform2f(program glbase.Program, location glbase.Uniform, v0, v1 float32) { + C.gl4_3compat_glProgramUniform2f(gl.funcs, C.GLuint(program), C.GLint(location), C.GLfloat(v0), C.GLfloat(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2iv.xml +func (gl *GL) ProgramUniform2iv(program glbase.Program, location glbase.Uniform, count int, value []int32) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_3compat_glProgramUniform2iv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2i.xml +func (gl *GL) ProgramUniform2i(program glbase.Program, location glbase.Uniform, v0, v1 int32) { + C.gl4_3compat_glProgramUniform2i(gl.funcs, C.GLuint(program), C.GLint(location), C.GLint(v0), C.GLint(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1uiv.xml +func (gl *GL) ProgramUniform1uiv(program glbase.Program, location glbase.Uniform, count int, value []uint32) { + C.gl4_3compat_glProgramUniform1uiv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1ui.xml +func (gl *GL) ProgramUniform1ui(program glbase.Program, location glbase.Uniform, v0 uint32) { + C.gl4_3compat_glProgramUniform1ui(gl.funcs, C.GLuint(program), C.GLint(location), C.GLuint(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1dv.xml +func (gl *GL) ProgramUniform1dv(program glbase.Program, location glbase.Uniform, count int, value []float64) { + C.gl4_3compat_glProgramUniform1dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1d.xml +func (gl *GL) ProgramUniform1d(program glbase.Program, location glbase.Uniform, v0 float64) { + C.gl4_3compat_glProgramUniform1d(gl.funcs, C.GLuint(program), C.GLint(location), C.GLdouble(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1fv.xml +func (gl *GL) ProgramUniform1fv(program glbase.Program, location glbase.Uniform, count int, value []float32) { + C.gl4_3compat_glProgramUniform1fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1f.xml +func (gl *GL) ProgramUniform1f(program glbase.Program, location glbase.Uniform, v0 float32) { + C.gl4_3compat_glProgramUniform1f(gl.funcs, C.GLuint(program), C.GLint(location), C.GLfloat(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1iv.xml +func (gl *GL) ProgramUniform1iv(program glbase.Program, location glbase.Uniform, count int, value []int32) { + C.gl4_3compat_glProgramUniform1iv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1i.xml +func (gl *GL) ProgramUniform1i(program glbase.Program, location glbase.Uniform, v0 int32) { + C.gl4_3compat_glProgramUniform1i(gl.funcs, C.GLuint(program), C.GLint(location), C.GLint(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramPipelineiv.xml +func (gl *GL) GetProgramPipelineiv(pipeline uint32, pname glbase.Enum, params []int32) { + C.gl4_3compat_glGetProgramPipelineiv(gl.funcs, C.GLuint(pipeline), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsProgramPipeline.xml +func (gl *GL) IsProgramPipeline(pipeline uint32) bool { + glresult := C.gl4_3compat_glIsProgramPipeline(gl.funcs, C.GLuint(pipeline)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenProgramPipelines.xml +func (gl *GL) GenProgramPipelines(n int, pipelines []uint32) { + C.gl4_3compat_glGenProgramPipelines(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&pipelines[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteProgramPipelines.xml +func (gl *GL) DeleteProgramPipelines(n int, pipelines []uint32) { + C.gl4_3compat_glDeleteProgramPipelines(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&pipelines[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindProgramPipeline.xml +func (gl *GL) BindProgramPipeline(pipeline uint32) { + C.gl4_3compat_glBindProgramPipeline(gl.funcs, C.GLuint(pipeline)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glActiveShaderProgram.xml +func (gl *GL) ActiveShaderProgram(pipeline uint32, program glbase.Program) { + C.gl4_3compat_glActiveShaderProgram(gl.funcs, C.GLuint(pipeline), C.GLuint(program)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUseProgramStages.xml +func (gl *GL) UseProgramStages(pipeline uint32, stages glbase.Bitfield, program glbase.Program) { + C.gl4_3compat_glUseProgramStages(gl.funcs, C.GLuint(pipeline), C.GLbitfield(stages), C.GLuint(program)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramParameteri.xml +func (gl *GL) ProgramParameteri(program glbase.Program, pname glbase.Enum, value int32) { + C.gl4_3compat_glProgramParameteri(gl.funcs, C.GLuint(program), C.GLenum(pname), C.GLint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramBinary.xml +func (gl *GL) ProgramBinary(program glbase.Program, binaryFormat glbase.Enum, binary interface{}, length int32) { + var binary_ptr unsafe.Pointer + var binary_v = reflect.ValueOf(binary) + if binary != nil && binary_v.Kind() != reflect.Slice { + panic("parameter binary must be a slice") + } + if binary != nil { + binary_ptr = unsafe.Pointer(binary_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glProgramBinary(gl.funcs, C.GLuint(program), C.GLenum(binaryFormat), binary_ptr, C.GLsizei(length)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramBinary.xml +func (gl *GL) GetProgramBinary(program glbase.Program, bufSize int32, length []int32, binaryFormat []glbase.Enum, binary interface{}) { + var binary_ptr unsafe.Pointer + var binary_v = reflect.ValueOf(binary) + if binary != nil && binary_v.Kind() != reflect.Slice { + panic("parameter binary must be a slice") + } + if binary != nil { + binary_ptr = unsafe.Pointer(binary_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glGetProgramBinary(gl.funcs, C.GLuint(program), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLenum)(unsafe.Pointer(&binaryFormat[0])), binary_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearDepthf.xml +func (gl *GL) ClearDepthf(dd float32) { + C.gl4_3compat_glClearDepthf(gl.funcs, C.GLfloat(dd)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDepthRangef.xml +func (gl *GL) DepthRangef(n, f float32) { + C.gl4_3compat_glDepthRangef(gl.funcs, C.GLfloat(n), C.GLfloat(f)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetShaderPrecisionFormat.xml +func (gl *GL) GetShaderPrecisionFormat(shadertype, precisionType glbase.Enum, range_, precision []int32) { + C.gl4_3compat_glGetShaderPrecisionFormat(gl.funcs, C.GLenum(shadertype), C.GLenum(precisionType), (*C.GLint)(unsafe.Pointer(&range_[0])), (*C.GLint)(unsafe.Pointer(&precision[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glShaderBinary.xml +func (gl *GL) ShaderBinary(count int, shaders []glbase.Shader, binaryFormat glbase.Enum, binary interface{}, length int32) { + var binary_ptr unsafe.Pointer + var binary_v = reflect.ValueOf(binary) + if binary != nil && binary_v.Kind() != reflect.Slice { + panic("parameter binary must be a slice") + } + if binary != nil { + binary_ptr = unsafe.Pointer(binary_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glShaderBinary(gl.funcs, C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&shaders[0])), C.GLenum(binaryFormat), binary_ptr, C.GLsizei(length)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glReleaseShaderCompiler.xml +func (gl *GL) ReleaseShaderCompiler() { + C.gl4_3compat_glReleaseShaderCompiler(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexStorage3D.xml +func (gl *GL) TexStorage3D(target glbase.Enum, levels int32, internalFormat glbase.Enum, width, height int, depth int32) { + C.gl4_3compat_glTexStorage3D(gl.funcs, C.GLenum(target), C.GLsizei(levels), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexStorage2D.xml +func (gl *GL) TexStorage2D(target glbase.Enum, levels int32, internalFormat glbase.Enum, width, height int) { + C.gl4_3compat_glTexStorage2D(gl.funcs, C.GLenum(target), C.GLsizei(levels), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexStorage1D.xml +func (gl *GL) TexStorage1D(target glbase.Enum, levels int32, internalFormat glbase.Enum, width int) { + C.gl4_3compat_glTexStorage1D(gl.funcs, C.GLenum(target), C.GLsizei(levels), C.GLenum(internalFormat), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMemoryBarrier.xml +func (gl *GL) MemoryBarrier(barriers glbase.Bitfield) { + C.gl4_3compat_glMemoryBarrier(gl.funcs, C.GLbitfield(barriers)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindImageTexture.xml +func (gl *GL) BindImageTexture(unit uint32, texture glbase.Texture, level int, layered bool, layer int32, access, format glbase.Enum) { + C.gl4_3compat_glBindImageTexture(gl.funcs, C.GLuint(unit), C.GLuint(texture), C.GLint(level), *(*C.GLboolean)(unsafe.Pointer(&layered)), C.GLint(layer), C.GLenum(access), C.GLenum(format)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveAtomicCounterBufferiv.xml +func (gl *GL) GetActiveAtomicCounterBufferiv(program glbase.Program, bufferIndex uint32, pname glbase.Enum, params []int32) { + C.gl4_3compat_glGetActiveAtomicCounterBufferiv(gl.funcs, C.GLuint(program), C.GLuint(bufferIndex), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetInternalformativ.xml +func (gl *GL) GetInternalformativ(target, internalFormat, pname glbase.Enum, bufSize int32, params []int32) { + C.gl4_3compat_glGetInternalformativ(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLenum(pname), C.GLsizei(bufSize), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawTransformFeedbackStreamInstanced.xml +func (gl *GL) DrawTransformFeedbackStreamInstanced(mode glbase.Enum, id, stream uint32, instancecount int32) { + C.gl4_3compat_glDrawTransformFeedbackStreamInstanced(gl.funcs, C.GLenum(mode), C.GLuint(id), C.GLuint(stream), C.GLsizei(instancecount)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawTransformFeedbackInstanced.xml +func (gl *GL) DrawTransformFeedbackInstanced(mode glbase.Enum, id uint32, instancecount int32) { + C.gl4_3compat_glDrawTransformFeedbackInstanced(gl.funcs, C.GLenum(mode), C.GLuint(id), C.GLsizei(instancecount)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsInstancedBaseVertexBaseInstance.xml +func (gl *GL) DrawElementsInstancedBaseVertexBaseInstance(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, instancecount, basevertex int32, baseinstance uint32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glDrawElementsInstancedBaseVertexBaseInstance(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLsizei(instancecount), C.GLint(basevertex), C.GLuint(baseinstance)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsInstancedBaseInstance.xml +func (gl *GL) DrawElementsInstancedBaseInstance(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, instancecount int32, baseinstance uint32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glDrawElementsInstancedBaseInstance(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLsizei(instancecount), C.GLuint(baseinstance)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawArraysInstancedBaseInstance.xml +func (gl *GL) DrawArraysInstancedBaseInstance(mode glbase.Enum, first, count int, instancecount int32, baseinstance uint32) { + C.gl4_3compat_glDrawArraysInstancedBaseInstance(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count), C.GLsizei(instancecount), C.GLuint(baseinstance)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexStorage3DMultisample.xml +func (gl *GL) TexStorage3DMultisample(target glbase.Enum, samples int32, internalFormat glbase.Enum, width, height int, depth int32, fixedsamplelocations bool) { + C.gl4_3compat_glTexStorage3DMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), *(*C.GLboolean)(unsafe.Pointer(&fixedsamplelocations))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexStorage2DMultisample.xml +func (gl *GL) TexStorage2DMultisample(target glbase.Enum, samples int32, internalFormat glbase.Enum, width, height int, fixedsamplelocations bool) { + C.gl4_3compat_glTexStorage2DMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), *(*C.GLboolean)(unsafe.Pointer(&fixedsamplelocations))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexBufferRange.xml +func (gl *GL) TexBufferRange(target, internalFormat glbase.Enum, buffer glbase.Buffer, offset, size int) { + C.gl4_3compat_glTexBufferRange(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLuint(buffer), C.GLintptr(offset), C.GLsizeiptr(size)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glShaderStorageBlockBinding.xml +func (gl *GL) ShaderStorageBlockBinding(program glbase.Program, storageBlockIndex, storageBlockBinding uint32) { + C.gl4_3compat_glShaderStorageBlockBinding(gl.funcs, C.GLuint(program), C.GLuint(storageBlockIndex), C.GLuint(storageBlockBinding)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramResourceLocationIndex.xml +func (gl *GL) GetProgramResourceLocationIndex(program glbase.Program, programInterface glbase.Enum, name []byte) int32 { + glresult := C.gl4_3compat_glGetProgramResourceLocationIndex(gl.funcs, C.GLuint(program), C.GLenum(programInterface), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramResourceLocation.xml +func (gl *GL) GetProgramResourceLocation(program glbase.Program, programInterface glbase.Enum, name []byte) int32 { + glresult := C.gl4_3compat_glGetProgramResourceLocation(gl.funcs, C.GLuint(program), C.GLenum(programInterface), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramResourceiv.xml +func (gl *GL) GetProgramResourceiv(program glbase.Program, programInterface glbase.Enum, index uint32, propCount int32, props []glbase.Enum, bufSize int32, length, params []int32) { + C.gl4_3compat_glGetProgramResourceiv(gl.funcs, C.GLuint(program), C.GLenum(programInterface), C.GLuint(index), C.GLsizei(propCount), (*C.GLenum)(unsafe.Pointer(&props[0])), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramResourceName.xml +func (gl *GL) GetProgramResourceName(program glbase.Program, programInterface glbase.Enum, index uint32, bufSize int32, length []int32, name []byte) { + C.gl4_3compat_glGetProgramResourceName(gl.funcs, C.GLuint(program), C.GLenum(programInterface), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramResourceIndex.xml +func (gl *GL) GetProgramResourceIndex(program glbase.Program, programInterface glbase.Enum, name []byte) uint32 { + glresult := C.gl4_3compat_glGetProgramResourceIndex(gl.funcs, C.GLuint(program), C.GLenum(programInterface), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramInterfaceiv.xml +func (gl *GL) GetProgramInterfaceiv(program glbase.Program, programInterface, pname glbase.Enum, params []int32) { + C.gl4_3compat_glGetProgramInterfaceiv(gl.funcs, C.GLuint(program), C.GLenum(programInterface), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiDrawElementsIndirect.xml +func (gl *GL) MultiDrawElementsIndirect(mode, gltype glbase.Enum, indirect interface{}, drawcount int32, stride int) { + var indirect_ptr unsafe.Pointer + var indirect_v = reflect.ValueOf(indirect) + if indirect != nil && indirect_v.Kind() != reflect.Slice { + panic("parameter indirect must be a slice") + } + if indirect != nil { + indirect_ptr = unsafe.Pointer(indirect_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glMultiDrawElementsIndirect(gl.funcs, C.GLenum(mode), C.GLenum(gltype), indirect_ptr, C.GLsizei(drawcount), C.GLsizei(stride)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiDrawArraysIndirect.xml +func (gl *GL) MultiDrawArraysIndirect(mode glbase.Enum, indirect interface{}, drawcount int32, stride int) { + var indirect_ptr unsafe.Pointer + var indirect_v = reflect.ValueOf(indirect) + if indirect != nil && indirect_v.Kind() != reflect.Slice { + panic("parameter indirect must be a slice") + } + if indirect != nil { + indirect_ptr = unsafe.Pointer(indirect_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glMultiDrawArraysIndirect(gl.funcs, C.GLenum(mode), indirect_ptr, C.GLsizei(drawcount), C.GLsizei(stride)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glInvalidateSubFramebuffer.xml +func (gl *GL) InvalidateSubFramebuffer(target glbase.Enum, numAttachments int32, attachments []glbase.Enum, x, y, width, height int) { + C.gl4_3compat_glInvalidateSubFramebuffer(gl.funcs, C.GLenum(target), C.GLsizei(numAttachments), (*C.GLenum)(unsafe.Pointer(&attachments[0])), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glInvalidateFramebuffer.xml +func (gl *GL) InvalidateFramebuffer(target glbase.Enum, numAttachments int32, attachments []glbase.Enum) { + C.gl4_3compat_glInvalidateFramebuffer(gl.funcs, C.GLenum(target), C.GLsizei(numAttachments), (*C.GLenum)(unsafe.Pointer(&attachments[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glInvalidateBufferData.xml +func (gl *GL) InvalidateBufferData(buffer glbase.Buffer) { + C.gl4_3compat_glInvalidateBufferData(gl.funcs, C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glInvalidateBufferSubData.xml +func (gl *GL) InvalidateBufferSubData(buffer glbase.Buffer, offset, length int) { + C.gl4_3compat_glInvalidateBufferSubData(gl.funcs, C.GLuint(buffer), C.GLintptr(offset), C.GLsizeiptr(length)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glInvalidateTexImage.xml +func (gl *GL) InvalidateTexImage(texture glbase.Texture, level int) { + C.gl4_3compat_glInvalidateTexImage(gl.funcs, C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glInvalidateTexSubImage.xml +func (gl *GL) InvalidateTexSubImage(texture glbase.Texture, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32) { + C.gl4_3compat_glInvalidateTexSubImage(gl.funcs, C.GLuint(texture), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetInternalformati64v.xml +func (gl *GL) GetInternalformati64v(target, internalFormat, pname glbase.Enum, bufSize int32, params []int64) { + C.gl4_3compat_glGetInternalformati64v(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLenum(pname), C.GLsizei(bufSize), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFramebufferParameteriv.xml +func (gl *GL) GetFramebufferParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_3compat_glGetFramebufferParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferParameteri.xml +func (gl *GL) FramebufferParameteri(target, pname glbase.Enum, param int32) { + C.gl4_3compat_glFramebufferParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexBindingDivisor.xml +func (gl *GL) VertexBindingDivisor(bindingindex, divisor uint32) { + C.gl4_3compat_glVertexBindingDivisor(gl.funcs, C.GLuint(bindingindex), C.GLuint(divisor)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribBinding.xml +func (gl *GL) VertexAttribBinding(attribindex, bindingindex uint32) { + C.gl4_3compat_glVertexAttribBinding(gl.funcs, C.GLuint(attribindex), C.GLuint(bindingindex)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribLFormat.xml +func (gl *GL) VertexAttribLFormat(attribindex uint32, size int, gltype glbase.Enum, relativeoffset uint32) { + C.gl4_3compat_glVertexAttribLFormat(gl.funcs, C.GLuint(attribindex), C.GLint(size), C.GLenum(gltype), C.GLuint(relativeoffset)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribIFormat.xml +func (gl *GL) VertexAttribIFormat(attribindex uint32, size int, gltype glbase.Enum, relativeoffset uint32) { + C.gl4_3compat_glVertexAttribIFormat(gl.funcs, C.GLuint(attribindex), C.GLint(size), C.GLenum(gltype), C.GLuint(relativeoffset)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribFormat.xml +func (gl *GL) VertexAttribFormat(attribindex uint32, size int, gltype glbase.Enum, normalized bool, relativeoffset uint32) { + C.gl4_3compat_glVertexAttribFormat(gl.funcs, C.GLuint(attribindex), C.GLint(size), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(relativeoffset)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindVertexBuffer.xml +func (gl *GL) BindVertexBuffer(bindingindex uint32, buffer glbase.Buffer, offset, stride int) { + C.gl4_3compat_glBindVertexBuffer(gl.funcs, C.GLuint(bindingindex), C.GLuint(buffer), C.GLintptr(offset), C.GLsizei(stride)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTextureView.xml +func (gl *GL) TextureView(texture glbase.Texture, target glbase.Enum, origtexture uint32, internalFormat glbase.Enum, minlevel, numlevels, minlayer, numlayers uint32) { + C.gl4_3compat_glTextureView(gl.funcs, C.GLuint(texture), C.GLenum(target), C.GLuint(origtexture), C.GLenum(internalFormat), C.GLuint(minlevel), C.GLuint(numlevels), C.GLuint(minlayer), C.GLuint(numlayers)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyImageSubData.xml +func (gl *GL) CopyImageSubData(srcName uint32, srcTarget glbase.Enum, srcLevel, srcX, srcY, srcZ int32, dstName uint32, dstTarget glbase.Enum, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth int32) { + C.gl4_3compat_glCopyImageSubData(gl.funcs, C.GLuint(srcName), C.GLenum(srcTarget), C.GLint(srcLevel), C.GLint(srcX), C.GLint(srcY), C.GLint(srcZ), C.GLuint(dstName), C.GLenum(dstTarget), C.GLint(dstLevel), C.GLint(dstX), C.GLint(dstY), C.GLint(dstZ), C.GLsizei(srcWidth), C.GLsizei(srcHeight), C.GLsizei(srcDepth)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDispatchComputeIndirect.xml +func (gl *GL) DispatchComputeIndirect(indirect int) { + C.gl4_3compat_glDispatchComputeIndirect(gl.funcs, C.GLintptr(indirect)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDispatchCompute.xml +func (gl *GL) DispatchCompute(num_groups_x, num_groups_y, num_groups_z uint32) { + C.gl4_3compat_glDispatchCompute(gl.funcs, C.GLuint(num_groups_x), C.GLuint(num_groups_y), C.GLuint(num_groups_z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferSubData.xml +func (gl *GL) ClearBufferSubData(target, internalFormat glbase.Enum, offset, size int, format, gltype glbase.Enum, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glClearBufferSubData(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLintptr(offset), C.GLsizeiptr(size), C.GLenum(format), C.GLenum(gltype), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferData.xml +func (gl *GL) ClearBufferData(target, internalFormat, format, gltype glbase.Enum, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glClearBufferData(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLenum(format), C.GLenum(gltype), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTranslatef.xml +func (gl *GL) Translatef(x, y, z float32) { + C.gl4_3compat_glTranslatef(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTranslated.xml +func (gl *GL) Translated(x, y, z float64) { + C.gl4_3compat_glTranslated(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glScalef.xml +func (gl *GL) Scalef(x, y, z float32) { + C.gl4_3compat_glScalef(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glScaled.xml +func (gl *GL) Scaled(x, y, z float64) { + C.gl4_3compat_glScaled(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRotatef.xml +func (gl *GL) Rotatef(angle, x, y, z float32) { + C.gl4_3compat_glRotatef(gl.funcs, C.GLfloat(angle), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRotated.xml +func (gl *GL) Rotated(angle, x, y, z float64) { + C.gl4_3compat_glRotated(gl.funcs, C.GLdouble(angle), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPushMatrix.xml +func (gl *GL) PushMatrix() { + C.gl4_3compat_glPushMatrix(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPopMatrix.xml +func (gl *GL) PopMatrix() { + C.gl4_3compat_glPopMatrix(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glOrtho.xml +func (gl *GL) Ortho(left, right, bottom, top, zNear, zFar float64) { + C.gl4_3compat_glOrtho(gl.funcs, C.GLdouble(left), C.GLdouble(right), C.GLdouble(bottom), C.GLdouble(top), C.GLdouble(zNear), C.GLdouble(zFar)) +} + +// MultMatrixd multiplies the current matrix with the provided matrix. +// +// The m parameter must hold 16 consecutive elements of a 4x4 column-major matrix. +// +// The current matrix is determined by the current matrix mode (see +// MatrixMode). It is either the projection matrix, modelview matrix, or the +// texture matrix. +// +// For example, if the current matrix is C and the coordinates to be transformed +// are v = (v[0], v[1], v[2], v[3]), then the current transformation is C × v, or +// +// c[0] c[4] c[8] c[12] v[0] +// c[1] c[5] c[9] c[13] v[1] +// c[2] c[6] c[10] c[14] X v[2] +// c[3] c[7] c[11] c[15] v[3] +// +// Calling MultMatrix with an argument of m = m[0], m[1], ..., m[15] +// replaces the current transformation with (C X M) x v, or +// +// c[0] c[4] c[8] c[12] m[0] m[4] m[8] m[12] v[0] +// c[1] c[5] c[9] c[13] m[1] m[5] m[9] m[13] v[1] +// c[2] c[6] c[10] c[14] X m[2] m[6] m[10] m[14] X v[2] +// c[3] c[7] c[11] c[15] m[3] m[7] m[11] m[15] v[3] +// +// Where 'X' denotes matrix multiplication, and v is represented as a 4x1 matrix. +// +// While the elements of the matrix may be specified with single or double +// precision, the GL may store or operate on these values in less-than-single +// precision. +// +// In many computer languages, 4×4 arrays are represented in row-major +// order. The transformations just described represent these matrices in +// column-major order. The order of the multiplication is important. For +// example, if the current transformation is a rotation, and MultMatrix is +// called with a translation matrix, the translation is done directly on the +// coordinates to be transformed, while the rotation is done on the results +// of that translation. +// +// GL.INVALID_OPERATION is generated if MultMatrix is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) MultMatrixd(m []float64) { + if len(m) != 16 { + panic("parameter m must have length 16 for the 4x4 matrix") + } + C.gl4_3compat_glMultMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// MultMatrixf multiplies the current matrix with the provided matrix. +// +// The m parameter must hold 16 consecutive elements of a 4x4 column-major matrix. +// +// The current matrix is determined by the current matrix mode (see +// MatrixMode). It is either the projection matrix, modelview matrix, or the +// texture matrix. +// +// For example, if the current matrix is C and the coordinates to be transformed +// are v = (v[0], v[1], v[2], v[3]), then the current transformation is C × v, or +// +// c[0] c[4] c[8] c[12] v[0] +// c[1] c[5] c[9] c[13] v[1] +// c[2] c[6] c[10] c[14] X v[2] +// c[3] c[7] c[11] c[15] v[3] +// +// Calling MultMatrix with an argument of m = m[0], m[1], ..., m[15] +// replaces the current transformation with (C X M) x v, or +// +// c[0] c[4] c[8] c[12] m[0] m[4] m[8] m[12] v[0] +// c[1] c[5] c[9] c[13] m[1] m[5] m[9] m[13] v[1] +// c[2] c[6] c[10] c[14] X m[2] m[6] m[10] m[14] X v[2] +// c[3] c[7] c[11] c[15] m[3] m[7] m[11] m[15] v[3] +// +// Where 'X' denotes matrix multiplication, and v is represented as a 4x1 matrix. +// +// While the elements of the matrix may be specified with single or double +// precision, the GL may store or operate on these values in less-than-single +// precision. +// +// In many computer languages, 4×4 arrays are represented in row-major +// order. The transformations just described represent these matrices in +// column-major order. The order of the multiplication is important. For +// example, if the current transformation is a rotation, and MultMatrix is +// called with a translation matrix, the translation is done directly on the +// coordinates to be transformed, while the rotation is done on the results +// of that translation. +// +// GL.INVALID_OPERATION is generated if MultMatrix is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) MultMatrixf(m []float32) { + if len(m) != 16 { + panic("parameter m must have length 16 for the 4x4 matrix") + } + C.gl4_3compat_glMultMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMatrixMode.xml +func (gl *GL) MatrixMode(mode glbase.Enum) { + C.gl4_3compat_glMatrixMode(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLoadMatrixd.xml +func (gl *GL) LoadMatrixd(m []float64) { + C.gl4_3compat_glLoadMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLoadMatrixf.xml +func (gl *GL) LoadMatrixf(m []float32) { + C.gl4_3compat_glLoadMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLoadIdentity.xml +func (gl *GL) LoadIdentity() { + C.gl4_3compat_glLoadIdentity(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFrustum.xml +func (gl *GL) Frustum(left, right, bottom, top, zNear, zFar float64) { + C.gl4_3compat_glFrustum(gl.funcs, C.GLdouble(left), C.GLdouble(right), C.GLdouble(bottom), C.GLdouble(top), C.GLdouble(zNear), C.GLdouble(zFar)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsList.xml +func (gl *GL) IsList(list uint32) bool { + glresult := C.gl4_3compat_glIsList(gl.funcs, C.GLuint(list)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexGeniv.xml +func (gl *GL) GetTexGeniv(coord, pname glbase.Enum, params []int32) { + C.gl4_3compat_glGetTexGeniv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexGenfv.xml +func (gl *GL) GetTexGenfv(coord, pname glbase.Enum, params []float32) { + C.gl4_3compat_glGetTexGenfv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexGendv.xml +func (gl *GL) GetTexGendv(coord, pname glbase.Enum, params []float64) { + C.gl4_3compat_glGetTexGendv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexEnviv.xml +func (gl *GL) GetTexEnviv(target, pname glbase.Enum, params []int32) { + C.gl4_3compat_glGetTexEnviv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexEnvfv.xml +func (gl *GL) GetTexEnvfv(target, pname glbase.Enum, params []float32) { + C.gl4_3compat_glGetTexEnvfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetPolygonStipple.xml +func (gl *GL) GetPolygonStipple(mask []uint8) { + C.gl4_3compat_glGetPolygonStipple(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&mask[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetPixelMapusv.xml +func (gl *GL) GetPixelMapusv(glmap glbase.Enum, values []uint16) { + C.gl4_3compat_glGetPixelMapusv(gl.funcs, C.GLenum(glmap), (*C.GLushort)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetPixelMapuiv.xml +func (gl *GL) GetPixelMapuiv(glmap glbase.Enum, values []uint32) { + C.gl4_3compat_glGetPixelMapuiv(gl.funcs, C.GLenum(glmap), (*C.GLuint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetPixelMapfv.xml +func (gl *GL) GetPixelMapfv(glmap glbase.Enum, values []float32) { + C.gl4_3compat_glGetPixelMapfv(gl.funcs, C.GLenum(glmap), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMaterialiv.xml +func (gl *GL) GetMaterialiv(face, pname glbase.Enum, params []int32) { + C.gl4_3compat_glGetMaterialiv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMaterialfv.xml +func (gl *GL) GetMaterialfv(face, pname glbase.Enum, params []float32) { + C.gl4_3compat_glGetMaterialfv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMapiv.xml +func (gl *GL) GetMapiv(target, query glbase.Enum, v []int32) { + C.gl4_3compat_glGetMapiv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMapfv.xml +func (gl *GL) GetMapfv(target, query glbase.Enum, v []float32) { + C.gl4_3compat_glGetMapfv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMapdv.xml +func (gl *GL) GetMapdv(target, query glbase.Enum, v []float64) { + C.gl4_3compat_glGetMapdv(gl.funcs, C.GLenum(target), C.GLenum(query), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetLightiv.xml +func (gl *GL) GetLightiv(light, pname glbase.Enum, params []int32) { + C.gl4_3compat_glGetLightiv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetLightfv.xml +func (gl *GL) GetLightfv(light, pname glbase.Enum, params []float32) { + C.gl4_3compat_glGetLightfv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetClipPlane.xml +func (gl *GL) GetClipPlane(plane glbase.Enum, equation []float64) { + C.gl4_3compat_glGetClipPlane(gl.funcs, C.GLenum(plane), (*C.GLdouble)(unsafe.Pointer(&equation[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawPixels.xml +func (gl *GL) DrawPixels(width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glDrawPixels(gl.funcs, C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyPixels.xml +func (gl *GL) CopyPixels(x, y, width, height int, gltype glbase.Enum) { + C.gl4_3compat_glCopyPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(gltype)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelMapusv.xml +func (gl *GL) PixelMapusv(glmap glbase.Enum, mapsize int32, values []uint16) { + C.gl4_3compat_glPixelMapusv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLushort)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelMapuiv.xml +func (gl *GL) PixelMapuiv(glmap glbase.Enum, mapsize int32, values []uint32) { + C.gl4_3compat_glPixelMapuiv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLuint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelMapfv.xml +func (gl *GL) PixelMapfv(glmap glbase.Enum, mapsize int32, values []float32) { + C.gl4_3compat_glPixelMapfv(gl.funcs, C.GLenum(glmap), C.GLint(mapsize), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelTransferi.xml +func (gl *GL) PixelTransferi(pname glbase.Enum, param int32) { + C.gl4_3compat_glPixelTransferi(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelTransferf.xml +func (gl *GL) PixelTransferf(pname glbase.Enum, param float32) { + C.gl4_3compat_glPixelTransferf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelZoom.xml +func (gl *GL) PixelZoom(xfactor, yfactor float32) { + C.gl4_3compat_glPixelZoom(gl.funcs, C.GLfloat(xfactor), C.GLfloat(yfactor)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glAlphaFunc.xml +func (gl *GL) AlphaFunc(glfunc glbase.Enum, ref float32) { + C.gl4_3compat_glAlphaFunc(gl.funcs, C.GLenum(glfunc), C.GLfloat(ref)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalPoint2.xml +func (gl *GL) EvalPoint2(i, j int32) { + C.gl4_3compat_glEvalPoint2(gl.funcs, C.GLint(i), C.GLint(j)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalMesh2.xml +func (gl *GL) EvalMesh2(mode glbase.Enum, i1, i2, j1, j2 int32) { + C.gl4_3compat_glEvalMesh2(gl.funcs, C.GLenum(mode), C.GLint(i1), C.GLint(i2), C.GLint(j1), C.GLint(j2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalPoint1.xml +func (gl *GL) EvalPoint1(i int32) { + C.gl4_3compat_glEvalPoint1(gl.funcs, C.GLint(i)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalMesh1.xml +func (gl *GL) EvalMesh1(mode glbase.Enum, i1, i2 int32) { + C.gl4_3compat_glEvalMesh1(gl.funcs, C.GLenum(mode), C.GLint(i1), C.GLint(i2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalCoord2fv.xml +func (gl *GL) EvalCoord2fv(u []float32) { + if len(u) != 2 { + panic("parameter u has incorrect length") + } + C.gl4_3compat_glEvalCoord2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalCoord2f.xml +func (gl *GL) EvalCoord2f(u, v float32) { + C.gl4_3compat_glEvalCoord2f(gl.funcs, C.GLfloat(u), C.GLfloat(v)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalCoord2dv.xml +func (gl *GL) EvalCoord2dv(u []float64) { + if len(u) != 2 { + panic("parameter u has incorrect length") + } + C.gl4_3compat_glEvalCoord2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalCoord2d.xml +func (gl *GL) EvalCoord2d(u, v float64) { + C.gl4_3compat_glEvalCoord2d(gl.funcs, C.GLdouble(u), C.GLdouble(v)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalCoord1fv.xml +func (gl *GL) EvalCoord1fv(u []float32) { + C.gl4_3compat_glEvalCoord1fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalCoord1f.xml +func (gl *GL) EvalCoord1f(u float32) { + C.gl4_3compat_glEvalCoord1f(gl.funcs, C.GLfloat(u)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalCoord1dv.xml +func (gl *GL) EvalCoord1dv(u []float64) { + C.gl4_3compat_glEvalCoord1dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&u[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEvalCoord1d.xml +func (gl *GL) EvalCoord1d(u float64) { + C.gl4_3compat_glEvalCoord1d(gl.funcs, C.GLdouble(u)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMapGrid2f.xml +func (gl *GL) MapGrid2f(un int32, u1, u2 float32, vn int32, v1, v2 float32) { + C.gl4_3compat_glMapGrid2f(gl.funcs, C.GLint(un), C.GLfloat(u1), C.GLfloat(u2), C.GLint(vn), C.GLfloat(v1), C.GLfloat(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMapGrid2d.xml +func (gl *GL) MapGrid2d(un int32, u1, u2 float64, vn int32, v1, v2 float64) { + C.gl4_3compat_glMapGrid2d(gl.funcs, C.GLint(un), C.GLdouble(u1), C.GLdouble(u2), C.GLint(vn), C.GLdouble(v1), C.GLdouble(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMapGrid1f.xml +func (gl *GL) MapGrid1f(un int32, u1, u2 float32) { + C.gl4_3compat_glMapGrid1f(gl.funcs, C.GLint(un), C.GLfloat(u1), C.GLfloat(u2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMapGrid1d.xml +func (gl *GL) MapGrid1d(un int32, u1, u2 float64) { + C.gl4_3compat_glMapGrid1d(gl.funcs, C.GLint(un), C.GLdouble(u1), C.GLdouble(u2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMap2f.xml +func (gl *GL) Map2f(target glbase.Enum, u1, u2 float32, ustride, uorder int32, v1, v2 float32, vstride, vorder int32, points []float32) { + C.gl4_3compat_glMap2f(gl.funcs, C.GLenum(target), C.GLfloat(u1), C.GLfloat(u2), C.GLint(ustride), C.GLint(uorder), C.GLfloat(v1), C.GLfloat(v2), C.GLint(vstride), C.GLint(vorder), (*C.GLfloat)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMap2d.xml +func (gl *GL) Map2d(target glbase.Enum, u1, u2 float64, ustride, uorder int32, v1, v2 float64, vstride, vorder int32, points []float64) { + C.gl4_3compat_glMap2d(gl.funcs, C.GLenum(target), C.GLdouble(u1), C.GLdouble(u2), C.GLint(ustride), C.GLint(uorder), C.GLdouble(v1), C.GLdouble(v2), C.GLint(vstride), C.GLint(vorder), (*C.GLdouble)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMap1f.xml +func (gl *GL) Map1f(target glbase.Enum, u1, u2 float32, stride, order int, points []float32) { + C.gl4_3compat_glMap1f(gl.funcs, C.GLenum(target), C.GLfloat(u1), C.GLfloat(u2), C.GLint(stride), C.GLint(order), (*C.GLfloat)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMap1d.xml +func (gl *GL) Map1d(target glbase.Enum, u1, u2 float64, stride, order int, points []float64) { + C.gl4_3compat_glMap1d(gl.funcs, C.GLenum(target), C.GLdouble(u1), C.GLdouble(u2), C.GLint(stride), C.GLint(order), (*C.GLdouble)(unsafe.Pointer(&points[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPushAttrib.xml +func (gl *GL) PushAttrib(mask glbase.Bitfield) { + C.gl4_3compat_glPushAttrib(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPopAttrib.xml +func (gl *GL) PopAttrib() { + C.gl4_3compat_glPopAttrib(gl.funcs) +} + +// Accum executes an operation on the accumulation buffer. +// +// Parameter op defines the accumulation buffer operation (GL.ACCUM, GL.LOAD, +// GL.ADD, GL.MULT, or GL.RETURN) and specifies how the value parameter is +// used. +// +// The accumulation buffer is an extended-range color buffer. Images are not +// rendered into it. Rather, images rendered into one of the color buffers +// are added to the contents of the accumulation buffer after rendering. +// Effects such as antialiasing (of points, lines, and polygons), motion +// blur, and depth of field can be created by accumulating images generated +// with different transformation matrices. +// +// Each pixel in the accumulation buffer consists of red, green, blue, and +// alpha values. The number of bits per component in the accumulation buffer +// depends on the implementation. You can examine this number by calling +// GetIntegerv four times, with arguments GL.ACCUM_RED_BITS, +// GL.ACCUM_GREEN_BITS, GL.ACCUM_BLUE_BITS, and GL.ACCUM_ALPHA_BITS. +// Regardless of the number of bits per component, the range of values stored +// by each component is (-1, 1). The accumulation buffer pixels are mapped +// one-to-one with frame buffer pixels. +// +// All accumulation buffer operations are limited to the area of the current +// scissor box and applied identically to the red, green, blue, and alpha +// components of each pixel. If a Accum operation results in a value outside +// the range (-1, 1), the contents of an accumulation buffer pixel component +// are undefined. +// +// The operations are as follows: +// +// GL.ACCUM +// Obtains R, G, B, and A values from the buffer currently selected for +// reading (see ReadBuffer). Each component value is divided by 2 n - +// 1 , where n is the number of bits allocated to each color component +// in the currently selected buffer. The result is a floating-point +// value in the range 0 1 , which is multiplied by value and added to +// the corresponding pixel component in the accumulation buffer, +// thereby updating the accumulation buffer. +// +// GL.LOAD +// Similar to GL.ACCUM, except that the current value in the +// accumulation buffer is not used in the calculation of the new value. +// That is, the R, G, B, and A values from the currently selected +// buffer are divided by 2 n - 1 , multiplied by value, and then stored +// in the corresponding accumulation buffer cell, overwriting the +// current value. +// +// GL.ADD +// Adds value to each R, G, B, and A in the accumulation buffer. +// +// GL.MULT +// Multiplies each R, G, B, and A in the accumulation buffer by value +// and returns the scaled component to its corresponding accumulation +// buffer location. +// +// GL.RETURN +// Transfers accumulation buffer values to the color buffer or buffers +// currently selected for writing. Each R, G, B, and A component is +// multiplied by value, then multiplied by 2 n - 1 , clamped to the +// range 0 2 n - 1 , and stored in the corresponding display buffer +// cell. The only fragment operations that are applied to this transfer +// are pixel ownership, scissor, dithering, and color writemasks. +// +// To clear the accumulation buffer, call ClearAccum with R, G, B, and A +// values to set it to, then call Clear with the accumulation buffer +// enabled. +// +// Error GL.INVALID_ENUM is generated if op is not an accepted value. +// GL.INVALID_OPERATION is generated if there is no accumulation buffer. +// GL.INVALID_OPERATION is generated if Accum is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) Accum(op glbase.Enum, value float32) { + C.gl4_3compat_glAccum(gl.funcs, C.GLenum(op), C.GLfloat(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexMask.xml +func (gl *GL) IndexMask(mask uint32) { + C.gl4_3compat_glIndexMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearIndex.xml +func (gl *GL) ClearIndex(c float32) { + C.gl4_3compat_glClearIndex(gl.funcs, C.GLfloat(c)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearAccum.xml +func (gl *GL) ClearAccum(red, green, blue, alpha float32) { + C.gl4_3compat_glClearAccum(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPushName.xml +func (gl *GL) PushName(name uint32) { + C.gl4_3compat_glPushName(gl.funcs, C.GLuint(name)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPopName.xml +func (gl *GL) PopName() { + C.gl4_3compat_glPopName(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPassThrough.xml +func (gl *GL) PassThrough(token float32) { + C.gl4_3compat_glPassThrough(gl.funcs, C.GLfloat(token)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLoadName.xml +func (gl *GL) LoadName(name uint32) { + C.gl4_3compat_glLoadName(gl.funcs, C.GLuint(name)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glInitNames.xml +func (gl *GL) InitNames() { + C.gl4_3compat_glInitNames(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRenderMode.xml +func (gl *GL) RenderMode(mode glbase.Enum) int32 { + glresult := C.gl4_3compat_glRenderMode(gl.funcs, C.GLenum(mode)) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSelectBuffer.xml +func (gl *GL) SelectBuffer(size int, buffer []glbase.Buffer) { + C.gl4_3compat_glSelectBuffer(gl.funcs, C.GLsizei(size), (*C.GLuint)(unsafe.Pointer(&buffer[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFeedbackBuffer.xml +func (gl *GL) FeedbackBuffer(size int, gltype glbase.Enum, buffer []float32) { + C.gl4_3compat_glFeedbackBuffer(gl.funcs, C.GLsizei(size), C.GLenum(gltype), (*C.GLfloat)(unsafe.Pointer(&buffer[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexGeniv.xml +func (gl *GL) TexGeniv(coord, pname glbase.Enum, params []int32) { + C.gl4_3compat_glTexGeniv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexGeni.xml +func (gl *GL) TexGeni(coord, pname glbase.Enum, param int32) { + C.gl4_3compat_glTexGeni(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexGenfv.xml +func (gl *GL) TexGenfv(coord, pname glbase.Enum, params []float32) { + C.gl4_3compat_glTexGenfv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexGenf.xml +func (gl *GL) TexGenf(coord, pname glbase.Enum, param float32) { + C.gl4_3compat_glTexGenf(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexGendv.xml +func (gl *GL) TexGendv(coord, pname glbase.Enum, params []float64) { + C.gl4_3compat_glTexGendv(gl.funcs, C.GLenum(coord), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexGend.xml +func (gl *GL) TexGend(coord, pname glbase.Enum, param float64) { + C.gl4_3compat_glTexGend(gl.funcs, C.GLenum(coord), C.GLenum(pname), C.GLdouble(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexEnviv.xml +func (gl *GL) TexEnviv(target, pname glbase.Enum, params []int32) { + C.gl4_3compat_glTexEnviv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexEnvi.xml +func (gl *GL) TexEnvi(target, pname glbase.Enum, param int32) { + C.gl4_3compat_glTexEnvi(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexEnvfv.xml +func (gl *GL) TexEnvfv(target, pname glbase.Enum, params []float32) { + C.gl4_3compat_glTexEnvfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexEnvf.xml +func (gl *GL) TexEnvf(target, pname glbase.Enum, param float32) { + C.gl4_3compat_glTexEnvf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glShadeModel.xml +func (gl *GL) ShadeModel(mode glbase.Enum) { + C.gl4_3compat_glShadeModel(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPolygonStipple.xml +func (gl *GL) PolygonStipple(mask []uint8) { + C.gl4_3compat_glPolygonStipple(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&mask[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMaterialiv.xml +func (gl *GL) Materialiv(face, pname glbase.Enum, params []int32) { + C.gl4_3compat_glMaterialiv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMateriali.xml +func (gl *GL) Materiali(face, pname glbase.Enum, param int32) { + C.gl4_3compat_glMateriali(gl.funcs, C.GLenum(face), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMaterialfv.xml +func (gl *GL) Materialfv(face, pname glbase.Enum, params []float32) { + C.gl4_3compat_glMaterialfv(gl.funcs, C.GLenum(face), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMaterialf.xml +func (gl *GL) Materialf(face, pname glbase.Enum, param float32) { + C.gl4_3compat_glMaterialf(gl.funcs, C.GLenum(face), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLineStipple.xml +func (gl *GL) LineStipple(factor int32, pattern uint16) { + C.gl4_3compat_glLineStipple(gl.funcs, C.GLint(factor), C.GLushort(pattern)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLightModeliv.xml +func (gl *GL) LightModeliv(pname glbase.Enum, params []int32) { + C.gl4_3compat_glLightModeliv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLightModeli.xml +func (gl *GL) LightModeli(pname glbase.Enum, param int32) { + C.gl4_3compat_glLightModeli(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLightModelfv.xml +func (gl *GL) LightModelfv(pname glbase.Enum, params []float32) { + C.gl4_3compat_glLightModelfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLightModelf.xml +func (gl *GL) LightModelf(pname glbase.Enum, param float32) { + C.gl4_3compat_glLightModelf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLightiv.xml +func (gl *GL) Lightiv(light, pname glbase.Enum, params []int32) { + C.gl4_3compat_glLightiv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLighti.xml +func (gl *GL) Lighti(light, pname glbase.Enum, param int32) { + C.gl4_3compat_glLighti(gl.funcs, C.GLenum(light), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLightfv.xml +func (gl *GL) Lightfv(light, pname glbase.Enum, params []float32) { + C.gl4_3compat_glLightfv(gl.funcs, C.GLenum(light), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLightf.xml +func (gl *GL) Lightf(light, pname glbase.Enum, param float32) { + C.gl4_3compat_glLightf(gl.funcs, C.GLenum(light), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogiv.xml +func (gl *GL) Fogiv(pname glbase.Enum, params []int32) { + C.gl4_3compat_glFogiv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogi.xml +func (gl *GL) Fogi(pname glbase.Enum, param int32) { + C.gl4_3compat_glFogi(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogfv.xml +func (gl *GL) Fogfv(pname glbase.Enum, params []float32) { + C.gl4_3compat_glFogfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogf.xml +func (gl *GL) Fogf(pname glbase.Enum, param float32) { + C.gl4_3compat_glFogf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorMaterial.xml +func (gl *GL) ColorMaterial(face, mode glbase.Enum) { + C.gl4_3compat_glColorMaterial(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClipPlane.xml +func (gl *GL) ClipPlane(plane glbase.Enum, equation []float64) { + C.gl4_3compat_glClipPlane(gl.funcs, C.GLenum(plane), (*C.GLdouble)(unsafe.Pointer(&equation[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex4sv.xml +func (gl *GL) Vertex4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glVertex4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex4s.xml +func (gl *GL) Vertex4s(x, y, z, w int16) { + C.gl4_3compat_glVertex4s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex4iv.xml +func (gl *GL) Vertex4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glVertex4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex4i.xml +func (gl *GL) Vertex4i(x, y, z, w int) { + C.gl4_3compat_glVertex4i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex4fv.xml +func (gl *GL) Vertex4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glVertex4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex4f.xml +func (gl *GL) Vertex4f(x, y, z, w float32) { + C.gl4_3compat_glVertex4f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex4dv.xml +func (gl *GL) Vertex4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glVertex4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex4d.xml +func (gl *GL) Vertex4d(x, y, z, w float64) { + C.gl4_3compat_glVertex4d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex3sv.xml +func (gl *GL) Vertex3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glVertex3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex3s.xml +func (gl *GL) Vertex3s(x, y, z int16) { + C.gl4_3compat_glVertex3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex3iv.xml +func (gl *GL) Vertex3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glVertex3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex3i.xml +func (gl *GL) Vertex3i(x, y, z int) { + C.gl4_3compat_glVertex3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex3fv.xml +func (gl *GL) Vertex3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glVertex3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex3f.xml +func (gl *GL) Vertex3f(x, y, z float32) { + C.gl4_3compat_glVertex3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex3dv.xml +func (gl *GL) Vertex3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glVertex3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex3d.xml +func (gl *GL) Vertex3d(x, y, z float64) { + C.gl4_3compat_glVertex3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex2sv.xml +func (gl *GL) Vertex2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glVertex2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex2s.xml +func (gl *GL) Vertex2s(x, y int16) { + C.gl4_3compat_glVertex2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex2iv.xml +func (gl *GL) Vertex2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glVertex2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex2i.xml +func (gl *GL) Vertex2i(x, y int) { + C.gl4_3compat_glVertex2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex2fv.xml +func (gl *GL) Vertex2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glVertex2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex2f.xml +func (gl *GL) Vertex2f(x, y float32) { + C.gl4_3compat_glVertex2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex2dv.xml +func (gl *GL) Vertex2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glVertex2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertex2d.xml +func (gl *GL) Vertex2d(x, y float64) { + C.gl4_3compat_glVertex2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord4sv.xml +func (gl *GL) TexCoord4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glTexCoord4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord4s.xml +func (gl *GL) TexCoord4s(s, t, r, q int16) { + C.gl4_3compat_glTexCoord4s(gl.funcs, C.GLshort(s), C.GLshort(t), C.GLshort(r), C.GLshort(q)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord4iv.xml +func (gl *GL) TexCoord4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glTexCoord4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord4i.xml +func (gl *GL) TexCoord4i(s, t, r, q int32) { + C.gl4_3compat_glTexCoord4i(gl.funcs, C.GLint(s), C.GLint(t), C.GLint(r), C.GLint(q)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord4fv.xml +func (gl *GL) TexCoord4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glTexCoord4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord4f.xml +func (gl *GL) TexCoord4f(s, t, r, q float32) { + C.gl4_3compat_glTexCoord4f(gl.funcs, C.GLfloat(s), C.GLfloat(t), C.GLfloat(r), C.GLfloat(q)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord4dv.xml +func (gl *GL) TexCoord4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glTexCoord4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord4d.xml +func (gl *GL) TexCoord4d(s, t, r, q float64) { + C.gl4_3compat_glTexCoord4d(gl.funcs, C.GLdouble(s), C.GLdouble(t), C.GLdouble(r), C.GLdouble(q)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord3sv.xml +func (gl *GL) TexCoord3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glTexCoord3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord3s.xml +func (gl *GL) TexCoord3s(s, t, r int16) { + C.gl4_3compat_glTexCoord3s(gl.funcs, C.GLshort(s), C.GLshort(t), C.GLshort(r)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord3iv.xml +func (gl *GL) TexCoord3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glTexCoord3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord3i.xml +func (gl *GL) TexCoord3i(s, t, r int32) { + C.gl4_3compat_glTexCoord3i(gl.funcs, C.GLint(s), C.GLint(t), C.GLint(r)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord3fv.xml +func (gl *GL) TexCoord3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glTexCoord3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord3f.xml +func (gl *GL) TexCoord3f(s, t, r float32) { + C.gl4_3compat_glTexCoord3f(gl.funcs, C.GLfloat(s), C.GLfloat(t), C.GLfloat(r)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord3dv.xml +func (gl *GL) TexCoord3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glTexCoord3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord3d.xml +func (gl *GL) TexCoord3d(s, t, r float64) { + C.gl4_3compat_glTexCoord3d(gl.funcs, C.GLdouble(s), C.GLdouble(t), C.GLdouble(r)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord2sv.xml +func (gl *GL) TexCoord2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glTexCoord2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord2s.xml +func (gl *GL) TexCoord2s(s, t int16) { + C.gl4_3compat_glTexCoord2s(gl.funcs, C.GLshort(s), C.GLshort(t)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord2iv.xml +func (gl *GL) TexCoord2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glTexCoord2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord2i.xml +func (gl *GL) TexCoord2i(s, t int32) { + C.gl4_3compat_glTexCoord2i(gl.funcs, C.GLint(s), C.GLint(t)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord2fv.xml +func (gl *GL) TexCoord2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glTexCoord2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord2f.xml +func (gl *GL) TexCoord2f(s, t float32) { + C.gl4_3compat_glTexCoord2f(gl.funcs, C.GLfloat(s), C.GLfloat(t)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord2dv.xml +func (gl *GL) TexCoord2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glTexCoord2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord2d.xml +func (gl *GL) TexCoord2d(s, t float64) { + C.gl4_3compat_glTexCoord2d(gl.funcs, C.GLdouble(s), C.GLdouble(t)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord1sv.xml +func (gl *GL) TexCoord1sv(v []int16) { + C.gl4_3compat_glTexCoord1sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord1s.xml +func (gl *GL) TexCoord1s(s int16) { + C.gl4_3compat_glTexCoord1s(gl.funcs, C.GLshort(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord1iv.xml +func (gl *GL) TexCoord1iv(v []int32) { + C.gl4_3compat_glTexCoord1iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord1i.xml +func (gl *GL) TexCoord1i(s int32) { + C.gl4_3compat_glTexCoord1i(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord1fv.xml +func (gl *GL) TexCoord1fv(v []float32) { + C.gl4_3compat_glTexCoord1fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord1f.xml +func (gl *GL) TexCoord1f(s float32) { + C.gl4_3compat_glTexCoord1f(gl.funcs, C.GLfloat(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord1dv.xml +func (gl *GL) TexCoord1dv(v []float64) { + C.gl4_3compat_glTexCoord1dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoord1d.xml +func (gl *GL) TexCoord1d(s float64) { + C.gl4_3compat_glTexCoord1d(gl.funcs, C.GLdouble(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRectsv.xml +func (gl *GL) Rectsv(v1, v2 []int16) { + C.gl4_3compat_glRectsv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v1[0])), (*C.GLshort)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRects.xml +func (gl *GL) Rects(x1, y1, x2, y2 int16) { + C.gl4_3compat_glRects(gl.funcs, C.GLshort(x1), C.GLshort(y1), C.GLshort(x2), C.GLshort(y2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRectiv.xml +func (gl *GL) Rectiv(v1, v2 []int32) { + C.gl4_3compat_glRectiv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v1[0])), (*C.GLint)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRecti.xml +func (gl *GL) Recti(x1, y1, x2, y2 int32) { + C.gl4_3compat_glRecti(gl.funcs, C.GLint(x1), C.GLint(y1), C.GLint(x2), C.GLint(y2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRectfv.xml +func (gl *GL) Rectfv(v1, v2 []float32) { + C.gl4_3compat_glRectfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v1[0])), (*C.GLfloat)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRectf.xml +func (gl *GL) Rectf(x1, y1, x2, y2 float32) { + C.gl4_3compat_glRectf(gl.funcs, C.GLfloat(x1), C.GLfloat(y1), C.GLfloat(x2), C.GLfloat(y2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRectdv.xml +func (gl *GL) Rectdv(v1, v2 []float64) { + C.gl4_3compat_glRectdv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v1[0])), (*C.GLdouble)(unsafe.Pointer(&v2[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRectd.xml +func (gl *GL) Rectd(x1, y1, x2, y2 float64) { + C.gl4_3compat_glRectd(gl.funcs, C.GLdouble(x1), C.GLdouble(y1), C.GLdouble(x2), C.GLdouble(y2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos4sv.xml +func (gl *GL) RasterPos4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glRasterPos4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos4s.xml +func (gl *GL) RasterPos4s(x, y, z, w int16) { + C.gl4_3compat_glRasterPos4s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos4iv.xml +func (gl *GL) RasterPos4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glRasterPos4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos4i.xml +func (gl *GL) RasterPos4i(x, y, z, w int) { + C.gl4_3compat_glRasterPos4i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos4fv.xml +func (gl *GL) RasterPos4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glRasterPos4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos4f.xml +func (gl *GL) RasterPos4f(x, y, z, w float32) { + C.gl4_3compat_glRasterPos4f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos4dv.xml +func (gl *GL) RasterPos4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glRasterPos4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos4d.xml +func (gl *GL) RasterPos4d(x, y, z, w float64) { + C.gl4_3compat_glRasterPos4d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos3sv.xml +func (gl *GL) RasterPos3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glRasterPos3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos3s.xml +func (gl *GL) RasterPos3s(x, y, z int16) { + C.gl4_3compat_glRasterPos3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos3iv.xml +func (gl *GL) RasterPos3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glRasterPos3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos3i.xml +func (gl *GL) RasterPos3i(x, y, z int) { + C.gl4_3compat_glRasterPos3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos3fv.xml +func (gl *GL) RasterPos3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glRasterPos3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos3f.xml +func (gl *GL) RasterPos3f(x, y, z float32) { + C.gl4_3compat_glRasterPos3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos3dv.xml +func (gl *GL) RasterPos3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glRasterPos3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos3d.xml +func (gl *GL) RasterPos3d(x, y, z float64) { + C.gl4_3compat_glRasterPos3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos2sv.xml +func (gl *GL) RasterPos2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glRasterPos2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos2s.xml +func (gl *GL) RasterPos2s(x, y int16) { + C.gl4_3compat_glRasterPos2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos2iv.xml +func (gl *GL) RasterPos2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glRasterPos2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos2i.xml +func (gl *GL) RasterPos2i(x, y int) { + C.gl4_3compat_glRasterPos2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos2fv.xml +func (gl *GL) RasterPos2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glRasterPos2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos2f.xml +func (gl *GL) RasterPos2f(x, y float32) { + C.gl4_3compat_glRasterPos2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos2dv.xml +func (gl *GL) RasterPos2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glRasterPos2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRasterPos2d.xml +func (gl *GL) RasterPos2d(x, y float64) { + C.gl4_3compat_glRasterPos2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3sv.xml +func (gl *GL) Normal3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glNormal3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3s.xml +func (gl *GL) Normal3s(nx, ny, nz int16) { + C.gl4_3compat_glNormal3s(gl.funcs, C.GLshort(nx), C.GLshort(ny), C.GLshort(nz)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3iv.xml +func (gl *GL) Normal3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glNormal3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3i.xml +func (gl *GL) Normal3i(nx, ny, nz int32) { + C.gl4_3compat_glNormal3i(gl.funcs, C.GLint(nx), C.GLint(ny), C.GLint(nz)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3fv.xml +func (gl *GL) Normal3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glNormal3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3f.xml +func (gl *GL) Normal3f(nx, ny, nz float32) { + C.gl4_3compat_glNormal3f(gl.funcs, C.GLfloat(nx), C.GLfloat(ny), C.GLfloat(nz)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3dv.xml +func (gl *GL) Normal3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glNormal3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3d.xml +func (gl *GL) Normal3d(nx, ny, nz float64) { + C.gl4_3compat_glNormal3d(gl.funcs, C.GLdouble(nx), C.GLdouble(ny), C.GLdouble(nz)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3bv.xml +func (gl *GL) Normal3bv(v []byte) { + C.gl4_3compat_glNormal3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormal3b.xml +func (gl *GL) Normal3b(nx, ny, nz byte) { + C.gl4_3compat_glNormal3b(gl.funcs, C.GLbyte(nx), C.GLbyte(ny), C.GLbyte(nz)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexsv.xml +func (gl *GL) Indexsv(c []int16) { + C.gl4_3compat_glIndexsv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexs.xml +func (gl *GL) Indexs(c int16) { + C.gl4_3compat_glIndexs(gl.funcs, C.GLshort(c)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexiv.xml +func (gl *GL) Indexiv(c []int32) { + C.gl4_3compat_glIndexiv(gl.funcs, (*C.GLint)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexi.xml +func (gl *GL) Indexi(c int32) { + C.gl4_3compat_glIndexi(gl.funcs, C.GLint(c)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexfv.xml +func (gl *GL) Indexfv(c []float32) { + C.gl4_3compat_glIndexfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexf.xml +func (gl *GL) Indexf(c float32) { + C.gl4_3compat_glIndexf(gl.funcs, C.GLfloat(c)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexdv.xml +func (gl *GL) Indexdv(c []float64) { + C.gl4_3compat_glIndexdv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexd.xml +func (gl *GL) Indexd(c float64) { + C.gl4_3compat_glIndexd(gl.funcs, C.GLdouble(c)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEnd.xml +func (gl *GL) End() { + C.gl4_3compat_glEnd(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEdgeFlagv.xml +func (gl *GL) EdgeFlagv(flag []bool) { + C.gl4_3compat_glEdgeFlagv(gl.funcs, (*C.GLboolean)(unsafe.Pointer(&flag[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEdgeFlag.xml +func (gl *GL) EdgeFlag(flag bool) { + C.gl4_3compat_glEdgeFlag(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4usv.xml +func (gl *GL) Color4usv(v []uint16) { + C.gl4_3compat_glColor4usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4us.xml +func (gl *GL) Color4us(red, green, blue, alpha uint16) { + C.gl4_3compat_glColor4us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue), C.GLushort(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4uiv.xml +func (gl *GL) Color4uiv(v []uint32) { + C.gl4_3compat_glColor4uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4ui.xml +func (gl *GL) Color4ui(red, green, blue, alpha uint32) { + C.gl4_3compat_glColor4ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue), C.GLuint(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4ubv.xml +func (gl *GL) Color4ubv(v []uint8) { + C.gl4_3compat_glColor4ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4ub.xml +func (gl *GL) Color4ub(red, green, blue, alpha uint8) { + C.gl4_3compat_glColor4ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue), C.GLubyte(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4sv.xml +func (gl *GL) Color4sv(v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glColor4sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4s.xml +func (gl *GL) Color4s(red, green, blue, alpha int16) { + C.gl4_3compat_glColor4s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue), C.GLshort(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4iv.xml +func (gl *GL) Color4iv(v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glColor4iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4i.xml +func (gl *GL) Color4i(red, green, blue, alpha int32) { + C.gl4_3compat_glColor4i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue), C.GLint(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4fv.xml +func (gl *GL) Color4fv(v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glColor4fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4f.xml +func (gl *GL) Color4f(red, green, blue, alpha float32) { + C.gl4_3compat_glColor4f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4dv.xml +func (gl *GL) Color4dv(v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glColor4dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4d.xml +func (gl *GL) Color4d(red, green, blue, alpha float64) { + C.gl4_3compat_glColor4d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue), C.GLdouble(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4bv.xml +func (gl *GL) Color4bv(v []byte) { + C.gl4_3compat_glColor4bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor4b.xml +func (gl *GL) Color4b(red, green, blue, alpha byte) { + C.gl4_3compat_glColor4b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue), C.GLbyte(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3usv.xml +func (gl *GL) Color3usv(v []uint16) { + C.gl4_3compat_glColor3usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3us.xml +func (gl *GL) Color3us(red, green, blue uint16) { + C.gl4_3compat_glColor3us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3uiv.xml +func (gl *GL) Color3uiv(v []uint32) { + C.gl4_3compat_glColor3uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3ui.xml +func (gl *GL) Color3ui(red, green, blue uint32) { + C.gl4_3compat_glColor3ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3ubv.xml +func (gl *GL) Color3ubv(v []uint8) { + C.gl4_3compat_glColor3ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3ub.xml +func (gl *GL) Color3ub(red, green, blue uint8) { + C.gl4_3compat_glColor3ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3sv.xml +func (gl *GL) Color3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glColor3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3s.xml +func (gl *GL) Color3s(red, green, blue int16) { + C.gl4_3compat_glColor3s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3iv.xml +func (gl *GL) Color3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glColor3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3i.xml +func (gl *GL) Color3i(red, green, blue int32) { + C.gl4_3compat_glColor3i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3fv.xml +func (gl *GL) Color3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glColor3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3f.xml +func (gl *GL) Color3f(red, green, blue float32) { + C.gl4_3compat_glColor3f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3dv.xml +func (gl *GL) Color3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glColor3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3d.xml +func (gl *GL) Color3d(red, green, blue float64) { + C.gl4_3compat_glColor3d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3bv.xml +func (gl *GL) Color3bv(v []byte) { + C.gl4_3compat_glColor3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColor3b.xml +func (gl *GL) Color3b(red, green, blue byte) { + C.gl4_3compat_glColor3b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBitmap.xml +func (gl *GL) Bitmap(width, height int, xorig, yorig, xmove, ymove float32, bitmap []uint8) { + C.gl4_3compat_glBitmap(gl.funcs, C.GLsizei(width), C.GLsizei(height), C.GLfloat(xorig), C.GLfloat(yorig), C.GLfloat(xmove), C.GLfloat(ymove), (*C.GLubyte)(unsafe.Pointer(&bitmap[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBegin.xml +func (gl *GL) Begin(mode glbase.Enum) { + C.gl4_3compat_glBegin(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glListBase.xml +func (gl *GL) ListBase(base uint32) { + C.gl4_3compat_glListBase(gl.funcs, C.GLuint(base)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenLists.xml +func (gl *GL) GenLists(range_ int32) uint32 { + glresult := C.gl4_3compat_glGenLists(gl.funcs, C.GLsizei(range_)) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteLists.xml +func (gl *GL) DeleteLists(list uint32, range_ int32) { + C.gl4_3compat_glDeleteLists(gl.funcs, C.GLuint(list), C.GLsizei(range_)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCallLists.xml +func (gl *GL) CallLists(n int, gltype glbase.Enum, lists interface{}) { + var lists_ptr unsafe.Pointer + var lists_v = reflect.ValueOf(lists) + if lists != nil && lists_v.Kind() != reflect.Slice { + panic("parameter lists must be a slice") + } + if lists != nil { + lists_ptr = unsafe.Pointer(lists_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glCallLists(gl.funcs, C.GLsizei(n), C.GLenum(gltype), lists_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCallList.xml +func (gl *GL) CallList(list uint32) { + C.gl4_3compat_glCallList(gl.funcs, C.GLuint(list)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndList.xml +func (gl *GL) EndList() { + C.gl4_3compat_glEndList(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNewList.xml +func (gl *GL) NewList(list uint32, mode glbase.Enum) { + C.gl4_3compat_glNewList(gl.funcs, C.GLuint(list), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPushClientAttrib.xml +func (gl *GL) PushClientAttrib(mask glbase.Bitfield) { + C.gl4_3compat_glPushClientAttrib(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPopClientAttrib.xml +func (gl *GL) PopClientAttrib() { + C.gl4_3compat_glPopClientAttrib(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPrioritizeTextures.xml +func (gl *GL) PrioritizeTextures(n int, textures []glbase.Texture, priorities []float32) { + C.gl4_3compat_glPrioritizeTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0])), (*C.GLfloat)(unsafe.Pointer(&priorities[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glAreTexturesResident.xml +func (gl *GL) AreTexturesResident(n int, textures []glbase.Texture, residences []bool) bool { + glresult := C.gl4_3compat_glAreTexturesResident(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0])), (*C.GLboolean)(unsafe.Pointer(&residences[0]))) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexPointer.xml +func (gl *GL) VertexPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glVertexPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordPointer.xml +func (gl *GL) TexCoordPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glTexCoordPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormalPointer.xml +func (gl *GL) NormalPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glNormalPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glInterleavedArrays.xml +func (gl *GL) InterleavedArrays(format glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glInterleavedArrays(gl.funcs, C.GLenum(format), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexPointer.xml +func (gl *GL) IndexPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glIndexPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEnableClientState.xml +func (gl *GL) EnableClientState(array glbase.Enum) { + C.gl4_3compat_glEnableClientState(gl.funcs, C.GLenum(array)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEdgeFlagPointer.xml +func (gl *GL) EdgeFlagPointer(stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glEdgeFlagPointer(gl.funcs, C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDisableClientState.xml +func (gl *GL) DisableClientState(array glbase.Enum) { + C.gl4_3compat_glDisableClientState(gl.funcs, C.GLenum(array)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorPointer.xml +func (gl *GL) ColorPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glColorPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glArrayElement.xml +func (gl *GL) ArrayElement(i int32) { + C.gl4_3compat_glArrayElement(gl.funcs, C.GLint(i)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glResetMinmax.xml +func (gl *GL) ResetMinmax(target glbase.Enum) { + C.gl4_3compat_glResetMinmax(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glResetHistogram.xml +func (gl *GL) ResetHistogram(target glbase.Enum) { + C.gl4_3compat_glResetHistogram(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMinmax.xml +func (gl *GL) Minmax(target, internalFormat glbase.Enum, sink bool) { + C.gl4_3compat_glMinmax(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), *(*C.GLboolean)(unsafe.Pointer(&sink))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glHistogram.xml +func (gl *GL) Histogram(target glbase.Enum, width int, internalFormat glbase.Enum, sink bool) { + C.gl4_3compat_glHistogram(gl.funcs, C.GLenum(target), C.GLsizei(width), C.GLenum(internalFormat), *(*C.GLboolean)(unsafe.Pointer(&sink))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMinmaxParameteriv.xml +func (gl *GL) GetMinmaxParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_3compat_glGetMinmaxParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMinmaxParameterfv.xml +func (gl *GL) GetMinmaxParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_3compat_glGetMinmaxParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMinmax.xml +func (gl *GL) GetMinmax(target glbase.Enum, reset bool, format, gltype glbase.Enum, values interface{}) { + var values_ptr unsafe.Pointer + var values_v = reflect.ValueOf(values) + if values != nil && values_v.Kind() != reflect.Slice { + panic("parameter values must be a slice") + } + if values != nil { + values_ptr = unsafe.Pointer(values_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glGetMinmax(gl.funcs, C.GLenum(target), *(*C.GLboolean)(unsafe.Pointer(&reset)), C.GLenum(format), C.GLenum(gltype), values_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetHistogramParameteriv.xml +func (gl *GL) GetHistogramParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_3compat_glGetHistogramParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetHistogramParameterfv.xml +func (gl *GL) GetHistogramParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_3compat_glGetHistogramParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetHistogram.xml +func (gl *GL) GetHistogram(target glbase.Enum, reset bool, format, gltype glbase.Enum, values interface{}) { + var values_ptr unsafe.Pointer + var values_v = reflect.ValueOf(values) + if values != nil && values_v.Kind() != reflect.Slice { + panic("parameter values must be a slice") + } + if values != nil { + values_ptr = unsafe.Pointer(values_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glGetHistogram(gl.funcs, C.GLenum(target), *(*C.GLboolean)(unsafe.Pointer(&reset)), C.GLenum(format), C.GLenum(gltype), values_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSeparableFilter2D.xml +func (gl *GL) SeparableFilter2D(target, internalFormat glbase.Enum, width, height int, format, gltype glbase.Enum, row, column interface{}) { + var row_ptr unsafe.Pointer + var row_v = reflect.ValueOf(row) + if row != nil && row_v.Kind() != reflect.Slice { + panic("parameter row must be a slice") + } + if row != nil { + row_ptr = unsafe.Pointer(row_v.Index(0).Addr().Pointer()) + } + var column_ptr unsafe.Pointer + var column_v = reflect.ValueOf(column) + if column != nil && column_v.Kind() != reflect.Slice { + panic("parameter column must be a slice") + } + if column != nil { + column_ptr = unsafe.Pointer(column_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glSeparableFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), row_ptr, column_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSeparableFilter.xml +func (gl *GL) GetSeparableFilter(target, format, gltype glbase.Enum, row, column, span interface{}) { + var row_ptr unsafe.Pointer + var row_v = reflect.ValueOf(row) + if row != nil && row_v.Kind() != reflect.Slice { + panic("parameter row must be a slice") + } + if row != nil { + row_ptr = unsafe.Pointer(row_v.Index(0).Addr().Pointer()) + } + var column_ptr unsafe.Pointer + var column_v = reflect.ValueOf(column) + if column != nil && column_v.Kind() != reflect.Slice { + panic("parameter column must be a slice") + } + if column != nil { + column_ptr = unsafe.Pointer(column_v.Index(0).Addr().Pointer()) + } + var span_ptr unsafe.Pointer + var span_v = reflect.ValueOf(span) + if span != nil && span_v.Kind() != reflect.Slice { + panic("parameter span must be a slice") + } + if span != nil { + span_ptr = unsafe.Pointer(span_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glGetSeparableFilter(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), row_ptr, column_ptr, span_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetConvolutionParameteriv.xml +func (gl *GL) GetConvolutionParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_3compat_glGetConvolutionParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetConvolutionParameterfv.xml +func (gl *GL) GetConvolutionParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_3compat_glGetConvolutionParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetConvolutionFilter.xml +func (gl *GL) GetConvolutionFilter(target, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glGetConvolutionFilter(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyConvolutionFilter2D.xml +func (gl *GL) CopyConvolutionFilter2D(target, internalFormat glbase.Enum, x, y, width, height int) { + C.gl4_3compat_glCopyConvolutionFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyConvolutionFilter1D.xml +func (gl *GL) CopyConvolutionFilter1D(target, internalFormat glbase.Enum, x, y, width int) { + C.gl4_3compat_glCopyConvolutionFilter1D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glConvolutionParameteriv.xml +func (gl *GL) ConvolutionParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_3compat_glConvolutionParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glConvolutionParameteri.xml +func (gl *GL) ConvolutionParameteri(target, pname glbase.Enum, params int32) { + C.gl4_3compat_glConvolutionParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(params)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glConvolutionParameterfv.xml +func (gl *GL) ConvolutionParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_3compat_glConvolutionParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glConvolutionParameterf.xml +func (gl *GL) ConvolutionParameterf(target, pname glbase.Enum, params float32) { + C.gl4_3compat_glConvolutionParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(params)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glConvolutionFilter2D.xml +func (gl *GL) ConvolutionFilter2D(target, internalFormat glbase.Enum, width, height int, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glConvolutionFilter2D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glConvolutionFilter1D.xml +func (gl *GL) ConvolutionFilter1D(target, internalFormat glbase.Enum, width int, format, gltype glbase.Enum, image interface{}) { + var image_ptr unsafe.Pointer + var image_v = reflect.ValueOf(image) + if image != nil && image_v.Kind() != reflect.Slice { + panic("parameter image must be a slice") + } + if image != nil { + image_ptr = unsafe.Pointer(image_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glConvolutionFilter1D(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), image_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyColorSubTable.xml +func (gl *GL) CopyColorSubTable(target glbase.Enum, start int32, x, y, width int) { + C.gl4_3compat_glCopyColorSubTable(gl.funcs, C.GLenum(target), C.GLsizei(start), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorSubTable.xml +func (gl *GL) ColorSubTable(target glbase.Enum, start int32, count int, format, gltype glbase.Enum, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glColorSubTable(gl.funcs, C.GLenum(target), C.GLsizei(start), C.GLsizei(count), C.GLenum(format), C.GLenum(gltype), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetColorTableParameteriv.xml +func (gl *GL) GetColorTableParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_3compat_glGetColorTableParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetColorTableParameterfv.xml +func (gl *GL) GetColorTableParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_3compat_glGetColorTableParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetColorTable.xml +func (gl *GL) GetColorTable(target, format, gltype glbase.Enum, table interface{}) { + var table_ptr unsafe.Pointer + var table_v = reflect.ValueOf(table) + if table != nil && table_v.Kind() != reflect.Slice { + panic("parameter table must be a slice") + } + if table != nil { + table_ptr = unsafe.Pointer(table_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glGetColorTable(gl.funcs, C.GLenum(target), C.GLenum(format), C.GLenum(gltype), table_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyColorTable.xml +func (gl *GL) CopyColorTable(target, internalFormat glbase.Enum, x, y, width int) { + C.gl4_3compat_glCopyColorTable(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorTableParameteriv.xml +func (gl *GL) ColorTableParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_3compat_glColorTableParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorTableParameterfv.xml +func (gl *GL) ColorTableParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_3compat_glColorTableParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorTable.xml +func (gl *GL) ColorTable(target, internalFormat glbase.Enum, width int, format, gltype glbase.Enum, table interface{}) { + var table_ptr unsafe.Pointer + var table_v = reflect.ValueOf(table) + if table != nil && table_v.Kind() != reflect.Slice { + panic("parameter table must be a slice") + } + if table != nil { + table_ptr = unsafe.Pointer(table_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glColorTable(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), table_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultTransposeMatrixd.xml +func (gl *GL) MultTransposeMatrixd(m []float64) { + C.gl4_3compat_glMultTransposeMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultTransposeMatrixf.xml +func (gl *GL) MultTransposeMatrixf(m []float32) { + C.gl4_3compat_glMultTransposeMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLoadTransposeMatrixd.xml +func (gl *GL) LoadTransposeMatrixd(m []float64) { + C.gl4_3compat_glLoadTransposeMatrixd(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLoadTransposeMatrixf.xml +func (gl *GL) LoadTransposeMatrixf(m []float32) { + C.gl4_3compat_glLoadTransposeMatrixf(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord4sv.xml +func (gl *GL) MultiTexCoord4sv(target glbase.Enum, v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glMultiTexCoord4sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord4s.xml +func (gl *GL) MultiTexCoord4s(target glbase.Enum, s, t, r, q int16) { + C.gl4_3compat_glMultiTexCoord4s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t), C.GLshort(r), C.GLshort(q)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord4iv.xml +func (gl *GL) MultiTexCoord4iv(target glbase.Enum, v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glMultiTexCoord4iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord4i.xml +func (gl *GL) MultiTexCoord4i(target glbase.Enum, s, t, r, q int32) { + C.gl4_3compat_glMultiTexCoord4i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t), C.GLint(r), C.GLint(q)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord4fv.xml +func (gl *GL) MultiTexCoord4fv(target glbase.Enum, v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glMultiTexCoord4fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord4f.xml +func (gl *GL) MultiTexCoord4f(target glbase.Enum, s, t, r, q float32) { + C.gl4_3compat_glMultiTexCoord4f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t), C.GLfloat(r), C.GLfloat(q)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord4dv.xml +func (gl *GL) MultiTexCoord4dv(target glbase.Enum, v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glMultiTexCoord4dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord4d.xml +func (gl *GL) MultiTexCoord4d(target glbase.Enum, s, t, r, q float64) { + C.gl4_3compat_glMultiTexCoord4d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t), C.GLdouble(r), C.GLdouble(q)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord3sv.xml +func (gl *GL) MultiTexCoord3sv(target glbase.Enum, v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glMultiTexCoord3sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord3s.xml +func (gl *GL) MultiTexCoord3s(target glbase.Enum, s, t, r int16) { + C.gl4_3compat_glMultiTexCoord3s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t), C.GLshort(r)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord3iv.xml +func (gl *GL) MultiTexCoord3iv(target glbase.Enum, v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glMultiTexCoord3iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord3i.xml +func (gl *GL) MultiTexCoord3i(target glbase.Enum, s, t, r int32) { + C.gl4_3compat_glMultiTexCoord3i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t), C.GLint(r)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord3fv.xml +func (gl *GL) MultiTexCoord3fv(target glbase.Enum, v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glMultiTexCoord3fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord3f.xml +func (gl *GL) MultiTexCoord3f(target glbase.Enum, s, t, r float32) { + C.gl4_3compat_glMultiTexCoord3f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t), C.GLfloat(r)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord3dv.xml +func (gl *GL) MultiTexCoord3dv(target glbase.Enum, v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glMultiTexCoord3dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord3d.xml +func (gl *GL) MultiTexCoord3d(target glbase.Enum, s, t, r float64) { + C.gl4_3compat_glMultiTexCoord3d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t), C.GLdouble(r)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord2sv.xml +func (gl *GL) MultiTexCoord2sv(target glbase.Enum, v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glMultiTexCoord2sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord2s.xml +func (gl *GL) MultiTexCoord2s(target glbase.Enum, s, t int16) { + C.gl4_3compat_glMultiTexCoord2s(gl.funcs, C.GLenum(target), C.GLshort(s), C.GLshort(t)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord2iv.xml +func (gl *GL) MultiTexCoord2iv(target glbase.Enum, v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glMultiTexCoord2iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord2i.xml +func (gl *GL) MultiTexCoord2i(target glbase.Enum, s, t int32) { + C.gl4_3compat_glMultiTexCoord2i(gl.funcs, C.GLenum(target), C.GLint(s), C.GLint(t)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord2fv.xml +func (gl *GL) MultiTexCoord2fv(target glbase.Enum, v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glMultiTexCoord2fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord2f.xml +func (gl *GL) MultiTexCoord2f(target glbase.Enum, s, t float32) { + C.gl4_3compat_glMultiTexCoord2f(gl.funcs, C.GLenum(target), C.GLfloat(s), C.GLfloat(t)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord2dv.xml +func (gl *GL) MultiTexCoord2dv(target glbase.Enum, v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glMultiTexCoord2dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord2d.xml +func (gl *GL) MultiTexCoord2d(target glbase.Enum, s, t float64) { + C.gl4_3compat_glMultiTexCoord2d(gl.funcs, C.GLenum(target), C.GLdouble(s), C.GLdouble(t)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord1sv.xml +func (gl *GL) MultiTexCoord1sv(target glbase.Enum, v []int16) { + C.gl4_3compat_glMultiTexCoord1sv(gl.funcs, C.GLenum(target), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord1s.xml +func (gl *GL) MultiTexCoord1s(target glbase.Enum, s int16) { + C.gl4_3compat_glMultiTexCoord1s(gl.funcs, C.GLenum(target), C.GLshort(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord1iv.xml +func (gl *GL) MultiTexCoord1iv(target glbase.Enum, v []int32) { + C.gl4_3compat_glMultiTexCoord1iv(gl.funcs, C.GLenum(target), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord1i.xml +func (gl *GL) MultiTexCoord1i(target glbase.Enum, s int32) { + C.gl4_3compat_glMultiTexCoord1i(gl.funcs, C.GLenum(target), C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord1fv.xml +func (gl *GL) MultiTexCoord1fv(target glbase.Enum, v []float32) { + C.gl4_3compat_glMultiTexCoord1fv(gl.funcs, C.GLenum(target), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord1f.xml +func (gl *GL) MultiTexCoord1f(target glbase.Enum, s float32) { + C.gl4_3compat_glMultiTexCoord1f(gl.funcs, C.GLenum(target), C.GLfloat(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord1dv.xml +func (gl *GL) MultiTexCoord1dv(target glbase.Enum, v []float64) { + C.gl4_3compat_glMultiTexCoord1dv(gl.funcs, C.GLenum(target), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoord1d.xml +func (gl *GL) MultiTexCoord1d(target glbase.Enum, s float64) { + C.gl4_3compat_glMultiTexCoord1d(gl.funcs, C.GLenum(target), C.GLdouble(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClientActiveTexture.xml +func (gl *GL) ClientActiveTexture(texture glbase.Enum) { + C.gl4_3compat_glClientActiveTexture(gl.funcs, C.GLenum(texture)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos3sv.xml +func (gl *GL) WindowPos3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glWindowPos3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos3s.xml +func (gl *GL) WindowPos3s(x, y, z int16) { + C.gl4_3compat_glWindowPos3s(gl.funcs, C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos3iv.xml +func (gl *GL) WindowPos3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glWindowPos3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos3i.xml +func (gl *GL) WindowPos3i(x, y, z int) { + C.gl4_3compat_glWindowPos3i(gl.funcs, C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos3fv.xml +func (gl *GL) WindowPos3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glWindowPos3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos3f.xml +func (gl *GL) WindowPos3f(x, y, z float32) { + C.gl4_3compat_glWindowPos3f(gl.funcs, C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos3dv.xml +func (gl *GL) WindowPos3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glWindowPos3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos3d.xml +func (gl *GL) WindowPos3d(x, y, z float64) { + C.gl4_3compat_glWindowPos3d(gl.funcs, C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos2sv.xml +func (gl *GL) WindowPos2sv(v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glWindowPos2sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos2s.xml +func (gl *GL) WindowPos2s(x, y int16) { + C.gl4_3compat_glWindowPos2s(gl.funcs, C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos2iv.xml +func (gl *GL) WindowPos2iv(v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glWindowPos2iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos2i.xml +func (gl *GL) WindowPos2i(x, y int) { + C.gl4_3compat_glWindowPos2i(gl.funcs, C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos2fv.xml +func (gl *GL) WindowPos2fv(v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glWindowPos2fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos2f.xml +func (gl *GL) WindowPos2f(x, y float32) { + C.gl4_3compat_glWindowPos2f(gl.funcs, C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos2dv.xml +func (gl *GL) WindowPos2dv(v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glWindowPos2dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWindowPos2d.xml +func (gl *GL) WindowPos2d(x, y float64) { + C.gl4_3compat_glWindowPos2d(gl.funcs, C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColorPointer.xml +func (gl *GL) SecondaryColorPointer(size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glSecondaryColorPointer(gl.funcs, C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3usv.xml +func (gl *GL) SecondaryColor3usv(v []uint16) { + C.gl4_3compat_glSecondaryColor3usv(gl.funcs, (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3us.xml +func (gl *GL) SecondaryColor3us(red, green, blue uint16) { + C.gl4_3compat_glSecondaryColor3us(gl.funcs, C.GLushort(red), C.GLushort(green), C.GLushort(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3uiv.xml +func (gl *GL) SecondaryColor3uiv(v []uint32) { + C.gl4_3compat_glSecondaryColor3uiv(gl.funcs, (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3ui.xml +func (gl *GL) SecondaryColor3ui(red, green, blue uint32) { + C.gl4_3compat_glSecondaryColor3ui(gl.funcs, C.GLuint(red), C.GLuint(green), C.GLuint(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3ubv.xml +func (gl *GL) SecondaryColor3ubv(v []uint8) { + C.gl4_3compat_glSecondaryColor3ubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3ub.xml +func (gl *GL) SecondaryColor3ub(red, green, blue uint8) { + C.gl4_3compat_glSecondaryColor3ub(gl.funcs, C.GLubyte(red), C.GLubyte(green), C.GLubyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3sv.xml +func (gl *GL) SecondaryColor3sv(v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glSecondaryColor3sv(gl.funcs, (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3s.xml +func (gl *GL) SecondaryColor3s(red, green, blue int16) { + C.gl4_3compat_glSecondaryColor3s(gl.funcs, C.GLshort(red), C.GLshort(green), C.GLshort(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3iv.xml +func (gl *GL) SecondaryColor3iv(v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glSecondaryColor3iv(gl.funcs, (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3i.xml +func (gl *GL) SecondaryColor3i(red, green, blue int32) { + C.gl4_3compat_glSecondaryColor3i(gl.funcs, C.GLint(red), C.GLint(green), C.GLint(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3fv.xml +func (gl *GL) SecondaryColor3fv(v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glSecondaryColor3fv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3f.xml +func (gl *GL) SecondaryColor3f(red, green, blue float32) { + C.gl4_3compat_glSecondaryColor3f(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3dv.xml +func (gl *GL) SecondaryColor3dv(v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glSecondaryColor3dv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3d.xml +func (gl *GL) SecondaryColor3d(red, green, blue float64) { + C.gl4_3compat_glSecondaryColor3d(gl.funcs, C.GLdouble(red), C.GLdouble(green), C.GLdouble(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3bv.xml +func (gl *GL) SecondaryColor3bv(v []byte) { + C.gl4_3compat_glSecondaryColor3bv(gl.funcs, (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColor3b.xml +func (gl *GL) SecondaryColor3b(red, green, blue byte) { + C.gl4_3compat_glSecondaryColor3b(gl.funcs, C.GLbyte(red), C.GLbyte(green), C.GLbyte(blue)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogCoordPointer.xml +func (gl *GL) FogCoordPointer(gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_3compat_glFogCoordPointer(gl.funcs, C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogCoorddv.xml +func (gl *GL) FogCoorddv(coord []float64) { + C.gl4_3compat_glFogCoorddv(gl.funcs, (*C.GLdouble)(unsafe.Pointer(&coord[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogCoordd.xml +func (gl *GL) FogCoordd(coord float64) { + C.gl4_3compat_glFogCoordd(gl.funcs, C.GLdouble(coord)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogCoordfv.xml +func (gl *GL) FogCoordfv(coord []float32) { + C.gl4_3compat_glFogCoordfv(gl.funcs, (*C.GLfloat)(unsafe.Pointer(&coord[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFogCoordf.xml +func (gl *GL) FogCoordf(coord float32) { + C.gl4_3compat_glFogCoordf(gl.funcs, C.GLfloat(coord)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4usv.xml +func (gl *GL) VertexAttrib4usv(index glbase.Attrib, v []uint16) { + C.gl4_3compat_glVertexAttrib4usv(gl.funcs, C.GLuint(index), (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4uiv.xml +func (gl *GL) VertexAttrib4uiv(index glbase.Attrib, v []uint32) { + C.gl4_3compat_glVertexAttrib4uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4ubv.xml +func (gl *GL) VertexAttrib4ubv(index glbase.Attrib, v []uint8) { + C.gl4_3compat_glVertexAttrib4ubv(gl.funcs, C.GLuint(index), (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4sv.xml +func (gl *GL) VertexAttrib4sv(index glbase.Attrib, v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glVertexAttrib4sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4s.xml +func (gl *GL) VertexAttrib4s(index glbase.Attrib, x, y, z, w int16) { + C.gl4_3compat_glVertexAttrib4s(gl.funcs, C.GLuint(index), C.GLshort(x), C.GLshort(y), C.GLshort(z), C.GLshort(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4iv.xml +func (gl *GL) VertexAttrib4iv(index glbase.Attrib, v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glVertexAttrib4iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4fv.xml +func (gl *GL) VertexAttrib4fv(index glbase.Attrib, v []float32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glVertexAttrib4fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4f.xml +func (gl *GL) VertexAttrib4f(index glbase.Attrib, x, y, z, w float32) { + C.gl4_3compat_glVertexAttrib4f(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4dv.xml +func (gl *GL) VertexAttrib4dv(index glbase.Attrib, v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glVertexAttrib4dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4d.xml +func (gl *GL) VertexAttrib4d(index glbase.Attrib, x, y, z, w float64) { + C.gl4_3compat_glVertexAttrib4d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4bv.xml +func (gl *GL) VertexAttrib4bv(index glbase.Attrib, v []byte) { + C.gl4_3compat_glVertexAttrib4bv(gl.funcs, C.GLuint(index), (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4Nusv.xml +func (gl *GL) VertexAttrib4Nusv(index glbase.Attrib, v []uint16) { + C.gl4_3compat_glVertexAttrib4Nusv(gl.funcs, C.GLuint(index), (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4Nuiv.xml +func (gl *GL) VertexAttrib4Nuiv(index glbase.Attrib, v []uint32) { + C.gl4_3compat_glVertexAttrib4Nuiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4Nubv.xml +func (gl *GL) VertexAttrib4Nubv(index glbase.Attrib, v []uint8) { + C.gl4_3compat_glVertexAttrib4Nubv(gl.funcs, C.GLuint(index), (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4Nub.xml +func (gl *GL) VertexAttrib4Nub(index glbase.Attrib, x, y, z, w uint8) { + C.gl4_3compat_glVertexAttrib4Nub(gl.funcs, C.GLuint(index), C.GLubyte(x), C.GLubyte(y), C.GLubyte(z), C.GLubyte(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4Nsv.xml +func (gl *GL) VertexAttrib4Nsv(index glbase.Attrib, v []int16) { + C.gl4_3compat_glVertexAttrib4Nsv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4Niv.xml +func (gl *GL) VertexAttrib4Niv(index glbase.Attrib, v []int32) { + C.gl4_3compat_glVertexAttrib4Niv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib4Nbv.xml +func (gl *GL) VertexAttrib4Nbv(index glbase.Attrib, v []byte) { + C.gl4_3compat_glVertexAttrib4Nbv(gl.funcs, C.GLuint(index), (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib3sv.xml +func (gl *GL) VertexAttrib3sv(index glbase.Attrib, v []int16) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glVertexAttrib3sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib3s.xml +func (gl *GL) VertexAttrib3s(index glbase.Attrib, x, y, z int16) { + C.gl4_3compat_glVertexAttrib3s(gl.funcs, C.GLuint(index), C.GLshort(x), C.GLshort(y), C.GLshort(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib3fv.xml +func (gl *GL) VertexAttrib3fv(index glbase.Attrib, v []float32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glVertexAttrib3fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib3f.xml +func (gl *GL) VertexAttrib3f(index glbase.Attrib, x, y, z float32) { + C.gl4_3compat_glVertexAttrib3f(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib3dv.xml +func (gl *GL) VertexAttrib3dv(index glbase.Attrib, v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glVertexAttrib3dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib3d.xml +func (gl *GL) VertexAttrib3d(index glbase.Attrib, x, y, z float64) { + C.gl4_3compat_glVertexAttrib3d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib2sv.xml +func (gl *GL) VertexAttrib2sv(index glbase.Attrib, v []int16) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glVertexAttrib2sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib2s.xml +func (gl *GL) VertexAttrib2s(index glbase.Attrib, x, y int16) { + C.gl4_3compat_glVertexAttrib2s(gl.funcs, C.GLuint(index), C.GLshort(x), C.GLshort(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib2fv.xml +func (gl *GL) VertexAttrib2fv(index glbase.Attrib, v []float32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glVertexAttrib2fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib2f.xml +func (gl *GL) VertexAttrib2f(index glbase.Attrib, x, y float32) { + C.gl4_3compat_glVertexAttrib2f(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib2dv.xml +func (gl *GL) VertexAttrib2dv(index glbase.Attrib, v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glVertexAttrib2dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib2d.xml +func (gl *GL) VertexAttrib2d(index glbase.Attrib, x, y float64) { + C.gl4_3compat_glVertexAttrib2d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib1sv.xml +func (gl *GL) VertexAttrib1sv(index glbase.Attrib, v []int16) { + C.gl4_3compat_glVertexAttrib1sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib1s.xml +func (gl *GL) VertexAttrib1s(index glbase.Attrib, x int16) { + C.gl4_3compat_glVertexAttrib1s(gl.funcs, C.GLuint(index), C.GLshort(x)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib1fv.xml +func (gl *GL) VertexAttrib1fv(index glbase.Attrib, v []float32) { + C.gl4_3compat_glVertexAttrib1fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib1f.xml +func (gl *GL) VertexAttrib1f(index glbase.Attrib, x float32) { + C.gl4_3compat_glVertexAttrib1f(gl.funcs, C.GLuint(index), C.GLfloat(x)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib1dv.xml +func (gl *GL) VertexAttrib1dv(index glbase.Attrib, v []float64) { + C.gl4_3compat_glVertexAttrib1dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttrib1d.xml +func (gl *GL) VertexAttrib1d(index glbase.Attrib, x float64) { + C.gl4_3compat_glVertexAttrib1d(gl.funcs, C.GLuint(index), C.GLdouble(x)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI4usv.xml +func (gl *GL) VertexAttribI4usv(index glbase.Attrib, v []uint16) { + C.gl4_3compat_glVertexAttribI4usv(gl.funcs, C.GLuint(index), (*C.GLushort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI4ubv.xml +func (gl *GL) VertexAttribI4ubv(index glbase.Attrib, v []uint8) { + C.gl4_3compat_glVertexAttribI4ubv(gl.funcs, C.GLuint(index), (*C.GLubyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI4sv.xml +func (gl *GL) VertexAttribI4sv(index glbase.Attrib, v []int16) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glVertexAttribI4sv(gl.funcs, C.GLuint(index), (*C.GLshort)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI4bv.xml +func (gl *GL) VertexAttribI4bv(index glbase.Attrib, v []byte) { + C.gl4_3compat_glVertexAttribI4bv(gl.funcs, C.GLuint(index), (*C.GLbyte)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI4uiv.xml +func (gl *GL) VertexAttribI4uiv(index glbase.Attrib, v []uint32) { + C.gl4_3compat_glVertexAttribI4uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI3uiv.xml +func (gl *GL) VertexAttribI3uiv(index glbase.Attrib, v []uint32) { + C.gl4_3compat_glVertexAttribI3uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI2uiv.xml +func (gl *GL) VertexAttribI2uiv(index glbase.Attrib, v []uint32) { + C.gl4_3compat_glVertexAttribI2uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI1uiv.xml +func (gl *GL) VertexAttribI1uiv(index glbase.Attrib, v []uint32) { + C.gl4_3compat_glVertexAttribI1uiv(gl.funcs, C.GLuint(index), (*C.GLuint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI4iv.xml +func (gl *GL) VertexAttribI4iv(index glbase.Attrib, v []int32) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glVertexAttribI4iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI3iv.xml +func (gl *GL) VertexAttribI3iv(index glbase.Attrib, v []int32) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glVertexAttribI3iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI2iv.xml +func (gl *GL) VertexAttribI2iv(index glbase.Attrib, v []int32) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_3compat_glVertexAttribI2iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI1iv.xml +func (gl *GL) VertexAttribI1iv(index glbase.Attrib, v []int32) { + C.gl4_3compat_glVertexAttribI1iv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI4ui.xml +func (gl *GL) VertexAttribI4ui(index glbase.Attrib, x, y, z, w uint32) { + C.gl4_3compat_glVertexAttribI4ui(gl.funcs, C.GLuint(index), C.GLuint(x), C.GLuint(y), C.GLuint(z), C.GLuint(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI3ui.xml +func (gl *GL) VertexAttribI3ui(index glbase.Attrib, x, y, z uint32) { + C.gl4_3compat_glVertexAttribI3ui(gl.funcs, C.GLuint(index), C.GLuint(x), C.GLuint(y), C.GLuint(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI2ui.xml +func (gl *GL) VertexAttribI2ui(index glbase.Attrib, x, y uint32) { + C.gl4_3compat_glVertexAttribI2ui(gl.funcs, C.GLuint(index), C.GLuint(x), C.GLuint(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI1ui.xml +func (gl *GL) VertexAttribI1ui(index glbase.Attrib, x uint32) { + C.gl4_3compat_glVertexAttribI1ui(gl.funcs, C.GLuint(index), C.GLuint(x)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI4i.xml +func (gl *GL) VertexAttribI4i(index glbase.Attrib, x, y, z, w int) { + C.gl4_3compat_glVertexAttribI4i(gl.funcs, C.GLuint(index), C.GLint(x), C.GLint(y), C.GLint(z), C.GLint(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI3i.xml +func (gl *GL) VertexAttribI3i(index glbase.Attrib, x, y, z int) { + C.gl4_3compat_glVertexAttribI3i(gl.funcs, C.GLuint(index), C.GLint(x), C.GLint(y), C.GLint(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI2i.xml +func (gl *GL) VertexAttribI2i(index glbase.Attrib, x, y int) { + C.gl4_3compat_glVertexAttribI2i(gl.funcs, C.GLuint(index), C.GLint(x), C.GLint(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribI1i.xml +func (gl *GL) VertexAttribI1i(index glbase.Attrib, x int) { + C.gl4_3compat_glVertexAttribI1i(gl.funcs, C.GLuint(index), C.GLint(x)) +} diff --git a/gl/4.3core/funcs.cpp b/gl/4.3core/funcs.cpp new file mode 100644 index 00000000..fec3ebd3 --- /dev/null +++ b/gl/4.3core/funcs.cpp @@ -0,0 +1,2946 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#include +#include + +#include "funcs.h" + +void *gl4_3core_funcs() { + QOpenGLFunctions_4_3_Core* funcs = QOpenGLContext::currentContext()->versionFunctions(); + if (!funcs) { + return 0; + } + funcs->initializeOpenGLFunctions(); + return funcs; +} + + +void gl4_3core_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewport(x, y, width, height); +} + +void gl4_3core_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRange(nearVal, farVal); +} + +GLboolean gl4_3core_glIsEnabled(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabled(cap); +} + +void gl4_3core_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameteriv(target, level, pname, params); +} + +void gl4_3core_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexLevelParameterfv(target, level, pname, params); +} + +void gl4_3core_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameteriv(target, pname, params); +} + +void gl4_3core_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterfv(target, pname, params); +} + +void gl4_3core_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexImage(target, level, format, gltype, pixels); +} + +void gl4_3core_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegerv(pname, params); +} + +void gl4_3core_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFloatv(pname, params); +} + +GLenum gl4_3core_glGetError(void *_glfuncs) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetError(); +} + +void gl4_3core_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetDoublev(pname, params); +} + +void gl4_3core_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleanv(pname, params); +} + +void gl4_3core_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadPixels(x, y, width, height, format, gltype, pixels); +} + +void gl4_3core_glReadBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReadBuffer(mode); +} + +void gl4_3core_glPixelStorei(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStorei(pname, param); +} + +void gl4_3core_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPixelStoref(pname, param); +} + +void gl4_3core_glDepthFunc(void *_glfuncs, GLenum glfunc) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthFunc(glfunc); +} + +void gl4_3core_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOp(fail, zfail, zpass); +} + +void gl4_3core_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFunc(glfunc, ref, mask); +} + +void gl4_3core_glLogicOp(void *_glfuncs, GLenum opcode) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLogicOp(opcode); +} + +void gl4_3core_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFunc(sfactor, dfactor); +} + +void gl4_3core_glFlush(void *_glfuncs) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlush(); +} + +void gl4_3core_glFinish(void *_glfuncs) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFinish(); +} + +void gl4_3core_glEnable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnable(cap); +} + +void gl4_3core_glDisable(void *_glfuncs, GLenum cap) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisable(cap); +} + +void gl4_3core_glDepthMask(void *_glfuncs, GLboolean flag) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthMask(flag); +} + +void gl4_3core_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMask(red, green, blue, alpha); +} + +void gl4_3core_glStencilMask(void *_glfuncs, GLuint mask) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMask(mask); +} + +void gl4_3core_glClearDepth(void *_glfuncs, GLdouble depth) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearDepth(depth); +} + +void gl4_3core_glClearStencil(void *_glfuncs, GLint s) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearStencil(s); +} + +void gl4_3core_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearColor(red, green, blue, alpha); +} + +void gl4_3core_glClear(void *_glfuncs, GLbitfield mask) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClear(mask); +} + +void gl4_3core_glDrawBuffer(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffer(mode); +} + +void gl4_3core_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage2D(target, level, internalFormat, width, height, border, format, gltype, pixels); +} + +void gl4_3core_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage1D(target, level, internalFormat, width, border, format, gltype, pixels); +} + +void gl4_3core_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteriv(target, pname, params); +} + +void gl4_3core_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameteri(target, pname, param); +} + +void gl4_3core_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterfv(target, pname, params); +} + +void gl4_3core_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterf(target, pname, param); +} + +void gl4_3core_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissor(x, y, width, height); +} + +void gl4_3core_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonMode(face, mode); +} + +void gl4_3core_glPointSize(void *_glfuncs, GLfloat size) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointSize(size); +} + +void gl4_3core_glLineWidth(void *_glfuncs, GLfloat width) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLineWidth(width); +} + +void gl4_3core_glHint(void *_glfuncs, GLenum target, GLenum mode) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glHint(target, mode); +} + +void gl4_3core_glFrontFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFrontFace(mode); +} + +void gl4_3core_glCullFace(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCullFace(mode); +} + +void gl4_3core_glIndexubv(void *_glfuncs, const GLubyte* c) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexubv(c); +} + +void gl4_3core_glIndexub(void *_glfuncs, GLubyte c) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glIndexub(c); +} + +GLboolean gl4_3core_glIsTexture(void *_glfuncs, GLuint texture) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsTexture(texture); +} + +void gl4_3core_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenTextures(n, textures); +} + +void gl4_3core_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteTextures(n, textures); +} + +void gl4_3core_glBindTexture(void *_glfuncs, GLenum target, GLuint texture) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindTexture(target, texture); +} + +void gl4_3core_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, gltype, pixels); +} + +void gl4_3core_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage1D(target, level, xoffset, width, format, gltype, pixels); +} + +void gl4_3core_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); +} + +void gl4_3core_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage1D(target, level, xoffset, x, y, width); +} + +void gl4_3core_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage2D(target, level, internalFormat, x, y, width, height, border); +} + +void gl4_3core_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexImage1D(target, level, internalFormat, x, y, width, border); +} + +void gl4_3core_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPolygonOffset(factor, units); +} + +void gl4_3core_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElements(mode, count, gltype, indices); +} + +void gl4_3core_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArrays(mode, first, count); +} + +void gl4_3core_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); +} + +void gl4_3core_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, gltype, pixels); +} + +void gl4_3core_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage3D(target, level, internalFormat, width, height, depth, border, format, gltype, pixels); +} + +void gl4_3core_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawRangeElements(mode, start, end, count, gltype, indices); +} + +void gl4_3core_glBlendEquation(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquation(mode); +} + +void gl4_3core_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendColor(red, green, blue, alpha); +} + +void gl4_3core_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetCompressedTexImage(target, level, img); +} + +void gl4_3core_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data); +} + +void gl4_3core_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); +} + +void gl4_3core_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); +} + +void gl4_3core_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage1D(target, level, internalFormat, width, border, imageSize, data); +} + +void gl4_3core_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data); +} + +void gl4_3core_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage3D(target, level, internalFormat, width, height, depth, border, imageSize, data); +} + +void gl4_3core_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSampleCoverage(value, invert); +} + +void gl4_3core_glActiveTexture(void *_glfuncs, GLenum texture) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glActiveTexture(texture); +} + +void gl4_3core_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteriv(pname, params); +} + +void gl4_3core_glPointParameteri(void *_glfuncs, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameteri(pname, param); +} + +void gl4_3core_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterfv(pname, params); +} + +void gl4_3core_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPointParameterf(pname, param); +} + +void gl4_3core_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiDrawArrays(mode, first, count, drawcount); +} + +void gl4_3core_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); +} + +void gl4_3core_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferParameteriv(target, pname, params); +} + +GLboolean gl4_3core_glUnmapBuffer(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glUnmapBuffer(target); +} + +void gl4_3core_glGetBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferSubData(target, offset, size, data); +} + +void gl4_3core_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferSubData(target, offset, size, data); +} + +void gl4_3core_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferData(target, size, data, usage); +} + +GLboolean gl4_3core_glIsBuffer(void *_glfuncs, GLuint buffer) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsBuffer(buffer); +} + +void gl4_3core_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenBuffers(n, buffers); +} + +void gl4_3core_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteBuffers(n, buffers); +} + +void gl4_3core_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBuffer(target, buffer); +} + +void gl4_3core_glGetQueryObjectuiv(void *_glfuncs, GLuint id, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectuiv(id, pname, params); +} + +void gl4_3core_glGetQueryObjectiv(void *_glfuncs, GLuint id, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectiv(id, pname, params); +} + +void gl4_3core_glGetQueryiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryiv(target, pname, params); +} + +void gl4_3core_glEndQuery(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndQuery(target); +} + +void gl4_3core_glBeginQuery(void *_glfuncs, GLenum target, GLuint id) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginQuery(target, id); +} + +GLboolean gl4_3core_glIsQuery(void *_glfuncs, GLuint id) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsQuery(id); +} + +void gl4_3core_glDeleteQueries(void *_glfuncs, GLsizei n, const GLuint* ids) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteQueries(n, ids); +} + +void gl4_3core_glGenQueries(void *_glfuncs, GLsizei n, GLuint* ids) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenQueries(n, ids); +} + +void gl4_3core_glVertexAttribPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLboolean normalized, GLsizei stride, const GLvoid* offset) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribPointer(index, size, gltype, normalized, stride, offset); +} + +void gl4_3core_glValidateProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glValidateProgram(program); +} + +void gl4_3core_glUniformMatrix4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4fv(location, count, transpose, value); +} + +void gl4_3core_glUniformMatrix3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3fv(location, count, transpose, value); +} + +void gl4_3core_glUniformMatrix2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2fv(location, count, transpose, value); +} + +void gl4_3core_glUniform4iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4iv(location, count, value); +} + +void gl4_3core_glUniform3iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3iv(location, count, value); +} + +void gl4_3core_glUniform2iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2iv(location, count, value); +} + +void gl4_3core_glUniform1iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1iv(location, count, value); +} + +void gl4_3core_glUniform4fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4fv(location, count, value); +} + +void gl4_3core_glUniform3fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3fv(location, count, value); +} + +void gl4_3core_glUniform2fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2fv(location, count, value); +} + +void gl4_3core_glUniform1fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1fv(location, count, value); +} + +void gl4_3core_glUniform4i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4i(location, v0, v1, v2, v3); +} + +void gl4_3core_glUniform3i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3i(location, v0, v1, v2); +} + +void gl4_3core_glUniform2i(void *_glfuncs, GLint location, GLint v0, GLint v1) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2i(location, v0, v1); +} + +void gl4_3core_glUniform1i(void *_glfuncs, GLint location, GLint v0) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1i(location, v0); +} + +void gl4_3core_glUniform4f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4f(location, v0, v1, v2, v3); +} + +void gl4_3core_glUniform3f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3f(location, v0, v1, v2); +} + +void gl4_3core_glUniform2f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2f(location, v0, v1); +} + +void gl4_3core_glUniform1f(void *_glfuncs, GLint location, GLfloat v0) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1f(location, v0); +} + +void gl4_3core_glUseProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUseProgram(program); +} + +void gl4_3core_glShaderSource(void *_glfuncs, GLuint shader, GLsizei count, const GLchar** source, const GLint* length) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShaderSource(shader, count, source, length); +} + +void gl4_3core_glLinkProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLinkProgram(program); +} + +GLboolean gl4_3core_glIsShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsShader(shader); +} + +GLboolean gl4_3core_glIsProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsProgram(program); +} + +void gl4_3core_glGetVertexAttribiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribiv(index, pname, params); +} + +void gl4_3core_glGetVertexAttribfv(void *_glfuncs, GLuint index, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribfv(index, pname, params); +} + +void gl4_3core_glGetVertexAttribdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribdv(index, pname, params); +} + +void gl4_3core_glGetUniformiv(void *_glfuncs, GLuint program, GLint location, GLint* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformiv(program, location, params); +} + +void gl4_3core_glGetUniformfv(void *_glfuncs, GLuint program, GLint location, GLfloat* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformfv(program, location, params); +} + +GLint gl4_3core_glGetUniformLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetUniformLocation(program, name); +} + +void gl4_3core_glGetShaderSource(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderSource(shader, bufSize, length, source); +} + +void gl4_3core_glGetShaderInfoLog(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderInfoLog(shader, bufSize, length, infoLog); +} + +void gl4_3core_glGetShaderiv(void *_glfuncs, GLuint shader, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderiv(shader, pname, params); +} + +void gl4_3core_glGetProgramInfoLog(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramInfoLog(program, bufSize, length, infoLog); +} + +void gl4_3core_glGetProgramiv(void *_glfuncs, GLuint program, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramiv(program, pname, params); +} + +GLint gl4_3core_glGetAttribLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetAttribLocation(program, name); +} + +void gl4_3core_glGetAttachedShaders(void *_glfuncs, GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetAttachedShaders(program, maxCount, count, obj); +} + +void gl4_3core_glGetActiveUniform(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniform(program, index, bufSize, length, size, gltype, name); +} + +void gl4_3core_glGetActiveAttrib(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveAttrib(program, index, bufSize, length, size, gltype, name); +} + +void gl4_3core_glEnableVertexAttribArray(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnableVertexAttribArray(index); +} + +void gl4_3core_glDisableVertexAttribArray(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisableVertexAttribArray(index); +} + +void gl4_3core_glDetachShader(void *_glfuncs, GLuint program, GLuint shader) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDetachShader(program, shader); +} + +void gl4_3core_glDeleteShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteShader(shader); +} + +void gl4_3core_glDeleteProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteProgram(program); +} + +GLuint gl4_3core_glCreateShader(void *_glfuncs, GLenum gltype) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCreateShader(gltype); +} + +GLuint gl4_3core_glCreateProgram(void *_glfuncs) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCreateProgram(); +} + +void gl4_3core_glCompileShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompileShader(shader); +} + +void gl4_3core_glBindAttribLocation(void *_glfuncs, GLuint program, GLuint index, const GLchar* name) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindAttribLocation(program, index, name); +} + +void gl4_3core_glAttachShader(void *_glfuncs, GLuint program, GLuint shader) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAttachShader(program, shader); +} + +void gl4_3core_glStencilMaskSeparate(void *_glfuncs, GLenum face, GLuint mask) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMaskSeparate(face, mask); +} + +void gl4_3core_glStencilFuncSeparate(void *_glfuncs, GLenum face, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFuncSeparate(face, glfunc, ref, mask); +} + +void gl4_3core_glStencilOpSeparate(void *_glfuncs, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOpSeparate(face, sfail, dpfail, dppass); +} + +void gl4_3core_glDrawBuffers(void *_glfuncs, GLsizei n, const GLenum* bufs) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawBuffers(n, bufs); +} + +void gl4_3core_glBlendEquationSeparate(void *_glfuncs, GLenum modeRGB, GLenum modeAlpha) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquationSeparate(modeRGB, modeAlpha); +} + +void gl4_3core_glUniformMatrix4x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x3fv(location, count, transpose, value); +} + +void gl4_3core_glUniformMatrix3x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x4fv(location, count, transpose, value); +} + +void gl4_3core_glUniformMatrix4x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x2fv(location, count, transpose, value); +} + +void gl4_3core_glUniformMatrix2x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x4fv(location, count, transpose, value); +} + +void gl4_3core_glUniformMatrix3x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x2fv(location, count, transpose, value); +} + +void gl4_3core_glUniformMatrix2x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x3fv(location, count, transpose, value); +} + +GLboolean gl4_3core_glIsVertexArray(void *_glfuncs, GLuint array) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsVertexArray(array); +} + +void gl4_3core_glGenVertexArrays(void *_glfuncs, GLsizei n, GLuint* arrays) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenVertexArrays(n, arrays); +} + +void gl4_3core_glDeleteVertexArrays(void *_glfuncs, GLsizei n, const GLuint* arrays) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteVertexArrays(n, arrays); +} + +void gl4_3core_glBindVertexArray(void *_glfuncs, GLuint array) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindVertexArray(array); +} + +void gl4_3core_glFlushMappedBufferRange(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr length) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFlushMappedBufferRange(target, offset, length); +} + +void gl4_3core_glFramebufferTextureLayer(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTextureLayer(target, attachment, texture, level, layer); +} + +void gl4_3core_glRenderbufferStorageMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRenderbufferStorageMultisample(target, samples, internalFormat, width, height); +} + +void gl4_3core_glBlitFramebuffer(void *_glfuncs, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); +} + +void gl4_3core_glGenerateMipmap(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenerateMipmap(target); +} + +void gl4_3core_glGetFramebufferAttachmentParameteriv(void *_glfuncs, GLenum target, GLenum attachment, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFramebufferAttachmentParameteriv(target, attachment, pname, params); +} + +void gl4_3core_glFramebufferRenderbuffer(void *_glfuncs, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer); +} + +void gl4_3core_glFramebufferTexture3D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset); +} + +void gl4_3core_glFramebufferTexture2D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture2D(target, attachment, textarget, texture, level); +} + +void gl4_3core_glFramebufferTexture1D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture1D(target, attachment, textarget, texture, level); +} + +GLenum gl4_3core_glCheckFramebufferStatus(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCheckFramebufferStatus(target); +} + +void gl4_3core_glGenFramebuffers(void *_glfuncs, GLsizei n, GLuint* framebuffers) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenFramebuffers(n, framebuffers); +} + +void gl4_3core_glDeleteFramebuffers(void *_glfuncs, GLsizei n, const GLuint* framebuffers) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteFramebuffers(n, framebuffers); +} + +void gl4_3core_glBindFramebuffer(void *_glfuncs, GLenum target, GLuint framebuffer) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFramebuffer(target, framebuffer); +} + +GLboolean gl4_3core_glIsFramebuffer(void *_glfuncs, GLuint framebuffer) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsFramebuffer(framebuffer); +} + +void gl4_3core_glGetRenderbufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetRenderbufferParameteriv(target, pname, params); +} + +void gl4_3core_glRenderbufferStorage(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRenderbufferStorage(target, internalFormat, width, height); +} + +void gl4_3core_glGenRenderbuffers(void *_glfuncs, GLsizei n, GLuint* renderbuffers) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenRenderbuffers(n, renderbuffers); +} + +void gl4_3core_glDeleteRenderbuffers(void *_glfuncs, GLsizei n, const GLuint* renderbuffers) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteRenderbuffers(n, renderbuffers); +} + +void gl4_3core_glBindRenderbuffer(void *_glfuncs, GLenum target, GLuint renderbuffer) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindRenderbuffer(target, renderbuffer); +} + +GLboolean gl4_3core_glIsRenderbuffer(void *_glfuncs, GLuint renderbuffer) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsRenderbuffer(renderbuffer); +} + +void gl4_3core_glClearBufferfi(void *_glfuncs, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferfi(buffer, drawbuffer, depth, stencil); +} + +void gl4_3core_glClearBufferfv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferfv(buffer, drawbuffer, value); +} + +void gl4_3core_glClearBufferuiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLuint* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferuiv(buffer, drawbuffer, value); +} + +void gl4_3core_glClearBufferiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLint* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferiv(buffer, drawbuffer, value); +} + +void gl4_3core_glGetTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterIuiv(target, pname, params); +} + +void gl4_3core_glGetTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTexParameterIiv(target, pname, params); +} + +void gl4_3core_glTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, const GLuint* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterIuiv(target, pname, params); +} + +void gl4_3core_glTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexParameterIiv(target, pname, params); +} + +void gl4_3core_glUniform4uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4uiv(location, count, value); +} + +void gl4_3core_glUniform3uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3uiv(location, count, value); +} + +void gl4_3core_glUniform2uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2uiv(location, count, value); +} + +void gl4_3core_glUniform1uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1uiv(location, count, value); +} + +void gl4_3core_glUniform4ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4ui(location, v0, v1, v2, v3); +} + +void gl4_3core_glUniform3ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3ui(location, v0, v1, v2); +} + +void gl4_3core_glUniform2ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2ui(location, v0, v1); +} + +void gl4_3core_glUniform1ui(void *_glfuncs, GLint location, GLuint v0) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1ui(location, v0); +} + +GLint gl4_3core_glGetFragDataLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetFragDataLocation(program, name); +} + +void gl4_3core_glBindFragDataLocation(void *_glfuncs, GLuint program, GLuint color, const GLchar* name) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFragDataLocation(program, color, name); +} + +void gl4_3core_glGetUniformuiv(void *_glfuncs, GLuint program, GLint location, GLuint* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformuiv(program, location, params); +} + +void gl4_3core_glGetVertexAttribIuiv(void *_glfuncs, GLuint index, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribIuiv(index, pname, params); +} + +void gl4_3core_glGetVertexAttribIiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribIiv(index, pname, params); +} + +void gl4_3core_glVertexAttribIPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribIPointer(index, size, gltype, stride, pointer); +} + +void gl4_3core_glEndConditionalRender(void *_glfuncs) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndConditionalRender(); +} + +void gl4_3core_glBeginConditionalRender(void *_glfuncs, GLuint id, GLenum mode) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginConditionalRender(id, mode); +} + +void gl4_3core_glClampColor(void *_glfuncs, GLenum target, GLenum clamp) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClampColor(target, clamp); +} + +void gl4_3core_glGetTransformFeedbackVarying(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetTransformFeedbackVarying(program, index, bufSize, length, size, gltype, name); +} + +void gl4_3core_glBindBufferBase(void *_glfuncs, GLenum target, GLuint index, GLuint buffer) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBufferBase(target, index, buffer); +} + +void gl4_3core_glBindBufferRange(void *_glfuncs, GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBufferRange(target, index, buffer, offset, size); +} + +void gl4_3core_glEndTransformFeedback(void *_glfuncs) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndTransformFeedback(); +} + +void gl4_3core_glBeginTransformFeedback(void *_glfuncs, GLenum primitiveMode) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginTransformFeedback(primitiveMode); +} + +GLboolean gl4_3core_glIsEnabledi(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsEnabledi(target, index); +} + +void gl4_3core_glDisablei(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisablei(target, index); +} + +void gl4_3core_glEnablei(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnablei(target, index); +} + +void gl4_3core_glGetIntegeri_v(void *_glfuncs, GLenum target, GLuint index, GLint* data) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetIntegeri_v(target, index, data); +} + +void gl4_3core_glGetBooleani_v(void *_glfuncs, GLenum target, GLuint index, GLboolean* data) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBooleani_v(target, index, data); +} + +void gl4_3core_glColorMaski(void *_glfuncs, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorMaski(index, r, g, b, a); +} + +void gl4_3core_glCopyBufferSubData(void *_glfuncs, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); +} + +void gl4_3core_glUniformBlockBinding(void *_glfuncs, GLuint program, GLuint v0, GLuint v1) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformBlockBinding(program, v0, v1); +} + +void gl4_3core_glGetActiveUniformBlockName(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName); +} + +void gl4_3core_glGetActiveUniformBlockiv(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params); +} + +GLuint gl4_3core_glGetUniformBlockIndex(void *_glfuncs, GLuint program, const GLchar* uniformBlockName) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetUniformBlockIndex(program, uniformBlockName); +} + +void gl4_3core_glGetActiveUniformName(void *_glfuncs, GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformName(program, uniformIndex, bufSize, length, uniformName); +} + +void gl4_3core_glGetActiveUniformsiv(void *_glfuncs, GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params); +} + +void gl4_3core_glPrimitiveRestartIndex(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPrimitiveRestartIndex(index); +} + +void gl4_3core_glTexBuffer(void *_glfuncs, GLenum target, GLenum internalFormat, GLuint buffer) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexBuffer(target, internalFormat, buffer); +} + +void gl4_3core_glDrawElementsInstanced(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsInstanced(mode, count, gltype, indices, instancecount); +} + +void gl4_3core_glDrawArraysInstanced(void *_glfuncs, GLenum mode, GLint first, GLsizei count, GLsizei instancecount) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArraysInstanced(mode, first, count, instancecount); +} + +void gl4_3core_glSampleMaski(void *_glfuncs, GLuint index, GLbitfield mask) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSampleMaski(index, mask); +} + +void gl4_3core_glGetMultisamplefv(void *_glfuncs, GLenum pname, GLuint index, GLfloat* val) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetMultisamplefv(pname, index, val); +} + +void gl4_3core_glTexImage3DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage3DMultisample(target, samples, internalFormat, width, height, depth, fixedsamplelocations); +} + +void gl4_3core_glTexImage2DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexImage2DMultisample(target, samples, internalFormat, width, height, fixedsamplelocations); +} + +void gl4_3core_glGetSynciv(void *_glfuncs, GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSynciv(sync, pname, bufSize, length, values); +} + +void gl4_3core_glGetInteger64v(void *_glfuncs, GLenum pname, GLint64* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetInteger64v(pname, params); +} + +void gl4_3core_glWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glWaitSync(sync, flags, timeout); +} + +GLenum gl4_3core_glClientWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glClientWaitSync(sync, flags, timeout); +} + +void gl4_3core_glDeleteSync(void *_glfuncs, GLsync sync) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteSync(sync); +} + +GLboolean gl4_3core_glIsSync(void *_glfuncs, GLsync sync) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsSync(sync); +} + +GLsync gl4_3core_glFenceSync(void *_glfuncs, GLenum condition, GLbitfield flags) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glFenceSync(condition, flags); +} + +void gl4_3core_glProvokingVertex(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProvokingVertex(mode); +} + +void gl4_3core_glDrawElementsInstancedBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLint basevertex) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsInstancedBaseVertex(mode, count, gltype, indices, instancecount, basevertex); +} + +void gl4_3core_glDrawRangeElementsBaseVertex(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawRangeElementsBaseVertex(mode, start, end, count, gltype, indices, basevertex); +} + +void gl4_3core_glDrawElementsBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsBaseVertex(mode, count, gltype, indices, basevertex); +} + +void gl4_3core_glFramebufferTexture(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture(target, attachment, texture, level); +} + +void gl4_3core_glGetBufferParameteri64v(void *_glfuncs, GLenum target, GLenum pname, GLint64* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferParameteri64v(target, pname, params); +} + +void gl4_3core_glGetInteger64i_v(void *_glfuncs, GLenum target, GLuint index, GLint64* data) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetInteger64i_v(target, index, data); +} + +void gl4_3core_glVertexAttribP4uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP4uiv(index, gltype, normalized, value); +} + +void gl4_3core_glVertexAttribP4ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP4ui(index, gltype, normalized, value); +} + +void gl4_3core_glVertexAttribP3uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP3uiv(index, gltype, normalized, value); +} + +void gl4_3core_glVertexAttribP3ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP3ui(index, gltype, normalized, value); +} + +void gl4_3core_glVertexAttribP2uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP2uiv(index, gltype, normalized, value); +} + +void gl4_3core_glVertexAttribP2ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP2ui(index, gltype, normalized, value); +} + +void gl4_3core_glVertexAttribP1uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP1uiv(index, gltype, normalized, value); +} + +void gl4_3core_glVertexAttribP1ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribP1ui(index, gltype, normalized, value); +} + +void gl4_3core_glSecondaryColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColorP3uiv(gltype, color); +} + +void gl4_3core_glSecondaryColorP3ui(void *_glfuncs, GLenum gltype, GLuint color) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSecondaryColorP3ui(gltype, color); +} + +void gl4_3core_glColorP4uiv(void *_glfuncs, GLenum gltype, const GLuint* color) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP4uiv(gltype, color); +} + +void gl4_3core_glColorP4ui(void *_glfuncs, GLenum gltype, GLuint color) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP4ui(gltype, color); +} + +void gl4_3core_glColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP3uiv(gltype, color); +} + +void gl4_3core_glColorP3ui(void *_glfuncs, GLenum gltype, GLuint color) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glColorP3ui(gltype, color); +} + +void gl4_3core_glNormalP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormalP3uiv(gltype, coords); +} + +void gl4_3core_glNormalP3ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glNormalP3ui(gltype, coords); +} + +void gl4_3core_glMultiTexCoordP4uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP4uiv(texture, gltype, coords); +} + +void gl4_3core_glMultiTexCoordP4ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP4ui(texture, gltype, coords); +} + +void gl4_3core_glMultiTexCoordP3uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP3uiv(texture, gltype, coords); +} + +void gl4_3core_glMultiTexCoordP3ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP3ui(texture, gltype, coords); +} + +void gl4_3core_glMultiTexCoordP2uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP2uiv(texture, gltype, coords); +} + +void gl4_3core_glMultiTexCoordP2ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP2ui(texture, gltype, coords); +} + +void gl4_3core_glMultiTexCoordP1uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP1uiv(texture, gltype, coords); +} + +void gl4_3core_glMultiTexCoordP1ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiTexCoordP1ui(texture, gltype, coords); +} + +void gl4_3core_glTexCoordP4uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP4uiv(gltype, coords); +} + +void gl4_3core_glTexCoordP4ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP4ui(gltype, coords); +} + +void gl4_3core_glTexCoordP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP3uiv(gltype, coords); +} + +void gl4_3core_glTexCoordP3ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP3ui(gltype, coords); +} + +void gl4_3core_glTexCoordP2uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP2uiv(gltype, coords); +} + +void gl4_3core_glTexCoordP2ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP2ui(gltype, coords); +} + +void gl4_3core_glTexCoordP1uiv(void *_glfuncs, GLenum gltype, const GLuint* coords) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP1uiv(gltype, coords); +} + +void gl4_3core_glTexCoordP1ui(void *_glfuncs, GLenum gltype, GLuint coords) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexCoordP1ui(gltype, coords); +} + +void gl4_3core_glVertexP4uiv(void *_glfuncs, GLenum gltype, const GLuint* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP4uiv(gltype, value); +} + +void gl4_3core_glVertexP4ui(void *_glfuncs, GLenum gltype, GLuint value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP4ui(gltype, value); +} + +void gl4_3core_glVertexP3uiv(void *_glfuncs, GLenum gltype, const GLuint* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP3uiv(gltype, value); +} + +void gl4_3core_glVertexP3ui(void *_glfuncs, GLenum gltype, GLuint value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP3ui(gltype, value); +} + +void gl4_3core_glVertexP2uiv(void *_glfuncs, GLenum gltype, const GLuint* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP2uiv(gltype, value); +} + +void gl4_3core_glVertexP2ui(void *_glfuncs, GLenum gltype, GLuint value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexP2ui(gltype, value); +} + +void gl4_3core_glGetQueryObjectui64v(void *_glfuncs, GLuint id, GLenum pname, GLuint64* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjectui64v(id, pname, params); +} + +void gl4_3core_glGetQueryObjecti64v(void *_glfuncs, GLuint id, GLenum pname, GLint64* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryObjecti64v(id, pname, params); +} + +void gl4_3core_glQueryCounter(void *_glfuncs, GLuint id, GLenum target) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glQueryCounter(id, target); +} + +void gl4_3core_glGetSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, GLuint* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameterIuiv(sampler, pname, params); +} + +void gl4_3core_glGetSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameterfv(sampler, pname, params); +} + +void gl4_3core_glGetSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameterIiv(sampler, pname, params); +} + +void gl4_3core_glGetSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetSamplerParameteriv(sampler, pname, params); +} + +void gl4_3core_glSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLuint* param) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterIuiv(sampler, pname, param); +} + +void gl4_3core_glSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterIiv(sampler, pname, param); +} + +void gl4_3core_glSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, const GLfloat* param) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterfv(sampler, pname, param); +} + +void gl4_3core_glSamplerParameterf(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat param) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameterf(sampler, pname, param); +} + +void gl4_3core_glSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameteriv(sampler, pname, param); +} + +void gl4_3core_glSamplerParameteri(void *_glfuncs, GLuint sampler, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSamplerParameteri(sampler, pname, param); +} + +void gl4_3core_glBindSampler(void *_glfuncs, GLuint unit, GLuint sampler) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindSampler(unit, sampler); +} + +GLboolean gl4_3core_glIsSampler(void *_glfuncs, GLuint sampler) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsSampler(sampler); +} + +void gl4_3core_glDeleteSamplers(void *_glfuncs, GLsizei count, const GLuint* samplers) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteSamplers(count, samplers); +} + +void gl4_3core_glGenSamplers(void *_glfuncs, GLsizei count, GLuint* samplers) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenSamplers(count, samplers); +} + +GLint gl4_3core_glGetFragDataIndex(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetFragDataIndex(program, name); +} + +void gl4_3core_glBindFragDataLocationIndexed(void *_glfuncs, GLuint program, GLuint colorNumber, GLuint index, const GLchar* name) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFragDataLocationIndexed(program, colorNumber, index, name); +} + +void gl4_3core_glVertexAttribDivisor(void *_glfuncs, GLuint index, GLuint divisor) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribDivisor(index, divisor); +} + +void gl4_3core_glGetQueryIndexediv(void *_glfuncs, GLenum target, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetQueryIndexediv(target, index, pname, params); +} + +void gl4_3core_glEndQueryIndexed(void *_glfuncs, GLenum target, GLuint index) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEndQueryIndexed(target, index); +} + +void gl4_3core_glBeginQueryIndexed(void *_glfuncs, GLenum target, GLuint index, GLuint id) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBeginQueryIndexed(target, index, id); +} + +void gl4_3core_glDrawTransformFeedbackStream(void *_glfuncs, GLenum mode, GLuint id, GLuint stream) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawTransformFeedbackStream(mode, id, stream); +} + +void gl4_3core_glDrawTransformFeedback(void *_glfuncs, GLenum mode, GLuint id) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawTransformFeedback(mode, id); +} + +void gl4_3core_glResumeTransformFeedback(void *_glfuncs) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glResumeTransformFeedback(); +} + +void gl4_3core_glPauseTransformFeedback(void *_glfuncs) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPauseTransformFeedback(); +} + +GLboolean gl4_3core_glIsTransformFeedback(void *_glfuncs, GLuint id) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsTransformFeedback(id); +} + +void gl4_3core_glGenTransformFeedbacks(void *_glfuncs, GLsizei n, GLuint* ids) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenTransformFeedbacks(n, ids); +} + +void gl4_3core_glDeleteTransformFeedbacks(void *_glfuncs, GLsizei n, const GLuint* ids) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteTransformFeedbacks(n, ids); +} + +void gl4_3core_glBindTransformFeedback(void *_glfuncs, GLenum target, GLuint id) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindTransformFeedback(target, id); +} + +void gl4_3core_glPatchParameterfv(void *_glfuncs, GLenum pname, const GLfloat* values) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPatchParameterfv(pname, values); +} + +void gl4_3core_glPatchParameteri(void *_glfuncs, GLenum pname, GLint value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glPatchParameteri(pname, value); +} + +void gl4_3core_glGetProgramStageiv(void *_glfuncs, GLuint program, GLenum shadertype, GLenum pname, GLint* values) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramStageiv(program, shadertype, pname, values); +} + +void gl4_3core_glGetUniformSubroutineuiv(void *_glfuncs, GLenum shadertype, GLint location, GLuint* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformSubroutineuiv(shadertype, location, params); +} + +void gl4_3core_glUniformSubroutinesuiv(void *_glfuncs, GLenum shadertype, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformSubroutinesuiv(shadertype, count, value); +} + +void gl4_3core_glGetActiveSubroutineName(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveSubroutineName(program, shadertype, index, bufSize, length, name); +} + +void gl4_3core_glGetActiveSubroutineUniformName(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveSubroutineUniformName(program, shadertype, index, bufSize, length, name); +} + +void gl4_3core_glGetActiveSubroutineUniformiv(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint* values) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveSubroutineUniformiv(program, shadertype, index, pname, values); +} + +GLuint gl4_3core_glGetSubroutineIndex(void *_glfuncs, GLuint program, GLenum shadertype, const GLchar* name) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetSubroutineIndex(program, shadertype, name); +} + +GLint gl4_3core_glGetSubroutineUniformLocation(void *_glfuncs, GLuint program, GLenum shadertype, const GLchar* name) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetSubroutineUniformLocation(program, shadertype, name); +} + +void gl4_3core_glGetUniformdv(void *_glfuncs, GLuint program, GLint location, GLdouble* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformdv(program, location, params); +} + +void gl4_3core_glUniformMatrix4x3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x3dv(location, count, transpose, value); +} + +void gl4_3core_glUniformMatrix4x2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4x2dv(location, count, transpose, value); +} + +void gl4_3core_glUniformMatrix3x4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x4dv(location, count, transpose, value); +} + +void gl4_3core_glUniformMatrix3x2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3x2dv(location, count, transpose, value); +} + +void gl4_3core_glUniformMatrix2x4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x4dv(location, count, transpose, value); +} + +void gl4_3core_glUniformMatrix2x3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2x3dv(location, count, transpose, value); +} + +void gl4_3core_glUniformMatrix4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4dv(location, count, transpose, value); +} + +void gl4_3core_glUniformMatrix3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3dv(location, count, transpose, value); +} + +void gl4_3core_glUniformMatrix2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2dv(location, count, transpose, value); +} + +void gl4_3core_glUniform4dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4dv(location, count, value); +} + +void gl4_3core_glUniform3dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3dv(location, count, value); +} + +void gl4_3core_glUniform2dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2dv(location, count, value); +} + +void gl4_3core_glUniform1dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1dv(location, count, value); +} + +void gl4_3core_glUniform4d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4d(location, v0, v1, v2, v3); +} + +void gl4_3core_glUniform3d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1, GLdouble v2) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3d(location, v0, v1, v2); +} + +void gl4_3core_glUniform2d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2d(location, v0, v1); +} + +void gl4_3core_glUniform1d(void *_glfuncs, GLint location, GLdouble v0) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1d(location, v0); +} + +void gl4_3core_glDrawElementsIndirect(void *_glfuncs, GLenum mode, GLenum gltype, const GLvoid* indirect) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsIndirect(mode, gltype, indirect); +} + +void gl4_3core_glDrawArraysIndirect(void *_glfuncs, GLenum mode, const GLvoid* indirect) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArraysIndirect(mode, indirect); +} + +void gl4_3core_glBlendFuncSeparatei(void *_glfuncs, GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha); +} + +void gl4_3core_glBlendFunci(void *_glfuncs, GLuint buf, GLenum src, GLenum dst) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFunci(buf, src, dst); +} + +void gl4_3core_glBlendEquationSeparatei(void *_glfuncs, GLuint buf, GLenum modeRGB, GLenum modeAlpha) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquationSeparatei(buf, modeRGB, modeAlpha); +} + +void gl4_3core_glBlendEquationi(void *_glfuncs, GLuint buf, GLenum mode) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquationi(buf, mode); +} + +void gl4_3core_glMinSampleShading(void *_glfuncs, GLfloat value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMinSampleShading(value); +} + +void gl4_3core_glGetDoublei_v(void *_glfuncs, GLenum target, GLuint index, GLdouble* data) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetDoublei_v(target, index, data); +} + +void gl4_3core_glGetFloati_v(void *_glfuncs, GLenum target, GLuint index, GLfloat* data) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFloati_v(target, index, data); +} + +void gl4_3core_glDepthRangeIndexed(void *_glfuncs, GLuint index, GLdouble n, GLdouble f) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRangeIndexed(index, n, f); +} + +void gl4_3core_glDepthRangeArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLdouble* v) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRangeArrayv(first, count, v); +} + +void gl4_3core_glScissorIndexedv(void *_glfuncs, GLuint index, const GLint* v) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissorIndexedv(index, v); +} + +void gl4_3core_glScissorIndexed(void *_glfuncs, GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissorIndexed(index, left, bottom, width, height); +} + +void gl4_3core_glScissorArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLint* v) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glScissorArrayv(first, count, v); +} + +void gl4_3core_glViewportIndexedfv(void *_glfuncs, GLuint index, const GLfloat* v) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewportIndexedfv(index, v); +} + +void gl4_3core_glViewportIndexedf(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewportIndexedf(index, x, y, w, h); +} + +void gl4_3core_glViewportArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLfloat* v) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glViewportArrayv(first, count, v); +} + +void gl4_3core_glGetVertexAttribLdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribLdv(index, pname, params); +} + +void gl4_3core_glVertexAttribLPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribLPointer(index, size, gltype, stride, pointer); +} + +void gl4_3core_glVertexAttribL4dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL4dv(index, v); +} + +void gl4_3core_glVertexAttribL3dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL3dv(index, v); +} + +void gl4_3core_glVertexAttribL2dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL2dv(index, v); +} + +void gl4_3core_glVertexAttribL1dv(void *_glfuncs, GLuint index, const GLdouble* v) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL1dv(index, v); +} + +void gl4_3core_glVertexAttribL4d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL4d(index, x, y, z, w); +} + +void gl4_3core_glVertexAttribL3d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL3d(index, x, y, z); +} + +void gl4_3core_glVertexAttribL2d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL2d(index, x, y); +} + +void gl4_3core_glVertexAttribL1d(void *_glfuncs, GLuint index, GLdouble x) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribL1d(index, x); +} + +void gl4_3core_glGetProgramPipelineInfoLog(void *_glfuncs, GLuint pipeline, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog); +} + +void gl4_3core_glValidateProgramPipeline(void *_glfuncs, GLuint pipeline) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glValidateProgramPipeline(pipeline); +} + +void gl4_3core_glProgramUniformMatrix4x3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4x3dv(program, location, count, transpose, value); +} + +void gl4_3core_glProgramUniformMatrix3x4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3x4dv(program, location, count, transpose, value); +} + +void gl4_3core_glProgramUniformMatrix4x2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4x2dv(program, location, count, transpose, value); +} + +void gl4_3core_glProgramUniformMatrix2x4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2x4dv(program, location, count, transpose, value); +} + +void gl4_3core_glProgramUniformMatrix3x2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3x2dv(program, location, count, transpose, value); +} + +void gl4_3core_glProgramUniformMatrix2x3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2x3dv(program, location, count, transpose, value); +} + +void gl4_3core_glProgramUniformMatrix4x3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4x3fv(program, location, count, transpose, value); +} + +void gl4_3core_glProgramUniformMatrix3x4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3x4fv(program, location, count, transpose, value); +} + +void gl4_3core_glProgramUniformMatrix4x2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4x2fv(program, location, count, transpose, value); +} + +void gl4_3core_glProgramUniformMatrix2x4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2x4fv(program, location, count, transpose, value); +} + +void gl4_3core_glProgramUniformMatrix3x2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3x2fv(program, location, count, transpose, value); +} + +void gl4_3core_glProgramUniformMatrix2x3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2x3fv(program, location, count, transpose, value); +} + +void gl4_3core_glProgramUniformMatrix4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4dv(program, location, count, transpose, value); +} + +void gl4_3core_glProgramUniformMatrix3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3dv(program, location, count, transpose, value); +} + +void gl4_3core_glProgramUniformMatrix2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2dv(program, location, count, transpose, value); +} + +void gl4_3core_glProgramUniformMatrix4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix4fv(program, location, count, transpose, value); +} + +void gl4_3core_glProgramUniformMatrix3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix3fv(program, location, count, transpose, value); +} + +void gl4_3core_glProgramUniformMatrix2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniformMatrix2fv(program, location, count, transpose, value); +} + +void gl4_3core_glProgramUniform4uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4uiv(program, location, count, value); +} + +void gl4_3core_glProgramUniform4ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4ui(program, location, v0, v1, v2, v3); +} + +void gl4_3core_glProgramUniform4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4dv(program, location, count, value); +} + +void gl4_3core_glProgramUniform4d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4d(program, location, v0, v1, v2, v3); +} + +void gl4_3core_glProgramUniform4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4fv(program, location, count, value); +} + +void gl4_3core_glProgramUniform4f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4f(program, location, v0, v1, v2, v3); +} + +void gl4_3core_glProgramUniform4iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4iv(program, location, count, value); +} + +void gl4_3core_glProgramUniform4i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform4i(program, location, v0, v1, v2, v3); +} + +void gl4_3core_glProgramUniform3uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3uiv(program, location, count, value); +} + +void gl4_3core_glProgramUniform3ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3ui(program, location, v0, v1, v2); +} + +void gl4_3core_glProgramUniform3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3dv(program, location, count, value); +} + +void gl4_3core_glProgramUniform3d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3d(program, location, v0, v1, v2); +} + +void gl4_3core_glProgramUniform3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3fv(program, location, count, value); +} + +void gl4_3core_glProgramUniform3f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3f(program, location, v0, v1, v2); +} + +void gl4_3core_glProgramUniform3iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3iv(program, location, count, value); +} + +void gl4_3core_glProgramUniform3i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1, GLint v2) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform3i(program, location, v0, v1, v2); +} + +void gl4_3core_glProgramUniform2uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2uiv(program, location, count, value); +} + +void gl4_3core_glProgramUniform2ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2ui(program, location, v0, v1); +} + +void gl4_3core_glProgramUniform2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2dv(program, location, count, value); +} + +void gl4_3core_glProgramUniform2d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2d(program, location, v0, v1); +} + +void gl4_3core_glProgramUniform2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2fv(program, location, count, value); +} + +void gl4_3core_glProgramUniform2f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2f(program, location, v0, v1); +} + +void gl4_3core_glProgramUniform2iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2iv(program, location, count, value); +} + +void gl4_3core_glProgramUniform2i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform2i(program, location, v0, v1); +} + +void gl4_3core_glProgramUniform1uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1uiv(program, location, count, value); +} + +void gl4_3core_glProgramUniform1ui(void *_glfuncs, GLuint program, GLint location, GLuint v0) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1ui(program, location, v0); +} + +void gl4_3core_glProgramUniform1dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1dv(program, location, count, value); +} + +void gl4_3core_glProgramUniform1d(void *_glfuncs, GLuint program, GLint location, GLdouble v0) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1d(program, location, v0); +} + +void gl4_3core_glProgramUniform1fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1fv(program, location, count, value); +} + +void gl4_3core_glProgramUniform1f(void *_glfuncs, GLuint program, GLint location, GLfloat v0) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1f(program, location, v0); +} + +void gl4_3core_glProgramUniform1iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1iv(program, location, count, value); +} + +void gl4_3core_glProgramUniform1i(void *_glfuncs, GLuint program, GLint location, GLint v0) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramUniform1i(program, location, v0); +} + +void gl4_3core_glGetProgramPipelineiv(void *_glfuncs, GLuint pipeline, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramPipelineiv(pipeline, pname, params); +} + +GLboolean gl4_3core_glIsProgramPipeline(void *_glfuncs, GLuint pipeline) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsProgramPipeline(pipeline); +} + +void gl4_3core_glGenProgramPipelines(void *_glfuncs, GLsizei n, GLuint* pipelines) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenProgramPipelines(n, pipelines); +} + +void gl4_3core_glDeleteProgramPipelines(void *_glfuncs, GLsizei n, const GLuint* pipelines) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteProgramPipelines(n, pipelines); +} + +void gl4_3core_glBindProgramPipeline(void *_glfuncs, GLuint pipeline) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindProgramPipeline(pipeline); +} + +void gl4_3core_glActiveShaderProgram(void *_glfuncs, GLuint pipeline, GLuint program) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glActiveShaderProgram(pipeline, program); +} + +void gl4_3core_glUseProgramStages(void *_glfuncs, GLuint pipeline, GLbitfield stages, GLuint program) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUseProgramStages(pipeline, stages, program); +} + +void gl4_3core_glProgramParameteri(void *_glfuncs, GLuint program, GLenum pname, GLint value) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramParameteri(program, pname, value); +} + +void gl4_3core_glProgramBinary(void *_glfuncs, GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glProgramBinary(program, binaryFormat, binary, length); +} + +void gl4_3core_glGetProgramBinary(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramBinary(program, bufSize, length, binaryFormat, binary); +} + +void gl4_3core_glClearDepthf(void *_glfuncs, GLfloat dd) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearDepthf(dd); +} + +void gl4_3core_glDepthRangef(void *_glfuncs, GLfloat n, GLfloat f) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRangef(n, f); +} + +void gl4_3core_glGetShaderPrecisionFormat(void *_glfuncs, GLenum shadertype, GLenum precisionType, GLint* range_, GLint* precision) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderPrecisionFormat(shadertype, precisionType, range_, precision); +} + +void gl4_3core_glShaderBinary(void *_glfuncs, GLsizei count, const GLuint* shaders, GLenum binaryFormat, const GLvoid* binary, GLsizei length) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShaderBinary(count, shaders, binaryFormat, binary, length); +} + +void gl4_3core_glReleaseShaderCompiler(void *_glfuncs) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReleaseShaderCompiler(); +} + +void gl4_3core_glTexStorage3D(void *_glfuncs, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexStorage3D(target, levels, internalFormat, width, height, depth); +} + +void gl4_3core_glTexStorage2D(void *_glfuncs, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexStorage2D(target, levels, internalFormat, width, height); +} + +void gl4_3core_glTexStorage1D(void *_glfuncs, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexStorage1D(target, levels, internalFormat, width); +} + +void gl4_3core_glMemoryBarrier(void *_glfuncs, GLbitfield barriers) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMemoryBarrier(barriers); +} + +void gl4_3core_glBindImageTexture(void *_glfuncs, GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindImageTexture(unit, texture, level, layered, layer, access, format); +} + +void gl4_3core_glGetActiveAtomicCounterBufferiv(void *_glfuncs, GLuint program, GLuint bufferIndex, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params); +} + +void gl4_3core_glGetInternalformativ(void *_glfuncs, GLenum target, GLenum internalFormat, GLenum pname, GLsizei bufSize, GLint* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetInternalformativ(target, internalFormat, pname, bufSize, params); +} + +void gl4_3core_glDrawTransformFeedbackStreamInstanced(void *_glfuncs, GLenum mode, GLuint id, GLuint stream, GLsizei instancecount) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount); +} + +void gl4_3core_glDrawTransformFeedbackInstanced(void *_glfuncs, GLenum mode, GLuint id, GLsizei instancecount) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawTransformFeedbackInstanced(mode, id, instancecount); +} + +void gl4_3core_glDrawElementsInstancedBaseVertexBaseInstance(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsInstancedBaseVertexBaseInstance(mode, count, gltype, indices, instancecount, basevertex, baseinstance); +} + +void gl4_3core_glDrawElementsInstancedBaseInstance(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLuint baseinstance) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawElementsInstancedBaseInstance(mode, count, gltype, indices, instancecount, baseinstance); +} + +void gl4_3core_glDrawArraysInstancedBaseInstance(void *_glfuncs, GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance); +} + +void gl4_3core_glTexStorage3DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexStorage3DMultisample(target, samples, internalFormat, width, height, depth, fixedsamplelocations); +} + +void gl4_3core_glTexStorage2DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexStorage2DMultisample(target, samples, internalFormat, width, height, fixedsamplelocations); +} + +void gl4_3core_glTexBufferRange(void *_glfuncs, GLenum target, GLenum internalFormat, GLuint buffer, GLintptr offset, GLsizeiptr size) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTexBufferRange(target, internalFormat, buffer, offset, size); +} + +void gl4_3core_glShaderStorageBlockBinding(void *_glfuncs, GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding); +} + +GLint gl4_3core_glGetProgramResourceLocationIndex(void *_glfuncs, GLuint program, GLenum programInterface, const GLchar* name) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetProgramResourceLocationIndex(program, programInterface, name); +} + +GLint gl4_3core_glGetProgramResourceLocation(void *_glfuncs, GLuint program, GLenum programInterface, const GLchar* name) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetProgramResourceLocation(program, programInterface, name); +} + +void gl4_3core_glGetProgramResourceiv(void *_glfuncs, GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum* props, GLsizei bufSize, GLsizei* length, GLint* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params); +} + +void gl4_3core_glGetProgramResourceName(void *_glfuncs, GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramResourceName(program, programInterface, index, bufSize, length, name); +} + +GLuint gl4_3core_glGetProgramResourceIndex(void *_glfuncs, GLuint program, GLenum programInterface, const GLchar* name) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetProgramResourceIndex(program, programInterface, name); +} + +void gl4_3core_glGetProgramInterfaceiv(void *_glfuncs, GLuint program, GLenum programInterface, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramInterfaceiv(program, programInterface, pname, params); +} + +void gl4_3core_glMultiDrawElementsIndirect(void *_glfuncs, GLenum mode, GLenum gltype, const GLvoid* indirect, GLsizei drawcount, GLsizei stride) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiDrawElementsIndirect(mode, gltype, indirect, drawcount, stride); +} + +void gl4_3core_glMultiDrawArraysIndirect(void *_glfuncs, GLenum mode, const GLvoid* indirect, GLsizei drawcount, GLsizei stride) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glMultiDrawArraysIndirect(mode, indirect, drawcount, stride); +} + +void gl4_3core_glInvalidateSubFramebuffer(void *_glfuncs, GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height); +} + +void gl4_3core_glInvalidateFramebuffer(void *_glfuncs, GLenum target, GLsizei numAttachments, const GLenum* attachments) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInvalidateFramebuffer(target, numAttachments, attachments); +} + +void gl4_3core_glInvalidateBufferData(void *_glfuncs, GLuint buffer) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInvalidateBufferData(buffer); +} + +void gl4_3core_glInvalidateBufferSubData(void *_glfuncs, GLuint buffer, GLintptr offset, GLsizeiptr length) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInvalidateBufferSubData(buffer, offset, length); +} + +void gl4_3core_glInvalidateTexImage(void *_glfuncs, GLuint texture, GLint level) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInvalidateTexImage(texture, level); +} + +void gl4_3core_glInvalidateTexSubImage(void *_glfuncs, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glInvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth); +} + +void gl4_3core_glGetInternalformati64v(void *_glfuncs, GLenum target, GLenum internalFormat, GLenum pname, GLsizei bufSize, GLint64* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetInternalformati64v(target, internalFormat, pname, bufSize, params); +} + +void gl4_3core_glGetFramebufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFramebufferParameteriv(target, pname, params); +} + +void gl4_3core_glFramebufferParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferParameteri(target, pname, param); +} + +void gl4_3core_glVertexBindingDivisor(void *_glfuncs, GLuint bindingindex, GLuint divisor) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexBindingDivisor(bindingindex, divisor); +} + +void gl4_3core_glVertexAttribBinding(void *_glfuncs, GLuint attribindex, GLuint bindingindex) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribBinding(attribindex, bindingindex); +} + +void gl4_3core_glVertexAttribLFormat(void *_glfuncs, GLuint attribindex, GLint size, GLenum gltype, GLuint relativeoffset) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribLFormat(attribindex, size, gltype, relativeoffset); +} + +void gl4_3core_glVertexAttribIFormat(void *_glfuncs, GLuint attribindex, GLint size, GLenum gltype, GLuint relativeoffset) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribIFormat(attribindex, size, gltype, relativeoffset); +} + +void gl4_3core_glVertexAttribFormat(void *_glfuncs, GLuint attribindex, GLint size, GLenum gltype, GLboolean normalized, GLuint relativeoffset) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribFormat(attribindex, size, gltype, normalized, relativeoffset); +} + +void gl4_3core_glBindVertexBuffer(void *_glfuncs, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindVertexBuffer(bindingindex, buffer, offset, stride); +} + +void gl4_3core_glTextureView(void *_glfuncs, GLuint texture, GLenum target, GLuint origtexture, GLenum internalFormat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glTextureView(texture, target, origtexture, internalFormat, minlevel, numlevels, minlayer, numlayers); +} + +void gl4_3core_glCopyImageSubData(void *_glfuncs, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth); +} + +void gl4_3core_glDispatchComputeIndirect(void *_glfuncs, GLintptr indirect) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDispatchComputeIndirect(indirect); +} + +void gl4_3core_glDispatchCompute(void *_glfuncs, GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDispatchCompute(num_groups_x, num_groups_y, num_groups_z); +} + +void gl4_3core_glClearBufferSubData(void *_glfuncs, GLenum target, GLenum internalFormat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum gltype, const GLvoid* data) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferSubData(target, internalFormat, offset, size, format, gltype, data); +} + +void gl4_3core_glClearBufferData(void *_glfuncs, GLenum target, GLenum internalFormat, GLenum format, GLenum gltype, const GLvoid* data) +{ + QOpenGLFunctions_4_3_Core* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearBufferData(target, internalFormat, format, gltype, data); +} + diff --git a/gl/4.3core/funcs.h b/gl/4.3core/funcs.h new file mode 100644 index 00000000..b65f69bc --- /dev/null +++ b/gl/4.3core/funcs.h @@ -0,0 +1,530 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#ifndef __cplusplus +#include +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef char GLchar; +typedef signed char GLbyte; /* 1-byte signed */ +typedef short GLshort; /* 2-byte signed */ +typedef int GLint; /* 4-byte signed */ +typedef unsigned char GLubyte; /* 1-byte unsigned */ +typedef unsigned short GLushort; /* 2-byte unsigned */ +typedef unsigned int GLuint; /* 4-byte unsigned */ +typedef int GLsizei; /* 4-byte signed */ +typedef float GLfloat; /* single precision float */ +typedef float GLclampf; /* single precision float in [0,1] */ +typedef double GLdouble; /* double precision float */ +typedef double GLclampd; /* double precision float in [0,1] */ +typedef int64_t GLint64; +typedef uint64_t GLuint64; +typedef ptrdiff_t GLintptr; +typedef ptrdiff_t GLsizeiptr; +typedef ptrdiff_t GLintptrARB; +typedef ptrdiff_t GLsizeiptrARB; +typedef struct __GLsync *GLsync; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +void *gl4_3core_funcs(); + +void gl4_3core_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_3core_glDepthRange(void *_glfuncs, GLdouble nearVal, GLdouble farVal); +GLboolean gl4_3core_glIsEnabled(void *_glfuncs, GLenum cap); +void gl4_3core_glGetTexLevelParameteriv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLint* params); +void gl4_3core_glGetTexLevelParameterfv(void *_glfuncs, GLenum target, GLint level, GLenum pname, GLfloat* params); +void gl4_3core_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_3core_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gl4_3core_glGetTexImage(void *_glfuncs, GLenum target, GLint level, GLenum format, GLenum gltype, GLvoid* pixels); +void gl4_3core_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params); +void gl4_3core_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params); +GLenum gl4_3core_glGetError(void *_glfuncs); +void gl4_3core_glGetDoublev(void *_glfuncs, GLenum pname, GLdouble* params); +void gl4_3core_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params); +void gl4_3core_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels); +void gl4_3core_glReadBuffer(void *_glfuncs, GLenum mode); +void gl4_3core_glPixelStorei(void *_glfuncs, GLenum pname, GLint param); +void gl4_3core_glPixelStoref(void *_glfuncs, GLenum pname, GLfloat param); +void gl4_3core_glDepthFunc(void *_glfuncs, GLenum glfunc); +void gl4_3core_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass); +void gl4_3core_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask); +void gl4_3core_glLogicOp(void *_glfuncs, GLenum opcode); +void gl4_3core_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor); +void gl4_3core_glFlush(void *_glfuncs); +void gl4_3core_glFinish(void *_glfuncs); +void gl4_3core_glEnable(void *_glfuncs, GLenum cap); +void gl4_3core_glDisable(void *_glfuncs, GLenum cap); +void gl4_3core_glDepthMask(void *_glfuncs, GLboolean flag); +void gl4_3core_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +void gl4_3core_glStencilMask(void *_glfuncs, GLuint mask); +void gl4_3core_glClearDepth(void *_glfuncs, GLdouble depth); +void gl4_3core_glClearStencil(void *_glfuncs, GLint s); +void gl4_3core_glClearColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl4_3core_glClear(void *_glfuncs, GLbitfield mask); +void gl4_3core_glDrawBuffer(void *_glfuncs, GLenum mode); +void gl4_3core_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_3core_glTexImage1D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_3core_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl4_3core_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl4_3core_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gl4_3core_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gl4_3core_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_3core_glPolygonMode(void *_glfuncs, GLenum face, GLenum mode); +void gl4_3core_glPointSize(void *_glfuncs, GLfloat size); +void gl4_3core_glLineWidth(void *_glfuncs, GLfloat width); +void gl4_3core_glHint(void *_glfuncs, GLenum target, GLenum mode); +void gl4_3core_glFrontFace(void *_glfuncs, GLenum mode); +void gl4_3core_glCullFace(void *_glfuncs, GLenum mode); +void gl4_3core_glIndexubv(void *_glfuncs, const GLubyte* c); +void gl4_3core_glIndexub(void *_glfuncs, GLubyte c); +GLboolean gl4_3core_glIsTexture(void *_glfuncs, GLuint texture); +void gl4_3core_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures); +void gl4_3core_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures); +void gl4_3core_glBindTexture(void *_glfuncs, GLenum target, GLuint texture); +void gl4_3core_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_3core_glTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_3core_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_3core_glCopyTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +void gl4_3core_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +void gl4_3core_glCopyTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border); +void gl4_3core_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units); +void gl4_3core_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl4_3core_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count); +void gl4_3core_glCopyTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_3core_glTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_3core_glTexImage3D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gl4_3core_glDrawRangeElements(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices); +void gl4_3core_glBlendEquation(void *_glfuncs, GLenum mode); +void gl4_3core_glBlendColor(void *_glfuncs, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void gl4_3core_glGetCompressedTexImage(void *_glfuncs, GLenum target, GLint level, GLvoid* img); +void gl4_3core_glCompressedTexSubImage1D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl4_3core_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl4_3core_glCompressedTexSubImage3D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data); +void gl4_3core_glCompressedTexImage1D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid* data); +void gl4_3core_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data); +void gl4_3core_glCompressedTexImage3D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data); +void gl4_3core_glSampleCoverage(void *_glfuncs, GLfloat value, GLboolean invert); +void gl4_3core_glActiveTexture(void *_glfuncs, GLenum texture); +void gl4_3core_glPointParameteriv(void *_glfuncs, GLenum pname, const GLint* params); +void gl4_3core_glPointParameteri(void *_glfuncs, GLenum pname, GLint param); +void gl4_3core_glPointParameterfv(void *_glfuncs, GLenum pname, const GLfloat* params); +void gl4_3core_glPointParameterf(void *_glfuncs, GLenum pname, GLfloat param); +void gl4_3core_glMultiDrawArrays(void *_glfuncs, GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount); +void gl4_3core_glBlendFuncSeparate(void *_glfuncs, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +void gl4_3core_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +GLboolean gl4_3core_glUnmapBuffer(void *_glfuncs, GLenum target); +void gl4_3core_glGetBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data); +void gl4_3core_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data); +void gl4_3core_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage); +GLboolean gl4_3core_glIsBuffer(void *_glfuncs, GLuint buffer); +void gl4_3core_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers); +void gl4_3core_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers); +void gl4_3core_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer); +void gl4_3core_glGetQueryObjectuiv(void *_glfuncs, GLuint id, GLenum pname, GLuint* params); +void gl4_3core_glGetQueryObjectiv(void *_glfuncs, GLuint id, GLenum pname, GLint* params); +void gl4_3core_glGetQueryiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_3core_glEndQuery(void *_glfuncs, GLenum target); +void gl4_3core_glBeginQuery(void *_glfuncs, GLenum target, GLuint id); +GLboolean gl4_3core_glIsQuery(void *_glfuncs, GLuint id); +void gl4_3core_glDeleteQueries(void *_glfuncs, GLsizei n, const GLuint* ids); +void gl4_3core_glGenQueries(void *_glfuncs, GLsizei n, GLuint* ids); +void gl4_3core_glVertexAttribPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLboolean normalized, GLsizei stride, const GLvoid* offset); +void gl4_3core_glValidateProgram(void *_glfuncs, GLuint program); +void gl4_3core_glUniformMatrix4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_3core_glUniformMatrix3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_3core_glUniformMatrix2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_3core_glUniform4iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl4_3core_glUniform3iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl4_3core_glUniform2iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl4_3core_glUniform1iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gl4_3core_glUniform4fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl4_3core_glUniform3fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl4_3core_glUniform2fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl4_3core_glUniform1fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gl4_3core_glUniform4i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +void gl4_3core_glUniform3i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2); +void gl4_3core_glUniform2i(void *_glfuncs, GLint location, GLint v0, GLint v1); +void gl4_3core_glUniform1i(void *_glfuncs, GLint location, GLint v0); +void gl4_3core_glUniform4f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +void gl4_3core_glUniform3f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +void gl4_3core_glUniform2f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1); +void gl4_3core_glUniform1f(void *_glfuncs, GLint location, GLfloat v0); +void gl4_3core_glUseProgram(void *_glfuncs, GLuint program); +void gl4_3core_glShaderSource(void *_glfuncs, GLuint shader, GLsizei count, const GLchar** source, const GLint* length); +void gl4_3core_glLinkProgram(void *_glfuncs, GLuint program); +GLboolean gl4_3core_glIsShader(void *_glfuncs, GLuint shader); +GLboolean gl4_3core_glIsProgram(void *_glfuncs, GLuint program); +void gl4_3core_glGetVertexAttribiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params); +void gl4_3core_glGetVertexAttribfv(void *_glfuncs, GLuint index, GLenum pname, GLfloat* params); +void gl4_3core_glGetVertexAttribdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params); +void gl4_3core_glGetUniformiv(void *_glfuncs, GLuint program, GLint location, GLint* params); +void gl4_3core_glGetUniformfv(void *_glfuncs, GLuint program, GLint location, GLfloat* params); +GLint gl4_3core_glGetUniformLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl4_3core_glGetShaderSource(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source); +void gl4_3core_glGetShaderInfoLog(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl4_3core_glGetShaderiv(void *_glfuncs, GLuint shader, GLenum pname, GLint* params); +void gl4_3core_glGetProgramInfoLog(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl4_3core_glGetProgramiv(void *_glfuncs, GLuint program, GLenum pname, GLint* params); +GLint gl4_3core_glGetAttribLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl4_3core_glGetAttachedShaders(void *_glfuncs, GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj); +void gl4_3core_glGetActiveUniform(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name); +void gl4_3core_glGetActiveAttrib(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name); +void gl4_3core_glEnableVertexAttribArray(void *_glfuncs, GLuint index); +void gl4_3core_glDisableVertexAttribArray(void *_glfuncs, GLuint index); +void gl4_3core_glDetachShader(void *_glfuncs, GLuint program, GLuint shader); +void gl4_3core_glDeleteShader(void *_glfuncs, GLuint shader); +void gl4_3core_glDeleteProgram(void *_glfuncs, GLuint program); +GLuint gl4_3core_glCreateShader(void *_glfuncs, GLenum gltype); +GLuint gl4_3core_glCreateProgram(void *_glfuncs); +void gl4_3core_glCompileShader(void *_glfuncs, GLuint shader); +void gl4_3core_glBindAttribLocation(void *_glfuncs, GLuint program, GLuint index, const GLchar* name); +void gl4_3core_glAttachShader(void *_glfuncs, GLuint program, GLuint shader); +void gl4_3core_glStencilMaskSeparate(void *_glfuncs, GLenum face, GLuint mask); +void gl4_3core_glStencilFuncSeparate(void *_glfuncs, GLenum face, GLenum glfunc, GLint ref, GLuint mask); +void gl4_3core_glStencilOpSeparate(void *_glfuncs, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +void gl4_3core_glDrawBuffers(void *_glfuncs, GLsizei n, const GLenum* bufs); +void gl4_3core_glBlendEquationSeparate(void *_glfuncs, GLenum modeRGB, GLenum modeAlpha); +void gl4_3core_glUniformMatrix4x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_3core_glUniformMatrix3x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_3core_glUniformMatrix4x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_3core_glUniformMatrix2x4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_3core_glUniformMatrix3x2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_3core_glUniformMatrix2x3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +GLboolean gl4_3core_glIsVertexArray(void *_glfuncs, GLuint array); +void gl4_3core_glGenVertexArrays(void *_glfuncs, GLsizei n, GLuint* arrays); +void gl4_3core_glDeleteVertexArrays(void *_glfuncs, GLsizei n, const GLuint* arrays); +void gl4_3core_glBindVertexArray(void *_glfuncs, GLuint array); +void gl4_3core_glFlushMappedBufferRange(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr length); +void gl4_3core_glFramebufferTextureLayer(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +void gl4_3core_glRenderbufferStorageMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height); +void gl4_3core_glBlitFramebuffer(void *_glfuncs, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +void gl4_3core_glGenerateMipmap(void *_glfuncs, GLenum target); +void gl4_3core_glGetFramebufferAttachmentParameteriv(void *_glfuncs, GLenum target, GLenum attachment, GLenum pname, GLint* params); +void gl4_3core_glFramebufferRenderbuffer(void *_glfuncs, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +void gl4_3core_glFramebufferTexture3D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +void gl4_3core_glFramebufferTexture2D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +void gl4_3core_glFramebufferTexture1D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLenum gl4_3core_glCheckFramebufferStatus(void *_glfuncs, GLenum target); +void gl4_3core_glGenFramebuffers(void *_glfuncs, GLsizei n, GLuint* framebuffers); +void gl4_3core_glDeleteFramebuffers(void *_glfuncs, GLsizei n, const GLuint* framebuffers); +void gl4_3core_glBindFramebuffer(void *_glfuncs, GLenum target, GLuint framebuffer); +GLboolean gl4_3core_glIsFramebuffer(void *_glfuncs, GLuint framebuffer); +void gl4_3core_glGetRenderbufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_3core_glRenderbufferStorage(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height); +void gl4_3core_glGenRenderbuffers(void *_glfuncs, GLsizei n, GLuint* renderbuffers); +void gl4_3core_glDeleteRenderbuffers(void *_glfuncs, GLsizei n, const GLuint* renderbuffers); +void gl4_3core_glBindRenderbuffer(void *_glfuncs, GLenum target, GLuint renderbuffer); +GLboolean gl4_3core_glIsRenderbuffer(void *_glfuncs, GLuint renderbuffer); +void gl4_3core_glClearBufferfi(void *_glfuncs, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); +void gl4_3core_glClearBufferfv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLfloat* value); +void gl4_3core_glClearBufferuiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLuint* value); +void gl4_3core_glClearBufferiv(void *_glfuncs, GLenum buffer, GLint drawbuffer, const GLint* value); +void gl4_3core_glGetTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, GLuint* params); +void gl4_3core_glGetTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_3core_glTexParameterIuiv(void *_glfuncs, GLenum target, GLenum pname, const GLuint* params); +void gl4_3core_glTexParameterIiv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gl4_3core_glUniform4uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl4_3core_glUniform3uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl4_3core_glUniform2uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl4_3core_glUniform1uiv(void *_glfuncs, GLint location, GLsizei count, const GLuint* value); +void gl4_3core_glUniform4ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +void gl4_3core_glUniform3ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1, GLuint v2); +void gl4_3core_glUniform2ui(void *_glfuncs, GLint location, GLuint v0, GLuint v1); +void gl4_3core_glUniform1ui(void *_glfuncs, GLint location, GLuint v0); +GLint gl4_3core_glGetFragDataLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gl4_3core_glBindFragDataLocation(void *_glfuncs, GLuint program, GLuint color, const GLchar* name); +void gl4_3core_glGetUniformuiv(void *_glfuncs, GLuint program, GLint location, GLuint* params); +void gl4_3core_glGetVertexAttribIuiv(void *_glfuncs, GLuint index, GLenum pname, GLuint* params); +void gl4_3core_glGetVertexAttribIiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params); +void gl4_3core_glVertexAttribIPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_3core_glEndConditionalRender(void *_glfuncs); +void gl4_3core_glBeginConditionalRender(void *_glfuncs, GLuint id, GLenum mode); +void gl4_3core_glClampColor(void *_glfuncs, GLenum target, GLenum clamp); +void gl4_3core_glGetTransformFeedbackVarying(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* gltype, GLchar* name); +void gl4_3core_glBindBufferBase(void *_glfuncs, GLenum target, GLuint index, GLuint buffer); +void gl4_3core_glBindBufferRange(void *_glfuncs, GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +void gl4_3core_glEndTransformFeedback(void *_glfuncs); +void gl4_3core_glBeginTransformFeedback(void *_glfuncs, GLenum primitiveMode); +GLboolean gl4_3core_glIsEnabledi(void *_glfuncs, GLenum target, GLuint index); +void gl4_3core_glDisablei(void *_glfuncs, GLenum target, GLuint index); +void gl4_3core_glEnablei(void *_glfuncs, GLenum target, GLuint index); +void gl4_3core_glGetIntegeri_v(void *_glfuncs, GLenum target, GLuint index, GLint* data); +void gl4_3core_glGetBooleani_v(void *_glfuncs, GLenum target, GLuint index, GLboolean* data); +void gl4_3core_glColorMaski(void *_glfuncs, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +void gl4_3core_glCopyBufferSubData(void *_glfuncs, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +void gl4_3core_glUniformBlockBinding(void *_glfuncs, GLuint program, GLuint v0, GLuint v1); +void gl4_3core_glGetActiveUniformBlockName(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName); +void gl4_3core_glGetActiveUniformBlockiv(void *_glfuncs, GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params); +GLuint gl4_3core_glGetUniformBlockIndex(void *_glfuncs, GLuint program, const GLchar* uniformBlockName); +void gl4_3core_glGetActiveUniformName(void *_glfuncs, GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName); +void gl4_3core_glGetActiveUniformsiv(void *_glfuncs, GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params); +void gl4_3core_glPrimitiveRestartIndex(void *_glfuncs, GLuint index); +void gl4_3core_glTexBuffer(void *_glfuncs, GLenum target, GLenum internalFormat, GLuint buffer); +void gl4_3core_glDrawElementsInstanced(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount); +void gl4_3core_glDrawArraysInstanced(void *_glfuncs, GLenum mode, GLint first, GLsizei count, GLsizei instancecount); +void gl4_3core_glSampleMaski(void *_glfuncs, GLuint index, GLbitfield mask); +void gl4_3core_glGetMultisamplefv(void *_glfuncs, GLenum pname, GLuint index, GLfloat* val); +void gl4_3core_glTexImage3DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); +void gl4_3core_glTexImage2DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +void gl4_3core_glGetSynciv(void *_glfuncs, GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values); +void gl4_3core_glGetInteger64v(void *_glfuncs, GLenum pname, GLint64* params); +void gl4_3core_glWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout); +GLenum gl4_3core_glClientWaitSync(void *_glfuncs, GLsync sync, GLbitfield flags, GLuint64 timeout); +void gl4_3core_glDeleteSync(void *_glfuncs, GLsync sync); +GLboolean gl4_3core_glIsSync(void *_glfuncs, GLsync sync); +GLsync gl4_3core_glFenceSync(void *_glfuncs, GLenum condition, GLbitfield flags); +void gl4_3core_glProvokingVertex(void *_glfuncs, GLenum mode); +void gl4_3core_glDrawElementsInstancedBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLint basevertex); +void gl4_3core_glDrawRangeElementsBaseVertex(void *_glfuncs, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex); +void gl4_3core_glDrawElementsBaseVertex(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLint basevertex); +void gl4_3core_glFramebufferTexture(void *_glfuncs, GLenum target, GLenum attachment, GLuint texture, GLint level); +void gl4_3core_glGetBufferParameteri64v(void *_glfuncs, GLenum target, GLenum pname, GLint64* params); +void gl4_3core_glGetInteger64i_v(void *_glfuncs, GLenum target, GLuint index, GLint64* data); +void gl4_3core_glVertexAttribP4uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl4_3core_glVertexAttribP4ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl4_3core_glVertexAttribP3uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl4_3core_glVertexAttribP3ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl4_3core_glVertexAttribP2uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl4_3core_glVertexAttribP2ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl4_3core_glVertexAttribP1uiv(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, const GLuint* value); +void gl4_3core_glVertexAttribP1ui(void *_glfuncs, GLuint index, GLenum gltype, GLboolean normalized, GLuint value); +void gl4_3core_glSecondaryColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color); +void gl4_3core_glSecondaryColorP3ui(void *_glfuncs, GLenum gltype, GLuint color); +void gl4_3core_glColorP4uiv(void *_glfuncs, GLenum gltype, const GLuint* color); +void gl4_3core_glColorP4ui(void *_glfuncs, GLenum gltype, GLuint color); +void gl4_3core_glColorP3uiv(void *_glfuncs, GLenum gltype, const GLuint* color); +void gl4_3core_glColorP3ui(void *_glfuncs, GLenum gltype, GLuint color); +void gl4_3core_glNormalP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_3core_glNormalP3ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_3core_glMultiTexCoordP4uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl4_3core_glMultiTexCoordP4ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl4_3core_glMultiTexCoordP3uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl4_3core_glMultiTexCoordP3ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl4_3core_glMultiTexCoordP2uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl4_3core_glMultiTexCoordP2ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl4_3core_glMultiTexCoordP1uiv(void *_glfuncs, GLenum texture, GLenum gltype, const GLuint* coords); +void gl4_3core_glMultiTexCoordP1ui(void *_glfuncs, GLenum texture, GLenum gltype, GLuint coords); +void gl4_3core_glTexCoordP4uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_3core_glTexCoordP4ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_3core_glTexCoordP3uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_3core_glTexCoordP3ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_3core_glTexCoordP2uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_3core_glTexCoordP2ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_3core_glTexCoordP1uiv(void *_glfuncs, GLenum gltype, const GLuint* coords); +void gl4_3core_glTexCoordP1ui(void *_glfuncs, GLenum gltype, GLuint coords); +void gl4_3core_glVertexP4uiv(void *_glfuncs, GLenum gltype, const GLuint* value); +void gl4_3core_glVertexP4ui(void *_glfuncs, GLenum gltype, GLuint value); +void gl4_3core_glVertexP3uiv(void *_glfuncs, GLenum gltype, const GLuint* value); +void gl4_3core_glVertexP3ui(void *_glfuncs, GLenum gltype, GLuint value); +void gl4_3core_glVertexP2uiv(void *_glfuncs, GLenum gltype, const GLuint* value); +void gl4_3core_glVertexP2ui(void *_glfuncs, GLenum gltype, GLuint value); +void gl4_3core_glGetQueryObjectui64v(void *_glfuncs, GLuint id, GLenum pname, GLuint64* params); +void gl4_3core_glGetQueryObjecti64v(void *_glfuncs, GLuint id, GLenum pname, GLint64* params); +void gl4_3core_glQueryCounter(void *_glfuncs, GLuint id, GLenum target); +void gl4_3core_glGetSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, GLuint* params); +void gl4_3core_glGetSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat* params); +void gl4_3core_glGetSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params); +void gl4_3core_glGetSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, GLint* params); +void gl4_3core_glSamplerParameterIuiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLuint* param); +void gl4_3core_glSamplerParameterIiv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param); +void gl4_3core_glSamplerParameterfv(void *_glfuncs, GLuint sampler, GLenum pname, const GLfloat* param); +void gl4_3core_glSamplerParameterf(void *_glfuncs, GLuint sampler, GLenum pname, GLfloat param); +void gl4_3core_glSamplerParameteriv(void *_glfuncs, GLuint sampler, GLenum pname, const GLint* param); +void gl4_3core_glSamplerParameteri(void *_glfuncs, GLuint sampler, GLenum pname, GLint param); +void gl4_3core_glBindSampler(void *_glfuncs, GLuint unit, GLuint sampler); +GLboolean gl4_3core_glIsSampler(void *_glfuncs, GLuint sampler); +void gl4_3core_glDeleteSamplers(void *_glfuncs, GLsizei count, const GLuint* samplers); +void gl4_3core_glGenSamplers(void *_glfuncs, GLsizei count, GLuint* samplers); +GLint gl4_3core_glGetFragDataIndex(void *_glfuncs, GLuint program, const GLchar* name); +void gl4_3core_glBindFragDataLocationIndexed(void *_glfuncs, GLuint program, GLuint colorNumber, GLuint index, const GLchar* name); +void gl4_3core_glVertexAttribDivisor(void *_glfuncs, GLuint index, GLuint divisor); +void gl4_3core_glGetQueryIndexediv(void *_glfuncs, GLenum target, GLuint index, GLenum pname, GLint* params); +void gl4_3core_glEndQueryIndexed(void *_glfuncs, GLenum target, GLuint index); +void gl4_3core_glBeginQueryIndexed(void *_glfuncs, GLenum target, GLuint index, GLuint id); +void gl4_3core_glDrawTransformFeedbackStream(void *_glfuncs, GLenum mode, GLuint id, GLuint stream); +void gl4_3core_glDrawTransformFeedback(void *_glfuncs, GLenum mode, GLuint id); +void gl4_3core_glResumeTransformFeedback(void *_glfuncs); +void gl4_3core_glPauseTransformFeedback(void *_glfuncs); +GLboolean gl4_3core_glIsTransformFeedback(void *_glfuncs, GLuint id); +void gl4_3core_glGenTransformFeedbacks(void *_glfuncs, GLsizei n, GLuint* ids); +void gl4_3core_glDeleteTransformFeedbacks(void *_glfuncs, GLsizei n, const GLuint* ids); +void gl4_3core_glBindTransformFeedback(void *_glfuncs, GLenum target, GLuint id); +void gl4_3core_glPatchParameterfv(void *_glfuncs, GLenum pname, const GLfloat* values); +void gl4_3core_glPatchParameteri(void *_glfuncs, GLenum pname, GLint value); +void gl4_3core_glGetProgramStageiv(void *_glfuncs, GLuint program, GLenum shadertype, GLenum pname, GLint* values); +void gl4_3core_glGetUniformSubroutineuiv(void *_glfuncs, GLenum shadertype, GLint location, GLuint* params); +void gl4_3core_glUniformSubroutinesuiv(void *_glfuncs, GLenum shadertype, GLsizei count, const GLuint* value); +void gl4_3core_glGetActiveSubroutineName(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name); +void gl4_3core_glGetActiveSubroutineUniformName(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name); +void gl4_3core_glGetActiveSubroutineUniformiv(void *_glfuncs, GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint* values); +GLuint gl4_3core_glGetSubroutineIndex(void *_glfuncs, GLuint program, GLenum shadertype, const GLchar* name); +GLint gl4_3core_glGetSubroutineUniformLocation(void *_glfuncs, GLuint program, GLenum shadertype, const GLchar* name); +void gl4_3core_glGetUniformdv(void *_glfuncs, GLuint program, GLint location, GLdouble* params); +void gl4_3core_glUniformMatrix4x3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3core_glUniformMatrix4x2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3core_glUniformMatrix3x4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3core_glUniformMatrix3x2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3core_glUniformMatrix2x4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3core_glUniformMatrix2x3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3core_glUniformMatrix4dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3core_glUniformMatrix3dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3core_glUniformMatrix2dv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3core_glUniform4dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value); +void gl4_3core_glUniform3dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value); +void gl4_3core_glUniform2dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value); +void gl4_3core_glUniform1dv(void *_glfuncs, GLint location, GLsizei count, const GLdouble* value); +void gl4_3core_glUniform4d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3); +void gl4_3core_glUniform3d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1, GLdouble v2); +void gl4_3core_glUniform2d(void *_glfuncs, GLint location, GLdouble v0, GLdouble v1); +void gl4_3core_glUniform1d(void *_glfuncs, GLint location, GLdouble v0); +void gl4_3core_glDrawElementsIndirect(void *_glfuncs, GLenum mode, GLenum gltype, const GLvoid* indirect); +void gl4_3core_glDrawArraysIndirect(void *_glfuncs, GLenum mode, const GLvoid* indirect); +void gl4_3core_glBlendFuncSeparatei(void *_glfuncs, GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); +void gl4_3core_glBlendFunci(void *_glfuncs, GLuint buf, GLenum src, GLenum dst); +void gl4_3core_glBlendEquationSeparatei(void *_glfuncs, GLuint buf, GLenum modeRGB, GLenum modeAlpha); +void gl4_3core_glBlendEquationi(void *_glfuncs, GLuint buf, GLenum mode); +void gl4_3core_glMinSampleShading(void *_glfuncs, GLfloat value); +void gl4_3core_glGetDoublei_v(void *_glfuncs, GLenum target, GLuint index, GLdouble* data); +void gl4_3core_glGetFloati_v(void *_glfuncs, GLenum target, GLuint index, GLfloat* data); +void gl4_3core_glDepthRangeIndexed(void *_glfuncs, GLuint index, GLdouble n, GLdouble f); +void gl4_3core_glDepthRangeArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLdouble* v); +void gl4_3core_glScissorIndexedv(void *_glfuncs, GLuint index, const GLint* v); +void gl4_3core_glScissorIndexed(void *_glfuncs, GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height); +void gl4_3core_glScissorArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLint* v); +void gl4_3core_glViewportIndexedfv(void *_glfuncs, GLuint index, const GLfloat* v); +void gl4_3core_glViewportIndexedf(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h); +void gl4_3core_glViewportArrayv(void *_glfuncs, GLuint first, GLsizei count, const GLfloat* v); +void gl4_3core_glGetVertexAttribLdv(void *_glfuncs, GLuint index, GLenum pname, GLdouble* params); +void gl4_3core_glVertexAttribLPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLsizei stride, const GLvoid* pointer); +void gl4_3core_glVertexAttribL4dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_3core_glVertexAttribL3dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_3core_glVertexAttribL2dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_3core_glVertexAttribL1dv(void *_glfuncs, GLuint index, const GLdouble* v); +void gl4_3core_glVertexAttribL4d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +void gl4_3core_glVertexAttribL3d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y, GLdouble z); +void gl4_3core_glVertexAttribL2d(void *_glfuncs, GLuint index, GLdouble x, GLdouble y); +void gl4_3core_glVertexAttribL1d(void *_glfuncs, GLuint index, GLdouble x); +void gl4_3core_glGetProgramPipelineInfoLog(void *_glfuncs, GLuint pipeline, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gl4_3core_glValidateProgramPipeline(void *_glfuncs, GLuint pipeline); +void gl4_3core_glProgramUniformMatrix4x3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3core_glProgramUniformMatrix3x4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3core_glProgramUniformMatrix4x2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3core_glProgramUniformMatrix2x4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3core_glProgramUniformMatrix3x2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3core_glProgramUniformMatrix2x3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3core_glProgramUniformMatrix4x3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_3core_glProgramUniformMatrix3x4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_3core_glProgramUniformMatrix4x2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_3core_glProgramUniformMatrix2x4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_3core_glProgramUniformMatrix3x2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_3core_glProgramUniformMatrix2x3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_3core_glProgramUniformMatrix4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3core_glProgramUniformMatrix3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3core_glProgramUniformMatrix2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); +void gl4_3core_glProgramUniformMatrix4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_3core_glProgramUniformMatrix3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_3core_glProgramUniformMatrix2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gl4_3core_glProgramUniform4uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value); +void gl4_3core_glProgramUniform4ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +void gl4_3core_glProgramUniform4dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value); +void gl4_3core_glProgramUniform4d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3); +void gl4_3core_glProgramUniform4fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value); +void gl4_3core_glProgramUniform4f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +void gl4_3core_glProgramUniform4iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value); +void gl4_3core_glProgramUniform4i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +void gl4_3core_glProgramUniform3uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value); +void gl4_3core_glProgramUniform3ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2); +void gl4_3core_glProgramUniform3dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value); +void gl4_3core_glProgramUniform3d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2); +void gl4_3core_glProgramUniform3fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value); +void gl4_3core_glProgramUniform3f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +void gl4_3core_glProgramUniform3iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value); +void gl4_3core_glProgramUniform3i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1, GLint v2); +void gl4_3core_glProgramUniform2uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value); +void gl4_3core_glProgramUniform2ui(void *_glfuncs, GLuint program, GLint location, GLuint v0, GLuint v1); +void gl4_3core_glProgramUniform2dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value); +void gl4_3core_glProgramUniform2d(void *_glfuncs, GLuint program, GLint location, GLdouble v0, GLdouble v1); +void gl4_3core_glProgramUniform2fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value); +void gl4_3core_glProgramUniform2f(void *_glfuncs, GLuint program, GLint location, GLfloat v0, GLfloat v1); +void gl4_3core_glProgramUniform2iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value); +void gl4_3core_glProgramUniform2i(void *_glfuncs, GLuint program, GLint location, GLint v0, GLint v1); +void gl4_3core_glProgramUniform1uiv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLuint* value); +void gl4_3core_glProgramUniform1ui(void *_glfuncs, GLuint program, GLint location, GLuint v0); +void gl4_3core_glProgramUniform1dv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLdouble* value); +void gl4_3core_glProgramUniform1d(void *_glfuncs, GLuint program, GLint location, GLdouble v0); +void gl4_3core_glProgramUniform1fv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLfloat* value); +void gl4_3core_glProgramUniform1f(void *_glfuncs, GLuint program, GLint location, GLfloat v0); +void gl4_3core_glProgramUniform1iv(void *_glfuncs, GLuint program, GLint location, GLsizei count, const GLint* value); +void gl4_3core_glProgramUniform1i(void *_glfuncs, GLuint program, GLint location, GLint v0); +void gl4_3core_glGetProgramPipelineiv(void *_glfuncs, GLuint pipeline, GLenum pname, GLint* params); +GLboolean gl4_3core_glIsProgramPipeline(void *_glfuncs, GLuint pipeline); +void gl4_3core_glGenProgramPipelines(void *_glfuncs, GLsizei n, GLuint* pipelines); +void gl4_3core_glDeleteProgramPipelines(void *_glfuncs, GLsizei n, const GLuint* pipelines); +void gl4_3core_glBindProgramPipeline(void *_glfuncs, GLuint pipeline); +void gl4_3core_glActiveShaderProgram(void *_glfuncs, GLuint pipeline, GLuint program); +void gl4_3core_glUseProgramStages(void *_glfuncs, GLuint pipeline, GLbitfield stages, GLuint program); +void gl4_3core_glProgramParameteri(void *_glfuncs, GLuint program, GLenum pname, GLint value); +void gl4_3core_glProgramBinary(void *_glfuncs, GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length); +void gl4_3core_glGetProgramBinary(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary); +void gl4_3core_glClearDepthf(void *_glfuncs, GLfloat dd); +void gl4_3core_glDepthRangef(void *_glfuncs, GLfloat n, GLfloat f); +void gl4_3core_glGetShaderPrecisionFormat(void *_glfuncs, GLenum shadertype, GLenum precisionType, GLint* range_, GLint* precision); +void gl4_3core_glShaderBinary(void *_glfuncs, GLsizei count, const GLuint* shaders, GLenum binaryFormat, const GLvoid* binary, GLsizei length); +void gl4_3core_glReleaseShaderCompiler(void *_glfuncs); +void gl4_3core_glTexStorage3D(void *_glfuncs, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth); +void gl4_3core_glTexStorage2D(void *_glfuncs, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height); +void gl4_3core_glTexStorage1D(void *_glfuncs, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width); +void gl4_3core_glMemoryBarrier(void *_glfuncs, GLbitfield barriers); +void gl4_3core_glBindImageTexture(void *_glfuncs, GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format); +void gl4_3core_glGetActiveAtomicCounterBufferiv(void *_glfuncs, GLuint program, GLuint bufferIndex, GLenum pname, GLint* params); +void gl4_3core_glGetInternalformativ(void *_glfuncs, GLenum target, GLenum internalFormat, GLenum pname, GLsizei bufSize, GLint* params); +void gl4_3core_glDrawTransformFeedbackStreamInstanced(void *_glfuncs, GLenum mode, GLuint id, GLuint stream, GLsizei instancecount); +void gl4_3core_glDrawTransformFeedbackInstanced(void *_glfuncs, GLenum mode, GLuint id, GLsizei instancecount); +void gl4_3core_glDrawElementsInstancedBaseVertexBaseInstance(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance); +void gl4_3core_glDrawElementsInstancedBaseInstance(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices, GLsizei instancecount, GLuint baseinstance); +void gl4_3core_glDrawArraysInstancedBaseInstance(void *_glfuncs, GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance); +void gl4_3core_glTexStorage3DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); +void gl4_3core_glTexStorage2DMultisample(void *_glfuncs, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +void gl4_3core_glTexBufferRange(void *_glfuncs, GLenum target, GLenum internalFormat, GLuint buffer, GLintptr offset, GLsizeiptr size); +void gl4_3core_glShaderStorageBlockBinding(void *_glfuncs, GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding); +GLint gl4_3core_glGetProgramResourceLocationIndex(void *_glfuncs, GLuint program, GLenum programInterface, const GLchar* name); +GLint gl4_3core_glGetProgramResourceLocation(void *_glfuncs, GLuint program, GLenum programInterface, const GLchar* name); +void gl4_3core_glGetProgramResourceiv(void *_glfuncs, GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum* props, GLsizei bufSize, GLsizei* length, GLint* params); +void gl4_3core_glGetProgramResourceName(void *_glfuncs, GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name); +GLuint gl4_3core_glGetProgramResourceIndex(void *_glfuncs, GLuint program, GLenum programInterface, const GLchar* name); +void gl4_3core_glGetProgramInterfaceiv(void *_glfuncs, GLuint program, GLenum programInterface, GLenum pname, GLint* params); +void gl4_3core_glMultiDrawElementsIndirect(void *_glfuncs, GLenum mode, GLenum gltype, const GLvoid* indirect, GLsizei drawcount, GLsizei stride); +void gl4_3core_glMultiDrawArraysIndirect(void *_glfuncs, GLenum mode, const GLvoid* indirect, GLsizei drawcount, GLsizei stride); +void gl4_3core_glInvalidateSubFramebuffer(void *_glfuncs, GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height); +void gl4_3core_glInvalidateFramebuffer(void *_glfuncs, GLenum target, GLsizei numAttachments, const GLenum* attachments); +void gl4_3core_glInvalidateBufferData(void *_glfuncs, GLuint buffer); +void gl4_3core_glInvalidateBufferSubData(void *_glfuncs, GLuint buffer, GLintptr offset, GLsizeiptr length); +void gl4_3core_glInvalidateTexImage(void *_glfuncs, GLuint texture, GLint level); +void gl4_3core_glInvalidateTexSubImage(void *_glfuncs, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth); +void gl4_3core_glGetInternalformati64v(void *_glfuncs, GLenum target, GLenum internalFormat, GLenum pname, GLsizei bufSize, GLint64* params); +void gl4_3core_glGetFramebufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gl4_3core_glFramebufferParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gl4_3core_glVertexBindingDivisor(void *_glfuncs, GLuint bindingindex, GLuint divisor); +void gl4_3core_glVertexAttribBinding(void *_glfuncs, GLuint attribindex, GLuint bindingindex); +void gl4_3core_glVertexAttribLFormat(void *_glfuncs, GLuint attribindex, GLint size, GLenum gltype, GLuint relativeoffset); +void gl4_3core_glVertexAttribIFormat(void *_glfuncs, GLuint attribindex, GLint size, GLenum gltype, GLuint relativeoffset); +void gl4_3core_glVertexAttribFormat(void *_glfuncs, GLuint attribindex, GLint size, GLenum gltype, GLboolean normalized, GLuint relativeoffset); +void gl4_3core_glBindVertexBuffer(void *_glfuncs, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride); +void gl4_3core_glTextureView(void *_glfuncs, GLuint texture, GLenum target, GLuint origtexture, GLenum internalFormat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers); +void gl4_3core_glCopyImageSubData(void *_glfuncs, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth); +void gl4_3core_glDispatchComputeIndirect(void *_glfuncs, GLintptr indirect); +void gl4_3core_glDispatchCompute(void *_glfuncs, GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z); +void gl4_3core_glClearBufferSubData(void *_glfuncs, GLenum target, GLenum internalFormat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum gltype, const GLvoid* data); +void gl4_3core_glClearBufferData(void *_glfuncs, GLenum target, GLenum internalFormat, GLenum format, GLenum gltype, const GLvoid* data); + + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/gl/4.3core/gl.go b/gl/4.3core/gl.go new file mode 100644 index 00000000..76df4604 --- /dev/null +++ b/gl/4.3core/gl.go @@ -0,0 +1,7052 @@ +// ** file automatically generated by glgen -- do not edit manually ** + +package GL + +// #cgo CXXFLAGS: -std=c++0x -pedantic-errors -Wall -fno-strict-aliasing +// #cgo LDFLAGS: -lstdc++ +// #cgo pkg-config: Qt5Core Qt5OpenGL +// +// #include "funcs.h" +// +// void free(void*); +// +import "C" + +import ( + "fmt" + "reflect" + "unsafe" + + "gopkg.in/qml.v1/gl/glbase" +) + +// API returns a value that offers methods matching the OpenGL version 4.3 API. +// +// The returned API must not be used after the provided OpenGL context becomes invalid. +func API(context glbase.Contexter) *GL { + gl := &GL{} + gl.funcs = C.gl4_3core_funcs() + if gl.funcs == nil { + panic(fmt.Errorf("OpenGL version 4.3 is not available")) + } + return gl +} + +// GL implements the OpenGL version 4.3 API. Values of this +// type must be created via the API function, and it must not be used after +// the associated OpenGL context becomes invalid. +type GL struct { + funcs unsafe.Pointer +} + +const ( + FALSE = 0 + TRUE = 1 + NONE = 0 + + BYTE = 0x1400 + UNSIGNED_BYTE = 0x1401 + SHORT = 0x1402 + UNSIGNED_SHORT = 0x1403 + INT = 0x1404 + UNSIGNED_INT = 0x1405 + FLOAT = 0x1406 + N2_BYTES = 0x1407 + N3_BYTES = 0x1408 + N4_BYTES = 0x1409 + DOUBLE = 0x140A + HALF_FLOAT = 0x140B + FIXED = 0x140C + + ACCUM = 0x0100 + LOAD = 0x0101 + RETURN = 0x0102 + MULT = 0x0103 + ADD = 0x0104 + + ACCUM_BUFFER_BIT = 0x00000200 + ALL_ATTRIB_BITS = 0xFFFFFFFF + COLOR_BUFFER_BIT = 0x00004000 + CURRENT_BIT = 0x00000001 + DEPTH_BUFFER_BIT = 0x00000100 + ENABLE_BIT = 0x00002000 + EVAL_BIT = 0x00010000 + FOG_BIT = 0x00000080 + HINT_BIT = 0x00008000 + LIGHTING_BIT = 0x00000040 + LINE_BIT = 0x00000004 + LIST_BIT = 0x00020000 + MULTISAMPLE_BIT = 0x20000000 + PIXEL_MODE_BIT = 0x00000020 + POINT_BIT = 0x00000002 + POLYGON_BIT = 0x00000008 + POLYGON_STIPPLE_BIT = 0x00000010 + SCISSOR_BIT = 0x00080000 + STENCIL_BUFFER_BIT = 0x00000400 + TEXTURE_BIT = 0x00040000 + TRANSFORM_BIT = 0x00001000 + VIEWPORT_BIT = 0x00000800 + + ALWAYS = 0x0207 + EQUAL = 0x0202 + GEQUAL = 0x0206 + GREATER = 0x0204 + LEQUAL = 0x0203 + LESS = 0x0201 + NEVER = 0x0200 + NOTEQUAL = 0x0205 + + LOGIC_OP = 0x0BF1 + + DST_ALPHA = 0x0304 + ONE = 1 + ONE_MINUS_DST_ALPHA = 0x0305 + ONE_MINUS_SRC_ALPHA = 0x0303 + ONE_MINUS_SRC_COLOR = 0x0301 + SRC_ALPHA = 0x0302 + SRC_COLOR = 0x0300 + ZERO = 0 + + DST_COLOR = 0x0306 + ONE_MINUS_DST_COLOR = 0x0307 + SRC_ALPHA_SATURATE = 0x0308 + + CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF + CLIENT_PIXEL_STORE_BIT = 0x00000001 + CLIENT_VERTEX_ARRAY_BIT = 0x00000002 + + CLIP_DISTANCE0 = 0x3000 + CLIP_DISTANCE1 = 0x3001 + CLIP_DISTANCE2 = 0x3002 + CLIP_DISTANCE3 = 0x3003 + CLIP_DISTANCE4 = 0x3004 + CLIP_DISTANCE5 = 0x3005 + CLIP_DISTANCE6 = 0x3006 + CLIP_DISTANCE7 = 0x3007 + CLIP_PLANE0 = 0x3000 + CLIP_PLANE1 = 0x3001 + CLIP_PLANE2 = 0x3002 + CLIP_PLANE3 = 0x3003 + CLIP_PLANE4 = 0x3004 + CLIP_PLANE5 = 0x3005 + + BACK = 0x0405 + FRONT = 0x0404 + FRONT_AND_BACK = 0x0408 + + AMBIENT = 0x1200 + AMBIENT_AND_DIFFUSE = 0x1602 + DIFFUSE = 0x1201 + EMISSION = 0x1600 + SPECULAR = 0x1202 + + CONTEXT_FLAG_DEBUG_BIT = 0x00000002 + CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x00000001 + + CONTEXT_COMPATIBILITY_PROFILE_BIT = 0x00000002 + CONTEXT_CORE_PROFILE_BIT = 0x00000001 + + AUX0 = 0x0409 + AUX1 = 0x040A + AUX2 = 0x040B + AUX3 = 0x040C + BACK_LEFT = 0x0402 + BACK_RIGHT = 0x0403 + FRONT_LEFT = 0x0400 + FRONT_RIGHT = 0x0401 + LEFT = 0x0406 + RIGHT = 0x0407 + + ALPHA_TEST = 0x0BC0 + AUTO_NORMAL = 0x0D80 + BLEND = 0x0BE2 + COLOR_ARRAY = 0x8076 + COLOR_LOGIC_OP = 0x0BF2 + COLOR_MATERIAL = 0x0B57 + CULL_FACE = 0x0B44 + DEPTH_TEST = 0x0B71 + DITHER = 0x0BD0 + EDGE_FLAG_ARRAY = 0x8079 + FOG = 0x0B60 + INDEX_ARRAY = 0x8077 + INDEX_LOGIC_OP = 0x0BF1 + LIGHT0 = 0x4000 + LIGHT1 = 0x4001 + LIGHT2 = 0x4002 + LIGHT3 = 0x4003 + LIGHT4 = 0x4004 + LIGHT5 = 0x4005 + LIGHT6 = 0x4006 + LIGHT7 = 0x4007 + LIGHTING = 0x0B50 + LINE_SMOOTH = 0x0B20 + LINE_STIPPLE = 0x0B24 + MAP1_COLOR_4 = 0x0D90 + MAP1_INDEX = 0x0D91 + MAP1_NORMAL = 0x0D92 + MAP1_TEXTURE_COORD_1 = 0x0D93 + MAP1_TEXTURE_COORD_2 = 0x0D94 + MAP1_TEXTURE_COORD_3 = 0x0D95 + MAP1_TEXTURE_COORD_4 = 0x0D96 + MAP1_VERTEX_3 = 0x0D97 + MAP1_VERTEX_4 = 0x0D98 + MAP2_COLOR_4 = 0x0DB0 + MAP2_INDEX = 0x0DB1 + MAP2_NORMAL = 0x0DB2 + MAP2_TEXTURE_COORD_1 = 0x0DB3 + MAP2_TEXTURE_COORD_2 = 0x0DB4 + MAP2_TEXTURE_COORD_3 = 0x0DB5 + MAP2_TEXTURE_COORD_4 = 0x0DB6 + MAP2_VERTEX_3 = 0x0DB7 + MAP2_VERTEX_4 = 0x0DB8 + NORMALIZE = 0x0BA1 + NORMAL_ARRAY = 0x8075 + POINT_SMOOTH = 0x0B10 + POLYGON_OFFSET_FILL = 0x8037 + POLYGON_OFFSET_LINE = 0x2A02 + POLYGON_OFFSET_POINT = 0x2A01 + POLYGON_SMOOTH = 0x0B41 + POLYGON_STIPPLE = 0x0B42 + SCISSOR_TEST = 0x0C11 + STENCIL_TEST = 0x0B90 + TEXTURE_1D = 0x0DE0 + TEXTURE_2D = 0x0DE1 + TEXTURE_COORD_ARRAY = 0x8078 + TEXTURE_GEN_Q = 0x0C63 + TEXTURE_GEN_R = 0x0C62 + TEXTURE_GEN_S = 0x0C60 + TEXTURE_GEN_T = 0x0C61 + VERTEX_ARRAY = 0x8074 + + INVALID_ENUM = 0x0500 + INVALID_FRAMEBUFFER_OPERATION = 0x0506 + INVALID_OPERATION = 0x0502 + INVALID_VALUE = 0x0501 + NO_ERROR = 0 + OUT_OF_MEMORY = 0x0505 + STACK_OVERFLOW = 0x0503 + STACK_UNDERFLOW = 0x0504 + + N2D = 0x0600 + N3D = 0x0601 + N3D_COLOR = 0x0602 + N3D_COLOR_TEXTURE = 0x0603 + N4D_COLOR_TEXTURE = 0x0604 + + BITMAP_TOKEN = 0x0704 + COPY_PIXEL_TOKEN = 0x0706 + DRAW_PIXEL_TOKEN = 0x0705 + LINE_RESET_TOKEN = 0x0707 + LINE_TOKEN = 0x0702 + PASS_THROUGH_TOKEN = 0x0700 + POINT_TOKEN = 0x0701 + POLYGON_TOKEN = 0x0703 + + EXP = 0x0800 + EXP2 = 0x0801 + LINEAR = 0x2601 + + FOG_COLOR = 0x0B66 + FOG_DENSITY = 0x0B62 + FOG_END = 0x0B64 + FOG_INDEX = 0x0B61 + FOG_MODE = 0x0B65 + FOG_START = 0x0B63 + + CCW = 0x0901 + CW = 0x0900 + + COEFF = 0x0A00 + DOMAIN = 0x0A02 + ORDER = 0x0A01 + + PIXEL_MAP_A_TO_A = 0x0C79 + PIXEL_MAP_B_TO_B = 0x0C78 + PIXEL_MAP_G_TO_G = 0x0C77 + PIXEL_MAP_I_TO_A = 0x0C75 + PIXEL_MAP_I_TO_B = 0x0C74 + PIXEL_MAP_I_TO_G = 0x0C73 + PIXEL_MAP_I_TO_I = 0x0C70 + PIXEL_MAP_I_TO_R = 0x0C72 + PIXEL_MAP_R_TO_R = 0x0C76 + PIXEL_MAP_S_TO_S = 0x0C71 + + ACCUM_ALPHA_BITS = 0x0D5B + ACCUM_BLUE_BITS = 0x0D5A + ACCUM_CLEAR_VALUE = 0x0B80 + ACCUM_GREEN_BITS = 0x0D59 + ACCUM_RED_BITS = 0x0D58 + ALIASED_LINE_WIDTH_RANGE = 0x846E + ALIASED_POINT_SIZE_RANGE = 0x846D + ALPHA_BIAS = 0x0D1D + ALPHA_BITS = 0x0D55 + ALPHA_SCALE = 0x0D1C + ALPHA_TEST_FUNC = 0x0BC1 + ALPHA_TEST_REF = 0x0BC2 + ATTRIB_STACK_DEPTH = 0x0BB0 + AUX_BUFFERS = 0x0C00 + BLEND_DST = 0x0BE0 + BLEND_SRC = 0x0BE1 + BLUE_BIAS = 0x0D1B + BLUE_BITS = 0x0D54 + BLUE_SCALE = 0x0D1A + CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1 + COLOR_ARRAY_SIZE = 0x8081 + COLOR_ARRAY_STRIDE = 0x8083 + COLOR_ARRAY_TYPE = 0x8082 + COLOR_CLEAR_VALUE = 0x0C22 + COLOR_MATERIAL_FACE = 0x0B55 + COLOR_MATERIAL_PARAMETER = 0x0B56 + COLOR_WRITEMASK = 0x0C23 + CULL_FACE_MODE = 0x0B45 + CURRENT_COLOR = 0x0B00 + CURRENT_INDEX = 0x0B01 + CURRENT_NORMAL = 0x0B02 + CURRENT_RASTER_COLOR = 0x0B04 + CURRENT_RASTER_DISTANCE = 0x0B09 + CURRENT_RASTER_INDEX = 0x0B05 + CURRENT_RASTER_POSITION = 0x0B07 + CURRENT_RASTER_POSITION_VALID = 0x0B08 + CURRENT_RASTER_TEXTURE_COORDS = 0x0B06 + CURRENT_TEXTURE_COORDS = 0x0B03 + DEPTH_BIAS = 0x0D1F + DEPTH_BITS = 0x0D56 + DEPTH_CLEAR_VALUE = 0x0B73 + DEPTH_FUNC = 0x0B74 + DEPTH_RANGE = 0x0B70 + DEPTH_SCALE = 0x0D1E + DEPTH_WRITEMASK = 0x0B72 + DOUBLEBUFFER = 0x0C32 + DRAW_BUFFER = 0x0C01 + EDGE_FLAG = 0x0B43 + EDGE_FLAG_ARRAY_STRIDE = 0x808C + FEEDBACK_BUFFER_SIZE = 0x0DF1 + FEEDBACK_BUFFER_TYPE = 0x0DF2 + FOG_HINT = 0x0C54 + FRONT_FACE = 0x0B46 + GREEN_BIAS = 0x0D19 + GREEN_BITS = 0x0D53 + GREEN_SCALE = 0x0D18 + INDEX_ARRAY_STRIDE = 0x8086 + INDEX_ARRAY_TYPE = 0x8085 + INDEX_BITS = 0x0D51 + INDEX_CLEAR_VALUE = 0x0C20 + INDEX_MODE = 0x0C30 + INDEX_OFFSET = 0x0D13 + INDEX_SHIFT = 0x0D12 + INDEX_WRITEMASK = 0x0C21 + LIGHT_MODEL_AMBIENT = 0x0B53 + LIGHT_MODEL_COLOR_CONTROL = 0x81F8 + LIGHT_MODEL_LOCAL_VIEWER = 0x0B51 + LIGHT_MODEL_TWO_SIDE = 0x0B52 + LINE_SMOOTH_HINT = 0x0C52 + LINE_STIPPLE_PATTERN = 0x0B25 + LINE_STIPPLE_REPEAT = 0x0B26 + LINE_WIDTH = 0x0B21 + LINE_WIDTH_GRANULARITY = 0x0B23 + LINE_WIDTH_RANGE = 0x0B22 + LIST_BASE = 0x0B32 + LIST_INDEX = 0x0B33 + LIST_MODE = 0x0B30 + LOGIC_OP_MODE = 0x0BF0 + MAP1_GRID_DOMAIN = 0x0DD0 + MAP1_GRID_SEGMENTS = 0x0DD1 + MAP2_GRID_DOMAIN = 0x0DD2 + MAP2_GRID_SEGMENTS = 0x0DD3 + MAP_COLOR = 0x0D10 + MAP_STENCIL = 0x0D11 + MATRIX_MODE = 0x0BA0 + MAX_ATTRIB_STACK_DEPTH = 0x0D35 + MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B + MAX_CLIP_DISTANCES = 0x0D32 + MAX_CLIP_PLANES = 0x0D32 + MAX_EVAL_ORDER = 0x0D30 + MAX_LIGHTS = 0x0D31 + MAX_LIST_NESTING = 0x0B31 + MAX_MODELVIEW_STACK_DEPTH = 0x0D36 + MAX_NAME_STACK_DEPTH = 0x0D37 + MAX_PIXEL_MAP_TABLE = 0x0D34 + MAX_PROJECTION_STACK_DEPTH = 0x0D38 + MAX_TEXTURE_SIZE = 0x0D33 + MAX_TEXTURE_STACK_DEPTH = 0x0D39 + MAX_VIEWPORT_DIMS = 0x0D3A + MODELVIEW_MATRIX = 0x0BA6 + MODELVIEW_STACK_DEPTH = 0x0BA3 + NAME_STACK_DEPTH = 0x0D70 + NORMAL_ARRAY_STRIDE = 0x807F + NORMAL_ARRAY_TYPE = 0x807E + PACK_ALIGNMENT = 0x0D05 + PACK_LSB_FIRST = 0x0D01 + PACK_ROW_LENGTH = 0x0D02 + PACK_SKIP_PIXELS = 0x0D04 + PACK_SKIP_ROWS = 0x0D03 + PACK_SWAP_BYTES = 0x0D00 + PERSPECTIVE_CORRECTION_HINT = 0x0C50 + PIXEL_MAP_A_TO_A_SIZE = 0x0CB9 + PIXEL_MAP_B_TO_B_SIZE = 0x0CB8 + PIXEL_MAP_G_TO_G_SIZE = 0x0CB7 + PIXEL_MAP_I_TO_A_SIZE = 0x0CB5 + PIXEL_MAP_I_TO_B_SIZE = 0x0CB4 + PIXEL_MAP_I_TO_G_SIZE = 0x0CB3 + PIXEL_MAP_I_TO_I_SIZE = 0x0CB0 + PIXEL_MAP_I_TO_R_SIZE = 0x0CB2 + PIXEL_MAP_R_TO_R_SIZE = 0x0CB6 + PIXEL_MAP_S_TO_S_SIZE = 0x0CB1 + POINT_SIZE = 0x0B11 + POINT_SIZE_GRANULARITY = 0x0B13 + POINT_SIZE_RANGE = 0x0B12 + POINT_SMOOTH_HINT = 0x0C51 + POLYGON_MODE = 0x0B40 + POLYGON_OFFSET_FACTOR = 0x8038 + POLYGON_OFFSET_UNITS = 0x2A00 + POLYGON_SMOOTH_HINT = 0x0C53 + PROJECTION_MATRIX = 0x0BA7 + PROJECTION_STACK_DEPTH = 0x0BA4 + READ_BUFFER = 0x0C02 + RED_BIAS = 0x0D15 + RED_BITS = 0x0D52 + RED_SCALE = 0x0D14 + RENDER_MODE = 0x0C40 + RGBA_MODE = 0x0C31 + SCISSOR_BOX = 0x0C10 + SELECTION_BUFFER_SIZE = 0x0DF4 + SHADE_MODEL = 0x0B54 + SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23 + SMOOTH_LINE_WIDTH_RANGE = 0x0B22 + SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13 + SMOOTH_POINT_SIZE_RANGE = 0x0B12 + STENCIL_BITS = 0x0D57 + STENCIL_CLEAR_VALUE = 0x0B91 + STENCIL_FAIL = 0x0B94 + STENCIL_FUNC = 0x0B92 + STENCIL_PASS_DEPTH_FAIL = 0x0B95 + STENCIL_PASS_DEPTH_PASS = 0x0B96 + STENCIL_REF = 0x0B97 + STENCIL_VALUE_MASK = 0x0B93 + STENCIL_WRITEMASK = 0x0B98 + STEREO = 0x0C33 + SUBPIXEL_BITS = 0x0D50 + TEXTURE_BINDING_1D = 0x8068 + TEXTURE_BINDING_2D = 0x8069 + TEXTURE_BINDING_3D = 0x806A + TEXTURE_COORD_ARRAY_SIZE = 0x8088 + TEXTURE_COORD_ARRAY_STRIDE = 0x808A + TEXTURE_COORD_ARRAY_TYPE = 0x8089 + TEXTURE_MATRIX = 0x0BA8 + TEXTURE_STACK_DEPTH = 0x0BA5 + UNPACK_ALIGNMENT = 0x0CF5 + UNPACK_LSB_FIRST = 0x0CF1 + UNPACK_ROW_LENGTH = 0x0CF2 + UNPACK_SKIP_PIXELS = 0x0CF4 + UNPACK_SKIP_ROWS = 0x0CF3 + UNPACK_SWAP_BYTES = 0x0CF0 + VERTEX_ARRAY_SIZE = 0x807A + VERTEX_ARRAY_STRIDE = 0x807C + VERTEX_ARRAY_TYPE = 0x807B + VIEWPORT = 0x0BA2 + ZOOM_X = 0x0D16 + ZOOM_Y = 0x0D17 + + COLOR_ARRAY_POINTER = 0x8090 + EDGE_FLAG_ARRAY_POINTER = 0x8093 + FEEDBACK_BUFFER_POINTER = 0x0DF0 + INDEX_ARRAY_POINTER = 0x8091 + NORMAL_ARRAY_POINTER = 0x808F + SELECTION_BUFFER_POINTER = 0x0DF3 + TEXTURE_COORD_ARRAY_POINTER = 0x8092 + VERTEX_ARRAY_POINTER = 0x808E + + TEXTURE_ALPHA_SIZE = 0x805F + TEXTURE_BLUE_SIZE = 0x805E + TEXTURE_BORDER = 0x1005 + TEXTURE_BORDER_COLOR = 0x1004 + TEXTURE_COMPONENTS = 0x1003 + TEXTURE_GREEN_SIZE = 0x805D + TEXTURE_HEIGHT = 0x1001 + TEXTURE_INTENSITY_SIZE = 0x8061 + TEXTURE_INTERNAL_FORMAT = 0x1003 + TEXTURE_LUMINANCE_SIZE = 0x8060 + TEXTURE_MAG_FILTER = 0x2800 + TEXTURE_MIN_FILTER = 0x2801 + TEXTURE_PRIORITY = 0x8066 + TEXTURE_RED_SIZE = 0x805C + TEXTURE_RESIDENT = 0x8067 + TEXTURE_WIDTH = 0x1000 + TEXTURE_WRAP_S = 0x2802 + TEXTURE_WRAP_T = 0x2803 + + DONT_CARE = 0x1100 + FASTEST = 0x1101 + NICEST = 0x1102 + + FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B + GENERATE_MIPMAP_HINT = 0x8192 + PROGRAM_BINARY_RETRIEVABLE_HINT = 0x8257 + TEXTURE_COMPRESSION_HINT = 0x84EF + + C3F_V3F = 0x2A24 + C4F_N3F_V3F = 0x2A26 + C4UB_V2F = 0x2A22 + C4UB_V3F = 0x2A23 + N3F_V3F = 0x2A25 + T2F_C3F_V3F = 0x2A2A + T2F_C4F_N3F_V3F = 0x2A2C + T2F_C4UB_V3F = 0x2A29 + T2F_N3F_V3F = 0x2A2B + T2F_V3F = 0x2A27 + T4F_C4F_N3F_V4F = 0x2A2D + T4F_V4F = 0x2A28 + V2F = 0x2A20 + V3F = 0x2A21 + + MODULATE = 0x2100 + REPLACE = 0x1E01 + + SEPARATE_SPECULAR_COLOR = 0x81FA + SINGLE_COLOR = 0x81F9 + + CONSTANT_ATTENUATION = 0x1207 + LINEAR_ATTENUATION = 0x1208 + POSITION = 0x1203 + QUADRATIC_ATTENUATION = 0x1209 + SPOT_CUTOFF = 0x1206 + SPOT_DIRECTION = 0x1204 + SPOT_EXPONENT = 0x1205 + + COMPILE = 0x1300 + COMPILE_AND_EXECUTE = 0x1301 + + AND = 0x1501 + AND_INVERTED = 0x1504 + AND_REVERSE = 0x1502 + CLEAR = 0x1500 + COPY = 0x1503 + COPY_INVERTED = 0x150C + EQUIV = 0x1509 + INVERT = 0x150A + NAND = 0x150E + NOOP = 0x1505 + NOR = 0x1508 + OR = 0x1507 + OR_INVERTED = 0x150D + OR_REVERSE = 0x150B + SET = 0x150F + XOR = 0x1506 + + MAP_FLUSH_EXPLICIT_BIT = 0x0010 + MAP_INVALIDATE_BUFFER_BIT = 0x0008 + MAP_INVALIDATE_RANGE_BIT = 0x0004 + MAP_READ_BIT = 0x0001 + MAP_UNSYNCHRONIZED_BIT = 0x0020 + MAP_WRITE_BIT = 0x0002 + + COLOR_INDEXES = 0x1603 + SHININESS = 0x1601 + + MODELVIEW = 0x1700 + PROJECTION = 0x1701 + TEXTURE = 0x1702 + + ALL_BARRIER_BITS = 0xFFFFFFFF + ATOMIC_COUNTER_BARRIER_BIT = 0x00001000 + BUFFER_UPDATE_BARRIER_BIT = 0x00000200 + COMMAND_BARRIER_BIT = 0x00000040 + ELEMENT_ARRAY_BARRIER_BIT = 0x00000002 + FRAMEBUFFER_BARRIER_BIT = 0x00000400 + PIXEL_BUFFER_BARRIER_BIT = 0x00000080 + SHADER_IMAGE_ACCESS_BARRIER_BIT = 0x00000020 + SHADER_STORAGE_BARRIER_BIT = 0x00002000 + TEXTURE_FETCH_BARRIER_BIT = 0x00000008 + TEXTURE_UPDATE_BARRIER_BIT = 0x00000100 + TRANSFORM_FEEDBACK_BARRIER_BIT = 0x00000800 + UNIFORM_BARRIER_BIT = 0x00000004 + VERTEX_ATTRIB_ARRAY_BARRIER_BIT = 0x00000001 + + LINE = 0x1B01 + POINT = 0x1B00 + + FILL = 0x1B02 + + COLOR = 0x1800 + DEPTH = 0x1801 + STENCIL = 0x1802 + + ALPHA = 0x1906 + BLUE = 0x1905 + COLOR_INDEX = 0x1900 + DEPTH_COMPONENT = 0x1902 + GREEN = 0x1904 + LUMINANCE = 0x1909 + LUMINANCE_ALPHA = 0x190A + RED = 0x1903 + RGB = 0x1907 + RGBA = 0x1908 + STENCIL_INDEX = 0x1901 + + ALPHA12 = 0x803D + ALPHA16 = 0x803E + ALPHA4 = 0x803B + ALPHA8 = 0x803C + INTENSITY = 0x8049 + INTENSITY12 = 0x804C + INTENSITY16 = 0x804D + INTENSITY4 = 0x804A + INTENSITY8 = 0x804B + LUMINANCE12 = 0x8041 + LUMINANCE12_ALPHA12 = 0x8047 + LUMINANCE12_ALPHA4 = 0x8046 + LUMINANCE16 = 0x8042 + LUMINANCE16_ALPHA16 = 0x8048 + LUMINANCE4 = 0x803F + LUMINANCE4_ALPHA4 = 0x8043 + LUMINANCE6_ALPHA2 = 0x8044 + LUMINANCE8 = 0x8040 + LUMINANCE8_ALPHA8 = 0x8045 + R3_G3_B2 = 0x2A10 + RGB10 = 0x8052 + RGB10_A2 = 0x8059 + RGB12 = 0x8053 + RGB16 = 0x8054 + RGB4 = 0x804F + RGB5 = 0x8050 + RGB5_A1 = 0x8057 + RGB8 = 0x8051 + RGBA12 = 0x805A + RGBA16 = 0x805B + RGBA2 = 0x8055 + RGBA4 = 0x8056 + RGBA8 = 0x8058 + + PACK_IMAGE_HEIGHT = 0x806C + PACK_SKIP_IMAGES = 0x806B + UNPACK_IMAGE_HEIGHT = 0x806E + UNPACK_SKIP_IMAGES = 0x806D + + BITMAP = 0x1A00 + UNSIGNED_BYTE_3_3_2 = 0x8032 + UNSIGNED_INT_10_10_10_2 = 0x8036 + UNSIGNED_INT_8_8_8_8 = 0x8035 + UNSIGNED_SHORT_4_4_4_4 = 0x8033 + UNSIGNED_SHORT_5_5_5_1 = 0x8034 + + POINT_DISTANCE_ATTENUATION = 0x8129 + POINT_FADE_THRESHOLD_SIZE = 0x8128 + POINT_SIZE_MAX = 0x8127 + POINT_SIZE_MIN = 0x8126 + + LINES = 0x0001 + LINES_ADJACENCY = 0x000A + LINE_LOOP = 0x0002 + LINE_STRIP = 0x0003 + LINE_STRIP_ADJACENCY = 0x000B + PATCHES = 0x000E + POINTS = 0x0000 + POLYGON = 0x0009 + QUADS = 0x0007 + QUAD_STRIP = 0x0008 + TRIANGLES = 0x0004 + TRIANGLES_ADJACENCY = 0x000C + TRIANGLE_FAN = 0x0006 + TRIANGLE_STRIP = 0x0005 + TRIANGLE_STRIP_ADJACENCY = 0x000D + + FEEDBACK = 0x1C01 + RENDER = 0x1C00 + SELECT = 0x1C02 + + FLAT = 0x1D00 + SMOOTH = 0x1D01 + + DECR = 0x1E03 + INCR = 0x1E02 + KEEP = 0x1E00 + + EXTENSIONS = 0x1F03 + RENDERER = 0x1F01 + VENDOR = 0x1F00 + VERSION = 0x1F02 + + S = 0x2000 + T = 0x2001 + R = 0x2002 + Q = 0x2003 + + DECAL = 0x2101 + + TEXTURE_ENV_COLOR = 0x2201 + TEXTURE_ENV_MODE = 0x2200 + + TEXTURE_ENV = 0x2300 + + EYE_LINEAR = 0x2400 + OBJECT_LINEAR = 0x2401 + SPHERE_MAP = 0x2402 + + EYE_PLANE = 0x2502 + OBJECT_PLANE = 0x2501 + TEXTURE_GEN_MODE = 0x2500 + + NEAREST = 0x2600 + + LINEAR_MIPMAP_LINEAR = 0x2703 + LINEAR_MIPMAP_NEAREST = 0x2701 + NEAREST_MIPMAP_LINEAR = 0x2702 + NEAREST_MIPMAP_NEAREST = 0x2700 + + GENERATE_MIPMAP = 0x8191 + TEXTURE_WRAP_R = 0x8072 + + PROXY_TEXTURE_1D = 0x8063 + PROXY_TEXTURE_2D = 0x8064 + PROXY_TEXTURE_3D = 0x8070 + TEXTURE_3D = 0x806F + TEXTURE_BASE_LEVEL = 0x813C + TEXTURE_MAX_LEVEL = 0x813D + TEXTURE_MAX_LOD = 0x813B + TEXTURE_MIN_LOD = 0x813A + + CLAMP = 0x2900 + CLAMP_TO_BORDER = 0x812D + CLAMP_TO_EDGE = 0x812F + REPEAT = 0x2901 + + VERTEX_SHADER_BIT = 0x00000001 + FRAGMENT_SHADER_BIT = 0x00000002 + GEOMETRY_SHADER_BIT = 0x00000004 + TESS_CONTROL_SHADER_BIT = 0x00000008 + TESS_EVALUATION_SHADER_BIT = 0x00000010 + COMPUTE_SHADER_BIT = 0x00000020 + ALL_SHADER_BITS = 0xFFFFFFFF + + SYNC_FLUSH_COMMANDS_BIT = 0x00000001 + INVALID_INDEX = 0xFFFFFFFF + TIMEOUT_IGNORED = 0xFFFFFFFFFFFFFFFF + CONSTANT_COLOR = 0x8001 + ONE_MINUS_CONSTANT_COLOR = 0x8002 + CONSTANT_ALPHA = 0x8003 + ONE_MINUS_CONSTANT_ALPHA = 0x8004 + FUNC_ADD = 0x8006 + MIN = 0x8007 + MAX = 0x8008 + BLEND_EQUATION_RGB = 0x8009 + FUNC_SUBTRACT = 0x800A + FUNC_REVERSE_SUBTRACT = 0x800B + RESCALE_NORMAL = 0x803A + TEXTURE_DEPTH = 0x8071 + MAX_3D_TEXTURE_SIZE = 0x8073 + MULTISAMPLE = 0x809D + SAMPLE_ALPHA_TO_COVERAGE = 0x809E + SAMPLE_ALPHA_TO_ONE = 0x809F + SAMPLE_COVERAGE = 0x80A0 + SAMPLE_BUFFERS = 0x80A8 + SAMPLES = 0x80A9 + SAMPLE_COVERAGE_VALUE = 0x80AA + SAMPLE_COVERAGE_INVERT = 0x80AB + BLEND_DST_RGB = 0x80C8 + BLEND_SRC_RGB = 0x80C9 + BLEND_DST_ALPHA = 0x80CA + BLEND_SRC_ALPHA = 0x80CB + BGR = 0x80E0 + BGRA = 0x80E1 + MAX_ELEMENTS_VERTICES = 0x80E8 + MAX_ELEMENTS_INDICES = 0x80E9 + DEPTH_COMPONENT16 = 0x81A5 + DEPTH_COMPONENT24 = 0x81A6 + DEPTH_COMPONENT32 = 0x81A7 + FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210 + FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211 + FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212 + FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213 + FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214 + FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215 + FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216 + FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217 + FRAMEBUFFER_DEFAULT = 0x8218 + FRAMEBUFFER_UNDEFINED = 0x8219 + DEPTH_STENCIL_ATTACHMENT = 0x821A + MAJOR_VERSION = 0x821B + MINOR_VERSION = 0x821C + NUM_EXTENSIONS = 0x821D + CONTEXT_FLAGS = 0x821E + COMPRESSED_RED = 0x8225 + COMPRESSED_RG = 0x8226 + RG = 0x8227 + RG_INTEGER = 0x8228 + R8 = 0x8229 + R16 = 0x822A + RG8 = 0x822B + RG16 = 0x822C + R16F = 0x822D + R32F = 0x822E + RG16F = 0x822F + RG32F = 0x8230 + R8I = 0x8231 + R8UI = 0x8232 + R16I = 0x8233 + R16UI = 0x8234 + R32I = 0x8235 + R32UI = 0x8236 + RG8I = 0x8237 + RG8UI = 0x8238 + RG16I = 0x8239 + RG16UI = 0x823A + RG32I = 0x823B + RG32UI = 0x823C + DEBUG_OUTPUT_SYNCHRONOUS = 0x8242 + DEBUG_NEXT_LOGGED_MESSAGE_LENGTH = 0x8243 + DEBUG_CALLBACK_FUNCTION = 0x8244 + DEBUG_CALLBACK_USER_PARAM = 0x8245 + DEBUG_SOURCE_API = 0x8246 + DEBUG_SOURCE_WINDOW_SYSTEM = 0x8247 + DEBUG_SOURCE_SHADER_COMPILER = 0x8248 + DEBUG_SOURCE_THIRD_PARTY = 0x8249 + DEBUG_SOURCE_APPLICATION = 0x824A + DEBUG_SOURCE_OTHER = 0x824B + DEBUG_TYPE_ERROR = 0x824C + DEBUG_TYPE_DEPRECATED_BEHAVIOR = 0x824D + DEBUG_TYPE_UNDEFINED_BEHAVIOR = 0x824E + DEBUG_TYPE_PORTABILITY = 0x824F + DEBUG_TYPE_PERFORMANCE = 0x8250 + DEBUG_TYPE_OTHER = 0x8251 + PROGRAM_SEPARABLE = 0x8258 + ACTIVE_PROGRAM = 0x8259 + PROGRAM_PIPELINE_BINDING = 0x825A + MAX_VIEWPORTS = 0x825B + VIEWPORT_SUBPIXEL_BITS = 0x825C + VIEWPORT_BOUNDS_RANGE = 0x825D + LAYER_PROVOKING_VERTEX = 0x825E + VIEWPORT_INDEX_PROVOKING_VERTEX = 0x825F + UNDEFINED_VERTEX = 0x8260 + MAX_COMPUTE_SHARED_MEMORY_SIZE = 0x8262 + MAX_COMPUTE_UNIFORM_COMPONENTS = 0x8263 + MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS = 0x8264 + MAX_COMPUTE_ATOMIC_COUNTERS = 0x8265 + MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS = 0x8266 + COMPUTE_WORK_GROUP_SIZE = 0x8267 + DEBUG_TYPE_MARKER = 0x8268 + DEBUG_TYPE_PUSH_GROUP = 0x8269 + DEBUG_TYPE_POP_GROUP = 0x826A + DEBUG_SEVERITY_NOTIFICATION = 0x826B + MAX_DEBUG_GROUP_STACK_DEPTH = 0x826C + DEBUG_GROUP_STACK_DEPTH = 0x826D + MAX_UNIFORM_LOCATIONS = 0x826E + INTERNALFORMAT_SUPPORTED = 0x826F + INTERNALFORMAT_PREFERRED = 0x8270 + INTERNALFORMAT_RED_SIZE = 0x8271 + INTERNALFORMAT_GREEN_SIZE = 0x8272 + INTERNALFORMAT_BLUE_SIZE = 0x8273 + INTERNALFORMAT_ALPHA_SIZE = 0x8274 + INTERNALFORMAT_DEPTH_SIZE = 0x8275 + INTERNALFORMAT_STENCIL_SIZE = 0x8276 + INTERNALFORMAT_SHARED_SIZE = 0x8277 + INTERNALFORMAT_RED_TYPE = 0x8278 + INTERNALFORMAT_GREEN_TYPE = 0x8279 + INTERNALFORMAT_BLUE_TYPE = 0x827A + INTERNALFORMAT_ALPHA_TYPE = 0x827B + INTERNALFORMAT_DEPTH_TYPE = 0x827C + INTERNALFORMAT_STENCIL_TYPE = 0x827D + MAX_WIDTH = 0x827E + MAX_HEIGHT = 0x827F + MAX_DEPTH = 0x8280 + MAX_LAYERS = 0x8281 + MAX_COMBINED_DIMENSIONS = 0x8282 + COLOR_COMPONENTS = 0x8283 + DEPTH_COMPONENTS = 0x8284 + STENCIL_COMPONENTS = 0x8285 + COLOR_RENDERABLE = 0x8286 + DEPTH_RENDERABLE = 0x8287 + STENCIL_RENDERABLE = 0x8288 + FRAMEBUFFER_RENDERABLE = 0x8289 + FRAMEBUFFER_RENDERABLE_LAYERED = 0x828A + FRAMEBUFFER_BLEND = 0x828B + READ_PIXELS = 0x828C + READ_PIXELS_FORMAT = 0x828D + READ_PIXELS_TYPE = 0x828E + TEXTURE_IMAGE_FORMAT = 0x828F + TEXTURE_IMAGE_TYPE = 0x8290 + GET_TEXTURE_IMAGE_FORMAT = 0x8291 + GET_TEXTURE_IMAGE_TYPE = 0x8292 + MIPMAP = 0x8293 + MANUAL_GENERATE_MIPMAP = 0x8294 + AUTO_GENERATE_MIPMAP = 0x8295 + COLOR_ENCODING = 0x8296 + SRGB_READ = 0x8297 + SRGB_WRITE = 0x8298 + FILTER = 0x829A + VERTEX_TEXTURE = 0x829B + TESS_CONTROL_TEXTURE = 0x829C + TESS_EVALUATION_TEXTURE = 0x829D + GEOMETRY_TEXTURE = 0x829E + FRAGMENT_TEXTURE = 0x829F + COMPUTE_TEXTURE = 0x82A0 + TEXTURE_SHADOW = 0x82A1 + TEXTURE_GATHER = 0x82A2 + TEXTURE_GATHER_SHADOW = 0x82A3 + SHADER_IMAGE_LOAD = 0x82A4 + SHADER_IMAGE_STORE = 0x82A5 + SHADER_IMAGE_ATOMIC = 0x82A6 + IMAGE_TEXEL_SIZE = 0x82A7 + IMAGE_COMPATIBILITY_CLASS = 0x82A8 + IMAGE_PIXEL_FORMAT = 0x82A9 + IMAGE_PIXEL_TYPE = 0x82AA + SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST = 0x82AC + SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST = 0x82AD + SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE = 0x82AE + SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE = 0x82AF + TEXTURE_COMPRESSED_BLOCK_WIDTH = 0x82B1 + TEXTURE_COMPRESSED_BLOCK_HEIGHT = 0x82B2 + TEXTURE_COMPRESSED_BLOCK_SIZE = 0x82B3 + CLEAR_BUFFER = 0x82B4 + TEXTURE_VIEW = 0x82B5 + VIEW_COMPATIBILITY_CLASS = 0x82B6 + FULL_SUPPORT = 0x82B7 + CAVEAT_SUPPORT = 0x82B8 + IMAGE_CLASS_4_X_32 = 0x82B9 + IMAGE_CLASS_2_X_32 = 0x82BA + IMAGE_CLASS_1_X_32 = 0x82BB + IMAGE_CLASS_4_X_16 = 0x82BC + IMAGE_CLASS_2_X_16 = 0x82BD + IMAGE_CLASS_1_X_16 = 0x82BE + IMAGE_CLASS_4_X_8 = 0x82BF + IMAGE_CLASS_2_X_8 = 0x82C0 + IMAGE_CLASS_1_X_8 = 0x82C1 + IMAGE_CLASS_11_11_10 = 0x82C2 + IMAGE_CLASS_10_10_10_2 = 0x82C3 + VIEW_CLASS_128_BITS = 0x82C4 + VIEW_CLASS_96_BITS = 0x82C5 + VIEW_CLASS_64_BITS = 0x82C6 + VIEW_CLASS_48_BITS = 0x82C7 + VIEW_CLASS_32_BITS = 0x82C8 + VIEW_CLASS_24_BITS = 0x82C9 + VIEW_CLASS_16_BITS = 0x82CA + VIEW_CLASS_8_BITS = 0x82CB + VIEW_CLASS_S3TC_DXT1_RGB = 0x82CC + VIEW_CLASS_S3TC_DXT1_RGBA = 0x82CD + VIEW_CLASS_S3TC_DXT3_RGBA = 0x82CE + VIEW_CLASS_S3TC_DXT5_RGBA = 0x82CF + VIEW_CLASS_RGTC1_RED = 0x82D0 + VIEW_CLASS_RGTC2_RG = 0x82D1 + VIEW_CLASS_BPTC_UNORM = 0x82D2 + VIEW_CLASS_BPTC_FLOAT = 0x82D3 + VERTEX_ATTRIB_BINDING = 0x82D4 + VERTEX_ATTRIB_RELATIVE_OFFSET = 0x82D5 + VERTEX_BINDING_DIVISOR = 0x82D6 + VERTEX_BINDING_OFFSET = 0x82D7 + VERTEX_BINDING_STRIDE = 0x82D8 + MAX_VERTEX_ATTRIB_RELATIVE_OFFSET = 0x82D9 + MAX_VERTEX_ATTRIB_BINDINGS = 0x82DA + TEXTURE_VIEW_MIN_LEVEL = 0x82DB + TEXTURE_VIEW_NUM_LEVELS = 0x82DC + TEXTURE_VIEW_MIN_LAYER = 0x82DD + TEXTURE_VIEW_NUM_LAYERS = 0x82DE + TEXTURE_IMMUTABLE_LEVELS = 0x82DF + BUFFER = 0x82E0 + SHADER = 0x82E1 + PROGRAM = 0x82E2 + QUERY = 0x82E3 + PROGRAM_PIPELINE = 0x82E4 + SAMPLER = 0x82E6 + MAX_LABEL_LENGTH = 0x82E8 + NUM_SHADING_LANGUAGE_VERSIONS = 0x82E9 + UNSIGNED_BYTE_2_3_3_REV = 0x8362 + UNSIGNED_SHORT_5_6_5 = 0x8363 + UNSIGNED_SHORT_5_6_5_REV = 0x8364 + UNSIGNED_SHORT_4_4_4_4_REV = 0x8365 + UNSIGNED_SHORT_1_5_5_5_REV = 0x8366 + UNSIGNED_INT_8_8_8_8_REV = 0x8367 + UNSIGNED_INT_2_10_10_10_REV = 0x8368 + MIRRORED_REPEAT = 0x8370 + FOG_COORDINATE_SOURCE = 0x8450 + FOG_COORD_SRC = 0x8450 + FOG_COORDINATE = 0x8451 + FOG_COORD = 0x8451 + FRAGMENT_DEPTH = 0x8452 + CURRENT_FOG_COORDINATE = 0x8453 + CURRENT_FOG_COORD = 0x8453 + FOG_COORDINATE_ARRAY_TYPE = 0x8454 + FOG_COORD_ARRAY_TYPE = 0x8454 + FOG_COORDINATE_ARRAY_STRIDE = 0x8455 + FOG_COORD_ARRAY_STRIDE = 0x8455 + FOG_COORDINATE_ARRAY_POINTER = 0x8456 + FOG_COORD_ARRAY_POINTER = 0x8456 + FOG_COORDINATE_ARRAY = 0x8457 + FOG_COORD_ARRAY = 0x8457 + COLOR_SUM = 0x8458 + CURRENT_SECONDARY_COLOR = 0x8459 + SECONDARY_COLOR_ARRAY_SIZE = 0x845A + SECONDARY_COLOR_ARRAY_TYPE = 0x845B + SECONDARY_COLOR_ARRAY_STRIDE = 0x845C + SECONDARY_COLOR_ARRAY_POINTER = 0x845D + SECONDARY_COLOR_ARRAY = 0x845E + CURRENT_RASTER_SECONDARY_COLOR = 0x845F + TEXTURE0 = 0x84C0 + TEXTURE1 = 0x84C1 + TEXTURE2 = 0x84C2 + TEXTURE3 = 0x84C3 + TEXTURE4 = 0x84C4 + TEXTURE5 = 0x84C5 + TEXTURE6 = 0x84C6 + TEXTURE7 = 0x84C7 + TEXTURE8 = 0x84C8 + TEXTURE9 = 0x84C9 + TEXTURE10 = 0x84CA + TEXTURE11 = 0x84CB + TEXTURE12 = 0x84CC + TEXTURE13 = 0x84CD + TEXTURE14 = 0x84CE + TEXTURE15 = 0x84CF + TEXTURE16 = 0x84D0 + TEXTURE17 = 0x84D1 + TEXTURE18 = 0x84D2 + TEXTURE19 = 0x84D3 + TEXTURE20 = 0x84D4 + TEXTURE21 = 0x84D5 + TEXTURE22 = 0x84D6 + TEXTURE23 = 0x84D7 + TEXTURE24 = 0x84D8 + TEXTURE25 = 0x84D9 + TEXTURE26 = 0x84DA + TEXTURE27 = 0x84DB + TEXTURE28 = 0x84DC + TEXTURE29 = 0x84DD + TEXTURE30 = 0x84DE + TEXTURE31 = 0x84DF + ACTIVE_TEXTURE = 0x84E0 + CLIENT_ACTIVE_TEXTURE = 0x84E1 + MAX_TEXTURE_UNITS = 0x84E2 + TRANSPOSE_MODELVIEW_MATRIX = 0x84E3 + TRANSPOSE_PROJECTION_MATRIX = 0x84E4 + TRANSPOSE_TEXTURE_MATRIX = 0x84E5 + TRANSPOSE_COLOR_MATRIX = 0x84E6 + SUBTRACT = 0x84E7 + MAX_RENDERBUFFER_SIZE = 0x84E8 + COMPRESSED_ALPHA = 0x84E9 + COMPRESSED_LUMINANCE = 0x84EA + COMPRESSED_LUMINANCE_ALPHA = 0x84EB + COMPRESSED_INTENSITY = 0x84EC + COMPRESSED_RGB = 0x84ED + COMPRESSED_RGBA = 0x84EE + UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER = 0x84F0 + UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x84F1 + TEXTURE_RECTANGLE = 0x84F5 + TEXTURE_BINDING_RECTANGLE = 0x84F6 + PROXY_TEXTURE_RECTANGLE = 0x84F7 + MAX_RECTANGLE_TEXTURE_SIZE = 0x84F8 + DEPTH_STENCIL = 0x84F9 + UNSIGNED_INT_24_8 = 0x84FA + MAX_TEXTURE_LOD_BIAS = 0x84FD + TEXTURE_FILTER_CONTROL = 0x8500 + TEXTURE_LOD_BIAS = 0x8501 + INCR_WRAP = 0x8507 + DECR_WRAP = 0x8508 + NORMAL_MAP = 0x8511 + REFLECTION_MAP = 0x8512 + TEXTURE_CUBE_MAP = 0x8513 + TEXTURE_BINDING_CUBE_MAP = 0x8514 + TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515 + TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516 + TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517 + TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518 + TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519 + TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A + PROXY_TEXTURE_CUBE_MAP = 0x851B + MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C + COMBINE = 0x8570 + COMBINE_RGB = 0x8571 + COMBINE_ALPHA = 0x8572 + RGB_SCALE = 0x8573 + ADD_SIGNED = 0x8574 + INTERPOLATE = 0x8575 + CONSTANT = 0x8576 + PRIMARY_COLOR = 0x8577 + PREVIOUS = 0x8578 + SOURCE0_RGB = 0x8580 + SRC0_RGB = 0x8580 + SOURCE1_RGB = 0x8581 + SRC1_RGB = 0x8581 + SOURCE2_RGB = 0x8582 + SRC2_RGB = 0x8582 + SOURCE0_ALPHA = 0x8588 + SRC0_ALPHA = 0x8588 + SOURCE1_ALPHA = 0x8589 + SRC1_ALPHA = 0x8589 + SOURCE2_ALPHA = 0x858A + SRC2_ALPHA = 0x858A + OPERAND0_RGB = 0x8590 + OPERAND1_RGB = 0x8591 + OPERAND2_RGB = 0x8592 + OPERAND0_ALPHA = 0x8598 + OPERAND1_ALPHA = 0x8599 + OPERAND2_ALPHA = 0x859A + VERTEX_ARRAY_BINDING = 0x85B5 + VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622 + VERTEX_ATTRIB_ARRAY_SIZE = 0x8623 + VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624 + VERTEX_ATTRIB_ARRAY_TYPE = 0x8625 + CURRENT_VERTEX_ATTRIB = 0x8626 + VERTEX_PROGRAM_POINT_SIZE = 0x8642 + PROGRAM_POINT_SIZE = 0x8642 + VERTEX_PROGRAM_TWO_SIDE = 0x8643 + VERTEX_ATTRIB_ARRAY_POINTER = 0x8645 + DEPTH_CLAMP = 0x864F + TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0 + TEXTURE_COMPRESSED = 0x86A1 + NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2 + COMPRESSED_TEXTURE_FORMATS = 0x86A3 + DOT3_RGB = 0x86AE + DOT3_RGBA = 0x86AF + PROGRAM_BINARY_LENGTH = 0x8741 + VERTEX_ATTRIB_ARRAY_LONG = 0x874E + BUFFER_SIZE = 0x8764 + BUFFER_USAGE = 0x8765 + NUM_PROGRAM_BINARY_FORMATS = 0x87FE + PROGRAM_BINARY_FORMATS = 0x87FF + STENCIL_BACK_FUNC = 0x8800 + STENCIL_BACK_FAIL = 0x8801 + STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802 + STENCIL_BACK_PASS_DEPTH_PASS = 0x8803 + RGBA32F = 0x8814 + RGB32F = 0x8815 + RGBA16F = 0x881A + RGB16F = 0x881B + MAX_DRAW_BUFFERS = 0x8824 + DRAW_BUFFER0 = 0x8825 + DRAW_BUFFER1 = 0x8826 + DRAW_BUFFER2 = 0x8827 + DRAW_BUFFER3 = 0x8828 + DRAW_BUFFER4 = 0x8829 + DRAW_BUFFER5 = 0x882A + DRAW_BUFFER6 = 0x882B + DRAW_BUFFER7 = 0x882C + DRAW_BUFFER8 = 0x882D + DRAW_BUFFER9 = 0x882E + DRAW_BUFFER10 = 0x882F + DRAW_BUFFER11 = 0x8830 + DRAW_BUFFER12 = 0x8831 + DRAW_BUFFER13 = 0x8832 + DRAW_BUFFER14 = 0x8833 + DRAW_BUFFER15 = 0x8834 + BLEND_EQUATION_ALPHA = 0x883D + TEXTURE_DEPTH_SIZE = 0x884A + DEPTH_TEXTURE_MODE = 0x884B + TEXTURE_COMPARE_MODE = 0x884C + TEXTURE_COMPARE_FUNC = 0x884D + COMPARE_R_TO_TEXTURE = 0x884E + COMPARE_REF_TO_TEXTURE = 0x884E + TEXTURE_CUBE_MAP_SEAMLESS = 0x884F + POINT_SPRITE = 0x8861 + COORD_REPLACE = 0x8862 + QUERY_COUNTER_BITS = 0x8864 + CURRENT_QUERY = 0x8865 + QUERY_RESULT = 0x8866 + QUERY_RESULT_AVAILABLE = 0x8867 + MAX_VERTEX_ATTRIBS = 0x8869 + VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A + MAX_TESS_CONTROL_INPUT_COMPONENTS = 0x886C + MAX_TESS_EVALUATION_INPUT_COMPONENTS = 0x886D + MAX_TEXTURE_COORDS = 0x8871 + MAX_TEXTURE_IMAGE_UNITS = 0x8872 + GEOMETRY_SHADER_INVOCATIONS = 0x887F + ARRAY_BUFFER = 0x8892 + ELEMENT_ARRAY_BUFFER = 0x8893 + ARRAY_BUFFER_BINDING = 0x8894 + ELEMENT_ARRAY_BUFFER_BINDING = 0x8895 + VERTEX_ARRAY_BUFFER_BINDING = 0x8896 + NORMAL_ARRAY_BUFFER_BINDING = 0x8897 + COLOR_ARRAY_BUFFER_BINDING = 0x8898 + INDEX_ARRAY_BUFFER_BINDING = 0x8899 + TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A + EDGE_FLAG_ARRAY_BUFFER_BINDING = 0x889B + SECONDARY_COLOR_ARRAY_BUFFER_BINDING = 0x889C + FOG_COORDINATE_ARRAY_BUFFER_BINDING = 0x889D + FOG_COORD_ARRAY_BUFFER_BINDING = 0x889D + WEIGHT_ARRAY_BUFFER_BINDING = 0x889E + VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F + READ_ONLY = 0x88B8 + WRITE_ONLY = 0x88B9 + READ_WRITE = 0x88BA + BUFFER_ACCESS = 0x88BB + BUFFER_MAPPED = 0x88BC + BUFFER_MAP_POINTER = 0x88BD + TIME_ELAPSED = 0x88BF + STREAM_DRAW = 0x88E0 + STREAM_READ = 0x88E1 + STREAM_COPY = 0x88E2 + STATIC_DRAW = 0x88E4 + STATIC_READ = 0x88E5 + STATIC_COPY = 0x88E6 + DYNAMIC_DRAW = 0x88E8 + DYNAMIC_READ = 0x88E9 + DYNAMIC_COPY = 0x88EA + PIXEL_PACK_BUFFER = 0x88EB + PIXEL_UNPACK_BUFFER = 0x88EC + PIXEL_PACK_BUFFER_BINDING = 0x88ED + PIXEL_UNPACK_BUFFER_BINDING = 0x88EF + DEPTH24_STENCIL8 = 0x88F0 + TEXTURE_STENCIL_SIZE = 0x88F1 + SRC1_COLOR = 0x88F9 + ONE_MINUS_SRC1_COLOR = 0x88FA + ONE_MINUS_SRC1_ALPHA = 0x88FB + MAX_DUAL_SOURCE_DRAW_BUFFERS = 0x88FC + VERTEX_ATTRIB_ARRAY_INTEGER = 0x88FD + VERTEX_ATTRIB_ARRAY_DIVISOR = 0x88FE + MAX_ARRAY_TEXTURE_LAYERS = 0x88FF + MIN_PROGRAM_TEXEL_OFFSET = 0x8904 + MAX_PROGRAM_TEXEL_OFFSET = 0x8905 + SAMPLES_PASSED = 0x8914 + GEOMETRY_VERTICES_OUT = 0x8916 + GEOMETRY_INPUT_TYPE = 0x8917 + GEOMETRY_OUTPUT_TYPE = 0x8918 + SAMPLER_BINDING = 0x8919 + CLAMP_VERTEX_COLOR = 0x891A + CLAMP_FRAGMENT_COLOR = 0x891B + CLAMP_READ_COLOR = 0x891C + FIXED_ONLY = 0x891D + UNIFORM_BUFFER = 0x8A11 + UNIFORM_BUFFER_BINDING = 0x8A28 + UNIFORM_BUFFER_START = 0x8A29 + UNIFORM_BUFFER_SIZE = 0x8A2A + MAX_VERTEX_UNIFORM_BLOCKS = 0x8A2B + MAX_GEOMETRY_UNIFORM_BLOCKS = 0x8A2C + MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8A2D + MAX_COMBINED_UNIFORM_BLOCKS = 0x8A2E + MAX_UNIFORM_BUFFER_BINDINGS = 0x8A2F + MAX_UNIFORM_BLOCK_SIZE = 0x8A30 + MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31 + MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 0x8A32 + MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33 + UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8A34 + ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35 + ACTIVE_UNIFORM_BLOCKS = 0x8A36 + UNIFORM_TYPE = 0x8A37 + UNIFORM_SIZE = 0x8A38 + UNIFORM_NAME_LENGTH = 0x8A39 + UNIFORM_BLOCK_INDEX = 0x8A3A + UNIFORM_OFFSET = 0x8A3B + UNIFORM_ARRAY_STRIDE = 0x8A3C + UNIFORM_MATRIX_STRIDE = 0x8A3D + UNIFORM_IS_ROW_MAJOR = 0x8A3E + UNIFORM_BLOCK_BINDING = 0x8A3F + UNIFORM_BLOCK_DATA_SIZE = 0x8A40 + UNIFORM_BLOCK_NAME_LENGTH = 0x8A41 + UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8A42 + UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43 + UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44 + UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 0x8A45 + UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46 + FRAGMENT_SHADER = 0x8B30 + VERTEX_SHADER = 0x8B31 + MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49 + MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A + MAX_VARYING_FLOATS = 0x8B4B + MAX_VARYING_COMPONENTS = 0x8B4B + MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C + MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D + SHADER_TYPE = 0x8B4F + FLOAT_VEC2 = 0x8B50 + FLOAT_VEC3 = 0x8B51 + FLOAT_VEC4 = 0x8B52 + INT_VEC2 = 0x8B53 + INT_VEC3 = 0x8B54 + INT_VEC4 = 0x8B55 + BOOL = 0x8B56 + BOOL_VEC2 = 0x8B57 + BOOL_VEC3 = 0x8B58 + BOOL_VEC4 = 0x8B59 + FLOAT_MAT2 = 0x8B5A + FLOAT_MAT3 = 0x8B5B + FLOAT_MAT4 = 0x8B5C + SAMPLER_1D = 0x8B5D + SAMPLER_2D = 0x8B5E + SAMPLER_3D = 0x8B5F + SAMPLER_CUBE = 0x8B60 + SAMPLER_1D_SHADOW = 0x8B61 + SAMPLER_2D_SHADOW = 0x8B62 + SAMPLER_2D_RECT = 0x8B63 + SAMPLER_2D_RECT_SHADOW = 0x8B64 + FLOAT_MAT2x3 = 0x8B65 + FLOAT_MAT2x4 = 0x8B66 + FLOAT_MAT3x2 = 0x8B67 + FLOAT_MAT3x4 = 0x8B68 + FLOAT_MAT4x2 = 0x8B69 + FLOAT_MAT4x3 = 0x8B6A + DELETE_STATUS = 0x8B80 + COMPILE_STATUS = 0x8B81 + LINK_STATUS = 0x8B82 + VALIDATE_STATUS = 0x8B83 + INFO_LOG_LENGTH = 0x8B84 + ATTACHED_SHADERS = 0x8B85 + ACTIVE_UNIFORMS = 0x8B86 + ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87 + SHADER_SOURCE_LENGTH = 0x8B88 + ACTIVE_ATTRIBUTES = 0x8B89 + ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A + SHADING_LANGUAGE_VERSION = 0x8B8C + CURRENT_PROGRAM = 0x8B8D + IMPLEMENTATION_COLOR_READ_TYPE = 0x8B9A + IMPLEMENTATION_COLOR_READ_FORMAT = 0x8B9B + TEXTURE_RED_TYPE = 0x8C10 + TEXTURE_GREEN_TYPE = 0x8C11 + TEXTURE_BLUE_TYPE = 0x8C12 + TEXTURE_ALPHA_TYPE = 0x8C13 + TEXTURE_DEPTH_TYPE = 0x8C16 + UNSIGNED_NORMALIZED = 0x8C17 + TEXTURE_1D_ARRAY = 0x8C18 + PROXY_TEXTURE_1D_ARRAY = 0x8C19 + TEXTURE_2D_ARRAY = 0x8C1A + PROXY_TEXTURE_2D_ARRAY = 0x8C1B + TEXTURE_BINDING_1D_ARRAY = 0x8C1C + TEXTURE_BINDING_2D_ARRAY = 0x8C1D + MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = 0x8C29 + TEXTURE_BUFFER = 0x8C2A + MAX_TEXTURE_BUFFER_SIZE = 0x8C2B + TEXTURE_BINDING_BUFFER = 0x8C2C + TEXTURE_BUFFER_DATA_STORE_BINDING = 0x8C2D + ANY_SAMPLES_PASSED = 0x8C2F + SAMPLE_SHADING = 0x8C36 + MIN_SAMPLE_SHADING_VALUE = 0x8C37 + R11F_G11F_B10F = 0x8C3A + UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B + RGB9_E5 = 0x8C3D + UNSIGNED_INT_5_9_9_9_REV = 0x8C3E + TEXTURE_SHARED_SIZE = 0x8C3F + SRGB = 0x8C40 + SRGB8 = 0x8C41 + SRGB_ALPHA = 0x8C42 + SRGB8_ALPHA8 = 0x8C43 + SLUMINANCE_ALPHA = 0x8C44 + SLUMINANCE8_ALPHA8 = 0x8C45 + SLUMINANCE = 0x8C46 + SLUMINANCE8 = 0x8C47 + COMPRESSED_SRGB = 0x8C48 + COMPRESSED_SRGB_ALPHA = 0x8C49 + COMPRESSED_SLUMINANCE = 0x8C4A + COMPRESSED_SLUMINANCE_ALPHA = 0x8C4B + TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76 + TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F + MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80 + TRANSFORM_FEEDBACK_VARYINGS = 0x8C83 + TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84 + TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85 + PRIMITIVES_GENERATED = 0x8C87 + TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88 + RASTERIZER_DISCARD = 0x8C89 + MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A + MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B + INTERLEAVED_ATTRIBS = 0x8C8C + SEPARATE_ATTRIBS = 0x8C8D + TRANSFORM_FEEDBACK_BUFFER = 0x8C8E + TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F + POINT_SPRITE_COORD_ORIGIN = 0x8CA0 + LOWER_LEFT = 0x8CA1 + UPPER_LEFT = 0x8CA2 + STENCIL_BACK_REF = 0x8CA3 + STENCIL_BACK_VALUE_MASK = 0x8CA4 + STENCIL_BACK_WRITEMASK = 0x8CA5 + DRAW_FRAMEBUFFER_BINDING = 0x8CA6 + FRAMEBUFFER_BINDING = 0x8CA6 + RENDERBUFFER_BINDING = 0x8CA7 + READ_FRAMEBUFFER = 0x8CA8 + DRAW_FRAMEBUFFER = 0x8CA9 + READ_FRAMEBUFFER_BINDING = 0x8CAA + RENDERBUFFER_SAMPLES = 0x8CAB + DEPTH_COMPONENT32F = 0x8CAC + DEPTH32F_STENCIL8 = 0x8CAD + FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0 + FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1 + FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2 + FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3 + FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4 + FRAMEBUFFER_COMPLETE = 0x8CD5 + FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6 + FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7 + FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB + FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC + FRAMEBUFFER_UNSUPPORTED = 0x8CDD + MAX_COLOR_ATTACHMENTS = 0x8CDF + COLOR_ATTACHMENT0 = 0x8CE0 + COLOR_ATTACHMENT1 = 0x8CE1 + COLOR_ATTACHMENT2 = 0x8CE2 + COLOR_ATTACHMENT3 = 0x8CE3 + COLOR_ATTACHMENT4 = 0x8CE4 + COLOR_ATTACHMENT5 = 0x8CE5 + COLOR_ATTACHMENT6 = 0x8CE6 + COLOR_ATTACHMENT7 = 0x8CE7 + COLOR_ATTACHMENT8 = 0x8CE8 + COLOR_ATTACHMENT9 = 0x8CE9 + COLOR_ATTACHMENT10 = 0x8CEA + COLOR_ATTACHMENT11 = 0x8CEB + COLOR_ATTACHMENT12 = 0x8CEC + COLOR_ATTACHMENT13 = 0x8CED + COLOR_ATTACHMENT14 = 0x8CEE + COLOR_ATTACHMENT15 = 0x8CEF + DEPTH_ATTACHMENT = 0x8D00 + STENCIL_ATTACHMENT = 0x8D20 + FRAMEBUFFER = 0x8D40 + RENDERBUFFER = 0x8D41 + RENDERBUFFER_WIDTH = 0x8D42 + RENDERBUFFER_HEIGHT = 0x8D43 + RENDERBUFFER_INTERNAL_FORMAT = 0x8D44 + STENCIL_INDEX1 = 0x8D46 + STENCIL_INDEX4 = 0x8D47 + STENCIL_INDEX8 = 0x8D48 + STENCIL_INDEX16 = 0x8D49 + RENDERBUFFER_RED_SIZE = 0x8D50 + RENDERBUFFER_GREEN_SIZE = 0x8D51 + RENDERBUFFER_BLUE_SIZE = 0x8D52 + RENDERBUFFER_ALPHA_SIZE = 0x8D53 + RENDERBUFFER_DEPTH_SIZE = 0x8D54 + RENDERBUFFER_STENCIL_SIZE = 0x8D55 + FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56 + MAX_SAMPLES = 0x8D57 + RGB565 = 0x8D62 + PRIMITIVE_RESTART_FIXED_INDEX = 0x8D69 + ANY_SAMPLES_PASSED_CONSERVATIVE = 0x8D6A + MAX_ELEMENT_INDEX = 0x8D6B + RGBA32UI = 0x8D70 + RGB32UI = 0x8D71 + RGBA16UI = 0x8D76 + RGB16UI = 0x8D77 + RGBA8UI = 0x8D7C + RGB8UI = 0x8D7D + RGBA32I = 0x8D82 + RGB32I = 0x8D83 + RGBA16I = 0x8D88 + RGB16I = 0x8D89 + RGBA8I = 0x8D8E + RGB8I = 0x8D8F + RED_INTEGER = 0x8D94 + GREEN_INTEGER = 0x8D95 + BLUE_INTEGER = 0x8D96 + ALPHA_INTEGER = 0x8D97 + RGB_INTEGER = 0x8D98 + RGBA_INTEGER = 0x8D99 + BGR_INTEGER = 0x8D9A + BGRA_INTEGER = 0x8D9B + INT_2_10_10_10_REV = 0x8D9F + FRAMEBUFFER_ATTACHMENT_LAYERED = 0x8DA7 + FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = 0x8DA8 + FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD + FRAMEBUFFER_SRGB = 0x8DB9 + COMPRESSED_RED_RGTC1 = 0x8DBB + COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC + COMPRESSED_RG_RGTC2 = 0x8DBD + COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE + SAMPLER_1D_ARRAY = 0x8DC0 + SAMPLER_2D_ARRAY = 0x8DC1 + SAMPLER_BUFFER = 0x8DC2 + SAMPLER_1D_ARRAY_SHADOW = 0x8DC3 + SAMPLER_2D_ARRAY_SHADOW = 0x8DC4 + SAMPLER_CUBE_SHADOW = 0x8DC5 + UNSIGNED_INT_VEC2 = 0x8DC6 + UNSIGNED_INT_VEC3 = 0x8DC7 + UNSIGNED_INT_VEC4 = 0x8DC8 + INT_SAMPLER_1D = 0x8DC9 + INT_SAMPLER_2D = 0x8DCA + INT_SAMPLER_3D = 0x8DCB + INT_SAMPLER_CUBE = 0x8DCC + INT_SAMPLER_2D_RECT = 0x8DCD + INT_SAMPLER_1D_ARRAY = 0x8DCE + INT_SAMPLER_2D_ARRAY = 0x8DCF + INT_SAMPLER_BUFFER = 0x8DD0 + UNSIGNED_INT_SAMPLER_1D = 0x8DD1 + UNSIGNED_INT_SAMPLER_2D = 0x8DD2 + UNSIGNED_INT_SAMPLER_3D = 0x8DD3 + UNSIGNED_INT_SAMPLER_CUBE = 0x8DD4 + UNSIGNED_INT_SAMPLER_2D_RECT = 0x8DD5 + UNSIGNED_INT_SAMPLER_1D_ARRAY = 0x8DD6 + UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8DD7 + UNSIGNED_INT_SAMPLER_BUFFER = 0x8DD8 + GEOMETRY_SHADER = 0x8DD9 + MAX_GEOMETRY_UNIFORM_COMPONENTS = 0x8DDF + MAX_GEOMETRY_OUTPUT_VERTICES = 0x8DE0 + MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = 0x8DE1 + ACTIVE_SUBROUTINES = 0x8DE5 + ACTIVE_SUBROUTINE_UNIFORMS = 0x8DE6 + MAX_SUBROUTINES = 0x8DE7 + MAX_SUBROUTINE_UNIFORM_LOCATIONS = 0x8DE8 + LOW_FLOAT = 0x8DF0 + MEDIUM_FLOAT = 0x8DF1 + HIGH_FLOAT = 0x8DF2 + LOW_INT = 0x8DF3 + MEDIUM_INT = 0x8DF4 + HIGH_INT = 0x8DF5 + SHADER_BINARY_FORMATS = 0x8DF8 + NUM_SHADER_BINARY_FORMATS = 0x8DF9 + SHADER_COMPILER = 0x8DFA + MAX_VERTEX_UNIFORM_VECTORS = 0x8DFB + MAX_VARYING_VECTORS = 0x8DFC + MAX_FRAGMENT_UNIFORM_VECTORS = 0x8DFD + QUERY_WAIT = 0x8E13 + QUERY_NO_WAIT = 0x8E14 + QUERY_BY_REGION_WAIT = 0x8E15 + QUERY_BY_REGION_NO_WAIT = 0x8E16 + MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E1E + MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E1F + TRANSFORM_FEEDBACK = 0x8E22 + TRANSFORM_FEEDBACK_BUFFER_PAUSED = 0x8E23 + TRANSFORM_FEEDBACK_BUFFER_ACTIVE = 0x8E24 + TRANSFORM_FEEDBACK_BINDING = 0x8E25 + TIMESTAMP = 0x8E28 + TEXTURE_SWIZZLE_R = 0x8E42 + TEXTURE_SWIZZLE_G = 0x8E43 + TEXTURE_SWIZZLE_B = 0x8E44 + TEXTURE_SWIZZLE_A = 0x8E45 + TEXTURE_SWIZZLE_RGBA = 0x8E46 + ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS = 0x8E47 + ACTIVE_SUBROUTINE_MAX_LENGTH = 0x8E48 + ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH = 0x8E49 + NUM_COMPATIBLE_SUBROUTINES = 0x8E4A + COMPATIBLE_SUBROUTINES = 0x8E4B + QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = 0x8E4C + FIRST_VERTEX_CONVENTION = 0x8E4D + LAST_VERTEX_CONVENTION = 0x8E4E + PROVOKING_VERTEX = 0x8E4F + SAMPLE_POSITION = 0x8E50 + SAMPLE_MASK = 0x8E51 + SAMPLE_MASK_VALUE = 0x8E52 + MAX_SAMPLE_MASK_WORDS = 0x8E59 + MAX_GEOMETRY_SHADER_INVOCATIONS = 0x8E5A + MIN_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5B + MAX_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5C + FRAGMENT_INTERPOLATION_OFFSET_BITS = 0x8E5D + MIN_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5E + MAX_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5F + MAX_TRANSFORM_FEEDBACK_BUFFERS = 0x8E70 + MAX_VERTEX_STREAMS = 0x8E71 + PATCH_VERTICES = 0x8E72 + PATCH_DEFAULT_INNER_LEVEL = 0x8E73 + PATCH_DEFAULT_OUTER_LEVEL = 0x8E74 + TESS_CONTROL_OUTPUT_VERTICES = 0x8E75 + TESS_GEN_MODE = 0x8E76 + TESS_GEN_SPACING = 0x8E77 + TESS_GEN_VERTEX_ORDER = 0x8E78 + TESS_GEN_POINT_MODE = 0x8E79 + ISOLINES = 0x8E7A + FRACTIONAL_ODD = 0x8E7B + FRACTIONAL_EVEN = 0x8E7C + MAX_PATCH_VERTICES = 0x8E7D + MAX_TESS_GEN_LEVEL = 0x8E7E + MAX_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E7F + MAX_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E80 + MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS = 0x8E81 + MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS = 0x8E82 + MAX_TESS_CONTROL_OUTPUT_COMPONENTS = 0x8E83 + MAX_TESS_PATCH_COMPONENTS = 0x8E84 + MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS = 0x8E85 + MAX_TESS_EVALUATION_OUTPUT_COMPONENTS = 0x8E86 + TESS_EVALUATION_SHADER = 0x8E87 + TESS_CONTROL_SHADER = 0x8E88 + MAX_TESS_CONTROL_UNIFORM_BLOCKS = 0x8E89 + MAX_TESS_EVALUATION_UNIFORM_BLOCKS = 0x8E8A + COMPRESSED_RGBA_BPTC_UNORM = 0x8E8C + COMPRESSED_SRGB_ALPHA_BPTC_UNORM = 0x8E8D + COMPRESSED_RGB_BPTC_SIGNED_FLOAT = 0x8E8E + COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT = 0x8E8F + COPY_READ_BUFFER = 0x8F36 + COPY_WRITE_BUFFER = 0x8F37 + MAX_IMAGE_UNITS = 0x8F38 + MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS = 0x8F39 + MAX_COMBINED_SHADER_OUTPUT_RESOURCES = 0x8F39 + IMAGE_BINDING_NAME = 0x8F3A + IMAGE_BINDING_LEVEL = 0x8F3B + IMAGE_BINDING_LAYERED = 0x8F3C + IMAGE_BINDING_LAYER = 0x8F3D + IMAGE_BINDING_ACCESS = 0x8F3E + DRAW_INDIRECT_BUFFER = 0x8F3F + DRAW_INDIRECT_BUFFER_BINDING = 0x8F43 + DOUBLE_MAT2 = 0x8F46 + DOUBLE_MAT3 = 0x8F47 + DOUBLE_MAT4 = 0x8F48 + DOUBLE_MAT2x3 = 0x8F49 + DOUBLE_MAT2x4 = 0x8F4A + DOUBLE_MAT3x2 = 0x8F4B + DOUBLE_MAT3x4 = 0x8F4C + DOUBLE_MAT4x2 = 0x8F4D + DOUBLE_MAT4x3 = 0x8F4E + VERTEX_BINDING_BUFFER = 0x8F4F + R8_SNORM = 0x8F94 + RG8_SNORM = 0x8F95 + RGB8_SNORM = 0x8F96 + RGBA8_SNORM = 0x8F97 + R16_SNORM = 0x8F98 + RG16_SNORM = 0x8F99 + RGB16_SNORM = 0x8F9A + RGBA16_SNORM = 0x8F9B + SIGNED_NORMALIZED = 0x8F9C + PRIMITIVE_RESTART = 0x8F9D + PRIMITIVE_RESTART_INDEX = 0x8F9E + DOUBLE_VEC2 = 0x8FFC + DOUBLE_VEC3 = 0x8FFD + DOUBLE_VEC4 = 0x8FFE + TEXTURE_CUBE_MAP_ARRAY = 0x9009 + TEXTURE_BINDING_CUBE_MAP_ARRAY = 0x900A + PROXY_TEXTURE_CUBE_MAP_ARRAY = 0x900B + SAMPLER_CUBE_MAP_ARRAY = 0x900C + SAMPLER_CUBE_MAP_ARRAY_SHADOW = 0x900D + INT_SAMPLER_CUBE_MAP_ARRAY = 0x900E + UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY = 0x900F + IMAGE_1D = 0x904C + IMAGE_2D = 0x904D + IMAGE_3D = 0x904E + IMAGE_2D_RECT = 0x904F + IMAGE_CUBE = 0x9050 + IMAGE_BUFFER = 0x9051 + IMAGE_1D_ARRAY = 0x9052 + IMAGE_2D_ARRAY = 0x9053 + IMAGE_CUBE_MAP_ARRAY = 0x9054 + IMAGE_2D_MULTISAMPLE = 0x9055 + IMAGE_2D_MULTISAMPLE_ARRAY = 0x9056 + INT_IMAGE_1D = 0x9057 + INT_IMAGE_2D = 0x9058 + INT_IMAGE_3D = 0x9059 + INT_IMAGE_2D_RECT = 0x905A + INT_IMAGE_CUBE = 0x905B + INT_IMAGE_BUFFER = 0x905C + INT_IMAGE_1D_ARRAY = 0x905D + INT_IMAGE_2D_ARRAY = 0x905E + INT_IMAGE_CUBE_MAP_ARRAY = 0x905F + INT_IMAGE_2D_MULTISAMPLE = 0x9060 + INT_IMAGE_2D_MULTISAMPLE_ARRAY = 0x9061 + UNSIGNED_INT_IMAGE_1D = 0x9062 + UNSIGNED_INT_IMAGE_2D = 0x9063 + UNSIGNED_INT_IMAGE_3D = 0x9064 + UNSIGNED_INT_IMAGE_2D_RECT = 0x9065 + UNSIGNED_INT_IMAGE_CUBE = 0x9066 + UNSIGNED_INT_IMAGE_BUFFER = 0x9067 + UNSIGNED_INT_IMAGE_1D_ARRAY = 0x9068 + UNSIGNED_INT_IMAGE_2D_ARRAY = 0x9069 + UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY = 0x906A + UNSIGNED_INT_IMAGE_2D_MULTISAMPLE = 0x906B + UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY = 0x906C + MAX_IMAGE_SAMPLES = 0x906D + IMAGE_BINDING_FORMAT = 0x906E + RGB10_A2UI = 0x906F + MIN_MAP_BUFFER_ALIGNMENT = 0x90BC + IMAGE_FORMAT_COMPATIBILITY_TYPE = 0x90C7 + IMAGE_FORMAT_COMPATIBILITY_BY_SIZE = 0x90C8 + IMAGE_FORMAT_COMPATIBILITY_BY_CLASS = 0x90C9 + MAX_VERTEX_IMAGE_UNIFORMS = 0x90CA + MAX_TESS_CONTROL_IMAGE_UNIFORMS = 0x90CB + MAX_TESS_EVALUATION_IMAGE_UNIFORMS = 0x90CC + MAX_GEOMETRY_IMAGE_UNIFORMS = 0x90CD + MAX_FRAGMENT_IMAGE_UNIFORMS = 0x90CE + MAX_COMBINED_IMAGE_UNIFORMS = 0x90CF + SHADER_STORAGE_BUFFER = 0x90D2 + SHADER_STORAGE_BUFFER_BINDING = 0x90D3 + SHADER_STORAGE_BUFFER_START = 0x90D4 + SHADER_STORAGE_BUFFER_SIZE = 0x90D5 + MAX_VERTEX_SHADER_STORAGE_BLOCKS = 0x90D6 + MAX_GEOMETRY_SHADER_STORAGE_BLOCKS = 0x90D7 + MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS = 0x90D8 + MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS = 0x90D9 + MAX_FRAGMENT_SHADER_STORAGE_BLOCKS = 0x90DA + MAX_COMPUTE_SHADER_STORAGE_BLOCKS = 0x90DB + MAX_COMBINED_SHADER_STORAGE_BLOCKS = 0x90DC + MAX_SHADER_STORAGE_BUFFER_BINDINGS = 0x90DD + MAX_SHADER_STORAGE_BLOCK_SIZE = 0x90DE + SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT = 0x90DF + DEPTH_STENCIL_TEXTURE_MODE = 0x90EA + MAX_COMPUTE_WORK_GROUP_INVOCATIONS = 0x90EB + UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER = 0x90EC + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER = 0x90ED + DISPATCH_INDIRECT_BUFFER = 0x90EE + DISPATCH_INDIRECT_BUFFER_BINDING = 0x90EF + TEXTURE_2D_MULTISAMPLE = 0x9100 + PROXY_TEXTURE_2D_MULTISAMPLE = 0x9101 + TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9102 + PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9103 + TEXTURE_BINDING_2D_MULTISAMPLE = 0x9104 + TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = 0x9105 + TEXTURE_SAMPLES = 0x9106 + TEXTURE_FIXED_SAMPLE_LOCATIONS = 0x9107 + SAMPLER_2D_MULTISAMPLE = 0x9108 + INT_SAMPLER_2D_MULTISAMPLE = 0x9109 + UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = 0x910A + SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910B + INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910C + UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910D + MAX_COLOR_TEXTURE_SAMPLES = 0x910E + MAX_DEPTH_TEXTURE_SAMPLES = 0x910F + MAX_INTEGER_SAMPLES = 0x9110 + MAX_SERVER_WAIT_TIMEOUT = 0x9111 + OBJECT_TYPE = 0x9112 + SYNC_CONDITION = 0x9113 + SYNC_STATUS = 0x9114 + SYNC_FLAGS = 0x9115 + SYNC_FENCE = 0x9116 + SYNC_GPU_COMMANDS_COMPLETE = 0x9117 + UNSIGNALED = 0x9118 + SIGNALED = 0x9119 + ALREADY_SIGNALED = 0x911A + TIMEOUT_EXPIRED = 0x911B + CONDITION_SATISFIED = 0x911C + WAIT_FAILED = 0x911D + BUFFER_ACCESS_FLAGS = 0x911F + BUFFER_MAP_LENGTH = 0x9120 + BUFFER_MAP_OFFSET = 0x9121 + MAX_VERTEX_OUTPUT_COMPONENTS = 0x9122 + MAX_GEOMETRY_INPUT_COMPONENTS = 0x9123 + MAX_GEOMETRY_OUTPUT_COMPONENTS = 0x9124 + MAX_FRAGMENT_INPUT_COMPONENTS = 0x9125 + CONTEXT_PROFILE_MASK = 0x9126 + UNPACK_COMPRESSED_BLOCK_WIDTH = 0x9127 + UNPACK_COMPRESSED_BLOCK_HEIGHT = 0x9128 + UNPACK_COMPRESSED_BLOCK_DEPTH = 0x9129 + UNPACK_COMPRESSED_BLOCK_SIZE = 0x912A + PACK_COMPRESSED_BLOCK_WIDTH = 0x912B + PACK_COMPRESSED_BLOCK_HEIGHT = 0x912C + PACK_COMPRESSED_BLOCK_DEPTH = 0x912D + PACK_COMPRESSED_BLOCK_SIZE = 0x912E + TEXTURE_IMMUTABLE_FORMAT = 0x912F + MAX_DEBUG_MESSAGE_LENGTH = 0x9143 + MAX_DEBUG_LOGGED_MESSAGES = 0x9144 + DEBUG_LOGGED_MESSAGES = 0x9145 + DEBUG_SEVERITY_HIGH = 0x9146 + DEBUG_SEVERITY_MEDIUM = 0x9147 + DEBUG_SEVERITY_LOW = 0x9148 + TEXTURE_BUFFER_OFFSET = 0x919D + TEXTURE_BUFFER_SIZE = 0x919E + TEXTURE_BUFFER_OFFSET_ALIGNMENT = 0x919F + COMPUTE_SHADER = 0x91B9 + MAX_COMPUTE_UNIFORM_BLOCKS = 0x91BB + MAX_COMPUTE_TEXTURE_IMAGE_UNITS = 0x91BC + MAX_COMPUTE_IMAGE_UNIFORMS = 0x91BD + MAX_COMPUTE_WORK_GROUP_COUNT = 0x91BE + MAX_COMPUTE_WORK_GROUP_SIZE = 0x91BF + COMPRESSED_R11_EAC = 0x9270 + COMPRESSED_SIGNED_R11_EAC = 0x9271 + COMPRESSED_RG11_EAC = 0x9272 + COMPRESSED_SIGNED_RG11_EAC = 0x9273 + COMPRESSED_RGB8_ETC2 = 0x9274 + COMPRESSED_SRGB8_ETC2 = 0x9275 + COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9276 + COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9277 + COMPRESSED_RGBA8_ETC2_EAC = 0x9278 + COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = 0x9279 + ATOMIC_COUNTER_BUFFER = 0x92C0 + ATOMIC_COUNTER_BUFFER_BINDING = 0x92C1 + ATOMIC_COUNTER_BUFFER_START = 0x92C2 + ATOMIC_COUNTER_BUFFER_SIZE = 0x92C3 + ATOMIC_COUNTER_BUFFER_DATA_SIZE = 0x92C4 + ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS = 0x92C5 + ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES = 0x92C6 + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER = 0x92C7 + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER = 0x92C8 + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x92C9 + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER = 0x92CA + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER = 0x92CB + MAX_VERTEX_ATOMIC_COUNTER_BUFFERS = 0x92CC + MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS = 0x92CD + MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS = 0x92CE + MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS = 0x92CF + MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS = 0x92D0 + MAX_COMBINED_ATOMIC_COUNTER_BUFFERS = 0x92D1 + MAX_VERTEX_ATOMIC_COUNTERS = 0x92D2 + MAX_TESS_CONTROL_ATOMIC_COUNTERS = 0x92D3 + MAX_TESS_EVALUATION_ATOMIC_COUNTERS = 0x92D4 + MAX_GEOMETRY_ATOMIC_COUNTERS = 0x92D5 + MAX_FRAGMENT_ATOMIC_COUNTERS = 0x92D6 + MAX_COMBINED_ATOMIC_COUNTERS = 0x92D7 + MAX_ATOMIC_COUNTER_BUFFER_SIZE = 0x92D8 + ACTIVE_ATOMIC_COUNTER_BUFFERS = 0x92D9 + UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX = 0x92DA + UNSIGNED_INT_ATOMIC_COUNTER = 0x92DB + MAX_ATOMIC_COUNTER_BUFFER_BINDINGS = 0x92DC + DEBUG_OUTPUT = 0x92E0 + UNIFORM = 0x92E1 + UNIFORM_BLOCK = 0x92E2 + PROGRAM_INPUT = 0x92E3 + PROGRAM_OUTPUT = 0x92E4 + BUFFER_VARIABLE = 0x92E5 + SHADER_STORAGE_BLOCK = 0x92E6 + IS_PER_PATCH = 0x92E7 + VERTEX_SUBROUTINE = 0x92E8 + TESS_CONTROL_SUBROUTINE = 0x92E9 + TESS_EVALUATION_SUBROUTINE = 0x92EA + GEOMETRY_SUBROUTINE = 0x92EB + FRAGMENT_SUBROUTINE = 0x92EC + COMPUTE_SUBROUTINE = 0x92ED + VERTEX_SUBROUTINE_UNIFORM = 0x92EE + TESS_CONTROL_SUBROUTINE_UNIFORM = 0x92EF + TESS_EVALUATION_SUBROUTINE_UNIFORM = 0x92F0 + GEOMETRY_SUBROUTINE_UNIFORM = 0x92F1 + FRAGMENT_SUBROUTINE_UNIFORM = 0x92F2 + COMPUTE_SUBROUTINE_UNIFORM = 0x92F3 + TRANSFORM_FEEDBACK_VARYING = 0x92F4 + ACTIVE_RESOURCES = 0x92F5 + MAX_NAME_LENGTH = 0x92F6 + MAX_NUM_ACTIVE_VARIABLES = 0x92F7 + MAX_NUM_COMPATIBLE_SUBROUTINES = 0x92F8 + NAME_LENGTH = 0x92F9 + TYPE = 0x92FA + ARRAY_SIZE = 0x92FB + OFFSET = 0x92FC + BLOCK_INDEX = 0x92FD + ARRAY_STRIDE = 0x92FE + MATRIX_STRIDE = 0x92FF + IS_ROW_MAJOR = 0x9300 + ATOMIC_COUNTER_BUFFER_INDEX = 0x9301 + BUFFER_BINDING = 0x9302 + BUFFER_DATA_SIZE = 0x9303 + NUM_ACTIVE_VARIABLES = 0x9304 + ACTIVE_VARIABLES = 0x9305 + REFERENCED_BY_VERTEX_SHADER = 0x9306 + REFERENCED_BY_TESS_CONTROL_SHADER = 0x9307 + REFERENCED_BY_TESS_EVALUATION_SHADER = 0x9308 + REFERENCED_BY_GEOMETRY_SHADER = 0x9309 + REFERENCED_BY_FRAGMENT_SHADER = 0x930A + REFERENCED_BY_COMPUTE_SHADER = 0x930B + TOP_LEVEL_ARRAY_SIZE = 0x930C + TOP_LEVEL_ARRAY_STRIDE = 0x930D + LOCATION = 0x930E + LOCATION_INDEX = 0x930F + FRAMEBUFFER_DEFAULT_WIDTH = 0x9310 + FRAMEBUFFER_DEFAULT_HEIGHT = 0x9311 + FRAMEBUFFER_DEFAULT_LAYERS = 0x9312 + FRAMEBUFFER_DEFAULT_SAMPLES = 0x9313 + FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS = 0x9314 + MAX_FRAMEBUFFER_WIDTH = 0x9315 + MAX_FRAMEBUFFER_HEIGHT = 0x9316 + MAX_FRAMEBUFFER_LAYERS = 0x9317 + MAX_FRAMEBUFFER_SAMPLES = 0x9318 + NUM_SAMPLE_COUNTS = 0x9380 +) + +// https://www.opengl.org/sdk/docs/man4/xhtml/glViewport.xml +func (gl *GL) Viewport(x, y, width, height int) { + C.gl4_3core_glViewport(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// DepthRange specifies the mapping of depth values from normalized device +// coordinates to window coordinates. +// +// Parameter nearVal specifies the mapping of the near clipping plane to window +// coordinates (defaults to 0), while farVal specifies the mapping of the far +// clipping plane to window coordinates (defaults to 1). +// +// After clipping and division by w, depth coordinates range from -1 to 1, +// corresponding to the near and far clipping planes. DepthRange specifies a +// linear mapping of the normalized depth coordinates in this range to window +// depth coordinates. Regardless of the actual depth buffer implementation, +// window coordinate depth values are treated as though they range from 0 through 1 +// (like color components). Thus, the values accepted by DepthRange are both +// clamped to this range before they are accepted. +// +// The default setting of (0, 1) maps the near plane to 0 and the far plane to 1. +// With this mapping, the depth buffer range is fully utilized. +// +// It is not necessary that nearVal be less than farVal. Reverse mappings such as +// nearVal 1, and farVal 0 are acceptable. +// +// GL.INVALID_OPERATION is generated if DepthRange is executed between the +// execution of Begin and the corresponding execution of End. +func (gl *GL) DepthRange(nearVal, farVal float64) { + C.gl4_3core_glDepthRange(gl.funcs, C.GLdouble(nearVal), C.GLdouble(farVal)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsEnabled.xml +func (gl *GL) IsEnabled(cap glbase.Enum) bool { + glresult := C.gl4_3core_glIsEnabled(gl.funcs, C.GLenum(cap)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexLevelParameteriv.xml +func (gl *GL) GetTexLevelParameteriv(target glbase.Enum, level int, pname glbase.Enum, params []int32) { + C.gl4_3core_glGetTexLevelParameteriv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexLevelParameterfv.xml +func (gl *GL) GetTexLevelParameterfv(target glbase.Enum, level int, pname glbase.Enum, params []float32) { + C.gl4_3core_glGetTexLevelParameterfv(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameteriv.xml +func (gl *GL) GetTexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_3core_glGetTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameterfv.xml +func (gl *GL) GetTexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_3core_glGetTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexImage.xml +func (gl *GL) GetTexImage(target glbase.Enum, level int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glGetTexImage(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetIntegerv.xml +func (gl *GL) GetIntegerv(pname glbase.Enum, params []int32) { + C.gl4_3core_glGetIntegerv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFloatv.xml +func (gl *GL) GetFloatv(pname glbase.Enum, params []float32) { + C.gl4_3core_glGetFloatv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetError.xml +func (gl *GL) GetError() glbase.Enum { + glresult := C.gl4_3core_glGetError(gl.funcs) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetDoublev.xml +func (gl *GL) GetDoublev(pname glbase.Enum, params []float64) { + C.gl4_3core_glGetDoublev(gl.funcs, C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBooleanv.xml +func (gl *GL) GetBooleanv(pname glbase.Enum, params []bool) { + C.gl4_3core_glGetBooleanv(gl.funcs, C.GLenum(pname), (*C.GLboolean)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glReadPixels.xml +func (gl *GL) ReadPixels(x, y, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glReadPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glReadBuffer.xml +func (gl *GL) ReadBuffer(mode glbase.Enum) { + C.gl4_3core_glReadBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelStorei.xml +func (gl *GL) PixelStorei(pname glbase.Enum, param int32) { + C.gl4_3core_glPixelStorei(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPixelStoref.xml +func (gl *GL) PixelStoref(pname glbase.Enum, param float32) { + C.gl4_3core_glPixelStoref(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDepthFunc.xml +func (gl *GL) DepthFunc(glfunc glbase.Enum) { + C.gl4_3core_glDepthFunc(gl.funcs, C.GLenum(glfunc)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilOp.xml +func (gl *GL) StencilOp(fail, zfail, zpass glbase.Enum) { + C.gl4_3core_glStencilOp(gl.funcs, C.GLenum(fail), C.GLenum(zfail), C.GLenum(zpass)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilFunc.xml +func (gl *GL) StencilFunc(glfunc glbase.Enum, ref int32, mask uint32) { + C.gl4_3core_glStencilFunc(gl.funcs, C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLogicOp.xml +func (gl *GL) LogicOp(opcode glbase.Enum) { + C.gl4_3core_glLogicOp(gl.funcs, C.GLenum(opcode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFunc.xml +func (gl *GL) BlendFunc(sfactor, dfactor glbase.Enum) { + C.gl4_3core_glBlendFunc(gl.funcs, C.GLenum(sfactor), C.GLenum(dfactor)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFlush.xml +func (gl *GL) Flush() { + C.gl4_3core_glFlush(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFinish.xml +func (gl *GL) Finish() { + C.gl4_3core_glFinish(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEnable.xml +func (gl *GL) Enable(cap glbase.Enum) { + C.gl4_3core_glEnable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDisable.xml +func (gl *GL) Disable(cap glbase.Enum) { + C.gl4_3core_glDisable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDepthMask.xml +func (gl *GL) DepthMask(flag bool) { + C.gl4_3core_glDepthMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorMask.xml +func (gl *GL) ColorMask(red, green, blue, alpha bool) { + C.gl4_3core_glColorMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&red)), *(*C.GLboolean)(unsafe.Pointer(&green)), *(*C.GLboolean)(unsafe.Pointer(&blue)), *(*C.GLboolean)(unsafe.Pointer(&alpha))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilMask.xml +func (gl *GL) StencilMask(mask uint32) { + C.gl4_3core_glStencilMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearDepth.xml +func (gl *GL) ClearDepth(depth float64) { + C.gl4_3core_glClearDepth(gl.funcs, C.GLdouble(depth)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearStencil.xml +func (gl *GL) ClearStencil(s int32) { + C.gl4_3core_glClearStencil(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearColor.xml +func (gl *GL) ClearColor(red, green, blue, alpha float32) { + C.gl4_3core_glClearColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClear.xml +func (gl *GL) Clear(mask glbase.Bitfield) { + C.gl4_3core_glClear(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawBuffer.xml +func (gl *GL) DrawBuffer(mode glbase.Enum) { + C.gl4_3core_glDrawBuffer(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage2D.xml +func (gl *GL) TexImage2D(target glbase.Enum, level int, internalFormat int32, width, height, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage1D.xml +func (gl *GL) TexImage1D(target glbase.Enum, level int, internalFormat int32, width, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameteriv.xml +func (gl *GL) TexParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_3core_glTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameteri.xml +func (gl *GL) TexParameteri(target, pname glbase.Enum, param int32) { + C.gl4_3core_glTexParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterfv.xml +func (gl *GL) TexParameterfv(target, pname glbase.Enum, params []float32) { + C.gl4_3core_glTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterf.xml +func (gl *GL) TexParameterf(target, pname glbase.Enum, param float32) { + C.gl4_3core_glTexParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glScissor.xml +func (gl *GL) Scissor(x, y, width, height int) { + C.gl4_3core_glScissor(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPolygonMode.xml +func (gl *GL) PolygonMode(face, mode glbase.Enum) { + C.gl4_3core_glPolygonMode(gl.funcs, C.GLenum(face), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointSize.xml +func (gl *GL) PointSize(size float32) { + C.gl4_3core_glPointSize(gl.funcs, C.GLfloat(size)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glLineWidth.xml +func (gl *GL) LineWidth(width float32) { + C.gl4_3core_glLineWidth(gl.funcs, C.GLfloat(width)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glHint.xml +func (gl *GL) Hint(target, mode glbase.Enum) { + C.gl4_3core_glHint(gl.funcs, C.GLenum(target), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFrontFace.xml +func (gl *GL) FrontFace(mode glbase.Enum) { + C.gl4_3core_glFrontFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCullFace.xml +func (gl *GL) CullFace(mode glbase.Enum) { + C.gl4_3core_glCullFace(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexubv.xml +func (gl *GL) Indexubv(c []uint8) { + C.gl4_3core_glIndexubv(gl.funcs, (*C.GLubyte)(unsafe.Pointer(&c[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIndexub.xml +func (gl *GL) Indexub(c uint8) { + C.gl4_3core_glIndexub(gl.funcs, C.GLubyte(c)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsTexture.xml +func (gl *GL) IsTexture(texture glbase.Texture) bool { + glresult := C.gl4_3core_glIsTexture(gl.funcs, C.GLuint(texture)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenTextures returns n texture names in textures. There is no guarantee +// that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenTextures. +// +// The generated textures have no dimensionality; they assume the +// dimensionality of the texture target to which they are first bound (see +// BindTexture). +// +// Texture names returned by a call to GenTextures are not returned by +// subsequent calls, unless they are first deleted with DeleteTextures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenTextures is available in GL version 2.0 or greater. +func (gl *GL) GenTextures(n int) []glbase.Texture { + if n == 0 { + return nil + } + textures := make([]glbase.Texture, n) + C.gl4_3core_glGenTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) + return textures +} + +// DeleteTextures deletes the textures objects whose names are stored +// in the textures slice. After a texture is deleted, it has no contents or +// dimensionality, and its name is free for reuse (for example by +// GenTextures). If a texture that is currently bound is deleted, the binding +// reverts to 0 (the default texture). +// +// DeleteTextures silently ignores 0's and names that do not correspond to +// existing textures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteTextures is available in GL version 2.0 or greater. +func (gl *GL) DeleteTextures(textures []glbase.Texture) { + n := len(textures) + if n == 0 { + return + } + C.gl4_3core_glDeleteTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindTexture.xml +func (gl *GL) BindTexture(target glbase.Enum, texture glbase.Texture) { + C.gl4_3core_glBindTexture(gl.funcs, C.GLenum(target), C.GLuint(texture)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexSubImage2D.xml +func (gl *GL) TexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexSubImage1D.xml +func (gl *GL) TexSubImage1D(target glbase.Enum, level, xoffset, width int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexSubImage2D.xml +func (gl *GL) CopyTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, x, y, width, height int) { + C.gl4_3core_glCopyTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexSubImage1D.xml +func (gl *GL) CopyTexSubImage1D(target glbase.Enum, level, xoffset, x, y, width int) { + C.gl4_3core_glCopyTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(x), C.GLint(y), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexImage2D.xml +func (gl *GL) CopyTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, height, border int) { + C.gl4_3core_glCopyTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexImage1D.xml +func (gl *GL) CopyTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, border int) { + C.gl4_3core_glCopyTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPolygonOffset.xml +func (gl *GL) PolygonOffset(factor, units float32) { + C.gl4_3core_glPolygonOffset(gl.funcs, C.GLfloat(factor), C.GLfloat(units)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElements.xml +func (gl *GL) DrawElements(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glDrawElements(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawArrays.xml +func (gl *GL) DrawArrays(mode glbase.Enum, first, count int) { + C.gl4_3core_glDrawArrays(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyTexSubImage3D.xml +func (gl *GL) CopyTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, x, y, width, height int) { + C.gl4_3core_glCopyTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexSubImage3D.xml +func (gl *GL) TexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage3D.xml +func (gl *GL) TexImage3D(target glbase.Enum, level int, internalFormat int32, width, height int, depth int32, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawRangeElements.xml +func (gl *GL) DrawRangeElements(mode glbase.Enum, start, end uint32, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glDrawRangeElements(gl.funcs, C.GLenum(mode), C.GLuint(start), C.GLuint(end), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendEquation.xml +func (gl *GL) BlendEquation(mode glbase.Enum) { + C.gl4_3core_glBlendEquation(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendColor.xml +func (gl *GL) BlendColor(red, green, blue, alpha float32) { + C.gl4_3core_glBlendColor(gl.funcs, C.GLfloat(red), C.GLfloat(green), C.GLfloat(blue), C.GLfloat(alpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetCompressedTexImage.xml +func (gl *GL) GetCompressedTexImage(target glbase.Enum, level int, img interface{}) { + var img_ptr unsafe.Pointer + var img_v = reflect.ValueOf(img) + if img != nil && img_v.Kind() != reflect.Slice { + panic("parameter img must be a slice") + } + if img != nil { + img_ptr = unsafe.Pointer(img_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glGetCompressedTexImage(gl.funcs, C.GLenum(target), C.GLint(level), img_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexSubImage1D.xml +func (gl *GL) CompressedTexSubImage1D(target glbase.Enum, level, xoffset, width int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glCompressedTexSubImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLsizei(width), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexSubImage2D.xml +func (gl *GL) CompressedTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glCompressedTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexSubImage3D.xml +func (gl *GL) CompressedTexSubImage3D(target glbase.Enum, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glCompressedTexSubImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexImage1D.xml +func (gl *GL) CompressedTexImage1D(target glbase.Enum, level int, internalFormat glbase.Enum, width, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glCompressedTexImage1D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexImage2D.xml +func (gl *GL) CompressedTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glCompressedTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCompressedTexImage3D.xml +func (gl *GL) CompressedTexImage3D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height int, depth int32, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glCompressedTexImage3D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSampleCoverage.xml +func (gl *GL) SampleCoverage(value float32, invert bool) { + C.gl4_3core_glSampleCoverage(gl.funcs, C.GLfloat(value), *(*C.GLboolean)(unsafe.Pointer(&invert))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glActiveTexture.xml +func (gl *GL) ActiveTexture(texture glbase.Enum) { + C.gl4_3core_glActiveTexture(gl.funcs, C.GLenum(texture)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointParameteriv.xml +func (gl *GL) PointParameteriv(pname glbase.Enum, params []int32) { + C.gl4_3core_glPointParameteriv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointParameteri.xml +func (gl *GL) PointParameteri(pname glbase.Enum, param int32) { + C.gl4_3core_glPointParameteri(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointParameterfv.xml +func (gl *GL) PointParameterfv(pname glbase.Enum, params []float32) { + C.gl4_3core_glPointParameterfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPointParameterf.xml +func (gl *GL) PointParameterf(pname glbase.Enum, param float32) { + C.gl4_3core_glPointParameterf(gl.funcs, C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiDrawArrays.xml +func (gl *GL) MultiDrawArrays(mode glbase.Enum, first, count []int, drawcount int32) { + C.gl4_3core_glMultiDrawArrays(gl.funcs, C.GLenum(mode), (*C.GLint)(unsafe.Pointer(&first[0])), (*C.GLsizei)(unsafe.Pointer(&count[0])), C.GLsizei(drawcount)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFuncSeparate.xml +func (gl *GL) BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha glbase.Enum) { + C.gl4_3core_glBlendFuncSeparate(gl.funcs, C.GLenum(sfactorRGB), C.GLenum(dfactorRGB), C.GLenum(sfactorAlpha), C.GLenum(dfactorAlpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBufferParameteriv.xml +func (gl *GL) GetBufferParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_3core_glGetBufferParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUnmapBuffer.xml +func (gl *GL) UnmapBuffer(target glbase.Enum) bool { + glresult := C.gl4_3core_glUnmapBuffer(gl.funcs, C.GLenum(target)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBufferSubData.xml +func (gl *GL) GetBufferSubData(target glbase.Enum, offset, size int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glGetBufferSubData(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(size), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBufferSubData.xml +func (gl *GL) BufferSubData(target glbase.Enum, offset, size int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glBufferSubData(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(size), data_ptr) +} + +// BufferData creates a new data store for the buffer object currently +// bound to target. Any pre-existing data store is deleted. The new data +// store is created with the specified size in bytes and usage. If data is +// not nil, it must be a slice that is used to initialize the data store. +// In that case the size parameter is ignored and the store size will match +// the slice data size. +// +// In its initial state, the new data store is not mapped, it has a NULL +// mapped pointer, and its mapped access is GL.READ_WRITE. +// +// The target constant must be one of GL.ARRAY_BUFFER, GL.COPY_READ_BUFFER, +// GL.COPY_WRITE_BUFFER, GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER, +// GL.PIXEL_UNPACK_BUFFER, GL.TEXTURE_BUFFER, GL.TRANSFORM_FEEDBACK_BUFFER, +// or GL.UNIFORM_BUFFER. +// +// The usage parameter is a hint to the GL implementation as to how a buffer +// object's data store will be accessed. This enables the GL implementation +// to make more intelligent decisions that may significantly impact buffer +// object performance. It does not, however, constrain the actual usage of +// the data store. usage can be broken down into two parts: first, the +// frequency of access (modification and usage), and second, the nature of +// that access. +// +// A usage frequency of STREAM and nature of DRAW is specified via the +// constant GL.STREAM_DRAW, for example. +// +// The usage frequency of access may be one of: +// +// STREAM +// The data store contents will be modified once and used at most a few times. +// +// STATIC +// The data store contents will be modified once and used many times. +// +// DYNAMIC +// The data store contents will be modified repeatedly and used many times. +// +// The usage nature of access may be one of: +// +// DRAW +// The data store contents are modified by the application, and used as +// the source for GL drawing and image specification commands. +// +// READ +// The data store contents are modified by reading data from the GL, +// and used to return that data when queried by the application. +// +// COPY +// The data store contents are modified by reading data from the GL, +// and used as the source for GL drawing and image specification +// commands. +// +// Clients must align data elements consistent with the requirements of the +// client platform, with an additional base-level requirement that an offset +// within a buffer to a datum comprising N bytes be a multiple of N. +// +// Error GL.INVALID_ENUM is generated if target is not one of the accepted +// buffer targets. GL.INVALID_ENUM is generated if usage is not +// GL.STREAM_DRAW, GL.STREAM_READ, GL.STREAM_COPY, GL.STATIC_DRAW, +// GL.STATIC_READ, GL.STATIC_COPY, GL.DYNAMIC_DRAW, GL.DYNAMIC_READ, or +// GL.DYNAMIC_COPY. GL.INVALID_VALUE is generated if size is negative. +// GL.INVALID_OPERATION is generated if the reserved buffer object name 0 is +// bound to target. GL.OUT_OF_MEMORY is generated if the GL is unable to +// create a data store with the specified size. +func (gl *GL) BufferData(target glbase.Enum, size int, data interface{}, usage glbase.Enum) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + if data != nil { + size = int(data_v.Type().Size()) * data_v.Len() + } + C.gl4_3core_glBufferData(gl.funcs, C.GLenum(target), C.GLsizeiptr(size), data_ptr, C.GLenum(usage)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsBuffer.xml +func (gl *GL) IsBuffer(buffer glbase.Buffer) bool { + glresult := C.gl4_3core_glIsBuffer(gl.funcs, C.GLuint(buffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GenBuffers returns n buffer object names. There is no guarantee that +// the names form a contiguous set of integers; however, it is guaranteed +// that none of the returned names was in use immediately before the call to +// GenBuffers. +// +// Buffer object names returned by a call to GenBuffers are not returned by +// subsequent calls, unless they are first deleted with DeleteBuffers. +// +// No buffer objects are associated with the returned buffer object names +// until they are first bound by calling BindBuffer. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if GenBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// GenBuffers is available in GL version 1.5 or greater. +func (gl *GL) GenBuffers(n int) []glbase.Buffer { + if n == 0 { + return nil + } + buffers := make([]glbase.Buffer, n) + C.gl4_3core_glGenBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) + return buffers +} + +// DeleteBuffers deletes the buffer objects whose names are stored in the +// buffers slice. +// +// After a buffer object is deleted, it has no contents, and its name is free +// for reuse (for example by GenBuffers). If a buffer object that is +// currently bound is deleted, the binding reverts to 0 (the absence of any +// buffer object, which reverts to client memory usage). +// +// DeleteBuffers silently ignores 0's and names that do not correspond to +// existing buffer objects. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if DeleteBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// DeleteBuffers is available in GL version 1.5 or greater. +func (gl *GL) DeleteBuffers(buffers []glbase.Buffer) { + n := len(buffers) + if n == 0 { + return + } + C.gl4_3core_glDeleteBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) +} + +// BindBuffer creates or puts in use a named buffer object. +// Calling BindBuffer with target set to GL.ARRAY_BUFFER, +// GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER or GL.PIXEL_UNPACK_BUFFER +// and buffer set to the name of the new buffer object binds the buffer +// object name to the target. When a buffer object is bound to a target, the +// previous binding for that target is automatically broken. +// +// Buffer object names are unsigned integers. The value zero is reserved, but +// there is no default buffer object for each buffer object target. Instead, +// buffer set to zero effectively unbinds any buffer object previously bound, +// and restores client memory usage for that buffer object target. Buffer +// object names and the corresponding buffer object contents are local to the +// shared display-list space (see XCreateContext) of the current GL rendering +// context; two rendering contexts share buffer object names only if they +// also share display lists. +// +// GenBuffers may be called to generate a set of new buffer object names. +// +// The state of a buffer object immediately after it is first bound is an +// unmapped zero-sized memory buffer with GL.READ_WRITE access and +// GL.STATIC_DRAW usage. +// +// While a non-zero buffer object name is bound, GL operations on the target +// to which it is bound affect the bound buffer object, and queries of the +// target to which it is bound return state from the bound buffer object. +// While buffer object name zero is bound, as in the initial state, attempts +// to modify or query state on the target to which it is bound generates an +// GL.INVALID_OPERATION error. +// +// When vertex array pointer state is changed, for example by a call to +// NormalPointer, the current buffer object binding (GL.ARRAY_BUFFER_BINDING) +// is copied into the corresponding client state for the vertex array type +// being changed, for example GL.NORMAL_ARRAY_BUFFER_BINDING. While a +// non-zero buffer object is bound to the GL.ARRAY_BUFFER target, the vertex +// array pointer parameter that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.ELEMENT_ARRAY_BUFFER +// target, the indices parameter of DrawElements, DrawRangeElements, or +// MultiDrawElements that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_PACK_BUFFER +// target, the following commands are affected: GetCompressedTexImage, +// GetConvolutionFilter, GetHistogram, GetMinmax, GetPixelMap, +// GetPolygonStipple, GetSeparableFilter, GetTexImage, and ReadPixels. The +// pointer parameter that is traditionally interpreted as a pointer to +// client-side memory where the pixels are to be packed is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_UNPACK_BUFFER +// target, the following commands are affected: Bitmap, ColorSubTable, +// ColorTable, CompressedTexImage1D, CompressedTexImage2D, +// CompressedTexImage3D, CompressedTexSubImage1D, CompressedTexSubImage2D, +// CompressedTexSubImage3D, ConvolutionFilter1D, ConvolutionFilter2D, +// DrawPixels, PixelMap, PolygonStipple, SeparableFilter2D, TexImage1D, +// TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, and TexSubImage3D. +// The pointer parameter that is traditionally interpreted as a pointer to +// client-side memory from which the pixels are to be unpacked is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// A buffer object binding created with BindBuffer remains active until a +// different buffer object name is bound to the same target, or until the +// bound buffer object is deleted with DeleteBuffers. +// +// Once created, a named buffer object may be re-bound to any target as often +// as needed. However, the GL implementation may make choices about how to +// optimize the storage of a buffer object based on its initial binding +// target. +// +// Error GL.INVALID_ENUM is generated if target is not one of the allowable +// values. GL.INVALID_OPERATION is generated if BindBuffer is executed +// between the execution of Begin and the corresponding execution of End. +// +// BindBuffer is available in GL version 1.5 or greater. +func (gl *GL) BindBuffer(target glbase.Enum, buffer glbase.Buffer) { + C.gl4_3core_glBindBuffer(gl.funcs, C.GLenum(target), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryObjectuiv.xml +func (gl *GL) GetQueryObjectuiv(id uint32, pname glbase.Enum, params []uint32) { + C.gl4_3core_glGetQueryObjectuiv(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryObjectiv.xml +func (gl *GL) GetQueryObjectiv(id uint32, pname glbase.Enum, params []int32) { + C.gl4_3core_glGetQueryObjectiv(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryiv.xml +func (gl *GL) GetQueryiv(target, pname glbase.Enum, params []int32) { + C.gl4_3core_glGetQueryiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndQuery.xml +func (gl *GL) EndQuery(target glbase.Enum) { + C.gl4_3core_glEndQuery(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBeginQuery.xml +func (gl *GL) BeginQuery(target glbase.Enum, id uint32) { + C.gl4_3core_glBeginQuery(gl.funcs, C.GLenum(target), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsQuery.xml +func (gl *GL) IsQuery(id uint32) bool { + glresult := C.gl4_3core_glIsQuery(gl.funcs, C.GLuint(id)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteQueries.xml +func (gl *GL) DeleteQueries(n int, ids []uint32) { + C.gl4_3core_glDeleteQueries(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenQueries.xml +func (gl *GL) GenQueries(n int, ids []uint32) { + C.gl4_3core_glGenQueries(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// VertexAttribPointer specifies the location and data format of the array +// of generic vertex attributes at index to use when rendering. size +// specifies the number of components per attribute and must be 1, 2, 3, or +// 4. type specifies the data type of each component, and stride specifies +// the byte stride from one attribute to the next, allowing vertices and +// attributes to be packed into a single array or stored in separate arrays. +// normalized indicates whether the values stored in an integer format are +// to be mapped to the range [-1,1] (for signed values) or [0,1] +// (for unsigned values) when they are accessed and converted to floating +// point; otherwise, values will be converted to floats directly without +// normalization. offset is a byte offset into the buffer object's data +// store, which must be bound to the GL.ARRAY_BUFFER target with BindBuffer. +// +// The buffer object binding (GL.ARRAY_BUFFER_BINDING) is saved as +// generic vertex attribute array client-side state +// (GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING) for the provided index. +// +// To enable and disable a generic vertex attribute array, call +// EnableVertexAttribArray and DisableVertexAttribArray with index. If +// enabled, the generic vertex attribute array is used when DrawArrays or +// DrawElements is called. Each generic vertex attribute array is initially +// disabled. +// +// VertexAttribPointer is typically implemented on the client side. +// +// Error GL.INVALID_ENUM is generated if type is not an accepted value. +// GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_VALUE is generated if size is not 1, 2, +// 3, or 4. GL.INVALID_VALUE is generated if stride is negative. +func (gl *GL) VertexAttribPointer(index glbase.Attrib, size int, gltype glbase.Enum, normalized bool, stride int, offset uintptr) { + offset_ptr := unsafe.Pointer(offset) + C.gl4_3core_glVertexAttribPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLsizei(stride), offset_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glValidateProgram.xml +func (gl *GL) ValidateProgram(program glbase.Program) { + C.gl4_3core_glValidateProgram(gl.funcs, C.GLuint(program)) +} + +// UniformMatrix4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*4) != 0 { + panic("invalid value length for UniformMatrix4fv") + } + count := len(value) / (4 * 4) + C.gl4_3core_glUniformMatrix4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*3) != 0 { + panic("invalid value length for UniformMatrix3fv") + } + count := len(value) / (3 * 3) + C.gl4_3core_glUniformMatrix3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*2) != 0 { + panic("invalid value length for UniformMatrix2fv") + } + count := len(value) / (2 * 2) + C.gl4_3core_glUniformMatrix2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform4iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4iv") + } + count := len(value) / 4 + C.gl4_3core_glUniform4iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform3iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3iv") + } + count := len(value) / 3 + C.gl4_3core_glUniform3iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform2iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2iv") + } + count := len(value) / 2 + C.gl4_3core_glUniform2iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform1iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl4_3core_glUniform1iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4fv") + } + count := len(value) / 4 + C.gl4_3core_glUniform4fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3fv") + } + count := len(value) / 3 + C.gl4_3core_glUniform3fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2fv") + } + count := len(value) / 2 + C.gl4_3core_glUniform2fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform1fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl4_3core_glUniform1fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform4i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4i(location glbase.Uniform, v0, v1, v2, v3 int32) { + C.gl4_3core_glUniform4i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2), C.GLint(v3)) +} + +// Uniform3i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3i(location glbase.Uniform, v0, v1, v2 int32) { + C.gl4_3core_glUniform3i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2)) +} + +// Uniform2i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2i(location glbase.Uniform, v0, v1 int32) { + C.gl4_3core_glUniform2i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1)) +} + +// Uniform1i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1i(location glbase.Uniform, v0 int32) { + C.gl4_3core_glUniform1i(gl.funcs, C.GLint(location), C.GLint(v0)) +} + +// Uniform4f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4f(location glbase.Uniform, v0, v1, v2, v3 float32) { + C.gl4_3core_glUniform4f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2), C.GLfloat(v3)) +} + +// Uniform3f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3f(location glbase.Uniform, v0, v1, v2 float32) { + C.gl4_3core_glUniform3f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2)) +} + +// Uniform2f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2f(location glbase.Uniform, v0, v1 float32) { + C.gl4_3core_glUniform2f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1)) +} + +// Uniform1f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1f(location glbase.Uniform, v0 float32) { + C.gl4_3core_glUniform1f(gl.funcs, C.GLint(location), C.GLfloat(v0)) +} + +// UseProgram installs the program object specified by program as part of +// current rendering state. One or more executables are created in a program +// object by successfully attaching shader objects to it with AttachShader, +// successfully compiling the shader objects with CompileShader, and +// successfully linking the program object with LinkProgram. +// +// A program object will contain an executable that will run on the vertex +// processor if it contains one or more shader objects of type +// GL.VERTEX_SHADER that have been successfully compiled and linked. +// Similarly, a program object will contain an executable that will run on +// the fragment processor if it contains one or more shader objects of type +// GL.FRAGMENT_SHADER that have been successfully compiled and linked. +// +// Successfully installing an executable on a programmable processor will +// cause the corresponding fixed functionality of OpenGL to be disabled. +// Specifically, if an executable is installed on the vertex processor, the +// OpenGL fixed functionality will be disabled as follows. +// +// - The modelview matrix is not applied to vertex coordinates. +// +// - The projection matrix is not applied to vertex coordinates. +// +// - The texture matrices are not applied to texture coordinates. +// +// - Normals are not transformed to eye coordinates. +// +// - Normals are not rescaled or normalized. +// +// - Normalization of GL.AUTO_NORMAL evaluated normals is not performed. +// +// - Texture coordinates are not generated automatically. +// +// - Per-vertex lighting is not performed. +// +// - Color material computations are not performed. +// +// - Color index lighting is not performed. +// +// - This list also applies when setting the current raster position. +// +// The executable that is installed on the vertex processor is expected to +// implement any or all of the desired functionality from the preceding list. +// Similarly, if an executable is installed on the fragment processor, the +// OpenGL fixed functionality will be disabled as follows. +// +// - Texture environment and texture functions are not applied. +// +// - Texture application is not applied. +// +// - Color sum is not applied. +// +// - Fog is not applied. +// +// Again, the fragment shader that is installed is expected to implement any +// or all of the desired functionality from the preceding list. +// +// While a program object is in use, applications are free to modify attached +// shader objects, compile attached shader objects, attach additional shader +// objects, and detach or delete shader objects. None of these operations +// will affect the executables that are part of the current state. However, +// relinking the program object that is currently in use will install the +// program object as part of the current rendering state if the link +// operation was successful (see LinkProgram). If the program object +// currently in use is relinked unsuccessfully, its link status will be set +// to GL.FALSE, but the executables and associated state will remain part of +// the current state until a subsequent call to UseProgram removes it from +// use. After it is removed from use, it cannot be made part of current state +// until it has been successfully relinked. +// +// If program contains shader objects of type GL.VERTEX_SHADER but it does +// not contain shader objects of type GL.FRAGMENT_SHADER, an executable will +// be installed on the vertex processor, but fixed functionality will be used +// for fragment processing. Similarly, if program contains shader objects of +// type GL.FRAGMENT_SHADER but it does not contain shader objects of type +// GL.VERTEX_SHADER, an executable will be installed on the fragment +// processor, but fixed functionality will be used for vertex processing. If +// program is 0, the programmable processors will be disabled, and fixed +// functionality will be used for both vertex and fragment processing. +// +// While a program object is in use, the state that controls the disabled +// fixed functionality may also be updated using the normal OpenGL calls. +// +// Like display lists and texture objects, the name space for program objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// Applications are responsible for providing the synchronization across API +// calls when objects are accessed from different execution threads. +// +// Error GL.INVALID_VALUE is generated if program is neither 0 nor a value +// generated by OpenGL. GL.INVALID_OPERATION is generated if program is not +// a program object. GL.INVALID_OPERATION is generated if program could not +// be made part of current state. GL.INVALID_OPERATION is generated if +// UseProgram is executed between the execution of Begin and the +// corresponding execution of End. +// +// UseProgram is available in GL version 2.0 or greater. +func (gl *GL) UseProgram(program glbase.Program) { + C.gl4_3core_glUseProgram(gl.funcs, C.GLuint(program)) +} + +// ShaderSource sets the source code in shader to the provided source code. Any source +// code previously stored in the shader object is completely replaced. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_VALUE is generated if count is less than 0. +// GL.INVALID_OPERATION is generated if ShaderSource is executed between the +// execution of Begin and the corresponding execution of End. +// +// ShaderSource is available in GL version 2.0 or greater. +func (gl *GL) ShaderSource(shader glbase.Shader, source ...string) { + count := len(source) + length := make([]int32, count) + source_c := make([]unsafe.Pointer, count) + for i, src := range source { + length[i] = int32(len(src)) + if len(src) > 0 { + source_c[i] = *(*unsafe.Pointer)(unsafe.Pointer(&src)) + } else { + source_c[i] = unsafe.Pointer(uintptr(0)) + } + } + C.gl4_3core_glShaderSource(gl.funcs, C.GLuint(shader), C.GLsizei(count), (**C.GLchar)(unsafe.Pointer(&source_c[0])), (*C.GLint)(unsafe.Pointer(&length[0]))) +} + +// LinkProgram links the program object specified by program. If any shader +// objects of type GL.VERTEX_SHADER are attached to program, they will be +// used to create an executable that will run on the programmable vertex +// processor. If any shader objects of type GL.FRAGMENT_SHADER are attached +// to program, they will be used to create an executable that will run on the +// programmable fragment processor. +// +// The status of the link operation will be stored as part of the program +// object's state. This value will be set to GL.TRUE if the program object +// was linked without errors and is ready for use, and GL.FALSE otherwise. It +// can be queried by calling GetProgramiv with arguments program and +// GL.LINK_STATUS. +// +// As a result of a successful link operation, all active user-defined +// uniform variables belonging to program will be initialized to 0, and each +// of the program object's active uniform variables will be assigned a +// location that can be queried by calling GetUniformLocation. Also, any +// active user-defined attribute variables that have not been bound to a +// generic vertex attribute index will be bound to one at this time. +// +// Linking of a program object can fail for a number of reasons as specified +// in the OpenGL Shading Language Specification. The following lists some of +// the conditions that will cause a link error. +// +// - The number of active attribute variables supported by the +// implementation has been exceeded. +// +// - The storage limit for uniform variables has been exceeded. +// +// - The number of active uniform variables supported by the implementation +// has been exceeded. +// +// - The main function is missing for the vertex shader or the fragment +// shader. +// +// - A varying variable actually used in the fragment shader is not +// declared in the same way (or is not declared at all) in the vertex +// shader. +// +// - A reference to a function or variable name is unresolved. +// +// - A shared global is declared with two different types or two different +// initial values. +// +// - One or more of the attached shader objects has not been successfully +// compiled. +// +// - Binding a generic attribute matrix caused some rows of the matrix to +// fall outside the allowed maximum of GL.MAX_VERTEX_ATTRIBS. +// +// - Not enough contiguous vertex attribute slots could be found to bind +// attribute matrices. +// +// When a program object has been successfully linked, the program object can +// be made part of current state by calling UseProgram. Whether or not the +// link operation was successful, the program object's information log will +// be overwritten. The information log can be retrieved by calling +// GetProgramInfoLog. +// +// LinkProgram will also install the generated executables as part of the +// current rendering state if the link operation was successful and the +// specified program object is already currently in use as a result of a +// previous call to UseProgram. If the program object currently in use is +// relinked unsuccessfully, its link status will be set to GL.FALSE , but the +// executables and associated state will remain part of the current state +// until a subsequent call to UseProgram removes it from use. After it is +// removed from use, it cannot be made part of current state until it has +// been successfully relinked. +// +// If program contains shader objects of type GL.VERTEX_SHADER but does not +// contain shader objects of type GL.FRAGMENT_SHADER, the vertex shader will +// be linked against the implicit interface for fixed functionality fragment +// processing. Similarly, if program contains shader objects of type +// GL.FRAGMENT_SHADER but it does not contain shader objects of type +// GL.VERTEX_SHADER, the fragment shader will be linked against the implicit +// interface for fixed functionality vertex processing. +// +// The program object's information log is updated and the program is +// generated at the time of the link operation. After the link operation, +// applications are free to modify attached shader objects, compile attached +// shader objects, detach shader objects, delete shader objects, and attach +// additional shader objects. None of these operations affects the +// information log or the program that is part of the program object. +// +// If the link operation is unsuccessful, any information about a previous +// link operation on program is lost (a failed link does not restore the +// old state of program). Certain information can still be retrieved +// from program even after an unsuccessful link operation. See for instance +// GetActiveAttrib and GetActiveUniform. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if LinkProgram is executed +// between the execution of Begin and the corresponding execution of End. +// +// LinkProgram is available in GL version 2.0 or greater. +func (gl *GL) LinkProgram(program glbase.Program) { + C.gl4_3core_glLinkProgram(gl.funcs, C.GLuint(program)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsShader.xml +func (gl *GL) IsShader(shader glbase.Shader) bool { + glresult := C.gl4_3core_glIsShader(gl.funcs, C.GLuint(shader)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsProgram.xml +func (gl *GL) IsProgram(program glbase.Program) bool { + glresult := C.gl4_3core_glIsProgram(gl.funcs, C.GLuint(program)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// GetVertexAttribiv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribiv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribiv(index glbase.Attrib, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl4_3core_glGetVertexAttribiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetVertexAttribfv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribfv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribfv(index glbase.Attrib, pname glbase.Enum, params []float32) { + var params_c [4]float32 + C.gl4_3core_glGetVertexAttribfv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetVertexAttribdv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribdv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribdv(index glbase.Attrib, pname glbase.Enum, params []float64) { + var params_c [4]float64 + C.gl4_3core_glGetVertexAttribdv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformiv returns in params the value of the specified uniform +// variable. The type of the uniform variable specified by location +// determines the number of values returned. If the uniform variable is +// defined in the shader as a boolean, int, or float, a single value will be +// returned. If it is defined as a vec2, ivec2, or bvec2, two values will be +// returned. If it is defined as a vec3, ivec3, or bvec3, three values will +// be returned, and so on. To query values stored in uniform variables +// declared as arrays, call GetUniformiv for each element of the array. To +// query values stored in uniform variables declared as structures, call +// GetUniformiv for each field in the structure. The values for uniform +// variables declared as a matrix will be returned in column major order. +// +// The locations assigned to uniform variables are not known until the +// program object is linked. After linking has occurred, the command +// GetUniformLocation can be used to obtain the location of a uniform +// variable. This location value can then be passed to GetUniformiv in order +// to query the current value of the uniform variable. After a program object +// has been linked successfully, the index values for uniform variables +// remain fixed until the next link command occurs. The uniform variable +// values can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if program has not been +// successfully linked. GL.INVALID_OPERATION is generated if location does +// not correspond to a valid uniform variable location for the specified +// program object. GL.INVALID_OPERATION is generated if GetUniformiv is +// executed between the execution of Begin and the corresponding execution of +// End. +// +// GetUniformiv is available in GL version 2.0 or greater. +func (gl *GL) GetUniformiv(program glbase.Program, location glbase.Uniform, params []int32) { + var params_c [4]int32 + C.gl4_3core_glGetUniformiv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformfv returns in params the value of the specified uniform +// variable. The type of the uniform variable specified by location +// determines the number of values returned. If the uniform variable is +// defined in the shader as a boolean, int, or float, a single value will be +// returned. If it is defined as a vec2, ivec2, or bvec2, two values will be +// returned. If it is defined as a vec3, ivec3, or bvec3, three values will +// be returned, and so on. To query values stored in uniform variables +// declared as arrays, call GetUniformfv for each element of the array. To +// query values stored in uniform variables declared as structures, call +// GetUniformfv for each field in the structure. The values for uniform +// variables declared as a matrix will be returned in column major order. +// +// The locations assigned to uniform variables are not known until the +// program object is linked. After linking has occurred, the command +// GetUniformLocation can be used to obtain the location of a uniform +// variable. This location value can then be passed to GetUniformfv in order +// to query the current value of the uniform variable. After a program object +// has been linked successfully, the index values for uniform variables +// remain fixed until the next link command occurs. The uniform variable +// values can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if program has not been +// successfully linked. GL.INVALID_OPERATION is generated if location does +// not correspond to a valid uniform variable location for the specified +// program object. GL.INVALID_OPERATION is generated if GetUniformfv is +// executed between the execution of Begin and the corresponding execution of +// End. +// +// GetUniformfv is available in GL version 2.0 or greater. +func (gl *GL) GetUniformfv(program glbase.Program, location glbase.Uniform, params []float32) { + var params_c [4]float32 + C.gl4_3core_glGetUniformfv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLfloat)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformLocation returns an integer that represents the location of a +// specific uniform variable within a program object. name must be an active +// uniform variable name in program that is not a structure, an array of +// structures, or a subcomponent of a vector or a matrix. This function +// returns -1 if name does not correspond to an active uniform variable in +// program or if name starts with the reserved prefix "gl_". +// +// Uniform variables that are structures or arrays of structures may be +// queried by calling GetUniformLocation for each field within the +// structure. The array element operator "[]" and the structure field +// operator "." may be used in name in order to select elements within an +// array or fields within a structure. The result of using these operators is +// not allowed to be another structure, an array of structures, or a +// subcomponent of a vector or a matrix. Except if the last part of name +// indicates a uniform variable array, the location of the first element of +// an array can be retrieved by using the name of the array, or by using the +// name appended by "[0]". +// +// The actual locations assigned to uniform variables are not known until the +// program object is linked successfully. After linking has occurred, the +// command GetUniformLocation can be used to obtain the location of a +// uniform variable. This location value can then be passed to Uniform to +// set the value of the uniform variable or to GetUniform in order to query +// the current value of the uniform variable. After a program object has been +// linked successfully, the index values for uniform variables remain fixed +// until the next link command occurs. Uniform variable locations and values +// can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program object. +// GL.INVALID_OPERATION is generated if program has not been successfully +// linked. GL.INVALID_OPERATION is generated if GetUniformLocation is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetUniformLocation is available in GL version 2.0 or greater. +func (gl *GL) GetUniformLocation(program glbase.Program, name string) glbase.Uniform { + name_cstr := C.CString(name) + glresult := C.gl4_3core_glGetUniformLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) + return glbase.Uniform(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetShaderSource.xml +func (gl *GL) GetShaderSource(shader glbase.Shader, bufSize int32, length []int32, source []byte) { + C.gl4_3core_glGetShaderSource(gl.funcs, C.GLuint(shader), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&source[0]))) +} + +// GetShaderInfoLog returns the information log for the specified shader +// object. The information log for a shader object is modified when the +// shader is compiled. +// +// The information log for a shader object is a string that may contain +// diagnostic messages, warning messages, and other information about the +// last compile operation. When a shader object is created, its information +// log will be a string of length 0, and the size of the current log can be +// obtained by calling GetShaderiv with the value GL.INFO_LOG_LENGTH. +// +// The information log for a shader object is the OpenGL implementer's +// primary mechanism for conveying information about the compilation process. +// Therefore, the information log can be helpful to application developers +// during the development process, even when compilation is successful. +// Application developers should not expect different OpenGL implementations +// to produce identical information logs. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_VALUE is generated if maxLength is less than 0. +// GL.INVALID_OPERATION is generated if GetShaderInfoLog is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetShaderInfoLog is available in GL version 2.0 or greater. +func (gl *GL) GetShaderInfoLog(shader glbase.Shader) []byte { + var params [1]int32 + var length int32 + gl.GetShaderiv(shader, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + C.gl4_3core_glGetShaderInfoLog(gl.funcs, C.GLuint(shader), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length)), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) + return infoLog +} + +// GetShaderiv GetShader returns in params the value of a parameter for a specific +// shader object. The following parameters are defined: +// +// GL.SHADER_TYPE +// params returns GL.VERTEX_SHADER if shader is a vertex shader object, +// and GL.FRAGMENT_SHADER if shader is a fragment shader object. +// +// GL.DELETE_STATUS +// params returns GL.TRUE if shader is currently flagged for deletion, +// and GL.FALSE otherwise. +// +// GL.COMPILE_STATUS +// params returns GL.TRUE if the last compile operation on shader was +// successful, and GL.FALSE otherwise. +// +// GL.INFO_LOG_LENGTH +// params returns the number of characters in the information log for +// shader including the null termination character (the size of the +// character buffer required to store the information log). If shader has +// no information log, a value of 0 is returned. +// +// GL.SHADER_SOURCE_LENGTH +// params returns the length of the concatenation of the source strings +// that make up the shader source for the shader, including the null +// termination character. (the size of the character buffer +// required to store the shader source). If no source code exists, 0 is +// returned. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader does not refer to a +// shader object. GL.INVALID_ENUM is generated if pname is not an accepted +// value. GL.INVALID_OPERATION is generated if GetShader is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetShaderiv is available in GL version 2.0 or greater. +func (gl *GL) GetShaderiv(shader glbase.Shader, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl4_3core_glGetShaderiv(gl.funcs, C.GLuint(shader), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetProgramInfoLog returns the information log for the specified program +// object. The information log for a program object is modified when the +// program object is linked or validated. +// +// The information log for a program object is either an empty string, or a +// string containing information about the last link operation, or a string +// containing information about the last validation operation. It may contain +// diagnostic messages, warning messages, and other information. When a +// program object is created, its information log will be a string of length +// 0, and the size of the current log can be obtained by calling GetProgramiv +// with the value GL.INFO_LOG_LENGTH. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated +// by OpenGL. GL.INVALID_OPERATION is generated if program is not a +// program object. +func (gl *GL) GetProgramInfoLog(program glbase.Program) []byte { + var params [1]int32 + var length int32 + gl.GetProgramiv(program, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + C.gl4_3core_glGetProgramInfoLog(gl.funcs, C.GLuint(program), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length)), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) + return infoLog +} + +// GetProgramiv returns in params the value of a parameter for a specific +// program object. The following parameters are defined: +// +// GL.DELETE_STATUS +// params returns GL.TRUE if program is currently flagged for deletion, +// and GL.FALSE otherwise. +// +// GL.LINK_STATUS +// params returns GL.TRUE if the last link operation on program was +// successful, and GL.FALSE otherwise. +// +// GL.VALIDATE_STATUS +// params returns GL.TRUE or if the last validation operation on +// program was successful, and GL.FALSE otherwise. +// +// GL.INFO_LOG_LENGTH +// params returns the number of characters in the information log for +// program including the null termination character (the size of +// the character buffer required to store the information log). If +// program has no information log, a value of 0 is returned. +// +// GL.ATTACHED_SHADERS +// params returns the number of shader objects attached to program. +// +// GL.ACTIVE_ATTRIBUTES +// params returns the number of active attribute variables for program. +// +// GL.ACTIVE_ATTRIBUTE_MAX_LENGTH +// params returns the length of the longest active attribute name for +// program, including the null termination character (the size of +// the character buffer required to store the longest attribute name). +// If no active attributes exist, 0 is returned. +// +// GL.ACTIVE_UNIFORMS +// params returns the number of active uniform variables for program. +// +// GL.ACTIVE_UNIFORM_MAX_LENGTH +// params returns the length of the longest active uniform variable +// name for program, including the null termination character (i.e., +// the size of the character buffer required to store the longest +// uniform variable name). If no active uniform variables exist, 0 is +// returned. +// +// GL.TRANSFORM_FEEDBACK_BUFFER_MODE +// params returns a symbolic constant indicating the buffer mode used +// when transform feedback is active. This may be GL.SEPARATE_ATTRIBS +// or GL.INTERLEAVED_ATTRIBS. +// +// GL.TRANSFORM_FEEDBACK_VARYINGS +// params returns the number of varying variables to capture in transform +// feedback mode for the program. +// +// GL.TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH +// params returns the length of the longest variable name to be used for +// transform feedback, including the null-terminator. +// +// GL.GEOMETRY_VERTICES_OUT +// params returns the maximum number of vertices that the geometry shader in +// program will output. +// +// GL.GEOMETRY_INPUT_TYPE +// params returns a symbolic constant indicating the primitive type accepted +// as input to the geometry shader contained in program. +// +// GL.GEOMETRY_OUTPUT_TYPE +// params returns a symbolic constant indicating the primitive type that will +// be output by the geometry shader contained in program. +// +// GL.ACTIVE_UNIFORM_BLOCKS and GL.ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH are +// available only if the GL version 3.1 or greater. +// +// GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE and +// GL.GEOMETRY_OUTPUT_TYPE are accepted only if the GL version is 3.2 or +// greater. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program does not refer to a +// program object. GL.INVALID_OPERATION is generated if pname is +// GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE, or +// GL.GEOMETRY_OUTPUT_TYPE, and program does not contain a geometry shader. +// GL.INVALID_ENUM is generated if pname is not an accepted value. +func (gl *GL) GetProgramiv(program glbase.Program, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gl4_3core_glGetProgramiv(gl.funcs, C.GLuint(program), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetAttribLocation queries the previously linked program object specified +// by program for the attribute variable specified by name and returns the +// index of the generic vertex attribute that is bound to that attribute +// variable. If name is a matrix attribute variable, the index of the first +// column of the matrix is returned. If the named attribute variable is not +// an active attribute in the specified program object or if name starts with +// the reserved prefix "gl_", a value of -1 is returned. +// +// The association between an attribute variable name and a generic attribute +// index can be specified at any time by calling BindAttribLocation. +// Attribute bindings do not go into effect until LinkProgram is called. +// After a program object has been linked successfully, the index values for +// attribute variables remain fixed until the next link command occurs. The +// attribute values can only be queried after a link if the link was +// successful. GetAttribLocation returns the binding that actually went +// into effect the last time LinkProgram was called for the specified +// program object. Attribute bindings that have been specified since the last +// link operation are not returned by GetAttribLocation. +// +// Error GL_INVALID_OPERATION is generated if program is not a value +// generated by OpenGL. GL_INVALID_OPERATION is generated if program is not +// a program object. GL_INVALID_OPERATION is generated if program has not +// been successfully linked. GL_INVALID_OPERATION is generated if +// GetAttribLocation is executed between the execution of Begin and the +// corresponding execution of End. +// +// GetAttribLocation is available in GL version 2.0 or greater. +func (gl *GL) GetAttribLocation(program glbase.Program, name string) glbase.Attrib { + name_cstr := C.CString(name) + glresult := C.gl4_3core_glGetAttribLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) + return glbase.Attrib(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetAttachedShaders.xml +func (gl *GL) GetAttachedShaders(program glbase.Program, maxCount int32, count []int, obj []uint32) { + C.gl4_3core_glGetAttachedShaders(gl.funcs, C.GLuint(program), C.GLsizei(maxCount), (*C.GLsizei)(unsafe.Pointer(&count[0])), (*C.GLuint)(unsafe.Pointer(&obj[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniform.xml +func (gl *GL) GetActiveUniform(program glbase.Program, index uint32, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl4_3core_glGetActiveUniform(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveAttrib.xml +func (gl *GL) GetActiveAttrib(program glbase.Program, index glbase.Attrib, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl4_3core_glGetActiveAttrib(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEnableVertexAttribArray.xml +func (gl *GL) EnableVertexAttribArray(index glbase.Attrib) { + C.gl4_3core_glEnableVertexAttribArray(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDisableVertexAttribArray.xml +func (gl *GL) DisableVertexAttribArray(index glbase.Attrib) { + C.gl4_3core_glDisableVertexAttribArray(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDetachShader.xml +func (gl *GL) DetachShader(program glbase.Program, shader glbase.Shader) { + C.gl4_3core_glDetachShader(gl.funcs, C.GLuint(program), C.GLuint(shader)) +} + +// DeleteShader frees the memory and invalidates the name associated with +// the shader object specified by shader. This command effectively undoes the +// effects of a call to CreateShader. +// +// If a shader object to be deleted is attached to a program object, it will +// be flagged for deletion, but it will not be deleted until it is no longer +// attached to any program object, for any rendering context (it must +// be detached from wherever it was attached before it will be deleted). A +// value of 0 for shader will be silently ignored. +// +// To determine whether an object has been flagged for deletion, call +// GetShader with arguments shader and GL.DELETE_STATUS. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. +// +// DeleteShader is available in GL version 2.0 or greater. +func (gl *GL) DeleteShader(shader glbase.Shader) { + C.gl4_3core_glDeleteShader(gl.funcs, C.GLuint(shader)) +} + +// DeleteProgram frees the memory and invalidates the name associated with +// the program object specified by program. This command effectively undoes +// the effects of a call to CreateProgram. +// +// If a program object is in use as part of current rendering state, it will +// be flagged for deletion, but it will not be deleted until it is no longer +// part of current state for any rendering context. If a program object to be +// deleted has shader objects attached to it, those shader objects will be +// automatically detached but not deleted unless they have already been +// flagged for deletion by a previous call to DeleteShader. A value of 0 +// for program will be silently ignored. +// +// To determine whether a program object has been flagged for deletion, call +// GetProgram with arguments program and GL.DELETE_STATUS. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. +// +// DeleteProgram is available in GL version 2.0 or greater. +func (gl *GL) DeleteProgram(program glbase.Program) { + C.gl4_3core_glDeleteProgram(gl.funcs, C.GLuint(program)) +} + +// CreateShader creates an empty shader object and returns a non-zero value +// by which it can be referenced. A shader object is used to maintain the +// source code strings that define a shader. shaderType indicates the type of +// shader to be created. +// +// Two types of shaders are supported. A shader of type GL.VERTEX_SHADER is a +// shader that is intended to run on the programmable vertex processor and +// replace the fixed functionality vertex processing in OpenGL. A shader of +// type GL.FRAGMENT_SHADER is a shader that is intended to run on the +// programmable fragment processor and replace the fixed functionality +// fragment processing in OpenGL. +// +// When created, a shader object's GL.SHADER_TYPE parameter is set to either +// GL.VERTEX_SHADER or GL.FRAGMENT_SHADER, depending on the value of +// shaderType. +// +// Like display lists and texture objects, the name space for shader objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// This function returns 0 if an error occurs creating the shader object. +// +// Error GL.INVALID_ENUM is generated if shaderType is not an accepted value. +// GL.INVALID_OPERATION is generated if CreateShader is executed between the +// execution of Begin and the corresponding execution of End. +// +// CreateShader is available in GL version 2.0 or greater. +func (gl *GL) CreateShader(gltype glbase.Enum) glbase.Shader { + glresult := C.gl4_3core_glCreateShader(gl.funcs, C.GLenum(gltype)) + return glbase.Shader(glresult) +} + +// CreateProgram creates an empty program object and returns a non-zero +// value by which it can be referenced. A program object is an object to +// which shader objects can be attached. This provides a mechanism to specify +// the shader objects that will be linked to create a program. It also +// provides a means for checking the compatibility of the shaders that will +// be used to create a program (for instance, checking the compatibility +// between a vertex shader and a fragment shader). When no longer needed as +// part of a program object, shader objects can be detached. +// +// One or more executables are created in a program object by successfully +// attaching shader objects to it with AttachShader, successfully compiling +// the shader objects with CompileShader, and successfully linking the +// program object with LinkProgram. These executables are made part of +// current state when UseProgram is called. Program objects can be deleted +// by calling DeleteProgram. The memory associated with the program object +// will be deleted when it is no longer part of current rendering state for +// any context. +// +// Like display lists and texture objects, the name space for program objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// Applications are responsible for providing the synchronization across API +// calls when objects are accessed from different execution threads. +// +// This function returns 0 if an error occurs creating the program object. +// +// Error GL.INVALID_OPERATION is generated if CreateProgram is executed +// between the execution of Begin and the corresponding execution of End. +// +// CreateProgram is available in GL version 2.0 or greater. +func (gl *GL) CreateProgram() glbase.Program { + glresult := C.gl4_3core_glCreateProgram(gl.funcs) + return glbase.Program(glresult) +} + +// CompileShader compiles the source code strings that have been stored in +// the shader object specified by shader. +// +// The compilation status will be stored as part of the shader object's +// state. This value will be set to GL.TRUE if the shader was compiled without +// errors and is ready for use, and GL.FALSE otherwise. It can be queried by +// calling GetShaderiv with arguments shader and GL.COMPILE_STATUS. +// +// Compilation of a shader can fail for a number of reasons as specified by +// the OpenGL Shading Language Specification. Whether or not the compilation +// was successful, information about the compilation can be obtained from the +// shader object's information log by calling GetShaderInfoLog. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_OPERATION is generated if CompileShader is executed +// between the execution of Begin and the corresponding execution of End. +// +// CompileShader is available in GL version 2.0 or greater. +func (gl *GL) CompileShader(shader glbase.Shader) { + C.gl4_3core_glCompileShader(gl.funcs, C.GLuint(shader)) +} + +// BindAttribLocation associates a user-defined attribute variable in the program +// object specified by program with a generic vertex attribute index. The name +// parameter specifies the name of the vertex shader attribute variable to +// which index is to be bound. When program is made part of the current state, +// values provided via the generic vertex attribute index will modify the +// value of the user-defined attribute variable specified by name. +// +// If name refers to a matrix attribute variable, index refers to the first +// column of the matrix. Other matrix columns are then automatically bound to +// locations index+1 for a matrix of type mat2; index+1 and index+2 for a +// matrix of type mat3; and index+1, index+2, and index+3 for a matrix of +// type mat4. +// +// This command makes it possible for vertex shaders to use descriptive names +// for attribute variables rather than generic variables that are numbered +// from 0 to GL.MAX_VERTEX_ATTRIBS-1. The values sent to each generic +// attribute index are part of current state, just like standard vertex +// attributes such as color, normal, and vertex position. If a different +// program object is made current by calling UseProgram, the generic vertex +// attributes are tracked in such a way that the same values will be observed +// by attributes in the new program object that are also bound to index. +// +// Attribute variable name-to-generic attribute index bindings for a program +// object can be explicitly assigned at any time by calling +// BindAttribLocation. Attribute bindings do not go into effect until +// LinkProgram is called. After a program object has been linked +// successfully, the index values for generic attributes remain fixed (and +// their values can be queried) until the next link command occurs. +// +// Applications are not allowed to bind any of the standard OpenGL vertex +// attributes using this command, as they are bound automatically when +// needed. Any attribute binding that occurs after the program object has +// been linked will not take effect until the next time the program object is +// linked. +// +// If name was bound previously, that information is lost. Thus you cannot +// bind one user-defined attribute variable to multiple indices, but you can +// bind multiple user-defined attribute variables to the same index. +// +// Applications are allowed to bind more than one user-defined attribute +// variable to the same generic vertex attribute index. This is called +// aliasing, and it is allowed only if just one of the aliased attributes is +// active in the executable program, or if no path through the shader +// consumes more than one attribute of a set of attributes aliased to the +// same location. The compiler and linker are allowed to assume that no +// aliasing is done and are free to employ optimizations that work only in +// the absence of aliasing. OpenGL implementations are not required to do +// error checking to detect aliasing. Because there is no way to bind +// standard attributes, it is not possible to alias generic attributes with +// conventional ones (except for generic attribute 0). +// +// BindAttribLocation can be called before any vertex shader objects are +// bound to the specified program object. It is also permissible to bind a +// generic attribute index to an attribute variable name that is never used +// in a vertex shader. +// +// Active attributes that are not explicitly bound will be bound by the +// linker when LinkProgram is called. The locations assigned can be queried +// by calling GetAttribLocation. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. +// GL.INVALID_OPERATION is generated if name starts with the reserved prefix "gl_". +// GL.INVALID_VALUE is generated if program is not a value generated by OpenGL. +// GL.INVALID_OPERATION is generated if program is not a program object. +// GL.INVALID_OPERATION is generated if BindAttribLocation is executed +// between the execution of Begin and the corresponding execution of End. +// +// BindAttribLocation is available in GL version 2.0 or greater. +func (gl *GL) BindAttribLocation(program glbase.Program, index glbase.Attrib, name string) { + name_cstr := C.CString(name) + C.gl4_3core_glBindAttribLocation(gl.funcs, C.GLuint(program), C.GLuint(index), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) +} + +// AttachShader attaches a shader object to a program object. +// +// In order to create an executable, there must be a way to specify the list +// of things that will be linked together. Program objects provide this +// mechanism. Shaders that are to be linked together in a program object must +// first be attached to that program object. This indicates that shader will +// be included in link operations that will be performed on program. +// +// All operations that can be performed on a shader object are valid whether +// or not the shader object is attached to a program object. It is +// permissible to attach a shader object to a program object before source +// code has been loaded into the shader object or before the shader object +// has been compiled. It is permissible to attach multiple shader objects of +// the same type because each may contain a portion of the complete shader. +// It is also permissible to attach a shader object to more than one program +// object. If a shader object is deleted while it is attached to a program +// object, it will be flagged for deletion, and deletion will not occur until +// DetachShader is called to detach it from all program objects to which it +// is attached. +// +// Error GL.INVALID_VALUE is generated if either program or shader is not a +// value generated by OpenGL. GL.INVALID_OPERATION is generated if program +// is not a program object. GL.INVALID_OPERATION is generated if shader is +// not a shader object. GL.INVALID_OPERATION is generated if shader is +// already attached to program. GL.INVALID_OPERATION is generated if +// AttachShader is executed between the execution of Begin and the +// corresponding execution of End. +// +// AttachShader is available in GL version 2.0 or greater. +func (gl *GL) AttachShader(program glbase.Program, shader glbase.Shader) { + C.gl4_3core_glAttachShader(gl.funcs, C.GLuint(program), C.GLuint(shader)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilMaskSeparate.xml +func (gl *GL) StencilMaskSeparate(face glbase.Enum, mask uint32) { + C.gl4_3core_glStencilMaskSeparate(gl.funcs, C.GLenum(face), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilFuncSeparate.xml +func (gl *GL) StencilFuncSeparate(face, glfunc glbase.Enum, ref int32, mask uint32) { + C.gl4_3core_glStencilFuncSeparate(gl.funcs, C.GLenum(face), C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glStencilOpSeparate.xml +func (gl *GL) StencilOpSeparate(face, sfail, dpfail, dppass glbase.Enum) { + C.gl4_3core_glStencilOpSeparate(gl.funcs, C.GLenum(face), C.GLenum(sfail), C.GLenum(dpfail), C.GLenum(dppass)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawBuffers.xml +func (gl *GL) DrawBuffers(n int, bufs []glbase.Enum) { + C.gl4_3core_glDrawBuffers(gl.funcs, C.GLsizei(n), (*C.GLenum)(unsafe.Pointer(&bufs[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendEquationSeparate.xml +func (gl *GL) BlendEquationSeparate(modeRGB, modeAlpha glbase.Enum) { + C.gl4_3core_glBlendEquationSeparate(gl.funcs, C.GLenum(modeRGB), C.GLenum(modeAlpha)) +} + +// UniformMatrix4x3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4x3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4x3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*3) != 0 { + panic("invalid value length for UniformMatrix4x3fv") + } + count := len(value) / (4 * 3) + C.gl4_3core_glUniformMatrix4x3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3x4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3x4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3x4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*4) != 0 { + panic("invalid value length for UniformMatrix3x4fv") + } + count := len(value) / (3 * 4) + C.gl4_3core_glUniformMatrix3x4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix4x2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4x2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4x2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*2) != 0 { + panic("invalid value length for UniformMatrix4x2fv") + } + count := len(value) / (4 * 2) + C.gl4_3core_glUniformMatrix4x2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2x4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2x4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2x4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*4) != 0 { + panic("invalid value length for UniformMatrix2x4fv") + } + count := len(value) / (2 * 4) + C.gl4_3core_glUniformMatrix2x4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3x2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3x2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3x2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*2) != 0 { + panic("invalid value length for UniformMatrix3x2fv") + } + count := len(value) / (3 * 2) + C.gl4_3core_glUniformMatrix3x2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2x3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2x3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2x3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*3) != 0 { + panic("invalid value length for UniformMatrix2x3fv") + } + count := len(value) / (2 * 3) + C.gl4_3core_glUniformMatrix2x3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsVertexArray.xml +func (gl *GL) IsVertexArray(array uint32) bool { + glresult := C.gl4_3core_glIsVertexArray(gl.funcs, C.GLuint(array)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenVertexArrays.xml +func (gl *GL) GenVertexArrays(n int, arrays []uint32) { + C.gl4_3core_glGenVertexArrays(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&arrays[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteVertexArrays.xml +func (gl *GL) DeleteVertexArrays(n int, arrays []uint32) { + C.gl4_3core_glDeleteVertexArrays(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&arrays[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindVertexArray.xml +func (gl *GL) BindVertexArray(array uint32) { + C.gl4_3core_glBindVertexArray(gl.funcs, C.GLuint(array)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFlushMappedBufferRange.xml +func (gl *GL) FlushMappedBufferRange(target glbase.Enum, offset, length int) { + C.gl4_3core_glFlushMappedBufferRange(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(length)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTextureLayer.xml +func (gl *GL) FramebufferTextureLayer(target, attachment glbase.Enum, texture glbase.Texture, level int, layer int32) { + C.gl4_3core_glFramebufferTextureLayer(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLuint(texture), C.GLint(level), C.GLint(layer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRenderbufferStorageMultisample.xml +func (gl *GL) RenderbufferStorageMultisample(target glbase.Enum, samples int32, internalFormat glbase.Enum, width, height int) { + C.gl4_3core_glRenderbufferStorageMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlitFramebuffer.xml +func (gl *GL) BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1 int32, mask glbase.Bitfield, filter glbase.Enum) { + C.gl4_3core_glBlitFramebuffer(gl.funcs, C.GLint(srcX0), C.GLint(srcY0), C.GLint(srcX1), C.GLint(srcY1), C.GLint(dstX0), C.GLint(dstY0), C.GLint(dstX1), C.GLint(dstY1), C.GLbitfield(mask), C.GLenum(filter)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenerateMipmap.xml +func (gl *GL) GenerateMipmap(target glbase.Enum) { + C.gl4_3core_glGenerateMipmap(gl.funcs, C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFramebufferAttachmentParameteriv.xml +func (gl *GL) GetFramebufferAttachmentParameteriv(target, attachment, pname glbase.Enum, params []int32) { + C.gl4_3core_glGetFramebufferAttachmentParameteriv(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferRenderbuffer.xml +func (gl *GL) FramebufferRenderbuffer(target, attachment, renderbuffertarget glbase.Enum, renderbuffer glbase.Renderbuffer) { + C.gl4_3core_glFramebufferRenderbuffer(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(renderbuffertarget), C.GLuint(renderbuffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture3D.xml +func (gl *GL) FramebufferTexture3D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int, zoffset int32) { + C.gl4_3core_glFramebufferTexture3D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level), C.GLint(zoffset)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture2D.xml +func (gl *GL) FramebufferTexture2D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int) { + C.gl4_3core_glFramebufferTexture2D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture1D.xml +func (gl *GL) FramebufferTexture1D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int) { + C.gl4_3core_glFramebufferTexture1D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCheckFramebufferStatus.xml +func (gl *GL) CheckFramebufferStatus(target glbase.Enum) glbase.Enum { + glresult := C.gl4_3core_glCheckFramebufferStatus(gl.funcs, C.GLenum(target)) + return glbase.Enum(glresult) +} + +// GenFramebuffers returns n framebuffer object names in ids. There is no +// guarantee that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenFramebuffers. +// +// Framebuffer object names returned by a call to GenFramebuffers are not +// returned by subsequent calls, unless they are first deleted with +// DeleteFramebuffers. +// +// The names returned in ids are marked as used, for the purposes of +// GenFramebuffers only, but they acquire state and type only when they are +// first bound. +// +// Error GL.INVALID_VALUE is generated if n is negative. +func (gl *GL) GenFramebuffers(n int) []glbase.Framebuffer { + if n == 0 { + return nil + } + framebuffers := make([]glbase.Framebuffer, n) + C.gl4_3core_glGenFramebuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&framebuffers[0]))) + return framebuffers +} + +// DeleteFramebuffers deletes the framebuffer objects whose names are +// stored in the framebuffers slice. The name zero is reserved by the GL and +// is silently ignored, should it occur in framebuffers, as are other unused +// names. Once a framebuffer object is deleted, its name is again unused and +// it has no attachments. If a framebuffer that is currently bound to one or +// more of the targets GL.DRAW_FRAMEBUFFER or GL.READ_FRAMEBUFFER is deleted, +// it is as though BindFramebuffer had been executed with the corresponding +// target and framebuffer zero. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteFramebuffers is available in GL version 3.0 or greater. +func (gl *GL) DeleteFramebuffers(framebuffers []glbase.Framebuffer) { + n := len(framebuffers) + if n == 0 { + return + } + C.gl4_3core_glDeleteFramebuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&framebuffers[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindFramebuffer.xml +func (gl *GL) BindFramebuffer(target glbase.Enum, framebuffer glbase.Framebuffer) { + C.gl4_3core_glBindFramebuffer(gl.funcs, C.GLenum(target), C.GLuint(framebuffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsFramebuffer.xml +func (gl *GL) IsFramebuffer(framebuffer glbase.Framebuffer) bool { + glresult := C.gl4_3core_glIsFramebuffer(gl.funcs, C.GLuint(framebuffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetRenderbufferParameteriv.xml +func (gl *GL) GetRenderbufferParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_3core_glGetRenderbufferParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glRenderbufferStorage.xml +func (gl *GL) RenderbufferStorage(target, internalFormat glbase.Enum, width, height int) { + C.gl4_3core_glRenderbufferStorage(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) +} + +// GenRenderbuffers returns n renderbuffer object names in renderbuffers. +// There is no guarantee that the names form a contiguous set of integers; +// however, it is guaranteed that none of the returned names was in use +// immediately before the call to GenRenderbuffers. +// +// Renderbuffer object names returned by a call to GenRenderbuffers are not +// returned by subsequent calls, unless they are first deleted with +// DeleteRenderbuffers. +// +// The names returned in renderbuffers are marked as used, for the purposes +// of GenRenderbuffers only, but they acquire state and type only when they +// are first bound. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenRenderbuffers is available in GL version 3.0 or greater. +func (gl *GL) GenRenderbuffers(n int) []glbase.Renderbuffer { + if n == 0 { + return nil + } + renderbuffers := make([]glbase.Renderbuffer, n) + C.gl4_3core_glGenRenderbuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&renderbuffers[0]))) + return renderbuffers +} + +// DeleteRenderbuffers deletes the renderbuffer objects whose names are stored +// in the renderbuffers slice. The name zero is reserved by the GL and +// is silently ignored, should it occur in renderbuffers, as are other unused +// names. Once a renderbuffer object is deleted, its name is again unused and +// it has no contents. If a renderbuffer that is currently bound to the +// target GL.RENDERBUFFER is deleted, it is as though BindRenderbuffer had +// been executed with a target of GL.RENDERBUFFER and a name of zero. +// +// If a renderbuffer object is attached to one or more attachment points in +// the currently bound framebuffer, then it as if FramebufferRenderbuffer +// had been called, with a renderbuffer of zero for each attachment point to +// which this image was attached in the currently bound framebuffer. In other +// words, this renderbuffer object is first detached from all attachment +// ponits in the currently bound framebuffer. Note that the renderbuffer +// image is specifically not detached from any non-bound framebuffers. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteRenderbuffers is available in GL version 3.0 or greater. +func (gl *GL) DeleteRenderbuffers(renderbuffers []glbase.Renderbuffer) { + n := len(renderbuffers) + if n == 0 { + return + } + C.gl4_3core_glDeleteRenderbuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&renderbuffers[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindRenderbuffer.xml +func (gl *GL) BindRenderbuffer(target glbase.Enum, renderbuffer glbase.Renderbuffer) { + C.gl4_3core_glBindRenderbuffer(gl.funcs, C.GLenum(target), C.GLuint(renderbuffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsRenderbuffer.xml +func (gl *GL) IsRenderbuffer(renderbuffer glbase.Renderbuffer) bool { + glresult := C.gl4_3core_glIsRenderbuffer(gl.funcs, C.GLuint(renderbuffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferfi.xml +func (gl *GL) ClearBufferfi(buffer glbase.Enum, drawbuffer int32, depth float32, stencil int32) { + C.gl4_3core_glClearBufferfi(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), C.GLfloat(depth), C.GLint(stencil)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferfv.xml +func (gl *GL) ClearBufferfv(buffer glbase.Enum, drawbuffer int32, value []float32) { + C.gl4_3core_glClearBufferfv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferuiv.xml +func (gl *GL) ClearBufferuiv(buffer glbase.Enum, drawbuffer int32, value []uint32) { + C.gl4_3core_glClearBufferuiv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferiv.xml +func (gl *GL) ClearBufferiv(buffer glbase.Enum, drawbuffer int32, value []int32) { + C.gl4_3core_glClearBufferiv(gl.funcs, C.GLenum(buffer), C.GLint(drawbuffer), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameterIuiv.xml +func (gl *GL) GetTexParameterIuiv(target, pname glbase.Enum, params []uint32) { + C.gl4_3core_glGetTexParameterIuiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTexParameterIiv.xml +func (gl *GL) GetTexParameterIiv(target, pname glbase.Enum, params []int32) { + C.gl4_3core_glGetTexParameterIiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterIuiv.xml +func (gl *GL) TexParameterIuiv(target, pname glbase.Enum, params []uint32) { + C.gl4_3core_glTexParameterIuiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexParameterIiv.xml +func (gl *GL) TexParameterIiv(target, pname glbase.Enum, params []int32) { + C.gl4_3core_glTexParameterIiv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// Uniform4uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4uiv") + } + count := len(value) / 4 + C.gl4_3core_glUniform4uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform3uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3uiv") + } + count := len(value) / 3 + C.gl4_3core_glUniform3uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform2uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2uiv") + } + count := len(value) / 2 + C.gl4_3core_glUniform2uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform1uiv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1uiv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1uiv(location glbase.Uniform, value []uint32) { + if len(value) == 0 { + return + } + count := len(value) + C.gl4_3core_glUniform1uiv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// Uniform4ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4ui(location glbase.Uniform, v0, v1, v2, v3 uint32) { + C.gl4_3core_glUniform4ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2), C.GLuint(v3)) +} + +// Uniform3ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3ui(location glbase.Uniform, v0, v1, v2 uint32) { + C.gl4_3core_glUniform3ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2)) +} + +// Uniform2ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2ui(location glbase.Uniform, v0, v1 uint32) { + C.gl4_3core_glUniform2ui(gl.funcs, C.GLint(location), C.GLuint(v0), C.GLuint(v1)) +} + +// Uniform1ui modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1ui operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1ui(location glbase.Uniform, v0 uint32) { + C.gl4_3core_glUniform1ui(gl.funcs, C.GLint(location), C.GLuint(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFragDataLocation.xml +func (gl *GL) GetFragDataLocation(program glbase.Program, name []byte) int32 { + glresult := C.gl4_3core_glGetFragDataLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindFragDataLocation.xml +func (gl *GL) BindFragDataLocation(program glbase.Program, color uint32, name []byte) { + C.gl4_3core_glBindFragDataLocation(gl.funcs, C.GLuint(program), C.GLuint(color), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetUniformuiv.xml +func (gl *GL) GetUniformuiv(program glbase.Program, location glbase.Uniform, params []uint32) { + C.gl4_3core_glGetUniformuiv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetVertexAttribIuiv.xml +func (gl *GL) GetVertexAttribIuiv(index glbase.Attrib, pname glbase.Enum, params []uint32) { + C.gl4_3core_glGetVertexAttribIuiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetVertexAttribIiv.xml +func (gl *GL) GetVertexAttribIiv(index glbase.Attrib, pname glbase.Enum, params []int32) { + C.gl4_3core_glGetVertexAttribIiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribIPointer.xml +func (gl *GL) VertexAttribIPointer(index glbase.Attrib, size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glVertexAttribIPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndConditionalRender.xml +func (gl *GL) EndConditionalRender() { + C.gl4_3core_glEndConditionalRender(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBeginConditionalRender.xml +func (gl *GL) BeginConditionalRender(id uint32, mode glbase.Enum) { + C.gl4_3core_glBeginConditionalRender(gl.funcs, C.GLuint(id), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClampColor.xml +func (gl *GL) ClampColor(target, clamp glbase.Enum) { + C.gl4_3core_glClampColor(gl.funcs, C.GLenum(target), C.GLenum(clamp)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetTransformFeedbackVarying.xml +func (gl *GL) GetTransformFeedbackVarying(program glbase.Program, index uint32, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gl4_3core_glGetTransformFeedbackVarying(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLsizei)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindBufferBase.xml +func (gl *GL) BindBufferBase(target glbase.Enum, index uint32, buffer glbase.Buffer) { + C.gl4_3core_glBindBufferBase(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindBufferRange.xml +func (gl *GL) BindBufferRange(target glbase.Enum, index uint32, buffer glbase.Buffer, offset, size int) { + C.gl4_3core_glBindBufferRange(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(buffer), C.GLintptr(offset), C.GLsizeiptr(size)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndTransformFeedback.xml +func (gl *GL) EndTransformFeedback() { + C.gl4_3core_glEndTransformFeedback(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBeginTransformFeedback.xml +func (gl *GL) BeginTransformFeedback(primitiveMode glbase.Enum) { + C.gl4_3core_glBeginTransformFeedback(gl.funcs, C.GLenum(primitiveMode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsEnabledi.xml +func (gl *GL) IsEnabledi(target glbase.Enum, index uint32) bool { + glresult := C.gl4_3core_glIsEnabledi(gl.funcs, C.GLenum(target), C.GLuint(index)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDisablei.xml +func (gl *GL) Disablei(target glbase.Enum, index uint32) { + C.gl4_3core_glDisablei(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEnablei.xml +func (gl *GL) Enablei(target glbase.Enum, index uint32) { + C.gl4_3core_glEnablei(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetIntegeri_v.xml +func (gl *GL) GetIntegeri_v(target glbase.Enum, index uint32, data []int32) { + C.gl4_3core_glGetIntegeri_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLint)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBooleani_v.xml +func (gl *GL) GetBooleani_v(target glbase.Enum, index uint32, data []bool) { + C.gl4_3core_glGetBooleani_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLboolean)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorMaski.xml +func (gl *GL) ColorMaski(index uint32, r, g, b, a bool) { + C.gl4_3core_glColorMaski(gl.funcs, C.GLuint(index), *(*C.GLboolean)(unsafe.Pointer(&r)), *(*C.GLboolean)(unsafe.Pointer(&g)), *(*C.GLboolean)(unsafe.Pointer(&b)), *(*C.GLboolean)(unsafe.Pointer(&a))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyBufferSubData.xml +func (gl *GL) CopyBufferSubData(readTarget, writeTarget glbase.Enum, readOffset, writeOffset, size int) { + C.gl4_3core_glCopyBufferSubData(gl.funcs, C.GLenum(readTarget), C.GLenum(writeTarget), C.GLintptr(readOffset), C.GLintptr(writeOffset), C.GLsizeiptr(size)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformBlockBinding.xml +func (gl *GL) UniformBlockBinding(program glbase.Program, v0, v1 uint32) { + C.gl4_3core_glUniformBlockBinding(gl.funcs, C.GLuint(program), C.GLuint(v0), C.GLuint(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformBlockName.xml +func (gl *GL) GetActiveUniformBlockName(program glbase.Program, uniformBlockIndex uint32, bufSize int32, length []int32, uniformBlockName []byte) { + C.gl4_3core_glGetActiveUniformBlockName(gl.funcs, C.GLuint(program), C.GLuint(uniformBlockIndex), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&uniformBlockName[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformBlockiv.xml +func (gl *GL) GetActiveUniformBlockiv(program glbase.Program, uniformBlockIndex uint32, pname glbase.Enum, params []int32) { + C.gl4_3core_glGetActiveUniformBlockiv(gl.funcs, C.GLuint(program), C.GLuint(uniformBlockIndex), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetUniformBlockIndex.xml +func (gl *GL) GetUniformBlockIndex(program glbase.Program, uniformBlockName []byte) uint32 { + glresult := C.gl4_3core_glGetUniformBlockIndex(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&uniformBlockName[0]))) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformName.xml +func (gl *GL) GetActiveUniformName(program glbase.Program, uniformIndex uint32, bufSize int32, length []int32, uniformName []byte) { + C.gl4_3core_glGetActiveUniformName(gl.funcs, C.GLuint(program), C.GLuint(uniformIndex), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&uniformName[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveUniformsiv.xml +func (gl *GL) GetActiveUniformsiv(program glbase.Program, uniformCount int32, uniformIndices []uint32, pname glbase.Enum, params []int32) { + C.gl4_3core_glGetActiveUniformsiv(gl.funcs, C.GLuint(program), C.GLsizei(uniformCount), (*C.GLuint)(unsafe.Pointer(&uniformIndices[0])), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPrimitiveRestartIndex.xml +func (gl *GL) PrimitiveRestartIndex(index uint32) { + C.gl4_3core_glPrimitiveRestartIndex(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexBuffer.xml +func (gl *GL) TexBuffer(target, internalFormat glbase.Enum, buffer glbase.Buffer) { + C.gl4_3core_glTexBuffer(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsInstanced.xml +func (gl *GL) DrawElementsInstanced(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, instancecount int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glDrawElementsInstanced(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLsizei(instancecount)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawArraysInstanced.xml +func (gl *GL) DrawArraysInstanced(mode glbase.Enum, first, count int, instancecount int32) { + C.gl4_3core_glDrawArraysInstanced(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count), C.GLsizei(instancecount)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSampleMaski.xml +func (gl *GL) SampleMaski(index uint32, mask glbase.Bitfield) { + C.gl4_3core_glSampleMaski(gl.funcs, C.GLuint(index), C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetMultisamplefv.xml +func (gl *GL) GetMultisamplefv(pname glbase.Enum, index uint32, val []float32) { + C.gl4_3core_glGetMultisamplefv(gl.funcs, C.GLenum(pname), C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&val[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage3DMultisample.xml +func (gl *GL) TexImage3DMultisample(target glbase.Enum, samples, internalFormat int32, width, height int, depth int32, fixedsamplelocations bool) { + C.gl4_3core_glTexImage3DMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), *(*C.GLboolean)(unsafe.Pointer(&fixedsamplelocations))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexImage2DMultisample.xml +func (gl *GL) TexImage2DMultisample(target glbase.Enum, samples, internalFormat int32, width, height int, fixedsamplelocations bool) { + C.gl4_3core_glTexImage2DMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), *(*C.GLboolean)(unsafe.Pointer(&fixedsamplelocations))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSynciv.xml +func (gl *GL) GetSynciv(sync glbase.Sync, pname glbase.Enum, bufSize int32, length, values []int32) { + C.gl4_3core_glGetSynciv(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLenum(pname), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetInteger64v.xml +func (gl *GL) GetInteger64v(pname glbase.Enum, params []int64) { + C.gl4_3core_glGetInteger64v(gl.funcs, C.GLenum(pname), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glWaitSync.xml +func (gl *GL) WaitSync(sync glbase.Sync, flags glbase.Bitfield, timeout uint64) { + C.gl4_3core_glWaitSync(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLbitfield(flags), C.GLuint64(timeout)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClientWaitSync.xml +func (gl *GL) ClientWaitSync(sync glbase.Sync, flags glbase.Bitfield, timeout uint64) glbase.Enum { + glresult := C.gl4_3core_glClientWaitSync(gl.funcs, C.GLsync(unsafe.Pointer(sync)), C.GLbitfield(flags), C.GLuint64(timeout)) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteSync.xml +func (gl *GL) DeleteSync(sync glbase.Sync) { + C.gl4_3core_glDeleteSync(gl.funcs, C.GLsync(unsafe.Pointer(sync))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsSync.xml +func (gl *GL) IsSync(sync glbase.Sync) bool { + glresult := C.gl4_3core_glIsSync(gl.funcs, C.GLsync(unsafe.Pointer(sync))) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFenceSync.xml +func (gl *GL) FenceSync(condition glbase.Enum, flags glbase.Bitfield) glbase.Sync { + glresult := C.gl4_3core_glFenceSync(gl.funcs, C.GLenum(condition), C.GLbitfield(flags)) + return glbase.Sync(unsafe.Pointer(glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProvokingVertex.xml +func (gl *GL) ProvokingVertex(mode glbase.Enum) { + C.gl4_3core_glProvokingVertex(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsInstancedBaseVertex.xml +func (gl *GL) DrawElementsInstancedBaseVertex(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, instancecount, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glDrawElementsInstancedBaseVertex(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLsizei(instancecount), C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawRangeElementsBaseVertex.xml +func (gl *GL) DrawRangeElementsBaseVertex(mode glbase.Enum, start, end uint32, count int, gltype glbase.Enum, indices interface{}, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glDrawRangeElementsBaseVertex(gl.funcs, C.GLenum(mode), C.GLuint(start), C.GLuint(end), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsBaseVertex.xml +func (gl *GL) DrawElementsBaseVertex(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, basevertex int32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glDrawElementsBaseVertex(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLint(basevertex)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferTexture.xml +func (gl *GL) FramebufferTexture(target, attachment glbase.Enum, texture glbase.Texture, level int) { + C.gl4_3core_glFramebufferTexture(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetBufferParameteri64v.xml +func (gl *GL) GetBufferParameteri64v(target, pname glbase.Enum, params []int64) { + C.gl4_3core_glGetBufferParameteri64v(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetInteger64i_v.xml +func (gl *GL) GetInteger64i_v(target glbase.Enum, index uint32, data []int64) { + C.gl4_3core_glGetInteger64i_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLint64)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP4uiv.xml +func (gl *GL) VertexAttribP4uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl4_3core_glVertexAttribP4uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP4ui.xml +func (gl *GL) VertexAttribP4ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl4_3core_glVertexAttribP4ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP3uiv.xml +func (gl *GL) VertexAttribP3uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl4_3core_glVertexAttribP3uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP3ui.xml +func (gl *GL) VertexAttribP3ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl4_3core_glVertexAttribP3ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP2uiv.xml +func (gl *GL) VertexAttribP2uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl4_3core_glVertexAttribP2uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP2ui.xml +func (gl *GL) VertexAttribP2ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl4_3core_glVertexAttribP2ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP1uiv.xml +func (gl *GL) VertexAttribP1uiv(index glbase.Attrib, gltype glbase.Enum, normalized bool, value []uint32) { + C.gl4_3core_glVertexAttribP1uiv(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribP1ui.xml +func (gl *GL) VertexAttribP1ui(index glbase.Attrib, gltype glbase.Enum, normalized bool, value uint32) { + C.gl4_3core_glVertexAttribP1ui(gl.funcs, C.GLuint(index), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColorP3uiv.xml +func (gl *GL) SecondaryColorP3uiv(gltype glbase.Enum, color []uint32) { + C.gl4_3core_glSecondaryColorP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&color[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSecondaryColorP3ui.xml +func (gl *GL) SecondaryColorP3ui(gltype glbase.Enum, color uint32) { + C.gl4_3core_glSecondaryColorP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(color)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorP4uiv.xml +func (gl *GL) ColorP4uiv(gltype glbase.Enum, color []uint32) { + C.gl4_3core_glColorP4uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&color[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorP4ui.xml +func (gl *GL) ColorP4ui(gltype glbase.Enum, color uint32) { + C.gl4_3core_glColorP4ui(gl.funcs, C.GLenum(gltype), C.GLuint(color)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorP3uiv.xml +func (gl *GL) ColorP3uiv(gltype glbase.Enum, color []uint32) { + C.gl4_3core_glColorP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&color[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glColorP3ui.xml +func (gl *GL) ColorP3ui(gltype glbase.Enum, color uint32) { + C.gl4_3core_glColorP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(color)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormalP3uiv.xml +func (gl *GL) NormalP3uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_3core_glNormalP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glNormalP3ui.xml +func (gl *GL) NormalP3ui(gltype glbase.Enum, coords uint32) { + C.gl4_3core_glNormalP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP4uiv.xml +func (gl *GL) MultiTexCoordP4uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl4_3core_glMultiTexCoordP4uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP4ui.xml +func (gl *GL) MultiTexCoordP4ui(texture, gltype glbase.Enum, coords uint32) { + C.gl4_3core_glMultiTexCoordP4ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP3uiv.xml +func (gl *GL) MultiTexCoordP3uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl4_3core_glMultiTexCoordP3uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP3ui.xml +func (gl *GL) MultiTexCoordP3ui(texture, gltype glbase.Enum, coords uint32) { + C.gl4_3core_glMultiTexCoordP3ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP2uiv.xml +func (gl *GL) MultiTexCoordP2uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl4_3core_glMultiTexCoordP2uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP2ui.xml +func (gl *GL) MultiTexCoordP2ui(texture, gltype glbase.Enum, coords uint32) { + C.gl4_3core_glMultiTexCoordP2ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP1uiv.xml +func (gl *GL) MultiTexCoordP1uiv(texture, gltype glbase.Enum, coords []uint32) { + C.gl4_3core_glMultiTexCoordP1uiv(gl.funcs, C.GLenum(texture), C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiTexCoordP1ui.xml +func (gl *GL) MultiTexCoordP1ui(texture, gltype glbase.Enum, coords uint32) { + C.gl4_3core_glMultiTexCoordP1ui(gl.funcs, C.GLenum(texture), C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP4uiv.xml +func (gl *GL) TexCoordP4uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_3core_glTexCoordP4uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP4ui.xml +func (gl *GL) TexCoordP4ui(gltype glbase.Enum, coords uint32) { + C.gl4_3core_glTexCoordP4ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP3uiv.xml +func (gl *GL) TexCoordP3uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_3core_glTexCoordP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP3ui.xml +func (gl *GL) TexCoordP3ui(gltype glbase.Enum, coords uint32) { + C.gl4_3core_glTexCoordP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP2uiv.xml +func (gl *GL) TexCoordP2uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_3core_glTexCoordP2uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP2ui.xml +func (gl *GL) TexCoordP2ui(gltype glbase.Enum, coords uint32) { + C.gl4_3core_glTexCoordP2ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP1uiv.xml +func (gl *GL) TexCoordP1uiv(gltype glbase.Enum, coords []uint32) { + C.gl4_3core_glTexCoordP1uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&coords[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexCoordP1ui.xml +func (gl *GL) TexCoordP1ui(gltype glbase.Enum, coords uint32) { + C.gl4_3core_glTexCoordP1ui(gl.funcs, C.GLenum(gltype), C.GLuint(coords)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP4uiv.xml +func (gl *GL) VertexP4uiv(gltype glbase.Enum, value []uint32) { + C.gl4_3core_glVertexP4uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP4ui.xml +func (gl *GL) VertexP4ui(gltype glbase.Enum, value uint32) { + C.gl4_3core_glVertexP4ui(gl.funcs, C.GLenum(gltype), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP3uiv.xml +func (gl *GL) VertexP3uiv(gltype glbase.Enum, value []uint32) { + C.gl4_3core_glVertexP3uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP3ui.xml +func (gl *GL) VertexP3ui(gltype glbase.Enum, value uint32) { + C.gl4_3core_glVertexP3ui(gl.funcs, C.GLenum(gltype), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP2uiv.xml +func (gl *GL) VertexP2uiv(gltype glbase.Enum, value []uint32) { + C.gl4_3core_glVertexP2uiv(gl.funcs, C.GLenum(gltype), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexP2ui.xml +func (gl *GL) VertexP2ui(gltype glbase.Enum, value uint32) { + C.gl4_3core_glVertexP2ui(gl.funcs, C.GLenum(gltype), C.GLuint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryObjectui64v.xml +func (gl *GL) GetQueryObjectui64v(id uint32, pname glbase.Enum, params []uint64) { + C.gl4_3core_glGetQueryObjectui64v(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLuint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryObjecti64v.xml +func (gl *GL) GetQueryObjecti64v(id uint32, pname glbase.Enum, params []int64) { + C.gl4_3core_glGetQueryObjecti64v(gl.funcs, C.GLuint(id), C.GLenum(pname), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glQueryCounter.xml +func (gl *GL) QueryCounter(id uint32, target glbase.Enum) { + C.gl4_3core_glQueryCounter(gl.funcs, C.GLuint(id), C.GLenum(target)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSamplerParameterIuiv.xml +func (gl *GL) GetSamplerParameterIuiv(sampler uint32, pname glbase.Enum, params []uint32) { + C.gl4_3core_glGetSamplerParameterIuiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSamplerParameterfv.xml +func (gl *GL) GetSamplerParameterfv(sampler uint32, pname glbase.Enum, params []float32) { + C.gl4_3core_glGetSamplerParameterfv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSamplerParameterIiv.xml +func (gl *GL) GetSamplerParameterIiv(sampler uint32, pname glbase.Enum, params []int32) { + C.gl4_3core_glGetSamplerParameterIiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSamplerParameteriv.xml +func (gl *GL) GetSamplerParameteriv(sampler uint32, pname glbase.Enum, params []int32) { + C.gl4_3core_glGetSamplerParameteriv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameterIuiv.xml +func (gl *GL) SamplerParameterIuiv(sampler uint32, pname glbase.Enum, param []uint32) { + C.gl4_3core_glSamplerParameterIuiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLuint)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameterIiv.xml +func (gl *GL) SamplerParameterIiv(sampler uint32, pname glbase.Enum, param []int32) { + C.gl4_3core_glSamplerParameterIiv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameterfv.xml +func (gl *GL) SamplerParameterfv(sampler uint32, pname glbase.Enum, param []float32) { + C.gl4_3core_glSamplerParameterfv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameterf.xml +func (gl *GL) SamplerParameterf(sampler uint32, pname glbase.Enum, param float32) { + C.gl4_3core_glSamplerParameterf(gl.funcs, C.GLuint(sampler), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameteriv.xml +func (gl *GL) SamplerParameteriv(sampler uint32, pname glbase.Enum, param []int32) { + C.gl4_3core_glSamplerParameteriv(gl.funcs, C.GLuint(sampler), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶m[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glSamplerParameteri.xml +func (gl *GL) SamplerParameteri(sampler uint32, pname glbase.Enum, param int32) { + C.gl4_3core_glSamplerParameteri(gl.funcs, C.GLuint(sampler), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindSampler.xml +func (gl *GL) BindSampler(unit, sampler uint32) { + C.gl4_3core_glBindSampler(gl.funcs, C.GLuint(unit), C.GLuint(sampler)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsSampler.xml +func (gl *GL) IsSampler(sampler uint32) bool { + glresult := C.gl4_3core_glIsSampler(gl.funcs, C.GLuint(sampler)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteSamplers.xml +func (gl *GL) DeleteSamplers(count int, samplers []uint32) { + C.gl4_3core_glDeleteSamplers(gl.funcs, C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&samplers[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenSamplers.xml +func (gl *GL) GenSamplers(count int, samplers []uint32) { + C.gl4_3core_glGenSamplers(gl.funcs, C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&samplers[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFragDataIndex.xml +func (gl *GL) GetFragDataIndex(program glbase.Program, name []byte) int32 { + glresult := C.gl4_3core_glGetFragDataIndex(gl.funcs, C.GLuint(program), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindFragDataLocationIndexed.xml +func (gl *GL) BindFragDataLocationIndexed(program glbase.Program, colorNumber, index uint32, name []byte) { + C.gl4_3core_glBindFragDataLocationIndexed(gl.funcs, C.GLuint(program), C.GLuint(colorNumber), C.GLuint(index), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribDivisor.xml +func (gl *GL) VertexAttribDivisor(index glbase.Attrib, divisor uint32) { + C.gl4_3core_glVertexAttribDivisor(gl.funcs, C.GLuint(index), C.GLuint(divisor)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetQueryIndexediv.xml +func (gl *GL) GetQueryIndexediv(target glbase.Enum, index uint32, pname glbase.Enum, params []int32) { + C.gl4_3core_glGetQueryIndexediv(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glEndQueryIndexed.xml +func (gl *GL) EndQueryIndexed(target glbase.Enum, index uint32) { + C.gl4_3core_glEndQueryIndexed(gl.funcs, C.GLenum(target), C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBeginQueryIndexed.xml +func (gl *GL) BeginQueryIndexed(target glbase.Enum, index, id uint32) { + C.gl4_3core_glBeginQueryIndexed(gl.funcs, C.GLenum(target), C.GLuint(index), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawTransformFeedbackStream.xml +func (gl *GL) DrawTransformFeedbackStream(mode glbase.Enum, id, stream uint32) { + C.gl4_3core_glDrawTransformFeedbackStream(gl.funcs, C.GLenum(mode), C.GLuint(id), C.GLuint(stream)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawTransformFeedback.xml +func (gl *GL) DrawTransformFeedback(mode glbase.Enum, id uint32) { + C.gl4_3core_glDrawTransformFeedback(gl.funcs, C.GLenum(mode), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glResumeTransformFeedback.xml +func (gl *GL) ResumeTransformFeedback() { + C.gl4_3core_glResumeTransformFeedback(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPauseTransformFeedback.xml +func (gl *GL) PauseTransformFeedback() { + C.gl4_3core_glPauseTransformFeedback(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsTransformFeedback.xml +func (gl *GL) IsTransformFeedback(id uint32) bool { + glresult := C.gl4_3core_glIsTransformFeedback(gl.funcs, C.GLuint(id)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenTransformFeedbacks.xml +func (gl *GL) GenTransformFeedbacks(n int, ids []uint32) { + C.gl4_3core_glGenTransformFeedbacks(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteTransformFeedbacks.xml +func (gl *GL) DeleteTransformFeedbacks(n int, ids []uint32) { + C.gl4_3core_glDeleteTransformFeedbacks(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&ids[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindTransformFeedback.xml +func (gl *GL) BindTransformFeedback(target glbase.Enum, id uint32) { + C.gl4_3core_glBindTransformFeedback(gl.funcs, C.GLenum(target), C.GLuint(id)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPatchParameterfv.xml +func (gl *GL) PatchParameterfv(pname glbase.Enum, values []float32) { + C.gl4_3core_glPatchParameterfv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glPatchParameteri.xml +func (gl *GL) PatchParameteri(pname glbase.Enum, value int32) { + C.gl4_3core_glPatchParameteri(gl.funcs, C.GLenum(pname), C.GLint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramStageiv.xml +func (gl *GL) GetProgramStageiv(program glbase.Program, shadertype, pname glbase.Enum, values []int32) { + C.gl4_3core_glGetProgramStageiv(gl.funcs, C.GLuint(program), C.GLenum(shadertype), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetUniformSubroutineuiv.xml +func (gl *GL) GetUniformSubroutineuiv(shadertype glbase.Enum, location glbase.Uniform, params []uint32) { + C.gl4_3core_glGetUniformSubroutineuiv(gl.funcs, C.GLenum(shadertype), C.GLint(location), (*C.GLuint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformSubroutinesuiv.xml +func (gl *GL) UniformSubroutinesuiv(shadertype glbase.Enum, count int, value []uint32) { + C.gl4_3core_glUniformSubroutinesuiv(gl.funcs, C.GLenum(shadertype), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveSubroutineName.xml +func (gl *GL) GetActiveSubroutineName(program glbase.Program, shadertype glbase.Enum, index uint32, bufSize int32, length []int32, name []byte) { + C.gl4_3core_glGetActiveSubroutineName(gl.funcs, C.GLuint(program), C.GLenum(shadertype), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveSubroutineUniformName.xml +func (gl *GL) GetActiveSubroutineUniformName(program glbase.Program, shadertype glbase.Enum, index uint32, bufSize int32, length []int32, name []byte) { + C.gl4_3core_glGetActiveSubroutineUniformName(gl.funcs, C.GLuint(program), C.GLenum(shadertype), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveSubroutineUniformiv.xml +func (gl *GL) GetActiveSubroutineUniformiv(program glbase.Program, shadertype glbase.Enum, index uint32, pname glbase.Enum, values []int32) { + C.gl4_3core_glGetActiveSubroutineUniformiv(gl.funcs, C.GLuint(program), C.GLenum(shadertype), C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSubroutineIndex.xml +func (gl *GL) GetSubroutineIndex(program glbase.Program, shadertype glbase.Enum, name []byte) uint32 { + glresult := C.gl4_3core_glGetSubroutineIndex(gl.funcs, C.GLuint(program), C.GLenum(shadertype), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetSubroutineUniformLocation.xml +func (gl *GL) GetSubroutineUniformLocation(program glbase.Program, shadertype glbase.Enum, name []byte) int32 { + glresult := C.gl4_3core_glGetSubroutineUniformLocation(gl.funcs, C.GLuint(program), C.GLenum(shadertype), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetUniformdv.xml +func (gl *GL) GetUniformdv(program glbase.Program, location glbase.Uniform, params []float64) { + C.gl4_3core_glGetUniformdv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix4x3dv.xml +func (gl *GL) UniformMatrix4x3dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_3core_glUniformMatrix4x3dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix4x2dv.xml +func (gl *GL) UniformMatrix4x2dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_3core_glUniformMatrix4x2dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix3x4dv.xml +func (gl *GL) UniformMatrix3x4dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_3core_glUniformMatrix3x4dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix3x2dv.xml +func (gl *GL) UniformMatrix3x2dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_3core_glUniformMatrix3x2dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix2x4dv.xml +func (gl *GL) UniformMatrix2x4dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_3core_glUniformMatrix2x4dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix2x3dv.xml +func (gl *GL) UniformMatrix2x3dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_3core_glUniformMatrix2x3dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix4dv.xml +func (gl *GL) UniformMatrix4dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_3core_glUniformMatrix4dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix3dv.xml +func (gl *GL) UniformMatrix3dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_3core_glUniformMatrix3dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniformMatrix2dv.xml +func (gl *GL) UniformMatrix2dv(location glbase.Uniform, count int, transpose bool, value []float64) { + C.gl4_3core_glUniformMatrix2dv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform4dv.xml +func (gl *GL) Uniform4dv(location glbase.Uniform, count int, value []float64) { + C.gl4_3core_glUniform4dv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform3dv.xml +func (gl *GL) Uniform3dv(location glbase.Uniform, count int, value []float64) { + C.gl4_3core_glUniform3dv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform2dv.xml +func (gl *GL) Uniform2dv(location glbase.Uniform, count int, value []float64) { + C.gl4_3core_glUniform2dv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform1dv.xml +func (gl *GL) Uniform1dv(location glbase.Uniform, count int, value []float64) { + C.gl4_3core_glUniform1dv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform4d.xml +func (gl *GL) Uniform4d(location glbase.Uniform, v0, v1, v2, v3 float64) { + C.gl4_3core_glUniform4d(gl.funcs, C.GLint(location), C.GLdouble(v0), C.GLdouble(v1), C.GLdouble(v2), C.GLdouble(v3)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform3d.xml +func (gl *GL) Uniform3d(location glbase.Uniform, v0, v1, v2 float64) { + C.gl4_3core_glUniform3d(gl.funcs, C.GLint(location), C.GLdouble(v0), C.GLdouble(v1), C.GLdouble(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform2d.xml +func (gl *GL) Uniform2d(location glbase.Uniform, v0, v1 float64) { + C.gl4_3core_glUniform2d(gl.funcs, C.GLint(location), C.GLdouble(v0), C.GLdouble(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUniform1d.xml +func (gl *GL) Uniform1d(location glbase.Uniform, v0 float64) { + C.gl4_3core_glUniform1d(gl.funcs, C.GLint(location), C.GLdouble(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsIndirect.xml +func (gl *GL) DrawElementsIndirect(mode, gltype glbase.Enum, indirect interface{}) { + var indirect_ptr unsafe.Pointer + var indirect_v = reflect.ValueOf(indirect) + if indirect != nil && indirect_v.Kind() != reflect.Slice { + panic("parameter indirect must be a slice") + } + if indirect != nil { + indirect_ptr = unsafe.Pointer(indirect_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glDrawElementsIndirect(gl.funcs, C.GLenum(mode), C.GLenum(gltype), indirect_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawArraysIndirect.xml +func (gl *GL) DrawArraysIndirect(mode glbase.Enum, indirect interface{}) { + var indirect_ptr unsafe.Pointer + var indirect_v = reflect.ValueOf(indirect) + if indirect != nil && indirect_v.Kind() != reflect.Slice { + panic("parameter indirect must be a slice") + } + if indirect != nil { + indirect_ptr = unsafe.Pointer(indirect_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glDrawArraysIndirect(gl.funcs, C.GLenum(mode), indirect_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFuncSeparatei.xml +func (gl *GL) BlendFuncSeparatei(buf uint32, srcRGB, dstRGB, srcAlpha, dstAlpha glbase.Enum) { + C.gl4_3core_glBlendFuncSeparatei(gl.funcs, C.GLuint(buf), C.GLenum(srcRGB), C.GLenum(dstRGB), C.GLenum(srcAlpha), C.GLenum(dstAlpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFunci.xml +func (gl *GL) BlendFunci(buf uint32, src, dst glbase.Enum) { + C.gl4_3core_glBlendFunci(gl.funcs, C.GLuint(buf), C.GLenum(src), C.GLenum(dst)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendEquationSeparatei.xml +func (gl *GL) BlendEquationSeparatei(buf uint32, modeRGB, modeAlpha glbase.Enum) { + C.gl4_3core_glBlendEquationSeparatei(gl.funcs, C.GLuint(buf), C.GLenum(modeRGB), C.GLenum(modeAlpha)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBlendEquationi.xml +func (gl *GL) BlendEquationi(buf uint32, mode glbase.Enum) { + C.gl4_3core_glBlendEquationi(gl.funcs, C.GLuint(buf), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMinSampleShading.xml +func (gl *GL) MinSampleShading(value float32) { + C.gl4_3core_glMinSampleShading(gl.funcs, C.GLfloat(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetDoublei_v.xml +func (gl *GL) GetDoublei_v(target glbase.Enum, index uint32, data []float64) { + C.gl4_3core_glGetDoublei_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFloati_v.xml +func (gl *GL) GetFloati_v(target glbase.Enum, index uint32, data []float32) { + C.gl4_3core_glGetFloati_v(gl.funcs, C.GLenum(target), C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&data[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDepthRangeIndexed.xml +func (gl *GL) DepthRangeIndexed(index uint32, n, f float64) { + C.gl4_3core_glDepthRangeIndexed(gl.funcs, C.GLuint(index), C.GLdouble(n), C.GLdouble(f)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDepthRangeArrayv.xml +func (gl *GL) DepthRangeArrayv(first uint32, count int, v []float64) { + C.gl4_3core_glDepthRangeArrayv(gl.funcs, C.GLuint(first), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glScissorIndexedv.xml +func (gl *GL) ScissorIndexedv(index uint32, v []int32) { + C.gl4_3core_glScissorIndexedv(gl.funcs, C.GLuint(index), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glScissorIndexed.xml +func (gl *GL) ScissorIndexed(index uint32, left, bottom int32, width, height int) { + C.gl4_3core_glScissorIndexed(gl.funcs, C.GLuint(index), C.GLint(left), C.GLint(bottom), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glScissorArrayv.xml +func (gl *GL) ScissorArrayv(first uint32, count int, v []int32) { + C.gl4_3core_glScissorArrayv(gl.funcs, C.GLuint(first), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glViewportIndexedfv.xml +func (gl *GL) ViewportIndexedfv(index uint32, v []float32) { + C.gl4_3core_glViewportIndexedfv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glViewportIndexedf.xml +func (gl *GL) ViewportIndexedf(index uint32, x, y, w, h float32) { + C.gl4_3core_glViewportIndexedf(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y), C.GLfloat(w), C.GLfloat(h)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glViewportArrayv.xml +func (gl *GL) ViewportArrayv(first uint32, count int, v []float32) { + C.gl4_3core_glViewportArrayv(gl.funcs, C.GLuint(first), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetVertexAttribLdv.xml +func (gl *GL) GetVertexAttribLdv(index glbase.Attrib, pname glbase.Enum, params []float64) { + C.gl4_3core_glGetVertexAttribLdv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLdouble)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribLPointer.xml +func (gl *GL) VertexAttribLPointer(index glbase.Attrib, size int, gltype glbase.Enum, stride int, pointer interface{}) { + var pointer_ptr unsafe.Pointer + var pointer_v = reflect.ValueOf(pointer) + if pointer != nil && pointer_v.Kind() != reflect.Slice { + panic("parameter pointer must be a slice") + } + if pointer != nil { + pointer_ptr = unsafe.Pointer(pointer_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glVertexAttribLPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), C.GLsizei(stride), pointer_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL4dv.xml +func (gl *GL) VertexAttribL4dv(index glbase.Attrib, v []float64) { + if len(v) != 4 { + panic("parameter v has incorrect length") + } + C.gl4_3core_glVertexAttribL4dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL3dv.xml +func (gl *GL) VertexAttribL3dv(index glbase.Attrib, v []float64) { + if len(v) != 3 { + panic("parameter v has incorrect length") + } + C.gl4_3core_glVertexAttribL3dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL2dv.xml +func (gl *GL) VertexAttribL2dv(index glbase.Attrib, v []float64) { + if len(v) != 2 { + panic("parameter v has incorrect length") + } + C.gl4_3core_glVertexAttribL2dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL1dv.xml +func (gl *GL) VertexAttribL1dv(index glbase.Attrib, v []float64) { + C.gl4_3core_glVertexAttribL1dv(gl.funcs, C.GLuint(index), (*C.GLdouble)(unsafe.Pointer(&v[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL4d.xml +func (gl *GL) VertexAttribL4d(index glbase.Attrib, x, y, z, w float64) { + C.gl4_3core_glVertexAttribL4d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z), C.GLdouble(w)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL3d.xml +func (gl *GL) VertexAttribL3d(index glbase.Attrib, x, y, z float64) { + C.gl4_3core_glVertexAttribL3d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y), C.GLdouble(z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL2d.xml +func (gl *GL) VertexAttribL2d(index glbase.Attrib, x, y float64) { + C.gl4_3core_glVertexAttribL2d(gl.funcs, C.GLuint(index), C.GLdouble(x), C.GLdouble(y)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribL1d.xml +func (gl *GL) VertexAttribL1d(index glbase.Attrib, x float64) { + C.gl4_3core_glVertexAttribL1d(gl.funcs, C.GLuint(index), C.GLdouble(x)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramPipelineInfoLog.xml +func (gl *GL) GetProgramPipelineInfoLog(pipeline uint32, bufSize int32, length []int32, infoLog []byte) { + C.gl4_3core_glGetProgramPipelineInfoLog(gl.funcs, C.GLuint(pipeline), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glValidateProgramPipeline.xml +func (gl *GL) ValidateProgramPipeline(pipeline uint32) { + C.gl4_3core_glValidateProgramPipeline(gl.funcs, C.GLuint(pipeline)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4x3dv.xml +func (gl *GL) ProgramUniformMatrix4x3dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_3core_glProgramUniformMatrix4x3dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3x4dv.xml +func (gl *GL) ProgramUniformMatrix3x4dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_3core_glProgramUniformMatrix3x4dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4x2dv.xml +func (gl *GL) ProgramUniformMatrix4x2dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_3core_glProgramUniformMatrix4x2dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2x4dv.xml +func (gl *GL) ProgramUniformMatrix2x4dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_3core_glProgramUniformMatrix2x4dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3x2dv.xml +func (gl *GL) ProgramUniformMatrix3x2dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_3core_glProgramUniformMatrix3x2dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2x3dv.xml +func (gl *GL) ProgramUniformMatrix2x3dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_3core_glProgramUniformMatrix2x3dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4x3fv.xml +func (gl *GL) ProgramUniformMatrix4x3fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_3core_glProgramUniformMatrix4x3fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3x4fv.xml +func (gl *GL) ProgramUniformMatrix3x4fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_3core_glProgramUniformMatrix3x4fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4x2fv.xml +func (gl *GL) ProgramUniformMatrix4x2fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_3core_glProgramUniformMatrix4x2fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2x4fv.xml +func (gl *GL) ProgramUniformMatrix2x4fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_3core_glProgramUniformMatrix2x4fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3x2fv.xml +func (gl *GL) ProgramUniformMatrix3x2fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_3core_glProgramUniformMatrix3x2fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2x3fv.xml +func (gl *GL) ProgramUniformMatrix2x3fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_3core_glProgramUniformMatrix2x3fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4dv.xml +func (gl *GL) ProgramUniformMatrix4dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_3core_glProgramUniformMatrix4dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3dv.xml +func (gl *GL) ProgramUniformMatrix3dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_3core_glProgramUniformMatrix3dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2dv.xml +func (gl *GL) ProgramUniformMatrix2dv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float64) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_3core_glProgramUniformMatrix2dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix4fv.xml +func (gl *GL) ProgramUniformMatrix4fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_3core_glProgramUniformMatrix4fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix3fv.xml +func (gl *GL) ProgramUniformMatrix3fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_3core_glProgramUniformMatrix3fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniformMatrix2fv.xml +func (gl *GL) ProgramUniformMatrix2fv(program glbase.Program, location glbase.Uniform, count int, transpose bool, value []float32) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_3core_glProgramUniformMatrix2fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4uiv.xml +func (gl *GL) ProgramUniform4uiv(program glbase.Program, location glbase.Uniform, count int, value []uint32) { + C.gl4_3core_glProgramUniform4uiv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4ui.xml +func (gl *GL) ProgramUniform4ui(program glbase.Program, location glbase.Uniform, v0, v1, v2, v3 uint32) { + C.gl4_3core_glProgramUniform4ui(gl.funcs, C.GLuint(program), C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2), C.GLuint(v3)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4dv.xml +func (gl *GL) ProgramUniform4dv(program glbase.Program, location glbase.Uniform, count int, value []float64) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_3core_glProgramUniform4dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4d.xml +func (gl *GL) ProgramUniform4d(program glbase.Program, location glbase.Uniform, v0, v1, v2, v3 float64) { + C.gl4_3core_glProgramUniform4d(gl.funcs, C.GLuint(program), C.GLint(location), C.GLdouble(v0), C.GLdouble(v1), C.GLdouble(v2), C.GLdouble(v3)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4fv.xml +func (gl *GL) ProgramUniform4fv(program glbase.Program, location glbase.Uniform, count int, value []float32) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_3core_glProgramUniform4fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4f.xml +func (gl *GL) ProgramUniform4f(program glbase.Program, location glbase.Uniform, v0, v1, v2, v3 float32) { + C.gl4_3core_glProgramUniform4f(gl.funcs, C.GLuint(program), C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2), C.GLfloat(v3)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4iv.xml +func (gl *GL) ProgramUniform4iv(program glbase.Program, location glbase.Uniform, count int, value []int32) { + if len(value) != 4 { + panic("parameter value has incorrect length") + } + C.gl4_3core_glProgramUniform4iv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform4i.xml +func (gl *GL) ProgramUniform4i(program glbase.Program, location glbase.Uniform, v0, v1, v2, v3 int32) { + C.gl4_3core_glProgramUniform4i(gl.funcs, C.GLuint(program), C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2), C.GLint(v3)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3uiv.xml +func (gl *GL) ProgramUniform3uiv(program glbase.Program, location glbase.Uniform, count int, value []uint32) { + C.gl4_3core_glProgramUniform3uiv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3ui.xml +func (gl *GL) ProgramUniform3ui(program glbase.Program, location glbase.Uniform, v0, v1, v2 uint32) { + C.gl4_3core_glProgramUniform3ui(gl.funcs, C.GLuint(program), C.GLint(location), C.GLuint(v0), C.GLuint(v1), C.GLuint(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3dv.xml +func (gl *GL) ProgramUniform3dv(program glbase.Program, location glbase.Uniform, count int, value []float64) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_3core_glProgramUniform3dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3d.xml +func (gl *GL) ProgramUniform3d(program glbase.Program, location glbase.Uniform, v0, v1, v2 float64) { + C.gl4_3core_glProgramUniform3d(gl.funcs, C.GLuint(program), C.GLint(location), C.GLdouble(v0), C.GLdouble(v1), C.GLdouble(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3fv.xml +func (gl *GL) ProgramUniform3fv(program glbase.Program, location glbase.Uniform, count int, value []float32) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_3core_glProgramUniform3fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3f.xml +func (gl *GL) ProgramUniform3f(program glbase.Program, location glbase.Uniform, v0, v1, v2 float32) { + C.gl4_3core_glProgramUniform3f(gl.funcs, C.GLuint(program), C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3iv.xml +func (gl *GL) ProgramUniform3iv(program glbase.Program, location glbase.Uniform, count int, value []int32) { + if len(value) != 3 { + panic("parameter value has incorrect length") + } + C.gl4_3core_glProgramUniform3iv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform3i.xml +func (gl *GL) ProgramUniform3i(program glbase.Program, location glbase.Uniform, v0, v1, v2 int32) { + C.gl4_3core_glProgramUniform3i(gl.funcs, C.GLuint(program), C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2uiv.xml +func (gl *GL) ProgramUniform2uiv(program glbase.Program, location glbase.Uniform, count int, value []uint32) { + C.gl4_3core_glProgramUniform2uiv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2ui.xml +func (gl *GL) ProgramUniform2ui(program glbase.Program, location glbase.Uniform, v0, v1 uint32) { + C.gl4_3core_glProgramUniform2ui(gl.funcs, C.GLuint(program), C.GLint(location), C.GLuint(v0), C.GLuint(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2dv.xml +func (gl *GL) ProgramUniform2dv(program glbase.Program, location glbase.Uniform, count int, value []float64) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_3core_glProgramUniform2dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2d.xml +func (gl *GL) ProgramUniform2d(program glbase.Program, location glbase.Uniform, v0, v1 float64) { + C.gl4_3core_glProgramUniform2d(gl.funcs, C.GLuint(program), C.GLint(location), C.GLdouble(v0), C.GLdouble(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2fv.xml +func (gl *GL) ProgramUniform2fv(program glbase.Program, location glbase.Uniform, count int, value []float32) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_3core_glProgramUniform2fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2f.xml +func (gl *GL) ProgramUniform2f(program glbase.Program, location glbase.Uniform, v0, v1 float32) { + C.gl4_3core_glProgramUniform2f(gl.funcs, C.GLuint(program), C.GLint(location), C.GLfloat(v0), C.GLfloat(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2iv.xml +func (gl *GL) ProgramUniform2iv(program glbase.Program, location glbase.Uniform, count int, value []int32) { + if len(value) != 2 { + panic("parameter value has incorrect length") + } + C.gl4_3core_glProgramUniform2iv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform2i.xml +func (gl *GL) ProgramUniform2i(program glbase.Program, location glbase.Uniform, v0, v1 int32) { + C.gl4_3core_glProgramUniform2i(gl.funcs, C.GLuint(program), C.GLint(location), C.GLint(v0), C.GLint(v1)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1uiv.xml +func (gl *GL) ProgramUniform1uiv(program glbase.Program, location glbase.Uniform, count int, value []uint32) { + C.gl4_3core_glProgramUniform1uiv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1ui.xml +func (gl *GL) ProgramUniform1ui(program glbase.Program, location glbase.Uniform, v0 uint32) { + C.gl4_3core_glProgramUniform1ui(gl.funcs, C.GLuint(program), C.GLint(location), C.GLuint(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1dv.xml +func (gl *GL) ProgramUniform1dv(program glbase.Program, location glbase.Uniform, count int, value []float64) { + C.gl4_3core_glProgramUniform1dv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLdouble)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1d.xml +func (gl *GL) ProgramUniform1d(program glbase.Program, location glbase.Uniform, v0 float64) { + C.gl4_3core_glProgramUniform1d(gl.funcs, C.GLuint(program), C.GLint(location), C.GLdouble(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1fv.xml +func (gl *GL) ProgramUniform1fv(program glbase.Program, location glbase.Uniform, count int, value []float32) { + C.gl4_3core_glProgramUniform1fv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1f.xml +func (gl *GL) ProgramUniform1f(program glbase.Program, location glbase.Uniform, v0 float32) { + C.gl4_3core_glProgramUniform1f(gl.funcs, C.GLuint(program), C.GLint(location), C.GLfloat(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1iv.xml +func (gl *GL) ProgramUniform1iv(program glbase.Program, location glbase.Uniform, count int, value []int32) { + C.gl4_3core_glProgramUniform1iv(gl.funcs, C.GLuint(program), C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramUniform1i.xml +func (gl *GL) ProgramUniform1i(program glbase.Program, location glbase.Uniform, v0 int32) { + C.gl4_3core_glProgramUniform1i(gl.funcs, C.GLuint(program), C.GLint(location), C.GLint(v0)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramPipelineiv.xml +func (gl *GL) GetProgramPipelineiv(pipeline uint32, pname glbase.Enum, params []int32) { + C.gl4_3core_glGetProgramPipelineiv(gl.funcs, C.GLuint(pipeline), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glIsProgramPipeline.xml +func (gl *GL) IsProgramPipeline(pipeline uint32) bool { + glresult := C.gl4_3core_glIsProgramPipeline(gl.funcs, C.GLuint(pipeline)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGenProgramPipelines.xml +func (gl *GL) GenProgramPipelines(n int, pipelines []uint32) { + C.gl4_3core_glGenProgramPipelines(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&pipelines[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDeleteProgramPipelines.xml +func (gl *GL) DeleteProgramPipelines(n int, pipelines []uint32) { + C.gl4_3core_glDeleteProgramPipelines(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&pipelines[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindProgramPipeline.xml +func (gl *GL) BindProgramPipeline(pipeline uint32) { + C.gl4_3core_glBindProgramPipeline(gl.funcs, C.GLuint(pipeline)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glActiveShaderProgram.xml +func (gl *GL) ActiveShaderProgram(pipeline uint32, program glbase.Program) { + C.gl4_3core_glActiveShaderProgram(gl.funcs, C.GLuint(pipeline), C.GLuint(program)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glUseProgramStages.xml +func (gl *GL) UseProgramStages(pipeline uint32, stages glbase.Bitfield, program glbase.Program) { + C.gl4_3core_glUseProgramStages(gl.funcs, C.GLuint(pipeline), C.GLbitfield(stages), C.GLuint(program)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramParameteri.xml +func (gl *GL) ProgramParameteri(program glbase.Program, pname glbase.Enum, value int32) { + C.gl4_3core_glProgramParameteri(gl.funcs, C.GLuint(program), C.GLenum(pname), C.GLint(value)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glProgramBinary.xml +func (gl *GL) ProgramBinary(program glbase.Program, binaryFormat glbase.Enum, binary interface{}, length int32) { + var binary_ptr unsafe.Pointer + var binary_v = reflect.ValueOf(binary) + if binary != nil && binary_v.Kind() != reflect.Slice { + panic("parameter binary must be a slice") + } + if binary != nil { + binary_ptr = unsafe.Pointer(binary_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glProgramBinary(gl.funcs, C.GLuint(program), C.GLenum(binaryFormat), binary_ptr, C.GLsizei(length)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramBinary.xml +func (gl *GL) GetProgramBinary(program glbase.Program, bufSize int32, length []int32, binaryFormat []glbase.Enum, binary interface{}) { + var binary_ptr unsafe.Pointer + var binary_v = reflect.ValueOf(binary) + if binary != nil && binary_v.Kind() != reflect.Slice { + panic("parameter binary must be a slice") + } + if binary != nil { + binary_ptr = unsafe.Pointer(binary_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glGetProgramBinary(gl.funcs, C.GLuint(program), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLenum)(unsafe.Pointer(&binaryFormat[0])), binary_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearDepthf.xml +func (gl *GL) ClearDepthf(dd float32) { + C.gl4_3core_glClearDepthf(gl.funcs, C.GLfloat(dd)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDepthRangef.xml +func (gl *GL) DepthRangef(n, f float32) { + C.gl4_3core_glDepthRangef(gl.funcs, C.GLfloat(n), C.GLfloat(f)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetShaderPrecisionFormat.xml +func (gl *GL) GetShaderPrecisionFormat(shadertype, precisionType glbase.Enum, range_, precision []int32) { + C.gl4_3core_glGetShaderPrecisionFormat(gl.funcs, C.GLenum(shadertype), C.GLenum(precisionType), (*C.GLint)(unsafe.Pointer(&range_[0])), (*C.GLint)(unsafe.Pointer(&precision[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glShaderBinary.xml +func (gl *GL) ShaderBinary(count int, shaders []glbase.Shader, binaryFormat glbase.Enum, binary interface{}, length int32) { + var binary_ptr unsafe.Pointer + var binary_v = reflect.ValueOf(binary) + if binary != nil && binary_v.Kind() != reflect.Slice { + panic("parameter binary must be a slice") + } + if binary != nil { + binary_ptr = unsafe.Pointer(binary_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glShaderBinary(gl.funcs, C.GLsizei(count), (*C.GLuint)(unsafe.Pointer(&shaders[0])), C.GLenum(binaryFormat), binary_ptr, C.GLsizei(length)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glReleaseShaderCompiler.xml +func (gl *GL) ReleaseShaderCompiler() { + C.gl4_3core_glReleaseShaderCompiler(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexStorage3D.xml +func (gl *GL) TexStorage3D(target glbase.Enum, levels int32, internalFormat glbase.Enum, width, height int, depth int32) { + C.gl4_3core_glTexStorage3D(gl.funcs, C.GLenum(target), C.GLsizei(levels), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexStorage2D.xml +func (gl *GL) TexStorage2D(target glbase.Enum, levels int32, internalFormat glbase.Enum, width, height int) { + C.gl4_3core_glTexStorage2D(gl.funcs, C.GLenum(target), C.GLsizei(levels), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexStorage1D.xml +func (gl *GL) TexStorage1D(target glbase.Enum, levels int32, internalFormat glbase.Enum, width int) { + C.gl4_3core_glTexStorage1D(gl.funcs, C.GLenum(target), C.GLsizei(levels), C.GLenum(internalFormat), C.GLsizei(width)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMemoryBarrier.xml +func (gl *GL) MemoryBarrier(barriers glbase.Bitfield) { + C.gl4_3core_glMemoryBarrier(gl.funcs, C.GLbitfield(barriers)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindImageTexture.xml +func (gl *GL) BindImageTexture(unit uint32, texture glbase.Texture, level int, layered bool, layer int32, access, format glbase.Enum) { + C.gl4_3core_glBindImageTexture(gl.funcs, C.GLuint(unit), C.GLuint(texture), C.GLint(level), *(*C.GLboolean)(unsafe.Pointer(&layered)), C.GLint(layer), C.GLenum(access), C.GLenum(format)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetActiveAtomicCounterBufferiv.xml +func (gl *GL) GetActiveAtomicCounterBufferiv(program glbase.Program, bufferIndex uint32, pname glbase.Enum, params []int32) { + C.gl4_3core_glGetActiveAtomicCounterBufferiv(gl.funcs, C.GLuint(program), C.GLuint(bufferIndex), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetInternalformativ.xml +func (gl *GL) GetInternalformativ(target, internalFormat, pname glbase.Enum, bufSize int32, params []int32) { + C.gl4_3core_glGetInternalformativ(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLenum(pname), C.GLsizei(bufSize), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawTransformFeedbackStreamInstanced.xml +func (gl *GL) DrawTransformFeedbackStreamInstanced(mode glbase.Enum, id, stream uint32, instancecount int32) { + C.gl4_3core_glDrawTransformFeedbackStreamInstanced(gl.funcs, C.GLenum(mode), C.GLuint(id), C.GLuint(stream), C.GLsizei(instancecount)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawTransformFeedbackInstanced.xml +func (gl *GL) DrawTransformFeedbackInstanced(mode glbase.Enum, id uint32, instancecount int32) { + C.gl4_3core_glDrawTransformFeedbackInstanced(gl.funcs, C.GLenum(mode), C.GLuint(id), C.GLsizei(instancecount)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsInstancedBaseVertexBaseInstance.xml +func (gl *GL) DrawElementsInstancedBaseVertexBaseInstance(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, instancecount, basevertex int32, baseinstance uint32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glDrawElementsInstancedBaseVertexBaseInstance(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLsizei(instancecount), C.GLint(basevertex), C.GLuint(baseinstance)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawElementsInstancedBaseInstance.xml +func (gl *GL) DrawElementsInstancedBaseInstance(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}, instancecount int32, baseinstance uint32) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glDrawElementsInstancedBaseInstance(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr, C.GLsizei(instancecount), C.GLuint(baseinstance)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDrawArraysInstancedBaseInstance.xml +func (gl *GL) DrawArraysInstancedBaseInstance(mode glbase.Enum, first, count int, instancecount int32, baseinstance uint32) { + C.gl4_3core_glDrawArraysInstancedBaseInstance(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count), C.GLsizei(instancecount), C.GLuint(baseinstance)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexStorage3DMultisample.xml +func (gl *GL) TexStorage3DMultisample(target glbase.Enum, samples int32, internalFormat glbase.Enum, width, height int, depth int32, fixedsamplelocations bool) { + C.gl4_3core_glTexStorage3DMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth), *(*C.GLboolean)(unsafe.Pointer(&fixedsamplelocations))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexStorage2DMultisample.xml +func (gl *GL) TexStorage2DMultisample(target glbase.Enum, samples int32, internalFormat glbase.Enum, width, height int, fixedsamplelocations bool) { + C.gl4_3core_glTexStorage2DMultisample(gl.funcs, C.GLenum(target), C.GLsizei(samples), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), *(*C.GLboolean)(unsafe.Pointer(&fixedsamplelocations))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTexBufferRange.xml +func (gl *GL) TexBufferRange(target, internalFormat glbase.Enum, buffer glbase.Buffer, offset, size int) { + C.gl4_3core_glTexBufferRange(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLuint(buffer), C.GLintptr(offset), C.GLsizeiptr(size)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glShaderStorageBlockBinding.xml +func (gl *GL) ShaderStorageBlockBinding(program glbase.Program, storageBlockIndex, storageBlockBinding uint32) { + C.gl4_3core_glShaderStorageBlockBinding(gl.funcs, C.GLuint(program), C.GLuint(storageBlockIndex), C.GLuint(storageBlockBinding)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramResourceLocationIndex.xml +func (gl *GL) GetProgramResourceLocationIndex(program glbase.Program, programInterface glbase.Enum, name []byte) int32 { + glresult := C.gl4_3core_glGetProgramResourceLocationIndex(gl.funcs, C.GLuint(program), C.GLenum(programInterface), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramResourceLocation.xml +func (gl *GL) GetProgramResourceLocation(program glbase.Program, programInterface glbase.Enum, name []byte) int32 { + glresult := C.gl4_3core_glGetProgramResourceLocation(gl.funcs, C.GLuint(program), C.GLenum(programInterface), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return int32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramResourceiv.xml +func (gl *GL) GetProgramResourceiv(program glbase.Program, programInterface glbase.Enum, index uint32, propCount int32, props []glbase.Enum, bufSize int32, length, params []int32) { + C.gl4_3core_glGetProgramResourceiv(gl.funcs, C.GLuint(program), C.GLenum(programInterface), C.GLuint(index), C.GLsizei(propCount), (*C.GLenum)(unsafe.Pointer(&props[0])), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramResourceName.xml +func (gl *GL) GetProgramResourceName(program glbase.Program, programInterface glbase.Enum, index uint32, bufSize int32, length []int32, name []byte) { + C.gl4_3core_glGetProgramResourceName(gl.funcs, C.GLuint(program), C.GLenum(programInterface), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramResourceIndex.xml +func (gl *GL) GetProgramResourceIndex(program glbase.Program, programInterface glbase.Enum, name []byte) uint32 { + glresult := C.gl4_3core_glGetProgramResourceIndex(gl.funcs, C.GLuint(program), C.GLenum(programInterface), (*C.GLchar)(unsafe.Pointer(&name[0]))) + return uint32(glresult) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetProgramInterfaceiv.xml +func (gl *GL) GetProgramInterfaceiv(program glbase.Program, programInterface, pname glbase.Enum, params []int32) { + C.gl4_3core_glGetProgramInterfaceiv(gl.funcs, C.GLuint(program), C.GLenum(programInterface), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiDrawElementsIndirect.xml +func (gl *GL) MultiDrawElementsIndirect(mode, gltype glbase.Enum, indirect interface{}, drawcount int32, stride int) { + var indirect_ptr unsafe.Pointer + var indirect_v = reflect.ValueOf(indirect) + if indirect != nil && indirect_v.Kind() != reflect.Slice { + panic("parameter indirect must be a slice") + } + if indirect != nil { + indirect_ptr = unsafe.Pointer(indirect_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glMultiDrawElementsIndirect(gl.funcs, C.GLenum(mode), C.GLenum(gltype), indirect_ptr, C.GLsizei(drawcount), C.GLsizei(stride)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glMultiDrawArraysIndirect.xml +func (gl *GL) MultiDrawArraysIndirect(mode glbase.Enum, indirect interface{}, drawcount int32, stride int) { + var indirect_ptr unsafe.Pointer + var indirect_v = reflect.ValueOf(indirect) + if indirect != nil && indirect_v.Kind() != reflect.Slice { + panic("parameter indirect must be a slice") + } + if indirect != nil { + indirect_ptr = unsafe.Pointer(indirect_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glMultiDrawArraysIndirect(gl.funcs, C.GLenum(mode), indirect_ptr, C.GLsizei(drawcount), C.GLsizei(stride)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glInvalidateSubFramebuffer.xml +func (gl *GL) InvalidateSubFramebuffer(target glbase.Enum, numAttachments int32, attachments []glbase.Enum, x, y, width, height int) { + C.gl4_3core_glInvalidateSubFramebuffer(gl.funcs, C.GLenum(target), C.GLsizei(numAttachments), (*C.GLenum)(unsafe.Pointer(&attachments[0])), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glInvalidateFramebuffer.xml +func (gl *GL) InvalidateFramebuffer(target glbase.Enum, numAttachments int32, attachments []glbase.Enum) { + C.gl4_3core_glInvalidateFramebuffer(gl.funcs, C.GLenum(target), C.GLsizei(numAttachments), (*C.GLenum)(unsafe.Pointer(&attachments[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glInvalidateBufferData.xml +func (gl *GL) InvalidateBufferData(buffer glbase.Buffer) { + C.gl4_3core_glInvalidateBufferData(gl.funcs, C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glInvalidateBufferSubData.xml +func (gl *GL) InvalidateBufferSubData(buffer glbase.Buffer, offset, length int) { + C.gl4_3core_glInvalidateBufferSubData(gl.funcs, C.GLuint(buffer), C.GLintptr(offset), C.GLsizeiptr(length)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glInvalidateTexImage.xml +func (gl *GL) InvalidateTexImage(texture glbase.Texture, level int) { + C.gl4_3core_glInvalidateTexImage(gl.funcs, C.GLuint(texture), C.GLint(level)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glInvalidateTexSubImage.xml +func (gl *GL) InvalidateTexSubImage(texture glbase.Texture, level, xoffset, yoffset int, zoffset int32, width, height int, depth int32) { + C.gl4_3core_glInvalidateTexSubImage(gl.funcs, C.GLuint(texture), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(zoffset), C.GLsizei(width), C.GLsizei(height), C.GLsizei(depth)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetInternalformati64v.xml +func (gl *GL) GetInternalformati64v(target, internalFormat, pname glbase.Enum, bufSize int32, params []int64) { + C.gl4_3core_glGetInternalformati64v(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLenum(pname), C.GLsizei(bufSize), (*C.GLint64)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glGetFramebufferParameteriv.xml +func (gl *GL) GetFramebufferParameteriv(target, pname glbase.Enum, params []int32) { + C.gl4_3core_glGetFramebufferParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glFramebufferParameteri.xml +func (gl *GL) FramebufferParameteri(target, pname glbase.Enum, param int32) { + C.gl4_3core_glFramebufferParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexBindingDivisor.xml +func (gl *GL) VertexBindingDivisor(bindingindex, divisor uint32) { + C.gl4_3core_glVertexBindingDivisor(gl.funcs, C.GLuint(bindingindex), C.GLuint(divisor)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribBinding.xml +func (gl *GL) VertexAttribBinding(attribindex, bindingindex uint32) { + C.gl4_3core_glVertexAttribBinding(gl.funcs, C.GLuint(attribindex), C.GLuint(bindingindex)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribLFormat.xml +func (gl *GL) VertexAttribLFormat(attribindex uint32, size int, gltype glbase.Enum, relativeoffset uint32) { + C.gl4_3core_glVertexAttribLFormat(gl.funcs, C.GLuint(attribindex), C.GLint(size), C.GLenum(gltype), C.GLuint(relativeoffset)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribIFormat.xml +func (gl *GL) VertexAttribIFormat(attribindex uint32, size int, gltype glbase.Enum, relativeoffset uint32) { + C.gl4_3core_glVertexAttribIFormat(gl.funcs, C.GLuint(attribindex), C.GLint(size), C.GLenum(gltype), C.GLuint(relativeoffset)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glVertexAttribFormat.xml +func (gl *GL) VertexAttribFormat(attribindex uint32, size int, gltype glbase.Enum, normalized bool, relativeoffset uint32) { + C.gl4_3core_glVertexAttribFormat(gl.funcs, C.GLuint(attribindex), C.GLint(size), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLuint(relativeoffset)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glBindVertexBuffer.xml +func (gl *GL) BindVertexBuffer(bindingindex uint32, buffer glbase.Buffer, offset, stride int) { + C.gl4_3core_glBindVertexBuffer(gl.funcs, C.GLuint(bindingindex), C.GLuint(buffer), C.GLintptr(offset), C.GLsizei(stride)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glTextureView.xml +func (gl *GL) TextureView(texture glbase.Texture, target glbase.Enum, origtexture uint32, internalFormat glbase.Enum, minlevel, numlevels, minlayer, numlayers uint32) { + C.gl4_3core_glTextureView(gl.funcs, C.GLuint(texture), C.GLenum(target), C.GLuint(origtexture), C.GLenum(internalFormat), C.GLuint(minlevel), C.GLuint(numlevels), C.GLuint(minlayer), C.GLuint(numlayers)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glCopyImageSubData.xml +func (gl *GL) CopyImageSubData(srcName uint32, srcTarget glbase.Enum, srcLevel, srcX, srcY, srcZ int32, dstName uint32, dstTarget glbase.Enum, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth int32) { + C.gl4_3core_glCopyImageSubData(gl.funcs, C.GLuint(srcName), C.GLenum(srcTarget), C.GLint(srcLevel), C.GLint(srcX), C.GLint(srcY), C.GLint(srcZ), C.GLuint(dstName), C.GLenum(dstTarget), C.GLint(dstLevel), C.GLint(dstX), C.GLint(dstY), C.GLint(dstZ), C.GLsizei(srcWidth), C.GLsizei(srcHeight), C.GLsizei(srcDepth)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDispatchComputeIndirect.xml +func (gl *GL) DispatchComputeIndirect(indirect int) { + C.gl4_3core_glDispatchComputeIndirect(gl.funcs, C.GLintptr(indirect)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glDispatchCompute.xml +func (gl *GL) DispatchCompute(num_groups_x, num_groups_y, num_groups_z uint32) { + C.gl4_3core_glDispatchCompute(gl.funcs, C.GLuint(num_groups_x), C.GLuint(num_groups_y), C.GLuint(num_groups_z)) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferSubData.xml +func (gl *GL) ClearBufferSubData(target, internalFormat glbase.Enum, offset, size int, format, gltype glbase.Enum, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glClearBufferSubData(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLintptr(offset), C.GLsizeiptr(size), C.GLenum(format), C.GLenum(gltype), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man4/xhtml/glClearBufferData.xml +func (gl *GL) ClearBufferData(target, internalFormat, format, gltype glbase.Enum, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gl4_3core_glClearBufferData(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLenum(format), C.GLenum(gltype), data_ptr) +} diff --git a/gl/es2/funcs.cpp b/gl/es2/funcs.cpp new file mode 100644 index 00000000..71acf8d1 --- /dev/null +++ b/gl/es2/funcs.cpp @@ -0,0 +1,813 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#include +#include + +#include "funcs.h" + +void *gles2_funcs() { + QOpenGLFunctions* funcs = QOpenGLContext::currentContext()->functions(); + if (!funcs) { + return 0; + } + return funcs; +} + + +void gles2_glActiveTexture(void *_glfuncs, GLenum texture) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glActiveTexture(texture); +} + +void gles2_glAttachShader(void *_glfuncs, GLuint program, GLuint shader) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glAttachShader(program, shader); +} + +void gles2_glBindAttribLocation(void *_glfuncs, GLuint program, GLuint index, const GLchar* name) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindAttribLocation(program, index, name); +} + +void gles2_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindBuffer(target, buffer); +} + +void gles2_glBindFramebuffer(void *_glfuncs, GLenum target, GLuint framebuffer) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindFramebuffer(target, framebuffer); +} + +void gles2_glBindRenderbuffer(void *_glfuncs, GLenum target, GLuint renderbuffer) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBindRenderbuffer(target, renderbuffer); +} + +void gles2_glBlendColor(void *_glfuncs, GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendColor(red, green, blue, alpha); +} + +void gles2_glBlendEquation(void *_glfuncs, GLenum mode) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquation(mode); +} + +void gles2_glBlendEquationSeparate(void *_glfuncs, GLenum modeRGB, GLenum modeAlpha) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendEquationSeparate(modeRGB, modeAlpha); +} + +void gles2_glBlendFuncSeparate(void *_glfuncs, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha); +} + +void gles2_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferData(target, size, data, usage); +} + +void gles2_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glBufferSubData(target, offset, size, data); +} + +GLenum gles2_glCheckFramebufferStatus(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCheckFramebufferStatus(target); +} + +void gles2_glClearDepthf(void *_glfuncs, GLclampf depth) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glClearDepthf(depth); +} + +void gles2_glCompileShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompileShader(shader); +} + +void gles2_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data); +} + +void gles2_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); +} + +GLuint gles2_glCreateProgram(void *_glfuncs) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCreateProgram(); +} + +GLuint gles2_glCreateShader(void *_glfuncs, GLenum gltype) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glCreateShader(gltype); +} + +void gles2_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteBuffers(n, buffers); +} + +void gles2_glDeleteFramebuffers(void *_glfuncs, GLsizei n, const GLuint* framebuffers) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteFramebuffers(n, framebuffers); +} + +void gles2_glDeleteProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteProgram(program); +} + +void gles2_glDeleteRenderbuffers(void *_glfuncs, GLsizei n, const GLuint* renderbuffers) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteRenderbuffers(n, renderbuffers); +} + +void gles2_glDeleteShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDeleteShader(shader); +} + +void gles2_glDepthRangef(void *_glfuncs, GLclampf zNear, GLclampf zFar) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDepthRangef(zNear, zFar); +} + +void gles2_glDetachShader(void *_glfuncs, GLuint program, GLuint shader) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDetachShader(program, shader); +} + +void gles2_glDisableVertexAttribArray(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glDisableVertexAttribArray(index); +} + +void gles2_glEnableVertexAttribArray(void *_glfuncs, GLuint index) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glEnableVertexAttribArray(index); +} + +void gles2_glFramebufferRenderbuffer(void *_glfuncs, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer); +} + +void gles2_glFramebufferTexture2D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glFramebufferTexture2D(target, attachment, textarget, texture, level); +} + +void gles2_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenBuffers(n, buffers); +} + +void gles2_glGenerateMipmap(void *_glfuncs, GLenum target) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenerateMipmap(target); +} + +void gles2_glGenFramebuffers(void *_glfuncs, GLsizei n, GLuint* framebuffers) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenFramebuffers(n, framebuffers); +} + +void gles2_glGenRenderbuffers(void *_glfuncs, GLsizei n, GLuint* renderbuffers) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGenRenderbuffers(n, renderbuffers); +} + +void gles2_glGetActiveAttrib(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveAttrib(program, index, bufSize, length, size, gltype, name); +} + +void gles2_glGetActiveUniform(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetActiveUniform(program, index, bufSize, length, size, gltype, name); +} + +void gles2_glGetAttachedShaders(void *_glfuncs, GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetAttachedShaders(program, maxcount, count, shaders); +} + +GLint gles2_glGetAttribLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetAttribLocation(program, name); +} + +void gles2_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetBufferParameteriv(target, pname, params); +} + +void gles2_glGetFramebufferAttachmentParameteriv(void *_glfuncs, GLenum target, GLenum attachment, GLenum pname, GLint* params) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetFramebufferAttachmentParameteriv(target, attachment, pname, params); +} + +void gles2_glGetProgramiv(void *_glfuncs, GLuint program, GLenum pname, GLint* params) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramiv(program, pname, params); +} + +void gles2_glGetProgramInfoLog(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetProgramInfoLog(program, bufSize, length, infoLog); +} + +void gles2_glGetRenderbufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetRenderbufferParameteriv(target, pname, params); +} + +void gles2_glGetShaderiv(void *_glfuncs, GLuint shader, GLenum pname, GLint* params) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderiv(shader, pname, params); +} + +void gles2_glGetShaderInfoLog(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderInfoLog(shader, bufSize, length, infoLog); +} + +void gles2_glGetShaderPrecisionFormat(void *_glfuncs, GLenum shadertype, GLenum precisionType, GLint* range_, GLint* precision) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderPrecisionFormat(shadertype, precisionType, range_, precision); +} + +void gles2_glGetShaderSource(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetShaderSource(shader, bufSize, length, source); +} + +void gles2_glGetUniformfv(void *_glfuncs, GLuint program, GLint location, GLfloat* params) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformfv(program, location, params); +} + +void gles2_glGetUniformiv(void *_glfuncs, GLuint program, GLint location, GLint* params) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetUniformiv(program, location, params); +} + +GLint gles2_glGetUniformLocation(void *_glfuncs, GLuint program, const GLchar* name) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glGetUniformLocation(program, name); +} + +void gles2_glGetVertexAttribfv(void *_glfuncs, GLuint index, GLenum pname, GLfloat* params) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribfv(index, pname, params); +} + +void gles2_glGetVertexAttribiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glGetVertexAttribiv(index, pname, params); +} + +GLboolean gles2_glIsBuffer(void *_glfuncs, GLuint buffer) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsBuffer(buffer); +} + +GLboolean gles2_glIsFramebuffer(void *_glfuncs, GLuint framebuffer) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsFramebuffer(framebuffer); +} + +GLboolean gles2_glIsProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsProgram(program); +} + +GLboolean gles2_glIsRenderbuffer(void *_glfuncs, GLuint renderbuffer) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsRenderbuffer(renderbuffer); +} + +GLboolean gles2_glIsShader(void *_glfuncs, GLuint shader) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + return _qglfuncs->glIsShader(shader); +} + +void gles2_glLinkProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glLinkProgram(program); +} + +void gles2_glReleaseShaderCompiler(void *_glfuncs) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glReleaseShaderCompiler(); +} + +void gles2_glRenderbufferStorage(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glRenderbufferStorage(target, internalFormat, width, height); +} + +void gles2_glSampleCoverage(void *_glfuncs, GLclampf value, GLboolean invert) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glSampleCoverage(value, invert); +} + +void gles2_glShaderBinary(void *_glfuncs, GLint n, const GLuint* shaders, GLenum binaryFormat, const GLvoid* binary, GLint length) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShaderBinary(n, shaders, binaryFormat, binary, length); +} + +void gles2_glShaderSource(void *_glfuncs, GLuint shader, GLsizei count, const GLchar** source, const GLint* length) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glShaderSource(shader, count, source, length); +} + +void gles2_glStencilFuncSeparate(void *_glfuncs, GLenum face, GLenum glfunc, GLint ref, GLuint mask) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilFuncSeparate(face, glfunc, ref, mask); +} + +void gles2_glStencilMaskSeparate(void *_glfuncs, GLenum face, GLuint mask) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilMaskSeparate(face, mask); +} + +void gles2_glStencilOpSeparate(void *_glfuncs, GLenum face, GLenum fail, GLenum zfail, GLenum zpass) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glStencilOpSeparate(face, fail, zfail, zpass); +} + +void gles2_glUniform1f(void *_glfuncs, GLint location, GLfloat v0) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1f(location, v0); +} + +void gles2_glUniform1fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1fv(location, count, value); +} + +void gles2_glUniform1i(void *_glfuncs, GLint location, GLint v0) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1i(location, v0); +} + +void gles2_glUniform1iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform1iv(location, count, value); +} + +void gles2_glUniform2f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2f(location, v0, v1); +} + +void gles2_glUniform2fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2fv(location, count, value); +} + +void gles2_glUniform2i(void *_glfuncs, GLint location, GLint v0, GLint v1) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2i(location, v0, v1); +} + +void gles2_glUniform2iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform2iv(location, count, value); +} + +void gles2_glUniform3f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3f(location, v0, v1, v2); +} + +void gles2_glUniform3fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3fv(location, count, value); +} + +void gles2_glUniform3i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3i(location, v0, v1, v2); +} + +void gles2_glUniform3iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform3iv(location, count, value); +} + +void gles2_glUniform4f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4f(location, v0, v1, v2, v3); +} + +void gles2_glUniform4fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4fv(location, count, value); +} + +void gles2_glUniform4i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4i(location, v0, v1, v2, v3); +} + +void gles2_glUniform4iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniform4iv(location, count, value); +} + +void gles2_glUniformMatrix2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix2fv(location, count, transpose, value); +} + +void gles2_glUniformMatrix3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix3fv(location, count, transpose, value); +} + +void gles2_glUniformMatrix4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUniformMatrix4fv(location, count, transpose, value); +} + +void gles2_glUseProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glUseProgram(program); +} + +void gles2_glValidateProgram(void *_glfuncs, GLuint program) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glValidateProgram(program); +} + +void gles2_glVertexAttrib1f(void *_glfuncs, GLuint index, GLfloat x) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1f(index, x); +} + +void gles2_glVertexAttrib1fv(void *_glfuncs, GLuint index, const GLfloat* values) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib1fv(index, values); +} + +void gles2_glVertexAttrib2f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2f(index, x, y); +} + +void gles2_glVertexAttrib2fv(void *_glfuncs, GLuint index, const GLfloat* values) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib2fv(index, values); +} + +void gles2_glVertexAttrib3f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3f(index, x, y, z); +} + +void gles2_glVertexAttrib3fv(void *_glfuncs, GLuint index, const GLfloat* values) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib3fv(index, values); +} + +void gles2_glVertexAttrib4f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4f(index, x, y, z, w); +} + +void gles2_glVertexAttrib4fv(void *_glfuncs, GLuint index, const GLfloat* values) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttrib4fv(index, values); +} + +void gles2_glVertexAttribPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLboolean normalized, GLsizei stride, const GLvoid* offset) +{ + QOpenGLFunctions* _qglfuncs = reinterpret_cast(_glfuncs); + _qglfuncs->glVertexAttribPointer(index, size, gltype, normalized, stride, offset); +} + +void gles2_glBindTexture(void *_glfuncs, GLenum target, GLuint texture) +{ + glBindTexture(target, texture); +} + +void gles2_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor) +{ + glBlendFunc(sfactor, dfactor); +} + +void gles2_glClear(void *_glfuncs, GLbitfield mask) +{ + glClear(mask); +} + +void gles2_glClearColor(void *_glfuncs, GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) +{ + glClearColor(red, green, blue, alpha); +} + +void gles2_glClearStencil(void *_glfuncs, GLint s) +{ + glClearStencil(s); +} + +void gles2_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) +{ + glColorMask(red, green, blue, alpha); +} + +void gles2_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) +{ + glCopyTexImage2D(target, level, internalFormat, x, y, width, height, border); +} + +void gles2_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); +} + +void gles2_glCullFace(void *_glfuncs, GLenum mode) +{ + glCullFace(mode); +} + +void gles2_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures) +{ + glDeleteTextures(n, textures); +} + +void gles2_glDepthFunc(void *_glfuncs, GLenum glfunc) +{ + glDepthFunc(glfunc); +} + +void gles2_glDepthMask(void *_glfuncs, GLboolean flag) +{ + glDepthMask(flag); +} + +void gles2_glDisable(void *_glfuncs, GLenum cap) +{ + glDisable(cap); +} + +void gles2_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count) +{ + glDrawArrays(mode, first, count); +} + +void gles2_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices) +{ + glDrawElements(mode, count, gltype, indices); +} + +void gles2_glEnable(void *_glfuncs, GLenum cap) +{ + glEnable(cap); +} + +void gles2_glFinish(void *_glfuncs) +{ + glFinish(); +} + +void gles2_glFlush(void *_glfuncs) +{ + glFlush(); +} + +void gles2_glFrontFace(void *_glfuncs, GLenum mode) +{ + glFrontFace(mode); +} + +void gles2_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures) +{ + glGenTextures(n, textures); +} + +void gles2_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params) +{ + glGetBooleanv(pname, params); +} + +GLenum gles2_glGetError(void *_glfuncs) +{ + return glGetError(); +} + +void gles2_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params) +{ + glGetFloatv(pname, params); +} + +void gles2_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params) +{ + glGetIntegerv(pname, params); +} + +void gles2_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params) +{ + glGetTexParameterfv(target, pname, params); +} + +void gles2_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params) +{ + glGetTexParameteriv(target, pname, params); +} + +void gles2_glHint(void *_glfuncs, GLenum target, GLenum mode) +{ + glHint(target, mode); +} + +GLboolean gles2_glIsEnabled(void *_glfuncs, GLenum cap) +{ + return glIsEnabled(cap); +} + +GLboolean gles2_glIsTexture(void *_glfuncs, GLuint texture) +{ + return glIsTexture(texture); +} + +void gles2_glLineWidth(void *_glfuncs, GLfloat width) +{ + glLineWidth(width); +} + +void gles2_glPixelStorei(void *_glfuncs, GLenum pname, GLint param) +{ + glPixelStorei(pname, param); +} + +void gles2_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units) +{ + glPolygonOffset(factor, units); +} + +void gles2_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels) +{ + glReadPixels(x, y, width, height, format, gltype, pixels); +} + +void gles2_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + glScissor(x, y, width, height); +} + +void gles2_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask) +{ + glStencilFunc(glfunc, ref, mask); +} + +void gles2_glStencilMask(void *_glfuncs, GLuint mask) +{ + glStencilMask(mask); +} + +void gles2_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass) +{ + glStencilOp(fail, zfail, zpass); +} + +void gles2_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + glTexImage2D(target, level, internalFormat, width, height, border, format, gltype, pixels); +} + +void gles2_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param) +{ + glTexParameterf(target, pname, param); +} + +void gles2_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params) +{ + glTexParameterfv(target, pname, params); +} + +void gles2_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param) +{ + glTexParameteri(target, pname, param); +} + +void gles2_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params) +{ + glTexParameteriv(target, pname, params); +} + +void gles2_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels) +{ + glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, gltype, pixels); +} + +void gles2_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height) +{ + glViewport(x, y, width, height); +} + diff --git a/gl/es2/funcs.h b/gl/es2/funcs.h new file mode 100644 index 00000000..7e9fd353 --- /dev/null +++ b/gl/es2/funcs.h @@ -0,0 +1,182 @@ + +// ** file automatically generated by glgen -- do not edit manually ** + +#ifndef __cplusplus +#include +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef char GLchar; +typedef signed char GLbyte; /* 1-byte signed */ +typedef short GLshort; /* 2-byte signed */ +typedef int GLint; /* 4-byte signed */ +typedef unsigned char GLubyte; /* 1-byte unsigned */ +typedef unsigned short GLushort; /* 2-byte unsigned */ +typedef unsigned int GLuint; /* 4-byte unsigned */ +typedef int GLsizei; /* 4-byte signed */ +typedef float GLfloat; /* single precision float */ +typedef float GLclampf; /* single precision float in [0,1] */ +typedef double GLdouble; /* double precision float */ +typedef double GLclampd; /* double precision float in [0,1] */ +typedef int64_t GLint64; +typedef uint64_t GLuint64; +typedef ptrdiff_t GLintptr; +typedef ptrdiff_t GLsizeiptr; +typedef ptrdiff_t GLintptrARB; +typedef ptrdiff_t GLsizeiptrARB; +typedef struct __GLsync *GLsync; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +void *gles2_funcs(); + +void gles2_glActiveTexture(void *_glfuncs, GLenum texture); +void gles2_glAttachShader(void *_glfuncs, GLuint program, GLuint shader); +void gles2_glBindAttribLocation(void *_glfuncs, GLuint program, GLuint index, const GLchar* name); +void gles2_glBindBuffer(void *_glfuncs, GLenum target, GLuint buffer); +void gles2_glBindFramebuffer(void *_glfuncs, GLenum target, GLuint framebuffer); +void gles2_glBindRenderbuffer(void *_glfuncs, GLenum target, GLuint renderbuffer); +void gles2_glBlendColor(void *_glfuncs, GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); +void gles2_glBlendEquation(void *_glfuncs, GLenum mode); +void gles2_glBlendEquationSeparate(void *_glfuncs, GLenum modeRGB, GLenum modeAlpha); +void gles2_glBlendFuncSeparate(void *_glfuncs, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); +void gles2_glBufferData(void *_glfuncs, GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage); +void gles2_glBufferSubData(void *_glfuncs, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data); +GLenum gles2_glCheckFramebufferStatus(void *_glfuncs, GLenum target); +void gles2_glClearDepthf(void *_glfuncs, GLclampf depth); +void gles2_glCompileShader(void *_glfuncs, GLuint shader); +void gles2_glCompressedTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data); +void gles2_glCompressedTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data); +GLuint gles2_glCreateProgram(void *_glfuncs); +GLuint gles2_glCreateShader(void *_glfuncs, GLenum gltype); +void gles2_glDeleteBuffers(void *_glfuncs, GLsizei n, const GLuint* buffers); +void gles2_glDeleteFramebuffers(void *_glfuncs, GLsizei n, const GLuint* framebuffers); +void gles2_glDeleteProgram(void *_glfuncs, GLuint program); +void gles2_glDeleteRenderbuffers(void *_glfuncs, GLsizei n, const GLuint* renderbuffers); +void gles2_glDeleteShader(void *_glfuncs, GLuint shader); +void gles2_glDepthRangef(void *_glfuncs, GLclampf zNear, GLclampf zFar); +void gles2_glDetachShader(void *_glfuncs, GLuint program, GLuint shader); +void gles2_glDisableVertexAttribArray(void *_glfuncs, GLuint index); +void gles2_glEnableVertexAttribArray(void *_glfuncs, GLuint index); +void gles2_glFramebufferRenderbuffer(void *_glfuncs, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +void gles2_glFramebufferTexture2D(void *_glfuncs, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +void gles2_glGenBuffers(void *_glfuncs, GLsizei n, GLuint* buffers); +void gles2_glGenerateMipmap(void *_glfuncs, GLenum target); +void gles2_glGenFramebuffers(void *_glfuncs, GLsizei n, GLuint* framebuffers); +void gles2_glGenRenderbuffers(void *_glfuncs, GLsizei n, GLuint* renderbuffers); +void gles2_glGetActiveAttrib(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name); +void gles2_glGetActiveUniform(void *_glfuncs, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* gltype, GLchar* name); +void gles2_glGetAttachedShaders(void *_glfuncs, GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders); +GLint gles2_glGetAttribLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gles2_glGetBufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gles2_glGetFramebufferAttachmentParameteriv(void *_glfuncs, GLenum target, GLenum attachment, GLenum pname, GLint* params); +void gles2_glGetProgramiv(void *_glfuncs, GLuint program, GLenum pname, GLint* params); +void gles2_glGetProgramInfoLog(void *_glfuncs, GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gles2_glGetRenderbufferParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gles2_glGetShaderiv(void *_glfuncs, GLuint shader, GLenum pname, GLint* params); +void gles2_glGetShaderInfoLog(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +void gles2_glGetShaderPrecisionFormat(void *_glfuncs, GLenum shadertype, GLenum precisionType, GLint* range_, GLint* precision); +void gles2_glGetShaderSource(void *_glfuncs, GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source); +void gles2_glGetUniformfv(void *_glfuncs, GLuint program, GLint location, GLfloat* params); +void gles2_glGetUniformiv(void *_glfuncs, GLuint program, GLint location, GLint* params); +GLint gles2_glGetUniformLocation(void *_glfuncs, GLuint program, const GLchar* name); +void gles2_glGetVertexAttribfv(void *_glfuncs, GLuint index, GLenum pname, GLfloat* params); +void gles2_glGetVertexAttribiv(void *_glfuncs, GLuint index, GLenum pname, GLint* params); +GLboolean gles2_glIsBuffer(void *_glfuncs, GLuint buffer); +GLboolean gles2_glIsFramebuffer(void *_glfuncs, GLuint framebuffer); +GLboolean gles2_glIsProgram(void *_glfuncs, GLuint program); +GLboolean gles2_glIsRenderbuffer(void *_glfuncs, GLuint renderbuffer); +GLboolean gles2_glIsShader(void *_glfuncs, GLuint shader); +void gles2_glLinkProgram(void *_glfuncs, GLuint program); +void gles2_glReleaseShaderCompiler(void *_glfuncs); +void gles2_glRenderbufferStorage(void *_glfuncs, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height); +void gles2_glSampleCoverage(void *_glfuncs, GLclampf value, GLboolean invert); +void gles2_glShaderBinary(void *_glfuncs, GLint n, const GLuint* shaders, GLenum binaryFormat, const GLvoid* binary, GLint length); +void gles2_glShaderSource(void *_glfuncs, GLuint shader, GLsizei count, const GLchar** source, const GLint* length); +void gles2_glStencilFuncSeparate(void *_glfuncs, GLenum face, GLenum glfunc, GLint ref, GLuint mask); +void gles2_glStencilMaskSeparate(void *_glfuncs, GLenum face, GLuint mask); +void gles2_glStencilOpSeparate(void *_glfuncs, GLenum face, GLenum fail, GLenum zfail, GLenum zpass); +void gles2_glUniform1f(void *_glfuncs, GLint location, GLfloat v0); +void gles2_glUniform1fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gles2_glUniform1i(void *_glfuncs, GLint location, GLint v0); +void gles2_glUniform1iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gles2_glUniform2f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1); +void gles2_glUniform2fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gles2_glUniform2i(void *_glfuncs, GLint location, GLint v0, GLint v1); +void gles2_glUniform2iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gles2_glUniform3f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +void gles2_glUniform3fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gles2_glUniform3i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2); +void gles2_glUniform3iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gles2_glUniform4f(void *_glfuncs, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +void gles2_glUniform4fv(void *_glfuncs, GLint location, GLsizei count, const GLfloat* value); +void gles2_glUniform4i(void *_glfuncs, GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +void gles2_glUniform4iv(void *_glfuncs, GLint location, GLsizei count, const GLint* value); +void gles2_glUniformMatrix2fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gles2_glUniformMatrix3fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gles2_glUniformMatrix4fv(void *_glfuncs, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +void gles2_glUseProgram(void *_glfuncs, GLuint program); +void gles2_glValidateProgram(void *_glfuncs, GLuint program); +void gles2_glVertexAttrib1f(void *_glfuncs, GLuint index, GLfloat x); +void gles2_glVertexAttrib1fv(void *_glfuncs, GLuint index, const GLfloat* values); +void gles2_glVertexAttrib2f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y); +void gles2_glVertexAttrib2fv(void *_glfuncs, GLuint index, const GLfloat* values); +void gles2_glVertexAttrib3f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z); +void gles2_glVertexAttrib3fv(void *_glfuncs, GLuint index, const GLfloat* values); +void gles2_glVertexAttrib4f(void *_glfuncs, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +void gles2_glVertexAttrib4fv(void *_glfuncs, GLuint index, const GLfloat* values); +void gles2_glVertexAttribPointer(void *_glfuncs, GLuint index, GLint size, GLenum gltype, GLboolean normalized, GLsizei stride, const GLvoid* offset); +void gles2_glBindTexture(void *_glfuncs, GLenum target, GLuint texture); +void gles2_glBlendFunc(void *_glfuncs, GLenum sfactor, GLenum dfactor); +void gles2_glClear(void *_glfuncs, GLbitfield mask); +void gles2_glClearColor(void *_glfuncs, GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); +void gles2_glClearStencil(void *_glfuncs, GLint s); +void gles2_glColorMask(void *_glfuncs, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +void gles2_glCopyTexImage2D(void *_glfuncs, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +void gles2_glCopyTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void gles2_glCullFace(void *_glfuncs, GLenum mode); +void gles2_glDeleteTextures(void *_glfuncs, GLsizei n, const GLuint* textures); +void gles2_glDepthFunc(void *_glfuncs, GLenum glfunc); +void gles2_glDepthMask(void *_glfuncs, GLboolean flag); +void gles2_glDisable(void *_glfuncs, GLenum cap); +void gles2_glDrawArrays(void *_glfuncs, GLenum mode, GLint first, GLsizei count); +void gles2_glDrawElements(void *_glfuncs, GLenum mode, GLsizei count, GLenum gltype, const GLvoid* indices); +void gles2_glEnable(void *_glfuncs, GLenum cap); +void gles2_glFinish(void *_glfuncs); +void gles2_glFlush(void *_glfuncs); +void gles2_glFrontFace(void *_glfuncs, GLenum mode); +void gles2_glGenTextures(void *_glfuncs, GLsizei n, GLuint* textures); +void gles2_glGetBooleanv(void *_glfuncs, GLenum pname, GLboolean* params); +GLenum gles2_glGetError(void *_glfuncs); +void gles2_glGetFloatv(void *_glfuncs, GLenum pname, GLfloat* params); +void gles2_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params); +void gles2_glGetTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, GLfloat* params); +void gles2_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params); +void gles2_glHint(void *_glfuncs, GLenum target, GLenum mode); +GLboolean gles2_glIsEnabled(void *_glfuncs, GLenum cap); +GLboolean gles2_glIsTexture(void *_glfuncs, GLuint texture); +void gles2_glLineWidth(void *_glfuncs, GLfloat width); +void gles2_glPixelStorei(void *_glfuncs, GLenum pname, GLint param); +void gles2_glPolygonOffset(void *_glfuncs, GLfloat factor, GLfloat units); +void gles2_glReadPixels(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum gltype, GLvoid* pixels); +void gles2_glScissor(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); +void gles2_glStencilFunc(void *_glfuncs, GLenum glfunc, GLint ref, GLuint mask); +void gles2_glStencilMask(void *_glfuncs, GLuint mask); +void gles2_glStencilOp(void *_glfuncs, GLenum fail, GLenum zfail, GLenum zpass); +void gles2_glTexImage2D(void *_glfuncs, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum gltype, const GLvoid* pixels); +void gles2_glTexParameterf(void *_glfuncs, GLenum target, GLenum pname, GLfloat param); +void gles2_glTexParameterfv(void *_glfuncs, GLenum target, GLenum pname, const GLfloat* params); +void gles2_glTexParameteri(void *_glfuncs, GLenum target, GLenum pname, GLint param); +void gles2_glTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, const GLint* params); +void gles2_glTexSubImage2D(void *_glfuncs, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum gltype, const GLvoid* pixels); +void gles2_glViewport(void *_glfuncs, GLint x, GLint y, GLsizei width, GLsizei height); + + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/gl/es2/gl.go b/gl/es2/gl.go new file mode 100644 index 00000000..82c9d77c --- /dev/null +++ b/gl/es2/gl.go @@ -0,0 +1,2990 @@ +// ** file automatically generated by glgen -- do not edit manually ** + +package GL + +// #cgo CXXFLAGS: -std=c++0x -pedantic-errors -Wall -fno-strict-aliasing +// #cgo LDFLAGS: -lstdc++ +// #cgo !darwin LDFLAGS: -lGL +// #cgo darwin LDFLAGS: -framework OpenGL +// #cgo pkg-config: Qt5Core Qt5OpenGL +// +// #include "funcs.h" +// +// void free(void*); +// +import "C" + +import ( + "fmt" + "reflect" + "unsafe" + + "gopkg.in/qml.v1/gl/glbase" +) + +// API returns a value that offers methods matching the OpenGL version ES2 API. +// +// The returned API must not be used after the provided OpenGL context becomes invalid. +func API(context glbase.Contexter) *GL { + gl := &GL{} + gl.funcs = C.gles2_funcs() + if gl.funcs == nil { + panic(fmt.Errorf("OpenGL version ES2 is not available")) + } + return gl +} + +// GL implements the OpenGL version ES2 API. Values of this +// type must be created via the API function, and it must not be used after +// the associated OpenGL context becomes invalid. +type GL struct { + funcs unsafe.Pointer +} + +const ( + FALSE = 0 + TRUE = 1 + NONE = 0 + + BYTE = 0x1400 + UNSIGNED_BYTE = 0x1401 + SHORT = 0x1402 + UNSIGNED_SHORT = 0x1403 + INT = 0x1404 + UNSIGNED_INT = 0x1405 + FLOAT = 0x1406 + FIXED = 0x140C + + COLOR_BUFFER_BIT = 0x00004000 + DEPTH_BUFFER_BIT = 0x00000100 + STENCIL_BUFFER_BIT = 0x00000400 + + ALWAYS = 0x0207 + EQUAL = 0x0202 + GEQUAL = 0x0206 + GREATER = 0x0204 + LEQUAL = 0x0203 + LESS = 0x0201 + NEVER = 0x0200 + NOTEQUAL = 0x0205 + + DST_ALPHA = 0x0304 + ONE = 1 + ONE_MINUS_DST_ALPHA = 0x0305 + ONE_MINUS_SRC_ALPHA = 0x0303 + ONE_MINUS_SRC_COLOR = 0x0301 + SRC_ALPHA = 0x0302 + SRC_COLOR = 0x0300 + ZERO = 0 + + DST_COLOR = 0x0306 + ONE_MINUS_DST_COLOR = 0x0307 + SRC_ALPHA_SATURATE = 0x0308 + + BACK = 0x0405 + FRONT = 0x0404 + FRONT_AND_BACK = 0x0408 + + BLEND = 0x0BE2 + CULL_FACE = 0x0B44 + DEPTH_TEST = 0x0B71 + DITHER = 0x0BD0 + POLYGON_OFFSET_FILL = 0x8037 + SCISSOR_TEST = 0x0C11 + STENCIL_TEST = 0x0B90 + TEXTURE_2D = 0x0DE1 + + INVALID_ENUM = 0x0500 + INVALID_FRAMEBUFFER_OPERATION = 0x0506 + INVALID_OPERATION = 0x0502 + INVALID_VALUE = 0x0501 + NO_ERROR = 0 + OUT_OF_MEMORY = 0x0505 + + LINEAR = 0x2601 + + CCW = 0x0901 + CW = 0x0900 + + ALIASED_LINE_WIDTH_RANGE = 0x846E + ALIASED_POINT_SIZE_RANGE = 0x846D + ALPHA_BITS = 0x0D55 + BLUE_BITS = 0x0D54 + COLOR_CLEAR_VALUE = 0x0C22 + COLOR_WRITEMASK = 0x0C23 + CULL_FACE_MODE = 0x0B45 + DEPTH_BITS = 0x0D56 + DEPTH_CLEAR_VALUE = 0x0B73 + DEPTH_FUNC = 0x0B74 + DEPTH_RANGE = 0x0B70 + DEPTH_WRITEMASK = 0x0B72 + FRONT_FACE = 0x0B46 + GREEN_BITS = 0x0D53 + LINE_WIDTH = 0x0B21 + MAX_TEXTURE_SIZE = 0x0D33 + MAX_VIEWPORT_DIMS = 0x0D3A + PACK_ALIGNMENT = 0x0D05 + POLYGON_OFFSET_FACTOR = 0x8038 + POLYGON_OFFSET_UNITS = 0x2A00 + RED_BITS = 0x0D52 + SCISSOR_BOX = 0x0C10 + STENCIL_BITS = 0x0D57 + STENCIL_CLEAR_VALUE = 0x0B91 + STENCIL_FAIL = 0x0B94 + STENCIL_FUNC = 0x0B92 + STENCIL_PASS_DEPTH_FAIL = 0x0B95 + STENCIL_PASS_DEPTH_PASS = 0x0B96 + STENCIL_REF = 0x0B97 + STENCIL_VALUE_MASK = 0x0B93 + STENCIL_WRITEMASK = 0x0B98 + SUBPIXEL_BITS = 0x0D50 + TEXTURE_BINDING_2D = 0x8069 + UNPACK_ALIGNMENT = 0x0CF5 + VIEWPORT = 0x0BA2 + + TEXTURE_MAG_FILTER = 0x2800 + TEXTURE_MIN_FILTER = 0x2801 + TEXTURE_WRAP_S = 0x2802 + TEXTURE_WRAP_T = 0x2803 + + DONT_CARE = 0x1100 + FASTEST = 0x1101 + NICEST = 0x1102 + + GENERATE_MIPMAP_HINT = 0x8192 + + REPLACE = 0x1E01 + + INVERT = 0x150A + + TEXTURE = 0x1702 + + ALPHA = 0x1906 + DEPTH_COMPONENT = 0x1902 + LUMINANCE = 0x1909 + LUMINANCE_ALPHA = 0x190A + RGB = 0x1907 + RGBA = 0x1908 + + RGB5_A1 = 0x8057 + RGBA4 = 0x8056 + + UNSIGNED_SHORT_4_4_4_4 = 0x8033 + UNSIGNED_SHORT_5_5_5_1 = 0x8034 + + LINES = 0x0001 + LINE_LOOP = 0x0002 + LINE_STRIP = 0x0003 + POINTS = 0x0000 + TRIANGLES = 0x0004 + TRIANGLE_FAN = 0x0006 + TRIANGLE_STRIP = 0x0005 + + DECR = 0x1E03 + INCR = 0x1E02 + KEEP = 0x1E00 + + EXTENSIONS = 0x1F03 + RENDERER = 0x1F01 + VENDOR = 0x1F00 + VERSION = 0x1F02 + + NEAREST = 0x2600 + + LINEAR_MIPMAP_LINEAR = 0x2703 + LINEAR_MIPMAP_NEAREST = 0x2701 + NEAREST_MIPMAP_LINEAR = 0x2702 + NEAREST_MIPMAP_NEAREST = 0x2700 + + CLAMP_TO_EDGE = 0x812F + REPEAT = 0x2901 + + CONSTANT_COLOR = 0x8001 + ONE_MINUS_CONSTANT_COLOR = 0x8002 + CONSTANT_ALPHA = 0x8003 + ONE_MINUS_CONSTANT_ALPHA = 0x8004 + BLEND_COLOR = 0x8005 + FUNC_ADD = 0x8006 + BLEND_EQUATION = 0x8009 + BLEND_EQUATION_RGB = 0x8009 + FUNC_SUBTRACT = 0x800A + FUNC_REVERSE_SUBTRACT = 0x800B + SAMPLE_ALPHA_TO_COVERAGE = 0x809E + SAMPLE_COVERAGE = 0x80A0 + SAMPLE_BUFFERS = 0x80A8 + SAMPLES = 0x80A9 + SAMPLE_COVERAGE_VALUE = 0x80AA + SAMPLE_COVERAGE_INVERT = 0x80AB + BLEND_DST_RGB = 0x80C8 + BLEND_SRC_RGB = 0x80C9 + BLEND_DST_ALPHA = 0x80CA + BLEND_SRC_ALPHA = 0x80CB + DEPTH_COMPONENT16 = 0x81A5 + UNSIGNED_SHORT_5_6_5 = 0x8363 + MIRRORED_REPEAT = 0x8370 + TEXTURE0 = 0x84C0 + TEXTURE1 = 0x84C1 + TEXTURE2 = 0x84C2 + TEXTURE3 = 0x84C3 + TEXTURE4 = 0x84C4 + TEXTURE5 = 0x84C5 + TEXTURE6 = 0x84C6 + TEXTURE7 = 0x84C7 + TEXTURE8 = 0x84C8 + TEXTURE9 = 0x84C9 + TEXTURE10 = 0x84CA + TEXTURE11 = 0x84CB + TEXTURE12 = 0x84CC + TEXTURE13 = 0x84CD + TEXTURE14 = 0x84CE + TEXTURE15 = 0x84CF + TEXTURE16 = 0x84D0 + TEXTURE17 = 0x84D1 + TEXTURE18 = 0x84D2 + TEXTURE19 = 0x84D3 + TEXTURE20 = 0x84D4 + TEXTURE21 = 0x84D5 + TEXTURE22 = 0x84D6 + TEXTURE23 = 0x84D7 + TEXTURE24 = 0x84D8 + TEXTURE25 = 0x84D9 + TEXTURE26 = 0x84DA + TEXTURE27 = 0x84DB + TEXTURE28 = 0x84DC + TEXTURE29 = 0x84DD + TEXTURE30 = 0x84DE + TEXTURE31 = 0x84DF + ACTIVE_TEXTURE = 0x84E0 + MAX_RENDERBUFFER_SIZE = 0x84E8 + INCR_WRAP = 0x8507 + DECR_WRAP = 0x8508 + TEXTURE_CUBE_MAP = 0x8513 + TEXTURE_BINDING_CUBE_MAP = 0x8514 + TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515 + TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516 + TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517 + TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518 + TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519 + TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A + MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C + VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622 + VERTEX_ATTRIB_ARRAY_SIZE = 0x8623 + VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624 + VERTEX_ATTRIB_ARRAY_TYPE = 0x8625 + CURRENT_VERTEX_ATTRIB = 0x8626 + VERTEX_ATTRIB_ARRAY_POINTER = 0x8645 + NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2 + COMPRESSED_TEXTURE_FORMATS = 0x86A3 + BUFFER_SIZE = 0x8764 + BUFFER_USAGE = 0x8765 + STENCIL_BACK_FUNC = 0x8800 + STENCIL_BACK_FAIL = 0x8801 + STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802 + STENCIL_BACK_PASS_DEPTH_PASS = 0x8803 + BLEND_EQUATION_ALPHA = 0x883D + MAX_VERTEX_ATTRIBS = 0x8869 + VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A + MAX_TEXTURE_IMAGE_UNITS = 0x8872 + ARRAY_BUFFER = 0x8892 + ELEMENT_ARRAY_BUFFER = 0x8893 + ARRAY_BUFFER_BINDING = 0x8894 + ELEMENT_ARRAY_BUFFER_BINDING = 0x8895 + VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F + STREAM_DRAW = 0x88E0 + STATIC_DRAW = 0x88E4 + DYNAMIC_DRAW = 0x88E8 + FRAGMENT_SHADER = 0x8B30 + VERTEX_SHADER = 0x8B31 + MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C + MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D + SHADER_TYPE = 0x8B4F + FLOAT_VEC2 = 0x8B50 + FLOAT_VEC3 = 0x8B51 + FLOAT_VEC4 = 0x8B52 + INT_VEC2 = 0x8B53 + INT_VEC3 = 0x8B54 + INT_VEC4 = 0x8B55 + BOOL = 0x8B56 + BOOL_VEC2 = 0x8B57 + BOOL_VEC3 = 0x8B58 + BOOL_VEC4 = 0x8B59 + FLOAT_MAT2 = 0x8B5A + FLOAT_MAT3 = 0x8B5B + FLOAT_MAT4 = 0x8B5C + SAMPLER_2D = 0x8B5E + SAMPLER_CUBE = 0x8B60 + DELETE_STATUS = 0x8B80 + COMPILE_STATUS = 0x8B81 + LINK_STATUS = 0x8B82 + VALIDATE_STATUS = 0x8B83 + INFO_LOG_LENGTH = 0x8B84 + ATTACHED_SHADERS = 0x8B85 + ACTIVE_UNIFORMS = 0x8B86 + ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87 + SHADER_SOURCE_LENGTH = 0x8B88 + ACTIVE_ATTRIBUTES = 0x8B89 + ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A + SHADING_LANGUAGE_VERSION = 0x8B8C + CURRENT_PROGRAM = 0x8B8D + IMPLEMENTATION_COLOR_READ_TYPE = 0x8B9A + IMPLEMENTATION_COLOR_READ_FORMAT = 0x8B9B + STENCIL_BACK_REF = 0x8CA3 + STENCIL_BACK_VALUE_MASK = 0x8CA4 + STENCIL_BACK_WRITEMASK = 0x8CA5 + FRAMEBUFFER_BINDING = 0x8CA6 + RENDERBUFFER_BINDING = 0x8CA7 + FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0 + FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1 + FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2 + FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3 + FRAMEBUFFER_COMPLETE = 0x8CD5 + FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6 + FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7 + FRAMEBUFFER_INCOMPLETE_DIMENSIONS = 0x8CD9 + FRAMEBUFFER_UNSUPPORTED = 0x8CDD + COLOR_ATTACHMENT0 = 0x8CE0 + DEPTH_ATTACHMENT = 0x8D00 + STENCIL_ATTACHMENT = 0x8D20 + FRAMEBUFFER = 0x8D40 + RENDERBUFFER = 0x8D41 + RENDERBUFFER_WIDTH = 0x8D42 + RENDERBUFFER_HEIGHT = 0x8D43 + RENDERBUFFER_INTERNAL_FORMAT = 0x8D44 + STENCIL_INDEX8 = 0x8D48 + RENDERBUFFER_RED_SIZE = 0x8D50 + RENDERBUFFER_GREEN_SIZE = 0x8D51 + RENDERBUFFER_BLUE_SIZE = 0x8D52 + RENDERBUFFER_ALPHA_SIZE = 0x8D53 + RENDERBUFFER_DEPTH_SIZE = 0x8D54 + RENDERBUFFER_STENCIL_SIZE = 0x8D55 + RGB565 = 0x8D62 + LOW_FLOAT = 0x8DF0 + MEDIUM_FLOAT = 0x8DF1 + HIGH_FLOAT = 0x8DF2 + LOW_INT = 0x8DF3 + MEDIUM_INT = 0x8DF4 + HIGH_INT = 0x8DF5 + SHADER_BINARY_FORMATS = 0x8DF8 + NUM_SHADER_BINARY_FORMATS = 0x8DF9 + SHADER_COMPILER = 0x8DFA + MAX_VERTEX_UNIFORM_VECTORS = 0x8DFB + MAX_VARYING_VECTORS = 0x8DFC + MAX_FRAGMENT_UNIFORM_VECTORS = 0x8DFD +) + +// https://www.opengl.org/sdk/docs/man2/xhtml/glActiveTexture.xml +func (gl *GL) ActiveTexture(texture glbase.Enum) { + C.gles2_glActiveTexture(gl.funcs, C.GLenum(texture)) +} + +// AttachShader attaches a shader object to a program object. +// +// In order to create an executable, there must be a way to specify the list +// of things that will be linked together. Program objects provide this +// mechanism. Shaders that are to be linked together in a program object must +// first be attached to that program object. This indicates that shader will +// be included in link operations that will be performed on program. +// +// All operations that can be performed on a shader object are valid whether +// or not the shader object is attached to a program object. It is +// permissible to attach a shader object to a program object before source +// code has been loaded into the shader object or before the shader object +// has been compiled. It is permissible to attach multiple shader objects of +// the same type because each may contain a portion of the complete shader. +// It is also permissible to attach a shader object to more than one program +// object. If a shader object is deleted while it is attached to a program +// object, it will be flagged for deletion, and deletion will not occur until +// DetachShader is called to detach it from all program objects to which it +// is attached. +// +// Error GL.INVALID_VALUE is generated if either program or shader is not a +// value generated by OpenGL. GL.INVALID_OPERATION is generated if program +// is not a program object. GL.INVALID_OPERATION is generated if shader is +// not a shader object. GL.INVALID_OPERATION is generated if shader is +// already attached to program. GL.INVALID_OPERATION is generated if +// AttachShader is executed between the execution of Begin and the +// corresponding execution of End. +// +// AttachShader is available in GL version 2.0 or greater. +func (gl *GL) AttachShader(program glbase.Program, shader glbase.Shader) { + C.gles2_glAttachShader(gl.funcs, C.GLuint(program), C.GLuint(shader)) +} + +// BindAttribLocation associates a user-defined attribute variable in the program +// object specified by program with a generic vertex attribute index. The name +// parameter specifies the name of the vertex shader attribute variable to +// which index is to be bound. When program is made part of the current state, +// values provided via the generic vertex attribute index will modify the +// value of the user-defined attribute variable specified by name. +// +// If name refers to a matrix attribute variable, index refers to the first +// column of the matrix. Other matrix columns are then automatically bound to +// locations index+1 for a matrix of type mat2; index+1 and index+2 for a +// matrix of type mat3; and index+1, index+2, and index+3 for a matrix of +// type mat4. +// +// This command makes it possible for vertex shaders to use descriptive names +// for attribute variables rather than generic variables that are numbered +// from 0 to GL.MAX_VERTEX_ATTRIBS-1. The values sent to each generic +// attribute index are part of current state, just like standard vertex +// attributes such as color, normal, and vertex position. If a different +// program object is made current by calling UseProgram, the generic vertex +// attributes are tracked in such a way that the same values will be observed +// by attributes in the new program object that are also bound to index. +// +// Attribute variable name-to-generic attribute index bindings for a program +// object can be explicitly assigned at any time by calling +// BindAttribLocation. Attribute bindings do not go into effect until +// LinkProgram is called. After a program object has been linked +// successfully, the index values for generic attributes remain fixed (and +// their values can be queried) until the next link command occurs. +// +// Applications are not allowed to bind any of the standard OpenGL vertex +// attributes using this command, as they are bound automatically when +// needed. Any attribute binding that occurs after the program object has +// been linked will not take effect until the next time the program object is +// linked. +// +// If name was bound previously, that information is lost. Thus you cannot +// bind one user-defined attribute variable to multiple indices, but you can +// bind multiple user-defined attribute variables to the same index. +// +// Applications are allowed to bind more than one user-defined attribute +// variable to the same generic vertex attribute index. This is called +// aliasing, and it is allowed only if just one of the aliased attributes is +// active in the executable program, or if no path through the shader +// consumes more than one attribute of a set of attributes aliased to the +// same location. The compiler and linker are allowed to assume that no +// aliasing is done and are free to employ optimizations that work only in +// the absence of aliasing. OpenGL implementations are not required to do +// error checking to detect aliasing. Because there is no way to bind +// standard attributes, it is not possible to alias generic attributes with +// conventional ones (except for generic attribute 0). +// +// BindAttribLocation can be called before any vertex shader objects are +// bound to the specified program object. It is also permissible to bind a +// generic attribute index to an attribute variable name that is never used +// in a vertex shader. +// +// Active attributes that are not explicitly bound will be bound by the +// linker when LinkProgram is called. The locations assigned can be queried +// by calling GetAttribLocation. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. +// GL.INVALID_OPERATION is generated if name starts with the reserved prefix "gl_". +// GL.INVALID_VALUE is generated if program is not a value generated by OpenGL. +// GL.INVALID_OPERATION is generated if program is not a program object. +// GL.INVALID_OPERATION is generated if BindAttribLocation is executed +// between the execution of Begin and the corresponding execution of End. +// +// BindAttribLocation is available in GL version 2.0 or greater. +func (gl *GL) BindAttribLocation(program glbase.Program, index glbase.Attrib, name string) { + name_cstr := C.CString(name) + C.gles2_glBindAttribLocation(gl.funcs, C.GLuint(program), C.GLuint(index), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) +} + +// BindBuffer creates or puts in use a named buffer object. +// Calling BindBuffer with target set to GL.ARRAY_BUFFER, +// GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER or GL.PIXEL_UNPACK_BUFFER +// and buffer set to the name of the new buffer object binds the buffer +// object name to the target. When a buffer object is bound to a target, the +// previous binding for that target is automatically broken. +// +// Buffer object names are unsigned integers. The value zero is reserved, but +// there is no default buffer object for each buffer object target. Instead, +// buffer set to zero effectively unbinds any buffer object previously bound, +// and restores client memory usage for that buffer object target. Buffer +// object names and the corresponding buffer object contents are local to the +// shared display-list space (see XCreateContext) of the current GL rendering +// context; two rendering contexts share buffer object names only if they +// also share display lists. +// +// GenBuffers may be called to generate a set of new buffer object names. +// +// The state of a buffer object immediately after it is first bound is an +// unmapped zero-sized memory buffer with GL.READ_WRITE access and +// GL.STATIC_DRAW usage. +// +// While a non-zero buffer object name is bound, GL operations on the target +// to which it is bound affect the bound buffer object, and queries of the +// target to which it is bound return state from the bound buffer object. +// While buffer object name zero is bound, as in the initial state, attempts +// to modify or query state on the target to which it is bound generates an +// GL.INVALID_OPERATION error. +// +// When vertex array pointer state is changed, for example by a call to +// NormalPointer, the current buffer object binding (GL.ARRAY_BUFFER_BINDING) +// is copied into the corresponding client state for the vertex array type +// being changed, for example GL.NORMAL_ARRAY_BUFFER_BINDING. While a +// non-zero buffer object is bound to the GL.ARRAY_BUFFER target, the vertex +// array pointer parameter that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.ELEMENT_ARRAY_BUFFER +// target, the indices parameter of DrawElements, DrawRangeElements, or +// MultiDrawElements that is traditionally interpreted as a pointer to +// client-side memory is instead interpreted as an offset within the buffer +// object measured in basic machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_PACK_BUFFER +// target, the following commands are affected: GetCompressedTexImage, +// GetConvolutionFilter, GetHistogram, GetMinmax, GetPixelMap, +// GetPolygonStipple, GetSeparableFilter, GetTexImage, and ReadPixels. The +// pointer parameter that is traditionally interpreted as a pointer to +// client-side memory where the pixels are to be packed is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// While a non-zero buffer object is bound to the GL.PIXEL_UNPACK_BUFFER +// target, the following commands are affected: Bitmap, ColorSubTable, +// ColorTable, CompressedTexImage1D, CompressedTexImage2D, +// CompressedTexImage3D, CompressedTexSubImage1D, CompressedTexSubImage2D, +// CompressedTexSubImage3D, ConvolutionFilter1D, ConvolutionFilter2D, +// DrawPixels, PixelMap, PolygonStipple, SeparableFilter2D, TexImage1D, +// TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, and TexSubImage3D. +// The pointer parameter that is traditionally interpreted as a pointer to +// client-side memory from which the pixels are to be unpacked is instead +// interpreted as an offset within the buffer object measured in basic +// machine units. +// +// A buffer object binding created with BindBuffer remains active until a +// different buffer object name is bound to the same target, or until the +// bound buffer object is deleted with DeleteBuffers. +// +// Once created, a named buffer object may be re-bound to any target as often +// as needed. However, the GL implementation may make choices about how to +// optimize the storage of a buffer object based on its initial binding +// target. +// +// Error GL.INVALID_ENUM is generated if target is not one of the allowable +// values. GL.INVALID_OPERATION is generated if BindBuffer is executed +// between the execution of Begin and the corresponding execution of End. +// +// BindBuffer is available in GL version 1.5 or greater. +func (gl *GL) BindBuffer(target glbase.Enum, buffer glbase.Buffer) { + C.gles2_glBindBuffer(gl.funcs, C.GLenum(target), C.GLuint(buffer)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBindFramebuffer.xml +func (gl *GL) BindFramebuffer(target glbase.Enum, framebuffer glbase.Framebuffer) { + C.gles2_glBindFramebuffer(gl.funcs, C.GLenum(target), C.GLuint(framebuffer)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBindRenderbuffer.xml +func (gl *GL) BindRenderbuffer(target glbase.Enum, renderbuffer glbase.Renderbuffer) { + C.gles2_glBindRenderbuffer(gl.funcs, C.GLenum(target), C.GLuint(renderbuffer)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBlendColor.xml +func (gl *GL) BlendColor(red, green, blue, alpha glbase.Clampf) { + C.gles2_glBlendColor(gl.funcs, C.GLclampf(red), C.GLclampf(green), C.GLclampf(blue), C.GLclampf(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBlendEquation.xml +func (gl *GL) BlendEquation(mode glbase.Enum) { + C.gles2_glBlendEquation(gl.funcs, C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBlendEquationSeparate.xml +func (gl *GL) BlendEquationSeparate(modeRGB, modeAlpha glbase.Enum) { + C.gles2_glBlendEquationSeparate(gl.funcs, C.GLenum(modeRGB), C.GLenum(modeAlpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBlendFuncSeparate.xml +func (gl *GL) BlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha glbase.Enum) { + C.gles2_glBlendFuncSeparate(gl.funcs, C.GLenum(srcRGB), C.GLenum(dstRGB), C.GLenum(srcAlpha), C.GLenum(dstAlpha)) +} + +// BufferData creates a new data store for the buffer object currently +// bound to target. Any pre-existing data store is deleted. The new data +// store is created with the specified size in bytes and usage. If data is +// not nil, it must be a slice that is used to initialize the data store. +// In that case the size parameter is ignored and the store size will match +// the slice data size. +// +// In its initial state, the new data store is not mapped, it has a NULL +// mapped pointer, and its mapped access is GL.READ_WRITE. +// +// The target constant must be one of GL.ARRAY_BUFFER, GL.COPY_READ_BUFFER, +// GL.COPY_WRITE_BUFFER, GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER, +// GL.PIXEL_UNPACK_BUFFER, GL.TEXTURE_BUFFER, GL.TRANSFORM_FEEDBACK_BUFFER, +// or GL.UNIFORM_BUFFER. +// +// The usage parameter is a hint to the GL implementation as to how a buffer +// object's data store will be accessed. This enables the GL implementation +// to make more intelligent decisions that may significantly impact buffer +// object performance. It does not, however, constrain the actual usage of +// the data store. usage can be broken down into two parts: first, the +// frequency of access (modification and usage), and second, the nature of +// that access. +// +// A usage frequency of STREAM and nature of DRAW is specified via the +// constant GL.STREAM_DRAW, for example. +// +// The usage frequency of access may be one of: +// +// STREAM +// The data store contents will be modified once and used at most a few times. +// +// STATIC +// The data store contents will be modified once and used many times. +// +// DYNAMIC +// The data store contents will be modified repeatedly and used many times. +// +// The usage nature of access may be one of: +// +// DRAW +// The data store contents are modified by the application, and used as +// the source for GL drawing and image specification commands. +// +// READ +// The data store contents are modified by reading data from the GL, +// and used to return that data when queried by the application. +// +// COPY +// The data store contents are modified by reading data from the GL, +// and used as the source for GL drawing and image specification +// commands. +// +// Clients must align data elements consistent with the requirements of the +// client platform, with an additional base-level requirement that an offset +// within a buffer to a datum comprising N bytes be a multiple of N. +// +// Error GL.INVALID_ENUM is generated if target is not one of the accepted +// buffer targets. GL.INVALID_ENUM is generated if usage is not +// GL.STREAM_DRAW, GL.STREAM_READ, GL.STREAM_COPY, GL.STATIC_DRAW, +// GL.STATIC_READ, GL.STATIC_COPY, GL.DYNAMIC_DRAW, GL.DYNAMIC_READ, or +// GL.DYNAMIC_COPY. GL.INVALID_VALUE is generated if size is negative. +// GL.INVALID_OPERATION is generated if the reserved buffer object name 0 is +// bound to target. GL.OUT_OF_MEMORY is generated if the GL is unable to +// create a data store with the specified size. +func (gl *GL) BufferData(target glbase.Enum, size int, data interface{}, usage glbase.Enum) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + if data != nil { + size = int(data_v.Type().Size()) * data_v.Len() + } + C.gles2_glBufferData(gl.funcs, C.GLenum(target), C.GLsizeiptr(size), data_ptr, C.GLenum(usage)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBufferSubData.xml +func (gl *GL) BufferSubData(target glbase.Enum, offset, size int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gles2_glBufferSubData(gl.funcs, C.GLenum(target), C.GLintptr(offset), C.GLsizeiptr(size), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCheckFramebufferStatus.xml +func (gl *GL) CheckFramebufferStatus(target glbase.Enum) glbase.Enum { + glresult := C.gles2_glCheckFramebufferStatus(gl.funcs, C.GLenum(target)) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearDepthf.xml +func (gl *GL) ClearDepthf(depth glbase.Clampf) { + C.gles2_glClearDepthf(gl.funcs, C.GLclampf(depth)) +} + +// CompileShader compiles the source code strings that have been stored in +// the shader object specified by shader. +// +// The compilation status will be stored as part of the shader object's +// state. This value will be set to GL.TRUE if the shader was compiled without +// errors and is ready for use, and GL.FALSE otherwise. It can be queried by +// calling GetShaderiv with arguments shader and GL.COMPILE_STATUS. +// +// Compilation of a shader can fail for a number of reasons as specified by +// the OpenGL Shading Language Specification. Whether or not the compilation +// was successful, information about the compilation can be obtained from the +// shader object's information log by calling GetShaderInfoLog. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_OPERATION is generated if CompileShader is executed +// between the execution of Begin and the corresponding execution of End. +// +// CompileShader is available in GL version 2.0 or greater. +func (gl *GL) CompileShader(shader glbase.Shader) { + C.gles2_glCompileShader(gl.funcs, C.GLuint(shader)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCompressedTexImage2D.xml +func (gl *GL) CompressedTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, width, height, border, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gles2_glCompressedTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLsizei(imageSize), data_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCompressedTexSubImage2D.xml +func (gl *GL) CompressedTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format glbase.Enum, imageSize int, data interface{}) { + var data_ptr unsafe.Pointer + var data_v = reflect.ValueOf(data) + if data != nil && data_v.Kind() != reflect.Slice { + panic("parameter data must be a slice") + } + if data != nil { + data_ptr = unsafe.Pointer(data_v.Index(0).Addr().Pointer()) + } + C.gles2_glCompressedTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLsizei(imageSize), data_ptr) +} + +// CreateProgram creates an empty program object and returns a non-zero +// value by which it can be referenced. A program object is an object to +// which shader objects can be attached. This provides a mechanism to specify +// the shader objects that will be linked to create a program. It also +// provides a means for checking the compatibility of the shaders that will +// be used to create a program (for instance, checking the compatibility +// between a vertex shader and a fragment shader). When no longer needed as +// part of a program object, shader objects can be detached. +// +// One or more executables are created in a program object by successfully +// attaching shader objects to it with AttachShader, successfully compiling +// the shader objects with CompileShader, and successfully linking the +// program object with LinkProgram. These executables are made part of +// current state when UseProgram is called. Program objects can be deleted +// by calling DeleteProgram. The memory associated with the program object +// will be deleted when it is no longer part of current rendering state for +// any context. +// +// Like display lists and texture objects, the name space for program objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// Applications are responsible for providing the synchronization across API +// calls when objects are accessed from different execution threads. +// +// This function returns 0 if an error occurs creating the program object. +// +// Error GL.INVALID_OPERATION is generated if CreateProgram is executed +// between the execution of Begin and the corresponding execution of End. +// +// CreateProgram is available in GL version 2.0 or greater. +func (gl *GL) CreateProgram() glbase.Program { + glresult := C.gles2_glCreateProgram(gl.funcs) + return glbase.Program(glresult) +} + +// CreateShader creates an empty shader object and returns a non-zero value +// by which it can be referenced. A shader object is used to maintain the +// source code strings that define a shader. shaderType indicates the type of +// shader to be created. +// +// Two types of shaders are supported. A shader of type GL.VERTEX_SHADER is a +// shader that is intended to run on the programmable vertex processor and +// replace the fixed functionality vertex processing in OpenGL. A shader of +// type GL.FRAGMENT_SHADER is a shader that is intended to run on the +// programmable fragment processor and replace the fixed functionality +// fragment processing in OpenGL. +// +// When created, a shader object's GL.SHADER_TYPE parameter is set to either +// GL.VERTEX_SHADER or GL.FRAGMENT_SHADER, depending on the value of +// shaderType. +// +// Like display lists and texture objects, the name space for shader objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// This function returns 0 if an error occurs creating the shader object. +// +// Error GL.INVALID_ENUM is generated if shaderType is not an accepted value. +// GL.INVALID_OPERATION is generated if CreateShader is executed between the +// execution of Begin and the corresponding execution of End. +// +// CreateShader is available in GL version 2.0 or greater. +func (gl *GL) CreateShader(gltype glbase.Enum) glbase.Shader { + glresult := C.gles2_glCreateShader(gl.funcs, C.GLenum(gltype)) + return glbase.Shader(glresult) +} + +// DeleteBuffers deletes the buffer objects whose names are stored in the +// buffers slice. +// +// After a buffer object is deleted, it has no contents, and its name is free +// for reuse (for example by GenBuffers). If a buffer object that is +// currently bound is deleted, the binding reverts to 0 (the absence of any +// buffer object, which reverts to client memory usage). +// +// DeleteBuffers silently ignores 0's and names that do not correspond to +// existing buffer objects. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if DeleteBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// DeleteBuffers is available in GL version 1.5 or greater. +func (gl *GL) DeleteBuffers(buffers []glbase.Buffer) { + n := len(buffers) + if n == 0 { + return + } + C.gles2_glDeleteBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) +} + +// DeleteFramebuffers deletes the framebuffer objects whose names are +// stored in the framebuffers slice. The name zero is reserved by the GL and +// is silently ignored, should it occur in framebuffers, as are other unused +// names. Once a framebuffer object is deleted, its name is again unused and +// it has no attachments. If a framebuffer that is currently bound to one or +// more of the targets GL.DRAW_FRAMEBUFFER or GL.READ_FRAMEBUFFER is deleted, +// it is as though BindFramebuffer had been executed with the corresponding +// target and framebuffer zero. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteFramebuffers is available in GL version 3.0 or greater. +func (gl *GL) DeleteFramebuffers(framebuffers []glbase.Framebuffer) { + n := len(framebuffers) + if n == 0 { + return + } + C.gles2_glDeleteFramebuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&framebuffers[0]))) +} + +// DeleteProgram frees the memory and invalidates the name associated with +// the program object specified by program. This command effectively undoes +// the effects of a call to CreateProgram. +// +// If a program object is in use as part of current rendering state, it will +// be flagged for deletion, but it will not be deleted until it is no longer +// part of current state for any rendering context. If a program object to be +// deleted has shader objects attached to it, those shader objects will be +// automatically detached but not deleted unless they have already been +// flagged for deletion by a previous call to DeleteShader. A value of 0 +// for program will be silently ignored. +// +// To determine whether a program object has been flagged for deletion, call +// GetProgram with arguments program and GL.DELETE_STATUS. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. +// +// DeleteProgram is available in GL version 2.0 or greater. +func (gl *GL) DeleteProgram(program glbase.Program) { + C.gles2_glDeleteProgram(gl.funcs, C.GLuint(program)) +} + +// DeleteRenderbuffers deletes the renderbuffer objects whose names are stored +// in the renderbuffers slice. The name zero is reserved by the GL and +// is silently ignored, should it occur in renderbuffers, as are other unused +// names. Once a renderbuffer object is deleted, its name is again unused and +// it has no contents. If a renderbuffer that is currently bound to the +// target GL.RENDERBUFFER is deleted, it is as though BindRenderbuffer had +// been executed with a target of GL.RENDERBUFFER and a name of zero. +// +// If a renderbuffer object is attached to one or more attachment points in +// the currently bound framebuffer, then it as if FramebufferRenderbuffer +// had been called, with a renderbuffer of zero for each attachment point to +// which this image was attached in the currently bound framebuffer. In other +// words, this renderbuffer object is first detached from all attachment +// ponits in the currently bound framebuffer. Note that the renderbuffer +// image is specifically not detached from any non-bound framebuffers. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteRenderbuffers is available in GL version 3.0 or greater. +func (gl *GL) DeleteRenderbuffers(renderbuffers []glbase.Renderbuffer) { + n := len(renderbuffers) + if n == 0 { + return + } + C.gles2_glDeleteRenderbuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&renderbuffers[0]))) +} + +// DeleteShader frees the memory and invalidates the name associated with +// the shader object specified by shader. This command effectively undoes the +// effects of a call to CreateShader. +// +// If a shader object to be deleted is attached to a program object, it will +// be flagged for deletion, but it will not be deleted until it is no longer +// attached to any program object, for any rendering context (it must +// be detached from wherever it was attached before it will be deleted). A +// value of 0 for shader will be silently ignored. +// +// To determine whether an object has been flagged for deletion, call +// GetShader with arguments shader and GL.DELETE_STATUS. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. +// +// DeleteShader is available in GL version 2.0 or greater. +func (gl *GL) DeleteShader(shader glbase.Shader) { + C.gles2_glDeleteShader(gl.funcs, C.GLuint(shader)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDepthRangef.xml +func (gl *GL) DepthRangef(zNear, zFar glbase.Clampf) { + C.gles2_glDepthRangef(gl.funcs, C.GLclampf(zNear), C.GLclampf(zFar)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDetachShader.xml +func (gl *GL) DetachShader(program glbase.Program, shader glbase.Shader) { + C.gles2_glDetachShader(gl.funcs, C.GLuint(program), C.GLuint(shader)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDisableVertexAttribArray.xml +func (gl *GL) DisableVertexAttribArray(index glbase.Attrib) { + C.gles2_glDisableVertexAttribArray(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEnableVertexAttribArray.xml +func (gl *GL) EnableVertexAttribArray(index glbase.Attrib) { + C.gles2_glEnableVertexAttribArray(gl.funcs, C.GLuint(index)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFramebufferRenderbuffer.xml +func (gl *GL) FramebufferRenderbuffer(target, attachment, renderbuffertarget glbase.Enum, renderbuffer glbase.Renderbuffer) { + C.gles2_glFramebufferRenderbuffer(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(renderbuffertarget), C.GLuint(renderbuffer)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFramebufferTexture2D.xml +func (gl *GL) FramebufferTexture2D(target, attachment, textarget glbase.Enum, texture glbase.Texture, level int) { + C.gles2_glFramebufferTexture2D(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(textarget), C.GLuint(texture), C.GLint(level)) +} + +// GenBuffers returns n buffer object names. There is no guarantee that +// the names form a contiguous set of integers; however, it is guaranteed +// that none of the returned names was in use immediately before the call to +// GenBuffers. +// +// Buffer object names returned by a call to GenBuffers are not returned by +// subsequent calls, unless they are first deleted with DeleteBuffers. +// +// No buffer objects are associated with the returned buffer object names +// until they are first bound by calling BindBuffer. +// +// Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION +// is generated if GenBuffers is executed between the execution of Begin +// and the corresponding execution of End. +// +// GenBuffers is available in GL version 1.5 or greater. +func (gl *GL) GenBuffers(n int) []glbase.Buffer { + if n == 0 { + return nil + } + buffers := make([]glbase.Buffer, n) + C.gles2_glGenBuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&buffers[0]))) + return buffers +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGenerateMipmap.xml +func (gl *GL) GenerateMipmap(target glbase.Enum) { + C.gles2_glGenerateMipmap(gl.funcs, C.GLenum(target)) +} + +// GenFramebuffers returns n framebuffer object names in ids. There is no +// guarantee that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenFramebuffers. +// +// Framebuffer object names returned by a call to GenFramebuffers are not +// returned by subsequent calls, unless they are first deleted with +// DeleteFramebuffers. +// +// The names returned in ids are marked as used, for the purposes of +// GenFramebuffers only, but they acquire state and type only when they are +// first bound. +// +// Error GL.INVALID_VALUE is generated if n is negative. +func (gl *GL) GenFramebuffers(n int) []glbase.Framebuffer { + if n == 0 { + return nil + } + framebuffers := make([]glbase.Framebuffer, n) + C.gles2_glGenFramebuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&framebuffers[0]))) + return framebuffers +} + +// GenRenderbuffers returns n renderbuffer object names in renderbuffers. +// There is no guarantee that the names form a contiguous set of integers; +// however, it is guaranteed that none of the returned names was in use +// immediately before the call to GenRenderbuffers. +// +// Renderbuffer object names returned by a call to GenRenderbuffers are not +// returned by subsequent calls, unless they are first deleted with +// DeleteRenderbuffers. +// +// The names returned in renderbuffers are marked as used, for the purposes +// of GenRenderbuffers only, but they acquire state and type only when they +// are first bound. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenRenderbuffers is available in GL version 3.0 or greater. +func (gl *GL) GenRenderbuffers(n int) []glbase.Renderbuffer { + if n == 0 { + return nil + } + renderbuffers := make([]glbase.Renderbuffer, n) + C.gles2_glGenRenderbuffers(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&renderbuffers[0]))) + return renderbuffers +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetActiveAttrib.xml +func (gl *GL) GetActiveAttrib(program glbase.Program, index glbase.Attrib, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gles2_glGetActiveAttrib(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetActiveUniform.xml +func (gl *GL) GetActiveUniform(program glbase.Program, index uint32, bufSize int32, length []int32, size []int, gltype []glbase.Enum, name []byte) { + C.gles2_glGetActiveUniform(gl.funcs, C.GLuint(program), C.GLuint(index), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLint)(unsafe.Pointer(&size[0])), (*C.GLenum)(unsafe.Pointer(&gltype[0])), (*C.GLchar)(unsafe.Pointer(&name[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetAttachedShaders.xml +func (gl *GL) GetAttachedShaders(program glbase.Program, maxcount int32, count []int, shaders []glbase.Shader) { + C.gles2_glGetAttachedShaders(gl.funcs, C.GLuint(program), C.GLsizei(maxcount), (*C.GLsizei)(unsafe.Pointer(&count[0])), (*C.GLuint)(unsafe.Pointer(&shaders[0]))) +} + +// GetAttribLocation queries the previously linked program object specified +// by program for the attribute variable specified by name and returns the +// index of the generic vertex attribute that is bound to that attribute +// variable. If name is a matrix attribute variable, the index of the first +// column of the matrix is returned. If the named attribute variable is not +// an active attribute in the specified program object or if name starts with +// the reserved prefix "gl_", a value of -1 is returned. +// +// The association between an attribute variable name and a generic attribute +// index can be specified at any time by calling BindAttribLocation. +// Attribute bindings do not go into effect until LinkProgram is called. +// After a program object has been linked successfully, the index values for +// attribute variables remain fixed until the next link command occurs. The +// attribute values can only be queried after a link if the link was +// successful. GetAttribLocation returns the binding that actually went +// into effect the last time LinkProgram was called for the specified +// program object. Attribute bindings that have been specified since the last +// link operation are not returned by GetAttribLocation. +// +// Error GL_INVALID_OPERATION is generated if program is not a value +// generated by OpenGL. GL_INVALID_OPERATION is generated if program is not +// a program object. GL_INVALID_OPERATION is generated if program has not +// been successfully linked. GL_INVALID_OPERATION is generated if +// GetAttribLocation is executed between the execution of Begin and the +// corresponding execution of End. +// +// GetAttribLocation is available in GL version 2.0 or greater. +func (gl *GL) GetAttribLocation(program glbase.Program, name string) glbase.Attrib { + name_cstr := C.CString(name) + glresult := C.gles2_glGetAttribLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) + return glbase.Attrib(glresult) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetBufferParameteriv.xml +func (gl *GL) GetBufferParameteriv(target, pname glbase.Enum, params []int32) { + C.gles2_glGetBufferParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetFramebufferAttachmentParameteriv.xml +func (gl *GL) GetFramebufferAttachmentParameteriv(target, attachment, pname glbase.Enum, params []int32) { + C.gles2_glGetFramebufferAttachmentParameteriv(gl.funcs, C.GLenum(target), C.GLenum(attachment), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// GetProgramiv returns in params the value of a parameter for a specific +// program object. The following parameters are defined: +// +// GL.DELETE_STATUS +// params returns GL.TRUE if program is currently flagged for deletion, +// and GL.FALSE otherwise. +// +// GL.LINK_STATUS +// params returns GL.TRUE if the last link operation on program was +// successful, and GL.FALSE otherwise. +// +// GL.VALIDATE_STATUS +// params returns GL.TRUE or if the last validation operation on +// program was successful, and GL.FALSE otherwise. +// +// GL.INFO_LOG_LENGTH +// params returns the number of characters in the information log for +// program including the null termination character (the size of +// the character buffer required to store the information log). If +// program has no information log, a value of 0 is returned. +// +// GL.ATTACHED_SHADERS +// params returns the number of shader objects attached to program. +// +// GL.ACTIVE_ATTRIBUTES +// params returns the number of active attribute variables for program. +// +// GL.ACTIVE_ATTRIBUTE_MAX_LENGTH +// params returns the length of the longest active attribute name for +// program, including the null termination character (the size of +// the character buffer required to store the longest attribute name). +// If no active attributes exist, 0 is returned. +// +// GL.ACTIVE_UNIFORMS +// params returns the number of active uniform variables for program. +// +// GL.ACTIVE_UNIFORM_MAX_LENGTH +// params returns the length of the longest active uniform variable +// name for program, including the null termination character (i.e., +// the size of the character buffer required to store the longest +// uniform variable name). If no active uniform variables exist, 0 is +// returned. +// +// GL.TRANSFORM_FEEDBACK_BUFFER_MODE +// params returns a symbolic constant indicating the buffer mode used +// when transform feedback is active. This may be GL.SEPARATE_ATTRIBS +// or GL.INTERLEAVED_ATTRIBS. +// +// GL.TRANSFORM_FEEDBACK_VARYINGS +// params returns the number of varying variables to capture in transform +// feedback mode for the program. +// +// GL.TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH +// params returns the length of the longest variable name to be used for +// transform feedback, including the null-terminator. +// +// GL.GEOMETRY_VERTICES_OUT +// params returns the maximum number of vertices that the geometry shader in +// program will output. +// +// GL.GEOMETRY_INPUT_TYPE +// params returns a symbolic constant indicating the primitive type accepted +// as input to the geometry shader contained in program. +// +// GL.GEOMETRY_OUTPUT_TYPE +// params returns a symbolic constant indicating the primitive type that will +// be output by the geometry shader contained in program. +// +// GL.ACTIVE_UNIFORM_BLOCKS and GL.ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH are +// available only if the GL version 3.1 or greater. +// +// GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE and +// GL.GEOMETRY_OUTPUT_TYPE are accepted only if the GL version is 3.2 or +// greater. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program does not refer to a +// program object. GL.INVALID_OPERATION is generated if pname is +// GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE, or +// GL.GEOMETRY_OUTPUT_TYPE, and program does not contain a geometry shader. +// GL.INVALID_ENUM is generated if pname is not an accepted value. +func (gl *GL) GetProgramiv(program glbase.Program, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gles2_glGetProgramiv(gl.funcs, C.GLuint(program), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetProgramInfoLog returns the information log for the specified program +// object. The information log for a program object is modified when the +// program object is linked or validated. +// +// The information log for a program object is either an empty string, or a +// string containing information about the last link operation, or a string +// containing information about the last validation operation. It may contain +// diagnostic messages, warning messages, and other information. When a +// program object is created, its information log will be a string of length +// 0, and the size of the current log can be obtained by calling GetProgramiv +// with the value GL.INFO_LOG_LENGTH. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated +// by OpenGL. GL.INVALID_OPERATION is generated if program is not a +// program object. +func (gl *GL) GetProgramInfoLog(program glbase.Program) []byte { + var params [1]int32 + var length int32 + gl.GetProgramiv(program, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + C.gles2_glGetProgramInfoLog(gl.funcs, C.GLuint(program), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length)), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) + return infoLog +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetRenderbufferParameteriv.xml +func (gl *GL) GetRenderbufferParameteriv(target, pname glbase.Enum, params []int32) { + C.gles2_glGetRenderbufferParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// GetShaderiv GetShader returns in params the value of a parameter for a specific +// shader object. The following parameters are defined: +// +// GL.SHADER_TYPE +// params returns GL.VERTEX_SHADER if shader is a vertex shader object, +// and GL.FRAGMENT_SHADER if shader is a fragment shader object. +// +// GL.DELETE_STATUS +// params returns GL.TRUE if shader is currently flagged for deletion, +// and GL.FALSE otherwise. +// +// GL.COMPILE_STATUS +// params returns GL.TRUE if the last compile operation on shader was +// successful, and GL.FALSE otherwise. +// +// GL.INFO_LOG_LENGTH +// params returns the number of characters in the information log for +// shader including the null termination character (the size of the +// character buffer required to store the information log). If shader has +// no information log, a value of 0 is returned. +// +// GL.SHADER_SOURCE_LENGTH +// params returns the length of the concatenation of the source strings +// that make up the shader source for the shader, including the null +// termination character. (the size of the character buffer +// required to store the shader source). If no source code exists, 0 is +// returned. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader does not refer to a +// shader object. GL.INVALID_ENUM is generated if pname is not an accepted +// value. GL.INVALID_OPERATION is generated if GetShader is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetShaderiv is available in GL version 2.0 or greater. +func (gl *GL) GetShaderiv(shader glbase.Shader, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gles2_glGetShaderiv(gl.funcs, C.GLuint(shader), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetShaderInfoLog returns the information log for the specified shader +// object. The information log for a shader object is modified when the +// shader is compiled. +// +// The information log for a shader object is a string that may contain +// diagnostic messages, warning messages, and other information about the +// last compile operation. When a shader object is created, its information +// log will be a string of length 0, and the size of the current log can be +// obtained by calling GetShaderiv with the value GL.INFO_LOG_LENGTH. +// +// The information log for a shader object is the OpenGL implementer's +// primary mechanism for conveying information about the compilation process. +// Therefore, the information log can be helpful to application developers +// during the development process, even when compilation is successful. +// Application developers should not expect different OpenGL implementations +// to produce identical information logs. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_VALUE is generated if maxLength is less than 0. +// GL.INVALID_OPERATION is generated if GetShaderInfoLog is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetShaderInfoLog is available in GL version 2.0 or greater. +func (gl *GL) GetShaderInfoLog(shader glbase.Shader) []byte { + var params [1]int32 + var length int32 + gl.GetShaderiv(shader, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + C.gles2_glGetShaderInfoLog(gl.funcs, C.GLuint(shader), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length)), (*C.GLchar)(unsafe.Pointer(&infoLog[0]))) + return infoLog +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetShaderPrecisionFormat.xml +func (gl *GL) GetShaderPrecisionFormat(shadertype, precisionType glbase.Enum, range_, precision []int32) { + C.gles2_glGetShaderPrecisionFormat(gl.funcs, C.GLenum(shadertype), C.GLenum(precisionType), (*C.GLint)(unsafe.Pointer(&range_[0])), (*C.GLint)(unsafe.Pointer(&precision[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetShaderSource.xml +func (gl *GL) GetShaderSource(shader glbase.Shader, bufSize int32, length []int32, source []byte) { + C.gles2_glGetShaderSource(gl.funcs, C.GLuint(shader), C.GLsizei(bufSize), (*C.GLsizei)(unsafe.Pointer(&length[0])), (*C.GLchar)(unsafe.Pointer(&source[0]))) +} + +// GetUniformfv returns in params the value of the specified uniform +// variable. The type of the uniform variable specified by location +// determines the number of values returned. If the uniform variable is +// defined in the shader as a boolean, int, or float, a single value will be +// returned. If it is defined as a vec2, ivec2, or bvec2, two values will be +// returned. If it is defined as a vec3, ivec3, or bvec3, three values will +// be returned, and so on. To query values stored in uniform variables +// declared as arrays, call GetUniformfv for each element of the array. To +// query values stored in uniform variables declared as structures, call +// GetUniformfv for each field in the structure. The values for uniform +// variables declared as a matrix will be returned in column major order. +// +// The locations assigned to uniform variables are not known until the +// program object is linked. After linking has occurred, the command +// GetUniformLocation can be used to obtain the location of a uniform +// variable. This location value can then be passed to GetUniformfv in order +// to query the current value of the uniform variable. After a program object +// has been linked successfully, the index values for uniform variables +// remain fixed until the next link command occurs. The uniform variable +// values can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if program has not been +// successfully linked. GL.INVALID_OPERATION is generated if location does +// not correspond to a valid uniform variable location for the specified +// program object. GL.INVALID_OPERATION is generated if GetUniformfv is +// executed between the execution of Begin and the corresponding execution of +// End. +// +// GetUniformfv is available in GL version 2.0 or greater. +func (gl *GL) GetUniformfv(program glbase.Program, location glbase.Uniform, params []float32) { + var params_c [4]float32 + C.gles2_glGetUniformfv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLfloat)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformiv returns in params the value of the specified uniform +// variable. The type of the uniform variable specified by location +// determines the number of values returned. If the uniform variable is +// defined in the shader as a boolean, int, or float, a single value will be +// returned. If it is defined as a vec2, ivec2, or bvec2, two values will be +// returned. If it is defined as a vec3, ivec3, or bvec3, three values will +// be returned, and so on. To query values stored in uniform variables +// declared as arrays, call GetUniformiv for each element of the array. To +// query values stored in uniform variables declared as structures, call +// GetUniformiv for each field in the structure. The values for uniform +// variables declared as a matrix will be returned in column major order. +// +// The locations assigned to uniform variables are not known until the +// program object is linked. After linking has occurred, the command +// GetUniformLocation can be used to obtain the location of a uniform +// variable. This location value can then be passed to GetUniformiv in order +// to query the current value of the uniform variable. After a program object +// has been linked successfully, the index values for uniform variables +// remain fixed until the next link command occurs. The uniform variable +// values can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if program has not been +// successfully linked. GL.INVALID_OPERATION is generated if location does +// not correspond to a valid uniform variable location for the specified +// program object. GL.INVALID_OPERATION is generated if GetUniformiv is +// executed between the execution of Begin and the corresponding execution of +// End. +// +// GetUniformiv is available in GL version 2.0 or greater. +func (gl *GL) GetUniformiv(program glbase.Program, location glbase.Uniform, params []int32) { + var params_c [4]int32 + C.gles2_glGetUniformiv(gl.funcs, C.GLuint(program), C.GLint(location), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetUniformLocation returns an integer that represents the location of a +// specific uniform variable within a program object. name must be an active +// uniform variable name in program that is not a structure, an array of +// structures, or a subcomponent of a vector or a matrix. This function +// returns -1 if name does not correspond to an active uniform variable in +// program or if name starts with the reserved prefix "gl_". +// +// Uniform variables that are structures or arrays of structures may be +// queried by calling GetUniformLocation for each field within the +// structure. The array element operator "[]" and the structure field +// operator "." may be used in name in order to select elements within an +// array or fields within a structure. The result of using these operators is +// not allowed to be another structure, an array of structures, or a +// subcomponent of a vector or a matrix. Except if the last part of name +// indicates a uniform variable array, the location of the first element of +// an array can be retrieved by using the name of the array, or by using the +// name appended by "[0]". +// +// The actual locations assigned to uniform variables are not known until the +// program object is linked successfully. After linking has occurred, the +// command GetUniformLocation can be used to obtain the location of a +// uniform variable. This location value can then be passed to Uniform to +// set the value of the uniform variable or to GetUniform in order to query +// the current value of the uniform variable. After a program object has been +// linked successfully, the index values for uniform variables remain fixed +// until the next link command occurs. Uniform variable locations and values +// can only be queried after a link if the link was successful. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program object. +// GL.INVALID_OPERATION is generated if program has not been successfully +// linked. GL.INVALID_OPERATION is generated if GetUniformLocation is executed +// between the execution of Begin and the corresponding execution of End. +// +// GetUniformLocation is available in GL version 2.0 or greater. +func (gl *GL) GetUniformLocation(program glbase.Program, name string) glbase.Uniform { + name_cstr := C.CString(name) + glresult := C.gles2_glGetUniformLocation(gl.funcs, C.GLuint(program), (*C.GLchar)(name_cstr)) + C.free(unsafe.Pointer(name_cstr)) + return glbase.Uniform(glresult) +} + +// GetVertexAttribfv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribfv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribfv(index glbase.Attrib, pname glbase.Enum, params []float32) { + var params_c [4]float32 + C.gles2_glGetVertexAttribfv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// GetVertexAttribiv returns in params the value of a generic vertex attribute +// parameter. The generic vertex attribute to be queried is specified by +// index, and the parameter to be queried is specified by pname. +// +// The accepted parameter names are as follows: +// +// GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +// params returns a single value, the name of the buffer object +// currently bound to the binding point corresponding to generic vertex +// attribute array index. If no buffer object is bound, 0 is returned. +// The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_ENABLED +// params returns a single value that is non-zero (true) if the vertex +// attribute array for index is enabled and 0 (false) if it is +// disabled. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_SIZE +// params returns a single value, the size of the vertex attribute +// array for index. The size is the number of values for each element +// of the vertex attribute array, and it will be 1, 2, 3, or 4. The +// initial value is 4. +// +// GL.VERTEX_ATTRIB_ARRAY_STRIDE +// params returns a single value, the array stride for (number of bytes +// between successive elements in) the vertex attribute array for +// index. A value of 0 indicates that the array elements are stored +// sequentially in memory. The initial value is 0. +// +// GL.VERTEX_ATTRIB_ARRAY_TYPE +// params returns a single value, a symbolic constant indicating the +// array type for the vertex attribute array for index. Possible values +// are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, +// GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is +// GL.FLOAT. +// +// GL.VERTEX_ATTRIB_ARRAY_NORMALIZED +// params returns a single value that is non-zero (true) if fixed-point +// data types for the vertex attribute array indicated by index are +// normalized when they are converted to floating point, and 0 (false) +// otherwise. The initial value is 0. +// +// GL.CURRENT_VERTEX_ATTRIB +// params returns four values that represent the current value for the +// generic vertex attribute specified by index. Generic vertex +// attribute 0 is unique in that it has no current state, so an error +// will be generated if index is 0. The initial value for all other +// generic vertex attributes is (0,0,0,1). +// +// All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent +// client-side state. +// +// Error GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an +// accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname +// is GL.CURRENT_VERTEX_ATTRIB. +// +// GetVertexAttribiv is available in GL version 2.0 or greater. +func (gl *GL) GetVertexAttribiv(index glbase.Attrib, pname glbase.Enum, params []int32) { + var params_c [4]int32 + C.gles2_glGetVertexAttribiv(gl.funcs, C.GLuint(index), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms_c[0]))) + copy(params, params_c[:]) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsBuffer.xml +func (gl *GL) IsBuffer(buffer glbase.Buffer) bool { + glresult := C.gles2_glIsBuffer(gl.funcs, C.GLuint(buffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsFramebuffer.xml +func (gl *GL) IsFramebuffer(framebuffer glbase.Framebuffer) bool { + glresult := C.gles2_glIsFramebuffer(gl.funcs, C.GLuint(framebuffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsProgram.xml +func (gl *GL) IsProgram(program glbase.Program) bool { + glresult := C.gles2_glIsProgram(gl.funcs, C.GLuint(program)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsRenderbuffer.xml +func (gl *GL) IsRenderbuffer(renderbuffer glbase.Renderbuffer) bool { + glresult := C.gles2_glIsRenderbuffer(gl.funcs, C.GLuint(renderbuffer)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsShader.xml +func (gl *GL) IsShader(shader glbase.Shader) bool { + glresult := C.gles2_glIsShader(gl.funcs, C.GLuint(shader)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// LinkProgram links the program object specified by program. If any shader +// objects of type GL.VERTEX_SHADER are attached to program, they will be +// used to create an executable that will run on the programmable vertex +// processor. If any shader objects of type GL.FRAGMENT_SHADER are attached +// to program, they will be used to create an executable that will run on the +// programmable fragment processor. +// +// The status of the link operation will be stored as part of the program +// object's state. This value will be set to GL.TRUE if the program object +// was linked without errors and is ready for use, and GL.FALSE otherwise. It +// can be queried by calling GetProgramiv with arguments program and +// GL.LINK_STATUS. +// +// As a result of a successful link operation, all active user-defined +// uniform variables belonging to program will be initialized to 0, and each +// of the program object's active uniform variables will be assigned a +// location that can be queried by calling GetUniformLocation. Also, any +// active user-defined attribute variables that have not been bound to a +// generic vertex attribute index will be bound to one at this time. +// +// Linking of a program object can fail for a number of reasons as specified +// in the OpenGL Shading Language Specification. The following lists some of +// the conditions that will cause a link error. +// +// - The number of active attribute variables supported by the +// implementation has been exceeded. +// +// - The storage limit for uniform variables has been exceeded. +// +// - The number of active uniform variables supported by the implementation +// has been exceeded. +// +// - The main function is missing for the vertex shader or the fragment +// shader. +// +// - A varying variable actually used in the fragment shader is not +// declared in the same way (or is not declared at all) in the vertex +// shader. +// +// - A reference to a function or variable name is unresolved. +// +// - A shared global is declared with two different types or two different +// initial values. +// +// - One or more of the attached shader objects has not been successfully +// compiled. +// +// - Binding a generic attribute matrix caused some rows of the matrix to +// fall outside the allowed maximum of GL.MAX_VERTEX_ATTRIBS. +// +// - Not enough contiguous vertex attribute slots could be found to bind +// attribute matrices. +// +// When a program object has been successfully linked, the program object can +// be made part of current state by calling UseProgram. Whether or not the +// link operation was successful, the program object's information log will +// be overwritten. The information log can be retrieved by calling +// GetProgramInfoLog. +// +// LinkProgram will also install the generated executables as part of the +// current rendering state if the link operation was successful and the +// specified program object is already currently in use as a result of a +// previous call to UseProgram. If the program object currently in use is +// relinked unsuccessfully, its link status will be set to GL.FALSE , but the +// executables and associated state will remain part of the current state +// until a subsequent call to UseProgram removes it from use. After it is +// removed from use, it cannot be made part of current state until it has +// been successfully relinked. +// +// If program contains shader objects of type GL.VERTEX_SHADER but does not +// contain shader objects of type GL.FRAGMENT_SHADER, the vertex shader will +// be linked against the implicit interface for fixed functionality fragment +// processing. Similarly, if program contains shader objects of type +// GL.FRAGMENT_SHADER but it does not contain shader objects of type +// GL.VERTEX_SHADER, the fragment shader will be linked against the implicit +// interface for fixed functionality vertex processing. +// +// The program object's information log is updated and the program is +// generated at the time of the link operation. After the link operation, +// applications are free to modify attached shader objects, compile attached +// shader objects, detach shader objects, delete shader objects, and attach +// additional shader objects. None of these operations affects the +// information log or the program that is part of the program object. +// +// If the link operation is unsuccessful, any information about a previous +// link operation on program is lost (a failed link does not restore the +// old state of program). Certain information can still be retrieved +// from program even after an unsuccessful link operation. See for instance +// GetActiveAttrib and GetActiveUniform. +// +// Error GL.INVALID_VALUE is generated if program is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if program is not a program +// object. GL.INVALID_OPERATION is generated if LinkProgram is executed +// between the execution of Begin and the corresponding execution of End. +// +// LinkProgram is available in GL version 2.0 or greater. +func (gl *GL) LinkProgram(program glbase.Program) { + C.gles2_glLinkProgram(gl.funcs, C.GLuint(program)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glReleaseShaderCompiler.xml +func (gl *GL) ReleaseShaderCompiler() { + C.gles2_glReleaseShaderCompiler(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glRenderbufferStorage.xml +func (gl *GL) RenderbufferStorage(target, internalFormat glbase.Enum, width, height int) { + C.gles2_glRenderbufferStorage(gl.funcs, C.GLenum(target), C.GLenum(internalFormat), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glSampleCoverage.xml +func (gl *GL) SampleCoverage(value glbase.Clampf, invert bool) { + C.gles2_glSampleCoverage(gl.funcs, C.GLclampf(value), *(*C.GLboolean)(unsafe.Pointer(&invert))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glShaderBinary.xml +func (gl *GL) ShaderBinary(n int, shaders []glbase.Shader, binaryFormat glbase.Enum, binary interface{}, length int32) { + var binary_ptr unsafe.Pointer + var binary_v = reflect.ValueOf(binary) + if binary != nil && binary_v.Kind() != reflect.Slice { + panic("parameter binary must be a slice") + } + if binary != nil { + binary_ptr = unsafe.Pointer(binary_v.Index(0).Addr().Pointer()) + } + C.gles2_glShaderBinary(gl.funcs, C.GLint(n), (*C.GLuint)(unsafe.Pointer(&shaders[0])), C.GLenum(binaryFormat), binary_ptr, C.GLint(length)) +} + +// ShaderSource sets the source code in shader to the provided source code. Any source +// code previously stored in the shader object is completely replaced. +// +// Error GL.INVALID_VALUE is generated if shader is not a value generated by +// OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader +// object. GL.INVALID_VALUE is generated if count is less than 0. +// GL.INVALID_OPERATION is generated if ShaderSource is executed between the +// execution of Begin and the corresponding execution of End. +// +// ShaderSource is available in GL version 2.0 or greater. +func (gl *GL) ShaderSource(shader glbase.Shader, source ...string) { + count := len(source) + length := make([]int32, count) + source_c := make([]unsafe.Pointer, count) + for i, src := range source { + length[i] = int32(len(src)) + if len(src) > 0 { + source_c[i] = *(*unsafe.Pointer)(unsafe.Pointer(&src)) + } else { + source_c[i] = unsafe.Pointer(uintptr(0)) + } + } + C.gles2_glShaderSource(gl.funcs, C.GLuint(shader), C.GLsizei(count), (**C.GLchar)(unsafe.Pointer(&source_c[0])), (*C.GLint)(unsafe.Pointer(&length[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilFuncSeparate.xml +func (gl *GL) StencilFuncSeparate(face, glfunc glbase.Enum, ref int32, mask uint32) { + C.gles2_glStencilFuncSeparate(gl.funcs, C.GLenum(face), C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilMaskSeparate.xml +func (gl *GL) StencilMaskSeparate(face glbase.Enum, mask uint32) { + C.gles2_glStencilMaskSeparate(gl.funcs, C.GLenum(face), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilOpSeparate.xml +func (gl *GL) StencilOpSeparate(face, fail, zfail, zpass glbase.Enum) { + C.gles2_glStencilOpSeparate(gl.funcs, C.GLenum(face), C.GLenum(fail), C.GLenum(zfail), C.GLenum(zpass)) +} + +// Uniform1f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1f(location glbase.Uniform, v0 float32) { + C.gles2_glUniform1f(gl.funcs, C.GLint(location), C.GLfloat(v0)) +} + +// Uniform1fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + count := len(value) + C.gles2_glUniform1fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform1i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform1i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1i(location glbase.Uniform, v0 int32) { + C.gles2_glUniform1i(gl.funcs, C.GLint(location), C.GLint(v0)) +} + +// Uniform1iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform1iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform1iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + count := len(value) + C.gles2_glUniform1iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform2f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2f(location glbase.Uniform, v0, v1 float32) { + C.gles2_glUniform2f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1)) +} + +// Uniform2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2fv") + } + count := len(value) / 2 + C.gles2_glUniform2fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform2i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform2i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2i(location glbase.Uniform, v0, v1 int32) { + C.gles2_glUniform2i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1)) +} + +// Uniform2iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform2iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform2iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%2 != 0 { + panic("invalid value length for Uniform2iv") + } + count := len(value) / 2 + C.gles2_glUniform2iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform3f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3f(location glbase.Uniform, v0, v1, v2 float32) { + C.gles2_glUniform3f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2)) +} + +// Uniform3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3fv") + } + count := len(value) / 3 + C.gles2_glUniform3fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform3i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform3i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3i(location glbase.Uniform, v0, v1, v2 int32) { + C.gles2_glUniform3i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2)) +} + +// Uniform3iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform3iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform3iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%3 != 0 { + panic("invalid value length for Uniform3iv") + } + count := len(value) / 3 + C.gles2_glUniform3iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// Uniform4f modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4f operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4f(location glbase.Uniform, v0, v1, v2, v3 float32) { + C.gles2_glUniform4f(gl.funcs, C.GLint(location), C.GLfloat(v0), C.GLfloat(v1), C.GLfloat(v2), C.GLfloat(v3)) +} + +// Uniform4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4fv(location glbase.Uniform, value []float32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4fv") + } + count := len(value) / 4 + C.gles2_glUniform4fv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// Uniform4i modifies the value of a single uniform variable. +// The location of the uniform variable to be modified is specified by +// location, which should be a value returned by GetUniformLocation. +// Uniform4i operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the +// uniform variable specified by location using the values passed as +// arguments. The number specified in the function should match the number of +// components in the data type of the specified uniform variable (1 for +// float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). +// The suffix f indicates that floating-point values are being passed; the +// suffix i indicates that integer values are being passed; the suffix ui +// indicates that unsigned integer values are being passed, and this type +// should also match the data type of the specified uniform variable. The i +// variants of this function should be used to provide values for uniform +// variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui +// variants of this function should be used to provide values for uniform +// variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of +// these. The f variants should be used to provide values for uniform +// variables of type float, vec2, vec3, vec4, or arrays of these. Either the +// i, ui or f variants may be used to provide values for uniform variables of +// type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable +// will be set to false if the input value is 0 or 0.0f, and it will be set +// to true otherwise. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4i(location glbase.Uniform, v0, v1, v2, v3 int32) { + C.gles2_glUniform4i(gl.funcs, C.GLint(location), C.GLint(v0), C.GLint(v1), C.GLint(v2), C.GLint(v3)) +} + +// Uniform4iv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// Uniform4iv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single +// uniform variable or a uniform variable array. These functions receive a +// slice with the values to be loaded into a uniform variable or a uniform +// variable array. A slice with length 1 should be used if modifying the value +// of a single uniform variable, and a length of 1 or greater can be used to +// modify an entire array or part of an array. When loading n elements +// starting at an arbitrary position m in a uniform variable array, elements +// m + n - 1 in the array will be replaced with the new values. If m + n - 1 +// is larger than the size of the uniform variable array, values for all +// array elements beyond the end of the array will be ignored. The number +// specified in the name of the command indicates the number of components +// for each element in value, and it should match the number of components in +// the data type of the specified uniform variable (1 for float, int, bool; +// 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name +// of the command must match the data type for the specified uniform variable +// as described for Uniform{1|2|3|4}{f|i|ui}. +// +// Uniform1i and Uniform1iv are the only two functions that may be used to +// load uniform variables defined as sampler types. Loading samplers with any +// other function will result in a GL.INVALID_OPERATION error. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) Uniform4iv(location glbase.Uniform, value []int32) { + if len(value) == 0 { + return + } + if len(value)%4 != 0 { + panic("invalid value length for Uniform4iv") + } + count := len(value) / 4 + C.gles2_glUniform4iv(gl.funcs, C.GLint(location), C.GLsizei(count), (*C.GLint)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix2fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix2fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix2fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(2*2) != 0 { + panic("invalid value length for UniformMatrix2fv") + } + count := len(value) / (2 * 2) + C.gles2_glUniformMatrix2fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix3fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix3fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix3fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(3*3) != 0 { + panic("invalid value length for UniformMatrix3fv") + } + count := len(value) / (3 * 3) + C.gles2_glUniformMatrix3fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UniformMatrix4fv modifies the value of a uniform variable or a uniform +// variable array. The location of the uniform variable to be modified is +// specified by location, which should be a value returned by GetUniformLocation. +// UniformMatrix4fv operates on the program object that was made part of +// current state by calling UseProgram. +// +// The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to +// modify a matrix or an array of matrices. The numbers in the function name +// are interpreted as the dimensionality of the matrix. The number 2 +// indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 +// values), and the number 4 indicates a 4x4 matrix (16 values). Non-square +// matrix dimensionality is explicit, with the first number representing the +// number of columns and the second number representing the number of rows. +// For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 +// values). The length of the provided slice must be a multiple of the number +// of values per matrix, to update one or more consecutive matrices. +// +// If transpose is false, each matrix is assumed to be supplied in column +// major order. If transpose is true, each matrix is assumed to be supplied +// in row major order. +// +// All active uniform variables defined in a program object are initialized +// to 0 when the program object is linked successfully. They retain the +// values assigned to them by a call to Uniform* until the next successful +// link operation occurs on the program object, when they are once again +// initialized to 0. +func (gl *GL) UniformMatrix4fv(location glbase.Uniform, transpose bool, value []float32) { + if len(value) == 0 { + return + } + if len(value)%(4*4) != 0 { + panic("invalid value length for UniformMatrix4fv") + } + count := len(value) / (4 * 4) + C.gles2_glUniformMatrix4fv(gl.funcs, C.GLint(location), C.GLsizei(count), *(*C.GLboolean)(unsafe.Pointer(&transpose)), (*C.GLfloat)(unsafe.Pointer(&value[0]))) +} + +// UseProgram installs the program object specified by program as part of +// current rendering state. One or more executables are created in a program +// object by successfully attaching shader objects to it with AttachShader, +// successfully compiling the shader objects with CompileShader, and +// successfully linking the program object with LinkProgram. +// +// A program object will contain an executable that will run on the vertex +// processor if it contains one or more shader objects of type +// GL.VERTEX_SHADER that have been successfully compiled and linked. +// Similarly, a program object will contain an executable that will run on +// the fragment processor if it contains one or more shader objects of type +// GL.FRAGMENT_SHADER that have been successfully compiled and linked. +// +// Successfully installing an executable on a programmable processor will +// cause the corresponding fixed functionality of OpenGL to be disabled. +// Specifically, if an executable is installed on the vertex processor, the +// OpenGL fixed functionality will be disabled as follows. +// +// - The modelview matrix is not applied to vertex coordinates. +// +// - The projection matrix is not applied to vertex coordinates. +// +// - The texture matrices are not applied to texture coordinates. +// +// - Normals are not transformed to eye coordinates. +// +// - Normals are not rescaled or normalized. +// +// - Normalization of GL.AUTO_NORMAL evaluated normals is not performed. +// +// - Texture coordinates are not generated automatically. +// +// - Per-vertex lighting is not performed. +// +// - Color material computations are not performed. +// +// - Color index lighting is not performed. +// +// - This list also applies when setting the current raster position. +// +// The executable that is installed on the vertex processor is expected to +// implement any or all of the desired functionality from the preceding list. +// Similarly, if an executable is installed on the fragment processor, the +// OpenGL fixed functionality will be disabled as follows. +// +// - Texture environment and texture functions are not applied. +// +// - Texture application is not applied. +// +// - Color sum is not applied. +// +// - Fog is not applied. +// +// Again, the fragment shader that is installed is expected to implement any +// or all of the desired functionality from the preceding list. +// +// While a program object is in use, applications are free to modify attached +// shader objects, compile attached shader objects, attach additional shader +// objects, and detach or delete shader objects. None of these operations +// will affect the executables that are part of the current state. However, +// relinking the program object that is currently in use will install the +// program object as part of the current rendering state if the link +// operation was successful (see LinkProgram). If the program object +// currently in use is relinked unsuccessfully, its link status will be set +// to GL.FALSE, but the executables and associated state will remain part of +// the current state until a subsequent call to UseProgram removes it from +// use. After it is removed from use, it cannot be made part of current state +// until it has been successfully relinked. +// +// If program contains shader objects of type GL.VERTEX_SHADER but it does +// not contain shader objects of type GL.FRAGMENT_SHADER, an executable will +// be installed on the vertex processor, but fixed functionality will be used +// for fragment processing. Similarly, if program contains shader objects of +// type GL.FRAGMENT_SHADER but it does not contain shader objects of type +// GL.VERTEX_SHADER, an executable will be installed on the fragment +// processor, but fixed functionality will be used for vertex processing. If +// program is 0, the programmable processors will be disabled, and fixed +// functionality will be used for both vertex and fragment processing. +// +// While a program object is in use, the state that controls the disabled +// fixed functionality may also be updated using the normal OpenGL calls. +// +// Like display lists and texture objects, the name space for program objects +// may be shared across a set of contexts, as long as the server sides of the +// contexts share the same address space. If the name space is shared across +// contexts, any attached objects and the data associated with those attached +// objects are shared as well. +// +// Applications are responsible for providing the synchronization across API +// calls when objects are accessed from different execution threads. +// +// Error GL.INVALID_VALUE is generated if program is neither 0 nor a value +// generated by OpenGL. GL.INVALID_OPERATION is generated if program is not +// a program object. GL.INVALID_OPERATION is generated if program could not +// be made part of current state. GL.INVALID_OPERATION is generated if +// UseProgram is executed between the execution of Begin and the +// corresponding execution of End. +// +// UseProgram is available in GL version 2.0 or greater. +func (gl *GL) UseProgram(program glbase.Program) { + C.gles2_glUseProgram(gl.funcs, C.GLuint(program)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glValidateProgram.xml +func (gl *GL) ValidateProgram(program glbase.Program) { + C.gles2_glValidateProgram(gl.funcs, C.GLuint(program)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib1f.xml +func (gl *GL) VertexAttrib1f(index glbase.Attrib, x float32) { + C.gles2_glVertexAttrib1f(gl.funcs, C.GLuint(index), C.GLfloat(x)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib1fv.xml +func (gl *GL) VertexAttrib1fv(index glbase.Attrib, values []float32) { + C.gles2_glVertexAttrib1fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib2f.xml +func (gl *GL) VertexAttrib2f(index glbase.Attrib, x, y float32) { + C.gles2_glVertexAttrib2f(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib2fv.xml +func (gl *GL) VertexAttrib2fv(index glbase.Attrib, values []float32) { + if len(values) != 2 { + panic("parameter values has incorrect length") + } + C.gles2_glVertexAttrib2fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib3f.xml +func (gl *GL) VertexAttrib3f(index glbase.Attrib, x, y, z float32) { + C.gles2_glVertexAttrib3f(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib3fv.xml +func (gl *GL) VertexAttrib3fv(index glbase.Attrib, values []float32) { + if len(values) != 3 { + panic("parameter values has incorrect length") + } + C.gles2_glVertexAttrib3fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4f.xml +func (gl *GL) VertexAttrib4f(index glbase.Attrib, x, y, z, w float32) { + C.gles2_glVertexAttrib4f(gl.funcs, C.GLuint(index), C.GLfloat(x), C.GLfloat(y), C.GLfloat(z), C.GLfloat(w)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib4fv.xml +func (gl *GL) VertexAttrib4fv(index glbase.Attrib, values []float32) { + if len(values) != 4 { + panic("parameter values has incorrect length") + } + C.gles2_glVertexAttrib4fv(gl.funcs, C.GLuint(index), (*C.GLfloat)(unsafe.Pointer(&values[0]))) +} + +// VertexAttribPointer specifies the location and data format of the array +// of generic vertex attributes at index to use when rendering. size +// specifies the number of components per attribute and must be 1, 2, 3, or +// 4. type specifies the data type of each component, and stride specifies +// the byte stride from one attribute to the next, allowing vertices and +// attributes to be packed into a single array or stored in separate arrays. +// normalized indicates whether the values stored in an integer format are +// to be mapped to the range [-1,1] (for signed values) or [0,1] +// (for unsigned values) when they are accessed and converted to floating +// point; otherwise, values will be converted to floats directly without +// normalization. offset is a byte offset into the buffer object's data +// store, which must be bound to the GL.ARRAY_BUFFER target with BindBuffer. +// +// The buffer object binding (GL.ARRAY_BUFFER_BINDING) is saved as +// generic vertex attribute array client-side state +// (GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING) for the provided index. +// +// To enable and disable a generic vertex attribute array, call +// EnableVertexAttribArray and DisableVertexAttribArray with index. If +// enabled, the generic vertex attribute array is used when DrawArrays or +// DrawElements is called. Each generic vertex attribute array is initially +// disabled. +// +// VertexAttribPointer is typically implemented on the client side. +// +// Error GL.INVALID_ENUM is generated if type is not an accepted value. +// GL.INVALID_VALUE is generated if index is greater than or equal to +// GL.MAX_VERTEX_ATTRIBS. GL.INVALID_VALUE is generated if size is not 1, 2, +// 3, or 4. GL.INVALID_VALUE is generated if stride is negative. +func (gl *GL) VertexAttribPointer(index glbase.Attrib, size int, gltype glbase.Enum, normalized bool, stride int, offset uintptr) { + offset_ptr := unsafe.Pointer(offset) + C.gles2_glVertexAttribPointer(gl.funcs, C.GLuint(index), C.GLint(size), C.GLenum(gltype), *(*C.GLboolean)(unsafe.Pointer(&normalized)), C.GLsizei(stride), offset_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBindTexture.xml +func (gl *GL) BindTexture(target glbase.Enum, texture glbase.Texture) { + C.gles2_glBindTexture(gl.funcs, C.GLenum(target), C.GLuint(texture)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glBlendFunc.xml +func (gl *GL) BlendFunc(sfactor, dfactor glbase.Enum) { + C.gles2_glBlendFunc(gl.funcs, C.GLenum(sfactor), C.GLenum(dfactor)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClear.xml +func (gl *GL) Clear(mask glbase.Bitfield) { + C.gles2_glClear(gl.funcs, C.GLbitfield(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearColor.xml +func (gl *GL) ClearColor(red, green, blue, alpha glbase.Clampf) { + C.gles2_glClearColor(gl.funcs, C.GLclampf(red), C.GLclampf(green), C.GLclampf(blue), C.GLclampf(alpha)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glClearStencil.xml +func (gl *GL) ClearStencil(s int32) { + C.gles2_glClearStencil(gl.funcs, C.GLint(s)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glColorMask.xml +func (gl *GL) ColorMask(red, green, blue, alpha bool) { + C.gles2_glColorMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&red)), *(*C.GLboolean)(unsafe.Pointer(&green)), *(*C.GLboolean)(unsafe.Pointer(&blue)), *(*C.GLboolean)(unsafe.Pointer(&alpha))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexImage2D.xml +func (gl *GL) CopyTexImage2D(target glbase.Enum, level int, internalFormat glbase.Enum, x, y, width, height, border int) { + C.gles2_glCopyTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLenum(internalFormat), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLint(border)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCopyTexSubImage2D.xml +func (gl *GL) CopyTexSubImage2D(target glbase.Enum, level, xoffset, yoffset, x, y, width, height int) { + C.gles2_glCopyTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glCullFace.xml +func (gl *GL) CullFace(mode glbase.Enum) { + C.gles2_glCullFace(gl.funcs, C.GLenum(mode)) +} + +// DeleteTextures deletes the textures objects whose names are stored +// in the textures slice. After a texture is deleted, it has no contents or +// dimensionality, and its name is free for reuse (for example by +// GenTextures). If a texture that is currently bound is deleted, the binding +// reverts to 0 (the default texture). +// +// DeleteTextures silently ignores 0's and names that do not correspond to +// existing textures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// DeleteTextures is available in GL version 2.0 or greater. +func (gl *GL) DeleteTextures(textures []glbase.Texture) { + n := len(textures) + if n == 0 { + return + } + C.gles2_glDeleteTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDepthFunc.xml +func (gl *GL) DepthFunc(glfunc glbase.Enum) { + C.gles2_glDepthFunc(gl.funcs, C.GLenum(glfunc)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDepthMask.xml +func (gl *GL) DepthMask(flag bool) { + C.gles2_glDepthMask(gl.funcs, *(*C.GLboolean)(unsafe.Pointer(&flag))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDisable.xml +func (gl *GL) Disable(cap glbase.Enum) { + C.gles2_glDisable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawArrays.xml +func (gl *GL) DrawArrays(mode glbase.Enum, first, count int) { + C.gles2_glDrawArrays(gl.funcs, C.GLenum(mode), C.GLint(first), C.GLsizei(count)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glDrawElements.xml +func (gl *GL) DrawElements(mode glbase.Enum, count int, gltype glbase.Enum, indices interface{}) { + var indices_ptr unsafe.Pointer + var indices_v = reflect.ValueOf(indices) + if indices != nil && indices_v.Kind() != reflect.Slice { + panic("parameter indices must be a slice") + } + if indices != nil { + indices_ptr = unsafe.Pointer(indices_v.Index(0).Addr().Pointer()) + } + C.gles2_glDrawElements(gl.funcs, C.GLenum(mode), C.GLsizei(count), C.GLenum(gltype), indices_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glEnable.xml +func (gl *GL) Enable(cap glbase.Enum) { + C.gles2_glEnable(gl.funcs, C.GLenum(cap)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFinish.xml +func (gl *GL) Finish() { + C.gles2_glFinish(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFlush.xml +func (gl *GL) Flush() { + C.gles2_glFlush(gl.funcs) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glFrontFace.xml +func (gl *GL) FrontFace(mode glbase.Enum) { + C.gles2_glFrontFace(gl.funcs, C.GLenum(mode)) +} + +// GenTextures returns n texture names in textures. There is no guarantee +// that the names form a contiguous set of integers; however, it is +// guaranteed that none of the returned names was in use immediately before +// the call to GenTextures. +// +// The generated textures have no dimensionality; they assume the +// dimensionality of the texture target to which they are first bound (see +// BindTexture). +// +// Texture names returned by a call to GenTextures are not returned by +// subsequent calls, unless they are first deleted with DeleteTextures. +// +// Error GL.INVALID_VALUE is generated if n is negative. +// +// GenTextures is available in GL version 2.0 or greater. +func (gl *GL) GenTextures(n int) []glbase.Texture { + if n == 0 { + return nil + } + textures := make([]glbase.Texture, n) + C.gles2_glGenTextures(gl.funcs, C.GLsizei(n), (*C.GLuint)(unsafe.Pointer(&textures[0]))) + return textures +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetBooleanv.xml +func (gl *GL) GetBooleanv(pname glbase.Enum, params []bool) { + C.gles2_glGetBooleanv(gl.funcs, C.GLenum(pname), (*C.GLboolean)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetError.xml +func (gl *GL) GetError() glbase.Enum { + glresult := C.gles2_glGetError(gl.funcs) + return glbase.Enum(glresult) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetFloatv.xml +func (gl *GL) GetFloatv(pname glbase.Enum, params []float32) { + C.gles2_glGetFloatv(gl.funcs, C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetIntegerv.xml +func (gl *GL) GetIntegerv(pname glbase.Enum, params []int32) { + C.gles2_glGetIntegerv(gl.funcs, C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexParameterfv.xml +func (gl *GL) GetTexParameterfv(target, pname glbase.Enum, params []float32) { + C.gles2_glGetTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glGetTexParameteriv.xml +func (gl *GL) GetTexParameteriv(target, pname glbase.Enum, params []int32) { + C.gles2_glGetTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glHint.xml +func (gl *GL) Hint(target, mode glbase.Enum) { + C.gles2_glHint(gl.funcs, C.GLenum(target), C.GLenum(mode)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsEnabled.xml +func (gl *GL) IsEnabled(cap glbase.Enum) bool { + glresult := C.gles2_glIsEnabled(gl.funcs, C.GLenum(cap)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glIsTexture.xml +func (gl *GL) IsTexture(texture glbase.Texture) bool { + glresult := C.gles2_glIsTexture(gl.funcs, C.GLuint(texture)) + return *(*bool)(unsafe.Pointer(&glresult)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glLineWidth.xml +func (gl *GL) LineWidth(width float32) { + C.gles2_glLineWidth(gl.funcs, C.GLfloat(width)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPixelStorei.xml +func (gl *GL) PixelStorei(pname glbase.Enum, param int32) { + C.gles2_glPixelStorei(gl.funcs, C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glPolygonOffset.xml +func (gl *GL) PolygonOffset(factor, units float32) { + C.gles2_glPolygonOffset(gl.funcs, C.GLfloat(factor), C.GLfloat(units)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glReadPixels.xml +func (gl *GL) ReadPixels(x, y, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gles2_glReadPixels(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glScissor.xml +func (gl *GL) Scissor(x, y, width, height int) { + C.gles2_glScissor(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilFunc.xml +func (gl *GL) StencilFunc(glfunc glbase.Enum, ref int32, mask uint32) { + C.gles2_glStencilFunc(gl.funcs, C.GLenum(glfunc), C.GLint(ref), C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilMask.xml +func (gl *GL) StencilMask(mask uint32) { + C.gles2_glStencilMask(gl.funcs, C.GLuint(mask)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glStencilOp.xml +func (gl *GL) StencilOp(fail, zfail, zpass glbase.Enum) { + C.gles2_glStencilOp(gl.funcs, C.GLenum(fail), C.GLenum(zfail), C.GLenum(zpass)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexImage2D.xml +func (gl *GL) TexImage2D(target glbase.Enum, level int, internalFormat int32, width, height, border int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gles2_glTexImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(internalFormat), C.GLsizei(width), C.GLsizei(height), C.GLint(border), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameterf.xml +func (gl *GL) TexParameterf(target, pname glbase.Enum, param float32) { + C.gles2_glTexParameterf(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLfloat(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameterfv.xml +func (gl *GL) TexParameterfv(target, pname glbase.Enum, params []float32) { + C.gles2_glTexParameterfv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLfloat)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameteri.xml +func (gl *GL) TexParameteri(target, pname glbase.Enum, param int32) { + C.gles2_glTexParameteri(gl.funcs, C.GLenum(target), C.GLenum(pname), C.GLint(param)) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexParameteriv.xml +func (gl *GL) TexParameteriv(target, pname glbase.Enum, params []int32) { + C.gles2_glTexParameteriv(gl.funcs, C.GLenum(target), C.GLenum(pname), (*C.GLint)(unsafe.Pointer(¶ms[0]))) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glTexSubImage2D.xml +func (gl *GL) TexSubImage2D(target glbase.Enum, level, xoffset, yoffset, width, height int, format, gltype glbase.Enum, pixels interface{}) { + var pixels_ptr unsafe.Pointer + var pixels_v = reflect.ValueOf(pixels) + if pixels != nil && pixels_v.Kind() != reflect.Slice { + panic("parameter pixels must be a slice") + } + if pixels != nil { + pixels_ptr = unsafe.Pointer(pixels_v.Index(0).Addr().Pointer()) + } + C.gles2_glTexSubImage2D(gl.funcs, C.GLenum(target), C.GLint(level), C.GLint(xoffset), C.GLint(yoffset), C.GLsizei(width), C.GLsizei(height), C.GLenum(format), C.GLenum(gltype), pixels_ptr) +} + +// https://www.opengl.org/sdk/docs/man2/xhtml/glViewport.xml +func (gl *GL) Viewport(x, y, width, height int) { + C.gles2_glViewport(gl.funcs, C.GLint(x), C.GLint(y), C.GLsizei(width), C.GLsizei(height)) +} diff --git a/gl/gengl/Makefile b/gl/gengl/Makefile new file mode 100644 index 00000000..f814cceb --- /dev/null +++ b/gl/gengl/Makefile @@ -0,0 +1,9 @@ + +gengl: main.go parseqt.go + go build + +%.go: %.rl + ragel -Z -G2 -o $@ $< + +run: gengl + ./gengl diff --git a/gl/gengl/funcs.go b/gl/gengl/funcs.go new file mode 100644 index 00000000..994a3e91 --- /dev/null +++ b/gl/gengl/funcs.go @@ -0,0 +1,1764 @@ +package main + +type funcTweak struct { + // name specifies the name of the Go function to be tweaked. + name string + + // copy copies all the definitions for this function tweak from the named + // function. Templates are parsed under the new context. + copy string + + // params specifies a map of zero or more tweaks for specific parameters. + params paramTweaks + + // result defines the function result as presented at the end of the func line. + // Simple type changes are handled automatically. More involved multi-value + // results will require an appropriate after snippet to handle the return. + result string + + // before is a code snippet to be injected before the C function call. + // It may use the following template variables and functions: + // + // . - dot holds the Func being tweaked + // {{copyDoc "Func"}} - replaced by the respective function documentation + // {{paramGoType . "param"}} - replaced by the respective parameter Go type + // + before string + + // after is a code snippet to be injected after the C function call. + // It may use the same template functions as available for before. + after string + + // doc defines the documentation for the function. It may use the same + // template functions as available for before and after. + doc string +} + +type paramTweak struct { + // rename changes the parameter name in the Go function while keeping the C + // function call unchanged. The before snippet must define a proper variable + // to be used under the original name. + rename string + + // replace changes the parameter name in the C function call to a variable + // named "_c", while keeping the Go parameter name unchanged. + // The before and after snippets must manipulate the two values as needed. + replace bool + + // retype changes the Go parameter type. + retype string + + // output flags the parameter as an output parameter, which causes it to be + // omitted from the input parameter list and added to the result list. + output bool + + // unnamed causes the name of a result parameter to be omitted if possible. + unnamed bool + + // single flags the parameter as carrying a single value rather than a slice, + // when the parameter is originally defined as a pointer. + single bool + + // omit drops the parameter from the Go function. The before snippet must + // define a variable with the proper name for the C function call to use. + omit bool +} + +type paramTweaks map[string]paramTweak + +var paramNameFixes = map[string]string{ + "binaryformat": "binaryFormat", + "bufsize": "bufSize", + "indx": "index", + "infolog": "infoLog", + "internalformat": "internalFormat", + "precisiontype": "precisionType", + "ptr": "pointer", +} + +var funcTweakList = []funcTweak{{ + name: "Accum", + doc: ` + executes an operation on the accumulation buffer. + + Parameter op defines the accumulation buffer operation (GL.ACCUM, GL.LOAD, + GL.ADD, GL.MULT, or GL.RETURN) and specifies how the value parameter is + used. + + The accumulation buffer is an extended-range color buffer. Images are not + rendered into it. Rather, images rendered into one of the color buffers + are added to the contents of the accumulation buffer after rendering. + Effects such as antialiasing (of points, lines, and polygons), motion + blur, and depth of field can be created by accumulating images generated + with different transformation matrices. + + Each pixel in the accumulation buffer consists of red, green, blue, and + alpha values. The number of bits per component in the accumulation buffer + depends on the implementation. You can examine this number by calling + GetIntegerv four times, with arguments GL.ACCUM_RED_BITS, + GL.ACCUM_GREEN_BITS, GL.ACCUM_BLUE_BITS, and GL.ACCUM_ALPHA_BITS. + Regardless of the number of bits per component, the range of values stored + by each component is (-1, 1). The accumulation buffer pixels are mapped + one-to-one with frame buffer pixels. + + All accumulation buffer operations are limited to the area of the current + scissor box and applied identically to the red, green, blue, and alpha + components of each pixel. If a Accum operation results in a value outside + the range (-1, 1), the contents of an accumulation buffer pixel component + are undefined. + + The operations are as follows: + + GL.ACCUM + Obtains R, G, B, and A values from the buffer currently selected for + reading (see ReadBuffer). Each component value is divided by 2 n - + 1 , where n is the number of bits allocated to each color component + in the currently selected buffer. The result is a floating-point + value in the range 0 1 , which is multiplied by value and added to + the corresponding pixel component in the accumulation buffer, + thereby updating the accumulation buffer. + + GL.LOAD + Similar to GL.ACCUM, except that the current value in the + accumulation buffer is not used in the calculation of the new value. + That is, the R, G, B, and A values from the currently selected + buffer are divided by 2 n - 1 , multiplied by value, and then stored + in the corresponding accumulation buffer cell, overwriting the + current value. + + GL.ADD + Adds value to each R, G, B, and A in the accumulation buffer. + + GL.MULT + Multiplies each R, G, B, and A in the accumulation buffer by value + and returns the scaled component to its corresponding accumulation + buffer location. + + GL.RETURN + Transfers accumulation buffer values to the color buffer or buffers + currently selected for writing. Each R, G, B, and A component is + multiplied by value, then multiplied by 2 n - 1 , clamped to the + range 0 2 n - 1 , and stored in the corresponding display buffer + cell. The only fragment operations that are applied to this transfer + are pixel ownership, scissor, dithering, and color writemasks. + + To clear the accumulation buffer, call ClearAccum with R, G, B, and A + values to set it to, then call Clear with the accumulation buffer + enabled. + + Error GL.INVALID_ENUM is generated if op is not an accepted value. + GL.INVALID_OPERATION is generated if there is no accumulation buffer. + GL.INVALID_OPERATION is generated if Accum is executed between the + execution of Begin and the corresponding execution of End. + `, +}, { + name: "AttachShader", + doc: ` + attaches a shader object to a program object. + + In order to create an executable, there must be a way to specify the list + of things that will be linked together. Program objects provide this + mechanism. Shaders that are to be linked together in a program object must + first be attached to that program object. This indicates that shader will + be included in link operations that will be performed on program. + + All operations that can be performed on a shader object are valid whether + or not the shader object is attached to a program object. It is + permissible to attach a shader object to a program object before source + code has been loaded into the shader object or before the shader object + has been compiled. It is permissible to attach multiple shader objects of + the same type because each may contain a portion of the complete shader. + It is also permissible to attach a shader object to more than one program + object. If a shader object is deleted while it is attached to a program + object, it will be flagged for deletion, and deletion will not occur until + DetachShader is called to detach it from all program objects to which it + is attached. + + Error GL.INVALID_VALUE is generated if either program or shader is not a + value generated by OpenGL. GL.INVALID_OPERATION is generated if program + is not a program object. GL.INVALID_OPERATION is generated if shader is + not a shader object. GL.INVALID_OPERATION is generated if shader is + already attached to program. GL.INVALID_OPERATION is generated if + AttachShader is executed between the execution of Begin and the + corresponding execution of End. + + {{funcSince . "2.0+"}} + `, +}, { + name: "BindAttribLocation", + params: paramTweaks{ + "name": {retype: "string"}, + }, + doc: ` + associates a user-defined attribute variable in the program + object specified by program with a generic vertex attribute index. The name + parameter specifies the name of the vertex shader attribute variable to + which index is to be bound. When program is made part of the current state, + values provided via the generic vertex attribute index will modify the + value of the user-defined attribute variable specified by name. + + If name refers to a matrix attribute variable, index refers to the first + column of the matrix. Other matrix columns are then automatically bound to + locations index+1 for a matrix of type mat2; index+1 and index+2 for a + matrix of type mat3; and index+1, index+2, and index+3 for a matrix of + type mat4. + + This command makes it possible for vertex shaders to use descriptive names + for attribute variables rather than generic variables that are numbered + from 0 to GL.MAX_VERTEX_ATTRIBS-1. The values sent to each generic + attribute index are part of current state, just like standard vertex + attributes such as color, normal, and vertex position. If a different + program object is made current by calling UseProgram, the generic vertex + attributes are tracked in such a way that the same values will be observed + by attributes in the new program object that are also bound to index. + + Attribute variable name-to-generic attribute index bindings for a program + object can be explicitly assigned at any time by calling + BindAttribLocation. Attribute bindings do not go into effect until + LinkProgram is called. After a program object has been linked + successfully, the index values for generic attributes remain fixed (and + their values can be queried) until the next link command occurs. + + Applications are not allowed to bind any of the standard OpenGL vertex + attributes using this command, as they are bound automatically when + needed. Any attribute binding that occurs after the program object has + been linked will not take effect until the next time the program object is + linked. + + If name was bound previously, that information is lost. Thus you cannot + bind one user-defined attribute variable to multiple indices, but you can + bind multiple user-defined attribute variables to the same index. + + Applications are allowed to bind more than one user-defined attribute + variable to the same generic vertex attribute index. This is called + aliasing, and it is allowed only if just one of the aliased attributes is + active in the executable program, or if no path through the shader + consumes more than one attribute of a set of attributes aliased to the + same location. The compiler and linker are allowed to assume that no + aliasing is done and are free to employ optimizations that work only in + the absence of aliasing. OpenGL implementations are not required to do + error checking to detect aliasing. Because there is no way to bind + standard attributes, it is not possible to alias generic attributes with + conventional ones (except for generic attribute 0). + + BindAttribLocation can be called before any vertex shader objects are + bound to the specified program object. It is also permissible to bind a + generic attribute index to an attribute variable name that is never used + in a vertex shader. + + Active attributes that are not explicitly bound will be bound by the + linker when LinkProgram is called. The locations assigned can be queried + by calling GetAttribLocation. + + Error GL.INVALID_VALUE is generated if index is greater than or equal to + GL.MAX_VERTEX_ATTRIBS. + GL.INVALID_OPERATION is generated if name starts with the reserved prefix "gl_". + GL.INVALID_VALUE is generated if program is not a value generated by OpenGL. + GL.INVALID_OPERATION is generated if program is not a program object. + GL.INVALID_OPERATION is generated if BindAttribLocation is executed + between the execution of Begin and the corresponding execution of End. + + {{funcSince . "2.0+"}} + `, +}, { + name: "BindBuffer", + doc: ` + creates or puts in use a named buffer object. + Calling BindBuffer with target set to GL.ARRAY_BUFFER, + GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER or GL.PIXEL_UNPACK_BUFFER + and buffer set to the name of the new buffer object binds the buffer + object name to the target. When a buffer object is bound to a target, the + previous binding for that target is automatically broken. + + Buffer object names are unsigned integers. The value zero is reserved, but + there is no default buffer object for each buffer object target. Instead, + buffer set to zero effectively unbinds any buffer object previously bound, + and restores client memory usage for that buffer object target. Buffer + object names and the corresponding buffer object contents are local to the + shared display-list space (see XCreateContext) of the current GL rendering + context; two rendering contexts share buffer object names only if they + also share display lists. + + GenBuffers may be called to generate a set of new buffer object names. + + The state of a buffer object immediately after it is first bound is an + unmapped zero-sized memory buffer with GL.READ_WRITE access and + GL.STATIC_DRAW usage. + + While a non-zero buffer object name is bound, GL operations on the target + to which it is bound affect the bound buffer object, and queries of the + target to which it is bound return state from the bound buffer object. + While buffer object name zero is bound, as in the initial state, attempts + to modify or query state on the target to which it is bound generates an + GL.INVALID_OPERATION error. + + When vertex array pointer state is changed, for example by a call to + NormalPointer, the current buffer object binding (GL.ARRAY_BUFFER_BINDING) + is copied into the corresponding client state for the vertex array type + being changed, for example GL.NORMAL_ARRAY_BUFFER_BINDING. While a + non-zero buffer object is bound to the GL.ARRAY_BUFFER target, the vertex + array pointer parameter that is traditionally interpreted as a pointer to + client-side memory is instead interpreted as an offset within the buffer + object measured in basic machine units. + + While a non-zero buffer object is bound to the GL.ELEMENT_ARRAY_BUFFER + target, the indices parameter of DrawElements, DrawRangeElements, or + MultiDrawElements that is traditionally interpreted as a pointer to + client-side memory is instead interpreted as an offset within the buffer + object measured in basic machine units. + + While a non-zero buffer object is bound to the GL.PIXEL_PACK_BUFFER + target, the following commands are affected: GetCompressedTexImage, + GetConvolutionFilter, GetHistogram, GetMinmax, GetPixelMap, + GetPolygonStipple, GetSeparableFilter, GetTexImage, and ReadPixels. The + pointer parameter that is traditionally interpreted as a pointer to + client-side memory where the pixels are to be packed is instead + interpreted as an offset within the buffer object measured in basic + machine units. + + While a non-zero buffer object is bound to the GL.PIXEL_UNPACK_BUFFER + target, the following commands are affected: Bitmap, ColorSubTable, + ColorTable, CompressedTexImage1D, CompressedTexImage2D, + CompressedTexImage3D, CompressedTexSubImage1D, CompressedTexSubImage2D, + CompressedTexSubImage3D, ConvolutionFilter1D, ConvolutionFilter2D, + DrawPixels, PixelMap, PolygonStipple, SeparableFilter2D, TexImage1D, + TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, and TexSubImage3D. + The pointer parameter that is traditionally interpreted as a pointer to + client-side memory from which the pixels are to be unpacked is instead + interpreted as an offset within the buffer object measured in basic + machine units. + + A buffer object binding created with BindBuffer remains active until a + different buffer object name is bound to the same target, or until the + bound buffer object is deleted with DeleteBuffers. + + Once created, a named buffer object may be re-bound to any target as often + as needed. However, the GL implementation may make choices about how to + optimize the storage of a buffer object based on its initial binding + target. + + Error GL.INVALID_ENUM is generated if target is not one of the allowable + values. GL.INVALID_OPERATION is generated if BindBuffer is executed + between the execution of Begin and the corresponding execution of End. + + {{funcSince . "1.5+"}} + `, +}, { + name: "BufferData", + before: ` + if data != nil { + size = int(data_v.Type().Size()) * data_v.Len() + } + `, + doc: ` + creates a new data store for the buffer object currently + bound to target. Any pre-existing data store is deleted. The new data + store is created with the specified size in bytes and usage. If data is + not nil, it must be a slice that is used to initialize the data store. + In that case the size parameter is ignored and the store size will match + the slice data size. + + In its initial state, the new data store is not mapped, it has a NULL + mapped pointer, and its mapped access is GL.READ_WRITE. + + The target constant must be one of GL.ARRAY_BUFFER, GL.COPY_READ_BUFFER, + GL.COPY_WRITE_BUFFER, GL.ELEMENT_ARRAY_BUFFER, GL.PIXEL_PACK_BUFFER, + GL.PIXEL_UNPACK_BUFFER, GL.TEXTURE_BUFFER, GL.TRANSFORM_FEEDBACK_BUFFER, + or GL.UNIFORM_BUFFER. + + The usage parameter is a hint to the GL implementation as to how a buffer + object's data store will be accessed. This enables the GL implementation + to make more intelligent decisions that may significantly impact buffer + object performance. It does not, however, constrain the actual usage of + the data store. usage can be broken down into two parts: first, the + frequency of access (modification and usage), and second, the nature of + that access. + + A usage frequency of STREAM and nature of DRAW is specified via the + constant GL.STREAM_DRAW, for example. + + The usage frequency of access may be one of: + + STREAM + The data store contents will be modified once and used at most a few times. + + STATIC + The data store contents will be modified once and used many times. + + DYNAMIC + The data store contents will be modified repeatedly and used many times. + + The usage nature of access may be one of: + + DRAW + The data store contents are modified by the application, and used as + the source for GL drawing and image specification commands. + + READ + The data store contents are modified by reading data from the GL, + and used to return that data when queried by the application. + + COPY + The data store contents are modified by reading data from the GL, + and used as the source for GL drawing and image specification + commands. + + Clients must align data elements consistent with the requirements of the + client platform, with an additional base-level requirement that an offset + within a buffer to a datum comprising N bytes be a multiple of N. + + Error GL.INVALID_ENUM is generated if target is not one of the accepted + buffer targets. GL.INVALID_ENUM is generated if usage is not + GL.STREAM_DRAW, GL.STREAM_READ, GL.STREAM_COPY, GL.STATIC_DRAW, + GL.STATIC_READ, GL.STATIC_COPY, GL.DYNAMIC_DRAW, GL.DYNAMIC_READ, or + GL.DYNAMIC_COPY. GL.INVALID_VALUE is generated if size is negative. + GL.INVALID_OPERATION is generated if the reserved buffer object name 0 is + bound to target. GL.OUT_OF_MEMORY is generated if the GL is unable to + create a data store with the specified size. + `, +}, { + name: "CompileShader", + doc: ` + compiles the source code strings that have been stored in + the shader object specified by shader. + + The compilation status will be stored as part of the shader object's + state. This value will be set to GL.TRUE if the shader was compiled without + errors and is ready for use, and GL.FALSE otherwise. It can be queried by + calling GetShaderiv with arguments shader and GL.COMPILE_STATUS. + + Compilation of a shader can fail for a number of reasons as specified by + the OpenGL Shading Language Specification. Whether or not the compilation + was successful, information about the compilation can be obtained from the + shader object's information log by calling GetShaderInfoLog. + + Error GL.INVALID_VALUE is generated if shader is not a value generated by + OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader + object. GL.INVALID_OPERATION is generated if CompileShader is executed + between the execution of Begin and the corresponding execution of End. + + {{funcSince . "2.0+"}} + `, +}, { + name: "CreateProgram", + result: "glbase.Program", + doc: ` + creates an empty program object and returns a non-zero + value by which it can be referenced. A program object is an object to + which shader objects can be attached. This provides a mechanism to specify + the shader objects that will be linked to create a program. It also + provides a means for checking the compatibility of the shaders that will + be used to create a program (for instance, checking the compatibility + between a vertex shader and a fragment shader). When no longer needed as + part of a program object, shader objects can be detached. + + One or more executables are created in a program object by successfully + attaching shader objects to it with AttachShader, successfully compiling + the shader objects with CompileShader, and successfully linking the + program object with LinkProgram. These executables are made part of + current state when UseProgram is called. Program objects can be deleted + by calling DeleteProgram. The memory associated with the program object + will be deleted when it is no longer part of current rendering state for + any context. + + Like display lists and texture objects, the name space for program objects + may be shared across a set of contexts, as long as the server sides of the + contexts share the same address space. If the name space is shared across + contexts, any attached objects and the data associated with those attached + objects are shared as well. + + Applications are responsible for providing the synchronization across API + calls when objects are accessed from different execution threads. + + This function returns 0 if an error occurs creating the program object. + + Error GL.INVALID_OPERATION is generated if CreateProgram is executed + between the execution of Begin and the corresponding execution of End. + + {{funcSince . "2.0+"}} + `, +}, { + name: "CreateShader", + result: "glbase.Shader", + doc: ` + creates an empty shader object and returns a non-zero value + by which it can be referenced. A shader object is used to maintain the + source code strings that define a shader. shaderType indicates the type of + shader to be created. + + Two types of shaders are supported. A shader of type GL.VERTEX_SHADER is a + shader that is intended to run on the programmable vertex processor and + replace the fixed functionality vertex processing in OpenGL. A shader of + type GL.FRAGMENT_SHADER is a shader that is intended to run on the + programmable fragment processor and replace the fixed functionality + fragment processing in OpenGL. + + When created, a shader object's GL.SHADER_TYPE parameter is set to either + GL.VERTEX_SHADER or GL.FRAGMENT_SHADER, depending on the value of + shaderType. + + Like display lists and texture objects, the name space for shader objects + may be shared across a set of contexts, as long as the server sides of the + contexts share the same address space. If the name space is shared across + contexts, any attached objects and the data associated with those attached + objects are shared as well. + + This function returns 0 if an error occurs creating the shader object. + + Error GL.INVALID_ENUM is generated if shaderType is not an accepted value. + GL.INVALID_OPERATION is generated if CreateShader is executed between the + execution of Begin and the corresponding execution of End. + + {{funcSince . "2.0+"}} + `, +}, { + name: "DeleteBuffers", + params: paramTweaks{ + "n": {omit: true}, + }, + before: ` + n := len(buffers) + if n == 0 { return } + `, + doc: ` + deletes the buffer objects whose names are stored in the + buffers slice. + + After a buffer object is deleted, it has no contents, and its name is free + for reuse (for example by GenBuffers). If a buffer object that is + currently bound is deleted, the binding reverts to 0 (the absence of any + buffer object, which reverts to client memory usage). + + DeleteBuffers silently ignores 0's and names that do not correspond to + existing buffer objects. + + Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION + is generated if DeleteBuffers is executed between the execution of Begin + and the corresponding execution of End. + + {{funcSince . "1.5+"}} + `, +}, { + name: "DeleteFramebuffers", + params: paramTweaks{ + "n": {omit: true}, + }, + before: ` + n := len(framebuffers) + if n == 0 { return } + `, + doc: ` + deletes the framebuffer objects whose names are + stored in the framebuffers slice. The name zero is reserved by the GL and + is silently ignored, should it occur in framebuffers, as are other unused + names. Once a framebuffer object is deleted, its name is again unused and + it has no attachments. If a framebuffer that is currently bound to one or + more of the targets GL.DRAW_FRAMEBUFFER or GL.READ_FRAMEBUFFER is deleted, + it is as though BindFramebuffer had been executed with the corresponding + target and framebuffer zero. + + Error GL.INVALID_VALUE is generated if n is negative. + + {{funcSince . "3.0+"}} + `, +}, { + name: "DeleteProgram", + doc: ` + frees the memory and invalidates the name associated with + the program object specified by program. This command effectively undoes + the effects of a call to CreateProgram. + + If a program object is in use as part of current rendering state, it will + be flagged for deletion, but it will not be deleted until it is no longer + part of current state for any rendering context. If a program object to be + deleted has shader objects attached to it, those shader objects will be + automatically detached but not deleted unless they have already been + flagged for deletion by a previous call to DeleteShader. A value of 0 + for program will be silently ignored. + + To determine whether a program object has been flagged for deletion, call + GetProgram with arguments program and GL.DELETE_STATUS. + + Error GL.INVALID_VALUE is generated if program is not a value generated by + OpenGL. + + {{funcSince . "2.0+"}} + `, +}, { + name: "DeleteRenderbuffers", + params: paramTweaks{ + "n": {omit: true}, + }, + before: ` + n := len(renderbuffers) + if n == 0 { return } + `, + doc: ` + deletes the renderbuffer objects whose names are stored + in the renderbuffers slice. The name zero is reserved by the GL and + is silently ignored, should it occur in renderbuffers, as are other unused + names. Once a renderbuffer object is deleted, its name is again unused and + it has no contents. If a renderbuffer that is currently bound to the + target GL.RENDERBUFFER is deleted, it is as though BindRenderbuffer had + been executed with a target of GL.RENDERBUFFER and a name of zero. + + If a renderbuffer object is attached to one or more attachment points in + the currently bound framebuffer, then it as if FramebufferRenderbuffer + had been called, with a renderbuffer of zero for each attachment point to + which this image was attached in the currently bound framebuffer. In other + words, this renderbuffer object is first detached from all attachment + ponits in the currently bound framebuffer. Note that the renderbuffer + image is specifically not detached from any non-bound framebuffers. + + Error GL.INVALID_VALUE is generated if n is negative. + + {{funcSince . "3.0+"}} + `, +}, { + name: "DeleteShader", + doc: ` + frees the memory and invalidates the name associated with + the shader object specified by shader. This command effectively undoes the + effects of a call to CreateShader. + + If a shader object to be deleted is attached to a program object, it will + be flagged for deletion, but it will not be deleted until it is no longer + attached to any program object, for any rendering context (it must + be detached from wherever it was attached before it will be deleted). A + value of 0 for shader will be silently ignored. + + To determine whether an object has been flagged for deletion, call + GetShader with arguments shader and GL.DELETE_STATUS. + + Error GL.INVALID_VALUE is generated if shader is not a value generated by + OpenGL. + + {{funcSince . "2.0+"}} + `, +}, { + name: "DeleteTextures", + params: paramTweaks{ + "n": {omit: true}, + }, + before: ` + n := len(textures) + if n == 0 { return } + `, + doc: ` + deletes the textures objects whose names are stored + in the textures slice. After a texture is deleted, it has no contents or + dimensionality, and its name is free for reuse (for example by + GenTextures). If a texture that is currently bound is deleted, the binding + reverts to 0 (the default texture). + + DeleteTextures silently ignores 0's and names that do not correspond to + existing textures. + + Error GL.INVALID_VALUE is generated if n is negative. + + {{funcSince . "2.0+"}} + `, +}, { + name: "DepthRange", + doc: ` + specifies the mapping of depth values from normalized device + coordinates to window coordinates. + + Parameter nearVal specifies the mapping of the near clipping plane to window + coordinates (defaults to 0), while farVal specifies the mapping of the far + clipping plane to window coordinates (defaults to 1). + + After clipping and division by w, depth coordinates range from -1 to 1, + corresponding to the near and far clipping planes. DepthRange specifies a + linear mapping of the normalized depth coordinates in this range to window + depth coordinates. Regardless of the actual depth buffer implementation, + window coordinate depth values are treated as though they range from 0 through 1 + (like color components). Thus, the values accepted by DepthRange are both + clamped to this range before they are accepted. + + The default setting of (0, 1) maps the near plane to 0 and the far plane to 1. + With this mapping, the depth buffer range is fully utilized. + + It is not necessary that nearVal be less than farVal. Reverse mappings such as + nearVal 1, and farVal 0 are acceptable. + + GL.INVALID_OPERATION is generated if DepthRange is executed between the + execution of Begin and the corresponding execution of End. + `, +}, { + name: "GenBuffers", + params: paramTweaks{ + "buffers": {output: true, unnamed: true}, + }, + before: ` + if n == 0 { return nil } + buffers := make([]glbase.Buffer, n) + `, + doc: ` + returns n buffer object names. There is no guarantee that + the names form a contiguous set of integers; however, it is guaranteed + that none of the returned names was in use immediately before the call to + GenBuffers. + + Buffer object names returned by a call to GenBuffers are not returned by + subsequent calls, unless they are first deleted with DeleteBuffers. + + No buffer objects are associated with the returned buffer object names + until they are first bound by calling BindBuffer. + + Error GL.INVALID_VALUE is generated if n is negative. GL.INVALID_OPERATION + is generated if GenBuffers is executed between the execution of Begin + and the corresponding execution of End. + + {{funcSince . "1.5+"}} + `, +}, { + name: "GenFramebuffers", + params: paramTweaks{ + "framebuffers": {output: true, unnamed: true}, + }, + before: ` + if n == 0 { return nil } + framebuffers := make([]glbase.Framebuffer, n) + `, + doc: ` + returns n framebuffer object names in ids. There is no + guarantee that the names form a contiguous set of integers; however, it is + guaranteed that none of the returned names was in use immediately before + the call to GenFramebuffers. + + Framebuffer object names returned by a call to GenFramebuffers are not + returned by subsequent calls, unless they are first deleted with + DeleteFramebuffers. + + The names returned in ids are marked as used, for the purposes of + GenFramebuffers only, but they acquire state and type only when they are + first bound. + + Error GL.INVALID_VALUE is generated if n is negative. + `, +}, { + name: "GenRenderbuffers", + params: paramTweaks{ + "renderbuffers": {output: true, unnamed: true}, + }, + before: ` + if n == 0 { return nil } + renderbuffers := make([]glbase.Renderbuffer, n) + `, + doc: ` + returns n renderbuffer object names in renderbuffers. + There is no guarantee that the names form a contiguous set of integers; + however, it is guaranteed that none of the returned names was in use + immediately before the call to GenRenderbuffers. + + Renderbuffer object names returned by a call to GenRenderbuffers are not + returned by subsequent calls, unless they are first deleted with + DeleteRenderbuffers. + + The names returned in renderbuffers are marked as used, for the purposes + of GenRenderbuffers only, but they acquire state and type only when they + are first bound. + + Error GL.INVALID_VALUE is generated if n is negative. + + {{funcSince . "3.0+"}} + `, +}, { + name: "GenTextures", + params: paramTweaks{ + "textures": {output: true, unnamed: true}, + }, + before: ` + if n == 0 { return nil } + textures := make([]glbase.Texture, n) + `, + doc: ` + returns n texture names in textures. There is no guarantee + that the names form a contiguous set of integers; however, it is + guaranteed that none of the returned names was in use immediately before + the call to GenTextures. + + The generated textures have no dimensionality; they assume the + dimensionality of the texture target to which they are first bound (see + BindTexture). + + Texture names returned by a call to GenTextures are not returned by + subsequent calls, unless they are first deleted with DeleteTextures. + + Error GL.INVALID_VALUE is generated if n is negative. + + {{funcSince . "2.0+"}} + `, +}, { + name: "GetAttribLocation", + params: paramTweaks{ + "name": {retype: "string"}, + }, + result: "glbase.Attrib", + doc: ` + queries the previously linked program object specified + by program for the attribute variable specified by name and returns the + index of the generic vertex attribute that is bound to that attribute + variable. If name is a matrix attribute variable, the index of the first + column of the matrix is returned. If the named attribute variable is not + an active attribute in the specified program object or if name starts with + the reserved prefix "gl_", a value of -1 is returned. + + The association between an attribute variable name and a generic attribute + index can be specified at any time by calling BindAttribLocation. + Attribute bindings do not go into effect until LinkProgram is called. + After a program object has been linked successfully, the index values for + attribute variables remain fixed until the next link command occurs. The + attribute values can only be queried after a link if the link was + successful. GetAttribLocation returns the binding that actually went + into effect the last time LinkProgram was called for the specified + program object. Attribute bindings that have been specified since the last + link operation are not returned by GetAttribLocation. + + Error GL_INVALID_OPERATION is generated if program is not a value + generated by OpenGL. GL_INVALID_OPERATION is generated if program is not + a program object. GL_INVALID_OPERATION is generated if program has not + been successfully linked. GL_INVALID_OPERATION is generated if + GetAttribLocation is executed between the execution of Begin and the + corresponding execution of End. + + {{funcSince . "2.0+"}} + `, +}, { + name: "GetProgramInfoLog", + params: paramTweaks{ + "bufSize": {omit: true}, + "length": {omit: true, single: true}, + "infoLog": {output: true, unnamed: true}, + }, + before: ` + var params [1]int32 + var length int32 + gl.GetProgramiv(program, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + `, + doc: ` + returns the information log for the specified program + object. The information log for a program object is modified when the + program object is linked or validated. + + The information log for a program object is either an empty string, or a + string containing information about the last link operation, or a string + containing information about the last validation operation. It may contain + diagnostic messages, warning messages, and other information. When a + program object is created, its information log will be a string of length + 0, and the size of the current log can be obtained by calling GetProgramiv + with the value GL.INFO_LOG_LENGTH. + + Error GL.INVALID_VALUE is generated if program is not a value generated + by OpenGL. GL.INVALID_OPERATION is generated if program is not a + program object. + `, +}, { + name: "GetProgramiv", + params: paramTweaks{ + "params": {replace: true}, + }, + before: ` + var params_c [4]{{paramGoType . "params"}} + `, + after: ` + copy(params, params_c[:]) + `, + doc: ` + returns in params the value of a parameter for a specific + program object. The following parameters are defined: + + GL.DELETE_STATUS + params returns GL.TRUE if program is currently flagged for deletion, + and GL.FALSE otherwise. + + GL.LINK_STATUS + params returns GL.TRUE if the last link operation on program was + successful, and GL.FALSE otherwise. + + GL.VALIDATE_STATUS + params returns GL.TRUE or if the last validation operation on + program was successful, and GL.FALSE otherwise. + + GL.INFO_LOG_LENGTH + params returns the number of characters in the information log for + program including the null termination character (the size of + the character buffer required to store the information log). If + program has no information log, a value of 0 is returned. + + GL.ATTACHED_SHADERS + params returns the number of shader objects attached to program. + + GL.ACTIVE_ATTRIBUTES + params returns the number of active attribute variables for program. + + GL.ACTIVE_ATTRIBUTE_MAX_LENGTH + params returns the length of the longest active attribute name for + program, including the null termination character (the size of + the character buffer required to store the longest attribute name). + If no active attributes exist, 0 is returned. + + GL.ACTIVE_UNIFORMS + params returns the number of active uniform variables for program. + + GL.ACTIVE_UNIFORM_MAX_LENGTH + params returns the length of the longest active uniform variable + name for program, including the null termination character (i.e., + the size of the character buffer required to store the longest + uniform variable name). If no active uniform variables exist, 0 is + returned. + + GL.TRANSFORM_FEEDBACK_BUFFER_MODE + params returns a symbolic constant indicating the buffer mode used + when transform feedback is active. This may be GL.SEPARATE_ATTRIBS + or GL.INTERLEAVED_ATTRIBS. + + GL.TRANSFORM_FEEDBACK_VARYINGS + params returns the number of varying variables to capture in transform + feedback mode for the program. + + GL.TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH + params returns the length of the longest variable name to be used for + transform feedback, including the null-terminator. + + GL.GEOMETRY_VERTICES_OUT + params returns the maximum number of vertices that the geometry shader in + program will output. + + GL.GEOMETRY_INPUT_TYPE + params returns a symbolic constant indicating the primitive type accepted + as input to the geometry shader contained in program. + + GL.GEOMETRY_OUTPUT_TYPE + params returns a symbolic constant indicating the primitive type that will + be output by the geometry shader contained in program. + + GL.ACTIVE_UNIFORM_BLOCKS and GL.ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH are + available only if the GL version 3.1 or greater. + + GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE and + GL.GEOMETRY_OUTPUT_TYPE are accepted only if the GL version is 3.2 or + greater. + + Error GL.INVALID_VALUE is generated if program is not a value generated by + OpenGL. GL.INVALID_OPERATION is generated if program does not refer to a + program object. GL.INVALID_OPERATION is generated if pname is + GL.GEOMETRY_VERTICES_OUT, GL.GEOMETRY_INPUT_TYPE, or + GL.GEOMETRY_OUTPUT_TYPE, and program does not contain a geometry shader. + GL.INVALID_ENUM is generated if pname is not an accepted value. + `, +}, { + name: "GetShaderiv", + params: paramTweaks{ + "params": {replace: true}, + }, + before: ` + var params_c [4]{{paramGoType . "params"}} + `, + after: ` + copy(params, params_c[:]) + `, + doc: ` + GetShader returns in params the value of a parameter for a specific + shader object. The following parameters are defined: + + GL.SHADER_TYPE + params returns GL.VERTEX_SHADER if shader is a vertex shader object, + and GL.FRAGMENT_SHADER if shader is a fragment shader object. + + GL.DELETE_STATUS + params returns GL.TRUE if shader is currently flagged for deletion, + and GL.FALSE otherwise. + + GL.COMPILE_STATUS + params returns GL.TRUE if the last compile operation on shader was + successful, and GL.FALSE otherwise. + + GL.INFO_LOG_LENGTH + params returns the number of characters in the information log for + shader including the null termination character (the size of the + character buffer required to store the information log). If shader has + no information log, a value of 0 is returned. + + GL.SHADER_SOURCE_LENGTH + params returns the length of the concatenation of the source strings + that make up the shader source for the shader, including the null + termination character. (the size of the character buffer + required to store the shader source). If no source code exists, 0 is + returned. + + Error GL.INVALID_VALUE is generated if shader is not a value generated by + OpenGL. GL.INVALID_OPERATION is generated if shader does not refer to a + shader object. GL.INVALID_ENUM is generated if pname is not an accepted + value. GL.INVALID_OPERATION is generated if GetShader is executed + between the execution of Begin and the corresponding execution of End. + + {{funcSince . "2.0+"}} + `, +}, { + name: "GetShaderInfoLog", + params: paramTweaks{ + "bufSize": {omit: true}, + "length": {omit: true, single: true}, + "infoLog": {output: true, unnamed: true}, + }, + before: ` + var params [1]int32 + var length int32 + gl.GetShaderiv(shader, INFO_LOG_LENGTH, params[:]) + bufSize := params[0] + infoLog := make([]byte, int(bufSize)) + `, + doc: ` + returns the information log for the specified shader + object. The information log for a shader object is modified when the + shader is compiled. + + The information log for a shader object is a string that may contain + diagnostic messages, warning messages, and other information about the + last compile operation. When a shader object is created, its information + log will be a string of length 0, and the size of the current log can be + obtained by calling GetShaderiv with the value GL.INFO_LOG_LENGTH. + + The information log for a shader object is the OpenGL implementer's + primary mechanism for conveying information about the compilation process. + Therefore, the information log can be helpful to application developers + during the development process, even when compilation is successful. + Application developers should not expect different OpenGL implementations + to produce identical information logs. + + Error GL.INVALID_VALUE is generated if shader is not a value generated by + OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader + object. GL.INVALID_VALUE is generated if maxLength is less than 0. + GL.INVALID_OPERATION is generated if GetShaderInfoLog is executed + between the execution of Begin and the corresponding execution of End. + + {{funcSince . "2.0+"}} + `, +}, { + name: "GetUniformLocation", + params: paramTweaks{ + "name": {retype: "string"}, + }, + result: "glbase.Uniform", + doc: ` + returns an integer that represents the location of a + specific uniform variable within a program object. name must be an active + uniform variable name in program that is not a structure, an array of + structures, or a subcomponent of a vector or a matrix. This function + returns -1 if name does not correspond to an active uniform variable in + program or if name starts with the reserved prefix "gl_". + + Uniform variables that are structures or arrays of structures may be + queried by calling GetUniformLocation for each field within the + structure. The array element operator "[]" and the structure field + operator "." may be used in name in order to select elements within an + array or fields within a structure. The result of using these operators is + not allowed to be another structure, an array of structures, or a + subcomponent of a vector or a matrix. Except if the last part of name + indicates a uniform variable array, the location of the first element of + an array can be retrieved by using the name of the array, or by using the + name appended by "[0]". + + The actual locations assigned to uniform variables are not known until the + program object is linked successfully. After linking has occurred, the + command GetUniformLocation can be used to obtain the location of a + uniform variable. This location value can then be passed to Uniform to + set the value of the uniform variable or to GetUniform in order to query + the current value of the uniform variable. After a program object has been + linked successfully, the index values for uniform variables remain fixed + until the next link command occurs. Uniform variable locations and values + can only be queried after a link if the link was successful. + + Error GL.INVALID_VALUE is generated if program is not a value generated by + OpenGL. GL.INVALID_OPERATION is generated if program is not a program object. + GL.INVALID_OPERATION is generated if program has not been successfully + linked. GL.INVALID_OPERATION is generated if GetUniformLocation is executed + between the execution of Begin and the corresponding execution of End. + + {{funcSince . "2.0+"}} + `, +}, { + name: "GetUniformfv", + copy: "GetUniformiv", +}, { + name: "GetUniformiv", + params: paramTweaks{ + "params": {replace: true}, + }, + before: ` + var params_c [4]{{paramGoType . "params"}} + `, + after: ` + copy(params, params_c[:]) + `, + doc: ` + returns in params the value of the specified uniform + variable. The type of the uniform variable specified by location + determines the number of values returned. If the uniform variable is + defined in the shader as a boolean, int, or float, a single value will be + returned. If it is defined as a vec2, ivec2, or bvec2, two values will be + returned. If it is defined as a vec3, ivec3, or bvec3, three values will + be returned, and so on. To query values stored in uniform variables + declared as arrays, call {{.GoName}} for each element of the array. To + query values stored in uniform variables declared as structures, call + {{.GoName}} for each field in the structure. The values for uniform + variables declared as a matrix will be returned in column major order. + + The locations assigned to uniform variables are not known until the + program object is linked. After linking has occurred, the command + GetUniformLocation can be used to obtain the location of a uniform + variable. This location value can then be passed to {{.GoName}} in order + to query the current value of the uniform variable. After a program object + has been linked successfully, the index values for uniform variables + remain fixed until the next link command occurs. The uniform variable + values can only be queried after a link if the link was successful. + + Error GL.INVALID_VALUE is generated if program is not a value generated by + OpenGL. GL.INVALID_OPERATION is generated if program is not a program + object. GL.INVALID_OPERATION is generated if program has not been + successfully linked. GL.INVALID_OPERATION is generated if location does + not correspond to a valid uniform variable location for the specified + program object. GL.INVALID_OPERATION is generated if {{.GoName}} is + executed between the execution of Begin and the corresponding execution of + End. + + {{funcSince . "2.0+"}} + `, +}, { + name: "GetVertexAttribdv", + copy: "GetVertexAttribiv", +}, { + name: "GetVertexAttribfv", + copy: "GetVertexAttribiv", +}, { + name: "GetVertexAttribiv", + params: paramTweaks{ + "params": {replace: true}, + }, + before: ` + var params_c [4]{{paramGoType . "params"}} + `, + after: ` + copy(params, params_c[:]) + `, + doc: ` + returns in params the value of a generic vertex attribute + parameter. The generic vertex attribute to be queried is specified by + index, and the parameter to be queried is specified by pname. + + The accepted parameter names are as follows: + + GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING + params returns a single value, the name of the buffer object + currently bound to the binding point corresponding to generic vertex + attribute array index. If no buffer object is bound, 0 is returned. + The initial value is 0. + + GL.VERTEX_ATTRIB_ARRAY_ENABLED + params returns a single value that is non-zero (true) if the vertex + attribute array for index is enabled and 0 (false) if it is + disabled. The initial value is 0. + + GL.VERTEX_ATTRIB_ARRAY_SIZE + params returns a single value, the size of the vertex attribute + array for index. The size is the number of values for each element + of the vertex attribute array, and it will be 1, 2, 3, or 4. The + initial value is 4. + + GL.VERTEX_ATTRIB_ARRAY_STRIDE + params returns a single value, the array stride for (number of bytes + between successive elements in) the vertex attribute array for + index. A value of 0 indicates that the array elements are stored + sequentially in memory. The initial value is 0. + + GL.VERTEX_ATTRIB_ARRAY_TYPE + params returns a single value, a symbolic constant indicating the + array type for the vertex attribute array for index. Possible values + are GL.BYTE, GL.UNSIGNED_BYTE, GL.SHORT, GL.UNSIGNED_SHORT, GL.INT, + GL.UNSIGNED_INT, GL.FLOAT, and GL.DOUBLE. The initial value is + GL.FLOAT. + + GL.VERTEX_ATTRIB_ARRAY_NORMALIZED + params returns a single value that is non-zero (true) if fixed-point + data types for the vertex attribute array indicated by index are + normalized when they are converted to floating point, and 0 (false) + otherwise. The initial value is 0. + + GL.CURRENT_VERTEX_ATTRIB + params returns four values that represent the current value for the + generic vertex attribute specified by index. Generic vertex + attribute 0 is unique in that it has no current state, so an error + will be generated if index is 0. The initial value for all other + generic vertex attributes is (0,0,0,1). + + All of the parameters except GL.CURRENT_VERTEX_ATTRIB represent + client-side state. + + Error GL.INVALID_VALUE is generated if index is greater than or equal to + GL.MAX_VERTEX_ATTRIBS. GL.INVALID_ENUM is generated if pname is not an + accepted value. GL.INVALID_OPERATION is generated if index is 0 and pname + is GL.CURRENT_VERTEX_ATTRIB. + + {{funcSince . "2.0+"}} + `, +}, { + name: "LinkProgram", + doc: ` + links the program object specified by program. If any shader + objects of type GL.VERTEX_SHADER are attached to program, they will be + used to create an executable that will run on the programmable vertex + processor. If any shader objects of type GL.FRAGMENT_SHADER are attached + to program, they will be used to create an executable that will run on the + programmable fragment processor. + + The status of the link operation will be stored as part of the program + object's state. This value will be set to GL.TRUE if the program object + was linked without errors and is ready for use, and GL.FALSE otherwise. It + can be queried by calling GetProgramiv with arguments program and + GL.LINK_STATUS. + + As a result of a successful link operation, all active user-defined + uniform variables belonging to program will be initialized to 0, and each + of the program object's active uniform variables will be assigned a + location that can be queried by calling GetUniformLocation. Also, any + active user-defined attribute variables that have not been bound to a + generic vertex attribute index will be bound to one at this time. + + Linking of a program object can fail for a number of reasons as specified + in the OpenGL Shading Language Specification. The following lists some of + the conditions that will cause a link error. + + - The number of active attribute variables supported by the + implementation has been exceeded. + + - The storage limit for uniform variables has been exceeded. + + - The number of active uniform variables supported by the implementation + has been exceeded. + + - The main function is missing for the vertex shader or the fragment + shader. + + - A varying variable actually used in the fragment shader is not + declared in the same way (or is not declared at all) in the vertex + shader. + + - A reference to a function or variable name is unresolved. + + - A shared global is declared with two different types or two different + initial values. + + - One or more of the attached shader objects has not been successfully + compiled. + + - Binding a generic attribute matrix caused some rows of the matrix to + fall outside the allowed maximum of GL.MAX_VERTEX_ATTRIBS. + + - Not enough contiguous vertex attribute slots could be found to bind + attribute matrices. + + When a program object has been successfully linked, the program object can + be made part of current state by calling UseProgram. Whether or not the + link operation was successful, the program object's information log will + be overwritten. The information log can be retrieved by calling + GetProgramInfoLog. + + LinkProgram will also install the generated executables as part of the + current rendering state if the link operation was successful and the + specified program object is already currently in use as a result of a + previous call to UseProgram. If the program object currently in use is + relinked unsuccessfully, its link status will be set to GL.FALSE , but the + executables and associated state will remain part of the current state + until a subsequent call to UseProgram removes it from use. After it is + removed from use, it cannot be made part of current state until it has + been successfully relinked. + + If program contains shader objects of type GL.VERTEX_SHADER but does not + contain shader objects of type GL.FRAGMENT_SHADER, the vertex shader will + be linked against the implicit interface for fixed functionality fragment + processing. Similarly, if program contains shader objects of type + GL.FRAGMENT_SHADER but it does not contain shader objects of type + GL.VERTEX_SHADER, the fragment shader will be linked against the implicit + interface for fixed functionality vertex processing. + + The program object's information log is updated and the program is + generated at the time of the link operation. After the link operation, + applications are free to modify attached shader objects, compile attached + shader objects, detach shader objects, delete shader objects, and attach + additional shader objects. None of these operations affects the + information log or the program that is part of the program object. + + If the link operation is unsuccessful, any information about a previous + link operation on program is lost (a failed link does not restore the + old state of program). Certain information can still be retrieved + from program even after an unsuccessful link operation. See for instance + GetActiveAttrib and GetActiveUniform. + + Error GL.INVALID_VALUE is generated if program is not a value generated by + OpenGL. GL.INVALID_OPERATION is generated if program is not a program + object. GL.INVALID_OPERATION is generated if LinkProgram is executed + between the execution of Begin and the corresponding execution of End. + + {{funcSince . "2.0+"}} + `, +}, { + name: "MultMatrixd", + before: ` + if len(m) != 16 { + panic("parameter m must have length 16 for the 4x4 matrix") + } + `, + doc: ` + multiplies the current matrix with the provided matrix. + + The m parameter must hold 16 consecutive elements of a 4x4 column-major matrix. + + The current matrix is determined by the current matrix mode (see + MatrixMode). It is either the projection matrix, modelview matrix, or the + texture matrix. + + For example, if the current matrix is C and the coordinates to be transformed + are v = (v[0], v[1], v[2], v[3]), then the current transformation is C × v, or + + c[0] c[4] c[8] c[12] v[0] + c[1] c[5] c[9] c[13] v[1] + c[2] c[6] c[10] c[14] X v[2] + c[3] c[7] c[11] c[15] v[3] + + Calling MultMatrix with an argument of m = m[0], m[1], ..., m[15] + replaces the current transformation with (C X M) x v, or + + c[0] c[4] c[8] c[12] m[0] m[4] m[8] m[12] v[0] + c[1] c[5] c[9] c[13] m[1] m[5] m[9] m[13] v[1] + c[2] c[6] c[10] c[14] X m[2] m[6] m[10] m[14] X v[2] + c[3] c[7] c[11] c[15] m[3] m[7] m[11] m[15] v[3] + + Where 'X' denotes matrix multiplication, and v is represented as a 4x1 matrix. + + While the elements of the matrix may be specified with single or double + precision, the GL may store or operate on these values in less-than-single + precision. + + In many computer languages, 4×4 arrays are represented in row-major + order. The transformations just described represent these matrices in + column-major order. The order of the multiplication is important. For + example, if the current transformation is a rotation, and MultMatrix is + called with a translation matrix, the translation is done directly on the + coordinates to be transformed, while the rotation is done on the results + of that translation. + + GL.INVALID_OPERATION is generated if MultMatrix is executed between the + execution of Begin and the corresponding execution of End. + `, +}, { + name: "MultMatrixf", + copy: "MultMatrixd", +}, { + name: "ShaderSource", + params: paramTweaks{ + "glstring": {rename: "source", retype: "...string", replace: true}, + "length": {omit: true}, + "count": {omit: true}, + }, + before: ` + count := len(source) + length := make([]int32, count) + source_c := make([]unsafe.Pointer, count) + for i, src := range source { + length[i] = int32(len(src)) + if len(src) > 0 { + source_c[i] = *(*unsafe.Pointer)(unsafe.Pointer(&src)) + } else { + source_c[i] = unsafe.Pointer(uintptr(0)) + } + } + `, + doc: ` + sets the source code in shader to the provided source code. Any source + code previously stored in the shader object is completely replaced. + + Error GL.INVALID_VALUE is generated if shader is not a value generated by + OpenGL. GL.INVALID_OPERATION is generated if shader is not a shader + object. GL.INVALID_VALUE is generated if count is less than 0. + GL.INVALID_OPERATION is generated if ShaderSource is executed between the + execution of Begin and the corresponding execution of End. + + {{funcSince . "2.0+"}} + `, +}, { + name: "Uniform1f", + copy: "Uniform4ui", +}, { + name: "Uniform2f", + copy: "Uniform4ui", +}, { + name: "Uniform3f", + copy: "Uniform4ui", +}, { + name: "Uniform4f", + copy: "Uniform4ui", +}, { + name: "Uniform1i", + copy: "Uniform4ui", +}, { + name: "Uniform2i", + copy: "Uniform4ui", +}, { + name: "Uniform3i", + copy: "Uniform4ui", +}, { + name: "Uniform4i", + copy: "Uniform4ui", +}, { + name: "Uniform1ui", + copy: "Uniform4ui", +}, { + name: "Uniform2ui", + copy: "Uniform4ui", +}, { + name: "Uniform3ui", + copy: "Uniform4ui", +}, { + name: "Uniform4ui", + doc: ` + modifies the value of a single uniform variable. + The location of the uniform variable to be modified is specified by + location, which should be a value returned by GetUniformLocation. + {{.GoName}} operates on the program object that was made part of + current state by calling UseProgram. + + The functions Uniform{1|2|3|4}{f|i|ui} are used to change the value of the + uniform variable specified by location using the values passed as + arguments. The number specified in the function should match the number of + components in the data type of the specified uniform variable (1 for + float, int, unsigned int, bool; 2 for vec2, ivec2, uvec2, bvec2, etc.). + The suffix f indicates that floating-point values are being passed; the + suffix i indicates that integer values are being passed; the suffix ui + indicates that unsigned integer values are being passed, and this type + should also match the data type of the specified uniform variable. The i + variants of this function should be used to provide values for uniform + variables defined as int, ivec2, ivec3, ivec4, or arrays of these. The ui + variants of this function should be used to provide values for uniform + variables defined as unsigned int, uvec2, uvec3, uvec4, or arrays of + these. The f variants should be used to provide values for uniform + variables of type float, vec2, vec3, vec4, or arrays of these. Either the + i, ui or f variants may be used to provide values for uniform variables of + type bool, bvec2, bvec3, bvec4, or arrays of these. The uniform variable + will be set to false if the input value is 0 or 0.0f, and it will be set + to true otherwise. + + Uniform1i and Uniform1iv are the only two functions that may be used to + load uniform variables defined as sampler types. Loading samplers with any + other function will result in a GL.INVALID_OPERATION error. + + All active uniform variables defined in a program object are initialized + to 0 when the program object is linked successfully. They retain the + values assigned to them by a call to Uniform* until the next successful + link operation occurs on the program object, when they are once again + initialized to 0. + `, +}, { + name: "Uniform1fv", + copy: "Uniform4uiv", +}, { + name: "Uniform2fv", + copy: "Uniform4uiv", +}, { + name: "Uniform3fv", + copy: "Uniform4uiv", +}, { + name: "Uniform4fv", + copy: "Uniform4uiv", +}, { + name: "Uniform1iv", + copy: "Uniform4uiv", +}, { + name: "Uniform2iv", + copy: "Uniform4uiv", +}, { + name: "Uniform3iv", + copy: "Uniform4uiv", +}, { + name: "Uniform4iv", + copy: "Uniform4uiv", +}, { + name: "Uniform1uiv", + copy: "Uniform4uiv", +}, { + name: "Uniform2uiv", + copy: "Uniform4uiv", +}, { + name: "Uniform3uiv", + copy: "Uniform4uiv", +}, { + name: "Uniform4uiv", + params: paramTweaks{ + "count": {omit: true}, + }, + before: ` + if len(value) == 0 { + return + } {{with $n := substr .GoName 7 8}}{{if ne $n "1"}} + if len(value)%{{$n}} != 0 { + panic("invalid value length for {{$.GoName}}") + } + count := len(value)/{{$n}} + {{else}} + count := len(value) + {{end}}{{end}} + `, + doc: ` + modifies the value of a uniform variable or a uniform + variable array. The location of the uniform variable to be modified is + specified by location, which should be a value returned by GetUniformLocation. + {{.GoName}} operates on the program object that was made part of + current state by calling UseProgram. + + The functions Uniform{1|2|3|4}{f|i|ui}v can be used to modify a single + uniform variable or a uniform variable array. These functions receive a + slice with the values to be loaded into a uniform variable or a uniform + variable array. A slice with length 1 should be used if modifying the value + of a single uniform variable, and a length of 1 or greater can be used to + modify an entire array or part of an array. When loading n elements + starting at an arbitrary position m in a uniform variable array, elements + m + n - 1 in the array will be replaced with the new values. If m + n - 1 + is larger than the size of the uniform variable array, values for all + array elements beyond the end of the array will be ignored. The number + specified in the name of the command indicates the number of components + for each element in value, and it should match the number of components in + the data type of the specified uniform variable (1 for float, int, bool; + 2 for vec2, ivec2, bvec2, etc.). The data type specified in the name + of the command must match the data type for the specified uniform variable + as described for Uniform{1|2|3|4}{f|i|ui}. + + Uniform1i and Uniform1iv are the only two functions that may be used to + load uniform variables defined as sampler types. Loading samplers with any + other function will result in a GL.INVALID_OPERATION error. + + All active uniform variables defined in a program object are initialized + to 0 when the program object is linked successfully. They retain the + values assigned to them by a call to Uniform* until the next successful + link operation occurs on the program object, when they are once again + initialized to 0. + `, +}, { + name: "UniformMatrix2fv", + copy: "UniformMatrix4x3fv", +}, { + name: "UniformMatrix2x3fv", + copy: "UniformMatrix4x3fv", +}, { + name: "UniformMatrix2x4fv", + copy: "UniformMatrix4x3fv", +}, { + name: "UniformMatrix3fv", + copy: "UniformMatrix4x3fv", +}, { + name: "UniformMatrix3x2fv", + copy: "UniformMatrix4x3fv", +}, { + name: "UniformMatrix3x4fv", + copy: "UniformMatrix4x3fv", +}, { + name: "UniformMatrix4fv", + copy: "UniformMatrix4x3fv", +}, { + name: "UniformMatrix4x2fv", + copy: "UniformMatrix4x3fv", +}, { + name: "UniformMatrix4x3fv", + params: paramTweaks{ + "count": {omit: true}, + }, + before: ` + if len(value) == 0 { + return + } {{with $n := substr $.GoName 13 14}}{{with $m := substr $.GoName 15 16}}{{if eq $m "v"}} + if len(value)%({{$n}}*{{$n}}) != 0 { + panic("invalid value length for {{$.GoName}}") + } + count := len(value)/({{$n}}*{{$n}}) + {{else}} + if len(value)%({{$n}}*{{$m}}) != 0 { + panic("invalid value length for {{$.GoName}}") + } + count := len(value)/({{$n}}*{{$m}}) + {{end}}{{end}}{{end}} + `, + doc: ` + modifies the value of a uniform variable or a uniform + variable array. The location of the uniform variable to be modified is + specified by location, which should be a value returned by GetUniformLocation. + {{.GoName}} operates on the program object that was made part of + current state by calling UseProgram. + + The functions UniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are used to + modify a matrix or an array of matrices. The numbers in the function name + are interpreted as the dimensionality of the matrix. The number 2 + indicates a 2x2 matrix (4 values), the number 3 indicates a 3x3 matrix (9 + values), and the number 4 indicates a 4x4 matrix (16 values). Non-square + matrix dimensionality is explicit, with the first number representing the + number of columns and the second number representing the number of rows. + For example, 2x4 indicates a 2x4 matrix with 2 columns and 4 rows (8 + values). The length of the provided slice must be a multiple of the number + of values per matrix, to update one or more consecutive matrices. + + If transpose is false, each matrix is assumed to be supplied in column + major order. If transpose is true, each matrix is assumed to be supplied + in row major order. + + All active uniform variables defined in a program object are initialized + to 0 when the program object is linked successfully. They retain the + values assigned to them by a call to Uniform* until the next successful + link operation occurs on the program object, when they are once again + initialized to 0. + `, +}, { + name: "UseProgram", + doc: ` + installs the program object specified by program as part of + current rendering state. One or more executables are created in a program + object by successfully attaching shader objects to it with AttachShader, + successfully compiling the shader objects with CompileShader, and + successfully linking the program object with LinkProgram. + + A program object will contain an executable that will run on the vertex + processor if it contains one or more shader objects of type + GL.VERTEX_SHADER that have been successfully compiled and linked. + Similarly, a program object will contain an executable that will run on + the fragment processor if it contains one or more shader objects of type + GL.FRAGMENT_SHADER that have been successfully compiled and linked. + + Successfully installing an executable on a programmable processor will + cause the corresponding fixed functionality of OpenGL to be disabled. + Specifically, if an executable is installed on the vertex processor, the + OpenGL fixed functionality will be disabled as follows. + + - The modelview matrix is not applied to vertex coordinates. + + - The projection matrix is not applied to vertex coordinates. + + - The texture matrices are not applied to texture coordinates. + + - Normals are not transformed to eye coordinates. + + - Normals are not rescaled or normalized. + + - Normalization of GL.AUTO_NORMAL evaluated normals is not performed. + + - Texture coordinates are not generated automatically. + + - Per-vertex lighting is not performed. + + - Color material computations are not performed. + + - Color index lighting is not performed. + + - This list also applies when setting the current raster position. + + The executable that is installed on the vertex processor is expected to + implement any or all of the desired functionality from the preceding list. + Similarly, if an executable is installed on the fragment processor, the + OpenGL fixed functionality will be disabled as follows. + + - Texture environment and texture functions are not applied. + + - Texture application is not applied. + + - Color sum is not applied. + + - Fog is not applied. + + Again, the fragment shader that is installed is expected to implement any + or all of the desired functionality from the preceding list. + + While a program object is in use, applications are free to modify attached + shader objects, compile attached shader objects, attach additional shader + objects, and detach or delete shader objects. None of these operations + will affect the executables that are part of the current state. However, + relinking the program object that is currently in use will install the + program object as part of the current rendering state if the link + operation was successful (see LinkProgram). If the program object + currently in use is relinked unsuccessfully, its link status will be set + to GL.FALSE, but the executables and associated state will remain part of + the current state until a subsequent call to UseProgram removes it from + use. After it is removed from use, it cannot be made part of current state + until it has been successfully relinked. + + If program contains shader objects of type GL.VERTEX_SHADER but it does + not contain shader objects of type GL.FRAGMENT_SHADER, an executable will + be installed on the vertex processor, but fixed functionality will be used + for fragment processing. Similarly, if program contains shader objects of + type GL.FRAGMENT_SHADER but it does not contain shader objects of type + GL.VERTEX_SHADER, an executable will be installed on the fragment + processor, but fixed functionality will be used for vertex processing. If + program is 0, the programmable processors will be disabled, and fixed + functionality will be used for both vertex and fragment processing. + + While a program object is in use, the state that controls the disabled + fixed functionality may also be updated using the normal OpenGL calls. + + Like display lists and texture objects, the name space for program objects + may be shared across a set of contexts, as long as the server sides of the + contexts share the same address space. If the name space is shared across + contexts, any attached objects and the data associated with those attached + objects are shared as well. + + Applications are responsible for providing the synchronization across API + calls when objects are accessed from different execution threads. + + Error GL.INVALID_VALUE is generated if program is neither 0 nor a value + generated by OpenGL. GL.INVALID_OPERATION is generated if program is not + a program object. GL.INVALID_OPERATION is generated if program could not + be made part of current state. GL.INVALID_OPERATION is generated if + UseProgram is executed between the execution of Begin and the + corresponding execution of End. + + {{funcSince . "2.0+"}} + `, +}, { + name: "VertexAttribPointer", + params: paramTweaks{ + "pointer": {rename: "offset", retype: "uintptr"}, + }, + before: ` + offset_ptr := unsafe.Pointer(offset) + `, + doc: ` + specifies the location and data format of the array + of generic vertex attributes at index to use when rendering. size + specifies the number of components per attribute and must be 1, 2, 3, or + 4. type specifies the data type of each component, and stride specifies + the byte stride from one attribute to the next, allowing vertices and + attributes to be packed into a single array or stored in separate arrays. + normalized indicates whether the values stored in an integer format are + to be mapped to the range [-1,1] (for signed values) or [0,1] + (for unsigned values) when they are accessed and converted to floating + point; otherwise, values will be converted to floats directly without + normalization. offset is a byte offset into the buffer object's data + store, which must be bound to the GL.ARRAY_BUFFER target with BindBuffer. + + The buffer object binding (GL.ARRAY_BUFFER_BINDING) is saved as + generic vertex attribute array client-side state + (GL.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING) for the provided index. + + To enable and disable a generic vertex attribute array, call + EnableVertexAttribArray and DisableVertexAttribArray with index. If + enabled, the generic vertex attribute array is used when DrawArrays or + DrawElements is called. Each generic vertex attribute array is initially + disabled. + + VertexAttribPointer is typically implemented on the client side. + + Error GL.INVALID_ENUM is generated if type is not an accepted value. + GL.INVALID_VALUE is generated if index is greater than or equal to + GL.MAX_VERTEX_ATTRIBS. GL.INVALID_VALUE is generated if size is not 1, 2, + 3, or 4. GL.INVALID_VALUE is generated if stride is negative. + `, +}} + +// vim:ts=8:tw=90:noet diff --git a/gl/gengl/gl.xml b/gl/gengl/gl.xml new file mode 100644 index 00000000..d5c92023 --- /dev/null +++ b/gl/gengl/gl.xml @@ -0,0 +1,43891 @@ + + + +Copyright (c) 2013-2014 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. + +------------------------------------------------------------------------ + +This file, gl.xml, is the OpenGL and OpenGL API Registry. The older +".spec" file format has been retired and will no longer be updated with +new extensions and API versions. The canonical version of the registry, +together with documentation, schema, and Python generator scripts used +to generate C header files for OpenGL and OpenGL ES, can always be found +in the Khronos Registry at + http://www.opengl.org/registry/ + + + + + + #include <stddef.h> + #include <KHR/khrplatform.h> + #ifndef GLEXT_64_TYPES_DEFINED +/* This code block is duplicated in glxext.h, so must be protected */ +#define GLEXT_64_TYPES_DEFINED +/* Define int32_t, int64_t, and uint64_t types for UST/MSC */ +/* (as used in the GL_EXT_timer_query extension). */ +#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L +#include <inttypes.h> +#elif defined(__sun__) || defined(__digital__) +#include <inttypes.h> +#if defined(__STDC__) +#if defined(__arch64__) || defined(_LP64) +typedef long int int64_t; +typedef unsigned long int uint64_t; +#else +typedef long long int int64_t; +typedef unsigned long long int uint64_t; +#endif /* __arch64__ */ +#endif /* __STDC__ */ +#elif defined( __VMS ) || defined(__sgi) +#include <inttypes.h> +#elif defined(__SCO__) || defined(__USLC__) +#include <stdint.h> +#elif defined(__UNIXOS2__) || defined(__SOL64__) +typedef long int int32_t; +typedef long long int int64_t; +typedef unsigned long long int uint64_t; +#elif defined(_WIN32) && defined(__GNUC__) +#include <stdint.h> +#elif defined(_WIN32) +typedef __int32 int32_t; +typedef __int64 int64_t; +typedef unsigned __int64 uint64_t; +#else +/* Fallback if nothing above works */ +#include <inttypes.h> +#endif +#endif + + typedef unsigned int GLenum; + typedef unsigned char GLboolean; + typedef unsigned int GLbitfield; + typedef void GLvoid; + typedef signed char GLbyte; + typedef short GLshort; + typedef int GLint; + typedef int GLclampx; + typedef unsigned char GLubyte; + typedef unsigned short GLushort; + typedef unsigned int GLuint; + typedef int GLsizei; + typedef float GLfloat; + typedef float GLclampf; + typedef double GLdouble; + typedef double GLclampd; + typedef void *GLeglImageOES; + typedef char GLchar; + typedef char GLcharARB; + #ifdef __APPLE__ +typedef void *GLhandleARB; +#else +typedef unsigned int GLhandleARB; +#endif + typedef unsigned short GLhalfARB; + typedef unsigned short GLhalf; + typedef GLint GLfixed; + typedef ptrdiff_t GLintptr; + typedef ptrdiff_t GLsizeiptr; + typedef int64_t GLint64; + typedef uint64_t GLuint64; + typedef ptrdiff_t GLintptrARB; + typedef ptrdiff_t GLsizeiptrARB; + typedef int64_t GLint64EXT; + typedef uint64_t GLuint64EXT; + typedef struct __GLsync *GLsync; + struct _cl_context; + struct _cl_event; + typedef void ( *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); + typedef void ( *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); + typedef void ( *GLDEBUGPROCKHR)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); + + typedef khronos_int32_t GLclampx; + + typedef khronos_int8_t GLbyte; + typedef khronos_uint8_t GLubyte; + typedef khronos_float_t GLfloat; + typedef khronos_float_t GLclampf; + typedef khronos_int32_t GLfixed; + typedef khronos_int64_t GLint64; + typedef khronos_uint64_t GLuint64; + typedef khronos_intptr_t GLintptr; + typedef khronos_ssize_t GLsizeiptr; + + typedef khronos_int8_t GLbyte; + typedef khronos_uint8_t GLubyte; + typedef khronos_float_t GLfloat; + typedef khronos_float_t GLclampf; + typedef khronos_int32_t GLfixed; + typedef khronos_int64_t GLint64; + typedef khronos_uint64_t GLuint64; + typedef khronos_int64_t GLint64EXT; + typedef khronos_uint64_t GLuint64EXT; + typedef khronos_intptr_t GLintptr; + typedef khronos_ssize_t GLsizeiptr; + + + typedef void ( *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,void *userParam); + typedef unsigned short GLhalfNV; + typedef GLintptr GLvdpauSurfaceNV; + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + void glAccum + GLenum op + GLfloat value + + + + void glAccumxOES + GLenum op + GLfixed value + + + void glActiveProgramEXT + GLuint program + + + void glActiveShaderProgram + GLuint pipeline + GLuint program + + + void glActiveShaderProgramEXT + GLuint pipeline + GLuint program + + + void glActiveStencilFaceEXT + GLenum face + + + + void glActiveTexture + GLenum texture + + + + void glActiveTextureARB + GLenum texture + + + + + void glActiveVaryingNV + GLuint program + const GLchar *name + + + void glAlphaFragmentOp1ATI + GLenum op + GLuint dst + GLuint dstMod + GLuint arg1 + GLuint arg1Rep + GLuint arg1Mod + + + void glAlphaFragmentOp2ATI + GLenum op + GLuint dst + GLuint dstMod + GLuint arg1 + GLuint arg1Rep + GLuint arg1Mod + GLuint arg2 + GLuint arg2Rep + GLuint arg2Mod + + + void glAlphaFragmentOp3ATI + GLenum op + GLuint dst + GLuint dstMod + GLuint arg1 + GLuint arg1Rep + GLuint arg1Mod + GLuint arg2 + GLuint arg2Rep + GLuint arg2Mod + GLuint arg3 + GLuint arg3Rep + GLuint arg3Mod + + + void glAlphaFunc + GLenum func + GLfloat ref + + + + void glAlphaFuncQCOM + GLenum func + GLclampf ref + + + void glAlphaFuncx + GLenum func + GLfixed ref + + + void glAlphaFuncxOES + GLenum func + GLfixed ref + + + void glApplyTextureEXT + GLenum mode + + + GLboolean glAreProgramsResidentNV + GLsizei n + const GLuint *programs + GLboolean *residences + + + + GLboolean glAreTexturesResident + GLsizei n + const GLuint *textures + GLboolean *residences + + + + GLboolean glAreTexturesResidentEXT + GLsizei n + const GLuint *textures + GLboolean *residences + + + + void glArrayElement + GLint i + + + void glArrayElementEXT + GLint i + + + + void glArrayObjectATI + GLenum array + GLint size + GLenum type + GLsizei stride + GLuint buffer + GLuint offset + + + void glAsyncMarkerSGIX + GLuint marker + + + void glAttachObjectARB + GLhandleARB containerObj + GLhandleARB obj + + + + void glAttachShader + GLuint program + GLuint shader + + + void glBegin + GLenum mode + + + + void glBeginConditionalRender + GLuint id + GLenum mode + + + void glBeginConditionalRenderNV + GLuint id + GLenum mode + + + + + void glBeginConditionalRenderNVX + GLuint id + + + void glBeginFragmentShaderATI + + + void glBeginOcclusionQueryNV + GLuint id + + + void glBeginPerfMonitorAMD + GLuint monitor + + + void glBeginPerfQueryINTEL + GLuint queryHandle + + + void glBeginQuery + GLenum target + GLuint id + + + + void glBeginQueryARB + GLenum target + GLuint id + + + + void glBeginQueryEXT + GLenum target + GLuint id + + + void glBeginQueryIndexed + GLenum target + GLuint index + GLuint id + + + void glBeginTransformFeedback + GLenum primitiveMode + + + void glBeginTransformFeedbackEXT + GLenum primitiveMode + + + + void glBeginTransformFeedbackNV + GLenum primitiveMode + + + + void glBeginVertexShaderEXT + + + void glBeginVideoCaptureNV + GLuint video_capture_slot + + + void glBindAttribLocation + GLuint program + GLuint index + const GLchar *name + + + void glBindAttribLocationARB + GLhandleARB programObj + GLuint index + const GLcharARB *name + + + + void glBindBuffer + GLenum target + GLuint buffer + + + void glBindBufferARB + GLenum target + GLuint buffer + + + + void glBindBufferBase + GLenum target + GLuint index + GLuint buffer + + + void glBindBufferBaseEXT + GLenum target + GLuint index + GLuint buffer + + + + void glBindBufferBaseNV + GLenum target + GLuint index + GLuint buffer + + + + void glBindBufferOffsetEXT + GLenum target + GLuint index + GLuint buffer + GLintptr offset + + + void glBindBufferOffsetNV + GLenum target + GLuint index + GLuint buffer + GLintptr offset + + + + void glBindBufferRange + GLenum target + GLuint index + GLuint buffer + GLintptr offset + GLsizeiptr size + + + void glBindBufferRangeEXT + GLenum target + GLuint index + GLuint buffer + GLintptr offset + GLsizeiptr size + + + + void glBindBufferRangeNV + GLenum target + GLuint index + GLuint buffer + GLintptr offset + GLsizeiptr size + + + + void glBindBuffersBase + GLenum target + GLuint first + GLsizei count + const GLuint *buffers + + + void glBindBuffersRange + GLenum target + GLuint first + GLsizei count + const GLuint *buffers + const GLintptr *offsets + const GLsizeiptr *sizes + + + void glBindFragDataLocation + GLuint program + GLuint color + const GLchar *name + + + void glBindFragDataLocationEXT + GLuint program + GLuint color + const GLchar *name + + + + void glBindFragDataLocationIndexed + GLuint program + GLuint colorNumber + GLuint index + const GLchar *name + + + void glBindFragmentShaderATI + GLuint id + + + void glBindFramebuffer + GLenum target + GLuint framebuffer + + + + void glBindFramebufferEXT + GLenum target + GLuint framebuffer + + + + void glBindFramebufferOES + GLenum target + GLuint framebuffer + + + void glBindImageTexture + GLuint unit + GLuint texture + GLint level + GLboolean layered + GLint layer + GLenum access + GLenum format + + + void glBindImageTextureEXT + GLuint index + GLuint texture + GLint level + GLboolean layered + GLint layer + GLenum access + GLint format + + + void glBindImageTextures + GLuint first + GLsizei count + const GLuint *textures + + + GLuint glBindLightParameterEXT + GLenum light + GLenum value + + + GLuint glBindMaterialParameterEXT + GLenum face + GLenum value + + + void glBindMultiTextureEXT + GLenum texunit + GLenum target + GLuint texture + + + GLuint glBindParameterEXT + GLenum value + + + void glBindProgramARB + GLenum target + GLuint program + + + + void glBindProgramNV + GLenum target + GLuint id + + + + + void glBindProgramPipeline + GLuint pipeline + + + void glBindProgramPipelineEXT + GLuint pipeline + + + void glBindRenderbuffer + GLenum target + GLuint renderbuffer + + + + void glBindRenderbufferEXT + GLenum target + GLuint renderbuffer + + + + void glBindRenderbufferOES + GLenum target + GLuint renderbuffer + + + void glBindSampler + GLuint unit + GLuint sampler + + + void glBindSamplers + GLuint first + GLsizei count + const GLuint *samplers + + + GLuint glBindTexGenParameterEXT + GLenum unit + GLenum coord + GLenum value + + + void glBindTexture + GLenum target + GLuint texture + + + + void glBindTextureEXT + GLenum target + GLuint texture + + + + + void glBindTextureUnit + GLuint unit + GLuint texture + + + GLuint glBindTextureUnitParameterEXT + GLenum unit + GLenum value + + + void glBindTextures + GLuint first + GLsizei count + const GLuint *textures + + + void glBindTransformFeedback + GLenum target + GLuint id + + + void glBindTransformFeedbackNV + GLenum target + GLuint id + + + void glBindVertexArray + GLuint array + + + + void glBindVertexArrayAPPLE + GLuint array + + + void glBindVertexArrayOES + GLuint array + + + + void glBindVertexBuffer + GLuint bindingindex + GLuint buffer + GLintptr offset + GLsizei stride + + + void glBindVertexBuffers + GLuint first + GLsizei count + const GLuint *buffers + const GLintptr *offsets + const GLsizei *strides + + + void glBindVertexShaderEXT + GLuint id + + + void glBindVideoCaptureStreamBufferNV + GLuint video_capture_slot + GLuint stream + GLenum frame_region + GLintptrARB offset + + + void glBindVideoCaptureStreamTextureNV + GLuint video_capture_slot + GLuint stream + GLenum frame_region + GLenum target + GLuint texture + + + void glBinormal3bEXT + GLbyte bx + GLbyte by + GLbyte bz + + + + void glBinormal3bvEXT + const GLbyte *v + + + void glBinormal3dEXT + GLdouble bx + GLdouble by + GLdouble bz + + + + void glBinormal3dvEXT + const GLdouble *v + + + void glBinormal3fEXT + GLfloat bx + GLfloat by + GLfloat bz + + + + void glBinormal3fvEXT + const GLfloat *v + + + void glBinormal3iEXT + GLint bx + GLint by + GLint bz + + + + void glBinormal3ivEXT + const GLint *v + + + void glBinormal3sEXT + GLshort bx + GLshort by + GLshort bz + + + + void glBinormal3svEXT + const GLshort *v + + + void glBinormalPointerEXT + GLenum type + GLsizei stride + const void *pointer + + + void glBitmap + GLsizei width + GLsizei height + GLfloat xorig + GLfloat yorig + GLfloat xmove + GLfloat ymove + const GLubyte *bitmap + + + + + void glBitmapxOES + GLsizei width + GLsizei height + GLfixed xorig + GLfixed yorig + GLfixed xmove + GLfixed ymove + const GLubyte *bitmap + + + void glBlendBarrierKHR + + + void glBlendBarrierNV + + + void glBlendColor + GLfloat red + GLfloat green + GLfloat blue + GLfloat alpha + + + + void glBlendColorEXT + GLfloat red + GLfloat green + GLfloat blue + GLfloat alpha + + + + + void glBlendColorxOES + GLfixed red + GLfixed green + GLfixed blue + GLfixed alpha + + + void glBlendEquation + GLenum mode + + + + void glBlendEquationEXT + GLenum mode + + + + + void glBlendEquationIndexedAMD + GLuint buf + GLenum mode + + + + void glBlendEquationOES + GLenum mode + + + void glBlendEquationSeparate + GLenum modeRGB + GLenum modeAlpha + + + + void glBlendEquationSeparateEXT + GLenum modeRGB + GLenum modeAlpha + + + + + void glBlendEquationSeparateIndexedAMD + GLuint buf + GLenum modeRGB + GLenum modeAlpha + + + + void glBlendEquationSeparateOES + GLenum modeRGB + GLenum modeAlpha + + + void glBlendEquationSeparatei + GLuint buf + GLenum modeRGB + GLenum modeAlpha + + + void glBlendEquationSeparateiARB + GLuint buf + GLenum modeRGB + GLenum modeAlpha + + + + void glBlendEquationSeparateiEXT + GLuint buf + GLenum modeRGB + GLenum modeAlpha + + + + void glBlendEquationi + GLuint buf + GLenum mode + + + void glBlendEquationiARB + GLuint buf + GLenum mode + + + + void glBlendEquationiEXT + GLuint buf + GLenum mode + + + + void glBlendFunc + GLenum sfactor + GLenum dfactor + + + + void glBlendFuncIndexedAMD + GLuint buf + GLenum src + GLenum dst + + + + void glBlendFuncSeparate + GLenum sfactorRGB + GLenum dfactorRGB + GLenum sfactorAlpha + GLenum dfactorAlpha + + + + void glBlendFuncSeparateEXT + GLenum sfactorRGB + GLenum dfactorRGB + GLenum sfactorAlpha + GLenum dfactorAlpha + + + + + void glBlendFuncSeparateINGR + GLenum sfactorRGB + GLenum dfactorRGB + GLenum sfactorAlpha + GLenum dfactorAlpha + + + + + void glBlendFuncSeparateIndexedAMD + GLuint buf + GLenum srcRGB + GLenum dstRGB + GLenum srcAlpha + GLenum dstAlpha + + + + void glBlendFuncSeparateOES + GLenum srcRGB + GLenum dstRGB + GLenum srcAlpha + GLenum dstAlpha + + + void glBlendFuncSeparatei + GLuint buf + GLenum srcRGB + GLenum dstRGB + GLenum srcAlpha + GLenum dstAlpha + + + void glBlendFuncSeparateiARB + GLuint buf + GLenum srcRGB + GLenum dstRGB + GLenum srcAlpha + GLenum dstAlpha + + + + void glBlendFuncSeparateiEXT + GLuint buf + GLenum srcRGB + GLenum dstRGB + GLenum srcAlpha + GLenum dstAlpha + + + + void glBlendFunci + GLuint buf + GLenum src + GLenum dst + + + void glBlendFunciARB + GLuint buf + GLenum src + GLenum dst + + + + void glBlendFunciEXT + GLuint buf + GLenum src + GLenum dst + + + + void glBlendParameteriNV + GLenum pname + GLint value + + + void glBlitFramebuffer + GLint srcX0 + GLint srcY0 + GLint srcX1 + GLint srcY1 + GLint dstX0 + GLint dstY0 + GLint dstX1 + GLint dstY1 + GLbitfield mask + GLenum filter + + + + void glBlitFramebufferANGLE + GLint srcX0 + GLint srcY0 + GLint srcX1 + GLint srcY1 + GLint dstX0 + GLint dstY0 + GLint dstX1 + GLint dstY1 + GLbitfield mask + GLenum filter + + + void glBlitFramebufferEXT + GLint srcX0 + GLint srcY0 + GLint srcX1 + GLint srcY1 + GLint dstX0 + GLint dstY0 + GLint dstX1 + GLint dstY1 + GLbitfield mask + GLenum filter + + + + + void glBlitFramebufferNV + GLint srcX0 + GLint srcY0 + GLint srcX1 + GLint srcY1 + GLint dstX0 + GLint dstY0 + GLint dstX1 + GLint dstY1 + GLbitfield mask + GLenum filter + + + + void glBlitNamedFramebuffer + GLuint readFramebuffer + GLuint drawFramebuffer + GLint srcX0 + GLint srcY0 + GLint srcX1 + GLint srcY1 + GLint dstX0 + GLint dstY0 + GLint dstX1 + GLint dstY1 + GLbitfield mask + GLenum filter + + + void glBufferAddressRangeNV + GLenum pname + GLuint index + GLuint64EXT address + GLsizeiptr length + + + void glBufferData + GLenum target + GLsizeiptr size + const void *data + GLenum usage + + + void glBufferDataARB + GLenum target + GLsizeiptrARB size + const void *data + GLenum usage + + + + void glBufferPageCommitmentARB + GLenum target + GLintptr offset + GLsizei size + GLboolean commit + + + void glBufferParameteriAPPLE + GLenum target + GLenum pname + GLint param + + + void glBufferStorage + GLenum target + GLsizeiptr size + const void *data + GLbitfield flags + + + void glBufferSubData + GLenum target + GLintptr offset + GLsizeiptr size + const void *data + + + void glBufferSubDataARB + GLenum target + GLintptrARB offset + GLsizeiptrARB size + const void *data + + + + void glCallList + GLuint list + + + + void glCallLists + GLsizei n + GLenum type + const void *lists + + + + GLenum glCheckFramebufferStatus + GLenum target + + + + GLenum glCheckFramebufferStatusEXT + GLenum target + + + + + GLenum glCheckFramebufferStatusOES + GLenum target + + + GLenum glCheckNamedFramebufferStatus + GLuint framebuffer + GLenum target + + + GLenum glCheckNamedFramebufferStatusEXT + GLuint framebuffer + GLenum target + + + void glClampColor + GLenum target + GLenum clamp + + + + void glClampColorARB + GLenum target + GLenum clamp + + + + + void glClear + GLbitfield mask + + + + void glClearAccum + GLfloat red + GLfloat green + GLfloat blue + GLfloat alpha + + + + void glClearAccumxOES + GLfixed red + GLfixed green + GLfixed blue + GLfixed alpha + + + void glClearBufferData + GLenum target + GLenum internalformat + GLenum format + GLenum type + const void *data + + + void glClearBufferSubData + GLenum target + GLenum internalformat + GLintptr offset + GLsizeiptr size + GLenum format + GLenum type + const void *data + + + void glClearBufferfi + GLenum buffer + GLint drawbuffer + GLfloat depth + GLint stencil + + + void glClearBufferfv + GLenum buffer + GLint drawbuffer + const GLfloat *value + + + void glClearBufferiv + GLenum buffer + GLint drawbuffer + const GLint *value + + + void glClearBufferuiv + GLenum buffer + GLint drawbuffer + const GLuint *value + + + void glClearColor + GLfloat red + GLfloat green + GLfloat blue + GLfloat alpha + + + + void glClearColorIiEXT + GLint red + GLint green + GLint blue + GLint alpha + + + + void glClearColorIuiEXT + GLuint red + GLuint green + GLuint blue + GLuint alpha + + + + void glClearColorx + GLfixed red + GLfixed green + GLfixed blue + GLfixed alpha + + + void glClearColorxOES + GLfixed red + GLfixed green + GLfixed blue + GLfixed alpha + + + void glClearDepth + GLdouble depth + + + + void glClearDepthdNV + GLdouble depth + + + + void glClearDepthf + GLfloat d + + + void glClearDepthfOES + GLclampf depth + + + + + void glClearDepthx + GLfixed depth + + + void glClearDepthxOES + GLfixed depth + + + void glClearIndex + GLfloat c + + + + void glClearNamedBufferData + GLuint buffer + GLenum internalformat + GLenum format + GLenum type + const void *data + + + void glClearNamedBufferDataEXT + GLuint buffer + GLenum internalformat + GLenum format + GLenum type + const void *data + + + void glClearNamedBufferSubData + GLuint buffer + GLenum internalformat + GLintptr offset + GLsizei size + GLenum format + GLenum type + const void *data + + + void glClearNamedBufferSubDataEXT + GLuint buffer + GLenum internalformat + GLsizeiptr offset + GLsizeiptr size + GLenum format + GLenum type + const void *data + + + void glClearNamedFramebufferfi + GLuint framebuffer + GLenum buffer + const GLfloat depth + GLint stencil + + + void glClearNamedFramebufferfv + GLuint framebuffer + GLenum buffer + GLint drawbuffer + const GLfloat *value + + + void glClearNamedFramebufferiv + GLuint framebuffer + GLenum buffer + GLint drawbuffer + const GLint *value + + + void glClearNamedFramebufferuiv + GLuint framebuffer + GLenum buffer + GLint drawbuffer + const GLuint *value + + + void glClearStencil + GLint s + + + + void glClearTexImage + GLuint texture + GLint level + GLenum format + GLenum type + const void *data + + + void glClearTexSubImage + GLuint texture + GLint level + GLint xoffset + GLint yoffset + GLint zoffset + GLsizei width + GLsizei height + GLsizei depth + GLenum format + GLenum type + const void *data + + + void glClientActiveTexture + GLenum texture + + + void glClientActiveTextureARB + GLenum texture + + + + void glClientActiveVertexStreamATI + GLenum stream + + + void glClientAttribDefaultEXT + GLbitfield mask + + + GLenum glClientWaitSync + GLsync sync + GLbitfield flags + GLuint64 timeout + + + GLenum glClientWaitSyncAPPLE + GLsync sync + GLbitfield flags + GLuint64 timeout + + + + void glClipControl + GLenum origin + GLenum depth + + + void glClipPlane + GLenum plane + const GLdouble *equation + + + + void glClipPlanef + GLenum p + const GLfloat *eqn + + + void glClipPlanefIMG + GLenum p + const GLfloat *eqn + + + void glClipPlanefOES + GLenum plane + const GLfloat *equation + + + + void glClipPlanex + GLenum plane + const GLfixed *equation + + + void glClipPlanexIMG + GLenum p + const GLfixed *eqn + + + void glClipPlanexOES + GLenum plane + const GLfixed *equation + + + void glColor3b + GLbyte red + GLbyte green + GLbyte blue + + + + void glColor3bv + const GLbyte *v + + + + void glColor3d + GLdouble red + GLdouble green + GLdouble blue + + + + void glColor3dv + const GLdouble *v + + + + void glColor3f + GLfloat red + GLfloat green + GLfloat blue + + + + void glColor3fVertex3fSUN + GLfloat r + GLfloat g + GLfloat b + GLfloat x + GLfloat y + GLfloat z + + + void glColor3fVertex3fvSUN + const GLfloat *c + const GLfloat *v + + + void glColor3fv + const GLfloat *v + + + + void glColor3hNV + GLhalfNV red + GLhalfNV green + GLhalfNV blue + + + + void glColor3hvNV + const GLhalfNV *v + + + + void glColor3i + GLint red + GLint green + GLint blue + + + + void glColor3iv + const GLint *v + + + + void glColor3s + GLshort red + GLshort green + GLshort blue + + + + void glColor3sv + const GLshort *v + + + + void glColor3ub + GLubyte red + GLubyte green + GLubyte blue + + + + void glColor3ubv + const GLubyte *v + + + + void glColor3ui + GLuint red + GLuint green + GLuint blue + + + + void glColor3uiv + const GLuint *v + + + + void glColor3us + GLushort red + GLushort green + GLushort blue + + + + void glColor3usv + const GLushort *v + + + + void glColor3xOES + GLfixed red + GLfixed green + GLfixed blue + + + void glColor3xvOES + const GLfixed *components + + + void glColor4b + GLbyte red + GLbyte green + GLbyte blue + GLbyte alpha + + + + void glColor4bv + const GLbyte *v + + + + void glColor4d + GLdouble red + GLdouble green + GLdouble blue + GLdouble alpha + + + + void glColor4dv + const GLdouble *v + + + + void glColor4f + GLfloat red + GLfloat green + GLfloat blue + GLfloat alpha + + + + void glColor4fNormal3fVertex3fSUN + GLfloat r + GLfloat g + GLfloat b + GLfloat a + GLfloat nx + GLfloat ny + GLfloat nz + GLfloat x + GLfloat y + GLfloat z + + + void glColor4fNormal3fVertex3fvSUN + const GLfloat *c + const GLfloat *n + const GLfloat *v + + + void glColor4fv + const GLfloat *v + + + + void glColor4hNV + GLhalfNV red + GLhalfNV green + GLhalfNV blue + GLhalfNV alpha + + + + void glColor4hvNV + const GLhalfNV *v + + + + void glColor4i + GLint red + GLint green + GLint blue + GLint alpha + + + + void glColor4iv + const GLint *v + + + + void glColor4s + GLshort red + GLshort green + GLshort blue + GLshort alpha + + + + void glColor4sv + const GLshort *v + + + + void glColor4ub + GLubyte red + GLubyte green + GLubyte blue + GLubyte alpha + + + + void glColor4ubVertex2fSUN + GLubyte r + GLubyte g + GLubyte b + GLubyte a + GLfloat x + GLfloat y + + + void glColor4ubVertex2fvSUN + const GLubyte *c + const GLfloat *v + + + void glColor4ubVertex3fSUN + GLubyte r + GLubyte g + GLubyte b + GLubyte a + GLfloat x + GLfloat y + GLfloat z + + + void glColor4ubVertex3fvSUN + const GLubyte *c + const GLfloat *v + + + void glColor4ubv + const GLubyte *v + + + + void glColor4ui + GLuint red + GLuint green + GLuint blue + GLuint alpha + + + + void glColor4uiv + const GLuint *v + + + + void glColor4us + GLushort red + GLushort green + GLushort blue + GLushort alpha + + + + void glColor4usv + const GLushort *v + + + + void glColor4x + GLfixed red + GLfixed green + GLfixed blue + GLfixed alpha + + + void glColor4xOES + GLfixed red + GLfixed green + GLfixed blue + GLfixed alpha + + + void glColor4xvOES + const GLfixed *components + + + void glColorFormatNV + GLint size + GLenum type + GLsizei stride + + + void glColorFragmentOp1ATI + GLenum op + GLuint dst + GLuint dstMask + GLuint dstMod + GLuint arg1 + GLuint arg1Rep + GLuint arg1Mod + + + void glColorFragmentOp2ATI + GLenum op + GLuint dst + GLuint dstMask + GLuint dstMod + GLuint arg1 + GLuint arg1Rep + GLuint arg1Mod + GLuint arg2 + GLuint arg2Rep + GLuint arg2Mod + + + void glColorFragmentOp3ATI + GLenum op + GLuint dst + GLuint dstMask + GLuint dstMod + GLuint arg1 + GLuint arg1Rep + GLuint arg1Mod + GLuint arg2 + GLuint arg2Rep + GLuint arg2Mod + GLuint arg3 + GLuint arg3Rep + GLuint arg3Mod + + + void glColorMask + GLboolean red + GLboolean green + GLboolean blue + GLboolean alpha + + + + void glColorMaskIndexedEXT + GLuint index + GLboolean r + GLboolean g + GLboolean b + GLboolean a + + + + void glColorMaski + GLuint index + GLboolean r + GLboolean g + GLboolean b + GLboolean a + + + void glColorMaskiEXT + GLuint index + GLboolean r + GLboolean g + GLboolean b + GLboolean a + + + + void glColorMaterial + GLenum face + GLenum mode + + + + void glColorP3ui + GLenum type + GLuint color + + + void glColorP3uiv + GLenum type + const GLuint *color + + + void glColorP4ui + GLenum type + GLuint color + + + void glColorP4uiv + GLenum type + const GLuint *color + + + void glColorPointer + GLint size + GLenum type + GLsizei stride + const void *pointer + + + void glColorPointerEXT + GLint size + GLenum type + GLsizei stride + GLsizei count + const void *pointer + + + void glColorPointerListIBM + GLint size + GLenum type + GLint stride + const void **pointer + GLint ptrstride + + + void glColorPointervINTEL + GLint size + GLenum type + const void **pointer + + + void glColorSubTable + GLenum target + GLsizei start + GLsizei count + GLenum format + GLenum type + const void *data + + + + + void glColorSubTableEXT + GLenum target + GLsizei start + GLsizei count + GLenum format + GLenum type + const void *data + + + + void glColorTable + GLenum target + GLenum internalformat + GLsizei width + GLenum format + GLenum type + const void *table + + + + + void glColorTableEXT + GLenum target + GLenum internalFormat + GLsizei width + GLenum format + GLenum type + const void *table + + + + void glColorTableParameterfv + GLenum target + GLenum pname + const GLfloat *params + + + + void glColorTableParameterfvSGI + GLenum target + GLenum pname + const GLfloat *params + + + + + void glColorTableParameteriv + GLenum target + GLenum pname + const GLint *params + + + + void glColorTableParameterivSGI + GLenum target + GLenum pname + const GLint *params + + + + + void glColorTableSGI + GLenum target + GLenum internalformat + GLsizei width + GLenum format + GLenum type + const void *table + + + + + void glCombinerInputNV + GLenum stage + GLenum portion + GLenum variable + GLenum input + GLenum mapping + GLenum componentUsage + + + + void glCombinerOutputNV + GLenum stage + GLenum portion + GLenum abOutput + GLenum cdOutput + GLenum sumOutput + GLenum scale + GLenum bias + GLboolean abDotProduct + GLboolean cdDotProduct + GLboolean muxSum + + + + void glCombinerParameterfNV + GLenum pname + GLfloat param + + + + void glCombinerParameterfvNV + GLenum pname + const GLfloat *params + + + + void glCombinerParameteriNV + GLenum pname + GLint param + + + + void glCombinerParameterivNV + GLenum pname + const GLint *params + + + + void glCombinerStageParameterfvNV + GLenum stage + GLenum pname + const GLfloat *params + + + void glCompileShader + GLuint shader + + + void glCompileShaderARB + GLhandleARB shaderObj + + + + void glCompileShaderIncludeARB + GLuint shader + GLsizei count + const GLchar *const*path + const GLint *length + + + void glCompressedMultiTexImage1DEXT + GLenum texunit + GLenum target + GLint level + GLenum internalformat + GLsizei width + GLint border + GLsizei imageSize + const void *bits + + + void glCompressedMultiTexImage2DEXT + GLenum texunit + GLenum target + GLint level + GLenum internalformat + GLsizei width + GLsizei height + GLint border + GLsizei imageSize + const void *bits + + + void glCompressedMultiTexImage3DEXT + GLenum texunit + GLenum target + GLint level + GLenum internalformat + GLsizei width + GLsizei height + GLsizei depth + GLint border + GLsizei imageSize + const void *bits + + + void glCompressedMultiTexSubImage1DEXT + GLenum texunit + GLenum target + GLint level + GLint xoffset + GLsizei width + GLenum format + GLsizei imageSize + const void *bits + + + void glCompressedMultiTexSubImage2DEXT + GLenum texunit + GLenum target + GLint level + GLint xoffset + GLint yoffset + GLsizei width + GLsizei height + GLenum format + GLsizei imageSize + const void *bits + + + void glCompressedMultiTexSubImage3DEXT + GLenum texunit + GLenum target + GLint level + GLint xoffset + GLint yoffset + GLint zoffset + GLsizei width + GLsizei height + GLsizei depth + GLenum format + GLsizei imageSize + const void *bits + + + void glCompressedTexImage1D + GLenum target + GLint level + GLenum internalformat + GLsizei width + GLint border + GLsizei imageSize + const void *data + + + + + void glCompressedTexImage1DARB + GLenum target + GLint level + GLenum internalformat + GLsizei width + GLint border + GLsizei imageSize + const void *data + + + + + void glCompressedTexImage2D + GLenum target + GLint level + GLenum internalformat + GLsizei width + GLsizei height + GLint border + GLsizei imageSize + const void *data + + + + + void glCompressedTexImage2DARB + GLenum target + GLint level + GLenum internalformat + GLsizei width + GLsizei height + GLint border + GLsizei imageSize + const void *data + + + + + void glCompressedTexImage3D + GLenum target + GLint level + GLenum internalformat + GLsizei width + GLsizei height + GLsizei depth + GLint border + GLsizei imageSize + const void *data + + + + + void glCompressedTexImage3DARB + GLenum target + GLint level + GLenum internalformat + GLsizei width + GLsizei height + GLsizei depth + GLint border + GLsizei imageSize + const void *data + + + + + void glCompressedTexImage3DOES + GLenum target + GLint level + GLenum internalformat + GLsizei width + GLsizei height + GLsizei depth + GLint border + GLsizei imageSize + const void *data + + + + void glCompressedTexSubImage1D + GLenum target + GLint level + GLint xoffset + GLsizei width + GLenum format + GLsizei imageSize + const void *data + + + + + void glCompressedTexSubImage1DARB + GLenum target + GLint level + GLint xoffset + GLsizei width + GLenum format + GLsizei imageSize + const void *data + + + + + void glCompressedTexSubImage2D + GLenum target + GLint level + GLint xoffset + GLint yoffset + GLsizei width + GLsizei height + GLenum format + GLsizei imageSize + const void *data + + + + + void glCompressedTexSubImage2DARB + GLenum target + GLint level + GLint xoffset + GLint yoffset + GLsizei width + GLsizei height + GLenum format + GLsizei imageSize + const void *data + + + + + void glCompressedTexSubImage3D + GLenum target + GLint level + GLint xoffset + GLint yoffset + GLint zoffset + GLsizei width + GLsizei height + GLsizei depth + GLenum format + GLsizei imageSize + const void *data + + + + + void glCompressedTexSubImage3DARB + GLenum target + GLint level + GLint xoffset + GLint yoffset + GLint zoffset + GLsizei width + GLsizei height + GLsizei depth + GLenum format + GLsizei imageSize + const void *data + + + + + void glCompressedTexSubImage3DOES + GLenum target + GLint level + GLint xoffset + GLint yoffset + GLint zoffset + GLsizei width + GLsizei height + GLsizei depth + GLenum format + GLsizei imageSize + const void *data + + + + void glCompressedTextureImage1DEXT + GLuint texture + GLenum target + GLint level + GLenum internalformat + GLsizei width + GLint border + GLsizei imageSize + const void *bits + + + void glCompressedTextureImage2DEXT + GLuint texture + GLenum target + GLint level + GLenum internalformat + GLsizei width + GLsizei height + GLint border + GLsizei imageSize + const void *bits + + + void glCompressedTextureImage3DEXT + GLuint texture + GLenum target + GLint level + GLenum internalformat + GLsizei width + GLsizei height + GLsizei depth + GLint border + GLsizei imageSize + const void *bits + + + void glCompressedTextureSubImage1D + GLuint texture + GLint level + GLint xoffset + GLsizei width + GLenum format + GLsizei imageSize + const void *data + + + void glCompressedTextureSubImage1DEXT + GLuint texture + GLenum target + GLint level + GLint xoffset + GLsizei width + GLenum format + GLsizei imageSize + const void *bits + + + void glCompressedTextureSubImage2D + GLuint texture + GLint level + GLint xoffset + GLint yoffset + GLsizei width + GLsizei height + GLenum format + GLsizei imageSize + const void *data + + + void glCompressedTextureSubImage2DEXT + GLuint texture + GLenum target + GLint level + GLint xoffset + GLint yoffset + GLsizei width + GLsizei height + GLenum format + GLsizei imageSize + const void *bits + + + void glCompressedTextureSubImage3D + GLuint texture + GLint level + GLint xoffset + GLint yoffset + GLint zoffset + GLsizei width + GLsizei height + GLsizei depth + GLenum format + GLsizei imageSize + const void *data + + + void glCompressedTextureSubImage3DEXT + GLuint texture + GLenum target + GLint level + GLint xoffset + GLint yoffset + GLint zoffset + GLsizei width + GLsizei height + GLsizei depth + GLenum format + GLsizei imageSize + const void *bits + + + void glConvolutionFilter1D + GLenum target + GLenum internalformat + GLsizei width + GLenum format + GLenum type + const void *image + + + + + void glConvolutionFilter1DEXT + GLenum target + GLenum internalformat + GLsizei width + GLenum format + GLenum type + const void *image + + + + + void glConvolutionFilter2D + GLenum target + GLenum internalformat + GLsizei width + GLsizei height + GLenum format + GLenum type + const void *image + + + + + void glConvolutionFilter2DEXT + GLenum target + GLenum internalformat + GLsizei width + GLsizei height + GLenum format + GLenum type + const void *image + + + + + void glConvolutionParameterf + GLenum target + GLenum pname + GLfloat params + + + + void glConvolutionParameterfEXT + GLenum target + GLenum pname + GLfloat params + + + + + void glConvolutionParameterfv + GLenum target + GLenum pname + const GLfloat *params + + + + void glConvolutionParameterfvEXT + GLenum target + GLenum pname + const GLfloat *params + + + + + void glConvolutionParameteri + GLenum target + GLenum pname + GLint params + + + + void glConvolutionParameteriEXT + GLenum target + GLenum pname + GLint params + + + + + void glConvolutionParameteriv + GLenum target + GLenum pname + const GLint *params + + + + void glConvolutionParameterivEXT + GLenum target + GLenum pname + const GLint *params + + + + + void glConvolutionParameterxOES + GLenum target + GLenum pname + GLfixed param + + + void glConvolutionParameterxvOES + GLenum target + GLenum pname + const GLfixed *params + + + void glCopyBufferSubData + GLenum readTarget + GLenum writeTarget + GLintptr readOffset + GLintptr writeOffset + GLsizeiptr size + + + void glCopyBufferSubDataNV + GLenum readTarget + GLenum writeTarget + GLintptr readOffset + GLintptr writeOffset + GLsizeiptr size + + + + void glCopyColorSubTable + GLenum target + GLsizei start + GLint x + GLint y + GLsizei width + + + + void glCopyColorSubTableEXT + GLenum target + GLsizei start + GLint x + GLint y + GLsizei width + + + + void glCopyColorTable + GLenum target + GLenum internalformat + GLint x + GLint y + GLsizei width + + + + void glCopyColorTableSGI + GLenum target + GLenum internalformat + GLint x + GLint y + GLsizei width + + + + + void glCopyConvolutionFilter1D + GLenum target + GLenum internalformat + GLint x + GLint y + GLsizei width + + + + void glCopyConvolutionFilter1DEXT + GLenum target + GLenum internalformat + GLint x + GLint y + GLsizei width + + + + + void glCopyConvolutionFilter2D + GLenum target + GLenum internalformat + GLint x + GLint y + GLsizei width + GLsizei height + + + + void glCopyConvolutionFilter2DEXT + GLenum target + GLenum internalformat + GLint x + GLint y + GLsizei width + GLsizei height + + + + + void glCopyImageSubData + GLuint srcName + GLenum srcTarget + GLint srcLevel + GLint srcX + GLint srcY + GLint srcZ + GLuint dstName + GLenum dstTarget + GLint dstLevel + GLint dstX + GLint dstY + GLint dstZ + GLsizei srcWidth + GLsizei srcHeight + GLsizei srcDepth + + + void glCopyImageSubDataEXT + GLuint srcName + GLenum srcTarget + GLint srcLevel + GLint srcX + GLint srcY + GLint srcZ + GLuint dstName + GLenum dstTarget + GLint dstLevel + GLint dstX + GLint dstY + GLint dstZ + GLsizei srcWidth + GLsizei srcHeight + GLsizei srcDepth + + + + void glCopyImageSubDataNV + GLuint srcName + GLenum srcTarget + GLint srcLevel + GLint srcX + GLint srcY + GLint srcZ + GLuint dstName + GLenum dstTarget + GLint dstLevel + GLint dstX + GLint dstY + GLint dstZ + GLsizei width + GLsizei height + GLsizei depth + + + + void glCopyMultiTexImage1DEXT + GLenum texunit + GLenum target + GLint level + GLenum internalformat + GLint x + GLint y + GLsizei width + GLint border + + + void glCopyMultiTexImage2DEXT + GLenum texunit + GLenum target + GLint level + GLenum internalformat + GLint x + GLint y + GLsizei width + GLsizei height + GLint border + + + void glCopyMultiTexSubImage1DEXT + GLenum texunit + GLenum target + GLint level + GLint xoffset + GLint x + GLint y + GLsizei width + + + void glCopyMultiTexSubImage2DEXT + GLenum texunit + GLenum target + GLint level + GLint xoffset + GLint yoffset + GLint x + GLint y + GLsizei width + GLsizei height + + + void glCopyMultiTexSubImage3DEXT + GLenum texunit + GLenum target + GLint level + GLint xoffset + GLint yoffset + GLint zoffset + GLint x + GLint y + GLsizei width + GLsizei height + + + void glCopyNamedBufferSubData + GLuint readBuffer + GLuint writeBuffer + GLintptr readOffset + GLintptr writeOffset + GLsizei size + + + void glCopyPathNV + GLuint resultPath + GLuint srcPath + + + void glCopyPixels + GLint x + GLint y + GLsizei width + GLsizei height + GLenum type + + + + void glCopyTexImage1D + GLenum target + GLint level + GLenum internalformat + GLint x + GLint y + GLsizei width + GLint border + + + + void glCopyTexImage1DEXT + GLenum target + GLint level + GLenum internalformat + GLint x + GLint y + GLsizei width + GLint border + + + + + void glCopyTexImage2D + GLenum target + GLint level + GLenum internalformat + GLint x + GLint y + GLsizei width + GLsizei height + GLint border + + + + void glCopyTexImage2DEXT + GLenum target + GLint level + GLenum internalformat + GLint x + GLint y + GLsizei width + GLsizei height + GLint border + + + + + void glCopyTexSubImage1D + GLenum target + GLint level + GLint xoffset + GLint x + GLint y + GLsizei width + + + + void glCopyTexSubImage1DEXT + GLenum target + GLint level + GLint xoffset + GLint x + GLint y + GLsizei width + + + + + void glCopyTexSubImage2D + GLenum target + GLint level + GLint xoffset + GLint yoffset + GLint x + GLint y + GLsizei width + GLsizei height + + + + void glCopyTexSubImage2DEXT + GLenum target + GLint level + GLint xoffset + GLint yoffset + GLint x + GLint y + GLsizei width + GLsizei height + + + + + void glCopyTexSubImage3D + GLenum target + GLint level + GLint xoffset + GLint yoffset + GLint zoffset + GLint x + GLint y + GLsizei width + GLsizei height + + + + void glCopyTexSubImage3DEXT + GLenum target + GLint level + GLint xoffset + GLint yoffset + GLint zoffset + GLint x + GLint y + GLsizei width + GLsizei height + + + + + void glCopyTexSubImage3DOES + GLenum target + GLint level + GLint xoffset + GLint yoffset + GLint zoffset + GLint x + GLint y + GLsizei width + GLsizei height + + + + void glCopyTextureImage1DEXT + GLuint texture + GLenum target + GLint level + GLenum internalformat + GLint x + GLint y + GLsizei width + GLint border + + + void glCopyTextureImage2DEXT + GLuint texture + GLenum target + GLint level + GLenum internalformat + GLint x + GLint y + GLsizei width + GLsizei height + GLint border + + + void glCopyTextureLevelsAPPLE + GLuint destinationTexture + GLuint sourceTexture + GLint sourceBaseLevel + GLsizei sourceLevelCount + + + void glCopyTextureSubImage1D + GLuint texture + GLint level + GLint xoffset + GLint x + GLint y + GLsizei width + + + void glCopyTextureSubImage1DEXT + GLuint texture + GLenum target + GLint level + GLint xoffset + GLint x + GLint y + GLsizei width + + + void glCopyTextureSubImage2D + GLuint texture + GLint level + GLint xoffset + GLint yoffset + GLint x + GLint y + GLsizei width + GLsizei height + + + void glCopyTextureSubImage2DEXT + GLuint texture + GLenum target + GLint level + GLint xoffset + GLint yoffset + GLint x + GLint y + GLsizei width + GLsizei height + + + void glCopyTextureSubImage3D + GLuint texture + GLint level + GLint xoffset + GLint yoffset + GLint zoffset + GLint x + GLint y + GLsizei width + GLsizei height + + + void glCopyTextureSubImage3DEXT + GLuint texture + GLenum target + GLint level + GLint xoffset + GLint yoffset + GLint zoffset + GLint x + GLint y + GLsizei width + GLsizei height + + + void glCoverFillPathInstancedNV + GLsizei numPaths + GLenum pathNameType + const void *paths + GLuint pathBase + GLenum coverMode + GLenum transformType + const GLfloat *transformValues + + + void glCoverFillPathNV + GLuint path + GLenum coverMode + + + void glCoverStrokePathInstancedNV + GLsizei numPaths + GLenum pathNameType + const void *paths + GLuint pathBase + GLenum coverMode + GLenum transformType + const GLfloat *transformValues + + + void glCoverStrokePathNV + GLuint path + GLenum coverMode + + + void glCoverageMaskNV + GLboolean mask + + + void glCoverageOperationNV + GLenum operation + + + void glCreateBuffers + GLsizei n + GLuint *buffers + + + void glCreateFramebuffers + GLsizei n + GLuint *framebuffers + + + void glCreatePerfQueryINTEL + GLuint queryId + GLuint *queryHandle + + + GLuint glCreateProgram + + + GLhandleARB glCreateProgramObjectARB + + + + void glCreateProgramPipelines + GLsizei n + GLuint *pipelines + + + void glCreateQueries + GLenum target + GLsizei n + GLuint *ids + + + void glCreateRenderbuffers + GLsizei n + GLuint *renderbuffers + + + void glCreateSamplers + GLsizei n + GLuint *samplers + + + GLuint glCreateShader + GLenum type + + + GLhandleARB glCreateShaderObjectARB + GLenum shaderType + + + + GLuint glCreateShaderProgramEXT + GLenum type + const GLchar *string + + + GLuint glCreateShaderProgramv + GLenum type + GLsizei count + const GLchar *const*strings + + + GLuint glCreateShaderProgramvEXT + GLenum type + GLsizei count + const GLchar **strings + + + GLsync glCreateSyncFromCLeventARB + struct _cl_context *context + struct _cl_event *event + GLbitfield flags + + + void glCreateTextures + GLenum target + GLsizei n + GLuint *textures + + + void glCreateTransformFeedbacks + GLsizei n + GLuint *ids + + + void glCreateVertexArrays + GLsizei n + GLuint *arrays + + + void glCullFace + GLenum mode + + + + void glCullParameterdvEXT + GLenum pname + GLdouble *params + + + void glCullParameterfvEXT + GLenum pname + GLfloat *params + + + void glCurrentPaletteMatrixARB + GLint index + + + + void glCurrentPaletteMatrixOES + GLuint matrixpaletteindex + + + void glDebugMessageCallback + GLDEBUGPROC callback + const void *userParam + + + void glDebugMessageCallbackAMD + GLDEBUGPROCAMD callback + void *userParam + + + void glDebugMessageCallbackARB + GLDEBUGPROCARB callback + const void *userParam + + + + void glDebugMessageCallbackKHR + GLDEBUGPROCKHR callback + const void *userParam + + + + void glDebugMessageControl + GLenum source + GLenum type + GLenum severity + GLsizei count + const GLuint *ids + GLboolean enabled + + + void glDebugMessageControlARB + GLenum source + GLenum type + GLenum severity + GLsizei count + const GLuint *ids + GLboolean enabled + + + + void glDebugMessageControlKHR + GLenum source + GLenum type + GLenum severity + GLsizei count + const GLuint *ids + GLboolean enabled + + + + void glDebugMessageEnableAMD + GLenum category + GLenum severity + GLsizei count + const GLuint *ids + GLboolean enabled + + + void glDebugMessageInsert + GLenum source + GLenum type + GLuint id + GLenum severity + GLsizei length + const GLchar *buf + + + void glDebugMessageInsertAMD + GLenum category + GLenum severity + GLuint id + GLsizei length + const GLchar *buf + + + void glDebugMessageInsertARB + GLenum source + GLenum type + GLuint id + GLenum severity + GLsizei length + const GLchar *buf + + + + void glDebugMessageInsertKHR + GLenum source + GLenum type + GLuint id + GLenum severity + GLsizei length + const GLchar *buf + + + + void glDeformSGIX + GLbitfield mask + + + + void glDeformationMap3dSGIX + GLenum target + GLdouble u1 + GLdouble u2 + GLint ustride + GLint uorder + GLdouble v1 + GLdouble v2 + GLint vstride + GLint vorder + GLdouble w1 + GLdouble w2 + GLint wstride + GLint worder + const GLdouble *points + + + + void glDeformationMap3fSGIX + GLenum target + GLfloat u1 + GLfloat u2 + GLint ustride + GLint uorder + GLfloat v1 + GLfloat v2 + GLint vstride + GLint vorder + GLfloat w1 + GLfloat w2 + GLint wstride + GLint worder + const GLfloat *points + + + + void glDeleteAsyncMarkersSGIX + GLuint marker + GLsizei range + + + void glDeleteBuffers + GLsizei n + const GLuint *buffers + + + void glDeleteBuffersARB + GLsizei n + const GLuint *buffers + + + + void glDeleteFencesAPPLE + GLsizei n + const GLuint *fences + + + void glDeleteFencesNV + GLsizei n + const GLuint *fences + + + + void glDeleteFragmentShaderATI + GLuint id + + + void glDeleteFramebuffers + GLsizei n + const GLuint *framebuffers + + + + void glDeleteFramebuffersEXT + GLsizei n + const GLuint *framebuffers + + + + + void glDeleteFramebuffersOES + GLsizei n + const GLuint *framebuffers + + + void glDeleteLists + GLuint list + GLsizei range + + + + void glDeleteNamedStringARB + GLint namelen + const GLchar *name + + + void glDeleteNamesAMD + GLenum identifier + GLuint num + const GLuint *names + + + void glDeleteObjectARB + GLhandleARB obj + + + void glDeleteOcclusionQueriesNV + GLsizei n + const GLuint *ids + + + void glDeletePathsNV + GLuint path + GLsizei range + + + void glDeletePerfMonitorsAMD + GLsizei n + GLuint *monitors + + + void glDeletePerfQueryINTEL + GLuint queryHandle + + + void glDeleteProgram + GLuint program + + + + void glDeleteProgramPipelines + GLsizei n + const GLuint *pipelines + + + void glDeleteProgramPipelinesEXT + GLsizei n + const GLuint *pipelines + + + void glDeleteProgramsARB + GLsizei n + const GLuint *programs + + + + void glDeleteProgramsNV + GLsizei n + const GLuint *programs + + + + + void glDeleteQueries + GLsizei n + const GLuint *ids + + + + void glDeleteQueriesARB + GLsizei n + const GLuint *ids + + + + void glDeleteQueriesEXT + GLsizei n + const GLuint *ids + + + void glDeleteRenderbuffers + GLsizei n + const GLuint *renderbuffers + + + + void glDeleteRenderbuffersEXT + GLsizei n + const GLuint *renderbuffers + + + + + void glDeleteRenderbuffersOES + GLsizei n + const GLuint *renderbuffers + + + void glDeleteSamplers + GLsizei count + const GLuint *samplers + + + void glDeleteShader + GLuint shader + + + + void glDeleteSync + GLsync sync + + + void glDeleteSyncAPPLE + GLsync sync + + + + void glDeleteTextures + GLsizei n + const GLuint *textures + + + + void glDeleteTexturesEXT + GLsizei n + const GLuint *textures + + + + void glDeleteTransformFeedbacks + GLsizei n + const GLuint *ids + + + void glDeleteTransformFeedbacksNV + GLsizei n + const GLuint *ids + + + + void glDeleteVertexArrays + GLsizei n + const GLuint *arrays + + + + void glDeleteVertexArraysAPPLE + GLsizei n + const GLuint *arrays + + + + void glDeleteVertexArraysOES + GLsizei n + const GLuint *arrays + + + + void glDeleteVertexShaderEXT + GLuint id + + + void glDepthBoundsEXT + GLclampd zmin + GLclampd zmax + + + + void glDepthBoundsdNV + GLdouble zmin + GLdouble zmax + + + + void glDepthFunc + GLenum func + + + + void glDepthMask + GLboolean flag + + + + void glDepthRange + GLdouble near + GLdouble far + + + + void glDepthRangeArrayv + GLuint first + GLsizei count + const GLdouble *v + + + void glDepthRangeIndexed + GLuint index + GLdouble n + GLdouble f + + + void glDepthRangedNV + GLdouble zNear + GLdouble zFar + + + + void glDepthRangef + GLfloat n + GLfloat f + + + void glDepthRangefOES + GLclampf n + GLclampf f + + + + + void glDepthRangex + GLfixed n + GLfixed f + + + void glDepthRangexOES + GLfixed n + GLfixed f + + + void glDetachObjectARB + GLhandleARB containerObj + GLhandleARB attachedObj + + + + void glDetachShader + GLuint program + GLuint shader + + + void glDetailTexFuncSGIS + GLenum target + GLsizei n + const GLfloat *points + + + + void glDisable + GLenum cap + + + + void glDisableClientState + GLenum array + + + void glDisableClientStateIndexedEXT + GLenum array + GLuint index + + + void glDisableClientStateiEXT + GLenum array + GLuint index + + + void glDisableDriverControlQCOM + GLuint driverControl + + + void glDisableIndexedEXT + GLenum target + GLuint index + + + + void glDisableVariantClientStateEXT + GLuint id + + + void glDisableVertexArrayAttrib + GLuint vaobj + GLuint index + + + void glDisableVertexArrayAttribEXT + GLuint vaobj + GLuint index + + + void glDisableVertexArrayEXT + GLuint vaobj + GLenum array + + + void glDisableVertexAttribAPPLE + GLuint index + GLenum pname + + + void glDisableVertexAttribArray + GLuint index + + + void glDisableVertexAttribArrayARB + GLuint index + + + + void glDisablei + GLenum target + GLuint index + + + void glDisableiEXT + GLenum target + GLuint index + + + + void glDiscardFramebufferEXT + GLenum target + GLsizei numAttachments + const GLenum *attachments + + + void glDispatchCompute + GLuint num_groups_x + GLuint num_groups_y + GLuint num_groups_z + + + void glDispatchComputeGroupSizeARB + GLuint num_groups_x + GLuint num_groups_y + GLuint num_groups_z + GLuint group_size_x + GLuint group_size_y + GLuint group_size_z + + + void glDispatchComputeIndirect + GLintptr indirect + + + void glDrawArrays + GLenum mode + GLint first + GLsizei count + + + + void glDrawArraysEXT + GLenum mode + GLint first + GLsizei count + + + + + void glDrawArraysIndirect + GLenum mode + const void *indirect + + + void glDrawArraysInstanced + GLenum mode + GLint first + GLsizei count + GLsizei instancecount + + + void glDrawArraysInstancedANGLE + GLenum mode + GLint first + GLsizei count + GLsizei primcount + + + + void glDrawArraysInstancedARB + GLenum mode + GLint first + GLsizei count + GLsizei primcount + + + + void glDrawArraysInstancedBaseInstance + GLenum mode + GLint first + GLsizei count + GLsizei instancecount + GLuint baseinstance + + + void glDrawArraysInstancedEXT + GLenum mode + GLint start + GLsizei count + GLsizei primcount + + + + void glDrawArraysInstancedNV + GLenum mode + GLint first + GLsizei count + GLsizei primcount + + + + void glDrawBuffer + GLenum buf + + + + void glDrawBuffers + GLsizei n + const GLenum *bufs + + + + void glDrawBuffersARB + GLsizei n + const GLenum *bufs + + + + void glDrawBuffersATI + GLsizei n + const GLenum *bufs + + + + + void glDrawBuffersEXT + GLsizei n + const GLenum *bufs + + + + void glDrawBuffersIndexedEXT + GLint n + const GLenum *location + const GLint *indices + + + void glDrawBuffersNV + GLsizei n + const GLenum *bufs + + + void glDrawElementArrayAPPLE + GLenum mode + GLint first + GLsizei count + + + void glDrawElementArrayATI + GLenum mode + GLsizei count + + + void glDrawElements + GLenum mode + GLsizei count + GLenum type + const void *indices + + + void glDrawElementsBaseVertex + GLenum mode + GLsizei count + GLenum type + const void *indices + GLint basevertex + + + void glDrawElementsIndirect + GLenum mode + GLenum type + const void *indirect + + + void glDrawElementsInstanced + GLenum mode + GLsizei count + GLenum type + const void *indices + GLsizei instancecount + + + void glDrawElementsInstancedANGLE + GLenum mode + GLsizei count + GLenum type + const void *indices + GLsizei primcount + + + + void glDrawElementsInstancedARB + GLenum mode + GLsizei count + GLenum type + const void *indices + GLsizei primcount + + + + void glDrawElementsInstancedBaseInstance + GLenum mode + GLsizei count + GLenum type + const void *indices + GLsizei instancecount + GLuint baseinstance + + + void glDrawElementsInstancedBaseVertex + GLenum mode + GLsizei count + GLenum type + const void *indices + GLsizei instancecount + GLint basevertex + + + void glDrawElementsInstancedBaseVertexBaseInstance + GLenum mode + GLsizei count + GLenum type + const void *indices + GLsizei instancecount + GLint basevertex + GLuint baseinstance + + + void glDrawElementsInstancedEXT + GLenum mode + GLsizei count + GLenum type + const void *indices + GLsizei primcount + + + + void glDrawElementsInstancedNV + GLenum mode + GLsizei count + GLenum type + const void *indices + GLsizei primcount + + + + void glDrawMeshArraysSUN + GLenum mode + GLint first + GLsizei count + GLsizei width + + + void glDrawPixels + GLsizei width + GLsizei height + GLenum format + GLenum type + const void *pixels + + + + + void glDrawRangeElementArrayAPPLE + GLenum mode + GLuint start + GLuint end + GLint first + GLsizei count + + + void glDrawRangeElementArrayATI + GLenum mode + GLuint start + GLuint end + GLsizei count + + + void glDrawRangeElements + GLenum mode + GLuint start + GLuint end + GLsizei count + GLenum type + const void *indices + + + void glDrawRangeElementsBaseVertex + GLenum mode + GLuint start + GLuint end + GLsizei count + GLenum type + const void *indices + GLint basevertex + + + void glDrawRangeElementsEXT + GLenum mode + GLuint start + GLuint end + GLsizei count + GLenum type + const void *indices + + + + void glDrawTexfOES + GLfloat x + GLfloat y + GLfloat z + GLfloat width + GLfloat height + + + void glDrawTexfvOES + const GLfloat *coords + + + void glDrawTexiOES + GLint x + GLint y + GLint z + GLint width + GLint height + + + void glDrawTexivOES + const GLint *coords + + + void glDrawTexsOES + GLshort x + GLshort y + GLshort z + GLshort width + GLshort height + + + void glDrawTexsvOES + const GLshort *coords + + + void glDrawTextureNV + GLuint texture + GLuint sampler + GLfloat x0 + GLfloat y0 + GLfloat x1 + GLfloat y1 + GLfloat z + GLfloat s0 + GLfloat t0 + GLfloat s1 + GLfloat t1 + + + void glDrawTexxOES + GLfixed x + GLfixed y + GLfixed z + GLfixed width + GLfixed height + + + void glDrawTexxvOES + const GLfixed *coords + + + void glDrawTransformFeedback + GLenum mode + GLuint id + + + void glDrawTransformFeedbackInstanced + GLenum mode + GLuint id + GLsizei instancecount + + + void glDrawTransformFeedbackNV + GLenum mode + GLuint id + + + + void glDrawTransformFeedbackStream + GLenum mode + GLuint id + GLuint stream + + + void glDrawTransformFeedbackStreamInstanced + GLenum mode + GLuint id + GLuint stream + GLsizei instancecount + + + void glEGLImageTargetRenderbufferStorageOES + GLenum target + GLeglImageOES image + + + void glEGLImageTargetTexture2DOES + GLenum target + GLeglImageOES image + + + void glEdgeFlag + GLboolean flag + + + + void glEdgeFlagFormatNV + GLsizei stride + + + void glEdgeFlagPointer + GLsizei stride + const void *pointer + + + void glEdgeFlagPointerEXT + GLsizei stride + GLsizei count + const GLboolean *pointer + + + void glEdgeFlagPointerListIBM + GLint stride + const GLboolean **pointer + GLint ptrstride + + + void glEdgeFlagv + const GLboolean *flag + + + + void glElementPointerAPPLE + GLenum type + const void *pointer + + + void glElementPointerATI + GLenum type + const void *pointer + + + void glEnable + GLenum cap + + + + void glEnableClientState + GLenum array + + + void glEnableClientStateIndexedEXT + GLenum array + GLuint index + + + void glEnableClientStateiEXT + GLenum array + GLuint index + + + void glEnableDriverControlQCOM + GLuint driverControl + + + void glEnableIndexedEXT + GLenum target + GLuint index + + + + void glEnableVariantClientStateEXT + GLuint id + + + void glEnableVertexArrayAttrib + GLuint vaobj + GLuint index + + + void glEnableVertexArrayAttribEXT + GLuint vaobj + GLuint index + + + void glEnableVertexArrayEXT + GLuint vaobj + GLenum array + + + void glEnableVertexAttribAPPLE + GLuint index + GLenum pname + + + void glEnableVertexAttribArray + GLuint index + + + void glEnableVertexAttribArrayARB + GLuint index + + + + void glEnablei + GLenum target + GLuint index + + + void glEnableiEXT + GLenum target + GLuint index + + + + void glEnd + + + + void glEndConditionalRender + + + + void glEndConditionalRenderNV + + + + void glEndConditionalRenderNVX + + + + void glEndFragmentShaderATI + + + void glEndList + + + + void glEndOcclusionQueryNV + + + void glEndPerfMonitorAMD + GLuint monitor + + + void glEndPerfQueryINTEL + GLuint queryHandle + + + void glEndQuery + GLenum target + + + + void glEndQueryARB + GLenum target + + + + void glEndQueryEXT + GLenum target + + + void glEndQueryIndexed + GLenum target + GLuint index + + + void glEndTilingQCOM + GLbitfield preserveMask + + + void glEndTransformFeedback + + + void glEndTransformFeedbackEXT + + + + void glEndTransformFeedbackNV + + + + void glEndVertexShaderEXT + + + void glEndVideoCaptureNV + GLuint video_capture_slot + + + void glEvalCoord1d + GLdouble u + + + + void glEvalCoord1dv + const GLdouble *u + + + + void glEvalCoord1f + GLfloat u + + + + void glEvalCoord1fv + const GLfloat *u + + + + void glEvalCoord1xOES + GLfixed u + + + void glEvalCoord1xvOES + const GLfixed *coords + + + void glEvalCoord2d + GLdouble u + GLdouble v + + + + void glEvalCoord2dv + const GLdouble *u + + + + void glEvalCoord2f + GLfloat u + GLfloat v + + + + void glEvalCoord2fv + const GLfloat *u + + + + void glEvalCoord2xOES + GLfixed u + GLfixed v + + + void glEvalCoord2xvOES + const GLfixed *coords + + + void glEvalMapsNV + GLenum target + GLenum mode + + + void glEvalMesh1 + GLenum mode + GLint i1 + GLint i2 + + + + void glEvalMesh2 + GLenum mode + GLint i1 + GLint i2 + GLint j1 + GLint j2 + + + + void glEvalPoint1 + GLint i + + + + void glEvalPoint2 + GLint i + GLint j + + + + void glExecuteProgramNV + GLenum target + GLuint id + const GLfloat *params + + + + void glExtGetBufferPointervQCOM + GLenum target + void **params + + + void glExtGetBuffersQCOM + GLuint *buffers + GLint maxBuffers + GLint *numBuffers + + + void glExtGetFramebuffersQCOM + GLuint *framebuffers + GLint maxFramebuffers + GLint *numFramebuffers + + + void glExtGetProgramBinarySourceQCOM + GLuint program + GLenum shadertype + GLchar *source + GLint *length + + + void glExtGetProgramsQCOM + GLuint *programs + GLint maxPrograms + GLint *numPrograms + + + void glExtGetRenderbuffersQCOM + GLuint *renderbuffers + GLint maxRenderbuffers + GLint *numRenderbuffers + + + void glExtGetShadersQCOM + GLuint *shaders + GLint maxShaders + GLint *numShaders + + + void glExtGetTexLevelParameterivQCOM + GLuint texture + GLenum face + GLint level + GLenum pname + GLint *params + + + void glExtGetTexSubImageQCOM + GLenum target + GLint level + GLint xoffset + GLint yoffset + GLint zoffset + GLsizei width + GLsizei height + GLsizei depth + GLenum format + GLenum type + void *texels + + + void glExtGetTexturesQCOM + GLuint *textures + GLint maxTextures + GLint *numTextures + + + GLboolean glExtIsProgramBinaryQCOM + GLuint program + + + void glExtTexObjectStateOverrideiQCOM + GLenum target + GLenum pname + GLint param + + + void glExtractComponentEXT + GLuint res + GLuint src + GLuint num + + + void glFeedbackBuffer + GLsizei size + GLenum type + GLfloat *buffer + + + + void glFeedbackBufferxOES + GLsizei n + GLenum type + const GLfixed *buffer + + + GLsync glFenceSync + GLenum condition + GLbitfield flags + + + GLsync glFenceSyncAPPLE + GLenum condition + GLbitfield flags + + + + void glFinalCombinerInputNV + GLenum variable + GLenum input + GLenum mapping + GLenum componentUsage + + + + void glFinish + + + + GLint glFinishAsyncSGIX + GLuint *markerp + + + void glFinishFenceAPPLE + GLuint fence + + + void glFinishFenceNV + GLuint fence + + + + void glFinishObjectAPPLE + GLenum object + GLint name + + + void glFinishTextureSUNX + + + void glFlush + + + + void glFlushMappedBufferRange + GLenum target + GLintptr offset + GLsizeiptr length + + + void glFlushMappedBufferRangeAPPLE + GLenum target + GLintptr offset + GLsizeiptr size + + + + void glFlushMappedBufferRangeEXT + GLenum target + GLintptr offset + GLsizeiptr length + + + + void glFlushMappedNamedBufferRange + GLuint buffer + GLintptr offset + GLsizei length + + + void glFlushMappedNamedBufferRangeEXT + GLuint buffer + GLintptr offset + GLsizeiptr length + + + void glFlushPixelDataRangeNV + GLenum target + + + void glFlushRasterSGIX + + + + void glFlushStaticDataIBM + GLenum target + + + void glFlushVertexArrayRangeAPPLE + GLsizei length + void *pointer + + + void glFlushVertexArrayRangeNV + + + void glFogCoordFormatNV + GLenum type + GLsizei stride + + + void glFogCoordPointer + GLenum type + GLsizei stride + const void *pointer + + + void glFogCoordPointerEXT + GLenum type + GLsizei stride + const void *pointer + + + + void glFogCoordPointerListIBM + GLenum type + GLint stride + const void **pointer + GLint ptrstride + + + void glFogCoordd + GLdouble coord + + + + void glFogCoorddEXT + GLdouble coord + + + + + void glFogCoorddv + const GLdouble *coord + + + + void glFogCoorddvEXT + const GLdouble *coord + + + + + void glFogCoordf + GLfloat coord + + + + void glFogCoordfEXT + GLfloat coord + + + + + void glFogCoordfv + const GLfloat *coord + + + + void glFogCoordfvEXT + const GLfloat *coord + + + + + void glFogCoordhNV + GLhalfNV fog + + + + void glFogCoordhvNV + const GLhalfNV *fog + + + + void glFogFuncSGIS + GLsizei n + const GLfloat *points + + + + void glFogf + GLenum pname + GLfloat param + + + + void glFogfv + GLenum pname + const GLfloat *params + + + + void glFogi + GLenum pname + GLint param + + + + void glFogiv + GLenum pname + const GLint *params + + + + void glFogx + GLenum pname + GLfixed param + + + void glFogxOES + GLenum pname + GLfixed param + + + void glFogxv + GLenum pname + const GLfixed *param + + + void glFogxvOES + GLenum pname + const GLfixed *param + + + void glFragmentColorMaterialSGIX + GLenum face + GLenum mode + + + void glFragmentLightModelfSGIX + GLenum pname + GLfloat param + + + void glFragmentLightModelfvSGIX + GLenum pname + const GLfloat *params + + + void glFragmentLightModeliSGIX + GLenum pname + GLint param + + + void glFragmentLightModelivSGIX + GLenum pname + const GLint *params + + + void glFragmentLightfSGIX + GLenum light + GLenum pname + GLfloat param + + + void glFragmentLightfvSGIX + GLenum light + GLenum pname + const GLfloat *params + + + void glFragmentLightiSGIX + GLenum light + GLenum pname + GLint param + + + void glFragmentLightivSGIX + GLenum light + GLenum pname + const GLint *params + + + void glFragmentMaterialfSGIX + GLenum face + GLenum pname + GLfloat param + + + void glFragmentMaterialfvSGIX + GLenum face + GLenum pname + const GLfloat *params + + + void glFragmentMaterialiSGIX + GLenum face + GLenum pname + GLint param + + + void glFragmentMaterialivSGIX + GLenum face + GLenum pname + const GLint *params + + + void glFrameTerminatorGREMEDY + + + void glFrameZoomSGIX + GLint factor + + + + void glFramebufferDrawBufferEXT + GLuint framebuffer + GLenum mode + + + void glFramebufferDrawBuffersEXT + GLuint framebuffer + GLsizei n + const GLenum *bufs + + + void glFramebufferParameteri + GLenum target + GLenum pname + GLint param + + + void glFramebufferReadBufferEXT + GLuint framebuffer + GLenum mode + + + void glFramebufferRenderbuffer + GLenum target + GLenum attachment + GLenum renderbuffertarget + GLuint renderbuffer + + + + void glFramebufferRenderbufferEXT + GLenum target + GLenum attachment + GLenum renderbuffertarget + GLuint renderbuffer + + + + + void glFramebufferRenderbufferOES + GLenum target + GLenum attachment + GLenum renderbuffertarget + GLuint renderbuffer + + + void glFramebufferTexture + GLenum target + GLenum attachment + GLuint texture + GLint level + + + void glFramebufferTexture1D + GLenum target + GLenum attachment + GLenum textarget + GLuint texture + GLint level + + + + void glFramebufferTexture1DEXT + GLenum target + GLenum attachment + GLenum textarget + GLuint texture + GLint level + + + + + void glFramebufferTexture2D + GLenum target + GLenum attachment + GLenum textarget + GLuint texture + GLint level + + + + void glFramebufferTexture2DEXT + GLenum target + GLenum attachment + GLenum textarget + GLuint texture + GLint level + + + + + void glFramebufferTexture2DMultisampleEXT + GLenum target + GLenum attachment + GLenum textarget + GLuint texture + GLint level + GLsizei samples + + + void glFramebufferTexture2DMultisampleIMG + GLenum target + GLenum attachment + GLenum textarget + GLuint texture + GLint level + GLsizei samples + + + void glFramebufferTexture2DOES + GLenum target + GLenum attachment + GLenum textarget + GLuint texture + GLint level + + + void glFramebufferTexture3D + GLenum target + GLenum attachment + GLenum textarget + GLuint texture + GLint level + GLint zoffset + + + + void glFramebufferTexture3DEXT + GLenum target + GLenum attachment + GLenum textarget + GLuint texture + GLint level + GLint zoffset + + + + + void glFramebufferTexture3DOES + GLenum target + GLenum attachment + GLenum textarget + GLuint texture + GLint level + GLint zoffset + + + + void glFramebufferTextureARB + GLenum target + GLenum attachment + GLuint texture + GLint level + + + + void glFramebufferTextureEXT + GLenum target + GLenum attachment + GLuint texture + GLint level + + + + void glFramebufferTextureFaceARB + GLenum target + GLenum attachment + GLuint texture + GLint level + GLenum face + + + void glFramebufferTextureFaceEXT + GLenum target + GLenum attachment + GLuint texture + GLint level + GLenum face + + + + void glFramebufferTextureLayer + GLenum target + GLenum attachment + GLuint texture + GLint level + GLint layer + + + + void glFramebufferTextureLayerARB + GLenum target + GLenum attachment + GLuint texture + GLint level + GLint layer + + + + void glFramebufferTextureLayerEXT + GLenum target + GLenum attachment + GLuint texture + GLint level + GLint layer + + + + void glFreeObjectBufferATI + GLuint buffer + + + void glFrontFace + GLenum mode + + + + void glFrustum + GLdouble left + GLdouble right + GLdouble bottom + GLdouble top + GLdouble zNear + GLdouble zFar + + + + void glFrustumf + GLfloat l + GLfloat r + GLfloat b + GLfloat t + GLfloat n + GLfloat f + + + void glFrustumfOES + GLfloat l + GLfloat r + GLfloat b + GLfloat t + GLfloat n + GLfloat f + + + + void glFrustumx + GLfixed l + GLfixed r + GLfixed b + GLfixed t + GLfixed n + GLfixed f + + + void glFrustumxOES + GLfixed l + GLfixed r + GLfixed b + GLfixed t + GLfixed n + GLfixed f + + + GLuint glGenAsyncMarkersSGIX + GLsizei range + + + void glGenBuffers + GLsizei n + GLuint *buffers + + + void glGenBuffersARB + GLsizei n + GLuint *buffers + + + + void glGenFencesAPPLE + GLsizei n + GLuint *fences + + + void glGenFencesNV + GLsizei n + GLuint *fences + + + + GLuint glGenFragmentShadersATI + GLuint range + + + void glGenFramebuffers + GLsizei n + GLuint *framebuffers + + + + void glGenFramebuffersEXT + GLsizei n + GLuint *framebuffers + + + + + void glGenFramebuffersOES + GLsizei n + GLuint *framebuffers + + + GLuint glGenLists + GLsizei range + + + + void glGenNamesAMD + GLenum identifier + GLuint num + GLuint *names + + + void glGenOcclusionQueriesNV + GLsizei n + GLuint *ids + + + GLuint glGenPathsNV + GLsizei range + + + void glGenPerfMonitorsAMD + GLsizei n + GLuint *monitors + + + void glGenProgramPipelines + GLsizei n + GLuint *pipelines + + + void glGenProgramPipelinesEXT + GLsizei n + GLuint *pipelines + + + void glGenProgramsARB + GLsizei n + GLuint *programs + + + + void glGenProgramsNV + GLsizei n + GLuint *programs + + + + + void glGenQueries + GLsizei n + GLuint *ids + + + + void glGenQueriesARB + GLsizei n + GLuint *ids + + + + void glGenQueriesEXT + GLsizei n + GLuint *ids + + + void glGenRenderbuffers + GLsizei n + GLuint *renderbuffers + + + + void glGenRenderbuffersEXT + GLsizei n + GLuint *renderbuffers + + + + + void glGenRenderbuffersOES + GLsizei n + GLuint *renderbuffers + + + void glGenSamplers + GLsizei count + GLuint *samplers + + + GLuint glGenSymbolsEXT + GLenum datatype + GLenum storagetype + GLenum range + GLuint components + + + void glGenTextures + GLsizei n + GLuint *textures + + + + void glGenTexturesEXT + GLsizei n + GLuint *textures + + + + void glGenTransformFeedbacks + GLsizei n + GLuint *ids + + + void glGenTransformFeedbacksNV + GLsizei n + GLuint *ids + + + + void glGenVertexArrays + GLsizei n + GLuint *arrays + + + + void glGenVertexArraysAPPLE + GLsizei n + GLuint *arrays + + + + void glGenVertexArraysOES + GLsizei n + GLuint *arrays + + + + GLuint glGenVertexShadersEXT + GLuint range + + + void glGenerateMipmap + GLenum target + + + + void glGenerateMipmapEXT + GLenum target + + + + + void glGenerateMipmapOES + GLenum target + + + void glGenerateMultiTexMipmapEXT + GLenum texunit + GLenum target + + + void glGenerateTextureMipmap + GLuint texture + + + void glGenerateTextureMipmapEXT + GLuint texture + GLenum target + + + void glGetActiveAtomicCounterBufferiv + GLuint program + GLuint bufferIndex + GLenum pname + GLint *params + + + void glGetActiveAttrib + GLuint program + GLuint index + GLsizei bufSize + GLsizei *length + GLint *size + GLenum *type + GLchar *name + + + void glGetActiveAttribARB + GLhandleARB programObj + GLuint index + GLsizei maxLength + GLsizei *length + GLint *size + GLenum *type + GLcharARB *name + + + + void glGetActiveSubroutineName + GLuint program + GLenum shadertype + GLuint index + GLsizei bufsize + GLsizei *length + GLchar *name + + + void glGetActiveSubroutineUniformName + GLuint program + GLenum shadertype + GLuint index + GLsizei bufsize + GLsizei *length + GLchar *name + + + void glGetActiveSubroutineUniformiv + GLuint program + GLenum shadertype + GLuint index + GLenum pname + GLint *values + + + void glGetActiveUniform + GLuint program + GLuint index + GLsizei bufSize + GLsizei *length + GLint *size + GLenum *type + GLchar *name + + + void glGetActiveUniformARB + GLhandleARB programObj + GLuint index + GLsizei maxLength + GLsizei *length + GLint *size + GLenum *type + GLcharARB *name + + + + void glGetActiveUniformBlockName + GLuint program + GLuint uniformBlockIndex + GLsizei bufSize + GLsizei *length + GLchar *uniformBlockName + + + void glGetActiveUniformBlockiv + GLuint program + GLuint uniformBlockIndex + GLenum pname + GLint *params + + + void glGetActiveUniformName + GLuint program + GLuint uniformIndex + GLsizei bufSize + GLsizei *length + GLchar *uniformName + + + void glGetActiveUniformsiv + GLuint program + GLsizei uniformCount + const GLuint *uniformIndices + GLenum pname + GLint *params + + + void glGetActiveVaryingNV + GLuint program + GLuint index + GLsizei bufSize + GLsizei *length + GLsizei *size + GLenum *type + GLchar *name + + + void glGetArrayObjectfvATI + GLenum array + GLenum pname + GLfloat *params + + + void glGetArrayObjectivATI + GLenum array + GLenum pname + GLint *params + + + void glGetAttachedObjectsARB + GLhandleARB containerObj + GLsizei maxCount + GLsizei *count + GLhandleARB *obj + + + void glGetAttachedShaders + GLuint program + GLsizei maxCount + GLsizei *count + GLuint *shaders + + + GLint glGetAttribLocation + GLuint program + const GLchar *name + + + GLint glGetAttribLocationARB + GLhandleARB programObj + const GLcharARB *name + + + + void glGetBooleanIndexedvEXT + GLenum target + GLuint index + GLboolean *data + + + + void glGetBooleani_v + GLenum target + GLuint index + GLboolean *data + + + void glGetBooleanv + GLenum pname + GLboolean *data + + + + void glGetBufferParameteri64v + GLenum target + GLenum pname + GLint64 *params + + + void glGetBufferParameteriv + GLenum target + GLenum pname + GLint *params + + + void glGetBufferParameterivARB + GLenum target + GLenum pname + GLint *params + + + + void glGetBufferParameterui64vNV + GLenum target + GLenum pname + GLuint64EXT *params + + + void glGetBufferPointerv + GLenum target + GLenum pname + void **params + + + void glGetBufferPointervARB + GLenum target + GLenum pname + void **params + + + + void glGetBufferPointervOES + GLenum target + GLenum pname + void **params + + + + void glGetBufferSubData + GLenum target + GLintptr offset + GLsizeiptr size + void *data + + + void glGetBufferSubDataARB + GLenum target + GLintptrARB offset + GLsizeiptrARB size + void *data + + + + void glGetClipPlane + GLenum plane + GLdouble *equation + + + + void glGetClipPlanef + GLenum plane + GLfloat *equation + + + void glGetClipPlanefOES + GLenum plane + GLfloat *equation + + + + void glGetClipPlanex + GLenum plane + GLfixed *equation + + + void glGetClipPlanexOES + GLenum plane + GLfixed *equation + + + void glGetColorTable + GLenum target + GLenum format + GLenum type + void *table + + + + + void glGetColorTableEXT + GLenum target + GLenum format + GLenum type + void *data + + + + void glGetColorTableParameterfv + GLenum target + GLenum pname + GLfloat *params + + + + void glGetColorTableParameterfvEXT + GLenum target + GLenum pname + GLfloat *params + + + + void glGetColorTableParameterfvSGI + GLenum target + GLenum pname + GLfloat *params + + + + void glGetColorTableParameteriv + GLenum target + GLenum pname + GLint *params + + + + void glGetColorTableParameterivEXT + GLenum target + GLenum pname + GLint *params + + + + void glGetColorTableParameterivSGI + GLenum target + GLenum pname + GLint *params + + + + void glGetColorTableSGI + GLenum target + GLenum format + GLenum type + void *table + + + + void glGetCombinerInputParameterfvNV + GLenum stage + GLenum portion + GLenum variable + GLenum pname + GLfloat *params + + + + void glGetCombinerInputParameterivNV + GLenum stage + GLenum portion + GLenum variable + GLenum pname + GLint *params + + + + void glGetCombinerOutputParameterfvNV + GLenum stage + GLenum portion + GLenum pname + GLfloat *params + + + + void glGetCombinerOutputParameterivNV + GLenum stage + GLenum portion + GLenum pname + GLint *params + + + + void glGetCombinerStageParameterfvNV + GLenum stage + GLenum pname + GLfloat *params + + + void glGetCompressedMultiTexImageEXT + GLenum texunit + GLenum target + GLint lod + void *img + + + void glGetCompressedTexImage + GLenum target + GLint level + void *img + + + + + void glGetCompressedTexImageARB + GLenum target + GLint level + void *img + + + + + void glGetCompressedTextureImage + GLuint texture + GLint level + GLsizei bufSize + void *pixels + + + void glGetCompressedTextureImageEXT + GLuint texture + GLenum target + GLint lod + void *img + + + void glGetCompressedTextureSubImage + GLuint texture + GLint level + GLint xoffset + GLint yoffset + GLint zoffset + GLsizei width + GLsizei height + GLsizei depth + GLsizei bufSize + void *pixels + + + void glGetConvolutionFilter + GLenum target + GLenum format + GLenum type + void *image + + + + + void glGetConvolutionFilterEXT + GLenum target + GLenum format + GLenum type + void *image + + + + void glGetConvolutionParameterfv + GLenum target + GLenum pname + GLfloat *params + + + + void glGetConvolutionParameterfvEXT + GLenum target + GLenum pname + GLfloat *params + + + + void glGetConvolutionParameteriv + GLenum target + GLenum pname + GLint *params + + + + void glGetConvolutionParameterivEXT + GLenum target + GLenum pname + GLint *params + + + + void glGetConvolutionParameterxvOES + GLenum target + GLenum pname + GLfixed *params + + + GLuint glGetDebugMessageLog + GLuint count + GLsizei bufSize + GLenum *sources + GLenum *types + GLuint *ids + GLenum *severities + GLsizei *lengths + GLchar *messageLog + + + GLuint glGetDebugMessageLogAMD + GLuint count + GLsizei bufsize + GLenum *categories + GLuint *severities + GLuint *ids + GLsizei *lengths + GLchar *message + + + GLuint glGetDebugMessageLogARB + GLuint count + GLsizei bufSize + GLenum *sources + GLenum *types + GLuint *ids + GLenum *severities + GLsizei *lengths + GLchar *messageLog + + + + GLuint glGetDebugMessageLogKHR + GLuint count + GLsizei bufSize + GLenum *sources + GLenum *types + GLuint *ids + GLenum *severities + GLsizei *lengths + GLchar *messageLog + + + + void glGetDetailTexFuncSGIS + GLenum target + GLfloat *points + + + + void glGetDoubleIndexedvEXT + GLenum target + GLuint index + GLdouble *data + + + + void glGetDoublei_v + GLenum target + GLuint index + GLdouble *data + + + void glGetDoublei_vEXT + GLenum pname + GLuint index + GLdouble *params + + + + void glGetDoublev + GLenum pname + GLdouble *data + + + + void glGetDriverControlStringQCOM + GLuint driverControl + GLsizei bufSize + GLsizei *length + GLchar *driverControlString + + + void glGetDriverControlsQCOM + GLint *num + GLsizei size + GLuint *driverControls + + + GLenum glGetError + + + + void glGetFenceivNV + GLuint fence + GLenum pname + GLint *params + + + + void glGetFinalCombinerInputParameterfvNV + GLenum variable + GLenum pname + GLfloat *params + + + + void glGetFinalCombinerInputParameterivNV + GLenum variable + GLenum pname + GLint *params + + + + void glGetFirstPerfQueryIdINTEL + GLuint *queryId + + + void glGetFixedv + GLenum pname + GLfixed *params + + + void glGetFixedvOES + GLenum pname + GLfixed *params + + + void glGetFloatIndexedvEXT + GLenum target + GLuint index + GLfloat *data + + + + void glGetFloati_v + GLenum target + GLuint index + GLfloat *data + + + void glGetFloati_vEXT + GLenum pname + GLuint index + GLfloat *params + + + + void glGetFloatv + GLenum pname + GLfloat *data + + + + void glGetFogFuncSGIS + GLfloat *points + + + GLint glGetFragDataIndex + GLuint program + const GLchar *name + + + GLint glGetFragDataLocation + GLuint program + const GLchar *name + + + GLint glGetFragDataLocationEXT + GLuint program + const GLchar *name + + + + void glGetFragmentLightfvSGIX + GLenum light + GLenum pname + GLfloat *params + + + void glGetFragmentLightivSGIX + GLenum light + GLenum pname + GLint *params + + + void glGetFragmentMaterialfvSGIX + GLenum face + GLenum pname + GLfloat *params + + + void glGetFragmentMaterialivSGIX + GLenum face + GLenum pname + GLint *params + + + void glGetFramebufferAttachmentParameteriv + GLenum target + GLenum attachment + GLenum pname + GLint *params + + + + void glGetFramebufferAttachmentParameterivEXT + GLenum target + GLenum attachment + GLenum pname + GLint *params + + + + + void glGetFramebufferAttachmentParameterivOES + GLenum target + GLenum attachment + GLenum pname + GLint *params + + + void glGetFramebufferParameteriv + GLenum target + GLenum pname + GLint *params + + + void glGetFramebufferParameterivEXT + GLuint framebuffer + GLenum pname + GLint *params + + + GLenum glGetGraphicsResetStatus + + + GLenum glGetGraphicsResetStatusARB + + + GLenum glGetGraphicsResetStatusEXT + + + GLenum glGetGraphicsResetStatusKHR + + + + GLhandleARB glGetHandleARB + GLenum pname + + + void glGetHistogram + GLenum target + GLboolean reset + GLenum format + GLenum type + void *values + + + + + void glGetHistogramEXT + GLenum target + GLboolean reset + GLenum format + GLenum type + void *values + + + + void glGetHistogramParameterfv + GLenum target + GLenum pname + GLfloat *params + + + + void glGetHistogramParameterfvEXT + GLenum target + GLenum pname + GLfloat *params + + + + void glGetHistogramParameteriv + GLenum target + GLenum pname + GLint *params + + + + void glGetHistogramParameterivEXT + GLenum target + GLenum pname + GLint *params + + + + void glGetHistogramParameterxvOES + GLenum target + GLenum pname + GLfixed *params + + + GLuint64 glGetImageHandleARB + GLuint texture + GLint level + GLboolean layered + GLint layer + GLenum format + + + GLuint64 glGetImageHandleNV + GLuint texture + GLint level + GLboolean layered + GLint layer + GLenum format + + + void glGetImageTransformParameterfvHP + GLenum target + GLenum pname + GLfloat *params + + + void glGetImageTransformParameterivHP + GLenum target + GLenum pname + GLint *params + + + void glGetInfoLogARB + GLhandleARB obj + GLsizei maxLength + GLsizei *length + GLcharARB *infoLog + + + GLint glGetInstrumentsSGIX + + + + void glGetInteger64i_v + GLenum target + GLuint index + GLint64 *data + + + void glGetInteger64v + GLenum pname + GLint64 *data + + + void glGetInteger64vAPPLE + GLenum pname + GLint64 *params + + + + void glGetIntegerIndexedvEXT + GLenum target + GLuint index + GLint *data + + + + void glGetIntegeri_v + GLenum target + GLuint index + GLint *data + + + void glGetIntegeri_vEXT + GLenum target + GLuint index + GLint *data + + + void glGetIntegerui64i_vNV + GLenum value + GLuint index + GLuint64EXT *result + + + void glGetIntegerui64vNV + GLenum value + GLuint64EXT *result + + + void glGetIntegerv + GLenum pname + GLint *data + + + + void glGetInternalformati64v + GLenum target + GLenum internalformat + GLenum pname + GLsizei bufSize + GLint64 *params + + + void glGetInternalformativ + GLenum target + GLenum internalformat + GLenum pname + GLsizei bufSize + GLint *params + + + void glGetInvariantBooleanvEXT + GLuint id + GLenum value + GLboolean *data + + + void glGetInvariantFloatvEXT + GLuint id + GLenum value + GLfloat *data + + + void glGetInvariantIntegervEXT + GLuint id + GLenum value + GLint *data + + + void glGetLightfv + GLenum light + GLenum pname + GLfloat *params + + + + void glGetLightiv + GLenum light + GLenum pname + GLint *params + + + + void glGetLightxOES + GLenum light + GLenum pname + GLfixed *params + + + void glGetLightxv + GLenum light + GLenum pname + GLfixed *params + + + void glGetLightxvOES + GLenum light + GLenum pname + GLfixed *params + + + void glGetListParameterfvSGIX + GLuint list + GLenum pname + GLfloat *params + + + void glGetListParameterivSGIX + GLuint list + GLenum pname + GLint *params + + + void glGetLocalConstantBooleanvEXT + GLuint id + GLenum value + GLboolean *data + + + void glGetLocalConstantFloatvEXT + GLuint id + GLenum value + GLfloat *data + + + void glGetLocalConstantIntegervEXT + GLuint id + GLenum value + GLint *data + + + void glGetMapAttribParameterfvNV + GLenum target + GLuint index + GLenum pname + GLfloat *params + + + void glGetMapAttribParameterivNV + GLenum target + GLuint index + GLenum pname + GLint *params + + + void glGetMapControlPointsNV + GLenum target + GLuint index + GLenum type + GLsizei ustride + GLsizei vstride + GLboolean packed + void *points + + + void glGetMapParameterfvNV + GLenum target + GLenum pname + GLfloat *params + + + void glGetMapParameterivNV + GLenum target + GLenum pname + GLint *params + + + void glGetMapdv + GLenum target + GLenum query + GLdouble *v + + + + void glGetMapfv + GLenum target + GLenum query + GLfloat *v + + + + void glGetMapiv + GLenum target + GLenum query + GLint *v + + + + void glGetMapxvOES + GLenum target + GLenum query + GLfixed *v + + + void glGetMaterialfv + GLenum face + GLenum pname + GLfloat *params + + + + void glGetMaterialiv + GLenum face + GLenum pname + GLint *params + + + + void glGetMaterialxOES + GLenum face + GLenum pname + GLfixed param + + + void glGetMaterialxv + GLenum face + GLenum pname + GLfixed *params + + + void glGetMaterialxvOES + GLenum face + GLenum pname + GLfixed *params + + + void glGetMinmax + GLenum target + GLboolean reset + GLenum format + GLenum type + void *values + + + + + void glGetMinmaxEXT + GLenum target + GLboolean reset + GLenum format + GLenum type + void *values + + + + void glGetMinmaxParameterfv + GLenum target + GLenum pname + GLfloat *params + + + + void glGetMinmaxParameterfvEXT + GLenum target + GLenum pname + GLfloat *params + + + + void glGetMinmaxParameteriv + GLenum target + GLenum pname + GLint *params + + + + void glGetMinmaxParameterivEXT + GLenum target + GLenum pname + GLint *params + + + + void glGetMultiTexEnvfvEXT + GLenum texunit + GLenum target + GLenum pname + GLfloat *params + + + void glGetMultiTexEnvivEXT + GLenum texunit + GLenum target + GLenum pname + GLint *params + + + void glGetMultiTexGendvEXT + GLenum texunit + GLenum coord + GLenum pname + GLdouble *params + + + void glGetMultiTexGenfvEXT + GLenum texunit + GLenum coord + GLenum pname + GLfloat *params + + + void glGetMultiTexGenivEXT + GLenum texunit + GLenum coord + GLenum pname + GLint *params + + + void glGetMultiTexImageEXT + GLenum texunit + GLenum target + GLint level + GLenum format + GLenum type + void *pixels + + + void glGetMultiTexLevelParameterfvEXT + GLenum texunit + GLenum target + GLint level + GLenum pname + GLfloat *params + + + void glGetMultiTexLevelParameterivEXT + GLenum texunit + GLenum target + GLint level + GLenum pname + GLint *params + + + void glGetMultiTexParameterIivEXT + GLenum texunit + GLenum target + GLenum pname + GLint *params + + + void glGetMultiTexParameterIuivEXT + GLenum texunit + GLenum target + GLenum pname + GLuint *params + + + void glGetMultiTexParameterfvEXT + GLenum texunit + GLenum target + GLenum pname + GLfloat *params + + + void glGetMultiTexParameterivEXT + GLenum texunit + GLenum target + GLenum pname + GLint *params + + + void glGetMultisamplefv + GLenum pname + GLuint index + GLfloat *val + + + void glGetMultisamplefvNV + GLenum pname + GLuint index + GLfloat *val + + + + void glGetNamedBufferParameteri64v + GLuint buffer + GLenum pname + GLint64 *params + + + void glGetNamedBufferParameteriv + GLuint buffer + GLenum pname + GLint *params + + + void glGetNamedBufferParameterivEXT + GLuint buffer + GLenum pname + GLint *params + + + void glGetNamedBufferParameterui64vNV + GLuint buffer + GLenum pname + GLuint64EXT *params + + + void glGetNamedBufferPointerv + GLuint buffer + GLenum pname + void **params + + + void glGetNamedBufferPointervEXT + GLuint buffer + GLenum pname + void **params + + + void glGetNamedBufferSubData + GLuint buffer + GLintptr offset + GLsizei size + void *data + + + void glGetNamedBufferSubDataEXT + GLuint buffer + GLintptr offset + GLsizeiptr size + void *data + + + void glGetNamedFramebufferAttachmentParameteriv + GLuint framebuffer + GLenum attachment + GLenum pname + GLint *params + + + void glGetNamedFramebufferAttachmentParameterivEXT + GLuint framebuffer + GLenum attachment + GLenum pname + GLint *params + + + void glGetNamedFramebufferParameteriv + GLuint framebuffer + GLenum pname + GLint *param + + + void glGetNamedFramebufferParameterivEXT + GLuint framebuffer + GLenum pname + GLint *params + + + void glGetNamedProgramLocalParameterIivEXT + GLuint program + GLenum target + GLuint index + GLint *params + + + void glGetNamedProgramLocalParameterIuivEXT + GLuint program + GLenum target + GLuint index + GLuint *params + + + void glGetNamedProgramLocalParameterdvEXT + GLuint program + GLenum target + GLuint index + GLdouble *params + + + void glGetNamedProgramLocalParameterfvEXT + GLuint program + GLenum target + GLuint index + GLfloat *params + + + void glGetNamedProgramStringEXT + GLuint program + GLenum target + GLenum pname + void *string + + + void glGetNamedProgramivEXT + GLuint program + GLenum target + GLenum pname + GLint *params + + + void glGetNamedRenderbufferParameteriv + GLuint renderbuffer + GLenum pname + GLint *params + + + void glGetNamedRenderbufferParameterivEXT + GLuint renderbuffer + GLenum pname + GLint *params + + + void glGetNamedStringARB + GLint namelen + const GLchar *name + GLsizei bufSize + GLint *stringlen + GLchar *string + + + void glGetNamedStringivARB + GLint namelen + const GLchar *name + GLenum pname + GLint *params + + + void glGetNextPerfQueryIdINTEL + GLuint queryId + GLuint *nextQueryId + + + void glGetObjectBufferfvATI + GLuint buffer + GLenum pname + GLfloat *params + + + void glGetObjectBufferivATI + GLuint buffer + GLenum pname + GLint *params + + + void glGetObjectLabel + GLenum identifier + GLuint name + GLsizei bufSize + GLsizei *length + GLchar *label + + + void glGetObjectLabelEXT + GLenum type + GLuint object + GLsizei bufSize + GLsizei *length + GLchar *label + + + void glGetObjectLabelKHR + GLenum identifier + GLuint name + GLsizei bufSize + GLsizei *length + GLchar *label + + + + void glGetObjectParameterfvARB + GLhandleARB obj + GLenum pname + GLfloat *params + + + void glGetObjectParameterivAPPLE + GLenum objectType + GLuint name + GLenum pname + GLint *params + + + void glGetObjectParameterivARB + GLhandleARB obj + GLenum pname + GLint *params + + + void glGetObjectPtrLabel + const void *ptr + GLsizei bufSize + GLsizei *length + GLchar *label + + + void glGetObjectPtrLabelKHR + const void *ptr + GLsizei bufSize + GLsizei *length + GLchar *label + + + + void glGetOcclusionQueryivNV + GLuint id + GLenum pname + GLint *params + + + void glGetOcclusionQueryuivNV + GLuint id + GLenum pname + GLuint *params + + + void glGetPathColorGenfvNV + GLenum color + GLenum pname + GLfloat *value + + + void glGetPathColorGenivNV + GLenum color + GLenum pname + GLint *value + + + void glGetPathCommandsNV + GLuint path + GLubyte *commands + + + void glGetPathCoordsNV + GLuint path + GLfloat *coords + + + void glGetPathDashArrayNV + GLuint path + GLfloat *dashArray + + + GLfloat glGetPathLengthNV + GLuint path + GLsizei startSegment + GLsizei numSegments + + + void glGetPathMetricRangeNV + GLbitfield metricQueryMask + GLuint firstPathName + GLsizei numPaths + GLsizei stride + GLfloat *metrics + + + void glGetPathMetricsNV + GLbitfield metricQueryMask + GLsizei numPaths + GLenum pathNameType + const void *paths + GLuint pathBase + GLsizei stride + GLfloat *metrics + + + void glGetPathParameterfvNV + GLuint path + GLenum pname + GLfloat *value + + + void glGetPathParameterivNV + GLuint path + GLenum pname + GLint *value + + + void glGetPathSpacingNV + GLenum pathListMode + GLsizei numPaths + GLenum pathNameType + const void *paths + GLuint pathBase + GLfloat advanceScale + GLfloat kerningScale + GLenum transformType + GLfloat *returnedSpacing + + + void glGetPathTexGenfvNV + GLenum texCoordSet + GLenum pname + GLfloat *value + + + void glGetPathTexGenivNV + GLenum texCoordSet + GLenum pname + GLint *value + + + void glGetPerfCounterInfoINTEL + GLuint queryId + GLuint counterId + GLuint counterNameLength + GLchar *counterName + GLuint counterDescLength + GLchar *counterDesc + GLuint *counterOffset + GLuint *counterDataSize + GLuint *counterTypeEnum + GLuint *counterDataTypeEnum + GLuint64 *rawCounterMaxValue + + + void glGetPerfMonitorCounterDataAMD + GLuint monitor + GLenum pname + GLsizei dataSize + GLuint *data + GLint *bytesWritten + + + void glGetPerfMonitorCounterInfoAMD + GLuint group + GLuint counter + GLenum pname + void *data + + + void glGetPerfMonitorCounterStringAMD + GLuint group + GLuint counter + GLsizei bufSize + GLsizei *length + GLchar *counterString + + + void glGetPerfMonitorCountersAMD + GLuint group + GLint *numCounters + GLint *maxActiveCounters + GLsizei counterSize + GLuint *counters + + + void glGetPerfMonitorGroupStringAMD + GLuint group + GLsizei bufSize + GLsizei *length + GLchar *groupString + + + void glGetPerfMonitorGroupsAMD + GLint *numGroups + GLsizei groupsSize + GLuint *groups + + + void glGetPerfQueryDataINTEL + GLuint queryHandle + GLuint flags + GLsizei dataSize + GLvoid *data + GLuint *bytesWritten + + + void glGetPerfQueryIdByNameINTEL + GLchar *queryName + GLuint *queryId + + + void glGetPerfQueryInfoINTEL + GLuint queryId + GLuint queryNameLength + GLchar *queryName + GLuint *dataSize + GLuint *noCounters + GLuint *noInstances + GLuint *capsMask + + + void glGetPixelMapfv + GLenum map + GLfloat *values + + + + + void glGetPixelMapuiv + GLenum map + GLuint *values + + + + + void glGetPixelMapusv + GLenum map + GLushort *values + + + + + void glGetPixelMapxv + GLenum map + GLint size + GLfixed *values + + + void glGetPixelTexGenParameterfvSGIS + GLenum pname + GLfloat *params + + + void glGetPixelTexGenParameterivSGIS + GLenum pname + GLint *params + + + void glGetPixelTransformParameterfvEXT + GLenum target + GLenum pname + GLfloat *params + + + + void glGetPixelTransformParameterivEXT + GLenum target + GLenum pname + GLint *params + + + + void glGetPointerIndexedvEXT + GLenum target + GLuint index + void **data + + + void glGetPointeri_vEXT + GLenum pname + GLuint index + void **params + + + void glGetPointerv + GLenum pname + void **params + + + + void glGetPointervEXT + GLenum pname + void **params + + + + void glGetPointervKHR + GLenum pname + void **params + + + + void glGetPolygonStipple + GLubyte *mask + + + + + void glGetProgramBinary + GLuint program + GLsizei bufSize + GLsizei *length + GLenum *binaryFormat + void *binary + + + void glGetProgramBinaryOES + GLuint program + GLsizei bufSize + GLsizei *length + GLenum *binaryFormat + void *binary + + + + void glGetProgramEnvParameterIivNV + GLenum target + GLuint index + GLint *params + + + void glGetProgramEnvParameterIuivNV + GLenum target + GLuint index + GLuint *params + + + void glGetProgramEnvParameterdvARB + GLenum target + GLuint index + GLdouble *params + + + void glGetProgramEnvParameterfvARB + GLenum target + GLuint index + GLfloat *params + + + void glGetProgramInfoLog + GLuint program + GLsizei bufSize + GLsizei *length + GLchar *infoLog + + + + void glGetProgramInterfaceiv + GLuint program + GLenum programInterface + GLenum pname + GLint *params + + + void glGetProgramLocalParameterIivNV + GLenum target + GLuint index + GLint *params + + + void glGetProgramLocalParameterIuivNV + GLenum target + GLuint index + GLuint *params + + + void glGetProgramLocalParameterdvARB + GLenum target + GLuint index + GLdouble *params + + + void glGetProgramLocalParameterfvARB + GLenum target + GLuint index + GLfloat *params + + + void glGetProgramNamedParameterdvNV + GLuint id + GLsizei len + const GLubyte *name + GLdouble *params + + + + void glGetProgramNamedParameterfvNV + GLuint id + GLsizei len + const GLubyte *name + GLfloat *params + + + + void glGetProgramParameterdvNV + GLenum target + GLuint index + GLenum pname + GLdouble *params + + + + void glGetProgramParameterfvNV + GLenum target + GLuint index + GLenum pname + GLfloat *params + + + + void glGetProgramPipelineInfoLog + GLuint pipeline + GLsizei bufSize + GLsizei *length + GLchar *infoLog + + + void glGetProgramPipelineInfoLogEXT + GLuint pipeline + GLsizei bufSize + GLsizei *length + GLchar *infoLog + + + void glGetProgramPipelineiv + GLuint pipeline + GLenum pname + GLint *params + + + void glGetProgramPipelineivEXT + GLuint pipeline + GLenum pname + GLint *params + + + GLuint glGetProgramResourceIndex + GLuint program + GLenum programInterface + const GLchar *name + + + GLint glGetProgramResourceLocation + GLuint program + GLenum programInterface + const GLchar *name + + + GLint glGetProgramResourceLocationIndex + GLuint program + GLenum programInterface + const GLchar *name + + + void glGetProgramResourceName + GLuint program + GLenum programInterface + GLuint index + GLsizei bufSize + GLsizei *length + GLchar *name + + + void glGetProgramResourcefvNV + GLuint program + GLenum programInterface + GLuint index + GLsizei propCount + const GLenum *props + GLsizei bufSize + GLsizei *length + GLfloat *params + + + void glGetProgramResourceiv + GLuint program + GLenum programInterface + GLuint index + GLsizei propCount + const GLenum *props + GLsizei bufSize + GLsizei *length + GLint *params + + + void glGetProgramStageiv + GLuint program + GLenum shadertype + GLenum pname + GLint *values + + + void glGetProgramStringARB + GLenum target + GLenum pname + void *string + + + void glGetProgramStringNV + GLuint id + GLenum pname + GLubyte *program + + + + void glGetProgramSubroutineParameteruivNV + GLenum target + GLuint index + GLuint *param + + + void glGetProgramiv + GLuint program + GLenum pname + GLint *params + + + + void glGetProgramivARB + GLenum target + GLenum pname + GLint *params + + + void glGetProgramivNV + GLuint id + GLenum pname + GLint *params + + + + void glGetQueryIndexediv + GLenum target + GLuint index + GLenum pname + GLint *params + + + void glGetQueryObjecti64v + GLuint id + GLenum pname + GLint64 *params + + + void glGetQueryObjecti64vEXT + GLuint id + GLenum pname + GLint64 *params + + + + + void glGetQueryObjectiv + GLuint id + GLenum pname + GLint *params + + + + void glGetQueryObjectivARB + GLuint id + GLenum pname + GLint *params + + + + void glGetQueryObjectivEXT + GLuint id + GLenum pname + GLint *params + + + + void glGetQueryObjectui64v + GLuint id + GLenum pname + GLuint64 *params + + + void glGetQueryObjectui64vEXT + GLuint id + GLenum pname + GLuint64 *params + + + + + void glGetQueryObjectuiv + GLuint id + GLenum pname + GLuint *params + + + + void glGetQueryObjectuivARB + GLuint id + GLenum pname + GLuint *params + + + + void glGetQueryObjectuivEXT + GLuint id + GLenum pname + GLuint *params + + + void glGetQueryiv + GLenum target + GLenum pname + GLint *params + + + + void glGetQueryivARB + GLenum target + GLenum pname + GLint *params + + + + void glGetQueryivEXT + GLenum target + GLenum pname + GLint *params + + + void glGetRenderbufferParameteriv + GLenum target + GLenum pname + GLint *params + + + + void glGetRenderbufferParameterivEXT + GLenum target + GLenum pname + GLint *params + + + + + void glGetRenderbufferParameterivOES + GLenum target + GLenum pname + GLint *params + + + void glGetSamplerParameterIiv + GLuint sampler + GLenum pname + GLint *params + + + void glGetSamplerParameterIivEXT + GLuint sampler + GLenum pname + GLint *params + + + + void glGetSamplerParameterIuiv + GLuint sampler + GLenum pname + GLuint *params + + + void glGetSamplerParameterIuivEXT + GLuint sampler + GLenum pname + GLuint *params + + + + void glGetSamplerParameterfv + GLuint sampler + GLenum pname + GLfloat *params + + + void glGetSamplerParameteriv + GLuint sampler + GLenum pname + GLint *params + + + void glGetSeparableFilter + GLenum target + GLenum format + GLenum type + void *row + void *column + void *span + + + + + void glGetSeparableFilterEXT + GLenum target + GLenum format + GLenum type + void *row + void *column + void *span + + + + void glGetShaderInfoLog + GLuint shader + GLsizei bufSize + GLsizei *length + GLchar *infoLog + + + + void glGetShaderPrecisionFormat + GLenum shadertype + GLenum precisiontype + GLint *range + GLint *precision + + + void glGetShaderSource + GLuint shader + GLsizei bufSize + GLsizei *length + GLchar *source + + + void glGetShaderSourceARB + GLhandleARB obj + GLsizei maxLength + GLsizei *length + GLcharARB *source + + + + void glGetShaderiv + GLuint shader + GLenum pname + GLint *params + + + + void glGetSharpenTexFuncSGIS + GLenum target + GLfloat *points + + + + const GLubyte *glGetString + GLenum name + + + + const GLubyte *glGetStringi + GLenum name + GLuint index + + + GLuint glGetSubroutineIndex + GLuint program + GLenum shadertype + const GLchar *name + + + GLint glGetSubroutineUniformLocation + GLuint program + GLenum shadertype + const GLchar *name + + + void glGetSynciv + GLsync sync + GLenum pname + GLsizei bufSize + GLsizei *length + GLint *values + + + void glGetSyncivAPPLE + GLsync sync + GLenum pname + GLsizei bufSize + GLsizei *length + GLint *values + + + + void glGetTexBumpParameterfvATI + GLenum pname + GLfloat *param + + + void glGetTexBumpParameterivATI + GLenum pname + GLint *param + + + void glGetTexEnvfv + GLenum target + GLenum pname + GLfloat *params + + + + void glGetTexEnviv + GLenum target + GLenum pname + GLint *params + + + + void glGetTexEnvxv + GLenum target + GLenum pname + GLfixed *params + + + void glGetTexEnvxvOES + GLenum target + GLenum pname + GLfixed *params + + + void glGetTexFilterFuncSGIS + GLenum target + GLenum filter + GLfloat *weights + + + + void glGetTexGendv + GLenum coord + GLenum pname + GLdouble *params + + + + void glGetTexGenfv + GLenum coord + GLenum pname + GLfloat *params + + + + void glGetTexGenfvOES + GLenum coord + GLenum pname + GLfloat *params + + + void glGetTexGeniv + GLenum coord + GLenum pname + GLint *params + + + + void glGetTexGenivOES + GLenum coord + GLenum pname + GLint *params + + + void glGetTexGenxvOES + GLenum coord + GLenum pname + GLfixed *params + + + void glGetTexImage + GLenum target + GLint level + GLenum format + GLenum type + void *pixels + + + + + void glGetTexLevelParameterfv + GLenum target + GLint level + GLenum pname + GLfloat *params + + + + void glGetTexLevelParameteriv + GLenum target + GLint level + GLenum pname + GLint *params + + + + void glGetTexLevelParameterxvOES + GLenum target + GLint level + GLenum pname + GLfixed *params + + + void glGetTexParameterIiv + GLenum target + GLenum pname + GLint *params + + + + void glGetTexParameterIivEXT + GLenum target + GLenum pname + GLint *params + + + + void glGetTexParameterIuiv + GLenum target + GLenum pname + GLuint *params + + + + void glGetTexParameterIuivEXT + GLenum target + GLenum pname + GLuint *params + + + + void glGetTexParameterPointervAPPLE + GLenum target + GLenum pname + void **params + + + void glGetTexParameterfv + GLenum target + GLenum pname + GLfloat *params + + + + void glGetTexParameteriv + GLenum target + GLenum pname + GLint *params + + + + void glGetTexParameterxv + GLenum target + GLenum pname + GLfixed *params + + + void glGetTexParameterxvOES + GLenum target + GLenum pname + GLfixed *params + + + GLuint64 glGetTextureHandleARB + GLuint texture + + + GLuint64 glGetTextureHandleNV + GLuint texture + + + void glGetTextureImage + GLuint texture + GLint level + GLenum format + GLenum type + GLsizei bufSize + void *pixels + + + void glGetTextureImageEXT + GLuint texture + GLenum target + GLint level + GLenum format + GLenum type + void *pixels + + + void glGetTextureLevelParameterfv + GLuint texture + GLint level + GLenum pname + GLfloat *params + + + void glGetTextureLevelParameterfvEXT + GLuint texture + GLenum target + GLint level + GLenum pname + GLfloat *params + + + void glGetTextureLevelParameteriv + GLuint texture + GLint level + GLenum pname + GLint *params + + + void glGetTextureLevelParameterivEXT + GLuint texture + GLenum target + GLint level + GLenum pname + GLint *params + + + void glGetTextureParameterIiv + GLuint texture + GLenum pname + GLint *params + + + void glGetTextureParameterIivEXT + GLuint texture + GLenum target + GLenum pname + GLint *params + + + void glGetTextureParameterIuiv + GLuint texture + GLenum pname + GLuint *params + + + void glGetTextureParameterIuivEXT + GLuint texture + GLenum target + GLenum pname + GLuint *params + + + void glGetTextureParameterfv + GLuint texture + GLenum pname + GLfloat *params + + + void glGetTextureParameterfvEXT + GLuint texture + GLenum target + GLenum pname + GLfloat *params + + + void glGetTextureParameteriv + GLuint texture + GLenum pname + GLint *params + + + void glGetTextureParameterivEXT + GLuint texture + GLenum target + GLenum pname + GLint *params + + + GLuint64 glGetTextureSamplerHandleARB + GLuint texture + GLuint sampler + + + GLuint64 glGetTextureSamplerHandleNV + GLuint texture + GLuint sampler + + + void glGetTextureSubImage + GLuint texture + GLint level + GLint xoffset + GLint yoffset + GLint zoffset + GLsizei width + GLsizei height + GLsizei depth + GLenum format + GLenum type + GLsizei bufSize + void *pixels + + + void glGetTrackMatrixivNV + GLenum target + GLuint address + GLenum pname + GLint *params + + + + void glGetTransformFeedbackVarying + GLuint program + GLuint index + GLsizei bufSize + GLsizei *length + GLsizei *size + GLenum *type + GLchar *name + + + void glGetTransformFeedbackVaryingEXT + GLuint program + GLuint index + GLsizei bufSize + GLsizei *length + GLsizei *size + GLenum *type + GLchar *name + + + + void glGetTransformFeedbackVaryingNV + GLuint program + GLuint index + GLint *location + + + void glGetTransformFeedbacki64_v + GLuint xfb + GLenum pname + GLuint index + GLint64 *param + + + void glGetTransformFeedbacki_v + GLuint xfb + GLenum pname + GLuint index + GLint *param + + + void glGetTransformFeedbackiv + GLuint xfb + GLenum pname + GLint *param + + + void glGetTranslatedShaderSourceANGLE + GLuint shader + GLsizei bufsize + GLsizei *length + GLchar *source + + + GLuint glGetUniformBlockIndex + GLuint program + const GLchar *uniformBlockName + + + GLint glGetUniformBufferSizeEXT + GLuint program + GLint location + + + void glGetUniformIndices + GLuint program + GLsizei uniformCount + const GLchar *const*uniformNames + GLuint *uniformIndices + + + GLint glGetUniformLocation + GLuint program + const GLchar *name + + + GLint glGetUniformLocationARB + GLhandleARB programObj + const GLcharARB *name + + + + GLintptr glGetUniformOffsetEXT + GLuint program + GLint location + + + void glGetUniformSubroutineuiv + GLenum shadertype + GLint location + GLuint *params + + + void glGetUniformdv + GLuint program + GLint location + GLdouble *params + + + void glGetUniformfv + GLuint program + GLint location + GLfloat *params + + + void glGetUniformfvARB + GLhandleARB programObj + GLint location + GLfloat *params + + + + void glGetUniformi64vNV + GLuint program + GLint location + GLint64EXT *params + + + void glGetUniformiv + GLuint program + GLint location + GLint *params + + + void glGetUniformivARB + GLhandleARB programObj + GLint location + GLint *params + + + + void glGetUniformui64vNV + GLuint program + GLint location + GLuint64EXT *params + + + void glGetUniformuiv + GLuint program + GLint location + GLuint *params + + + void glGetUniformuivEXT + GLuint program + GLint location + GLuint *params + + + + void glGetVariantArrayObjectfvATI + GLuint id + GLenum pname + GLfloat *params + + + void glGetVariantArrayObjectivATI + GLuint id + GLenum pname + GLint *params + + + void glGetVariantBooleanvEXT + GLuint id + GLenum value + GLboolean *data + + + void glGetVariantFloatvEXT + GLuint id + GLenum value + GLfloat *data + + + void glGetVariantIntegervEXT + GLuint id + GLenum value + GLint *data + + + void glGetVariantPointervEXT + GLuint id + GLenum value + void **data + + + GLint glGetVaryingLocationNV + GLuint program + const GLchar *name + + + void glGetVertexArrayIndexed64iv + GLuint vaobj + GLuint index + GLenum pname + GLint64 *param + + + void glGetVertexArrayIndexediv + GLuint vaobj + GLuint index + GLenum pname + GLint *param + + + void glGetVertexArrayIntegeri_vEXT + GLuint vaobj + GLuint index + GLenum pname + GLint *param + + + void glGetVertexArrayIntegervEXT + GLuint vaobj + GLenum pname + GLint *param + + + void glGetVertexArrayPointeri_vEXT + GLuint vaobj + GLuint index + GLenum pname + void **param + + + void glGetVertexArrayPointervEXT + GLuint vaobj + GLenum pname + void **param + + + void glGetVertexArrayiv + GLuint vaobj + GLenum pname + GLint *param + + + void glGetVertexAttribArrayObjectfvATI + GLuint index + GLenum pname + GLfloat *params + + + void glGetVertexAttribArrayObjectivATI + GLuint index + GLenum pname + GLint *params + + + void glGetVertexAttribIiv + GLuint index + GLenum pname + GLint *params + + + void glGetVertexAttribIivEXT + GLuint index + GLenum pname + GLint *params + + + + void glGetVertexAttribIuiv + GLuint index + GLenum pname + GLuint *params + + + void glGetVertexAttribIuivEXT + GLuint index + GLenum pname + GLuint *params + + + + void glGetVertexAttribLdv + GLuint index + GLenum pname + GLdouble *params + + + void glGetVertexAttribLdvEXT + GLuint index + GLenum pname + GLdouble *params + + + + void glGetVertexAttribLi64vNV + GLuint index + GLenum pname + GLint64EXT *params + + + void glGetVertexAttribLui64vARB + GLuint index + GLenum pname + GLuint64EXT *params + + + void glGetVertexAttribLui64vNV + GLuint index + GLenum pname + GLuint64EXT *params + + + void glGetVertexAttribPointerv + GLuint index + GLenum pname + void **pointer + + + + void glGetVertexAttribPointervARB + GLuint index + GLenum pname + void **pointer + + + + void glGetVertexAttribPointervNV + GLuint index + GLenum pname + void **pointer + + + + void glGetVertexAttribdv + GLuint index + GLenum pname + GLdouble *params + + + + void glGetVertexAttribdvARB + GLuint index + GLenum pname + GLdouble *params + + + + + void glGetVertexAttribdvNV + GLuint index + GLenum pname + GLdouble *params + + + + + void glGetVertexAttribfv + GLuint index + GLenum pname + GLfloat *params + + + + void glGetVertexAttribfvARB + GLuint index + GLenum pname + GLfloat *params + + + + + void glGetVertexAttribfvNV + GLuint index + GLenum pname + GLfloat *params + + + + + void glGetVertexAttribiv + GLuint index + GLenum pname + GLint *params + + + + void glGetVertexAttribivARB + GLuint index + GLenum pname + GLint *params + + + + + void glGetVertexAttribivNV + GLuint index + GLenum pname + GLint *params + + + + + void glGetVideoCaptureStreamdvNV + GLuint video_capture_slot + GLuint stream + GLenum pname + GLdouble *params + + + void glGetVideoCaptureStreamfvNV + GLuint video_capture_slot + GLuint stream + GLenum pname + GLfloat *params + + + void glGetVideoCaptureStreamivNV + GLuint video_capture_slot + GLuint stream + GLenum pname + GLint *params + + + void glGetVideoCaptureivNV + GLuint video_capture_slot + GLenum pname + GLint *params + + + void glGetVideoi64vNV + GLuint video_slot + GLenum pname + GLint64EXT *params + + + void glGetVideoivNV + GLuint video_slot + GLenum pname + GLint *params + + + void glGetVideoui64vNV + GLuint video_slot + GLenum pname + GLuint64EXT *params + + + void glGetVideouivNV + GLuint video_slot + GLenum pname + GLuint *params + + + void glGetnColorTable + GLenum target + GLenum format + GLenum type + GLsizei bufSize + void *table + + + void glGetnColorTableARB + GLenum target + GLenum format + GLenum type + GLsizei bufSize + void *table + + + void glGetnCompressedTexImage + GLenum target + GLint lod + GLsizei bufSize + void *pixels + + + void glGetnCompressedTexImageARB + GLenum target + GLint lod + GLsizei bufSize + void *img + + + void glGetnConvolutionFilter + GLenum target + GLenum format + GLenum type + GLsizei bufSize + void *image + + + void glGetnConvolutionFilterARB + GLenum target + GLenum format + GLenum type + GLsizei bufSize + void *image + + + void glGetnHistogram + GLenum target + GLboolean reset + GLenum format + GLenum type + GLsizei bufSize + void *values + + + void glGetnHistogramARB + GLenum target + GLboolean reset + GLenum format + GLenum type + GLsizei bufSize + void *values + + + void glGetnMapdv + GLenum target + GLenum query + GLsizei bufSize + GLdouble *v + + + void glGetnMapdvARB + GLenum target + GLenum query + GLsizei bufSize + GLdouble *v + + + void glGetnMapfv + GLenum target + GLenum query + GLsizei bufSize + GLfloat *v + + + void glGetnMapfvARB + GLenum target + GLenum query + GLsizei bufSize + GLfloat *v + + + void glGetnMapiv + GLenum target + GLenum query + GLsizei bufSize + GLint *v + + + void glGetnMapivARB + GLenum target + GLenum query + GLsizei bufSize + GLint *v + + + void glGetnMinmax + GLenum target + GLboolean reset + GLenum format + GLenum type + GLsizei bufSize + void *values + + + void glGetnMinmaxARB + GLenum target + GLboolean reset + GLenum format + GLenum type + GLsizei bufSize + void *values + + + void glGetnPixelMapfv + GLenum map + GLsizei bufSize + GLfloat *values + + + void glGetnPixelMapfvARB + GLenum map + GLsizei bufSize + GLfloat *values + + + void glGetnPixelMapuiv + GLenum map + GLsizei bufSize + GLuint *values + + + void glGetnPixelMapuivARB + GLenum map + GLsizei bufSize + GLuint *values + + + void glGetnPixelMapusv + GLenum map + GLsizei bufSize + GLushort *values + + + void glGetnPixelMapusvARB + GLenum map + GLsizei bufSize + GLushort *values + + + void glGetnPolygonStipple + GLsizei bufSize + GLubyte *pattern + + + void glGetnPolygonStippleARB + GLsizei bufSize + GLubyte *pattern + + + void glGetnSeparableFilter + GLenum target + GLenum format + GLenum type + GLsizei rowBufSize + void *row + GLsizei columnBufSize + void *column + void *span + + + void glGetnSeparableFilterARB + GLenum target + GLenum format + GLenum type + GLsizei rowBufSize + void *row + GLsizei columnBufSize + void *column + void *span + + + void glGetnTexImage + GLenum target + GLint level + GLenum format + GLenum type + GLsizei bufSize + void *pixels + + + void glGetnTexImageARB + GLenum target + GLint level + GLenum format + GLenum type + GLsizei bufSize + void *img + + + void glGetnUniformdv + GLuint program + GLint location + GLsizei bufSize + GLdouble *params + + + void glGetnUniformdvARB + GLuint program + GLint location + GLsizei bufSize + GLdouble *params + + + void glGetnUniformfv + GLuint program + GLint location + GLsizei bufSize + GLfloat *params + + + void glGetnUniformfvARB + GLuint program + GLint location + GLsizei bufSize + GLfloat *params + + + void glGetnUniformfvEXT + GLuint program + GLint location + GLsizei bufSize + GLfloat *params + + + void glGetnUniformfvKHR + GLuint program + GLint location + GLsizei bufSize + GLfloat *params + + + + void glGetnUniformiv + GLuint program + GLint location + GLsizei bufSize + GLint *params + + + void glGetnUniformivARB + GLuint program + GLint location + GLsizei bufSize + GLint *params + + + void glGetnUniformivEXT + GLuint program + GLint location + GLsizei bufSize + GLint *params + + + void glGetnUniformivKHR + GLuint program + GLint location + GLsizei bufSize + GLint *params + + + + void glGetnUniformuiv + GLuint program + GLint location + GLsizei bufSize + GLuint *params + + + void glGetnUniformuivARB + GLuint program + GLint location + GLsizei bufSize + GLuint *params + + + void glGetnUniformuivKHR + GLuint program + GLint location + GLsizei bufSize + GLuint *params + + + + void glGlobalAlphaFactorbSUN + GLbyte factor + + + void glGlobalAlphaFactordSUN + GLdouble factor + + + void glGlobalAlphaFactorfSUN + GLfloat factor + + + void glGlobalAlphaFactoriSUN + GLint factor + + + void glGlobalAlphaFactorsSUN + GLshort factor + + + void glGlobalAlphaFactorubSUN + GLubyte factor + + + void glGlobalAlphaFactoruiSUN + GLuint factor + + + void glGlobalAlphaFactorusSUN + GLushort factor + + + void glHint + GLenum target + GLenum mode + + + + void glHintPGI + GLenum target + GLint mode + + + void glHistogram + GLenum target + GLsizei width + GLenum internalformat + GLboolean sink + + + + void glHistogramEXT + GLenum target + GLsizei width + GLenum internalformat + GLboolean sink + + + + + void glIglooInterfaceSGIX + GLenum pname + const void *params + + + + void glImageTransformParameterfHP + GLenum target + GLenum pname + GLfloat param + + + void glImageTransformParameterfvHP + GLenum target + GLenum pname + const GLfloat *params + + + void glImageTransformParameteriHP + GLenum target + GLenum pname + GLint param + + + void glImageTransformParameterivHP + GLenum target + GLenum pname + const GLint *params + + + GLsync glImportSyncEXT + GLenum external_sync_type + GLintptr external_sync + GLbitfield flags + + + void glIndexFormatNV + GLenum type + GLsizei stride + + + void glIndexFuncEXT + GLenum func + GLclampf ref + + + void glIndexMask + GLuint mask + + + + void glIndexMaterialEXT + GLenum face + GLenum mode + + + void glIndexPointer + GLenum type + GLsizei stride + const void *pointer + + + void glIndexPointerEXT + GLenum type + GLsizei stride + GLsizei count + const void *pointer + + + void glIndexPointerListIBM + GLenum type + GLint stride + const void **pointer + GLint ptrstride + + + void glIndexd + GLdouble c + + + + void glIndexdv + const GLdouble *c + + + + void glIndexf + GLfloat c + + + + void glIndexfv + const GLfloat *c + + + + void glIndexi + GLint c + + + + void glIndexiv + const GLint *c + + + + void glIndexs + GLshort c + + + + void glIndexsv + const GLshort *c + + + + void glIndexub + GLubyte c + + + + void glIndexubv + const GLubyte *c + + + + void glIndexxOES + GLfixed component + + + void glIndexxvOES + const GLfixed *component + + + void glInitNames + + + + void glInsertComponentEXT + GLuint res + GLuint src + GLuint num + + + void glInsertEventMarkerEXT + GLsizei length + const GLchar *marker + + + void glInstrumentsBufferSGIX + GLsizei size + GLint *buffer + + + + void glInterleavedArrays + GLenum format + GLsizei stride + const void *pointer + + + void glInterpolatePathsNV + GLuint resultPath + GLuint pathA + GLuint pathB + GLfloat weight + + + void glInvalidateBufferData + GLuint buffer + + + void glInvalidateBufferSubData + GLuint buffer + GLintptr offset + GLsizeiptr length + + + void glInvalidateFramebuffer + GLenum target + GLsizei numAttachments + const GLenum *attachments + + + void glInvalidateNamedFramebufferData + GLuint framebuffer + GLsizei numAttachments + const GLenum *attachments + + + void glInvalidateNamedFramebufferSubData + GLuint framebuffer + GLsizei numAttachments + const GLenum *attachments + GLint x + GLint y + GLsizei width + GLsizei height + + + void glInvalidateSubFramebuffer + GLenum target + GLsizei numAttachments + const GLenum *attachments + GLint x + GLint y + GLsizei width + GLsizei height + + + void glInvalidateTexImage + GLuint texture + GLint level + + + void glInvalidateTexSubImage + GLuint texture + GLint level + GLint xoffset + GLint yoffset + GLint zoffset + GLsizei width + GLsizei height + GLsizei depth + + + GLboolean glIsAsyncMarkerSGIX + GLuint marker + + + GLboolean glIsBuffer + GLuint buffer + + + GLboolean glIsBufferARB + GLuint buffer + + + + GLboolean glIsBufferResidentNV + GLenum target + + + GLboolean glIsEnabled + GLenum cap + + + + GLboolean glIsEnabledIndexedEXT + GLenum target + GLuint index + + + + GLboolean glIsEnabledi + GLenum target + GLuint index + + + GLboolean glIsEnablediEXT + GLenum target + GLuint index + + + + GLboolean glIsFenceAPPLE + GLuint fence + + + GLboolean glIsFenceNV + GLuint fence + + + + GLboolean glIsFramebuffer + GLuint framebuffer + + + + GLboolean glIsFramebufferEXT + GLuint framebuffer + + + + + GLboolean glIsFramebufferOES + GLuint framebuffer + + + GLboolean glIsImageHandleResidentARB + GLuint64 handle + + + GLboolean glIsImageHandleResidentNV + GLuint64 handle + + + GLboolean glIsList + GLuint list + + + + GLboolean glIsNameAMD + GLenum identifier + GLuint name + + + GLboolean glIsNamedBufferResidentNV + GLuint buffer + + + GLboolean glIsNamedStringARB + GLint namelen + const GLchar *name + + + GLboolean glIsObjectBufferATI + GLuint buffer + + + GLboolean glIsOcclusionQueryNV + GLuint id + + + GLboolean glIsPathNV + GLuint path + + + GLboolean glIsPointInFillPathNV + GLuint path + GLuint mask + GLfloat x + GLfloat y + + + GLboolean glIsPointInStrokePathNV + GLuint path + GLfloat x + GLfloat y + + + GLboolean glIsProgram + GLuint program + + + + GLboolean glIsProgramARB + GLuint program + + + + GLboolean glIsProgramNV + GLuint id + + + + + GLboolean glIsProgramPipeline + GLuint pipeline + + + GLboolean glIsProgramPipelineEXT + GLuint pipeline + + + GLboolean glIsQuery + GLuint id + + + + GLboolean glIsQueryARB + GLuint id + + + + GLboolean glIsQueryEXT + GLuint id + + + GLboolean glIsRenderbuffer + GLuint renderbuffer + + + + GLboolean glIsRenderbufferEXT + GLuint renderbuffer + + + + + GLboolean glIsRenderbufferOES + GLuint renderbuffer + + + GLboolean glIsSampler + GLuint sampler + + + GLboolean glIsShader + GLuint shader + + + + GLboolean glIsSync + GLsync sync + + + GLboolean glIsSyncAPPLE + GLsync sync + + + + GLboolean glIsTexture + GLuint texture + + + + GLboolean glIsTextureEXT + GLuint texture + + + + GLboolean glIsTextureHandleResidentARB + GLuint64 handle + + + GLboolean glIsTextureHandleResidentNV + GLuint64 handle + + + GLboolean glIsTransformFeedback + GLuint id + + + GLboolean glIsTransformFeedbackNV + GLuint id + + + + GLboolean glIsVariantEnabledEXT + GLuint id + GLenum cap + + + GLboolean glIsVertexArray + GLuint array + + + + GLboolean glIsVertexArrayAPPLE + GLuint array + + + + GLboolean glIsVertexArrayOES + GLuint array + + + + GLboolean glIsVertexAttribEnabledAPPLE + GLuint index + GLenum pname + + + void glLabelObjectEXT + GLenum type + GLuint object + GLsizei length + const GLchar *label + + + void glLightEnviSGIX + GLenum pname + GLint param + + + void glLightModelf + GLenum pname + GLfloat param + + + + void glLightModelfv + GLenum pname + const GLfloat *params + + + + void glLightModeli + GLenum pname + GLint param + + + + void glLightModeliv + GLenum pname + const GLint *params + + + + void glLightModelx + GLenum pname + GLfixed param + + + void glLightModelxOES + GLenum pname + GLfixed param + + + void glLightModelxv + GLenum pname + const GLfixed *param + + + void glLightModelxvOES + GLenum pname + const GLfixed *param + + + void glLightf + GLenum light + GLenum pname + GLfloat param + + + + void glLightfv + GLenum light + GLenum pname + const GLfloat *params + + + + void glLighti + GLenum light + GLenum pname + GLint param + + + + void glLightiv + GLenum light + GLenum pname + const GLint *params + + + + void glLightx + GLenum light + GLenum pname + GLfixed param + + + void glLightxOES + GLenum light + GLenum pname + GLfixed param + + + void glLightxv + GLenum light + GLenum pname + const GLfixed *params + + + void glLightxvOES + GLenum light + GLenum pname + const GLfixed *params + + + void glLineStipple + GLint factor + GLushort pattern + + + + void glLineWidth + GLfloat width + + + + void glLineWidthx + GLfixed width + + + void glLineWidthxOES + GLfixed width + + + void glLinkProgram + GLuint program + + + void glLinkProgramARB + GLhandleARB programObj + + + + void glListBase + GLuint base + + + + void glListParameterfSGIX + GLuint list + GLenum pname + GLfloat param + + + + void glListParameterfvSGIX + GLuint list + GLenum pname + const GLfloat *params + + + + void glListParameteriSGIX + GLuint list + GLenum pname + GLint param + + + + void glListParameterivSGIX + GLuint list + GLenum pname + const GLint *params + + + + void glLoadIdentity + + + + void glLoadIdentityDeformationMapSGIX + GLbitfield mask + + + + void glLoadMatrixd + const GLdouble *m + + + + void glLoadMatrixf + const GLfloat *m + + + + void glLoadMatrixx + const GLfixed *m + + + void glLoadMatrixxOES + const GLfixed *m + + + void glLoadName + GLuint name + + + + void glLoadPaletteFromModelViewMatrixOES + + + void glLoadProgramNV + GLenum target + GLuint id + GLsizei len + const GLubyte *program + + + + void glLoadTransposeMatrixd + const GLdouble *m + + + void glLoadTransposeMatrixdARB + const GLdouble *m + + + + void glLoadTransposeMatrixf + const GLfloat *m + + + void glLoadTransposeMatrixfARB + const GLfloat *m + + + + void glLoadTransposeMatrixxOES + const GLfixed *m + + + void glLockArraysEXT + GLint first + GLsizei count + + + void glLogicOp + GLenum opcode + + + + void glMakeBufferNonResidentNV + GLenum target + + + void glMakeBufferResidentNV + GLenum target + GLenum access + + + void glMakeImageHandleNonResidentARB + GLuint64 handle + + + void glMakeImageHandleNonResidentNV + GLuint64 handle + + + void glMakeImageHandleResidentARB + GLuint64 handle + GLenum access + + + void glMakeImageHandleResidentNV + GLuint64 handle + GLenum access + + + void glMakeNamedBufferNonResidentNV + GLuint buffer + + + void glMakeNamedBufferResidentNV + GLuint buffer + GLenum access + + + void glMakeTextureHandleNonResidentARB + GLuint64 handle + + + void glMakeTextureHandleNonResidentNV + GLuint64 handle + + + void glMakeTextureHandleResidentARB + GLuint64 handle + + + void glMakeTextureHandleResidentNV + GLuint64 handle + + + void glMap1d + GLenum target + GLdouble u1 + GLdouble u2 + GLint stride + GLint order + const GLdouble *points + + + + void glMap1f + GLenum target + GLfloat u1 + GLfloat u2 + GLint stride + GLint order + const GLfloat *points + + + + void glMap1xOES + GLenum target + GLfixed u1 + GLfixed u2 + GLint stride + GLint order + GLfixed points + + + void glMap2d + GLenum target + GLdouble u1 + GLdouble u2 + GLint ustride + GLint uorder + GLdouble v1 + GLdouble v2 + GLint vstride + GLint vorder + const GLdouble *points + + + + void glMap2f + GLenum target + GLfloat u1 + GLfloat u2 + GLint ustride + GLint uorder + GLfloat v1 + GLfloat v2 + GLint vstride + GLint vorder + const GLfloat *points + + + + void glMap2xOES + GLenum target + GLfixed u1 + GLfixed u2 + GLint ustride + GLint uorder + GLfixed v1 + GLfixed v2 + GLint vstride + GLint vorder + GLfixed points + + + void *glMapBuffer + GLenum target + GLenum access + + + void *glMapBufferARB + GLenum target + GLenum access + + + + void *glMapBufferOES + GLenum target + GLenum access + + + + void *glMapBufferRange + GLenum target + GLintptr offset + GLsizeiptr length + GLbitfield access + + + + void *glMapBufferRangeEXT + GLenum target + GLintptr offset + GLsizeiptr length + GLbitfield access + + + + void glMapControlPointsNV + GLenum target + GLuint index + GLenum type + GLsizei ustride + GLsizei vstride + GLint uorder + GLint vorder + GLboolean packed + const void *points + + + void glMapGrid1d + GLint un + GLdouble u1 + GLdouble u2 + + + + void glMapGrid1f + GLint un + GLfloat u1 + GLfloat u2 + + + + void glMapGrid1xOES + GLint n + GLfixed u1 + GLfixed u2 + + + void glMapGrid2d + GLint un + GLdouble u1 + GLdouble u2 + GLint vn + GLdouble v1 + GLdouble v2 + + + + void glMapGrid2f + GLint un + GLfloat u1 + GLfloat u2 + GLint vn + GLfloat v1 + GLfloat v2 + + + + void glMapGrid2xOES + GLint n + GLfixed u1 + GLfixed u2 + GLfixed v1 + GLfixed v2 + + + void *glMapNamedBuffer + GLuint buffer + GLenum access + + + void *glMapNamedBufferEXT + GLuint buffer + GLenum access + + + void *glMapNamedBufferRange + GLuint buffer + GLintptr offset + GLsizei length + GLbitfield access + + + void *glMapNamedBufferRangeEXT + GLuint buffer + GLintptr offset + GLsizeiptr length + GLbitfield access + + + void *glMapObjectBufferATI + GLuint buffer + + + void glMapParameterfvNV + GLenum target + GLenum pname + const GLfloat *params + + + void glMapParameterivNV + GLenum target + GLenum pname + const GLint *params + + + void *glMapTexture2DINTEL + GLuint texture + GLint level + GLbitfield access + GLint *stride + GLenum *layout + + + void glMapVertexAttrib1dAPPLE + GLuint index + GLuint size + GLdouble u1 + GLdouble u2 + GLint stride + GLint order + const GLdouble *points + + + void glMapVertexAttrib1fAPPLE + GLuint index + GLuint size + GLfloat u1 + GLfloat u2 + GLint stride + GLint order + const GLfloat *points + + + void glMapVertexAttrib2dAPPLE + GLuint index + GLuint size + GLdouble u1 + GLdouble u2 + GLint ustride + GLint uorder + GLdouble v1 + GLdouble v2 + GLint vstride + GLint vorder + const GLdouble *points + + + void glMapVertexAttrib2fAPPLE + GLuint index + GLuint size + GLfloat u1 + GLfloat u2 + GLint ustride + GLint uorder + GLfloat v1 + GLfloat v2 + GLint vstride + GLint vorder + const GLfloat *points + + + void glMaterialf + GLenum face + GLenum pname + GLfloat param + + + + void glMaterialfv + GLenum face + GLenum pname + const GLfloat *params + + + + void glMateriali + GLenum face + GLenum pname + GLint param + + + + void glMaterialiv + GLenum face + GLenum pname + const GLint *params + + + + void glMaterialx + GLenum face + GLenum pname + GLfixed param + + + void glMaterialxOES + GLenum face + GLenum pname + GLfixed param + + + void glMaterialxv + GLenum face + GLenum pname + const GLfixed *param + + + void glMaterialxvOES + GLenum face + GLenum pname + const GLfixed *param + + + void glMatrixFrustumEXT + GLenum mode + GLdouble left + GLdouble right + GLdouble bottom + GLdouble top + GLdouble zNear + GLdouble zFar + + + void glMatrixIndexPointerARB + GLint size + GLenum type + GLsizei stride + const void *pointer + + + void glMatrixIndexPointerOES + GLint size + GLenum type + GLsizei stride + const void *pointer + + + void glMatrixIndexubvARB + GLint size + const GLubyte *indices + + + + void glMatrixIndexuivARB + GLint size + const GLuint *indices + + + + void glMatrixIndexusvARB + GLint size + const GLushort *indices + + + + void glMatrixLoad3x2fNV + GLenum matrixMode + const GLfloat *m + + + void glMatrixLoad3x3fNV + GLenum matrixMode + const GLfloat *m + + + void glMatrixLoadIdentityEXT + GLenum mode + + + void glMatrixLoadTranspose3x3fNV + GLenum matrixMode + const GLfloat *m + + + void glMatrixLoadTransposedEXT + GLenum mode + const GLdouble *m + + + void glMatrixLoadTransposefEXT + GLenum mode + const GLfloat *m + + + void glMatrixLoaddEXT + GLenum mode + const GLdouble *m + + + void glMatrixLoadfEXT + GLenum mode + const GLfloat *m + + + void glMatrixMode + GLenum mode + + + + void glMatrixMult3x2fNV + GLenum matrixMode + const GLfloat *m + + + void glMatrixMult3x3fNV + GLenum matrixMode + const GLfloat *m + + + void glMatrixMultTranspose3x3fNV + GLenum matrixMode + const GLfloat *m + + + void glMatrixMultTransposedEXT + GLenum mode + const GLdouble *m + + + void glMatrixMultTransposefEXT + GLenum mode + const GLfloat *m + + + void glMatrixMultdEXT + GLenum mode + const GLdouble *m + + + void glMatrixMultfEXT + GLenum mode + const GLfloat *m + + + void glMatrixOrthoEXT + GLenum mode + GLdouble left + GLdouble right + GLdouble bottom + GLdouble top + GLdouble zNear + GLdouble zFar + + + void glMatrixPopEXT + GLenum mode + + + void glMatrixPushEXT + GLenum mode + + + void glMatrixRotatedEXT + GLenum mode + GLdouble angle + GLdouble x + GLdouble y + GLdouble z + + + void glMatrixRotatefEXT + GLenum mode + GLfloat angle + GLfloat x + GLfloat y + GLfloat z + + + void glMatrixScaledEXT + GLenum mode + GLdouble x + GLdouble y + GLdouble z + + + void glMatrixScalefEXT + GLenum mode + GLfloat x + GLfloat y + GLfloat z + + + void glMatrixTranslatedEXT + GLenum mode + GLdouble x + GLdouble y + GLdouble z + + + void glMatrixTranslatefEXT + GLenum mode + GLfloat x + GLfloat y + GLfloat z + + + void glMemoryBarrier + GLbitfield barriers + + + void glMemoryBarrierByRegion + GLbitfield barriers + + + void glMemoryBarrierEXT + GLbitfield barriers + + + + void glMinSampleShading + GLfloat value + + + void glMinSampleShadingARB + GLfloat value + + + + void glMinSampleShadingOES + GLfloat value + + + + void glMinmax + GLenum target + GLenum internalformat + GLboolean sink + + + + void glMinmaxEXT + GLenum target + GLenum internalformat + GLboolean sink + + + + + void glMultMatrixd + const GLdouble *m + + + + void glMultMatrixf + const GLfloat *m + + + + void glMultMatrixx + const GLfixed *m + + + void glMultMatrixxOES + const GLfixed *m + + + void glMultTransposeMatrixd + const GLdouble *m + + + void glMultTransposeMatrixdARB + const GLdouble *m + + + + void glMultTransposeMatrixf + const GLfloat *m + + + void glMultTransposeMatrixfARB + const GLfloat *m + + + + void glMultTransposeMatrixxOES + const GLfixed *m + + + void glMultiDrawArrays + GLenum mode + const GLint *first + const GLsizei *count + GLsizei drawcount + + + void glMultiDrawArraysEXT + GLenum mode + const GLint *first + const GLsizei *count + GLsizei primcount + + + + void glMultiDrawArraysIndirect + GLenum mode + const void *indirect + GLsizei drawcount + GLsizei stride + + + void glMultiDrawArraysIndirectAMD + GLenum mode + const void *indirect + GLsizei primcount + GLsizei stride + + + + void glMultiDrawArraysIndirectBindlessCountNV + GLenum mode + const void *indirect + GLsizei drawCount + GLsizei maxDrawCount + GLsizei stride + GLint vertexBufferCount + + + void glMultiDrawArraysIndirectBindlessNV + GLenum mode + const void *indirect + GLsizei drawCount + GLsizei stride + GLint vertexBufferCount + + + void glMultiDrawArraysIndirectCountARB + GLenum mode + GLintptr indirect + GLintptr drawcount + GLsizei maxdrawcount + GLsizei stride + + + void glMultiDrawElementArrayAPPLE + GLenum mode + const GLint *first + const GLsizei *count + GLsizei primcount + + + void glMultiDrawElements + GLenum mode + const GLsizei *count + GLenum type + const void *const*indices + GLsizei drawcount + + + void glMultiDrawElementsBaseVertex + GLenum mode + const GLsizei *count + GLenum type + const void *const*indices + GLsizei drawcount + const GLint *basevertex + + + void glMultiDrawElementsEXT + GLenum mode + const GLsizei *count + GLenum type + const void *const*indices + GLsizei primcount + + + + void glMultiDrawElementsIndirect + GLenum mode + GLenum type + const void *indirect + GLsizei drawcount + GLsizei stride + + + void glMultiDrawElementsIndirectAMD + GLenum mode + GLenum type + const void *indirect + GLsizei primcount + GLsizei stride + + + + void glMultiDrawElementsIndirectBindlessCountNV + GLenum mode + GLenum type + const void *indirect + GLsizei drawCount + GLsizei maxDrawCount + GLsizei stride + GLint vertexBufferCount + + + void glMultiDrawElementsIndirectBindlessNV + GLenum mode + GLenum type + const void *indirect + GLsizei drawCount + GLsizei stride + GLint vertexBufferCount + + + void glMultiDrawElementsIndirectCountARB + GLenum mode + GLenum type + GLintptr indirect + GLintptr drawcount + GLsizei maxdrawcount + GLsizei stride + + + void glMultiDrawRangeElementArrayAPPLE + GLenum mode + GLuint start + GLuint end + const GLint *first + const GLsizei *count + GLsizei primcount + + + void glMultiModeDrawArraysIBM + const GLenum *mode + const GLint *first + const GLsizei *count + GLsizei primcount + GLint modestride + + + void glMultiModeDrawElementsIBM + const GLenum *mode + const GLsizei *count + GLenum type + const void *const*indices + GLsizei primcount + GLint modestride + + + void glMultiTexBufferEXT + GLenum texunit + GLenum target + GLenum internalformat + GLuint buffer + + + void glMultiTexCoord1bOES + GLenum texture + GLbyte s + + + void glMultiTexCoord1bvOES + GLenum texture + const GLbyte *coords + + + void glMultiTexCoord1d + GLenum target + GLdouble s + + + + void glMultiTexCoord1dARB + GLenum target + GLdouble s + + + + + void glMultiTexCoord1dv + GLenum target + const GLdouble *v + + + + void glMultiTexCoord1dvARB + GLenum target + const GLdouble *v + + + + + void glMultiTexCoord1f + GLenum target + GLfloat s + + + + void glMultiTexCoord1fARB + GLenum target + GLfloat s + + + + + void glMultiTexCoord1fv + GLenum target + const GLfloat *v + + + + void glMultiTexCoord1fvARB + GLenum target + const GLfloat *v + + + + + void glMultiTexCoord1hNV + GLenum target + GLhalfNV s + + + + void glMultiTexCoord1hvNV + GLenum target + const GLhalfNV *v + + + + void glMultiTexCoord1i + GLenum target + GLint s + + + + void glMultiTexCoord1iARB + GLenum target + GLint s + + + + + void glMultiTexCoord1iv + GLenum target + const GLint *v + + + + void glMultiTexCoord1ivARB + GLenum target + const GLint *v + + + + + void glMultiTexCoord1s + GLenum target + GLshort s + + + + void glMultiTexCoord1sARB + GLenum target + GLshort s + + + + + void glMultiTexCoord1sv + GLenum target + const GLshort *v + + + + void glMultiTexCoord1svARB + GLenum target + const GLshort *v + + + + + void glMultiTexCoord1xOES + GLenum texture + GLfixed s + + + void glMultiTexCoord1xvOES + GLenum texture + const GLfixed *coords + + + void glMultiTexCoord2bOES + GLenum texture + GLbyte s + GLbyte t + + + void glMultiTexCoord2bvOES + GLenum texture + const GLbyte *coords + + + void glMultiTexCoord2d + GLenum target + GLdouble s + GLdouble t + + + + void glMultiTexCoord2dARB + GLenum target + GLdouble s + GLdouble t + + + + + void glMultiTexCoord2dv + GLenum target + const GLdouble *v + + + + void glMultiTexCoord2dvARB + GLenum target + const GLdouble *v + + + + + void glMultiTexCoord2f + GLenum target + GLfloat s + GLfloat t + + + + void glMultiTexCoord2fARB + GLenum target + GLfloat s + GLfloat t + + + + + void glMultiTexCoord2fv + GLenum target + const GLfloat *v + + + + void glMultiTexCoord2fvARB + GLenum target + const GLfloat *v + + + + + void glMultiTexCoord2hNV + GLenum target + GLhalfNV s + GLhalfNV t + + + + void glMultiTexCoord2hvNV + GLenum target + const GLhalfNV *v + + + + void glMultiTexCoord2i + GLenum target + GLint s + GLint t + + + + void glMultiTexCoord2iARB + GLenum target + GLint s + GLint t + + + + + void glMultiTexCoord2iv + GLenum target + const GLint *v + + + + void glMultiTexCoord2ivARB + GLenum target + const GLint *v + + + + + void glMultiTexCoord2s + GLenum target + GLshort s + GLshort t + + + + void glMultiTexCoord2sARB + GLenum target + GLshort s + GLshort t + + + + + void glMultiTexCoord2sv + GLenum target + const GLshort *v + + + + void glMultiTexCoord2svARB + GLenum target + const GLshort *v + + + + + void glMultiTexCoord2xOES + GLenum texture + GLfixed s + GLfixed t + + + void glMultiTexCoord2xvOES + GLenum texture + const GLfixed *coords + + + void glMultiTexCoord3bOES + GLenum texture + GLbyte s + GLbyte t + GLbyte r + + + void glMultiTexCoord3bvOES + GLenum texture + const GLbyte *coords + + + void glMultiTexCoord3d + GLenum target + GLdouble s + GLdouble t + GLdouble r + + + + void glMultiTexCoord3dARB + GLenum target + GLdouble s + GLdouble t + GLdouble r + + + + + void glMultiTexCoord3dv + GLenum target + const GLdouble *v + + + + void glMultiTexCoord3dvARB + GLenum target + const GLdouble *v + + + + + void glMultiTexCoord3f + GLenum target + GLfloat s + GLfloat t + GLfloat r + + + + void glMultiTexCoord3fARB + GLenum target + GLfloat s + GLfloat t + GLfloat r + + + + + void glMultiTexCoord3fv + GLenum target + const GLfloat *v + + + + void glMultiTexCoord3fvARB + GLenum target + const GLfloat *v + + + + + void glMultiTexCoord3hNV + GLenum target + GLhalfNV s + GLhalfNV t + GLhalfNV r + + + + void glMultiTexCoord3hvNV + GLenum target + const GLhalfNV *v + + + + void glMultiTexCoord3i + GLenum target + GLint s + GLint t + GLint r + + + + void glMultiTexCoord3iARB + GLenum target + GLint s + GLint t + GLint r + + + + + void glMultiTexCoord3iv + GLenum target + const GLint *v + + + + void glMultiTexCoord3ivARB + GLenum target + const GLint *v + + + + + void glMultiTexCoord3s + GLenum target + GLshort s + GLshort t + GLshort r + + + + void glMultiTexCoord3sARB + GLenum target + GLshort s + GLshort t + GLshort r + + + + + void glMultiTexCoord3sv + GLenum target + const GLshort *v + + + + void glMultiTexCoord3svARB + GLenum target + const GLshort *v + + + + + void glMultiTexCoord3xOES + GLenum texture + GLfixed s + GLfixed t + GLfixed r + + + void glMultiTexCoord3xvOES + GLenum texture + const GLfixed *coords + + + void glMultiTexCoord4bOES + GLenum texture + GLbyte s + GLbyte t + GLbyte r + GLbyte q + + + void glMultiTexCoord4bvOES + GLenum texture + const GLbyte *coords + + + void glMultiTexCoord4d + GLenum target + GLdouble s + GLdouble t + GLdouble r + GLdouble q + + + + void glMultiTexCoord4dARB + GLenum target + GLdouble s + GLdouble t + GLdouble r + GLdouble q + + + + + void glMultiTexCoord4dv + GLenum target + const GLdouble *v + + + + void glMultiTexCoord4dvARB + GLenum target + const GLdouble *v + + + + + void glMultiTexCoord4f + GLenum target + GLfloat s + GLfloat t + GLfloat r + GLfloat q + + + + void glMultiTexCoord4fARB + GLenum target + GLfloat s + GLfloat t + GLfloat r + GLfloat q + + + + + void glMultiTexCoord4fv + GLenum target + const GLfloat *v + + + + void glMultiTexCoord4fvARB + GLenum target + const GLfloat *v + + + + + void glMultiTexCoord4hNV + GLenum target + GLhalfNV s + GLhalfNV t + GLhalfNV r + GLhalfNV q + + + + void glMultiTexCoord4hvNV + GLenum target + const GLhalfNV *v + + + + void glMultiTexCoord4i + GLenum target + GLint s + GLint t + GLint r + GLint q + + + + void glMultiTexCoord4iARB + GLenum target + GLint s + GLint t + GLint r + GLint q + + + + + void glMultiTexCoord4iv + GLenum target + const GLint *v + + + + void glMultiTexCoord4ivARB + GLenum target + const GLint *v + + + + + void glMultiTexCoord4s + GLenum target + GLshort s + GLshort t + GLshort r + GLshort q + + + + void glMultiTexCoord4sARB + GLenum target + GLshort s + GLshort t + GLshort r + GLshort q + + + + + void glMultiTexCoord4sv + GLenum target + const GLshort *v + + + + void glMultiTexCoord4svARB + GLenum target + const GLshort *v + + + + + void glMultiTexCoord4x + GLenum texture + GLfixed s + GLfixed t + GLfixed r + GLfixed q + + + void glMultiTexCoord4xOES + GLenum texture + GLfixed s + GLfixed t + GLfixed r + GLfixed q + + + void glMultiTexCoord4xvOES + GLenum texture + const GLfixed *coords + + + void glMultiTexCoordP1ui + GLenum texture + GLenum type + GLuint coords + + + void glMultiTexCoordP1uiv + GLenum texture + GLenum type + const GLuint *coords + + + void glMultiTexCoordP2ui + GLenum texture + GLenum type + GLuint coords + + + void glMultiTexCoordP2uiv + GLenum texture + GLenum type + const GLuint *coords + + + void glMultiTexCoordP3ui + GLenum texture + GLenum type + GLuint coords + + + void glMultiTexCoordP3uiv + GLenum texture + GLenum type + const GLuint *coords + + + void glMultiTexCoordP4ui + GLenum texture + GLenum type + GLuint coords + + + void glMultiTexCoordP4uiv + GLenum texture + GLenum type + const GLuint *coords + + + void glMultiTexCoordPointerEXT + GLenum texunit + GLint size + GLenum type + GLsizei stride + const void *pointer + + + void glMultiTexEnvfEXT + GLenum texunit + GLenum target + GLenum pname + GLfloat param + + + + void glMultiTexEnvfvEXT + GLenum texunit + GLenum target + GLenum pname + const GLfloat *params + + + void glMultiTexEnviEXT + GLenum texunit + GLenum target + GLenum pname + GLint param + + + + void glMultiTexEnvivEXT + GLenum texunit + GLenum target + GLenum pname + const GLint *params + + + void glMultiTexGendEXT + GLenum texunit + GLenum coord + GLenum pname + GLdouble param + + + + void glMultiTexGendvEXT + GLenum texunit + GLenum coord + GLenum pname + const GLdouble *params + + + void glMultiTexGenfEXT + GLenum texunit + GLenum coord + GLenum pname + GLfloat param + + + + void glMultiTexGenfvEXT + GLenum texunit + GLenum coord + GLenum pname + const GLfloat *params + + + void glMultiTexGeniEXT + GLenum texunit + GLenum coord + GLenum pname + GLint param + + + + void glMultiTexGenivEXT + GLenum texunit + GLenum coord + GLenum pname + const GLint *params + + + void glMultiTexImage1DEXT + GLenum texunit + GLenum target + GLint level + GLint internalformat + GLsizei width + GLint border + GLenum format + GLenum type + const void *pixels + + + void glMultiTexImage2DEXT + GLenum texunit + GLenum target + GLint level + GLint internalformat + GLsizei width + GLsizei height + GLint border + GLenum format + GLenum type + const void *pixels + + + void glMultiTexImage3DEXT + GLenum texunit + GLenum target + GLint level + GLint internalformat + GLsizei width + GLsizei height + GLsizei depth + GLint border + GLenum format + GLenum type + const void *pixels + + + void glMultiTexParameterIivEXT + GLenum texunit + GLenum target + GLenum pname + const GLint *params + + + void glMultiTexParameterIuivEXT + GLenum texunit + GLenum target + GLenum pname + const GLuint *params + + + void glMultiTexParameterfEXT + GLenum texunit + GLenum target + GLenum pname + GLfloat param + + + + void glMultiTexParameterfvEXT + GLenum texunit + GLenum target + GLenum pname + const GLfloat *params + + + void glMultiTexParameteriEXT + GLenum texunit + GLenum target + GLenum pname + GLint param + + + + void glMultiTexParameterivEXT + GLenum texunit + GLenum target + GLenum pname + const GLint *params + + + void glMultiTexRenderbufferEXT + GLenum texunit + GLenum target + GLuint renderbuffer + + + void glMultiTexSubImage1DEXT + GLenum texunit + GLenum target + GLint level + GLint xoffset + GLsizei width + GLenum format + GLenum type + const void *pixels + + + void glMultiTexSubImage2DEXT + GLenum texunit + GLenum target + GLint level + GLint xoffset + GLint yoffset + GLsizei width + GLsizei height + GLenum format + GLenum type + const void *pixels + + + void glMultiTexSubImage3DEXT + GLenum texunit + GLenum target + GLint level + GLint xoffset + GLint yoffset + GLint zoffset + GLsizei width + GLsizei height + GLsizei depth + GLenum format + GLenum type + const void *pixels + + + void glNamedBufferData + GLuint buffer + GLsizei size + const void *data + GLenum usage + + + void glNamedBufferDataEXT + GLuint buffer + GLsizeiptr size + const void *data + GLenum usage + + + void glNamedBufferPageCommitmentARB + GLuint buffer + GLintptr offset + GLsizei size + GLboolean commit + + + void glNamedBufferPageCommitmentEXT + GLuint buffer + GLintptr offset + GLsizei size + GLboolean commit + + + void glNamedBufferStorage + GLuint buffer + GLsizei size + const void *data + GLbitfield flags + + + void glNamedBufferStorageEXT + GLuint buffer + GLsizeiptr size + const void *data + GLbitfield flags + + + void glNamedBufferSubData + GLuint buffer + GLintptr offset + GLsizei size + const void *data + + + void glNamedBufferSubDataEXT + GLuint buffer + GLintptr offset + GLsizeiptr size + const void *data + + + void glNamedCopyBufferSubDataEXT + GLuint readBuffer + GLuint writeBuffer + GLintptr readOffset + GLintptr writeOffset + GLsizeiptr size + + + void glNamedFramebufferDrawBuffer + GLuint framebuffer + GLenum buf + + + void glNamedFramebufferDrawBuffers + GLuint framebuffer + GLsizei n + const GLenum *bufs + + + void glNamedFramebufferParameteri + GLuint framebuffer + GLenum pname + GLint param + + + void glNamedFramebufferParameteriEXT + GLuint framebuffer + GLenum pname + GLint param + + + void glNamedFramebufferReadBuffer + GLuint framebuffer + GLenum src + + + void glNamedFramebufferRenderbuffer + GLuint framebuffer + GLenum attachment + GLenum renderbuffertarget + GLuint renderbuffer + + + void glNamedFramebufferRenderbufferEXT + GLuint framebuffer + GLenum attachment + GLenum renderbuffertarget + GLuint renderbuffer + + + void glNamedFramebufferTexture + GLuint framebuffer + GLenum attachment + GLuint texture + GLint level + + + void glNamedFramebufferTexture1DEXT + GLuint framebuffer + GLenum attachment + GLenum textarget + GLuint texture + GLint level + + + void glNamedFramebufferTexture2DEXT + GLuint framebuffer + GLenum attachment + GLenum textarget + GLuint texture + GLint level + + + void glNamedFramebufferTexture3DEXT + GLuint framebuffer + GLenum attachment + GLenum textarget + GLuint texture + GLint level + GLint zoffset + + + void glNamedFramebufferTextureEXT + GLuint framebuffer + GLenum attachment + GLuint texture + GLint level + + + void glNamedFramebufferTextureFaceEXT + GLuint framebuffer + GLenum attachment + GLuint texture + GLint level + GLenum face + + + void glNamedFramebufferTextureLayer + GLuint framebuffer + GLenum attachment + GLuint texture + GLint level + GLint layer + + + void glNamedFramebufferTextureLayerEXT + GLuint framebuffer + GLenum attachment + GLuint texture + GLint level + GLint layer + + + void glNamedProgramLocalParameter4dEXT + GLuint program + GLenum target + GLuint index + GLdouble x + GLdouble y + GLdouble z + GLdouble w + + + + void glNamedProgramLocalParameter4dvEXT + GLuint program + GLenum target + GLuint index + const GLdouble *params + + + void glNamedProgramLocalParameter4fEXT + GLuint program + GLenum target + GLuint index + GLfloat x + GLfloat y + GLfloat z + GLfloat w + + + + void glNamedProgramLocalParameter4fvEXT + GLuint program + GLenum target + GLuint index + const GLfloat *params + + + void glNamedProgramLocalParameterI4iEXT + GLuint program + GLenum target + GLuint index + GLint x + GLint y + GLint z + GLint w + + + + void glNamedProgramLocalParameterI4ivEXT + GLuint program + GLenum target + GLuint index + const GLint *params + + + void glNamedProgramLocalParameterI4uiEXT + GLuint program + GLenum target + GLuint index + GLuint x + GLuint y + GLuint z + GLuint w + + + + void glNamedProgramLocalParameterI4uivEXT + GLuint program + GLenum target + GLuint index + const GLuint *params + + + void glNamedProgramLocalParameters4fvEXT + GLuint program + GLenum target + GLuint index + GLsizei count + const GLfloat *params + + + void glNamedProgramLocalParametersI4ivEXT + GLuint program + GLenum target + GLuint index + GLsizei count + const GLint *params + + + void glNamedProgramLocalParametersI4uivEXT + GLuint program + GLenum target + GLuint index + GLsizei count + const GLuint *params + + + void glNamedProgramStringEXT + GLuint program + GLenum target + GLenum format + GLsizei len + const void *string + + + void glNamedRenderbufferStorage + GLuint renderbuffer + GLenum internalformat + GLsizei width + GLsizei height + + + void glNamedRenderbufferStorageEXT + GLuint renderbuffer + GLenum internalformat + GLsizei width + GLsizei height + + + void glNamedRenderbufferStorageMultisample + GLuint renderbuffer + GLsizei samples + GLenum internalformat + GLsizei width + GLsizei height + + + void glNamedRenderbufferStorageMultisampleCoverageEXT + GLuint renderbuffer + GLsizei coverageSamples + GLsizei colorSamples + GLenum internalformat + GLsizei width + GLsizei height + + + void glNamedRenderbufferStorageMultisampleEXT + GLuint renderbuffer + GLsizei samples + GLenum internalformat + GLsizei width + GLsizei height + + + void glNamedStringARB + GLenum type + GLint namelen + const GLchar *name + GLint stringlen + const GLchar *string + + + void glNewList + GLuint list + GLenum mode + + + + GLuint glNewObjectBufferATI + GLsizei size + const void *pointer + GLenum usage + + + void glNormal3b + GLbyte nx + GLbyte ny + GLbyte nz + + + + void glNormal3bv + const GLbyte *v + + + + void glNormal3d + GLdouble nx + GLdouble ny + GLdouble nz + + + + void glNormal3dv + const GLdouble *v + + + + void glNormal3f + GLfloat nx + GLfloat ny + GLfloat nz + + + + void glNormal3fVertex3fSUN + GLfloat nx + GLfloat ny + GLfloat nz + GLfloat x + GLfloat y + GLfloat z + + + void glNormal3fVertex3fvSUN + const GLfloat *n + const GLfloat *v + + + void glNormal3fv + const GLfloat *v + + + + void glNormal3hNV + GLhalfNV nx + GLhalfNV ny + GLhalfNV nz + + + + void glNormal3hvNV + const GLhalfNV *v + + + + void glNormal3i + GLint nx + GLint ny + GLint nz + + + + void glNormal3iv + const GLint *v + + + + void glNormal3s + GLshort nx + GLshort ny + GLshort nz + + + + void glNormal3sv + const GLshort *v + + + + void glNormal3x + GLfixed nx + GLfixed ny + GLfixed nz + + + void glNormal3xOES + GLfixed nx + GLfixed ny + GLfixed nz + + + void glNormal3xvOES + const GLfixed *coords + + + void glNormalFormatNV + GLenum type + GLsizei stride + + + void glNormalP3ui + GLenum type + GLuint coords + + + void glNormalP3uiv + GLenum type + const GLuint *coords + + + void glNormalPointer + GLenum type + GLsizei stride + const void *pointer + + + void glNormalPointerEXT + GLenum type + GLsizei stride + GLsizei count + const void *pointer + + + void glNormalPointerListIBM + GLenum type + GLint stride + const void **pointer + GLint ptrstride + + + void glNormalPointervINTEL + GLenum type + const void **pointer + + + void glNormalStream3bATI + GLenum stream + GLbyte nx + GLbyte ny + GLbyte nz + + + void glNormalStream3bvATI + GLenum stream + const GLbyte *coords + + + void glNormalStream3dATI + GLenum stream + GLdouble nx + GLdouble ny + GLdouble nz + + + void glNormalStream3dvATI + GLenum stream + const GLdouble *coords + + + void glNormalStream3fATI + GLenum stream + GLfloat nx + GLfloat ny + GLfloat nz + + + void glNormalStream3fvATI + GLenum stream + const GLfloat *coords + + + void glNormalStream3iATI + GLenum stream + GLint nx + GLint ny + GLint nz + + + void glNormalStream3ivATI + GLenum stream + const GLint *coords + + + void glNormalStream3sATI + GLenum stream + GLshort nx + GLshort ny + GLshort nz + + + void glNormalStream3svATI + GLenum stream + const GLshort *coords + + + void glObjectLabel + GLenum identifier + GLuint name + GLsizei length + const GLchar *label + + + void glObjectLabelKHR + GLenum identifier + GLuint name + GLsizei length + const GLchar *label + + + + void glObjectPtrLabel + const void *ptr + GLsizei length + const GLchar *label + + + void glObjectPtrLabelKHR + const void *ptr + GLsizei length + const GLchar *label + + + + GLenum glObjectPurgeableAPPLE + GLenum objectType + GLuint name + GLenum option + + + GLenum glObjectUnpurgeableAPPLE + GLenum objectType + GLuint name + GLenum option + + + void glOrtho + GLdouble left + GLdouble right + GLdouble bottom + GLdouble top + GLdouble zNear + GLdouble zFar + + + + void glOrthof + GLfloat l + GLfloat r + GLfloat b + GLfloat t + GLfloat n + GLfloat f + + + void glOrthofOES + GLfloat l + GLfloat r + GLfloat b + GLfloat t + GLfloat n + GLfloat f + + + + void glOrthox + GLfixed l + GLfixed r + GLfixed b + GLfixed t + GLfixed n + GLfixed f + + + void glOrthoxOES + GLfixed l + GLfixed r + GLfixed b + GLfixed t + GLfixed n + GLfixed f + + + void glPNTrianglesfATI + GLenum pname + GLfloat param + + + void glPNTrianglesiATI + GLenum pname + GLint param + + + void glPassTexCoordATI + GLuint dst + GLuint coord + GLenum swizzle + + + void glPassThrough + GLfloat token + + + + void glPassThroughxOES + GLfixed token + + + void glPatchParameterfv + GLenum pname + const GLfloat *values + + + void glPatchParameteri + GLenum pname + GLint value + + + void glPatchParameteriEXT + GLenum pname + GLint value + + + + void glPathColorGenNV + GLenum color + GLenum genMode + GLenum colorFormat + const GLfloat *coeffs + + + void glPathCommandsNV + GLuint path + GLsizei numCommands + const GLubyte *commands + GLsizei numCoords + GLenum coordType + const void *coords + + + void glPathCoordsNV + GLuint path + GLsizei numCoords + GLenum coordType + const void *coords + + + void glPathCoverDepthFuncNV + GLenum func + + + void glPathDashArrayNV + GLuint path + GLsizei dashCount + const GLfloat *dashArray + + + void glPathFogGenNV + GLenum genMode + + + GLenum glPathGlyphIndexArrayNV + GLuint firstPathName + GLenum fontTarget + const void *fontName + GLbitfield fontStyle + GLuint firstGlyphIndex + GLsizei numGlyphs + GLuint pathParameterTemplate + GLfloat emScale + + + GLenum glPathGlyphIndexRangeNV + GLenum fontTarget + const void *fontName + GLbitfield fontStyle + GLuint pathParameterTemplate + GLfloat emScale + GLuint baseAndCount[2] + + + void glPathGlyphRangeNV + GLuint firstPathName + GLenum fontTarget + const void *fontName + GLbitfield fontStyle + GLuint firstGlyph + GLsizei numGlyphs + GLenum handleMissingGlyphs + GLuint pathParameterTemplate + GLfloat emScale + + + void glPathGlyphsNV + GLuint firstPathName + GLenum fontTarget + const void *fontName + GLbitfield fontStyle + GLsizei numGlyphs + GLenum type + const void *charcodes + GLenum handleMissingGlyphs + GLuint pathParameterTemplate + GLfloat emScale + + + GLenum glPathMemoryGlyphIndexArrayNV + GLuint firstPathName + GLenum fontTarget + GLsizeiptr fontSize + const void *fontData + GLsizei faceIndex + GLuint firstGlyphIndex + GLsizei numGlyphs + GLuint pathParameterTemplate + GLfloat emScale + + + void glPathParameterfNV + GLuint path + GLenum pname + GLfloat value + + + void glPathParameterfvNV + GLuint path + GLenum pname + const GLfloat *value + + + void glPathParameteriNV + GLuint path + GLenum pname + GLint value + + + void glPathParameterivNV + GLuint path + GLenum pname + const GLint *value + + + void glPathStencilDepthOffsetNV + GLfloat factor + GLfloat units + + + void glPathStencilFuncNV + GLenum func + GLint ref + GLuint mask + + + void glPathStringNV + GLuint path + GLenum format + GLsizei length + const void *pathString + + + void glPathSubCommandsNV + GLuint path + GLsizei commandStart + GLsizei commandsToDelete + GLsizei numCommands + const GLubyte *commands + GLsizei numCoords + GLenum coordType + const void *coords + + + void glPathSubCoordsNV + GLuint path + GLsizei coordStart + GLsizei numCoords + GLenum coordType + const void *coords + + + void glPathTexGenNV + GLenum texCoordSet + GLenum genMode + GLint components + const GLfloat *coeffs + + + void glPauseTransformFeedback + + + void glPauseTransformFeedbackNV + + + + void glPixelDataRangeNV + GLenum target + GLsizei length + const void *pointer + + + void glPixelMapfv + GLenum map + GLsizei mapsize + const GLfloat *values + + + + + void glPixelMapuiv + GLenum map + GLsizei mapsize + const GLuint *values + + + + + void glPixelMapusv + GLenum map + GLsizei mapsize + const GLushort *values + + + + + void glPixelMapx + GLenum map + GLint size + const GLfixed *values + + + void glPixelStoref + GLenum pname + GLfloat param + + + + void glPixelStorei + GLenum pname + GLint param + + + + void glPixelStorex + GLenum pname + GLfixed param + + + void glPixelTexGenParameterfSGIS + GLenum pname + GLfloat param + + + void glPixelTexGenParameterfvSGIS + GLenum pname + const GLfloat *params + + + void glPixelTexGenParameteriSGIS + GLenum pname + GLint param + + + void glPixelTexGenParameterivSGIS + GLenum pname + const GLint *params + + + void glPixelTexGenSGIX + GLenum mode + + + + void glPixelTransferf + GLenum pname + GLfloat param + + + + void glPixelTransferi + GLenum pname + GLint param + + + + void glPixelTransferxOES + GLenum pname + GLfixed param + + + void glPixelTransformParameterfEXT + GLenum target + GLenum pname + GLfloat param + + + + void glPixelTransformParameterfvEXT + GLenum target + GLenum pname + const GLfloat *params + + + void glPixelTransformParameteriEXT + GLenum target + GLenum pname + GLint param + + + + void glPixelTransformParameterivEXT + GLenum target + GLenum pname + const GLint *params + + + void glPixelZoom + GLfloat xfactor + GLfloat yfactor + + + + void glPixelZoomxOES + GLfixed xfactor + GLfixed yfactor + + + GLboolean glPointAlongPathNV + GLuint path + GLsizei startSegment + GLsizei numSegments + GLfloat distance + GLfloat *x + GLfloat *y + GLfloat *tangentX + GLfloat *tangentY + + + void glPointParameterf + GLenum pname + GLfloat param + + + + void glPointParameterfARB + GLenum pname + GLfloat param + + + + + void glPointParameterfEXT + GLenum pname + GLfloat param + + + + void glPointParameterfSGIS + GLenum pname + GLfloat param + + + + void glPointParameterfv + GLenum pname + const GLfloat *params + + + + void glPointParameterfvARB + GLenum pname + const GLfloat *params + + + + + void glPointParameterfvEXT + GLenum pname + const GLfloat *params + + + + void glPointParameterfvSGIS + GLenum pname + const GLfloat *params + + + + void glPointParameteri + GLenum pname + GLint param + + + + void glPointParameteriNV + GLenum pname + GLint param + + + + + void glPointParameteriv + GLenum pname + const GLint *params + + + + void glPointParameterivNV + GLenum pname + const GLint *params + + + + + void glPointParameterx + GLenum pname + GLfixed param + + + void glPointParameterxOES + GLenum pname + GLfixed param + + + void glPointParameterxv + GLenum pname + const GLfixed *params + + + void glPointParameterxvOES + GLenum pname + const GLfixed *params + + + void glPointSize + GLfloat size + + + + void glPointSizePointerOES + GLenum type + GLsizei stride + const void *pointer + + + void glPointSizex + GLfixed size + + + void glPointSizexOES + GLfixed size + + + GLint glPollAsyncSGIX + GLuint *markerp + + + GLint glPollInstrumentsSGIX + GLint *marker_p + + + + void glPolygonMode + GLenum face + GLenum mode + + + + void glPolygonOffset + GLfloat factor + GLfloat units + + + + void glPolygonOffsetEXT + GLfloat factor + GLfloat bias + + + + void glPolygonOffsetx + GLfixed factor + GLfixed units + + + void glPolygonOffsetxOES + GLfixed factor + GLfixed units + + + void glPolygonStipple + const GLubyte *mask + + + + + void glPopAttrib + + + + void glPopClientAttrib + + + void glPopDebugGroup + + + void glPopDebugGroupKHR + + + + void glPopGroupMarkerEXT + + + void glPopMatrix + + + + void glPopName + + + + void glPresentFrameDualFillNV + GLuint video_slot + GLuint64EXT minPresentTime + GLuint beginPresentTimeId + GLuint presentDurationId + GLenum type + GLenum target0 + GLuint fill0 + GLenum target1 + GLuint fill1 + GLenum target2 + GLuint fill2 + GLenum target3 + GLuint fill3 + + + void glPresentFrameKeyedNV + GLuint video_slot + GLuint64EXT minPresentTime + GLuint beginPresentTimeId + GLuint presentDurationId + GLenum type + GLenum target0 + GLuint fill0 + GLuint key0 + GLenum target1 + GLuint fill1 + GLuint key1 + + + void glPrimitiveBoundingBoxEXT + GLfloat minX + GLfloat minY + GLfloat minZ + GLfloat minW + GLfloat maxX + GLfloat maxY + GLfloat maxZ + GLfloat maxW + + + void glPrimitiveRestartIndex + GLuint index + + + void glPrimitiveRestartIndexNV + GLuint index + + + void glPrimitiveRestartNV + + + void glPrioritizeTextures + GLsizei n + const GLuint *textures + const GLfloat *priorities + + + + void glPrioritizeTexturesEXT + GLsizei n + const GLuint *textures + const GLclampf *priorities + + + + + void glPrioritizeTexturesxOES + GLsizei n + const GLuint *textures + const GLfixed *priorities + + + void glProgramBinary + GLuint program + GLenum binaryFormat + const void *binary + GLsizei length + + + void glProgramBinaryOES + GLuint program + GLenum binaryFormat + const void *binary + GLint length + + + + void glProgramBufferParametersIivNV + GLenum target + GLuint bindingIndex + GLuint wordIndex + GLsizei count + const GLint *params + + + void glProgramBufferParametersIuivNV + GLenum target + GLuint bindingIndex + GLuint wordIndex + GLsizei count + const GLuint *params + + + void glProgramBufferParametersfvNV + GLenum target + GLuint bindingIndex + GLuint wordIndex + GLsizei count + const GLfloat *params + + + void glProgramEnvParameter4dARB + GLenum target + GLuint index + GLdouble x + GLdouble y + GLdouble z + GLdouble w + + + + void glProgramEnvParameter4dvARB + GLenum target + GLuint index + const GLdouble *params + + + void glProgramEnvParameter4fARB + GLenum target + GLuint index + GLfloat x + GLfloat y + GLfloat z + GLfloat w + + + + void glProgramEnvParameter4fvARB + GLenum target + GLuint index + const GLfloat *params + + + void glProgramEnvParameterI4iNV + GLenum target + GLuint index + GLint x + GLint y + GLint z + GLint w + + + + void glProgramEnvParameterI4ivNV + GLenum target + GLuint index + const GLint *params + + + void glProgramEnvParameterI4uiNV + GLenum target + GLuint index + GLuint x + GLuint y + GLuint z + GLuint w + + + + void glProgramEnvParameterI4uivNV + GLenum target + GLuint index + const GLuint *params + + + void glProgramEnvParameters4fvEXT + GLenum target + GLuint index + GLsizei count + const GLfloat *params + + + + void glProgramEnvParametersI4ivNV + GLenum target + GLuint index + GLsizei count + const GLint *params + + + void glProgramEnvParametersI4uivNV + GLenum target + GLuint index + GLsizei count + const GLuint *params + + + void glProgramLocalParameter4dARB + GLenum target + GLuint index + GLdouble x + GLdouble y + GLdouble z + GLdouble w + + + + void glProgramLocalParameter4dvARB + GLenum target + GLuint index + const GLdouble *params + + + void glProgramLocalParameter4fARB + GLenum target + GLuint index + GLfloat x + GLfloat y + GLfloat z + GLfloat w + + + + void glProgramLocalParameter4fvARB + GLenum target + GLuint index + const GLfloat *params + + + void glProgramLocalParameterI4iNV + GLenum target + GLuint index + GLint x + GLint y + GLint z + GLint w + + + + void glProgramLocalParameterI4ivNV + GLenum target + GLuint index + const GLint *params + + + void glProgramLocalParameterI4uiNV + GLenum target + GLuint index + GLuint x + GLuint y + GLuint z + GLuint w + + + + void glProgramLocalParameterI4uivNV + GLenum target + GLuint index + const GLuint *params + + + void glProgramLocalParameters4fvEXT + GLenum target + GLuint index + GLsizei count + const GLfloat *params + + + + void glProgramLocalParametersI4ivNV + GLenum target + GLuint index + GLsizei count + const GLint *params + + + void glProgramLocalParametersI4uivNV + GLenum target + GLuint index + GLsizei count + const GLuint *params + + + void glProgramNamedParameter4dNV + GLuint id + GLsizei len + const GLubyte *name + GLdouble x + GLdouble y + GLdouble z + GLdouble w + + + + void glProgramNamedParameter4dvNV + GLuint id + GLsizei len + const GLubyte *name + const GLdouble *v + + + + void glProgramNamedParameter4fNV + GLuint id + GLsizei len + const GLubyte *name + GLfloat x + GLfloat y + GLfloat z + GLfloat w + + + + void glProgramNamedParameter4fvNV + GLuint id + GLsizei len + const GLubyte *name + const GLfloat *v + + + + void glProgramParameter4dNV + GLenum target + GLuint index + GLdouble x + GLdouble y + GLdouble z + GLdouble w + + + + void glProgramParameter4dvNV + GLenum target + GLuint index + const GLdouble *v + + + + void glProgramParameter4fNV + GLenum target + GLuint index + GLfloat x + GLfloat y + GLfloat z + GLfloat w + + + + void glProgramParameter4fvNV + GLenum target + GLuint index + const GLfloat *v + + + + void glProgramParameteri + GLuint program + GLenum pname + GLint value + + + void glProgramParameteriARB + GLuint program + GLenum pname + GLint value + + + + void glProgramParameteriEXT + GLuint program + GLenum pname + GLint value + + + + void glProgramParameters4dvNV + GLenum target + GLuint index + GLsizei count + const GLdouble *v + + + + void glProgramParameters4fvNV + GLenum target + GLuint index + GLsizei count + const GLfloat *v + + + + void glProgramPathFragmentInputGenNV + GLuint program + GLint location + GLenum genMode + GLint components + const GLfloat *coeffs + + + void glProgramStringARB + GLenum target + GLenum format + GLsizei len + const void *string + + + void glProgramSubroutineParametersuivNV + GLenum target + GLsizei count + const GLuint *params + + + void glProgramUniform1d + GLuint program + GLint location + GLdouble v0 + + + void glProgramUniform1dEXT + GLuint program + GLint location + GLdouble x + + + void glProgramUniform1dv + GLuint program + GLint location + GLsizei count + const GLdouble *value + + + void glProgramUniform1dvEXT + GLuint program + GLint location + GLsizei count + const GLdouble *value + + + void glProgramUniform1f + GLuint program + GLint location + GLfloat v0 + + + void glProgramUniform1fEXT + GLuint program + GLint location + GLfloat v0 + + + + void glProgramUniform1fv + GLuint program + GLint location + GLsizei count + const GLfloat *value + + + void glProgramUniform1fvEXT + GLuint program + GLint location + GLsizei count + const GLfloat *value + + + + void glProgramUniform1i + GLuint program + GLint location + GLint v0 + + + void glProgramUniform1i64NV + GLuint program + GLint location + GLint64EXT x + + + void glProgramUniform1i64vNV + GLuint program + GLint location + GLsizei count + const GLint64EXT *value + + + void glProgramUniform1iEXT + GLuint program + GLint location + GLint v0 + + + + void glProgramUniform1iv + GLuint program + GLint location + GLsizei count + const GLint *value + + + void glProgramUniform1ivEXT + GLuint program + GLint location + GLsizei count + const GLint *value + + + + void glProgramUniform1ui + GLuint program + GLint location + GLuint v0 + + + void glProgramUniform1ui64NV + GLuint program + GLint location + GLuint64EXT x + + + void glProgramUniform1ui64vNV + GLuint program + GLint location + GLsizei count + const GLuint64EXT *value + + + void glProgramUniform1uiEXT + GLuint program + GLint location + GLuint v0 + + + + void glProgramUniform1uiv + GLuint program + GLint location + GLsizei count + const GLuint *value + + + void glProgramUniform1uivEXT + GLuint program + GLint location + GLsizei count + const GLuint *value + + + + void glProgramUniform2d + GLuint program + GLint location + GLdouble v0 + GLdouble v1 + + + void glProgramUniform2dEXT + GLuint program + GLint location + GLdouble x + GLdouble y + + + void glProgramUniform2dv + GLuint program + GLint location + GLsizei count + const GLdouble *value + + + void glProgramUniform2dvEXT + GLuint program + GLint location + GLsizei count + const GLdouble *value + + + void glProgramUniform2f + GLuint program + GLint location + GLfloat v0 + GLfloat v1 + + + void glProgramUniform2fEXT + GLuint program + GLint location + GLfloat v0 + GLfloat v1 + + + + void glProgramUniform2fv + GLuint program + GLint location + GLsizei count + const GLfloat *value + + + void glProgramUniform2fvEXT + GLuint program + GLint location + GLsizei count + const GLfloat *value + + + + void glProgramUniform2i + GLuint program + GLint location + GLint v0 + GLint v1 + + + void glProgramUniform2i64NV + GLuint program + GLint location + GLint64EXT x + GLint64EXT y + + + void glProgramUniform2i64vNV + GLuint program + GLint location + GLsizei count + const GLint64EXT *value + + + void glProgramUniform2iEXT + GLuint program + GLint location + GLint v0 + GLint v1 + + + + void glProgramUniform2iv + GLuint program + GLint location + GLsizei count + const GLint *value + + + void glProgramUniform2ivEXT + GLuint program + GLint location + GLsizei count + const GLint *value + + + + void glProgramUniform2ui + GLuint program + GLint location + GLuint v0 + GLuint v1 + + + void glProgramUniform2ui64NV + GLuint program + GLint location + GLuint64EXT x + GLuint64EXT y + + + void glProgramUniform2ui64vNV + GLuint program + GLint location + GLsizei count + const GLuint64EXT *value + + + void glProgramUniform2uiEXT + GLuint program + GLint location + GLuint v0 + GLuint v1 + + + + void glProgramUniform2uiv + GLuint program + GLint location + GLsizei count + const GLuint *value + + + void glProgramUniform2uivEXT + GLuint program + GLint location + GLsizei count + const GLuint *value + + + + void glProgramUniform3d + GLuint program + GLint location + GLdouble v0 + GLdouble v1 + GLdouble v2 + + + void glProgramUniform3dEXT + GLuint program + GLint location + GLdouble x + GLdouble y + GLdouble z + + + void glProgramUniform3dv + GLuint program + GLint location + GLsizei count + const GLdouble *value + + + void glProgramUniform3dvEXT + GLuint program + GLint location + GLsizei count + const GLdouble *value + + + void glProgramUniform3f + GLuint program + GLint location + GLfloat v0 + GLfloat v1 + GLfloat v2 + + + void glProgramUniform3fEXT + GLuint program + GLint location + GLfloat v0 + GLfloat v1 + GLfloat v2 + + + + void glProgramUniform3fv + GLuint program + GLint location + GLsizei count + const GLfloat *value + + + void glProgramUniform3fvEXT + GLuint program + GLint location + GLsizei count + const GLfloat *value + + + + void glProgramUniform3i + GLuint program + GLint location + GLint v0 + GLint v1 + GLint v2 + + + void glProgramUniform3i64NV + GLuint program + GLint location + GLint64EXT x + GLint64EXT y + GLint64EXT z + + + void glProgramUniform3i64vNV + GLuint program + GLint location + GLsizei count + const GLint64EXT *value + + + void glProgramUniform3iEXT + GLuint program + GLint location + GLint v0 + GLint v1 + GLint v2 + + + + void glProgramUniform3iv + GLuint program + GLint location + GLsizei count + const GLint *value + + + void glProgramUniform3ivEXT + GLuint program + GLint location + GLsizei count + const GLint *value + + + + void glProgramUniform3ui + GLuint program + GLint location + GLuint v0 + GLuint v1 + GLuint v2 + + + void glProgramUniform3ui64NV + GLuint program + GLint location + GLuint64EXT x + GLuint64EXT y + GLuint64EXT z + + + void glProgramUniform3ui64vNV + GLuint program + GLint location + GLsizei count + const GLuint64EXT *value + + + void glProgramUniform3uiEXT + GLuint program + GLint location + GLuint v0 + GLuint v1 + GLuint v2 + + + + void glProgramUniform3uiv + GLuint program + GLint location + GLsizei count + const GLuint *value + + + void glProgramUniform3uivEXT + GLuint program + GLint location + GLsizei count + const GLuint *value + + + + void glProgramUniform4d + GLuint program + GLint location + GLdouble v0 + GLdouble v1 + GLdouble v2 + GLdouble v3 + + + void glProgramUniform4dEXT + GLuint program + GLint location + GLdouble x + GLdouble y + GLdouble z + GLdouble w + + + void glProgramUniform4dv + GLuint program + GLint location + GLsizei count + const GLdouble *value + + + void glProgramUniform4dvEXT + GLuint program + GLint location + GLsizei count + const GLdouble *value + + + void glProgramUniform4f + GLuint program + GLint location + GLfloat v0 + GLfloat v1 + GLfloat v2 + GLfloat v3 + + + void glProgramUniform4fEXT + GLuint program + GLint location + GLfloat v0 + GLfloat v1 + GLfloat v2 + GLfloat v3 + + + + void glProgramUniform4fv + GLuint program + GLint location + GLsizei count + const GLfloat *value + + + void glProgramUniform4fvEXT + GLuint program + GLint location + GLsizei count + const GLfloat *value + + + + void glProgramUniform4i + GLuint program + GLint location + GLint v0 + GLint v1 + GLint v2 + GLint v3 + + + void glProgramUniform4i64NV + GLuint program + GLint location + GLint64EXT x + GLint64EXT y + GLint64EXT z + GLint64EXT w + + + void glProgramUniform4i64vNV + GLuint program + GLint location + GLsizei count + const GLint64EXT *value + + + void glProgramUniform4iEXT + GLuint program + GLint location + GLint v0 + GLint v1 + GLint v2 + GLint v3 + + + + void glProgramUniform4iv + GLuint program + GLint location + GLsizei count + const GLint *value + + + void glProgramUniform4ivEXT + GLuint program + GLint location + GLsizei count + const GLint *value + + + + void glProgramUniform4ui + GLuint program + GLint location + GLuint v0 + GLuint v1 + GLuint v2 + GLuint v3 + + + void glProgramUniform4ui64NV + GLuint program + GLint location + GLuint64EXT x + GLuint64EXT y + GLuint64EXT z + GLuint64EXT w + + + void glProgramUniform4ui64vNV + GLuint program + GLint location + GLsizei count + const GLuint64EXT *value + + + void glProgramUniform4uiEXT + GLuint program + GLint location + GLuint v0 + GLuint v1 + GLuint v2 + GLuint v3 + + + + void glProgramUniform4uiv + GLuint program + GLint location + GLsizei count + const GLuint *value + + + void glProgramUniform4uivEXT + GLuint program + GLint location + GLsizei count + const GLuint *value + + + + void glProgramUniformHandleui64ARB + GLuint program + GLint location + GLuint64 value + + + void glProgramUniformHandleui64NV + GLuint program + GLint location + GLuint64 value + + + void glProgramUniformHandleui64vARB + GLuint program + GLint location + GLsizei count + const GLuint64 *values + + + void glProgramUniformHandleui64vNV + GLuint program + GLint location + GLsizei count + const GLuint64 *values + + + void glProgramUniformMatrix2dv + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLdouble *value + + + void glProgramUniformMatrix2dvEXT + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLdouble *value + + + void glProgramUniformMatrix2fv + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + void glProgramUniformMatrix2fvEXT + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + + void glProgramUniformMatrix2x3dv + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLdouble *value + + + void glProgramUniformMatrix2x3dvEXT + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLdouble *value + + + void glProgramUniformMatrix2x3fv + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + void glProgramUniformMatrix2x3fvEXT + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + + void glProgramUniformMatrix2x4dv + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLdouble *value + + + void glProgramUniformMatrix2x4dvEXT + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLdouble *value + + + void glProgramUniformMatrix2x4fv + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + void glProgramUniformMatrix2x4fvEXT + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + + void glProgramUniformMatrix3dv + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLdouble *value + + + void glProgramUniformMatrix3dvEXT + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLdouble *value + + + void glProgramUniformMatrix3fv + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + void glProgramUniformMatrix3fvEXT + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + + void glProgramUniformMatrix3x2dv + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLdouble *value + + + void glProgramUniformMatrix3x2dvEXT + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLdouble *value + + + void glProgramUniformMatrix3x2fv + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + void glProgramUniformMatrix3x2fvEXT + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + + void glProgramUniformMatrix3x4dv + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLdouble *value + + + void glProgramUniformMatrix3x4dvEXT + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLdouble *value + + + void glProgramUniformMatrix3x4fv + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + void glProgramUniformMatrix3x4fvEXT + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + + void glProgramUniformMatrix4dv + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLdouble *value + + + void glProgramUniformMatrix4dvEXT + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLdouble *value + + + void glProgramUniformMatrix4fv + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + void glProgramUniformMatrix4fvEXT + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + + void glProgramUniformMatrix4x2dv + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLdouble *value + + + void glProgramUniformMatrix4x2dvEXT + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLdouble *value + + + void glProgramUniformMatrix4x2fv + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + void glProgramUniformMatrix4x2fvEXT + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + + void glProgramUniformMatrix4x3dv + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLdouble *value + + + void glProgramUniformMatrix4x3dvEXT + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLdouble *value + + + void glProgramUniformMatrix4x3fv + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + void glProgramUniformMatrix4x3fvEXT + GLuint program + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + + void glProgramUniformui64NV + GLuint program + GLint location + GLuint64EXT value + + + void glProgramUniformui64vNV + GLuint program + GLint location + GLsizei count + const GLuint64EXT *value + + + void glProgramVertexLimitNV + GLenum target + GLint limit + + + void glProvokingVertex + GLenum mode + + + void glProvokingVertexEXT + GLenum mode + + + + void glPushAttrib + GLbitfield mask + + + + void glPushClientAttrib + GLbitfield mask + + + void glPushClientAttribDefaultEXT + GLbitfield mask + + + void glPushDebugGroup + GLenum source + GLuint id + GLsizei length + const GLchar *message + + + void glPushDebugGroupKHR + GLenum source + GLuint id + GLsizei length + const GLchar *message + + + + void glPushGroupMarkerEXT + GLsizei length + const GLchar *marker + + + void glPushMatrix + + + + void glPushName + GLuint name + + + + void glQueryCounter + GLuint id + GLenum target + + + void glQueryCounterEXT + GLuint id + GLenum target + + + + GLbitfield glQueryMatrixxOES + GLfixed *mantissa + GLint *exponent + + + void glQueryObjectParameteruiAMD + GLenum target + GLuint id + GLenum pname + GLuint param + + + void glRasterPos2d + GLdouble x + GLdouble y + + + + void glRasterPos2dv + const GLdouble *v + + + + void glRasterPos2f + GLfloat x + GLfloat y + + + + void glRasterPos2fv + const GLfloat *v + + + + void glRasterPos2i + GLint x + GLint y + + + + void glRasterPos2iv + const GLint *v + + + + void glRasterPos2s + GLshort x + GLshort y + + + + void glRasterPos2sv + const GLshort *v + + + + void glRasterPos2xOES + GLfixed x + GLfixed y + + + void glRasterPos2xvOES + const GLfixed *coords + + + void glRasterPos3d + GLdouble x + GLdouble y + GLdouble z + + + + void glRasterPos3dv + const GLdouble *v + + + + void glRasterPos3f + GLfloat x + GLfloat y + GLfloat z + + + + void glRasterPos3fv + const GLfloat *v + + + + void glRasterPos3i + GLint x + GLint y + GLint z + + + + void glRasterPos3iv + const GLint *v + + + + void glRasterPos3s + GLshort x + GLshort y + GLshort z + + + + void glRasterPos3sv + const GLshort *v + + + + void glRasterPos3xOES + GLfixed x + GLfixed y + GLfixed z + + + void glRasterPos3xvOES + const GLfixed *coords + + + void glRasterPos4d + GLdouble x + GLdouble y + GLdouble z + GLdouble w + + + + void glRasterPos4dv + const GLdouble *v + + + + void glRasterPos4f + GLfloat x + GLfloat y + GLfloat z + GLfloat w + + + + void glRasterPos4fv + const GLfloat *v + + + + void glRasterPos4i + GLint x + GLint y + GLint z + GLint w + + + + void glRasterPos4iv + const GLint *v + + + + void glRasterPos4s + GLshort x + GLshort y + GLshort z + GLshort w + + + + void glRasterPos4sv + const GLshort *v + + + + void glRasterPos4xOES + GLfixed x + GLfixed y + GLfixed z + GLfixed w + + + void glRasterPos4xvOES + const GLfixed *coords + + + void glReadBuffer + GLenum src + + + + void glReadBufferIndexedEXT + GLenum src + GLint index + + + void glReadBufferNV + GLenum mode + + + void glReadInstrumentsSGIX + GLint marker + + + + void glReadPixels + GLint x + GLint y + GLsizei width + GLsizei height + GLenum format + GLenum type + void *pixels + + + + + void glReadnPixels + GLint x + GLint y + GLsizei width + GLsizei height + GLenum format + GLenum type + GLsizei bufSize + void *data + + + void glReadnPixelsARB + GLint x + GLint y + GLsizei width + GLsizei height + GLenum format + GLenum type + GLsizei bufSize + void *data + + + + void glReadnPixelsEXT + GLint x + GLint y + GLsizei width + GLsizei height + GLenum format + GLenum type + GLsizei bufSize + void *data + + + + void glReadnPixelsKHR + GLint x + GLint y + GLsizei width + GLsizei height + GLenum format + GLenum type + GLsizei bufSize + void *data + + + + void glRectd + GLdouble x1 + GLdouble y1 + GLdouble x2 + GLdouble y2 + + + + void glRectdv + const GLdouble *v1 + const GLdouble *v2 + + + + void glRectf + GLfloat x1 + GLfloat y1 + GLfloat x2 + GLfloat y2 + + + + void glRectfv + const GLfloat *v1 + const GLfloat *v2 + + + + void glRecti + GLint x1 + GLint y1 + GLint x2 + GLint y2 + + + + void glRectiv + const GLint *v1 + const GLint *v2 + + + + void glRects + GLshort x1 + GLshort y1 + GLshort x2 + GLshort y2 + + + + void glRectsv + const GLshort *v1 + const GLshort *v2 + + + + void glRectxOES + GLfixed x1 + GLfixed y1 + GLfixed x2 + GLfixed y2 + + + void glRectxvOES + const GLfixed *v1 + const GLfixed *v2 + + + void glReferencePlaneSGIX + const GLdouble *equation + + + + void glReleaseShaderCompiler + + + GLint glRenderMode + GLenum mode + + + + void glRenderbufferStorage + GLenum target + GLenum internalformat + GLsizei width + GLsizei height + + + + void glRenderbufferStorageEXT + GLenum target + GLenum internalformat + GLsizei width + GLsizei height + + + + + void glRenderbufferStorageMultisample + GLenum target + GLsizei samples + GLenum internalformat + GLsizei width + GLsizei height + + + + void glRenderbufferStorageMultisampleANGLE + GLenum target + GLsizei samples + GLenum internalformat + GLsizei width + GLsizei height + + + void glRenderbufferStorageMultisampleAPPLE + GLenum target + GLsizei samples + GLenum internalformat + GLsizei width + GLsizei height + + + void glRenderbufferStorageMultisampleCoverageNV + GLenum target + GLsizei coverageSamples + GLsizei colorSamples + GLenum internalformat + GLsizei width + GLsizei height + + + void glRenderbufferStorageMultisampleEXT + GLenum target + GLsizei samples + GLenum internalformat + GLsizei width + GLsizei height + + + + + void glRenderbufferStorageMultisampleIMG + GLenum target + GLsizei samples + GLenum internalformat + GLsizei width + GLsizei height + + + void glRenderbufferStorageMultisampleNV + GLenum target + GLsizei samples + GLenum internalformat + GLsizei width + GLsizei height + + + + void glRenderbufferStorageOES + GLenum target + GLenum internalformat + GLsizei width + GLsizei height + + + void glReplacementCodePointerSUN + GLenum type + GLsizei stride + const void **pointer + + + void glReplacementCodeubSUN + GLubyte code + + + void glReplacementCodeubvSUN + const GLubyte *code + + + void glReplacementCodeuiColor3fVertex3fSUN + GLuint rc + GLfloat r + GLfloat g + GLfloat b + GLfloat x + GLfloat y + GLfloat z + + + void glReplacementCodeuiColor3fVertex3fvSUN + const GLuint *rc + const GLfloat *c + const GLfloat *v + + + void glReplacementCodeuiColor4fNormal3fVertex3fSUN + GLuint rc + GLfloat r + GLfloat g + GLfloat b + GLfloat a + GLfloat nx + GLfloat ny + GLfloat nz + GLfloat x + GLfloat y + GLfloat z + + + void glReplacementCodeuiColor4fNormal3fVertex3fvSUN + const GLuint *rc + const GLfloat *c + const GLfloat *n + const GLfloat *v + + + void glReplacementCodeuiColor4ubVertex3fSUN + GLuint rc + GLubyte r + GLubyte g + GLubyte b + GLubyte a + GLfloat x + GLfloat y + GLfloat z + + + void glReplacementCodeuiColor4ubVertex3fvSUN + const GLuint *rc + const GLubyte *c + const GLfloat *v + + + void glReplacementCodeuiNormal3fVertex3fSUN + GLuint rc + GLfloat nx + GLfloat ny + GLfloat nz + GLfloat x + GLfloat y + GLfloat z + + + void glReplacementCodeuiNormal3fVertex3fvSUN + const GLuint *rc + const GLfloat *n + const GLfloat *v + + + void glReplacementCodeuiSUN + GLuint code + + + void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN + GLuint rc + GLfloat s + GLfloat t + GLfloat r + GLfloat g + GLfloat b + GLfloat a + GLfloat nx + GLfloat ny + GLfloat nz + GLfloat x + GLfloat y + GLfloat z + + + void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN + const GLuint *rc + const GLfloat *tc + const GLfloat *c + const GLfloat *n + const GLfloat *v + + + void glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN + GLuint rc + GLfloat s + GLfloat t + GLfloat nx + GLfloat ny + GLfloat nz + GLfloat x + GLfloat y + GLfloat z + + + void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN + const GLuint *rc + const GLfloat *tc + const GLfloat *n + const GLfloat *v + + + void glReplacementCodeuiTexCoord2fVertex3fSUN + GLuint rc + GLfloat s + GLfloat t + GLfloat x + GLfloat y + GLfloat z + + + void glReplacementCodeuiTexCoord2fVertex3fvSUN + const GLuint *rc + const GLfloat *tc + const GLfloat *v + + + void glReplacementCodeuiVertex3fSUN + GLuint rc + GLfloat x + GLfloat y + GLfloat z + + + void glReplacementCodeuiVertex3fvSUN + const GLuint *rc + const GLfloat *v + + + void glReplacementCodeuivSUN + const GLuint *code + + + void glReplacementCodeusSUN + GLushort code + + + void glReplacementCodeusvSUN + const GLushort *code + + + void glRequestResidentProgramsNV + GLsizei n + const GLuint *programs + + + + void glResetHistogram + GLenum target + + + + void glResetHistogramEXT + GLenum target + + + + + void glResetMinmax + GLenum target + + + + void glResetMinmaxEXT + GLenum target + + + + + void glResizeBuffersMESA + + + void glResolveMultisampleFramebufferAPPLE + + + void glResumeTransformFeedback + + + void glResumeTransformFeedbackNV + + + + void glRotated + GLdouble angle + GLdouble x + GLdouble y + GLdouble z + + + + void glRotatef + GLfloat angle + GLfloat x + GLfloat y + GLfloat z + + + + void glRotatex + GLfixed angle + GLfixed x + GLfixed y + GLfixed z + + + void glRotatexOES + GLfixed angle + GLfixed x + GLfixed y + GLfixed z + + + void glSampleCoverage + GLfloat value + GLboolean invert + + + + void glSampleCoverageARB + GLfloat value + GLboolean invert + + + + void glSampleCoverageOES + GLfixed value + GLboolean invert + + + void glSampleCoveragex + GLclampx value + GLboolean invert + + + void glSampleCoveragexOES + GLclampx value + GLboolean invert + + + void glSampleMapATI + GLuint dst + GLuint interp + GLenum swizzle + + + void glSampleMaskEXT + GLclampf value + GLboolean invert + + + void glSampleMaskIndexedNV + GLuint index + GLbitfield mask + + + void glSampleMaskSGIS + GLclampf value + GLboolean invert + + + + + void glSampleMaski + GLuint maskNumber + GLbitfield mask + + + void glSamplePatternEXT + GLenum pattern + + + void glSamplePatternSGIS + GLenum pattern + + + + + void glSamplerParameterIiv + GLuint sampler + GLenum pname + const GLint *param + + + void glSamplerParameterIivEXT + GLuint sampler + GLenum pname + const GLint *param + + + + void glSamplerParameterIuiv + GLuint sampler + GLenum pname + const GLuint *param + + + void glSamplerParameterIuivEXT + GLuint sampler + GLenum pname + const GLuint *param + + + + void glSamplerParameterf + GLuint sampler + GLenum pname + GLfloat param + + + void glSamplerParameterfv + GLuint sampler + GLenum pname + const GLfloat *param + + + void glSamplerParameteri + GLuint sampler + GLenum pname + GLint param + + + void glSamplerParameteriv + GLuint sampler + GLenum pname + const GLint *param + + + void glScaled + GLdouble x + GLdouble y + GLdouble z + + + + void glScalef + GLfloat x + GLfloat y + GLfloat z + + + + void glScalex + GLfixed x + GLfixed y + GLfixed z + + + void glScalexOES + GLfixed x + GLfixed y + GLfixed z + + + void glScissor + GLint x + GLint y + GLsizei width + GLsizei height + + + + void glScissorArrayv + GLuint first + GLsizei count + const GLint *v + + + void glScissorIndexed + GLuint index + GLint left + GLint bottom + GLsizei width + GLsizei height + + + void glScissorIndexedv + GLuint index + const GLint *v + + + void glSecondaryColor3b + GLbyte red + GLbyte green + GLbyte blue + + + + void glSecondaryColor3bEXT + GLbyte red + GLbyte green + GLbyte blue + + + + + void glSecondaryColor3bv + const GLbyte *v + + + + void glSecondaryColor3bvEXT + const GLbyte *v + + + + + void glSecondaryColor3d + GLdouble red + GLdouble green + GLdouble blue + + + + void glSecondaryColor3dEXT + GLdouble red + GLdouble green + GLdouble blue + + + + + void glSecondaryColor3dv + const GLdouble *v + + + + void glSecondaryColor3dvEXT + const GLdouble *v + + + + + void glSecondaryColor3f + GLfloat red + GLfloat green + GLfloat blue + + + + void glSecondaryColor3fEXT + GLfloat red + GLfloat green + GLfloat blue + + + + + void glSecondaryColor3fv + const GLfloat *v + + + + void glSecondaryColor3fvEXT + const GLfloat *v + + + + + void glSecondaryColor3hNV + GLhalfNV red + GLhalfNV green + GLhalfNV blue + + + + void glSecondaryColor3hvNV + const GLhalfNV *v + + + + void glSecondaryColor3i + GLint red + GLint green + GLint blue + + + + void glSecondaryColor3iEXT + GLint red + GLint green + GLint blue + + + + + void glSecondaryColor3iv + const GLint *v + + + + void glSecondaryColor3ivEXT + const GLint *v + + + + + void glSecondaryColor3s + GLshort red + GLshort green + GLshort blue + + + + void glSecondaryColor3sEXT + GLshort red + GLshort green + GLshort blue + + + + + void glSecondaryColor3sv + const GLshort *v + + + + void glSecondaryColor3svEXT + const GLshort *v + + + + + void glSecondaryColor3ub + GLubyte red + GLubyte green + GLubyte blue + + + + void glSecondaryColor3ubEXT + GLubyte red + GLubyte green + GLubyte blue + + + + + void glSecondaryColor3ubv + const GLubyte *v + + + + void glSecondaryColor3ubvEXT + const GLubyte *v + + + + + void glSecondaryColor3ui + GLuint red + GLuint green + GLuint blue + + + + void glSecondaryColor3uiEXT + GLuint red + GLuint green + GLuint blue + + + + + void glSecondaryColor3uiv + const GLuint *v + + + + void glSecondaryColor3uivEXT + const GLuint *v + + + + + void glSecondaryColor3us + GLushort red + GLushort green + GLushort blue + + + + void glSecondaryColor3usEXT + GLushort red + GLushort green + GLushort blue + + + + + void glSecondaryColor3usv + const GLushort *v + + + + void glSecondaryColor3usvEXT + const GLushort *v + + + + + void glSecondaryColorFormatNV + GLint size + GLenum type + GLsizei stride + + + void glSecondaryColorP3ui + GLenum type + GLuint color + + + void glSecondaryColorP3uiv + GLenum type + const GLuint *color + + + void glSecondaryColorPointer + GLint size + GLenum type + GLsizei stride + const void *pointer + + + void glSecondaryColorPointerEXT + GLint size + GLenum type + GLsizei stride + const void *pointer + + + + void glSecondaryColorPointerListIBM + GLint size + GLenum type + GLint stride + const void **pointer + GLint ptrstride + + + void glSelectBuffer + GLsizei size + GLuint *buffer + + + + void glSelectPerfMonitorCountersAMD + GLuint monitor + GLboolean enable + GLuint group + GLint numCounters + GLuint *counterList + + + void glSeparableFilter2D + GLenum target + GLenum internalformat + GLsizei width + GLsizei height + GLenum format + GLenum type + const void *row + const void *column + + + + + void glSeparableFilter2DEXT + GLenum target + GLenum internalformat + GLsizei width + GLsizei height + GLenum format + GLenum type + const void *row + const void *column + + + + + void glSetFenceAPPLE + GLuint fence + + + void glSetFenceNV + GLuint fence + GLenum condition + + + void glSetFragmentShaderConstantATI + GLuint dst + const GLfloat *value + + + void glSetInvariantEXT + GLuint id + GLenum type + const void *addr + + + void glSetLocalConstantEXT + GLuint id + GLenum type + const void *addr + + + void glSetMultisamplefvAMD + GLenum pname + GLuint index + const GLfloat *val + + + void glShadeModel + GLenum mode + + + + void glShaderBinary + GLsizei count + const GLuint *shaders + GLenum binaryformat + const void *binary + GLsizei length + + + void glShaderOp1EXT + GLenum op + GLuint res + GLuint arg1 + + + void glShaderOp2EXT + GLenum op + GLuint res + GLuint arg1 + GLuint arg2 + + + void glShaderOp3EXT + GLenum op + GLuint res + GLuint arg1 + GLuint arg2 + GLuint arg3 + + + void glShaderSource + GLuint shader + GLsizei count + const GLchar *const*string + const GLint *length + + + void glShaderSourceARB + GLhandleARB shaderObj + GLsizei count + const GLcharARB **string + const GLint *length + + + + void glShaderStorageBlockBinding + GLuint program + GLuint storageBlockIndex + GLuint storageBlockBinding + + + void glSharpenTexFuncSGIS + GLenum target + GLsizei n + const GLfloat *points + + + + void glSpriteParameterfSGIX + GLenum pname + GLfloat param + + + + void glSpriteParameterfvSGIX + GLenum pname + const GLfloat *params + + + + void glSpriteParameteriSGIX + GLenum pname + GLint param + + + + void glSpriteParameterivSGIX + GLenum pname + const GLint *params + + + + void glStartInstrumentsSGIX + + + + void glStartTilingQCOM + GLuint x + GLuint y + GLuint width + GLuint height + GLbitfield preserveMask + + + void glStencilClearTagEXT + GLsizei stencilTagBits + GLuint stencilClearTag + + + + void glStencilFillPathInstancedNV + GLsizei numPaths + GLenum pathNameType + const void *paths + GLuint pathBase + GLenum fillMode + GLuint mask + GLenum transformType + const GLfloat *transformValues + + + void glStencilFillPathNV + GLuint path + GLenum fillMode + GLuint mask + + + void glStencilFunc + GLenum func + GLint ref + GLuint mask + + + + void glStencilFuncSeparate + GLenum face + GLenum func + GLint ref + GLuint mask + + + void glStencilFuncSeparateATI + GLenum frontfunc + GLenum backfunc + GLint ref + GLuint mask + + + void glStencilMask + GLuint mask + + + + void glStencilMaskSeparate + GLenum face + GLuint mask + + + void glStencilOp + GLenum fail + GLenum zfail + GLenum zpass + + + + void glStencilOpSeparate + GLenum face + GLenum sfail + GLenum dpfail + GLenum dppass + + + void glStencilOpSeparateATI + GLenum face + GLenum sfail + GLenum dpfail + GLenum dppass + + + + void glStencilOpValueAMD + GLenum face + GLuint value + + + void glStencilStrokePathInstancedNV + GLsizei numPaths + GLenum pathNameType + const void *paths + GLuint pathBase + GLint reference + GLuint mask + GLenum transformType + const GLfloat *transformValues + + + void glStencilStrokePathNV + GLuint path + GLint reference + GLuint mask + + + void glStencilThenCoverFillPathInstancedNV + GLsizei numPaths + GLenum pathNameType + const void *paths + GLuint pathBase + GLenum fillMode + GLuint mask + GLenum coverMode + GLenum transformType + const GLfloat *transformValues + + + void glStencilThenCoverFillPathNV + GLuint path + GLenum fillMode + GLuint mask + GLenum coverMode + + + void glStencilThenCoverStrokePathInstancedNV + GLsizei numPaths + GLenum pathNameType + const void *paths + GLuint pathBase + GLint reference + GLuint mask + GLenum coverMode + GLenum transformType + const GLfloat *transformValues + + + void glStencilThenCoverStrokePathNV + GLuint path + GLint reference + GLuint mask + GLenum coverMode + + + void glStopInstrumentsSGIX + GLint marker + + + + void glStringMarkerGREMEDY + GLsizei len + const void *string + + + void glSwizzleEXT + GLuint res + GLuint in + GLenum outX + GLenum outY + GLenum outZ + GLenum outW + + + void glSyncTextureINTEL + GLuint texture + + + void glTagSampleBufferSGIX + + + + void glTangent3bEXT + GLbyte tx + GLbyte ty + GLbyte tz + + + + void glTangent3bvEXT + const GLbyte *v + + + void glTangent3dEXT + GLdouble tx + GLdouble ty + GLdouble tz + + + + void glTangent3dvEXT + const GLdouble *v + + + void glTangent3fEXT + GLfloat tx + GLfloat ty + GLfloat tz + + + + void glTangent3fvEXT + const GLfloat *v + + + void glTangent3iEXT + GLint tx + GLint ty + GLint tz + + + + void glTangent3ivEXT + const GLint *v + + + void glTangent3sEXT + GLshort tx + GLshort ty + GLshort tz + + + + void glTangent3svEXT + const GLshort *v + + + void glTangentPointerEXT + GLenum type + GLsizei stride + const void *pointer + + + void glTbufferMask3DFX + GLuint mask + + + void glTessellationFactorAMD + GLfloat factor + + + void glTessellationModeAMD + GLenum mode + + + GLboolean glTestFenceAPPLE + GLuint fence + + + GLboolean glTestFenceNV + GLuint fence + + + + GLboolean glTestObjectAPPLE + GLenum object + GLuint name + + + void glTexBuffer + GLenum target + GLenum internalformat + GLuint buffer + + + void glTexBufferARB + GLenum target + GLenum internalformat + GLuint buffer + + + + void glTexBufferEXT + GLenum target + GLenum internalformat + GLuint buffer + + + + void glTexBufferRange + GLenum target + GLenum internalformat + GLuint buffer + GLintptr offset + GLsizeiptr size + + + void glTexBufferRangeEXT + GLenum target + GLenum internalformat + GLuint buffer + GLintptr offset + GLsizeiptr size + + + + void glTexBumpParameterfvATI + GLenum pname + const GLfloat *param + + + void glTexBumpParameterivATI + GLenum pname + const GLint *param + + + void glTexCoord1bOES + GLbyte s + + + void glTexCoord1bvOES + const GLbyte *coords + + + void glTexCoord1d + GLdouble s + + + + void glTexCoord1dv + const GLdouble *v + + + + void glTexCoord1f + GLfloat s + + + + void glTexCoord1fv + const GLfloat *v + + + + void glTexCoord1hNV + GLhalfNV s + + + + void glTexCoord1hvNV + const GLhalfNV *v + + + + void glTexCoord1i + GLint s + + + + void glTexCoord1iv + const GLint *v + + + + void glTexCoord1s + GLshort s + + + + void glTexCoord1sv + const GLshort *v + + + + void glTexCoord1xOES + GLfixed s + + + void glTexCoord1xvOES + const GLfixed *coords + + + void glTexCoord2bOES + GLbyte s + GLbyte t + + + void glTexCoord2bvOES + const GLbyte *coords + + + void glTexCoord2d + GLdouble s + GLdouble t + + + + void glTexCoord2dv + const GLdouble *v + + + + void glTexCoord2f + GLfloat s + GLfloat t + + + + void glTexCoord2fColor3fVertex3fSUN + GLfloat s + GLfloat t + GLfloat r + GLfloat g + GLfloat b + GLfloat x + GLfloat y + GLfloat z + + + void glTexCoord2fColor3fVertex3fvSUN + const GLfloat *tc + const GLfloat *c + const GLfloat *v + + + void glTexCoord2fColor4fNormal3fVertex3fSUN + GLfloat s + GLfloat t + GLfloat r + GLfloat g + GLfloat b + GLfloat a + GLfloat nx + GLfloat ny + GLfloat nz + GLfloat x + GLfloat y + GLfloat z + + + void glTexCoord2fColor4fNormal3fVertex3fvSUN + const GLfloat *tc + const GLfloat *c + const GLfloat *n + const GLfloat *v + + + void glTexCoord2fColor4ubVertex3fSUN + GLfloat s + GLfloat t + GLubyte r + GLubyte g + GLubyte b + GLubyte a + GLfloat x + GLfloat y + GLfloat z + + + void glTexCoord2fColor4ubVertex3fvSUN + const GLfloat *tc + const GLubyte *c + const GLfloat *v + + + void glTexCoord2fNormal3fVertex3fSUN + GLfloat s + GLfloat t + GLfloat nx + GLfloat ny + GLfloat nz + GLfloat x + GLfloat y + GLfloat z + + + void glTexCoord2fNormal3fVertex3fvSUN + const GLfloat *tc + const GLfloat *n + const GLfloat *v + + + void glTexCoord2fVertex3fSUN + GLfloat s + GLfloat t + GLfloat x + GLfloat y + GLfloat z + + + void glTexCoord2fVertex3fvSUN + const GLfloat *tc + const GLfloat *v + + + void glTexCoord2fv + const GLfloat *v + + + + void glTexCoord2hNV + GLhalfNV s + GLhalfNV t + + + + void glTexCoord2hvNV + const GLhalfNV *v + + + + void glTexCoord2i + GLint s + GLint t + + + + void glTexCoord2iv + const GLint *v + + + + void glTexCoord2s + GLshort s + GLshort t + + + + void glTexCoord2sv + const GLshort *v + + + + void glTexCoord2xOES + GLfixed s + GLfixed t + + + void glTexCoord2xvOES + const GLfixed *coords + + + void glTexCoord3bOES + GLbyte s + GLbyte t + GLbyte r + + + void glTexCoord3bvOES + const GLbyte *coords + + + void glTexCoord3d + GLdouble s + GLdouble t + GLdouble r + + + + void glTexCoord3dv + const GLdouble *v + + + + void glTexCoord3f + GLfloat s + GLfloat t + GLfloat r + + + + void glTexCoord3fv + const GLfloat *v + + + + void glTexCoord3hNV + GLhalfNV s + GLhalfNV t + GLhalfNV r + + + + void glTexCoord3hvNV + const GLhalfNV *v + + + + void glTexCoord3i + GLint s + GLint t + GLint r + + + + void glTexCoord3iv + const GLint *v + + + + void glTexCoord3s + GLshort s + GLshort t + GLshort r + + + + void glTexCoord3sv + const GLshort *v + + + + void glTexCoord3xOES + GLfixed s + GLfixed t + GLfixed r + + + void glTexCoord3xvOES + const GLfixed *coords + + + void glTexCoord4bOES + GLbyte s + GLbyte t + GLbyte r + GLbyte q + + + void glTexCoord4bvOES + const GLbyte *coords + + + void glTexCoord4d + GLdouble s + GLdouble t + GLdouble r + GLdouble q + + + + void glTexCoord4dv + const GLdouble *v + + + + void glTexCoord4f + GLfloat s + GLfloat t + GLfloat r + GLfloat q + + + + void glTexCoord4fColor4fNormal3fVertex4fSUN + GLfloat s + GLfloat t + GLfloat p + GLfloat q + GLfloat r + GLfloat g + GLfloat b + GLfloat a + GLfloat nx + GLfloat ny + GLfloat nz + GLfloat x + GLfloat y + GLfloat z + GLfloat w + + + void glTexCoord4fColor4fNormal3fVertex4fvSUN + const GLfloat *tc + const GLfloat *c + const GLfloat *n + const GLfloat *v + + + void glTexCoord4fVertex4fSUN + GLfloat s + GLfloat t + GLfloat p + GLfloat q + GLfloat x + GLfloat y + GLfloat z + GLfloat w + + + void glTexCoord4fVertex4fvSUN + const GLfloat *tc + const GLfloat *v + + + void glTexCoord4fv + const GLfloat *v + + + + void glTexCoord4hNV + GLhalfNV s + GLhalfNV t + GLhalfNV r + GLhalfNV q + + + + void glTexCoord4hvNV + const GLhalfNV *v + + + + void glTexCoord4i + GLint s + GLint t + GLint r + GLint q + + + + void glTexCoord4iv + const GLint *v + + + + void glTexCoord4s + GLshort s + GLshort t + GLshort r + GLshort q + + + + void glTexCoord4sv + const GLshort *v + + + + void glTexCoord4xOES + GLfixed s + GLfixed t + GLfixed r + GLfixed q + + + void glTexCoord4xvOES + const GLfixed *coords + + + void glTexCoordFormatNV + GLint size + GLenum type + GLsizei stride + + + void glTexCoordP1ui + GLenum type + GLuint coords + + + void glTexCoordP1uiv + GLenum type + const GLuint *coords + + + void glTexCoordP2ui + GLenum type + GLuint coords + + + void glTexCoordP2uiv + GLenum type + const GLuint *coords + + + void glTexCoordP3ui + GLenum type + GLuint coords + + + void glTexCoordP3uiv + GLenum type + const GLuint *coords + + + void glTexCoordP4ui + GLenum type + GLuint coords + + + void glTexCoordP4uiv + GLenum type + const GLuint *coords + + + void glTexCoordPointer + GLint size + GLenum type + GLsizei stride + const void *pointer + + + void glTexCoordPointerEXT + GLint size + GLenum type + GLsizei stride + GLsizei count + const void *pointer + + + void glTexCoordPointerListIBM + GLint size + GLenum type + GLint stride + const void **pointer + GLint ptrstride + + + void glTexCoordPointervINTEL + GLint size + GLenum type + const void **pointer + + + void glTexEnvf + GLenum target + GLenum pname + GLfloat param + + + + void glTexEnvfv + GLenum target + GLenum pname + const GLfloat *params + + + + void glTexEnvi + GLenum target + GLenum pname + GLint param + + + + void glTexEnviv + GLenum target + GLenum pname + const GLint *params + + + + void glTexEnvx + GLenum target + GLenum pname + GLfixed param + + + void glTexEnvxOES + GLenum target + GLenum pname + GLfixed param + + + void glTexEnvxv + GLenum target + GLenum pname + const GLfixed *params + + + void glTexEnvxvOES + GLenum target + GLenum pname + const GLfixed *params + + + void glTexFilterFuncSGIS + GLenum target + GLenum filter + GLsizei n + const GLfloat *weights + + + + void glTexGend + GLenum coord + GLenum pname + GLdouble param + + + + void glTexGendv + GLenum coord + GLenum pname + const GLdouble *params + + + + void glTexGenf + GLenum coord + GLenum pname + GLfloat param + + + + void glTexGenfOES + GLenum coord + GLenum pname + GLfloat param + + + void glTexGenfv + GLenum coord + GLenum pname + const GLfloat *params + + + + void glTexGenfvOES + GLenum coord + GLenum pname + const GLfloat *params + + + void glTexGeni + GLenum coord + GLenum pname + GLint param + + + + void glTexGeniOES + GLenum coord + GLenum pname + GLint param + + + void glTexGeniv + GLenum coord + GLenum pname + const GLint *params + + + + void glTexGenivOES + GLenum coord + GLenum pname + const GLint *params + + + void glTexGenxOES + GLenum coord + GLenum pname + GLfixed param + + + void glTexGenxvOES + GLenum coord + GLenum pname + const GLfixed *params + + + void glTexImage1D + GLenum target + GLint level + GLint internalformat + GLsizei width + GLint border + GLenum format + GLenum type + const void *pixels + + + + + void glTexImage2D + GLenum target + GLint level + GLint internalformat + GLsizei width + GLsizei height + GLint border + GLenum format + GLenum type + const void *pixels + + + + + void glTexImage2DMultisample + GLenum target + GLsizei samples + GLenum internalformat + GLsizei width + GLsizei height + GLboolean fixedsamplelocations + + + void glTexImage2DMultisampleCoverageNV + GLenum target + GLsizei coverageSamples + GLsizei colorSamples + GLint internalFormat + GLsizei width + GLsizei height + GLboolean fixedSampleLocations + + + void glTexImage3D + GLenum target + GLint level + GLint internalformat + GLsizei width + GLsizei height + GLsizei depth + GLint border + GLenum format + GLenum type + const void *pixels + + + + + void glTexImage3DEXT + GLenum target + GLint level + GLenum internalformat + GLsizei width + GLsizei height + GLsizei depth + GLint border + GLenum format + GLenum type + const void *pixels + + + + + void glTexImage3DMultisample + GLenum target + GLsizei samples + GLenum internalformat + GLsizei width + GLsizei height + GLsizei depth + GLboolean fixedsamplelocations + + + void glTexImage3DMultisampleCoverageNV + GLenum target + GLsizei coverageSamples + GLsizei colorSamples + GLint internalFormat + GLsizei width + GLsizei height + GLsizei depth + GLboolean fixedSampleLocations + + + void glTexImage3DOES + GLenum target + GLint level + GLenum internalformat + GLsizei width + GLsizei height + GLsizei depth + GLint border + GLenum format + GLenum type + const void *pixels + + + + void glTexImage4DSGIS + GLenum target + GLint level + GLenum internalformat + GLsizei width + GLsizei height + GLsizei depth + GLsizei size4d + GLint border + GLenum format + GLenum type + const void *pixels + + + + void glTexPageCommitmentARB + GLenum target + GLint level + GLint xoffset + GLint yoffset + GLint zoffset + GLsizei width + GLsizei height + GLsizei depth + GLboolean resident + + + void glTexParameterIiv + GLenum target + GLenum pname + const GLint *params + + + + void glTexParameterIivEXT + GLenum target + GLenum pname + const GLint *params + + + + void glTexParameterIuiv + GLenum target + GLenum pname + const GLuint *params + + + + void glTexParameterIuivEXT + GLenum target + GLenum pname + const GLuint *params + + + + void glTexParameterf + GLenum target + GLenum pname + GLfloat param + + + + void glTexParameterfv + GLenum target + GLenum pname + const GLfloat *params + + + + void glTexParameteri + GLenum target + GLenum pname + GLint param + + + + void glTexParameteriv + GLenum target + GLenum pname + const GLint *params + + + + void glTexParameterx + GLenum target + GLenum pname + GLfixed param + + + void glTexParameterxOES + GLenum target + GLenum pname + GLfixed param + + + void glTexParameterxv + GLenum target + GLenum pname + const GLfixed *params + + + void glTexParameterxvOES + GLenum target + GLenum pname + const GLfixed *params + + + void glTexRenderbufferNV + GLenum target + GLuint renderbuffer + + + void glTexStorage1D + GLenum target + GLsizei levels + GLenum internalformat + GLsizei width + + + void glTexStorage1DEXT + GLenum target + GLsizei levels + GLenum internalformat + GLsizei width + + + + void glTexStorage2D + GLenum target + GLsizei levels + GLenum internalformat + GLsizei width + GLsizei height + + + void glTexStorage2DEXT + GLenum target + GLsizei levels + GLenum internalformat + GLsizei width + GLsizei height + + + + void glTexStorage2DMultisample + GLenum target + GLsizei samples + GLenum internalformat + GLsizei width + GLsizei height + GLboolean fixedsamplelocations + + + void glTexStorage3D + GLenum target + GLsizei levels + GLenum internalformat + GLsizei width + GLsizei height + GLsizei depth + + + void glTexStorage3DEXT + GLenum target + GLsizei levels + GLenum internalformat + GLsizei width + GLsizei height + GLsizei depth + + + + void glTexStorage3DMultisample + GLenum target + GLsizei samples + GLenum internalformat + GLsizei width + GLsizei height + GLsizei depth + GLboolean fixedsamplelocations + + + void glTexStorage3DMultisampleOES + GLenum target + GLsizei samples + GLenum internalformat + GLsizei width + GLsizei height + GLsizei depth + GLboolean fixedsamplelocations + + + + void glTexStorageSparseAMD + GLenum target + GLenum internalFormat + GLsizei width + GLsizei height + GLsizei depth + GLsizei layers + GLbitfield flags + + + void glTexSubImage1D + GLenum target + GLint level + GLint xoffset + GLsizei width + GLenum format + GLenum type + const void *pixels + + + + + void glTexSubImage1DEXT + GLenum target + GLint level + GLint xoffset + GLsizei width + GLenum format + GLenum type + const void *pixels + + + + + void glTexSubImage2D + GLenum target + GLint level + GLint xoffset + GLint yoffset + GLsizei width + GLsizei height + GLenum format + GLenum type + const void *pixels + + + + + void glTexSubImage2DEXT + GLenum target + GLint level + GLint xoffset + GLint yoffset + GLsizei width + GLsizei height + GLenum format + GLenum type + const void *pixels + + + + + void glTexSubImage3D + GLenum target + GLint level + GLint xoffset + GLint yoffset + GLint zoffset + GLsizei width + GLsizei height + GLsizei depth + GLenum format + GLenum type + const void *pixels + + + + + void glTexSubImage3DEXT + GLenum target + GLint level + GLint xoffset + GLint yoffset + GLint zoffset + GLsizei width + GLsizei height + GLsizei depth + GLenum format + GLenum type + const void *pixels + + + + + void glTexSubImage3DOES + GLenum target + GLint level + GLint xoffset + GLint yoffset + GLint zoffset + GLsizei width + GLsizei height + GLsizei depth + GLenum format + GLenum type + const void *pixels + + + + void glTexSubImage4DSGIS + GLenum target + GLint level + GLint xoffset + GLint yoffset + GLint zoffset + GLint woffset + GLsizei width + GLsizei height + GLsizei depth + GLsizei size4d + GLenum format + GLenum type + const void *pixels + + + + void glTextureBarrier + + + void glTextureBarrierNV + + + + void glTextureBuffer + GLuint texture + GLenum internalformat + GLuint buffer + + + void glTextureBufferEXT + GLuint texture + GLenum target + GLenum internalformat + GLuint buffer + + + void glTextureBufferRange + GLuint texture + GLenum internalformat + GLuint buffer + GLintptr offset + GLsizei size + + + void glTextureBufferRangeEXT + GLuint texture + GLenum target + GLenum internalformat + GLuint buffer + GLintptr offset + GLsizeiptr size + + + void glTextureColorMaskSGIS + GLboolean red + GLboolean green + GLboolean blue + GLboolean alpha + + + + void glTextureImage1DEXT + GLuint texture + GLenum target + GLint level + GLint internalformat + GLsizei width + GLint border + GLenum format + GLenum type + const void *pixels + + + void glTextureImage2DEXT + GLuint texture + GLenum target + GLint level + GLint internalformat + GLsizei width + GLsizei height + GLint border + GLenum format + GLenum type + const void *pixels + + + void glTextureImage2DMultisampleCoverageNV + GLuint texture + GLenum target + GLsizei coverageSamples + GLsizei colorSamples + GLint internalFormat + GLsizei width + GLsizei height + GLboolean fixedSampleLocations + + + void glTextureImage2DMultisampleNV + GLuint texture + GLenum target + GLsizei samples + GLint internalFormat + GLsizei width + GLsizei height + GLboolean fixedSampleLocations + + + void glTextureImage3DEXT + GLuint texture + GLenum target + GLint level + GLint internalformat + GLsizei width + GLsizei height + GLsizei depth + GLint border + GLenum format + GLenum type + const void *pixels + + + void glTextureImage3DMultisampleCoverageNV + GLuint texture + GLenum target + GLsizei coverageSamples + GLsizei colorSamples + GLint internalFormat + GLsizei width + GLsizei height + GLsizei depth + GLboolean fixedSampleLocations + + + void glTextureImage3DMultisampleNV + GLuint texture + GLenum target + GLsizei samples + GLint internalFormat + GLsizei width + GLsizei height + GLsizei depth + GLboolean fixedSampleLocations + + + void glTextureLightEXT + GLenum pname + + + void glTextureMaterialEXT + GLenum face + GLenum mode + + + void glTextureNormalEXT + GLenum mode + + + void glTexturePageCommitmentEXT + GLuint texture + GLint level + GLint xoffset + GLint yoffset + GLint zoffset + GLsizei width + GLsizei height + GLsizei depth + GLboolean resident + + + void glTextureParameterIiv + GLuint texture + GLenum pname + const GLint *params + + + void glTextureParameterIivEXT + GLuint texture + GLenum target + GLenum pname + const GLint *params + + + void glTextureParameterIuiv + GLuint texture + GLenum pname + const GLuint *params + + + void glTextureParameterIuivEXT + GLuint texture + GLenum target + GLenum pname + const GLuint *params + + + void glTextureParameterf + GLuint texture + GLenum pname + GLfloat param + + + void glTextureParameterfEXT + GLuint texture + GLenum target + GLenum pname + GLfloat param + + + + void glTextureParameterfv + GLuint texture + GLenum pname + const GLfloat *param + + + void glTextureParameterfvEXT + GLuint texture + GLenum target + GLenum pname + const GLfloat *params + + + void glTextureParameteri + GLuint texture + GLenum pname + GLint param + + + void glTextureParameteriEXT + GLuint texture + GLenum target + GLenum pname + GLint param + + + + void glTextureParameteriv + GLuint texture + GLenum pname + const GLint *param + + + void glTextureParameterivEXT + GLuint texture + GLenum target + GLenum pname + const GLint *params + + + void glTextureRangeAPPLE + GLenum target + GLsizei length + const void *pointer + + + void glTextureRenderbufferEXT + GLuint texture + GLenum target + GLuint renderbuffer + + + void glTextureStorage1D + GLuint texture + GLsizei levels + GLenum internalformat + GLsizei width + + + void glTextureStorage1DEXT + GLuint texture + GLenum target + GLsizei levels + GLenum internalformat + GLsizei width + + + void glTextureStorage2D + GLuint texture + GLsizei levels + GLenum internalformat + GLsizei width + GLsizei height + + + void glTextureStorage2DEXT + GLuint texture + GLenum target + GLsizei levels + GLenum internalformat + GLsizei width + GLsizei height + + + void glTextureStorage2DMultisample + GLuint texture + GLsizei samples + GLenum internalformat + GLsizei width + GLsizei height + GLboolean fixedsamplelocations + + + void glTextureStorage2DMultisampleEXT + GLuint texture + GLenum target + GLsizei samples + GLenum internalformat + GLsizei width + GLsizei height + GLboolean fixedsamplelocations + + + void glTextureStorage3D + GLuint texture + GLsizei levels + GLenum internalformat + GLsizei width + GLsizei height + GLsizei depth + + + void glTextureStorage3DEXT + GLuint texture + GLenum target + GLsizei levels + GLenum internalformat + GLsizei width + GLsizei height + GLsizei depth + + + void glTextureStorage3DMultisample + GLuint texture + GLsizei samples + GLenum internalformat + GLsizei width + GLsizei height + GLsizei depth + GLboolean fixedsamplelocations + + + void glTextureStorage3DMultisampleEXT + GLuint texture + GLenum target + GLsizei samples + GLenum internalformat + GLsizei width + GLsizei height + GLsizei depth + GLboolean fixedsamplelocations + + + void glTextureStorageSparseAMD + GLuint texture + GLenum target + GLenum internalFormat + GLsizei width + GLsizei height + GLsizei depth + GLsizei layers + GLbitfield flags + + + void glTextureSubImage1D + GLuint texture + GLint level + GLint xoffset + GLsizei width + GLenum format + GLenum type + const void *pixels + + + void glTextureSubImage1DEXT + GLuint texture + GLenum target + GLint level + GLint xoffset + GLsizei width + GLenum format + GLenum type + const void *pixels + + + void glTextureSubImage2D + GLuint texture + GLint level + GLint xoffset + GLint yoffset + GLsizei width + GLsizei height + GLenum format + GLenum type + const void *pixels + + + void glTextureSubImage2DEXT + GLuint texture + GLenum target + GLint level + GLint xoffset + GLint yoffset + GLsizei width + GLsizei height + GLenum format + GLenum type + const void *pixels + + + void glTextureSubImage3D + GLuint texture + GLint level + GLint xoffset + GLint yoffset + GLint zoffset + GLsizei width + GLsizei height + GLsizei depth + GLenum format + GLenum type + const void *pixels + + + void glTextureSubImage3DEXT + GLuint texture + GLenum target + GLint level + GLint xoffset + GLint yoffset + GLint zoffset + GLsizei width + GLsizei height + GLsizei depth + GLenum format + GLenum type + const void *pixels + + + void glTextureView + GLuint texture + GLenum target + GLuint origtexture + GLenum internalformat + GLuint minlevel + GLuint numlevels + GLuint minlayer + GLuint numlayers + + + void glTextureViewEXT + GLuint texture + GLenum target + GLuint origtexture + GLenum internalformat + GLuint minlevel + GLuint numlevels + GLuint minlayer + GLuint numlayers + + + + void glTrackMatrixNV + GLenum target + GLuint address + GLenum matrix + GLenum transform + + + + void glTransformFeedbackAttribsNV + GLsizei count + const GLint *attribs + GLenum bufferMode + + + void glTransformFeedbackBufferBase + GLuint xfb + GLuint index + GLuint buffer + + + void glTransformFeedbackBufferRange + GLuint xfb + GLuint index + GLuint buffer + GLintptr offset + GLsizei size + + + void glTransformFeedbackStreamAttribsNV + GLsizei count + const GLint *attribs + GLsizei nbuffers + const GLint *bufstreams + GLenum bufferMode + + + void glTransformFeedbackVaryings + GLuint program + GLsizei count + const GLchar *const*varyings + GLenum bufferMode + + + void glTransformFeedbackVaryingsEXT + GLuint program + GLsizei count + const GLchar *const*varyings + GLenum bufferMode + + + + void glTransformFeedbackVaryingsNV + GLuint program + GLsizei count + const GLint *locations + GLenum bufferMode + + + void glTransformPathNV + GLuint resultPath + GLuint srcPath + GLenum transformType + const GLfloat *transformValues + + + void glTranslated + GLdouble x + GLdouble y + GLdouble z + + + + void glTranslatef + GLfloat x + GLfloat y + GLfloat z + + + + void glTranslatex + GLfixed x + GLfixed y + GLfixed z + + + void glTranslatexOES + GLfixed x + GLfixed y + GLfixed z + + + void glUniform1d + GLint location + GLdouble x + + + void glUniform1dv + GLint location + GLsizei count + const GLdouble *value + + + void glUniform1f + GLint location + GLfloat v0 + + + void glUniform1fARB + GLint location + GLfloat v0 + + + + void glUniform1fv + GLint location + GLsizei count + const GLfloat *value + + + void glUniform1fvARB + GLint location + GLsizei count + const GLfloat *value + + + + void glUniform1i + GLint location + GLint v0 + + + void glUniform1i64NV + GLint location + GLint64EXT x + + + void glUniform1i64vNV + GLint location + GLsizei count + const GLint64EXT *value + + + void glUniform1iARB + GLint location + GLint v0 + + + + void glUniform1iv + GLint location + GLsizei count + const GLint *value + + + void glUniform1ivARB + GLint location + GLsizei count + const GLint *value + + + + void glUniform1ui + GLint location + GLuint v0 + + + void glUniform1ui64NV + GLint location + GLuint64EXT x + + + void glUniform1ui64vNV + GLint location + GLsizei count + const GLuint64EXT *value + + + void glUniform1uiEXT + GLint location + GLuint v0 + + + + void glUniform1uiv + GLint location + GLsizei count + const GLuint *value + + + void glUniform1uivEXT + GLint location + GLsizei count + const GLuint *value + + + + void glUniform2d + GLint location + GLdouble x + GLdouble y + + + void glUniform2dv + GLint location + GLsizei count + const GLdouble *value + + + void glUniform2f + GLint location + GLfloat v0 + GLfloat v1 + + + void glUniform2fARB + GLint location + GLfloat v0 + GLfloat v1 + + + + void glUniform2fv + GLint location + GLsizei count + const GLfloat *value + + + void glUniform2fvARB + GLint location + GLsizei count + const GLfloat *value + + + + void glUniform2i + GLint location + GLint v0 + GLint v1 + + + void glUniform2i64NV + GLint location + GLint64EXT x + GLint64EXT y + + + void glUniform2i64vNV + GLint location + GLsizei count + const GLint64EXT *value + + + void glUniform2iARB + GLint location + GLint v0 + GLint v1 + + + + void glUniform2iv + GLint location + GLsizei count + const GLint *value + + + void glUniform2ivARB + GLint location + GLsizei count + const GLint *value + + + + void glUniform2ui + GLint location + GLuint v0 + GLuint v1 + + + void glUniform2ui64NV + GLint location + GLuint64EXT x + GLuint64EXT y + + + void glUniform2ui64vNV + GLint location + GLsizei count + const GLuint64EXT *value + + + void glUniform2uiEXT + GLint location + GLuint v0 + GLuint v1 + + + + void glUniform2uiv + GLint location + GLsizei count + const GLuint *value + + + void glUniform2uivEXT + GLint location + GLsizei count + const GLuint *value + + + + void glUniform3d + GLint location + GLdouble x + GLdouble y + GLdouble z + + + void glUniform3dv + GLint location + GLsizei count + const GLdouble *value + + + void glUniform3f + GLint location + GLfloat v0 + GLfloat v1 + GLfloat v2 + + + void glUniform3fARB + GLint location + GLfloat v0 + GLfloat v1 + GLfloat v2 + + + + void glUniform3fv + GLint location + GLsizei count + const GLfloat *value + + + void glUniform3fvARB + GLint location + GLsizei count + const GLfloat *value + + + + void glUniform3i + GLint location + GLint v0 + GLint v1 + GLint v2 + + + void glUniform3i64NV + GLint location + GLint64EXT x + GLint64EXT y + GLint64EXT z + + + void glUniform3i64vNV + GLint location + GLsizei count + const GLint64EXT *value + + + void glUniform3iARB + GLint location + GLint v0 + GLint v1 + GLint v2 + + + + void glUniform3iv + GLint location + GLsizei count + const GLint *value + + + void glUniform3ivARB + GLint location + GLsizei count + const GLint *value + + + + void glUniform3ui + GLint location + GLuint v0 + GLuint v1 + GLuint v2 + + + void glUniform3ui64NV + GLint location + GLuint64EXT x + GLuint64EXT y + GLuint64EXT z + + + void glUniform3ui64vNV + GLint location + GLsizei count + const GLuint64EXT *value + + + void glUniform3uiEXT + GLint location + GLuint v0 + GLuint v1 + GLuint v2 + + + + void glUniform3uiv + GLint location + GLsizei count + const GLuint *value + + + void glUniform3uivEXT + GLint location + GLsizei count + const GLuint *value + + + + void glUniform4d + GLint location + GLdouble x + GLdouble y + GLdouble z + GLdouble w + + + void glUniform4dv + GLint location + GLsizei count + const GLdouble *value + + + void glUniform4f + GLint location + GLfloat v0 + GLfloat v1 + GLfloat v2 + GLfloat v3 + + + void glUniform4fARB + GLint location + GLfloat v0 + GLfloat v1 + GLfloat v2 + GLfloat v3 + + + + void glUniform4fv + GLint location + GLsizei count + const GLfloat *value + + + void glUniform4fvARB + GLint location + GLsizei count + const GLfloat *value + + + + void glUniform4i + GLint location + GLint v0 + GLint v1 + GLint v2 + GLint v3 + + + void glUniform4i64NV + GLint location + GLint64EXT x + GLint64EXT y + GLint64EXT z + GLint64EXT w + + + void glUniform4i64vNV + GLint location + GLsizei count + const GLint64EXT *value + + + void glUniform4iARB + GLint location + GLint v0 + GLint v1 + GLint v2 + GLint v3 + + + + void glUniform4iv + GLint location + GLsizei count + const GLint *value + + + void glUniform4ivARB + GLint location + GLsizei count + const GLint *value + + + + void glUniform4ui + GLint location + GLuint v0 + GLuint v1 + GLuint v2 + GLuint v3 + + + void glUniform4ui64NV + GLint location + GLuint64EXT x + GLuint64EXT y + GLuint64EXT z + GLuint64EXT w + + + void glUniform4ui64vNV + GLint location + GLsizei count + const GLuint64EXT *value + + + void glUniform4uiEXT + GLint location + GLuint v0 + GLuint v1 + GLuint v2 + GLuint v3 + + + + void glUniform4uiv + GLint location + GLsizei count + const GLuint *value + + + void glUniform4uivEXT + GLint location + GLsizei count + const GLuint *value + + + + void glUniformBlockBinding + GLuint program + GLuint uniformBlockIndex + GLuint uniformBlockBinding + + + void glUniformBufferEXT + GLuint program + GLint location + GLuint buffer + + + void glUniformHandleui64ARB + GLint location + GLuint64 value + + + void glUniformHandleui64NV + GLint location + GLuint64 value + + + void glUniformHandleui64vARB + GLint location + GLsizei count + const GLuint64 *value + + + void glUniformHandleui64vNV + GLint location + GLsizei count + const GLuint64 *value + + + void glUniformMatrix2dv + GLint location + GLsizei count + GLboolean transpose + const GLdouble *value + + + void glUniformMatrix2fv + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + void glUniformMatrix2fvARB + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + + void glUniformMatrix2x3dv + GLint location + GLsizei count + GLboolean transpose + const GLdouble *value + + + void glUniformMatrix2x3fv + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + + void glUniformMatrix2x3fvNV + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + + void glUniformMatrix2x4dv + GLint location + GLsizei count + GLboolean transpose + const GLdouble *value + + + void glUniformMatrix2x4fv + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + + void glUniformMatrix2x4fvNV + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + + void glUniformMatrix3dv + GLint location + GLsizei count + GLboolean transpose + const GLdouble *value + + + void glUniformMatrix3fv + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + void glUniformMatrix3fvARB + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + + void glUniformMatrix3x2dv + GLint location + GLsizei count + GLboolean transpose + const GLdouble *value + + + void glUniformMatrix3x2fv + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + + void glUniformMatrix3x2fvNV + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + + void glUniformMatrix3x4dv + GLint location + GLsizei count + GLboolean transpose + const GLdouble *value + + + void glUniformMatrix3x4fv + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + + void glUniformMatrix3x4fvNV + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + + void glUniformMatrix4dv + GLint location + GLsizei count + GLboolean transpose + const GLdouble *value + + + void glUniformMatrix4fv + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + void glUniformMatrix4fvARB + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + + void glUniformMatrix4x2dv + GLint location + GLsizei count + GLboolean transpose + const GLdouble *value + + + void glUniformMatrix4x2fv + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + + void glUniformMatrix4x2fvNV + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + + void glUniformMatrix4x3dv + GLint location + GLsizei count + GLboolean transpose + const GLdouble *value + + + void glUniformMatrix4x3fv + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + + void glUniformMatrix4x3fvNV + GLint location + GLsizei count + GLboolean transpose + const GLfloat *value + + + + void glUniformSubroutinesuiv + GLenum shadertype + GLsizei count + const GLuint *indices + + + void glUniformui64NV + GLint location + GLuint64EXT value + + + void glUniformui64vNV + GLint location + GLsizei count + const GLuint64EXT *value + + + void glUnlockArraysEXT + + + GLboolean glUnmapBuffer + GLenum target + + + GLboolean glUnmapBufferARB + GLenum target + + + + GLboolean glUnmapBufferOES + GLenum target + + + + GLboolean glUnmapNamedBuffer + GLuint buffer + + + GLboolean glUnmapNamedBufferEXT + GLuint buffer + + + void glUnmapObjectBufferATI + GLuint buffer + + + void glUnmapTexture2DINTEL + GLuint texture + GLint level + + + void glUpdateObjectBufferATI + GLuint buffer + GLuint offset + GLsizei size + const void *pointer + GLenum preserve + + + void glUseProgram + GLuint program + + + void glUseProgramObjectARB + GLhandleARB programObj + + + + void glUseProgramStages + GLuint pipeline + GLbitfield stages + GLuint program + + + void glUseProgramStagesEXT + GLuint pipeline + GLbitfield stages + GLuint program + + + void glUseShaderProgramEXT + GLenum type + GLuint program + + + void glVDPAUFiniNV + + + void glVDPAUGetSurfaceivNV + GLvdpauSurfaceNV surface + GLenum pname + GLsizei bufSize + GLsizei *length + GLint *values + + + void glVDPAUInitNV + const void *vdpDevice + const void *getProcAddress + + + GLboolean glVDPAUIsSurfaceNV + GLvdpauSurfaceNV surface + + + void glVDPAUMapSurfacesNV + GLsizei numSurfaces + const GLvdpauSurfaceNV *surfaces + + + GLvdpauSurfaceNV glVDPAURegisterOutputSurfaceNV + const void *vdpSurface + GLenum target + GLsizei numTextureNames + const GLuint *textureNames + + + GLvdpauSurfaceNV glVDPAURegisterVideoSurfaceNV + const void *vdpSurface + GLenum target + GLsizei numTextureNames + const GLuint *textureNames + + + void glVDPAUSurfaceAccessNV + GLvdpauSurfaceNV surface + GLenum access + + + void glVDPAUUnmapSurfacesNV + GLsizei numSurface + const GLvdpauSurfaceNV *surfaces + + + void glVDPAUUnregisterSurfaceNV + GLvdpauSurfaceNV surface + + + void glValidateProgram + GLuint program + + + void glValidateProgramARB + GLhandleARB programObj + + + + void glValidateProgramPipeline + GLuint pipeline + + + void glValidateProgramPipelineEXT + GLuint pipeline + + + void glVariantArrayObjectATI + GLuint id + GLenum type + GLsizei stride + GLuint buffer + GLuint offset + + + void glVariantPointerEXT + GLuint id + GLenum type + GLuint stride + const void *addr + + + void glVariantbvEXT + GLuint id + const GLbyte *addr + + + void glVariantdvEXT + GLuint id + const GLdouble *addr + + + void glVariantfvEXT + GLuint id + const GLfloat *addr + + + void glVariantivEXT + GLuint id + const GLint *addr + + + void glVariantsvEXT + GLuint id + const GLshort *addr + + + void glVariantubvEXT + GLuint id + const GLubyte *addr + + + void glVariantuivEXT + GLuint id + const GLuint *addr + + + void glVariantusvEXT + GLuint id + const GLushort *addr + + + void glVertex2bOES + GLbyte x + GLbyte y + + + void glVertex2bvOES + const GLbyte *coords + + + void glVertex2d + GLdouble x + GLdouble y + + + + void glVertex2dv + const GLdouble *v + + + + void glVertex2f + GLfloat x + GLfloat y + + + + void glVertex2fv + const GLfloat *v + + + + void glVertex2hNV + GLhalfNV x + GLhalfNV y + + + + void glVertex2hvNV + const GLhalfNV *v + + + + void glVertex2i + GLint x + GLint y + + + + void glVertex2iv + const GLint *v + + + + void glVertex2s + GLshort x + GLshort y + + + + void glVertex2sv + const GLshort *v + + + + void glVertex2xOES + GLfixed x + + + void glVertex2xvOES + const GLfixed *coords + + + void glVertex3bOES + GLbyte x + GLbyte y + GLbyte z + + + void glVertex3bvOES + const GLbyte *coords + + + void glVertex3d + GLdouble x + GLdouble y + GLdouble z + + + + void glVertex3dv + const GLdouble *v + + + + void glVertex3f + GLfloat x + GLfloat y + GLfloat z + + + + void glVertex3fv + const GLfloat *v + + + + void glVertex3hNV + GLhalfNV x + GLhalfNV y + GLhalfNV z + + + + void glVertex3hvNV + const GLhalfNV *v + + + + void glVertex3i + GLint x + GLint y + GLint z + + + + void glVertex3iv + const GLint *v + + + + void glVertex3s + GLshort x + GLshort y + GLshort z + + + + void glVertex3sv + const GLshort *v + + + + void glVertex3xOES + GLfixed x + GLfixed y + + + void glVertex3xvOES + const GLfixed *coords + + + void glVertex4bOES + GLbyte x + GLbyte y + GLbyte z + GLbyte w + + + void glVertex4bvOES + const GLbyte *coords + + + void glVertex4d + GLdouble x + GLdouble y + GLdouble z + GLdouble w + + + + void glVertex4dv + const GLdouble *v + + + + void glVertex4f + GLfloat x + GLfloat y + GLfloat z + GLfloat w + + + + void glVertex4fv + const GLfloat *v + + + + void glVertex4hNV + GLhalfNV x + GLhalfNV y + GLhalfNV z + GLhalfNV w + + + + void glVertex4hvNV + const GLhalfNV *v + + + + void glVertex4i + GLint x + GLint y + GLint z + GLint w + + + + void glVertex4iv + const GLint *v + + + + void glVertex4s + GLshort x + GLshort y + GLshort z + GLshort w + + + + void glVertex4sv + const GLshort *v + + + + void glVertex4xOES + GLfixed x + GLfixed y + GLfixed z + + + void glVertex4xvOES + const GLfixed *coords + + + void glVertexArrayAttribBinding + GLuint vaobj + GLuint attribindex + GLuint bindingindex + + + void glVertexArrayAttribFormat + GLuint vaobj + GLuint attribindex + GLint size + GLenum type + GLboolean normalized + GLuint relativeoffset + + + void glVertexArrayAttribIFormat + GLuint vaobj + GLuint attribindex + GLint size + GLenum type + GLuint relativeoffset + + + void glVertexArrayAttribLFormat + GLuint vaobj + GLuint attribindex + GLint size + GLenum type + GLuint relativeoffset + + + void glVertexArrayBindVertexBufferEXT + GLuint vaobj + GLuint bindingindex + GLuint buffer + GLintptr offset + GLsizei stride + + + void glVertexArrayBindingDivisor + GLuint vaobj + GLuint bindingindex + GLuint divisor + + + void glVertexArrayColorOffsetEXT + GLuint vaobj + GLuint buffer + GLint size + GLenum type + GLsizei stride + GLintptr offset + + + void glVertexArrayEdgeFlagOffsetEXT + GLuint vaobj + GLuint buffer + GLsizei stride + GLintptr offset + + + void glVertexArrayElementBuffer + GLuint vaobj + GLuint buffer + + + void glVertexArrayFogCoordOffsetEXT + GLuint vaobj + GLuint buffer + GLenum type + GLsizei stride + GLintptr offset + + + void glVertexArrayIndexOffsetEXT + GLuint vaobj + GLuint buffer + GLenum type + GLsizei stride + GLintptr offset + + + void glVertexArrayMultiTexCoordOffsetEXT + GLuint vaobj + GLuint buffer + GLenum texunit + GLint size + GLenum type + GLsizei stride + GLintptr offset + + + void glVertexArrayNormalOffsetEXT + GLuint vaobj + GLuint buffer + GLenum type + GLsizei stride + GLintptr offset + + + void glVertexArrayParameteriAPPLE + GLenum pname + GLint param + + + void glVertexArrayRangeAPPLE + GLsizei length + void *pointer + + + void glVertexArrayRangeNV + GLsizei length + const void *pointer + + + void glVertexArraySecondaryColorOffsetEXT + GLuint vaobj + GLuint buffer + GLint size + GLenum type + GLsizei stride + GLintptr offset + + + void glVertexArrayTexCoordOffsetEXT + GLuint vaobj + GLuint buffer + GLint size + GLenum type + GLsizei stride + GLintptr offset + + + void glVertexArrayVertexAttribBindingEXT + GLuint vaobj + GLuint attribindex + GLuint bindingindex + + + void glVertexArrayVertexAttribDivisorEXT + GLuint vaobj + GLuint index + GLuint divisor + + + void glVertexArrayVertexAttribFormatEXT + GLuint vaobj + GLuint attribindex + GLint size + GLenum type + GLboolean normalized + GLuint relativeoffset + + + void glVertexArrayVertexAttribIFormatEXT + GLuint vaobj + GLuint attribindex + GLint size + GLenum type + GLuint relativeoffset + + + void glVertexArrayVertexAttribIOffsetEXT + GLuint vaobj + GLuint buffer + GLuint index + GLint size + GLenum type + GLsizei stride + GLintptr offset + + + void glVertexArrayVertexAttribLFormatEXT + GLuint vaobj + GLuint attribindex + GLint size + GLenum type + GLuint relativeoffset + + + void glVertexArrayVertexAttribLOffsetEXT + GLuint vaobj + GLuint buffer + GLuint index + GLint size + GLenum type + GLsizei stride + GLintptr offset + + + void glVertexArrayVertexAttribOffsetEXT + GLuint vaobj + GLuint buffer + GLuint index + GLint size + GLenum type + GLboolean normalized + GLsizei stride + GLintptr offset + + + void glVertexArrayVertexBindingDivisorEXT + GLuint vaobj + GLuint bindingindex + GLuint divisor + + + void glVertexArrayVertexBuffer + GLuint vaobj + GLuint bindingindex + GLuint buffer + GLintptr offset + GLsizei stride + + + void glVertexArrayVertexBuffers + GLuint vaobj + GLuint first + GLsizei count + const GLuint *buffers + const GLintptr *offsets + const GLsizei *strides + + + void glVertexArrayVertexOffsetEXT + GLuint vaobj + GLuint buffer + GLint size + GLenum type + GLsizei stride + GLintptr offset + + + void glVertexAttrib1d + GLuint index + GLdouble x + + + + void glVertexAttrib1dARB + GLuint index + GLdouble x + + + + + void glVertexAttrib1dNV + GLuint index + GLdouble x + + + + + void glVertexAttrib1dv + GLuint index + const GLdouble *v + + + + void glVertexAttrib1dvARB + GLuint index + const GLdouble *v + + + + + void glVertexAttrib1dvNV + GLuint index + const GLdouble *v + + + + + void glVertexAttrib1f + GLuint index + GLfloat x + + + + void glVertexAttrib1fARB + GLuint index + GLfloat x + + + + + void glVertexAttrib1fNV + GLuint index + GLfloat x + + + + + void glVertexAttrib1fv + GLuint index + const GLfloat *v + + + + void glVertexAttrib1fvARB + GLuint index + const GLfloat *v + + + + + void glVertexAttrib1fvNV + GLuint index + const GLfloat *v + + + + + void glVertexAttrib1hNV + GLuint index + GLhalfNV x + + + + void glVertexAttrib1hvNV + GLuint index + const GLhalfNV *v + + + + void glVertexAttrib1s + GLuint index + GLshort x + + + + void glVertexAttrib1sARB + GLuint index + GLshort x + + + + + void glVertexAttrib1sNV + GLuint index + GLshort x + + + + + void glVertexAttrib1sv + GLuint index + const GLshort *v + + + + void glVertexAttrib1svARB + GLuint index + const GLshort *v + + + + + void glVertexAttrib1svNV + GLuint index + const GLshort *v + + + + + void glVertexAttrib2d + GLuint index + GLdouble x + GLdouble y + + + + void glVertexAttrib2dARB + GLuint index + GLdouble x + GLdouble y + + + + + void glVertexAttrib2dNV + GLuint index + GLdouble x + GLdouble y + + + + + void glVertexAttrib2dv + GLuint index + const GLdouble *v + + + + void glVertexAttrib2dvARB + GLuint index + const GLdouble *v + + + + + void glVertexAttrib2dvNV + GLuint index + const GLdouble *v + + + + + void glVertexAttrib2f + GLuint index + GLfloat x + GLfloat y + + + + void glVertexAttrib2fARB + GLuint index + GLfloat x + GLfloat y + + + + + void glVertexAttrib2fNV + GLuint index + GLfloat x + GLfloat y + + + + + void glVertexAttrib2fv + GLuint index + const GLfloat *v + + + + void glVertexAttrib2fvARB + GLuint index + const GLfloat *v + + + + + void glVertexAttrib2fvNV + GLuint index + const GLfloat *v + + + + + void glVertexAttrib2hNV + GLuint index + GLhalfNV x + GLhalfNV y + + + + void glVertexAttrib2hvNV + GLuint index + const GLhalfNV *v + + + + void glVertexAttrib2s + GLuint index + GLshort x + GLshort y + + + + void glVertexAttrib2sARB + GLuint index + GLshort x + GLshort y + + + + + void glVertexAttrib2sNV + GLuint index + GLshort x + GLshort y + + + + + void glVertexAttrib2sv + GLuint index + const GLshort *v + + + + void glVertexAttrib2svARB + GLuint index + const GLshort *v + + + + + void glVertexAttrib2svNV + GLuint index + const GLshort *v + + + + + void glVertexAttrib3d + GLuint index + GLdouble x + GLdouble y + GLdouble z + + + + void glVertexAttrib3dARB + GLuint index + GLdouble x + GLdouble y + GLdouble z + + + + + void glVertexAttrib3dNV + GLuint index + GLdouble x + GLdouble y + GLdouble z + + + + + void glVertexAttrib3dv + GLuint index + const GLdouble *v + + + + void glVertexAttrib3dvARB + GLuint index + const GLdouble *v + + + + + void glVertexAttrib3dvNV + GLuint index + const GLdouble *v + + + + + void glVertexAttrib3f + GLuint index + GLfloat x + GLfloat y + GLfloat z + + + + void glVertexAttrib3fARB + GLuint index + GLfloat x + GLfloat y + GLfloat z + + + + + void glVertexAttrib3fNV + GLuint index + GLfloat x + GLfloat y + GLfloat z + + + + + void glVertexAttrib3fv + GLuint index + const GLfloat *v + + + + void glVertexAttrib3fvARB + GLuint index + const GLfloat *v + + + + + void glVertexAttrib3fvNV + GLuint index + const GLfloat *v + + + + + void glVertexAttrib3hNV + GLuint index + GLhalfNV x + GLhalfNV y + GLhalfNV z + + + + void glVertexAttrib3hvNV + GLuint index + const GLhalfNV *v + + + + void glVertexAttrib3s + GLuint index + GLshort x + GLshort y + GLshort z + + + + void glVertexAttrib3sARB + GLuint index + GLshort x + GLshort y + GLshort z + + + + + void glVertexAttrib3sNV + GLuint index + GLshort x + GLshort y + GLshort z + + + + + void glVertexAttrib3sv + GLuint index + const GLshort *v + + + + void glVertexAttrib3svARB + GLuint index + const GLshort *v + + + + + void glVertexAttrib3svNV + GLuint index + const GLshort *v + + + + + void glVertexAttrib4Nbv + GLuint index + const GLbyte *v + + + void glVertexAttrib4NbvARB + GLuint index + const GLbyte *v + + + + void glVertexAttrib4Niv + GLuint index + const GLint *v + + + void glVertexAttrib4NivARB + GLuint index + const GLint *v + + + + void glVertexAttrib4Nsv + GLuint index + const GLshort *v + + + void glVertexAttrib4NsvARB + GLuint index + const GLshort *v + + + + void glVertexAttrib4Nub + GLuint index + GLubyte x + GLubyte y + GLubyte z + GLubyte w + + + void glVertexAttrib4NubARB + GLuint index + GLubyte x + GLubyte y + GLubyte z + GLubyte w + + + + void glVertexAttrib4Nubv + GLuint index + const GLubyte *v + + + + void glVertexAttrib4NubvARB + GLuint index + const GLubyte *v + + + + + void glVertexAttrib4Nuiv + GLuint index + const GLuint *v + + + void glVertexAttrib4NuivARB + GLuint index + const GLuint *v + + + + void glVertexAttrib4Nusv + GLuint index + const GLushort *v + + + void glVertexAttrib4NusvARB + GLuint index + const GLushort *v + + + + void glVertexAttrib4bv + GLuint index + const GLbyte *v + + + void glVertexAttrib4bvARB + GLuint index + const GLbyte *v + + + + void glVertexAttrib4d + GLuint index + GLdouble x + GLdouble y + GLdouble z + GLdouble w + + + + void glVertexAttrib4dARB + GLuint index + GLdouble x + GLdouble y + GLdouble z + GLdouble w + + + + + void glVertexAttrib4dNV + GLuint index + GLdouble x + GLdouble y + GLdouble z + GLdouble w + + + + + void glVertexAttrib4dv + GLuint index + const GLdouble *v + + + + void glVertexAttrib4dvARB + GLuint index + const GLdouble *v + + + + + void glVertexAttrib4dvNV + GLuint index + const GLdouble *v + + + + + void glVertexAttrib4f + GLuint index + GLfloat x + GLfloat y + GLfloat z + GLfloat w + + + + void glVertexAttrib4fARB + GLuint index + GLfloat x + GLfloat y + GLfloat z + GLfloat w + + + + + void glVertexAttrib4fNV + GLuint index + GLfloat x + GLfloat y + GLfloat z + GLfloat w + + + + + void glVertexAttrib4fv + GLuint index + const GLfloat *v + + + + void glVertexAttrib4fvARB + GLuint index + const GLfloat *v + + + + + void glVertexAttrib4fvNV + GLuint index + const GLfloat *v + + + + + void glVertexAttrib4hNV + GLuint index + GLhalfNV x + GLhalfNV y + GLhalfNV z + GLhalfNV w + + + + void glVertexAttrib4hvNV + GLuint index + const GLhalfNV *v + + + + void glVertexAttrib4iv + GLuint index + const GLint *v + + + void glVertexAttrib4ivARB + GLuint index + const GLint *v + + + + void glVertexAttrib4s + GLuint index + GLshort x + GLshort y + GLshort z + GLshort w + + + + void glVertexAttrib4sARB + GLuint index + GLshort x + GLshort y + GLshort z + GLshort w + + + + + void glVertexAttrib4sNV + GLuint index + GLshort x + GLshort y + GLshort z + GLshort w + + + + + void glVertexAttrib4sv + GLuint index + const GLshort *v + + + + void glVertexAttrib4svARB + GLuint index + const GLshort *v + + + + + void glVertexAttrib4svNV + GLuint index + const GLshort *v + + + + + void glVertexAttrib4ubNV + GLuint index + GLubyte x + GLubyte y + GLubyte z + GLubyte w + + + + + void glVertexAttrib4ubv + GLuint index + const GLubyte *v + + + void glVertexAttrib4ubvARB + GLuint index + const GLubyte *v + + + + void glVertexAttrib4ubvNV + GLuint index + const GLubyte *v + + + + + void glVertexAttrib4uiv + GLuint index + const GLuint *v + + + void glVertexAttrib4uivARB + GLuint index + const GLuint *v + + + + void glVertexAttrib4usv + GLuint index + const GLushort *v + + + void glVertexAttrib4usvARB + GLuint index + const GLushort *v + + + + void glVertexAttribArrayObjectATI + GLuint index + GLint size + GLenum type + GLboolean normalized + GLsizei stride + GLuint buffer + GLuint offset + + + void glVertexAttribBinding + GLuint attribindex + GLuint bindingindex + + + void glVertexAttribDivisor + GLuint index + GLuint divisor + + + void glVertexAttribDivisorANGLE + GLuint index + GLuint divisor + + + + void glVertexAttribDivisorARB + GLuint index + GLuint divisor + + + + void glVertexAttribDivisorEXT + GLuint index + GLuint divisor + + + + void glVertexAttribDivisorNV + GLuint index + GLuint divisor + + + + void glVertexAttribFormat + GLuint attribindex + GLint size + GLenum type + GLboolean normalized + GLuint relativeoffset + + + void glVertexAttribFormatNV + GLuint index + GLint size + GLenum type + GLboolean normalized + GLsizei stride + + + void glVertexAttribI1i + GLuint index + GLint x + + + + void glVertexAttribI1iEXT + GLuint index + GLint x + + + + + void glVertexAttribI1iv + GLuint index + const GLint *v + + + void glVertexAttribI1ivEXT + GLuint index + const GLint *v + + + + void glVertexAttribI1ui + GLuint index + GLuint x + + + + void glVertexAttribI1uiEXT + GLuint index + GLuint x + + + + + void glVertexAttribI1uiv + GLuint index + const GLuint *v + + + void glVertexAttribI1uivEXT + GLuint index + const GLuint *v + + + + void glVertexAttribI2i + GLuint index + GLint x + GLint y + + + + void glVertexAttribI2iEXT + GLuint index + GLint x + GLint y + + + + + void glVertexAttribI2iv + GLuint index + const GLint *v + + + void glVertexAttribI2ivEXT + GLuint index + const GLint *v + + + + void glVertexAttribI2ui + GLuint index + GLuint x + GLuint y + + + + void glVertexAttribI2uiEXT + GLuint index + GLuint x + GLuint y + + + + + void glVertexAttribI2uiv + GLuint index + const GLuint *v + + + void glVertexAttribI2uivEXT + GLuint index + const GLuint *v + + + + void glVertexAttribI3i + GLuint index + GLint x + GLint y + GLint z + + + + void glVertexAttribI3iEXT + GLuint index + GLint x + GLint y + GLint z + + + + + void glVertexAttribI3iv + GLuint index + const GLint *v + + + void glVertexAttribI3ivEXT + GLuint index + const GLint *v + + + + void glVertexAttribI3ui + GLuint index + GLuint x + GLuint y + GLuint z + + + + void glVertexAttribI3uiEXT + GLuint index + GLuint x + GLuint y + GLuint z + + + + + void glVertexAttribI3uiv + GLuint index + const GLuint *v + + + void glVertexAttribI3uivEXT + GLuint index + const GLuint *v + + + + void glVertexAttribI4bv + GLuint index + const GLbyte *v + + + void glVertexAttribI4bvEXT + GLuint index + const GLbyte *v + + + + void glVertexAttribI4i + GLuint index + GLint x + GLint y + GLint z + GLint w + + + + void glVertexAttribI4iEXT + GLuint index + GLint x + GLint y + GLint z + GLint w + + + + + void glVertexAttribI4iv + GLuint index + const GLint *v + + + void glVertexAttribI4ivEXT + GLuint index + const GLint *v + + + + void glVertexAttribI4sv + GLuint index + const GLshort *v + + + void glVertexAttribI4svEXT + GLuint index + const GLshort *v + + + + void glVertexAttribI4ubv + GLuint index + const GLubyte *v + + + void glVertexAttribI4ubvEXT + GLuint index + const GLubyte *v + + + + void glVertexAttribI4ui + GLuint index + GLuint x + GLuint y + GLuint z + GLuint w + + + + void glVertexAttribI4uiEXT + GLuint index + GLuint x + GLuint y + GLuint z + GLuint w + + + + + void glVertexAttribI4uiv + GLuint index + const GLuint *v + + + void glVertexAttribI4uivEXT + GLuint index + const GLuint *v + + + + void glVertexAttribI4usv + GLuint index + const GLushort *v + + + void glVertexAttribI4usvEXT + GLuint index + const GLushort *v + + + + void glVertexAttribIFormat + GLuint attribindex + GLint size + GLenum type + GLuint relativeoffset + + + void glVertexAttribIFormatNV + GLuint index + GLint size + GLenum type + GLsizei stride + + + void glVertexAttribIPointer + GLuint index + GLint size + GLenum type + GLsizei stride + const void *pointer + + + void glVertexAttribIPointerEXT + GLuint index + GLint size + GLenum type + GLsizei stride + const void *pointer + + + + void glVertexAttribL1d + GLuint index + GLdouble x + + + void glVertexAttribL1dEXT + GLuint index + GLdouble x + + + + void glVertexAttribL1dv + GLuint index + const GLdouble *v + + + void glVertexAttribL1dvEXT + GLuint index + const GLdouble *v + + + + void glVertexAttribL1i64NV + GLuint index + GLint64EXT x + + + void glVertexAttribL1i64vNV + GLuint index + const GLint64EXT *v + + + void glVertexAttribL1ui64ARB + GLuint index + GLuint64EXT x + + + void glVertexAttribL1ui64NV + GLuint index + GLuint64EXT x + + + void glVertexAttribL1ui64vARB + GLuint index + const GLuint64EXT *v + + + void glVertexAttribL1ui64vNV + GLuint index + const GLuint64EXT *v + + + void glVertexAttribL2d + GLuint index + GLdouble x + GLdouble y + + + void glVertexAttribL2dEXT + GLuint index + GLdouble x + GLdouble y + + + + void glVertexAttribL2dv + GLuint index + const GLdouble *v + + + void glVertexAttribL2dvEXT + GLuint index + const GLdouble *v + + + + void glVertexAttribL2i64NV + GLuint index + GLint64EXT x + GLint64EXT y + + + void glVertexAttribL2i64vNV + GLuint index + const GLint64EXT *v + + + void glVertexAttribL2ui64NV + GLuint index + GLuint64EXT x + GLuint64EXT y + + + void glVertexAttribL2ui64vNV + GLuint index + const GLuint64EXT *v + + + void glVertexAttribL3d + GLuint index + GLdouble x + GLdouble y + GLdouble z + + + void glVertexAttribL3dEXT + GLuint index + GLdouble x + GLdouble y + GLdouble z + + + + void glVertexAttribL3dv + GLuint index + const GLdouble *v + + + void glVertexAttribL3dvEXT + GLuint index + const GLdouble *v + + + + void glVertexAttribL3i64NV + GLuint index + GLint64EXT x + GLint64EXT y + GLint64EXT z + + + void glVertexAttribL3i64vNV + GLuint index + const GLint64EXT *v + + + void glVertexAttribL3ui64NV + GLuint index + GLuint64EXT x + GLuint64EXT y + GLuint64EXT z + + + void glVertexAttribL3ui64vNV + GLuint index + const GLuint64EXT *v + + + void glVertexAttribL4d + GLuint index + GLdouble x + GLdouble y + GLdouble z + GLdouble w + + + void glVertexAttribL4dEXT + GLuint index + GLdouble x + GLdouble y + GLdouble z + GLdouble w + + + + void glVertexAttribL4dv + GLuint index + const GLdouble *v + + + void glVertexAttribL4dvEXT + GLuint index + const GLdouble *v + + + + void glVertexAttribL4i64NV + GLuint index + GLint64EXT x + GLint64EXT y + GLint64EXT z + GLint64EXT w + + + void glVertexAttribL4i64vNV + GLuint index + const GLint64EXT *v + + + void glVertexAttribL4ui64NV + GLuint index + GLuint64EXT x + GLuint64EXT y + GLuint64EXT z + GLuint64EXT w + + + void glVertexAttribL4ui64vNV + GLuint index + const GLuint64EXT *v + + + void glVertexAttribLFormat + GLuint attribindex + GLint size + GLenum type + GLuint relativeoffset + + + void glVertexAttribLFormatNV + GLuint index + GLint size + GLenum type + GLsizei stride + + + void glVertexAttribLPointer + GLuint index + GLint size + GLenum type + GLsizei stride + const void *pointer + + + void glVertexAttribLPointerEXT + GLuint index + GLint size + GLenum type + GLsizei stride + const void *pointer + + + + void glVertexAttribP1ui + GLuint index + GLenum type + GLboolean normalized + GLuint value + + + void glVertexAttribP1uiv + GLuint index + GLenum type + GLboolean normalized + const GLuint *value + + + void glVertexAttribP2ui + GLuint index + GLenum type + GLboolean normalized + GLuint value + + + void glVertexAttribP2uiv + GLuint index + GLenum type + GLboolean normalized + const GLuint *value + + + void glVertexAttribP3ui + GLuint index + GLenum type + GLboolean normalized + GLuint value + + + void glVertexAttribP3uiv + GLuint index + GLenum type + GLboolean normalized + const GLuint *value + + + void glVertexAttribP4ui + GLuint index + GLenum type + GLboolean normalized + GLuint value + + + void glVertexAttribP4uiv + GLuint index + GLenum type + GLboolean normalized + const GLuint *value + + + void glVertexAttribParameteriAMD + GLuint index + GLenum pname + GLint param + + + void glVertexAttribPointer + GLuint index + GLint size + GLenum type + GLboolean normalized + GLsizei stride + const void *pointer + + + void glVertexAttribPointerARB + GLuint index + GLint size + GLenum type + GLboolean normalized + GLsizei stride + const void *pointer + + + + void glVertexAttribPointerNV + GLuint index + GLint fsize + GLenum type + GLsizei stride + const void *pointer + + + void glVertexAttribs1dvNV + GLuint index + GLsizei count + const GLdouble *v + + + + void glVertexAttribs1fvNV + GLuint index + GLsizei count + const GLfloat *v + + + + void glVertexAttribs1hvNV + GLuint index + GLsizei n + const GLhalfNV *v + + + + void glVertexAttribs1svNV + GLuint index + GLsizei count + const GLshort *v + + + + void glVertexAttribs2dvNV + GLuint index + GLsizei count + const GLdouble *v + + + + void glVertexAttribs2fvNV + GLuint index + GLsizei count + const GLfloat *v + + + + void glVertexAttribs2hvNV + GLuint index + GLsizei n + const GLhalfNV *v + + + + void glVertexAttribs2svNV + GLuint index + GLsizei count + const GLshort *v + + + + void glVertexAttribs3dvNV + GLuint index + GLsizei count + const GLdouble *v + + + + void glVertexAttribs3fvNV + GLuint index + GLsizei count + const GLfloat *v + + + + void glVertexAttribs3hvNV + GLuint index + GLsizei n + const GLhalfNV *v + + + + void glVertexAttribs3svNV + GLuint index + GLsizei count + const GLshort *v + + + + void glVertexAttribs4dvNV + GLuint index + GLsizei count + const GLdouble *v + + + + void glVertexAttribs4fvNV + GLuint index + GLsizei count + const GLfloat *v + + + + void glVertexAttribs4hvNV + GLuint index + GLsizei n + const GLhalfNV *v + + + + void glVertexAttribs4svNV + GLuint index + GLsizei count + const GLshort *v + + + + void glVertexAttribs4ubvNV + GLuint index + GLsizei count + const GLubyte *v + + + + void glVertexBindingDivisor + GLuint bindingindex + GLuint divisor + + + void glVertexBlendARB + GLint count + + + + void glVertexBlendEnvfATI + GLenum pname + GLfloat param + + + void glVertexBlendEnviATI + GLenum pname + GLint param + + + void glVertexFormatNV + GLint size + GLenum type + GLsizei stride + + + void glVertexP2ui + GLenum type + GLuint value + + + void glVertexP2uiv + GLenum type + const GLuint *value + + + void glVertexP3ui + GLenum type + GLuint value + + + void glVertexP3uiv + GLenum type + const GLuint *value + + + void glVertexP4ui + GLenum type + GLuint value + + + void glVertexP4uiv + GLenum type + const GLuint *value + + + void glVertexPointer + GLint size + GLenum type + GLsizei stride + const void *pointer + + + void glVertexPointerEXT + GLint size + GLenum type + GLsizei stride + GLsizei count + const void *pointer + + + void glVertexPointerListIBM + GLint size + GLenum type + GLint stride + const void **pointer + GLint ptrstride + + + void glVertexPointervINTEL + GLint size + GLenum type + const void **pointer + + + void glVertexStream1dATI + GLenum stream + GLdouble x + + + void glVertexStream1dvATI + GLenum stream + const GLdouble *coords + + + void glVertexStream1fATI + GLenum stream + GLfloat x + + + void glVertexStream1fvATI + GLenum stream + const GLfloat *coords + + + void glVertexStream1iATI + GLenum stream + GLint x + + + void glVertexStream1ivATI + GLenum stream + const GLint *coords + + + void glVertexStream1sATI + GLenum stream + GLshort x + + + void glVertexStream1svATI + GLenum stream + const GLshort *coords + + + void glVertexStream2dATI + GLenum stream + GLdouble x + GLdouble y + + + void glVertexStream2dvATI + GLenum stream + const GLdouble *coords + + + void glVertexStream2fATI + GLenum stream + GLfloat x + GLfloat y + + + void glVertexStream2fvATI + GLenum stream + const GLfloat *coords + + + void glVertexStream2iATI + GLenum stream + GLint x + GLint y + + + void glVertexStream2ivATI + GLenum stream + const GLint *coords + + + void glVertexStream2sATI + GLenum stream + GLshort x + GLshort y + + + void glVertexStream2svATI + GLenum stream + const GLshort *coords + + + void glVertexStream3dATI + GLenum stream + GLdouble x + GLdouble y + GLdouble z + + + void glVertexStream3dvATI + GLenum stream + const GLdouble *coords + + + void glVertexStream3fATI + GLenum stream + GLfloat x + GLfloat y + GLfloat z + + + void glVertexStream3fvATI + GLenum stream + const GLfloat *coords + + + void glVertexStream3iATI + GLenum stream + GLint x + GLint y + GLint z + + + void glVertexStream3ivATI + GLenum stream + const GLint *coords + + + void glVertexStream3sATI + GLenum stream + GLshort x + GLshort y + GLshort z + + + void glVertexStream3svATI + GLenum stream + const GLshort *coords + + + void glVertexStream4dATI + GLenum stream + GLdouble x + GLdouble y + GLdouble z + GLdouble w + + + void glVertexStream4dvATI + GLenum stream + const GLdouble *coords + + + void glVertexStream4fATI + GLenum stream + GLfloat x + GLfloat y + GLfloat z + GLfloat w + + + void glVertexStream4fvATI + GLenum stream + const GLfloat *coords + + + void glVertexStream4iATI + GLenum stream + GLint x + GLint y + GLint z + GLint w + + + void glVertexStream4ivATI + GLenum stream + const GLint *coords + + + void glVertexStream4sATI + GLenum stream + GLshort x + GLshort y + GLshort z + GLshort w + + + void glVertexStream4svATI + GLenum stream + const GLshort *coords + + + void glVertexWeightPointerEXT + GLint size + GLenum type + GLsizei stride + const void *pointer + + + void glVertexWeightfEXT + GLfloat weight + + + + void glVertexWeightfvEXT + const GLfloat *weight + + + + void glVertexWeighthNV + GLhalfNV weight + + + + void glVertexWeighthvNV + const GLhalfNV *weight + + + + GLenum glVideoCaptureNV + GLuint video_capture_slot + GLuint *sequence_num + GLuint64EXT *capture_time + + + void glVideoCaptureStreamParameterdvNV + GLuint video_capture_slot + GLuint stream + GLenum pname + const GLdouble *params + + + void glVideoCaptureStreamParameterfvNV + GLuint video_capture_slot + GLuint stream + GLenum pname + const GLfloat *params + + + void glVideoCaptureStreamParameterivNV + GLuint video_capture_slot + GLuint stream + GLenum pname + const GLint *params + + + void glViewport + GLint x + GLint y + GLsizei width + GLsizei height + + + + void glViewportArrayv + GLuint first + GLsizei count + const GLfloat *v + + + void glViewportIndexedf + GLuint index + GLfloat x + GLfloat y + GLfloat w + GLfloat h + + + void glViewportIndexedfv + GLuint index + const GLfloat *v + + + void glWaitSync + GLsync sync + GLbitfield flags + GLuint64 timeout + + + void glWaitSyncAPPLE + GLsync sync + GLbitfield flags + GLuint64 timeout + + + + void glWeightPathsNV + GLuint resultPath + GLsizei numPaths + const GLuint *paths + const GLfloat *weights + + + void glWeightPointerARB + GLint size + GLenum type + GLsizei stride + const void *pointer + + + void glWeightPointerOES + GLint size + GLenum type + GLsizei stride + const void *pointer + + + void glWeightbvARB + GLint size + const GLbyte *weights + + + + void glWeightdvARB + GLint size + const GLdouble *weights + + + + void glWeightfvARB + GLint size + const GLfloat *weights + + + + void glWeightivARB + GLint size + const GLint *weights + + + + void glWeightsvARB + GLint size + const GLshort *weights + + + + void glWeightubvARB + GLint size + const GLubyte *weights + + + + void glWeightuivARB + GLint size + const GLuint *weights + + + + void glWeightusvARB + GLint size + const GLushort *weights + + + + void glWindowPos2d + GLdouble x + GLdouble y + + + + void glWindowPos2dARB + GLdouble x + GLdouble y + + + + + void glWindowPos2dMESA + GLdouble x + GLdouble y + + + + + void glWindowPos2dv + const GLdouble *v + + + + void glWindowPos2dvARB + const GLdouble *v + + + + + void glWindowPos2dvMESA + const GLdouble *v + + + + void glWindowPos2f + GLfloat x + GLfloat y + + + + void glWindowPos2fARB + GLfloat x + GLfloat y + + + + + void glWindowPos2fMESA + GLfloat x + GLfloat y + + + + + void glWindowPos2fv + const GLfloat *v + + + + void glWindowPos2fvARB + const GLfloat *v + + + + + void glWindowPos2fvMESA + const GLfloat *v + + + + void glWindowPos2i + GLint x + GLint y + + + + void glWindowPos2iARB + GLint x + GLint y + + + + + void glWindowPos2iMESA + GLint x + GLint y + + + + + void glWindowPos2iv + const GLint *v + + + + void glWindowPos2ivARB + const GLint *v + + + + + void glWindowPos2ivMESA + const GLint *v + + + + void glWindowPos2s + GLshort x + GLshort y + + + + void glWindowPos2sARB + GLshort x + GLshort y + + + + + void glWindowPos2sMESA + GLshort x + GLshort y + + + + + void glWindowPos2sv + const GLshort *v + + + + void glWindowPos2svARB + const GLshort *v + + + + + void glWindowPos2svMESA + const GLshort *v + + + + void glWindowPos3d + GLdouble x + GLdouble y + GLdouble z + + + + void glWindowPos3dARB + GLdouble x + GLdouble y + GLdouble z + + + + + void glWindowPos3dMESA + GLdouble x + GLdouble y + GLdouble z + + + + + void glWindowPos3dv + const GLdouble *v + + + + void glWindowPos3dvARB + const GLdouble *v + + + + + void glWindowPos3dvMESA + const GLdouble *v + + + + void glWindowPos3f + GLfloat x + GLfloat y + GLfloat z + + + + void glWindowPos3fARB + GLfloat x + GLfloat y + GLfloat z + + + + + void glWindowPos3fMESA + GLfloat x + GLfloat y + GLfloat z + + + + + void glWindowPos3fv + const GLfloat *v + + + + void glWindowPos3fvARB + const GLfloat *v + + + + + void glWindowPos3fvMESA + const GLfloat *v + + + + void glWindowPos3i + GLint x + GLint y + GLint z + + + + void glWindowPos3iARB + GLint x + GLint y + GLint z + + + + + void glWindowPos3iMESA + GLint x + GLint y + GLint z + + + + + void glWindowPos3iv + const GLint *v + + + + void glWindowPos3ivARB + const GLint *v + + + + + void glWindowPos3ivMESA + const GLint *v + + + + void glWindowPos3s + GLshort x + GLshort y + GLshort z + + + + void glWindowPos3sARB + GLshort x + GLshort y + GLshort z + + + + + void glWindowPos3sMESA + GLshort x + GLshort y + GLshort z + + + + + void glWindowPos3sv + const GLshort *v + + + + void glWindowPos3svARB + const GLshort *v + + + + + void glWindowPos3svMESA + const GLshort *v + + + + void glWindowPos4dMESA + GLdouble x + GLdouble y + GLdouble z + GLdouble w + + + + void glWindowPos4dvMESA + const GLdouble *v + + + void glWindowPos4fMESA + GLfloat x + GLfloat y + GLfloat z + GLfloat w + + + + void glWindowPos4fvMESA + const GLfloat *v + + + void glWindowPos4iMESA + GLint x + GLint y + GLint z + GLint w + + + + void glWindowPos4ivMESA + const GLint *v + + + void glWindowPos4sMESA + GLshort x + GLshort y + GLshort z + GLshort w + + + + void glWindowPos4svMESA + const GLshort *v + + + void glWriteMaskEXT + GLuint res + GLuint in + GLenum outX + GLenum outY + GLenum outZ + GLenum outW + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/gl/gengl/main.go b/gl/gengl/main.go new file mode 100644 index 00000000..e92e861f --- /dev/null +++ b/gl/gengl/main.go @@ -0,0 +1,1283 @@ +package main + +import ( + "bufio" + "bytes" + "encoding/xml" + "flag" + "fmt" + "go/format" + "go/token" + "io/ioutil" + "os" + "path/filepath" + "regexp" + "strconv" + "strings" + "text/template" +) + +type Header struct { + Class string + Const []Const + Func []Func + Type []Type + + FeatureFlags []Const + + GLVersionName string + GLVersionLabel string +} + +type Const struct { + Name string + Value string + Heading string + Comment string + LineBlock int + Disabled bool + + GoName string +} + +type Func struct { + Name string + Type string + Addr int + Param []Param + + GoName string + GoType string + DocName string + + Missing bool +} + +type Param struct { + Name string + Type string + Addr int + Array int + Const bool + + GoName string + GoNameOrig string + GoType string +} + +type Type struct { + Name string + Type string + Comment string + + GoName string +} + +type glVersion struct { + api, number, profile string +} + +var glVersions = []glVersion{ + {"gl", "1.0", ""}, + {"gl", "1.1", ""}, + {"gl", "1.2", ""}, + {"gl", "1.3", ""}, + {"gl", "1.4", ""}, + {"gl", "1.5", ""}, + {"gl", "2.0", ""}, + {"gl", "2.1", ""}, + {"gl", "3.0", ""}, + {"gl", "3.1", ""}, + {"gl", "3.2", "core"}, + {"gl", "3.2", "compatibility"}, + {"gl", "3.3", "core"}, + {"gl", "3.3", "compatibility"}, + {"gl", "4.0", "core"}, + {"gl", "4.0", "compatibility"}, + {"gl", "4.1", "core"}, + {"gl", "4.1", "compatibility"}, + {"gl", "4.2", "core"}, + {"gl", "4.2", "compatibility"}, + {"gl", "4.3", "core"}, + {"gl", "4.3", "compatibility"}, + {"gles2", "2.0", ""}, +} + +func (v glVersion) name() string { + if v.api == "gles2" { + return "ES2" + } + return v.number +} + +func (v glVersion) label() string { + if v.api == "gles2" { + return "es2" + } + name := strings.Replace(v.number, ".", "_", -1) + if v.profile == "compatibility" { + return name + "compat" + } + return name + v.profile +} + +func (v glVersion) qtheader() string { + if v.api == "gles2" { + return "qopenglfunctions.h" + } + s := "qopenglfunctions_" + strings.Replace(v.number, ".", "_", -1) + if v.profile != "" { + s += "_" + v.profile + } + return s + ".h" +} + +func main() { + flag.Parse() + args := flag.Args() + if len(args) != 2 { + fmt.Fprintf(os.Stderr, "usage: gengl \n") + os.Exit(1) + } + if err := run(args[0], args[1]); err != nil { + fmt.Fprintf(os.Stderr, "error: %v\n", err) + os.Exit(1) + } +} + +func dirnames(path string) ([]string, error) { + dir, err := os.Open(path) + if err != nil { + return nil, err + } + list, err := dir.Readdirnames(0) + dir.Close() + return list, err +} + +func parseQtHeader(filename string) (*Header, error) { + classData, err := ioutil.ReadFile(filename) + if err != nil { + return nil, fmt.Errorf("cannot read qt header file: %v", err) + } + var header Header + err = parseQt(string(classData), &header) + if err != nil { + return nil, err + } + return &header, nil +} + +func borrowFuncs(header *Header, filename string) error { + bheader, err := parseQtHeader(filename) + if err != nil { + return err + } + + seen := make(map[string]bool) + for _, f := range header.Func { + seen[f.Name] = true + } + for _, f := range bheader.Func { + if !seen[f.Name] { + f.Missing = true + header.Func = append(header.Func, f) + } + } + return nil +} + +func run(qtdir, outdir string) error { + consts, err := parseConsts("gl.xml") + if err != nil { + return err + } + + for _, glVersion := range glVersions { + header, err := parseQtHeader(filepath.Join(qtdir, "QtGui", glVersion.qtheader())) + if err != nil { + return err + } + + header.GLVersionLabel = glVersion.label() + header.GLVersionName = glVersion.name() + header.Const = consts[glVersion] + + if glVersion.api == "gles2" { + // Qt < 5.3 misses several ES2 entries in QOpenGLFunctions. As a workaround, + // find the missing entries from the pure ES2 class and use them directly. + err := borrowFuncs(header, filepath.Join(qtdir, "QtGui", "qopenglfunctions_es2.h")) + if err != nil { + return err + } + } + + err = prepareHeader(header) + if err != nil { + return err + } + + fileContent := make(map[string][]byte) + for _, pkgFile := range packageFiles { + var buf bytes.Buffer + err = pkgFile.Template.Execute(&buf, header) + if err != nil { + return fmt.Errorf("cannot execute template: %v", err) + } + data := buf.Bytes() + if strings.HasSuffix(pkgFile.Name, ".go") { + newdata, err := format.Source(data) + if err != nil { + return fmt.Errorf("\n%s\ncannot format generated Go code: %v\n", data, err) + } + data = newdata + } + fileContent[pkgFile.Name] = data + } + + glDir := filepath.Join(outdir, strings.Replace(header.GLVersionLabel, "_", ".", -1)) + err = os.MkdirAll(glDir, 0755) + if err != nil { + return fmt.Errorf("cannot make package directory at %s: %v", glDir, err) + } + oldNames, err := dirnames(glDir) + if err != nil { + return fmt.Errorf("cannot list contents of directory %s: %v", glDir, err) + } + for _, oldName := range oldNames { + oldPath := filepath.Join(glDir, oldName) + if err := os.Remove(oldPath); err != nil { + return fmt.Errorf("cannot remove previous file in %s: %v", glDir, err) + } + } + for name, data := range fileContent { + err = ioutil.WriteFile(filepath.Join(glDir, name), data, 0644) + if err != nil { + return err + } + } + } + return nil +} + +type glRegistry struct { + Enums []glEnum `xml:"enums>enum"` + Groups []glGroup `xml:"groups>group"` + Features []glFeature `xml:"feature"` +} + +type glFeature struct { + API string `xml:"api,attr"` + Number string `xml:"number,attr"` + Requires []glChange `xml:"require"` + Removes []glChange `xml:"remove"` +} + +type glChange struct { + Profile string `xml:"profile,attr"` + Enums []glEnum `xml:"enum"` +} + +type glGroup struct { + Name string `xml:"name,attr"` + Enums []glEnum `xml:"enum"` +} + +type glEnum struct { + API string `xml:"api,attr"` + Name string `xml:"name,attr"` + Value string `xml:"value,attr"` +} + +type groupTweak struct { + group string + rename string + replace []string + append []string + reorder bool +} + +var groupTweaks = []groupTweak{{ + group: "Boolean", + reorder: true, + append: []string{"GL_NONE"}, +}, { + group: "DataType", + reorder: true, + replace: []string{ + "GL_BYTE", + "GL_UNSIGNED_BYTE", + "GL_SHORT", + "GL_UNSIGNED_SHORT", + "GL_INT", + "GL_UNSIGNED_INT", + "GL_FLOAT", + "GL_2_BYTES", + "GL_2_BYTES_NV", + "GL_3_BYTES", + "GL_3_BYTES_NV", + "GL_4_BYTES", + "GL_4_BYTES_NV", + "GL_DOUBLE", + "GL_DOUBLE_EXT", + "GL_HALF_FLOAT", + "GL_HALF_FLOAT_ARB", + "GL_HALF_FLOAT_NV", + "GL_HALF_APPLE", + "GL_FIXED", + "GL_FIXED_OES", + "GL_INT64_NV", + "GL_UNSIGNED_INT64_ARB", + "GL_UNSIGNED_INT64_NV", + }, +}, { + group: "BlendingFactorSrc", + replace: []string{ + "GL_CONSTANT_ALPHA_EXT", + "GL_CONSTANT_COLOR_EXT", + "GL_DST_ALPHA", + "GL_DST_COLOR", + "GL_ONE", + "GL_ONE_MINUS_DST_ALPHA", + "GL_ONE_MINUS_DST_COLOR", + "GL_ONE_MINUS_SRC_ALPHA", + "GL_ONE_MINUS_SRC_COLOR", + "GL_SRC_ALPHA", + "GL_SRC_COLOR", + "GL_SRC_ALPHA_SATURATE", + "GL_ZERO", + }, +}, { + group: "AttribMask", + append: []string{ + "GL_COVERAGE_BUFFER_BIT_NV", + }, +}} + +func tweakGroups(groups []glGroup) { + tweaks := make(map[string]groupTweak) + reorder := make(map[string]int) + top := 0 + for _, tweak := range groupTweaks { + tweaks[tweak.group] = tweak + if tweak.reorder { + reorder[tweak.group] = top + top++ + } + } + + // Take reordered groups out, leaving space at the start. + stash := make([]glGroup, top) + for i, group := range groups { + newi, ok := reorder[group.Name] + if !ok { + continue + } + stash[newi] = group + copy(groups[1:i+1], groups[0:i]) + } + // Put reordered groups back, in the proper order. + copy(groups, stash) + + for i, group := range groups { + tweak, ok := tweaks[group.Name] + if !ok { + continue + } + if tweak.rename != "" { + group.Name = tweak.rename + } + if tweak.replace != nil { + group.Enums = group.Enums[:0] + for _, name := range tweak.replace { + group.Enums = append(group.Enums, glEnum{Name: name}) + } + } + if tweak.append != nil { + for _, name := range tweak.append { + group.Enums = append(group.Enums, glEnum{Name: name}) + } + } + groups[i] = group + } +} + +func parseConsts(filename string) (map[glVersion][]Const, error) { + f, err := os.Open(filename) + if err != nil { + return nil, fmt.Errorf("cannot open %s: %v", filename, err) + } + defer f.Close() + + var registry glRegistry + err = xml.NewDecoder(f).Decode(®istry) + if err != nil { + return nil, fmt.Errorf("cannot parse %s: %v", filename, err) + } + + var all = make(map[glVersion]map[string]bool) + var last = make(map[string]map[string]bool) + for _, feature := range registry.Features { + for _, profile := range []string{"", "core", "compatibility"} { + required := make(map[string]bool) + for name := range last[feature.API+":"+profile] { + required[name] = true + } + if profile != "" { + for name := range last[feature.API+":"] { + required[name] = true + } + } + + for _, require := range feature.Requires { + if require.Profile == profile || require.Profile == "" { + for _, enum := range require.Enums { + required[enum.Name] = true + } + } + } + for _, remove := range feature.Removes { + if remove.Profile == profile || remove.Profile == "" { + for _, enum := range remove.Enums { + delete(required, enum.Name) + } + } + } + + all[glVersion{feature.API, feature.Number, profile}] = required + last[feature.API+":"+profile] = required + } + } + + // Enums in groups and requires/removes have no values. + enums := make(map[string]glEnum) + for _, enum := range registry.Enums { + enums[enum.Name] = enum + } + + tweakGroups(registry.Groups) + + consts := make(map[glVersion][]Const) + for _, glVersion := range glVersions { + var required = all[glVersion] + var done = make(map[string]bool) + var lineblock = 0 + var vconsts []Const + for _, group := range registry.Groups { + for _, enum := range group.Enums { + if required[enum.Name] && !done[enum.Name] { + done[enum.Name] = true + c := Const{ + Name: enum.Name, + Value: enums[enum.Name].Value, + LineBlock: lineblock, + } + vconsts = append(vconsts, c) + } + } + lineblock++ + } + // Everything else not found in groups. + for _, enum := range registry.Enums { + if required[enum.Name] && !done[enum.Name] { + done[enum.Name] = true + c := Const{ + Name: enum.Name, + Value: enum.Value, + LineBlock: lineblock, + } + vconsts = append(vconsts, c) + } + } + consts[glVersion] = vconsts + } + // Version 1.0 has no enums. Copy from 1.1. + consts[glVersion{"gl", "1.0", ""}] = consts[glVersion{"gl", "1.1", ""}] + return consts, nil +} + +func prepareHeader(header *Header) error { + funcNameDocCount := make(map[string]int) + + for fi, f := range header.Func { + docPrefix := funcNameDocPrefix(f.Name) + if docPrefix != f.Name { + funcNameDocCount[docPrefix]++ + } + if !strings.HasPrefix(f.Name, "gl") || len(f.Name) < 3 { + panic("unexpected C function name: " + f.Name) + } + f.GoName = f.Name[2:] + if f.Type == "int" { + // Some consistency. It's in a gl* function after all. + f.Type = "GLint" + } + if f.Type != "void" { + f.GoType = goTypeName(f.Type) + } + tweaks := funcTweaks[f.GoName] + if tweaks.result != "" { + f.GoType = tweaks.result + } + for pi := range f.Param { + f.Param[pi] = prepareParam(f, pi) + } + header.Func[fi] = f + } + + for fi, f := range header.Func { + prefix := funcNameDocPrefix(f.Name) + if funcNameDocCount[prefix] > 1 { + f.DocName = prefix + } else { + f.DocName = f.Name + } + header.Func[fi] = f + } + + for ti, t := range header.Type { + t.GoName = goTypeName(t.Name) + header.Type[ti] = t + } + + for ci, c := range header.Const { + if !strings.HasPrefix(c.Name, "GL") || len(c.Name) < 3 { + panic("unexpected C define name: " + c.Name) + } + if c.Name[3] >= '0' && c.Name[3] <= '9' { + c.GoName = "N" + c.Name[3:] + } else { + c.GoName = c.Name[3:] + } + header.Const[ci] = c + } + + return nil +} + +func goTypeName(ctypeName string) string { + // These types carry very little meaning, so it's more + // convenient to have their native counterparts instead. + switch ctypeName { + case "GLboolean": + return "bool" + case "GLbyte", "GLchar": + return "byte" + case "GLubyte": + return "uint8" + case "GLshort": + return "int16" + case "GLushort": + return "uint16" + case "GLint", "GLsizei": + return "int32" + case "GLuint": + return "uint32" + case "GLint64": + return "int64" + case "GLuint64": + return "uint64" + case "GLintptr", "GLsizeiptr": + return "int" + case "GLuintptr": + return "uintptr" + case "GLfloat": + return "float32" + case "GLdouble": + return "float64" + } + if !strings.HasPrefix(ctypeName, "GL") || len(ctypeName) < 3 { + panic("unexpected C type name: " + ctypeName) + } + return "glbase." + string(ctypeName[2]-('a'-'A')) + ctypeName[3:] +} + +func prepareParam(f Func, pi int) Param { + p := f.Param[pi] + + // Qt seems to have gratuitously changed some names. + if name, ok := paramNameFixes[p.Name]; ok { + p.Name = name + } + if pi > 0 && strings.HasPrefix(f.GoName, "Uniform") && p.Name != "count" && p.Name != "transpose" { + if strings.HasSuffix(f.GoName, "v") { + p.Name = "value" + } else if f.Param[1].Name == "count" { + p.Name = "v" + string('0' + pi-2) + } else { + p.Name = "v" + string('0' + pi-1) + } + } + + // Other names conflict with Go keywords. + switch p.Name { + case "type", "func", "map", "string": + p.GoName = "gl" + p.Name + default: + if token.Lookup(p.Name) != token.IDENT { + p.GoName = p.Name + "_" + } else { + p.GoName = p.Name + } + } + + // Some consistency. Those are a gl* function after all. + switch p.Type { + case "void": + p.Type = "GLvoid" + case "char": + p.Type = "GLchar" + case "qopengl_GLsizeiptr", "qopengl_GLintptr": + p.Type = p.Type[8:] + } + + // Prepare the parameter type. + p.GoType = goTypeName(p.Type) + switch p.GoType { + case "uint32": + switch p.GoName { + case "program", "programs": + p.GoType = "glbase.Program" + case "shader", "shaders": + p.GoType = "glbase.Shader" + case "buffer", "buffers": + p.GoType = "glbase.Buffer" + case "texture", "textures": + p.GoType = "glbase.Texture" + case "framebuffer", "framebuffers": + p.GoType = "glbase.Framebuffer" + case "renderbuffer", "renderbuffers": + p.GoType = "glbase.Renderbuffer" + case "index": + if strings.Contains(f.Name, "Attrib") { + p.GoType = "glbase.Attrib" + } + } + case "int32": + switch p.GoName { + case "size", "count", "stride", "offset", "xoffset", "yoffset", "order", "level": + p.GoType = "int" + case "n", "first", "width", "height", "border", "imageSize": + p.GoType = "int" + case "x", "y", "z", "w": + if !strings.HasPrefix(f.GoName, "Uniform") { + p.GoType = "int" + } + case "location": + if strings.Contains(f.Name, "Uniform") { + p.GoType = "glbase.Uniform" + } + } + } + + // Save the original name so that future tweaks can still refer + // to it, and apply the tweaks. + p.GoNameOrig = p.GoName + tweak := funcTweaks[f.GoName].params[p.GoNameOrig] + if tweak.retype != "" { + p.GoType = tweak.retype + } + if tweak.rename != "" { + p.GoName = tweak.rename + } + + return p +} + +func funcNameDocPrefix(cfuncName string) string { + k := len(cfuncName) - 1 + if cfuncName[k] == 'v' { + k-- + } + switch cfuncName[k] { + case 'i', 'f', 'd', 's', 'b': + k-- + if cfuncName[k] == 'u' { + k-- + } + switch cfuncName[k] { + case '1', '2', '3', '4': + k-- + } + } + return cfuncName[:k+1] +} + +var constLineBlock = -1 + +func constNewLine(lineBlock int) bool { + if lineBlock == constLineBlock { + return false + } + constLineBlock = lineBlock + return true +} + +func substr(s string, i ...int) string { + switch len(i) { + case 1: + return s[i[0]:] + case 2: + return s[i[0]:i[1]] + } + panic("invalid number of arguments for substr") +} + +var funcTweaks = make(map[string]funcTweak) + +func init() { + var re = regexp.MustCompile(`\bcopy:([a-zA-Z0-9]+)\b`) + for _, tweak := range funcTweakList { + funcTweaks[tweak.name] = tweak + } + for _, tweak := range funcTweakList { + if tweak.copy != "" { + doc := tweak.doc + name := tweak.name + tweak = funcTweaks[tweak.copy] + tweak.name = name + if doc != "" { + tweak.doc = doc + } + } + tweak.doc = re.ReplaceAllStringFunc(tweak.doc, func(match string) string { + return funcTweaks[match[5:]].doc + }) + funcTweaks[tweak.name] = tweak + } +} + +func funcComment(header *Header, f Func) string { + var doc = funcTweaks[f.GoName].doc + doc = strings.TrimRight(execTemplate(f.GoName+":doc", doc, f), "\n\t ") + var buf bytes.Buffer + if doc != "" { + var scanner = bufio.NewScanner(bytes.NewBufferString(doc)) + var started bool + var prefix string + for scanner.Scan() { + line := scanner.Text() + if !started { + if line == "" { + continue + } + started = true + trimmed := strings.TrimLeft(line, "\t ") + prefix = line[:len(line)-len(trimmed)] + line = f.GoName + " " + trimmed + } else { + line = strings.TrimPrefix(line, prefix) + } + buf.WriteString("// ") + buf.WriteString(line) + buf.WriteByte('\n') + } + } + if buf.Len() > 0 { + return strings.TrimSuffix(buf.String(), "\n") + } + var manNum = 2 + if header.GLVersionName[0] >= '2' && header.GLVersionName[0] <= '4' { + manNum = int(header.GLVersionName[0] - '0') + } + return fmt.Sprintf("// https://www.opengl.org/sdk/docs/man%d/xhtml/%s.xml", manNum, f.Name) +} + +type paramItem struct { + GoName string + GoType string +} + +func appendResultList(list []paramItem, f Func) []paramItem { + var tweaks = funcTweaks[f.GoName] + var buf bytes.Buffer + tweak := tweaks.params["result"] + if f.GoType != "" && !tweak.omit { + var item paramItem + if tweak.rename != "" { + item.GoName = tweak.rename + } else { + item.GoName = "result" + } + if tweak.retype != "" { + item.GoType = tweak.retype + } else { + for i := 0; i < f.Addr; i++ { + buf.WriteString("[]") + } + buf.WriteString(f.GoType) + item.GoType = buf.String() + } + list = append(list, item) + } + return list +} + +func appendParamsList(list []paramItem, f Func, output bool) []paramItem { + var tweaks = funcTweaks[f.GoName] + var buf bytes.Buffer + for _, param := range f.Param { + tweak := tweaks.params[param.GoNameOrig] + if tweak.omit || tweak.output != output { + continue + } + item := paramItem{GoName: param.GoName} + if tweak.retype != "" { + item.GoType = param.GoType + } else if param.Addr == 1 && param.Type == "GLvoid" { + item.GoType = "interface{}" + } else if tweak.single { + item.GoType = param.GoType + } else { + buf.Truncate(0) + for j := 0; j < param.Addr; j++ { + buf.WriteString("[]") + } + if param.Array > 0 { + buf.WriteByte('[') + buf.WriteString(strconv.Itoa(param.Array)) + buf.WriteByte(']') + } + buf.WriteString(param.GoType) + item.GoType = buf.String() + } + list = append(list, item) + } + return list +} + +func formatParamsList(list []paramItem) string { + var buf bytes.Buffer + for i, item := range list { + if i > 0 { + buf.WriteString(", ") + } + buf.WriteString(item.GoName) + if i == len(list)-1 || item.GoType != list[i+1].GoType { + buf.WriteByte(' ') + buf.WriteString(item.GoType) + } + } + return buf.String() +} + +func funcParams(f Func) string { + list := appendParamsList(nil, f, false) + return formatParamsList(list) +} + +func funcResult(f Func) string { + list := appendResultList(nil, f) + list = appendParamsList(list, f, true) + if len(list) == 0 { + return "" + } + if len(list) == 1 && (list[0].GoName == "result" || funcTweaks[f.GoName].params[list[0].GoName].unnamed) { + return list[0].GoType + } + return "(" + formatParamsList(list) + ")" +} + +func funcBefore(f Func) string { + content := funcTweaks[f.GoName].before + return strings.TrimSpace(execTemplate(f.GoName+":before", content, f)) +} + +func funcAfter(f Func) string { + content := funcTweaks[f.GoName].after + return strings.TrimSpace(execTemplate(f.GoName+":after", content, f)) +} + +func funcCallParams(f Func) string { + tweaks := funcTweaks[f.GoName] + var buf bytes.Buffer + for i, param := range f.Param { + if i > 0 { + buf.WriteString(", ") + } + tweak := tweaks.params[param.GoNameOrig] + name := param.GoName + if tweak.replace { + name += "_c" + } + if param.Addr == 1 && param.Type == "GLvoid" { + buf.WriteString(name) + buf.WriteString("_ptr") + } else if param.Addr == 1 && param.Type == "GLchar" && param.GoType == "string" { + buf.WriteString("(*C.GLchar)(") + buf.WriteString(name) + buf.WriteString("_cstr)") + } else if param.Addr > 0 { + buf.WriteByte('(') + for i := 0; i < param.Addr; i++ { + buf.WriteByte('*') + } + buf.WriteString("C.") + buf.WriteString(param.Type) + buf.WriteString(")(unsafe.Pointer(&") + buf.WriteString(name) + if !tweak.single { + buf.WriteString("[0]") + } + buf.WriteString("))") + + } else if param.Type == "GLboolean" { + buf.WriteString("*(*C.GLboolean)(unsafe.Pointer(&") + buf.WriteString(name) + buf.WriteString("))") + } else if param.Type == "GLsync" { + buf.WriteString("C.GLsync(unsafe.Pointer(") + buf.WriteString(name) + buf.WriteString("))") + } else { + buf.WriteString("C.") + buf.WriteString(param.Type) + buf.WriteByte('(') + buf.WriteString(name) + buf.WriteByte(')') + } + } + return buf.String() +} + +func funcCallParamsPrep(f Func) string { + var buf bytes.Buffer + for _, param := range f.Param { + name := param.GoName + if param.Addr == 1 && param.Type == "GLchar" && param.GoType == "string" { + fmt.Fprintf(&buf, "%s_cstr := C.CString(%s)\n", name, name) + } + if param.Addr == 1 && param.Type == "GLvoid" && param.GoType == "glbase.Void" { + fmt.Fprintf(&buf, "var %s_ptr unsafe.Pointer\n", name) + fmt.Fprintf(&buf, "var %s_v = reflect.ValueOf(%s)\n", name, name) + fmt.Fprintf(&buf, "if %s != nil && %s_v.Kind() != reflect.Slice { panic(\"parameter %s must be a slice\") }\n", name, name, name) + fmt.Fprintf(&buf, "if %s != nil { %s_ptr = unsafe.Pointer(%s_v.Index(0).Addr().Pointer()) }\n", name, name, name) + } + if plen := funcParamLen(f, param); plen > 0 { + fmt.Fprintf(&buf, "if len(%s) != %d { panic(\"parameter %s has incorrect length\") }\n", name, plen, name) + } + } + return buf.String() +} + +func funcCallParamsPost(f Func) string { + var buf bytes.Buffer + for _, param := range f.Param { + if param.Addr == 1 && param.Type == "GLchar" && param.GoType == "string" { + buf.WriteString("C.free(unsafe.Pointer(") + buf.WriteString(param.GoName) + buf.WriteString("_cstr))\n") + } + } + return buf.String() +} + +func funcReturnResult(f Func) string { + tweaks := funcTweaks[f.GoName] + var buf bytes.Buffer + if f.GoType != "" { + if f.Type == "GLboolean" { + buf.WriteString("*(*bool)(unsafe.Pointer(&glresult))") + } else if f.Type == "GLsync" { + buf.WriteString("glbase.Sync(unsafe.Pointer(glresult))") + } else { + buf.WriteString(f.GoType) + buf.WriteString("(glresult)") + } + } + for _, param := range f.Param { + tweak := tweaks.params[param.GoNameOrig] + if tweak.omit || !tweak.output { + continue + } + if buf.Len() > 0 { + buf.WriteString(", ") + } + buf.WriteString(param.GoName) + } + return buf.String() +} + +func funcCParams(f Func) string { + var buf bytes.Buffer + for i, param := range f.Param { + if i > 0 { + buf.WriteString(", ") + } + if param.Const { + buf.WriteString("const ") + } + buf.WriteString(param.Type) + for j := 0; j < param.Addr; j++ { + buf.WriteString("*") + } + if param.Array > 0 { + buf.WriteByte('[') + buf.WriteString(strconv.Itoa(param.Array)) + buf.WriteByte(']') + } + buf.WriteByte(' ') + buf.WriteString(param.GoName) + } + return buf.String() +} + +func funcCCallParams(f Func) string { + var buf bytes.Buffer + for i, param := range f.Param { + if i > 0 { + buf.WriteString(", ") + } + buf.WriteString(param.GoName) + } + return buf.String() +} + +func funcParamLen(f Func, param Param) int { + if strings.HasPrefix(f.GoName, "Uniform") { + return 0 + } + if param.Addr == 0 || len(f.Name) < 3 || f.Name[len(f.Name)-1] != 'v' { + return 0 + } + switch f.Name[len(f.Name)-2] { + case 'i', 'f', 'd', 's': + switch c := f.Name[len(f.Name)-3]; c { + case '2', '3', '4': + return int(c - '0') + } + } + return 0 +} + +// funcSupported returns whether the given function has wrapping +// properly implemented already. +func funcSupported(f Func) bool { + if _, ok := funcTweaks[f.GoName]; ok { + return true + } + if f.Addr > 0 { + return false + } + for _, param := range f.Param { + if param.Array > 0 { + return false + } + if param.Addr > 1 { + return false + } + } + return true +} + +func copyDoc(name string) string { + return funcTweaks[name].doc +} + +func paramGoType(f Func, name string) string { + for _, param := range f.Param { + if param.GoName == name { + return param.GoType + } + } + panic(fmt.Sprintf("parameter %q not found in function %s", name, f.GoName)) +} + +func funcSince(f Func, since string) string { + if strings.HasSuffix(since, "+") { + return f.GoName + " is available in GL version " + since[:len(since)-1] + " or greater." + } + return f.GoName + " is available in GL version " + since + "." +} + +func execTemplate(name, content string, dot interface{}) string { + if !strings.Contains(content, "{{") { + return content + } + var buf bytes.Buffer + tmpl := template.Must(template.New(name).Funcs(funcs).Parse(content)) + if err := tmpl.Execute(&buf, dot); err != nil { + panic(err) + } + return buf.String() +} + +func buildTemplate(name, content string) *template.Template { + return template.Must(template.New(name).Funcs(funcs).Parse(content)) +} + +var funcs template.FuncMap + +type packageFile struct { + Name string + Template *template.Template +} + +var packageFiles []packageFile + +func init() { + funcs = template.FuncMap{ + "copyDoc": copyDoc, + "paramGoType": paramGoType, + "funcSince": funcSince, + + "constNewLine": constNewLine, + "lower": strings.ToLower, + "substr": substr, + + "funcSupported": funcSupported, + "funcComment": funcComment, + "funcParams": funcParams, + "funcResult": funcResult, + "funcBefore": funcBefore, + "funcCallParams": funcCallParams, + "funcCallParamsPrep": funcCallParamsPrep, + "funcCallParamsPost": funcCallParamsPost, + "funcAfter": funcAfter, + "funcReturnResult": funcReturnResult, + "funcCParams": funcCParams, + "funcCCallParams": funcCCallParams, + } + + packageFiles = []packageFile{ + {"gl.go", buildTemplate("gl.go", tmplGo)}, + {"funcs.cpp", buildTemplate("funcs.cpp", tmplFuncsCpp)}, + {"funcs.h", buildTemplate("funcs.h", tmplFuncsH)}, + } +} + +var tmplGo = ` +// ** file automatically generated by glgen -- do not edit manually ** + +package GL + +// #cgo CXXFLAGS: -std=c++0x -pedantic-errors -Wall -fno-strict-aliasing +// #cgo LDFLAGS: -lstdc++ +{{if eq $.GLVersionName "ES2"}}// #cgo !darwin LDFLAGS: -lGL +// #cgo darwin LDFLAGS: -framework OpenGL +{{end}}// #cgo pkg-config: Qt5Core Qt5OpenGL +// +// #include "funcs.h" +// +// void free(void*); +// +import "C" + +import ( + "fmt" + "reflect" + "unsafe" + + "gopkg.in/qml.v1/gl/glbase" +) + +// API returns a value that offers methods matching the OpenGL version {{$.GLVersionName}} API. +// +// The returned API must not be used after the provided OpenGL context becomes invalid. +func API(context glbase.Contexter) *GL { + gl := &GL{} + gl.funcs = C.gl{{$.GLVersionLabel}}_funcs() + if gl.funcs == nil { + panic(fmt.Errorf("OpenGL version {{$.GLVersionName}} is not available")) + } + return gl +} + +// GL implements the OpenGL version {{$.GLVersionName}} API. Values of this +// type must be created via the API function, and it must not be used after +// the associated OpenGL context becomes invalid. +type GL struct { + funcs unsafe.Pointer +} + +const ({{range $const := $.Const}}{{if $const.LineBlock | constNewLine}} +{{end}}{{if $const.Heading}} // {{$const.Heading}} +{{end}} {{if $const.Disabled}}//{{end}}{{$const.GoName}} = {{$const.Value}}{{if $const.Comment}} // {{$const.Comment}}{{end}} +{{end}}) + +{{ range $func := $.Func }}{{if $func | funcSupported}} +{{funcComment $ $func}} +func (gl *GL) {{$func.GoName}}({{funcParams $func}}) {{funcResult $func}} { + {{funcCallParamsPrep $func}} {{/* +*/}} {{with $code := funcBefore $func}}{{$code}} + {{end}} {{/* +*/}} {{if ne $func.Type "void"}}glresult := {{end}}C.gl{{$.GLVersionLabel}}_{{$func.Name}}(gl.funcs{{if $func.Param}}, {{funcCallParams $func}}{{end}}) + {{with $code := funcAfter $func}}{{$code}} + {{end}} {{/* +*/}} {{funcCallParamsPost $func}} {{/* +*/}} {{with $code := funcReturnResult $func}}return {{$code}} + {{end}} {{/* +*/}} } +{{end}}{{end}} +` + +var tmplFuncsCpp = ` +// ** file automatically generated by glgen -- do not edit manually ** + +#include +#include + +#include "funcs.h" + +void *gl{{$.GLVersionLabel}}_funcs() { + {{$.Class}}* funcs = QOpenGLContext::currentContext()->{{if eq $.Class "QOpenGLFunctions"}}functions{{else}}versionFunctions<{{$.Class}}>{{end}}(); + if (!funcs) { + return 0; + }{{if ne $.Class "QOpenGLFunctions"}} + funcs->initializeOpenGLFunctions();{{end}} + return funcs; +} + +{{ range $func := $.Func }}{{if $func | funcSupported}} +{{$func.Type}} gl{{$.GLVersionLabel}}_{{$func.Name}}(void *_glfuncs{{if $func.Param}}, {{funcCParams $func}}{{end}}) +{ + {{if not $func.Missing}}{{$.Class}}* _qglfuncs = reinterpret_cast<{{$.Class}}*>(_glfuncs); + {{end}}{{if $func.GoType}}return {{end}}{{if not $func.Missing}}_qglfuncs->{{end}}{{$func.Name}}({{funcCCallParams $func}}); +} +{{end}}{{end}} +` + +var tmplFuncsH = ` +// ** file automatically generated by glgen -- do not edit manually ** + +#ifndef __cplusplus +#include +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef char GLchar; +typedef signed char GLbyte; /* 1-byte signed */ +typedef short GLshort; /* 2-byte signed */ +typedef int GLint; /* 4-byte signed */ +typedef unsigned char GLubyte; /* 1-byte unsigned */ +typedef unsigned short GLushort; /* 2-byte unsigned */ +typedef unsigned int GLuint; /* 4-byte unsigned */ +typedef int GLsizei; /* 4-byte signed */ +typedef float GLfloat; /* single precision float */ +typedef float GLclampf; /* single precision float in [0,1] */ +typedef double GLdouble; /* double precision float */ +typedef double GLclampd; /* double precision float in [0,1] */ +typedef int64_t GLint64; +typedef uint64_t GLuint64; +typedef ptrdiff_t GLintptr; +typedef ptrdiff_t GLsizeiptr; +typedef ptrdiff_t GLintptrARB; +typedef ptrdiff_t GLsizeiptrARB; +typedef struct __GLsync *GLsync; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +void *gl{{$.GLVersionLabel}}_funcs(); + +{{ range $func := $.Func }}{{if $func | funcSupported}}{{$func.Type}} gl{{$.GLVersionLabel}}_{{$func.Name}}(void *_glfuncs{{if $func.Param}}, {{funcCParams $func}}{{end}}); +{{end}}{{end}} + +#ifdef __cplusplus +} // extern "C" +#endif +` diff --git a/gl/gengl/parseqt.go b/gl/gengl/parseqt.go new file mode 100644 index 00000000..a4a882dd --- /dev/null +++ b/gl/gengl/parseqt.go @@ -0,0 +1,13904 @@ + +// line 1 "parseqt.rl" +// +// To compile: +// +// ragel -Z -G2 -o parseqt.go parseqt.rl +// +// To show a diagram of the state machine: +// +// ragel -V -G2 -p -o parseqt.dot parseqt.rl +// dot -Tsvg -o parseqt.svg parseqt.dot +// chrome parseqt.svg +// + +package main + +import ( + "fmt" +) + + +// line 23 "parseqt.go" +const parseqt_start int = 447 +const parseqt_first_final int = 447 +const parseqt_error int = 0 + +const parseqt_en_main int = 447 +const parseqt_en_inclass int = 450 +const parseqt_en_skiperror int = 446 + + +// line 23 "parseqt.rl" + + +func parseQt(data string, header *Header) error { + var cs, p, pe int + var ts, te, act, eof int + + pe = len(data) + eof = len(data) + + _, _, _ = ts, te, act + + //stack := make([]int, 32) + //top := 0 + + var curline = 1 + + var m0, m1, m2, m3, m4, m5, m6 int + var foundclass int + var inpublic bool + var heading string + var lineblock int + var f Func + + +// line 58 "parseqt.go" + { + cs = parseqt_start + ts = 0 + te = 0 + act = 0 + } + +// line 66 "parseqt.go" + { + if p == pe { + goto _test_eof + } + switch cs { + case 447: + goto st_case_447 + case 1: + goto st_case_1 + case 2: + goto st_case_2 + case 3: + goto st_case_3 + case 4: + goto st_case_4 + case 5: + goto st_case_5 + case 6: + goto st_case_6 + case 7: + goto st_case_7 + case 8: + goto st_case_8 + case 9: + goto st_case_9 + case 10: + goto st_case_10 + case 11: + goto st_case_11 + case 12: + goto st_case_12 + case 13: + goto st_case_13 + case 14: + goto st_case_14 + case 15: + goto st_case_15 + case 16: + goto st_case_16 + case 17: + goto st_case_17 + case 18: + goto st_case_18 + case 19: + goto st_case_19 + case 20: + goto st_case_20 + case 21: + goto st_case_21 + case 448: + goto st_case_448 + case 22: + goto st_case_22 + case 23: + goto st_case_23 + case 24: + goto st_case_24 + case 25: + goto st_case_25 + case 26: + goto st_case_26 + case 27: + goto st_case_27 + case 28: + goto st_case_28 + case 29: + goto st_case_29 + case 30: + goto st_case_30 + case 31: + goto st_case_31 + case 32: + goto st_case_32 + case 33: + goto st_case_33 + case 34: + goto st_case_34 + case 35: + goto st_case_35 + case 36: + goto st_case_36 + case 37: + goto st_case_37 + case 38: + goto st_case_38 + case 39: + goto st_case_39 + case 40: + goto st_case_40 + case 41: + goto st_case_41 + case 42: + goto st_case_42 + case 43: + goto st_case_43 + case 44: + goto st_case_44 + case 45: + goto st_case_45 + case 46: + goto st_case_46 + case 47: + goto st_case_47 + case 48: + goto st_case_48 + case 49: + goto st_case_49 + case 50: + goto st_case_50 + case 51: + goto st_case_51 + case 52: + goto st_case_52 + case 53: + goto st_case_53 + case 54: + goto st_case_54 + case 55: + goto st_case_55 + case 56: + goto st_case_56 + case 449: + goto st_case_449 + case 57: + goto st_case_57 + case 446: + goto st_case_446 + case 453: + goto st_case_453 + case 0: + goto st_case_0 + case 454: + goto st_case_454 + case 450: + goto st_case_450 + case 58: + goto st_case_58 + case 59: + goto st_case_59 + case 60: + goto st_case_60 + case 61: + goto st_case_61 + case 62: + goto st_case_62 + case 63: + goto st_case_63 + case 64: + goto st_case_64 + case 65: + goto st_case_65 + case 66: + goto st_case_66 + case 67: + goto st_case_67 + case 68: + goto st_case_68 + case 69: + goto st_case_69 + case 70: + goto st_case_70 + case 71: + goto st_case_71 + case 72: + goto st_case_72 + case 73: + goto st_case_73 + case 74: + goto st_case_74 + case 75: + goto st_case_75 + case 76: + goto st_case_76 + case 77: + goto st_case_77 + case 78: + goto st_case_78 + case 79: + goto st_case_79 + case 80: + goto st_case_80 + case 81: + goto st_case_81 + case 82: + goto st_case_82 + case 83: + goto st_case_83 + case 84: + goto st_case_84 + case 85: + goto st_case_85 + case 86: + goto st_case_86 + case 87: + goto st_case_87 + case 88: + goto st_case_88 + case 89: + goto st_case_89 + case 90: + goto st_case_90 + case 91: + goto st_case_91 + case 92: + goto st_case_92 + case 93: + goto st_case_93 + case 94: + goto st_case_94 + case 95: + goto st_case_95 + case 96: + goto st_case_96 + case 97: + goto st_case_97 + case 98: + goto st_case_98 + case 99: + goto st_case_99 + case 100: + goto st_case_100 + case 101: + goto st_case_101 + case 102: + goto st_case_102 + case 103: + goto st_case_103 + case 104: + goto st_case_104 + case 105: + goto st_case_105 + case 106: + goto st_case_106 + case 107: + goto st_case_107 + case 108: + goto st_case_108 + case 109: + goto st_case_109 + case 110: + goto st_case_110 + case 111: + goto st_case_111 + case 112: + goto st_case_112 + case 113: + goto st_case_113 + case 114: + goto st_case_114 + case 115: + goto st_case_115 + case 116: + goto st_case_116 + case 117: + goto st_case_117 + case 118: + goto st_case_118 + case 119: + goto st_case_119 + case 120: + goto st_case_120 + case 121: + goto st_case_121 + case 122: + goto st_case_122 + case 123: + goto st_case_123 + case 124: + goto st_case_124 + case 125: + goto st_case_125 + case 126: + goto st_case_126 + case 127: + goto st_case_127 + case 128: + goto st_case_128 + case 129: + goto st_case_129 + case 130: + goto st_case_130 + case 131: + goto st_case_131 + case 132: + goto st_case_132 + case 133: + goto st_case_133 + case 134: + goto st_case_134 + case 135: + goto st_case_135 + case 136: + goto st_case_136 + case 137: + goto st_case_137 + case 138: + goto st_case_138 + case 139: + goto st_case_139 + case 140: + goto st_case_140 + case 141: + goto st_case_141 + case 142: + goto st_case_142 + case 143: + goto st_case_143 + case 144: + goto st_case_144 + case 145: + goto st_case_145 + case 451: + goto st_case_451 + case 146: + goto st_case_146 + case 147: + goto st_case_147 + case 148: + goto st_case_148 + case 149: + goto st_case_149 + case 150: + goto st_case_150 + case 151: + goto st_case_151 + case 152: + goto st_case_152 + case 153: + goto st_case_153 + case 154: + goto st_case_154 + case 155: + goto st_case_155 + case 156: + goto st_case_156 + case 157: + goto st_case_157 + case 158: + goto st_case_158 + case 159: + goto st_case_159 + case 160: + goto st_case_160 + case 452: + goto st_case_452 + case 161: + goto st_case_161 + case 162: + goto st_case_162 + case 163: + goto st_case_163 + case 164: + goto st_case_164 + case 165: + goto st_case_165 + case 166: + goto st_case_166 + case 167: + goto st_case_167 + case 168: + goto st_case_168 + case 169: + goto st_case_169 + case 170: + goto st_case_170 + case 171: + goto st_case_171 + case 172: + goto st_case_172 + case 173: + goto st_case_173 + case 174: + goto st_case_174 + case 175: + goto st_case_175 + case 176: + goto st_case_176 + case 177: + goto st_case_177 + case 178: + goto st_case_178 + case 179: + goto st_case_179 + case 180: + goto st_case_180 + case 181: + goto st_case_181 + case 182: + goto st_case_182 + case 183: + goto st_case_183 + case 184: + goto st_case_184 + case 185: + goto st_case_185 + case 186: + goto st_case_186 + case 187: + goto st_case_187 + case 188: + goto st_case_188 + case 189: + goto st_case_189 + case 190: + goto st_case_190 + case 191: + goto st_case_191 + case 192: + goto st_case_192 + case 193: + goto st_case_193 + case 194: + goto st_case_194 + case 195: + goto st_case_195 + case 196: + goto st_case_196 + case 197: + goto st_case_197 + case 198: + goto st_case_198 + case 199: + goto st_case_199 + case 200: + goto st_case_200 + case 201: + goto st_case_201 + case 202: + goto st_case_202 + case 203: + goto st_case_203 + case 204: + goto st_case_204 + case 205: + goto st_case_205 + case 206: + goto st_case_206 + case 207: + goto st_case_207 + case 208: + goto st_case_208 + case 209: + goto st_case_209 + case 210: + goto st_case_210 + case 211: + goto st_case_211 + case 212: + goto st_case_212 + case 213: + goto st_case_213 + case 214: + goto st_case_214 + case 215: + goto st_case_215 + case 216: + goto st_case_216 + case 217: + goto st_case_217 + case 218: + goto st_case_218 + case 219: + goto st_case_219 + case 220: + goto st_case_220 + case 221: + goto st_case_221 + case 222: + goto st_case_222 + case 223: + goto st_case_223 + case 224: + goto st_case_224 + case 225: + goto st_case_225 + case 226: + goto st_case_226 + case 227: + goto st_case_227 + case 228: + goto st_case_228 + case 229: + goto st_case_229 + case 230: + goto st_case_230 + case 231: + goto st_case_231 + case 232: + goto st_case_232 + case 233: + goto st_case_233 + case 234: + goto st_case_234 + case 235: + goto st_case_235 + case 236: + goto st_case_236 + case 237: + goto st_case_237 + case 238: + goto st_case_238 + case 239: + goto st_case_239 + case 240: + goto st_case_240 + case 241: + goto st_case_241 + case 242: + goto st_case_242 + case 243: + goto st_case_243 + case 244: + goto st_case_244 + case 245: + goto st_case_245 + case 246: + goto st_case_246 + case 247: + goto st_case_247 + case 248: + goto st_case_248 + case 249: + goto st_case_249 + case 250: + goto st_case_250 + case 251: + goto st_case_251 + case 252: + goto st_case_252 + case 253: + goto st_case_253 + case 254: + goto st_case_254 + case 255: + goto st_case_255 + case 256: + goto st_case_256 + case 257: + goto st_case_257 + case 258: + goto st_case_258 + case 259: + goto st_case_259 + case 260: + goto st_case_260 + case 261: + goto st_case_261 + case 262: + goto st_case_262 + case 263: + goto st_case_263 + case 264: + goto st_case_264 + case 265: + goto st_case_265 + case 266: + goto st_case_266 + case 267: + goto st_case_267 + case 268: + goto st_case_268 + case 269: + goto st_case_269 + case 270: + goto st_case_270 + case 271: + goto st_case_271 + case 272: + goto st_case_272 + case 273: + goto st_case_273 + case 274: + goto st_case_274 + case 275: + goto st_case_275 + case 276: + goto st_case_276 + case 277: + goto st_case_277 + case 278: + goto st_case_278 + case 279: + goto st_case_279 + case 280: + goto st_case_280 + case 281: + goto st_case_281 + case 282: + goto st_case_282 + case 283: + goto st_case_283 + case 284: + goto st_case_284 + case 285: + goto st_case_285 + case 286: + goto st_case_286 + case 287: + goto st_case_287 + case 288: + goto st_case_288 + case 289: + goto st_case_289 + case 290: + goto st_case_290 + case 291: + goto st_case_291 + case 292: + goto st_case_292 + case 293: + goto st_case_293 + case 294: + goto st_case_294 + case 295: + goto st_case_295 + case 296: + goto st_case_296 + case 297: + goto st_case_297 + case 298: + goto st_case_298 + case 299: + goto st_case_299 + case 300: + goto st_case_300 + case 301: + goto st_case_301 + case 302: + goto st_case_302 + case 303: + goto st_case_303 + case 304: + goto st_case_304 + case 305: + goto st_case_305 + case 306: + goto st_case_306 + case 307: + goto st_case_307 + case 308: + goto st_case_308 + case 309: + goto st_case_309 + case 310: + goto st_case_310 + case 311: + goto st_case_311 + case 312: + goto st_case_312 + case 313: + goto st_case_313 + case 314: + goto st_case_314 + case 315: + goto st_case_315 + case 316: + goto st_case_316 + case 317: + goto st_case_317 + case 318: + goto st_case_318 + case 319: + goto st_case_319 + case 320: + goto st_case_320 + case 321: + goto st_case_321 + case 322: + goto st_case_322 + case 323: + goto st_case_323 + case 324: + goto st_case_324 + case 325: + goto st_case_325 + case 326: + goto st_case_326 + case 327: + goto st_case_327 + case 328: + goto st_case_328 + case 329: + goto st_case_329 + case 330: + goto st_case_330 + case 331: + goto st_case_331 + case 332: + goto st_case_332 + case 333: + goto st_case_333 + case 334: + goto st_case_334 + case 335: + goto st_case_335 + case 336: + goto st_case_336 + case 337: + goto st_case_337 + case 338: + goto st_case_338 + case 339: + goto st_case_339 + case 340: + goto st_case_340 + case 341: + goto st_case_341 + case 342: + goto st_case_342 + case 343: + goto st_case_343 + case 344: + goto st_case_344 + case 345: + goto st_case_345 + case 346: + goto st_case_346 + case 347: + goto st_case_347 + case 348: + goto st_case_348 + case 349: + goto st_case_349 + case 350: + goto st_case_350 + case 351: + goto st_case_351 + case 352: + goto st_case_352 + case 353: + goto st_case_353 + case 354: + goto st_case_354 + case 355: + goto st_case_355 + case 356: + goto st_case_356 + case 357: + goto st_case_357 + case 358: + goto st_case_358 + case 359: + goto st_case_359 + case 360: + goto st_case_360 + case 361: + goto st_case_361 + case 362: + goto st_case_362 + case 363: + goto st_case_363 + case 364: + goto st_case_364 + case 365: + goto st_case_365 + case 366: + goto st_case_366 + case 367: + goto st_case_367 + case 368: + goto st_case_368 + case 369: + goto st_case_369 + case 370: + goto st_case_370 + case 371: + goto st_case_371 + case 372: + goto st_case_372 + case 373: + goto st_case_373 + case 374: + goto st_case_374 + case 375: + goto st_case_375 + case 376: + goto st_case_376 + case 377: + goto st_case_377 + case 378: + goto st_case_378 + case 379: + goto st_case_379 + case 380: + goto st_case_380 + case 381: + goto st_case_381 + case 382: + goto st_case_382 + case 383: + goto st_case_383 + case 384: + goto st_case_384 + case 385: + goto st_case_385 + case 386: + goto st_case_386 + case 387: + goto st_case_387 + case 388: + goto st_case_388 + case 389: + goto st_case_389 + case 390: + goto st_case_390 + case 391: + goto st_case_391 + case 392: + goto st_case_392 + case 393: + goto st_case_393 + case 394: + goto st_case_394 + case 395: + goto st_case_395 + case 396: + goto st_case_396 + case 397: + goto st_case_397 + case 398: + goto st_case_398 + case 399: + goto st_case_399 + case 400: + goto st_case_400 + case 401: + goto st_case_401 + case 402: + goto st_case_402 + case 403: + goto st_case_403 + case 404: + goto st_case_404 + case 405: + goto st_case_405 + case 406: + goto st_case_406 + case 407: + goto st_case_407 + case 408: + goto st_case_408 + case 409: + goto st_case_409 + case 410: + goto st_case_410 + case 411: + goto st_case_411 + case 412: + goto st_case_412 + case 413: + goto st_case_413 + case 414: + goto st_case_414 + case 415: + goto st_case_415 + case 416: + goto st_case_416 + case 417: + goto st_case_417 + case 418: + goto st_case_418 + case 419: + goto st_case_419 + case 420: + goto st_case_420 + case 421: + goto st_case_421 + case 422: + goto st_case_422 + case 423: + goto st_case_423 + case 424: + goto st_case_424 + case 425: + goto st_case_425 + case 426: + goto st_case_426 + case 427: + goto st_case_427 + case 428: + goto st_case_428 + case 429: + goto st_case_429 + case 430: + goto st_case_430 + case 431: + goto st_case_431 + case 432: + goto st_case_432 + case 433: + goto st_case_433 + case 434: + goto st_case_434 + case 435: + goto st_case_435 + case 436: + goto st_case_436 + case 437: + goto st_case_437 + case 438: + goto st_case_438 + case 439: + goto st_case_439 + case 440: + goto st_case_440 + case 441: + goto st_case_441 + case 442: + goto st_case_442 + case 443: + goto st_case_443 + case 444: + goto st_case_444 + case 445: + goto st_case_445 + } + goto st_out +tr1: +// line 47 "parseqt.rl" + + curline++ +// line 71 "parseqt.rl" + +te = p+1 + + goto st447 +tr24: +// line 71 "parseqt.rl" + +p = (te) - 1 + + goto st447 +tr25: +// line 47 "parseqt.rl" + + curline++ +// line 62 "parseqt.rl" + +te = p+1 +{ + if data[m0:m1] == "QOpenGLFunctions" { + header.Class = data[m0:m1] + foundclass++ + } + {goto st450 } + } + goto st447 +tr60: +// line 47 "parseqt.rl" + + curline++ +// line 55 "parseqt.rl" + +te = p+1 +{ + header.Class = data[m0:m1] + foundclass++ + {goto st450 } + } + goto st447 +tr529: +// line 71 "parseqt.rl" + +te = p +p-- + + goto st447 + st447: +// line 1 "NONE" + +ts = 0 + + if p++; p == pe { + goto _test_eof447 + } + st_case_447: +// line 1 "NONE" + +ts = p + +// line 1047 "parseqt.go" + switch data[p] { + case 10: + goto tr1 + case 99: + goto st2 + } + goto st1 + st1: + if p++; p == pe { + goto _test_eof1 + } + st_case_1: + if data[p] == 10 { + goto tr1 + } + goto st1 + st2: + if p++; p == pe { + goto _test_eof2 + } + st_case_2: + switch data[p] { + case 10: + goto tr1 + case 108: + goto st3 + } + goto st1 + st3: + if p++; p == pe { + goto _test_eof3 + } + st_case_3: + switch data[p] { + case 10: + goto tr1 + case 97: + goto st4 + } + goto st1 + st4: + if p++; p == pe { + goto _test_eof4 + } + st_case_4: + switch data[p] { + case 10: + goto tr1 + case 115: + goto st5 + } + goto st1 + st5: + if p++; p == pe { + goto _test_eof5 + } + st_case_5: + switch data[p] { + case 10: + goto tr1 + case 115: + goto st6 + } + goto st1 + st6: + if p++; p == pe { + goto _test_eof6 + } + st_case_6: + switch data[p] { + case 10: + goto tr1 + case 32: + goto st7 + } + goto st1 + st7: + if p++; p == pe { + goto _test_eof7 + } + st_case_7: + switch data[p] { + case 10: + goto tr1 + case 81: + goto st8 + } + goto st1 + st8: + if p++; p == pe { + goto _test_eof8 + } + st_case_8: + switch data[p] { + case 10: + goto tr1 + case 95: + goto st9 + } + goto st1 + st9: + if p++; p == pe { + goto _test_eof9 + } + st_case_9: + switch data[p] { + case 10: + goto tr1 + case 71: + goto st10 + } + goto st1 + st10: + if p++; p == pe { + goto _test_eof10 + } + st_case_10: + switch data[p] { + case 10: + goto tr1 + case 85: + goto st11 + } + goto st1 + st11: + if p++; p == pe { + goto _test_eof11 + } + st_case_11: + switch data[p] { + case 10: + goto tr1 + case 73: + goto st12 + } + goto st1 + st12: + if p++; p == pe { + goto _test_eof12 + } + st_case_12: + switch data[p] { + case 10: + goto tr1 + case 95: + goto st13 + } + goto st1 + st13: + if p++; p == pe { + goto _test_eof13 + } + st_case_13: + switch data[p] { + case 10: + goto tr1 + case 69: + goto st14 + } + goto st1 + st14: + if p++; p == pe { + goto _test_eof14 + } + st_case_14: + switch data[p] { + case 10: + goto tr1 + case 88: + goto st15 + } + goto st1 + st15: + if p++; p == pe { + goto _test_eof15 + } + st_case_15: + switch data[p] { + case 10: + goto tr1 + case 80: + goto st16 + } + goto st1 + st16: + if p++; p == pe { + goto _test_eof16 + } + st_case_16: + switch data[p] { + case 10: + goto tr1 + case 79: + goto st17 + } + goto st1 + st17: + if p++; p == pe { + goto _test_eof17 + } + st_case_17: + switch data[p] { + case 10: + goto tr1 + case 82: + goto st18 + } + goto st1 + st18: + if p++; p == pe { + goto _test_eof18 + } + st_case_18: + switch data[p] { + case 10: + goto tr1 + case 84: + goto st19 + } + goto st1 + st19: + if p++; p == pe { + goto _test_eof19 + } + st_case_19: + switch data[p] { + case 10: + goto tr1 + case 32: + goto st20 + } + goto st1 + st20: + if p++; p == pe { + goto _test_eof20 + } + st_case_20: + switch data[p] { + case 10: + goto tr1 + case 95: + goto tr20 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto tr20 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto tr20 + } + default: + goto tr20 + } + goto st1 +tr20: +// line 54 "parseqt.rl" + + m0 = p +// line 61 "parseqt.rl" + + m0 = p + goto st21 + st21: + if p++; p == pe { + goto _test_eof21 + } + st_case_21: +// line 1317 "parseqt.go" + switch data[p] { + case 10: + goto tr21 + case 32: + goto tr22 + case 95: + goto st21 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st21 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st21 + } + default: + goto st21 + } + goto st1 +tr21: +// line 1 "NONE" + +te = p+1 + +// line 61 "parseqt.rl" + + m1 = p +// line 47 "parseqt.rl" + + curline++ + goto st448 + st448: + if p++; p == pe { + goto _test_eof448 + } + st_case_448: +// line 1356 "parseqt.go" + if data[p] == 123 { + goto st22 + } + goto tr529 + st22: + if p++; p == pe { + goto _test_eof22 + } + st_case_22: + if data[p] == 10 { + goto tr25 + } + goto tr24 +tr22: +// line 54 "parseqt.rl" + + m1 = p + goto st23 + st23: + if p++; p == pe { + goto _test_eof23 + } + st_case_23: +// line 1380 "parseqt.go" + switch data[p] { + case 10: + goto tr1 + case 58: + goto st24 + } + goto st1 + st24: + if p++; p == pe { + goto _test_eof24 + } + st_case_24: + switch data[p] { + case 10: + goto tr1 + case 32: + goto st25 + } + goto st1 + st25: + if p++; p == pe { + goto _test_eof25 + } + st_case_25: + switch data[p] { + case 10: + goto tr1 + case 112: + goto st26 + } + goto st1 + st26: + if p++; p == pe { + goto _test_eof26 + } + st_case_26: + switch data[p] { + case 10: + goto tr1 + case 117: + goto st27 + } + goto st1 + st27: + if p++; p == pe { + goto _test_eof27 + } + st_case_27: + switch data[p] { + case 10: + goto tr1 + case 98: + goto st28 + } + goto st1 + st28: + if p++; p == pe { + goto _test_eof28 + } + st_case_28: + switch data[p] { + case 10: + goto tr1 + case 108: + goto st29 + } + goto st1 + st29: + if p++; p == pe { + goto _test_eof29 + } + st_case_29: + switch data[p] { + case 10: + goto tr1 + case 105: + goto st30 + } + goto st1 + st30: + if p++; p == pe { + goto _test_eof30 + } + st_case_30: + switch data[p] { + case 10: + goto tr1 + case 99: + goto st31 + } + goto st1 + st31: + if p++; p == pe { + goto _test_eof31 + } + st_case_31: + switch data[p] { + case 10: + goto tr1 + case 32: + goto st32 + } + goto st1 + st32: + if p++; p == pe { + goto _test_eof32 + } + st_case_32: + switch data[p] { + case 10: + goto tr1 + case 81: + goto st33 + } + goto st1 + st33: + if p++; p == pe { + goto _test_eof33 + } + st_case_33: + switch data[p] { + case 10: + goto tr1 + case 65: + goto st34 + } + goto st1 + st34: + if p++; p == pe { + goto _test_eof34 + } + st_case_34: + switch data[p] { + case 10: + goto tr1 + case 98: + goto st35 + } + goto st1 + st35: + if p++; p == pe { + goto _test_eof35 + } + st_case_35: + switch data[p] { + case 10: + goto tr1 + case 115: + goto st36 + } + goto st1 + st36: + if p++; p == pe { + goto _test_eof36 + } + st_case_36: + switch data[p] { + case 10: + goto tr1 + case 116: + goto st37 + } + goto st1 + st37: + if p++; p == pe { + goto _test_eof37 + } + st_case_37: + switch data[p] { + case 10: + goto tr1 + case 114: + goto st38 + } + goto st1 + st38: + if p++; p == pe { + goto _test_eof38 + } + st_case_38: + switch data[p] { + case 10: + goto tr1 + case 97: + goto st39 + } + goto st1 + st39: + if p++; p == pe { + goto _test_eof39 + } + st_case_39: + switch data[p] { + case 10: + goto tr1 + case 99: + goto st40 + } + goto st1 + st40: + if p++; p == pe { + goto _test_eof40 + } + st_case_40: + switch data[p] { + case 10: + goto tr1 + case 116: + goto st41 + } + goto st1 + st41: + if p++; p == pe { + goto _test_eof41 + } + st_case_41: + switch data[p] { + case 10: + goto tr1 + case 79: + goto st42 + } + goto st1 + st42: + if p++; p == pe { + goto _test_eof42 + } + st_case_42: + switch data[p] { + case 10: + goto tr1 + case 112: + goto st43 + } + goto st1 + st43: + if p++; p == pe { + goto _test_eof43 + } + st_case_43: + switch data[p] { + case 10: + goto tr1 + case 101: + goto st44 + } + goto st1 + st44: + if p++; p == pe { + goto _test_eof44 + } + st_case_44: + switch data[p] { + case 10: + goto tr1 + case 110: + goto st45 + } + goto st1 + st45: + if p++; p == pe { + goto _test_eof45 + } + st_case_45: + switch data[p] { + case 10: + goto tr1 + case 71: + goto st46 + } + goto st1 + st46: + if p++; p == pe { + goto _test_eof46 + } + st_case_46: + switch data[p] { + case 10: + goto tr1 + case 76: + goto st47 + } + goto st1 + st47: + if p++; p == pe { + goto _test_eof47 + } + st_case_47: + switch data[p] { + case 10: + goto tr1 + case 70: + goto st48 + } + goto st1 + st48: + if p++; p == pe { + goto _test_eof48 + } + st_case_48: + switch data[p] { + case 10: + goto tr1 + case 117: + goto st49 + } + goto st1 + st49: + if p++; p == pe { + goto _test_eof49 + } + st_case_49: + switch data[p] { + case 10: + goto tr1 + case 110: + goto st50 + } + goto st1 + st50: + if p++; p == pe { + goto _test_eof50 + } + st_case_50: + switch data[p] { + case 10: + goto tr1 + case 99: + goto st51 + } + goto st1 + st51: + if p++; p == pe { + goto _test_eof51 + } + st_case_51: + switch data[p] { + case 10: + goto tr1 + case 116: + goto st52 + } + goto st1 + st52: + if p++; p == pe { + goto _test_eof52 + } + st_case_52: + switch data[p] { + case 10: + goto tr1 + case 105: + goto st53 + } + goto st1 + st53: + if p++; p == pe { + goto _test_eof53 + } + st_case_53: + switch data[p] { + case 10: + goto tr1 + case 111: + goto st54 + } + goto st1 + st54: + if p++; p == pe { + goto _test_eof54 + } + st_case_54: + switch data[p] { + case 10: + goto tr1 + case 110: + goto st55 + } + goto st1 + st55: + if p++; p == pe { + goto _test_eof55 + } + st_case_55: + switch data[p] { + case 10: + goto tr1 + case 115: + goto st56 + } + goto st1 + st56: + if p++; p == pe { + goto _test_eof56 + } + st_case_56: + if data[p] == 10 { + goto tr59 + } + goto st1 +tr59: +// line 1 "NONE" + +te = p+1 + +// line 47 "parseqt.rl" + + curline++ + goto st449 + st449: + if p++; p == pe { + goto _test_eof449 + } + st_case_449: +// line 1795 "parseqt.go" + if data[p] == 123 { + goto st57 + } + goto tr529 + st57: + if p++; p == pe { + goto _test_eof57 + } + st_case_57: + if data[p] == 10 { + goto tr60 + } + goto tr24 + st446: +// line 1 "NONE" + +ts = 0 + + if p++; p == pe { + goto _test_eof446 + } + st_case_446: +// line 1818 "parseqt.go" + switch data[p] { + case 10: + goto tr526 + case 59: + goto tr527 + } + goto st446 +tr526: +// line 47 "parseqt.rl" + + curline++ +// line 157 "parseqt.rl" + + {goto st447 } + goto st453 + st453: + if p++; p == pe { + goto _test_eof453 + } + st_case_453: +// line 1839 "parseqt.go" + goto st0 +st_case_0: + st0: + cs = 0 + goto _out +tr527: +// line 157 "parseqt.rl" + + {goto st447 } + goto st454 + st454: + if p++; p == pe { + goto _test_eof454 + } + st_case_454: +// line 1855 "parseqt.go" + switch data[p] { + case 10: + goto tr526 + case 59: + goto tr527 + } + goto st446 +tr63: +// line 47 "parseqt.rl" + + curline++ +// line 147 "parseqt.rl" + +te = p+1 +{ + // Reset heading comment. + heading = "" + + // Start new line block. + lineblock++ + } + goto st450 +tr79: +// line 76 "parseqt.rl" + + m0 = p +// line 47 "parseqt.rl" + + curline++ +// line 77 "parseqt.rl" + +te = p+1 +{ + heading = data[m0:m1] + _ = heading + lineblock++ + } + goto st450 +tr81: +// line 47 "parseqt.rl" + + curline++ +// line 77 "parseqt.rl" + +te = p+1 +{ + heading = data[m0:m1] + _ = heading + lineblock++ + } + goto st450 +tr96: +// line 47 "parseqt.rl" + + curline++ +// line 128 "parseqt.rl" + +te = p+1 + + goto st450 +tr102: +// line 1 "NONE" + + switch act { + case 0: + {{goto st0 }} + case 10: + {p = (te) - 1 + + if (inpublic) { + header.Func = append(header.Func, f) + } + } + } + + goto st450 +tr130: +// line 114 "parseqt.rl" + +te = p+1 +{ + if (inpublic) { + header.Func = append(header.Func, f) + } + } + goto st450 +tr250: +// line 47 "parseqt.rl" + + curline++ +// line 84 "parseqt.rl" + +te = p+1 +{ + if data[m0:m1] != header.Class { + {p++; cs = 450; goto _out } + } + } + goto st450 +tr279: +// line 47 "parseqt.rl" + + curline++ +// line 131 "parseqt.rl" + +te = p+1 + + goto st450 +tr315: +// line 47 "parseqt.rl" + + curline++ +// line 91 "parseqt.rl" + +te = p+1 + + goto st450 +tr398: +// line 47 "parseqt.rl" + + curline++ +// line 124 "parseqt.rl" + +te = p+1 + + goto st450 +tr416: +// line 47 "parseqt.rl" + + curline++ +// line 94 "parseqt.rl" + +te = p+1 + + goto st450 +tr433: +// line 47 "parseqt.rl" + + curline++ +// line 102 "parseqt.rl" + +te = p+1 +{ + inpublic = false + } + goto st450 +tr445: +// line 47 "parseqt.rl" + + curline++ +// line 98 "parseqt.rl" + +te = p+1 +{ + inpublic = true + } + goto st450 +tr481: +// line 47 "parseqt.rl" + + curline++ +// line 140 "parseqt.rl" + +te = p+1 +{ + foundclass++; + {goto st447 } + } + goto st450 +tr519: +// line 47 "parseqt.rl" + + curline++ +// line 136 "parseqt.rl" + +te = p+1 + + goto st450 +tr533: +// line 114 "parseqt.rl" + +te = p +p-- +{ + if (inpublic) { + header.Func = append(header.Func, f) + } + } + goto st450 + st450: +// line 1 "NONE" + +ts = 0 + +// line 1 "NONE" + +act = 0 + + if p++; p == pe { + goto _test_eof450 + } + st_case_450: +// line 1 "NONE" + +ts = p + +// line 2062 "parseqt.go" + switch data[p] { + case 9: + goto st58 + case 10: + goto tr63 + case 32: + goto st58 + case 35: + goto st405 + case 47: + goto st59 + case 58: + goto st188 + case 81: + goto tr67 + case 95: + goto tr65 + case 98: + goto tr68 + case 99: + goto tr69 + case 101: + goto tr70 + case 102: + goto tr71 + case 112: + goto tr72 + case 115: + goto tr73 + case 125: + goto st401 + case 126: + goto st403 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto tr65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto tr65 + } + default: + goto tr65 + } + goto st0 + st58: + if p++; p == pe { + goto _test_eof58 + } + st_case_58: + switch data[p] { + case 9: + goto st58 + case 10: + goto tr63 + case 32: + goto st58 + case 47: + goto st59 + case 58: + goto st188 + case 81: + goto tr67 + case 95: + goto tr65 + case 98: + goto tr68 + case 99: + goto tr69 + case 101: + goto tr70 + case 102: + goto tr71 + case 112: + goto tr72 + case 115: + goto tr73 + case 125: + goto st401 + case 126: + goto st403 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto tr65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto tr65 + } + default: + goto tr65 + } + goto st0 + st59: + if p++; p == pe { + goto _test_eof59 + } + st_case_59: + if data[p] == 47 { + goto st60 + } + goto st0 +tr78: +// line 76 "parseqt.rl" + + m0 = p +// line 76 "parseqt.rl" + + m1 = p + goto st60 + st60: + if p++; p == pe { + goto _test_eof60 + } + st_case_60: +// line 2182 "parseqt.go" + switch data[p] { + case 9: + goto tr78 + case 10: + goto tr79 + case 32: + goto tr78 + } + goto tr77 +tr77: +// line 76 "parseqt.rl" + + m0 = p +// line 76 "parseqt.rl" + + m1 = p + goto st61 +tr80: +// line 76 "parseqt.rl" + + m1 = p + goto st61 + st61: + if p++; p == pe { + goto _test_eof61 + } + st_case_61: +// line 2210 "parseqt.go" + if data[p] == 10 { + goto tr81 + } + goto tr80 +tr65: +// line 84 "parseqt.rl" + + m0 = p +// line 107 "parseqt.rl" + + m0 = p + goto st62 + st62: + if p++; p == pe { + goto _test_eof62 + } + st_case_62: +// line 2228 "parseqt.go" + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 +tr82: +// line 107 "parseqt.rl" + + m1 = p; m4 = 0 + goto st63 + st63: + if p++; p == pe { + goto _test_eof63 + } + st_case_63: +// line 2266 "parseqt.go" + switch data[p] { + case 9: + goto st63 + case 32: + goto st63 + case 42: + goto tr87 + case 95: + goto st65 + case 99: + goto st134 + case 103: + goto tr90 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 +tr84: +// line 107 "parseqt.rl" + + m1 = p; m4 = 0 +// line 107 "parseqt.rl" + + m4++ +// line 127 "parseqt.rl" + + m4++ + goto st64 +tr87: +// line 107 "parseqt.rl" + + m4++ +// line 127 "parseqt.rl" + + m4++ + goto st64 + st64: + if p++; p == pe { + goto _test_eof64 + } + st_case_64: +// line 2318 "parseqt.go" + switch data[p] { + case 9: + goto st63 + case 32: + goto st63 + case 42: + goto tr87 + case 95: + goto st65 + case 103: + goto tr90 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st65: + if p++; p == pe { + goto _test_eof65 + } + st_case_65: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st66: + if p++; p == pe { + goto _test_eof66 + } + st_case_66: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 59: + goto st67 + case 99: + goto st68 + case 123: + goto st73 + } + goto st0 + st67: + if p++; p == pe { + goto _test_eof67 + } + st_case_67: + switch data[p] { + case 9: + goto st67 + case 10: + goto tr96 + case 32: + goto st67 + } + goto st0 + st68: + if p++; p == pe { + goto _test_eof68 + } + st_case_68: + if data[p] == 111 { + goto st69 + } + goto st0 + st69: + if p++; p == pe { + goto _test_eof69 + } + st_case_69: + if data[p] == 110 { + goto st70 + } + goto st0 + st70: + if p++; p == pe { + goto _test_eof70 + } + st_case_70: + if data[p] == 115 { + goto st71 + } + goto st0 + st71: + if p++; p == pe { + goto _test_eof71 + } + st_case_71: + if data[p] == 116 { + goto st72 + } + goto st0 + st72: + if p++; p == pe { + goto _test_eof72 + } + st_case_72: + switch data[p] { + case 9: + goto st72 + case 32: + goto st72 + case 59: + goto st67 + case 123: + goto st73 + } + goto st0 + st73: + if p++; p == pe { + goto _test_eof73 + } + st_case_73: + switch data[p] { + case 10: + goto st0 + case 125: + goto st74 + } + goto st73 + st74: + if p++; p == pe { + goto _test_eof74 + } + st_case_74: + switch data[p] { + case 9: + goto st74 + case 10: + goto tr96 + case 32: + goto st74 + case 125: + goto st74 + } + goto st73 + st75: + if p++; p == pe { + goto _test_eof75 + } + st_case_75: + switch data[p] { + case 10: + goto tr102 + case 41: + goto st76 + } + goto st75 + st76: + if p++; p == pe { + goto _test_eof76 + } + st_case_76: + switch data[p] { + case 9: + goto st76 + case 10: + goto tr102 + case 32: + goto st76 + case 41: + goto st76 + case 59: + goto st77 + case 99: + goto st78 + case 123: + goto st83 + } + goto st75 + st77: + if p++; p == pe { + goto _test_eof77 + } + st_case_77: + switch data[p] { + case 9: + goto st77 + case 10: + goto tr96 + case 32: + goto st77 + case 41: + goto st76 + } + goto st75 + st78: + if p++; p == pe { + goto _test_eof78 + } + st_case_78: + switch data[p] { + case 10: + goto tr102 + case 41: + goto st76 + case 111: + goto st79 + } + goto st75 + st79: + if p++; p == pe { + goto _test_eof79 + } + st_case_79: + switch data[p] { + case 10: + goto tr102 + case 41: + goto st76 + case 110: + goto st80 + } + goto st75 + st80: + if p++; p == pe { + goto _test_eof80 + } + st_case_80: + switch data[p] { + case 10: + goto tr102 + case 41: + goto st76 + case 115: + goto st81 + } + goto st75 + st81: + if p++; p == pe { + goto _test_eof81 + } + st_case_81: + switch data[p] { + case 10: + goto tr102 + case 41: + goto st76 + case 116: + goto st82 + } + goto st75 + st82: + if p++; p == pe { + goto _test_eof82 + } + st_case_82: + switch data[p] { + case 9: + goto st82 + case 10: + goto tr102 + case 32: + goto st82 + case 41: + goto st76 + case 59: + goto st77 + case 123: + goto st83 + } + goto st75 + st83: + if p++; p == pe { + goto _test_eof83 + } + st_case_83: + switch data[p] { + case 10: + goto tr102 + case 41: + goto st84 + case 125: + goto st85 + } + goto st83 + st84: + if p++; p == pe { + goto _test_eof84 + } + st_case_84: + switch data[p] { + case 9: + goto st84 + case 10: + goto tr102 + case 32: + goto st84 + case 41: + goto st84 + case 59: + goto st85 + case 99: + goto st86 + case 125: + goto st85 + } + goto st83 + st85: + if p++; p == pe { + goto _test_eof85 + } + st_case_85: + switch data[p] { + case 9: + goto st85 + case 10: + goto tr96 + case 32: + goto st85 + case 41: + goto st84 + case 125: + goto st85 + } + goto st83 + st86: + if p++; p == pe { + goto _test_eof86 + } + st_case_86: + switch data[p] { + case 10: + goto tr102 + case 41: + goto st84 + case 111: + goto st87 + case 125: + goto st85 + } + goto st83 + st87: + if p++; p == pe { + goto _test_eof87 + } + st_case_87: + switch data[p] { + case 10: + goto tr102 + case 41: + goto st84 + case 110: + goto st88 + case 125: + goto st85 + } + goto st83 + st88: + if p++; p == pe { + goto _test_eof88 + } + st_case_88: + switch data[p] { + case 10: + goto tr102 + case 41: + goto st84 + case 115: + goto st89 + case 125: + goto st85 + } + goto st83 + st89: + if p++; p == pe { + goto _test_eof89 + } + st_case_89: + switch data[p] { + case 10: + goto tr102 + case 41: + goto st84 + case 116: + goto st90 + case 125: + goto st85 + } + goto st83 + st90: + if p++; p == pe { + goto _test_eof90 + } + st_case_90: + switch data[p] { + case 9: + goto st90 + case 10: + goto tr102 + case 32: + goto st90 + case 41: + goto st84 + case 59: + goto st85 + case 125: + goto st85 + } + goto st83 +tr90: +// line 109 "parseqt.rl" + + m2 = p + goto st91 + st91: + if p++; p == pe { + goto _test_eof91 + } + st_case_91: +// line 2762 "parseqt.go" + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 108: + goto st92 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st92: + if p++; p == pe { + goto _test_eof92 + } + st_case_92: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st93 + case 99: + goto st128 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st93 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st93 + } + default: + goto st93 + } + goto st0 + st93: + if p++; p == pe { + goto _test_eof93 + } + st_case_93: + switch data[p] { + case 9: + goto tr121 + case 32: + goto tr121 + case 40: + goto tr122 + case 95: + goto st93 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st93 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st93 + } + default: + goto st93 + } + goto st0 +tr121: +// line 109 "parseqt.rl" + + m3 = p; f = Func{Name: data[m2:m3], Type: data[m0:m1], Addr: m4} + goto st94 + st94: + if p++; p == pe { + goto _test_eof94 + } + st_case_94: +// line 2864 "parseqt.go" + switch data[p] { + case 9: + goto st94 + case 32: + goto st94 + case 40: + goto tr124 + } + goto st0 +tr122: +// line 109 "parseqt.rl" + + m3 = p; f = Func{Name: data[m2:m3], Type: data[m0:m1], Addr: m4} +// line 109 "parseqt.rl" + + m6 = 0 + goto st95 +tr124: +// line 109 "parseqt.rl" + + m6 = 0 + goto st95 + st95: + if p++; p == pe { + goto _test_eof95 + } + st_case_95: +// line 2892 "parseqt.go" + switch data[p] { + case 9: + goto st95 + case 32: + goto st95 + case 41: + goto st96 + case 95: + goto tr127 + case 99: + goto tr128 + case 118: + goto tr129 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto tr127 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto tr127 + } + default: + goto tr127 + } + goto st0 + st96: + if p++; p == pe { + goto _test_eof96 + } + st_case_96: + switch data[p] { + case 9: + goto st96 + case 32: + goto st96 + case 59: + goto tr130 + } + goto st0 +tr127: +// line 111 "parseqt.rl" + + m0 = p + goto st97 + st97: + if p++; p == pe { + goto _test_eof97 + } + st_case_97: +// line 2944 "parseqt.go" + switch data[p] { + case 9: + goto tr131 + case 32: + goto tr131 + case 42: + goto tr132 + case 95: + goto st97 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st97 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st97 + } + default: + goto st97 + } + goto st0 +tr131: +// line 111 "parseqt.rl" + + m1 = p; m4 = 0 + goto st98 + st98: + if p++; p == pe { + goto _test_eof98 + } + st_case_98: +// line 2978 "parseqt.go" + switch data[p] { + case 9: + goto st98 + case 32: + goto st98 + case 42: + goto tr135 + case 95: + goto tr136 + case 99: + goto tr137 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto tr136 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto tr136 + } + default: + goto tr136 + } + goto st0 +tr132: +// line 111 "parseqt.rl" + + m1 = p; m4 = 0 +// line 111 "parseqt.rl" + + m4++ + goto st99 +tr135: +// line 111 "parseqt.rl" + + m4++ + goto st99 + st99: + if p++; p == pe { + goto _test_eof99 + } + st_case_99: +// line 3022 "parseqt.go" + switch data[p] { + case 9: + goto st98 + case 32: + goto st98 + case 42: + goto tr135 + case 95: + goto tr136 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto tr136 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto tr136 + } + default: + goto tr136 + } + goto st0 +tr136: +// line 111 "parseqt.rl" + + m2 = p; m5 = 0 + goto st100 + st100: + if p++; p == pe { + goto _test_eof100 + } + st_case_100: +// line 3056 "parseqt.go" + switch data[p] { + case 9: + goto tr138 + case 32: + goto tr138 + case 41: + goto tr139 + case 44: + goto tr139 + case 91: + goto tr141 + case 95: + goto st100 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st100 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st100 + } + default: + goto st100 + } + goto st0 +tr138: +// line 111 "parseqt.rl" + + m3 = p + goto st101 + st101: + if p++; p == pe { + goto _test_eof101 + } + st_case_101: +// line 3094 "parseqt.go" + switch data[p] { + case 9: + goto st101 + case 32: + goto st101 + case 41: + goto tr143 + case 44: + goto tr143 + } + goto st0 +tr139: +// line 111 "parseqt.rl" + + m3 = p +// line 112 "parseqt.rl" + + f.Param = append(f.Param, Param{Name: data[m2:m3], Type: data[m0:m1], Addr: m4, Array: m5, Const: m6 > 0}); m6 = 0 + goto st102 +tr143: +// line 112 "parseqt.rl" + + f.Param = append(f.Param, Param{Name: data[m2:m3], Type: data[m0:m1], Addr: m4, Array: m5, Const: m6 > 0}); m6 = 0 + goto st102 + st102: + if p++; p == pe { + goto _test_eof102 + } + st_case_102: +// line 3124 "parseqt.go" + switch data[p] { + case 9: + goto st102 + case 32: + goto st102 + case 59: + goto tr130 + case 95: + goto tr127 + case 99: + goto tr128 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto tr127 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto tr127 + } + default: + goto tr127 + } + goto st0 +tr128: +// line 111 "parseqt.rl" + + m0 = p + goto st103 + st103: + if p++; p == pe { + goto _test_eof103 + } + st_case_103: +// line 3160 "parseqt.go" + switch data[p] { + case 9: + goto tr131 + case 32: + goto tr131 + case 42: + goto tr132 + case 95: + goto st97 + case 111: + goto st104 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st97 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st97 + } + default: + goto st97 + } + goto st0 + st104: + if p++; p == pe { + goto _test_eof104 + } + st_case_104: + switch data[p] { + case 9: + goto tr131 + case 32: + goto tr131 + case 42: + goto tr132 + case 95: + goto st97 + case 110: + goto st105 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st97 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st97 + } + default: + goto st97 + } + goto st0 + st105: + if p++; p == pe { + goto _test_eof105 + } + st_case_105: + switch data[p] { + case 9: + goto tr131 + case 32: + goto tr131 + case 42: + goto tr132 + case 95: + goto st97 + case 115: + goto st106 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st97 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st97 + } + default: + goto st97 + } + goto st0 + st106: + if p++; p == pe { + goto _test_eof106 + } + st_case_106: + switch data[p] { + case 9: + goto tr131 + case 32: + goto tr131 + case 42: + goto tr132 + case 95: + goto st97 + case 116: + goto st107 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st97 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st97 + } + default: + goto st97 + } + goto st0 + st107: + if p++; p == pe { + goto _test_eof107 + } + st_case_107: + switch data[p] { + case 9: + goto tr149 + case 32: + goto tr149 + case 42: + goto tr132 + case 95: + goto st97 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st97 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st97 + } + default: + goto st97 + } + goto st0 +tr149: +// line 111 "parseqt.rl" + + m6 = 1 +// line 111 "parseqt.rl" + + m1 = p; m4 = 0 + goto st108 + st108: + if p++; p == pe { + goto _test_eof108 + } + st_case_108: +// line 3317 "parseqt.go" + switch data[p] { + case 9: + goto st108 + case 32: + goto st108 + case 42: + goto tr135 + case 95: + goto tr151 + case 99: + goto tr152 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto tr151 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto tr151 + } + default: + goto tr151 + } + goto st0 +tr166: +// line 111 "parseqt.rl" + + m2 = p; m5 = 0 + goto st109 +tr151: +// line 111 "parseqt.rl" + + m0 = p +// line 111 "parseqt.rl" + + m2 = p; m5 = 0 + goto st109 + st109: + if p++; p == pe { + goto _test_eof109 + } + st_case_109: +// line 3361 "parseqt.go" + switch data[p] { + case 9: + goto tr153 + case 32: + goto tr153 + case 41: + goto tr139 + case 42: + goto tr132 + case 44: + goto tr139 + case 91: + goto tr141 + case 95: + goto st109 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st109 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st109 + } + default: + goto st109 + } + goto st0 +tr161: +// line 111 "parseqt.rl" + + m3 = p + goto st110 +tr153: +// line 111 "parseqt.rl" + + m1 = p; m4 = 0 +// line 111 "parseqt.rl" + + m3 = p + goto st110 + st110: + if p++; p == pe { + goto _test_eof110 + } + st_case_110: +// line 3409 "parseqt.go" + switch data[p] { + case 9: + goto st110 + case 32: + goto st110 + case 41: + goto tr143 + case 42: + goto tr135 + case 44: + goto tr143 + case 95: + goto tr136 + case 99: + goto tr137 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto tr136 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto tr136 + } + default: + goto tr136 + } + goto st0 +tr137: +// line 111 "parseqt.rl" + + m2 = p; m5 = 0 + goto st111 + st111: + if p++; p == pe { + goto _test_eof111 + } + st_case_111: +// line 3449 "parseqt.go" + switch data[p] { + case 9: + goto tr138 + case 32: + goto tr138 + case 41: + goto tr139 + case 44: + goto tr139 + case 91: + goto tr141 + case 95: + goto st100 + case 111: + goto st114 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st100 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st100 + } + default: + goto st100 + } + goto st0 +tr141: +// line 111 "parseqt.rl" + + m3 = p + goto st112 + st112: + if p++; p == pe { + goto _test_eof112 + } + st_case_112: +// line 3489 "parseqt.go" + if 48 <= data[p] && data[p] <= 57 { + goto tr157 + } + goto st0 +tr157: +// line 111 "parseqt.rl" + + m5 = m5*10 + (int(data[p]) - '0') + goto st113 + st113: + if p++; p == pe { + goto _test_eof113 + } + st_case_113: +// line 3504 "parseqt.go" + if data[p] == 93 { + goto st101 + } + if 48 <= data[p] && data[p] <= 57 { + goto tr157 + } + goto st0 + st114: + if p++; p == pe { + goto _test_eof114 + } + st_case_114: + switch data[p] { + case 9: + goto tr138 + case 32: + goto tr138 + case 41: + goto tr139 + case 44: + goto tr139 + case 91: + goto tr141 + case 95: + goto st100 + case 110: + goto st115 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st100 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st100 + } + default: + goto st100 + } + goto st0 + st115: + if p++; p == pe { + goto _test_eof115 + } + st_case_115: + switch data[p] { + case 9: + goto tr138 + case 32: + goto tr138 + case 41: + goto tr139 + case 44: + goto tr139 + case 91: + goto tr141 + case 95: + goto st100 + case 115: + goto st116 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st100 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st100 + } + default: + goto st100 + } + goto st0 + st116: + if p++; p == pe { + goto _test_eof116 + } + st_case_116: + switch data[p] { + case 9: + goto tr138 + case 32: + goto tr138 + case 41: + goto tr139 + case 44: + goto tr139 + case 91: + goto tr141 + case 95: + goto st100 + case 116: + goto st117 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st100 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st100 + } + default: + goto st100 + } + goto st0 + st117: + if p++; p == pe { + goto _test_eof117 + } + st_case_117: + switch data[p] { + case 9: + goto tr161 + case 32: + goto tr161 + case 41: + goto tr139 + case 42: + goto tr135 + case 44: + goto tr139 + case 91: + goto tr141 + case 95: + goto tr136 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto tr136 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto tr136 + } + default: + goto tr136 + } + goto st0 +tr152: +// line 111 "parseqt.rl" + + m0 = p +// line 111 "parseqt.rl" + + m2 = p; m5 = 0 + goto st118 + st118: + if p++; p == pe { + goto _test_eof118 + } + st_case_118: +// line 3661 "parseqt.go" + switch data[p] { + case 9: + goto tr153 + case 32: + goto tr153 + case 41: + goto tr139 + case 42: + goto tr132 + case 44: + goto tr139 + case 91: + goto tr141 + case 95: + goto st109 + case 111: + goto st119 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st109 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st109 + } + default: + goto st109 + } + goto st0 + st119: + if p++; p == pe { + goto _test_eof119 + } + st_case_119: + switch data[p] { + case 9: + goto tr153 + case 32: + goto tr153 + case 41: + goto tr139 + case 42: + goto tr132 + case 44: + goto tr139 + case 91: + goto tr141 + case 95: + goto st109 + case 110: + goto st120 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st109 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st109 + } + default: + goto st109 + } + goto st0 + st120: + if p++; p == pe { + goto _test_eof120 + } + st_case_120: + switch data[p] { + case 9: + goto tr153 + case 32: + goto tr153 + case 41: + goto tr139 + case 42: + goto tr132 + case 44: + goto tr139 + case 91: + goto tr141 + case 95: + goto st109 + case 115: + goto st121 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st109 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st109 + } + default: + goto st109 + } + goto st0 + st121: + if p++; p == pe { + goto _test_eof121 + } + st_case_121: + switch data[p] { + case 9: + goto tr153 + case 32: + goto tr153 + case 41: + goto tr139 + case 42: + goto tr132 + case 44: + goto tr139 + case 91: + goto tr141 + case 95: + goto st109 + case 116: + goto st122 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st109 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st109 + } + default: + goto st109 + } + goto st0 + st122: + if p++; p == pe { + goto _test_eof122 + } + st_case_122: + switch data[p] { + case 9: + goto tr153 + case 32: + goto tr153 + case 41: + goto tr139 + case 42: + goto tr132 + case 44: + goto tr139 + case 91: + goto tr141 + case 95: + goto tr166 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto tr166 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto tr166 + } + default: + goto tr166 + } + goto st0 +tr129: +// line 111 "parseqt.rl" + + m0 = p + goto st123 + st123: + if p++; p == pe { + goto _test_eof123 + } + st_case_123: +// line 3845 "parseqt.go" + switch data[p] { + case 9: + goto tr131 + case 32: + goto tr131 + case 42: + goto tr132 + case 95: + goto st97 + case 111: + goto st124 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st97 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st97 + } + default: + goto st97 + } + goto st0 + st124: + if p++; p == pe { + goto _test_eof124 + } + st_case_124: + switch data[p] { + case 9: + goto tr131 + case 32: + goto tr131 + case 42: + goto tr132 + case 95: + goto st97 + case 105: + goto st125 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st97 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st97 + } + default: + goto st97 + } + goto st0 + st125: + if p++; p == pe { + goto _test_eof125 + } + st_case_125: + switch data[p] { + case 9: + goto tr131 + case 32: + goto tr131 + case 42: + goto tr132 + case 95: + goto st97 + case 100: + goto st126 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st97 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st97 + } + default: + goto st97 + } + goto st0 + st126: + if p++; p == pe { + goto _test_eof126 + } + st_case_126: + switch data[p] { + case 9: + goto tr170 + case 32: + goto tr170 + case 41: + goto st96 + case 42: + goto tr132 + case 95: + goto st97 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st97 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st97 + } + default: + goto st97 + } + goto st0 +tr170: +// line 111 "parseqt.rl" + + m1 = p; m4 = 0 + goto st127 + st127: + if p++; p == pe { + goto _test_eof127 + } + st_case_127: +// line 3971 "parseqt.go" + switch data[p] { + case 9: + goto st127 + case 32: + goto st127 + case 41: + goto st96 + case 42: + goto tr135 + case 95: + goto tr136 + case 99: + goto tr137 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto tr136 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto tr136 + } + default: + goto tr136 + } + goto st0 + st128: + if p++; p == pe { + goto _test_eof128 + } + st_case_128: + switch data[p] { + case 9: + goto tr121 + case 32: + goto tr121 + case 40: + goto tr122 + case 95: + goto st93 + case 111: + goto st129 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st93 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st93 + } + default: + goto st93 + } + goto st0 + st129: + if p++; p == pe { + goto _test_eof129 + } + st_case_129: + switch data[p] { + case 9: + goto tr121 + case 32: + goto tr121 + case 40: + goto tr122 + case 95: + goto st93 + case 110: + goto st130 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st93 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st93 + } + default: + goto st93 + } + goto st0 + st130: + if p++; p == pe { + goto _test_eof130 + } + st_case_130: + switch data[p] { + case 9: + goto tr121 + case 32: + goto tr121 + case 40: + goto tr122 + case 95: + goto st93 + case 115: + goto st131 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st93 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st93 + } + default: + goto st93 + } + goto st0 + st131: + if p++; p == pe { + goto _test_eof131 + } + st_case_131: + switch data[p] { + case 9: + goto tr121 + case 32: + goto tr121 + case 40: + goto tr122 + case 95: + goto st93 + case 116: + goto st132 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st93 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st93 + } + default: + goto st93 + } + goto st0 + st132: + if p++; p == pe { + goto _test_eof132 + } + st_case_132: + switch data[p] { + case 9: + goto tr176 + case 32: + goto tr176 + case 40: + goto tr122 + case 59: + goto st67 + case 95: + goto st93 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st93 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st93 + } + default: + goto st93 + } + goto st0 +tr176: +// line 109 "parseqt.rl" + + m3 = p; f = Func{Name: data[m2:m3], Type: data[m0:m1], Addr: m4} + goto st133 + st133: + if p++; p == pe { + goto _test_eof133 + } + st_case_133: +// line 4161 "parseqt.go" + switch data[p] { + case 9: + goto st133 + case 32: + goto st133 + case 40: + goto tr124 + case 59: + goto st67 + case 123: + goto st73 + } + goto st0 + st134: + if p++; p == pe { + goto _test_eof134 + } + st_case_134: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 111: + goto st135 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st135: + if p++; p == pe { + goto _test_eof135 + } + st_case_135: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 110: + goto st136 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st136: + if p++; p == pe { + goto _test_eof136 + } + st_case_136: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 115: + goto st137 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st137: + if p++; p == pe { + goto _test_eof137 + } + st_case_137: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 116: + goto st138 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st138: + if p++; p == pe { + goto _test_eof138 + } + st_case_138: + switch data[p] { + case 9: + goto st139 + case 32: + goto st139 + case 40: + goto st75 + case 42: + goto tr87 + case 59: + goto st67 + case 95: + goto st65 + case 103: + goto tr183 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 +tr339: +// line 107 "parseqt.rl" + + m1 = p; m4 = 0 + goto st139 + st139: + if p++; p == pe { + goto _test_eof139 + } + st_case_139: +// line 4357 "parseqt.go" + switch data[p] { + case 9: + goto st139 + case 32: + goto st139 + case 42: + goto tr87 + case 59: + goto st67 + case 95: + goto st65 + case 99: + goto st134 + case 103: + goto tr90 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 +tr183: +// line 109 "parseqt.rl" + + m2 = p + goto st140 + st140: + if p++; p == pe { + goto _test_eof140 + } + st_case_140: +// line 4399 "parseqt.go" + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 108: + goto st141 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st141: + if p++; p == pe { + goto _test_eof141 + } + st_case_141: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st142 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st142 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st142 + } + default: + goto st142 + } + goto st0 + st142: + if p++; p == pe { + goto _test_eof142 + } + st_case_142: + switch data[p] { + case 9: + goto tr186 + case 32: + goto tr186 + case 40: + goto tr187 + case 59: + goto st67 + case 95: + goto st142 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st142 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st142 + } + default: + goto st142 + } + goto st0 +tr186: +// line 109 "parseqt.rl" + + m3 = p; f = Func{Name: data[m2:m3], Type: data[m0:m1], Addr: m4} + goto st143 + st143: + if p++; p == pe { + goto _test_eof143 + } + st_case_143: +// line 4503 "parseqt.go" + switch data[p] { + case 9: + goto st143 + case 32: + goto st143 + case 40: + goto tr124 + case 59: + goto st67 + case 99: + goto st68 + case 123: + goto st73 + } + goto st0 +tr187: +// line 109 "parseqt.rl" + + m3 = p; f = Func{Name: data[m2:m3], Type: data[m0:m1], Addr: m4} +// line 109 "parseqt.rl" + + m6 = 0 + goto st144 + st144: + if p++; p == pe { + goto _test_eof144 + } + st_case_144: +// line 4532 "parseqt.go" + switch data[p] { + case 9: + goto st144 + case 10: + goto st0 + case 32: + goto st144 + case 41: + goto st145 + case 95: + goto tr191 + case 99: + goto tr192 + case 118: + goto tr193 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto tr191 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto tr191 + } + default: + goto tr191 + } + goto st75 + st145: + if p++; p == pe { + goto _test_eof145 + } + st_case_145: + switch data[p] { + case 9: + goto st145 + case 10: + goto st0 + case 32: + goto st145 + case 41: + goto st76 + case 59: + goto tr194 + case 99: + goto st78 + case 123: + goto st83 + } + goto st75 +tr194: +// line 1 "NONE" + +te = p+1 + +// line 114 "parseqt.rl" + +act = 10; + goto st451 + st451: + if p++; p == pe { + goto _test_eof451 + } + st_case_451: +// line 4598 "parseqt.go" + switch data[p] { + case 9: + goto st77 + case 10: + goto tr96 + case 32: + goto st77 + case 41: + goto st76 + } + goto st75 +tr191: +// line 111 "parseqt.rl" + + m0 = p + goto st146 + st146: + if p++; p == pe { + goto _test_eof146 + } + st_case_146: +// line 4620 "parseqt.go" + switch data[p] { + case 9: + goto tr195 + case 10: + goto st0 + case 32: + goto tr195 + case 41: + goto st76 + case 42: + goto tr196 + case 95: + goto st146 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st146 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st146 + } + default: + goto st146 + } + goto st75 +tr195: +// line 111 "parseqt.rl" + + m1 = p; m4 = 0 + goto st147 + st147: + if p++; p == pe { + goto _test_eof147 + } + st_case_147: +// line 4658 "parseqt.go" + switch data[p] { + case 9: + goto st147 + case 10: + goto st0 + case 32: + goto st147 + case 41: + goto st76 + case 42: + goto tr199 + case 95: + goto tr200 + case 99: + goto tr201 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto tr200 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto tr200 + } + default: + goto tr200 + } + goto st75 +tr196: +// line 111 "parseqt.rl" + + m1 = p; m4 = 0 +// line 111 "parseqt.rl" + + m4++ + goto st148 +tr199: +// line 111 "parseqt.rl" + + m4++ + goto st148 + st148: + if p++; p == pe { + goto _test_eof148 + } + st_case_148: +// line 4706 "parseqt.go" + switch data[p] { + case 9: + goto st147 + case 10: + goto st0 + case 32: + goto st147 + case 41: + goto st76 + case 42: + goto tr199 + case 95: + goto tr200 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto tr200 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto tr200 + } + default: + goto tr200 + } + goto st75 +tr200: +// line 111 "parseqt.rl" + + m2 = p; m5 = 0 + goto st149 + st149: + if p++; p == pe { + goto _test_eof149 + } + st_case_149: +// line 4744 "parseqt.go" + switch data[p] { + case 9: + goto tr202 + case 10: + goto st0 + case 32: + goto tr202 + case 41: + goto tr203 + case 44: + goto tr204 + case 91: + goto tr206 + case 95: + goto st149 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st149 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st149 + } + default: + goto st149 + } + goto st75 +tr202: +// line 111 "parseqt.rl" + + m3 = p + goto st150 + st150: + if p++; p == pe { + goto _test_eof150 + } + st_case_150: +// line 4784 "parseqt.go" + switch data[p] { + case 9: + goto st150 + case 10: + goto st0 + case 32: + goto st150 + case 41: + goto tr208 + case 44: + goto tr209 + } + goto st75 +tr203: +// line 111 "parseqt.rl" + + m3 = p +// line 112 "parseqt.rl" + + f.Param = append(f.Param, Param{Name: data[m2:m3], Type: data[m0:m1], Addr: m4, Array: m5, Const: m6 > 0}); m6 = 0 + goto st151 +tr208: +// line 112 "parseqt.rl" + + f.Param = append(f.Param, Param{Name: data[m2:m3], Type: data[m0:m1], Addr: m4, Array: m5, Const: m6 > 0}); m6 = 0 + goto st151 + st151: + if p++; p == pe { + goto _test_eof151 + } + st_case_151: +// line 4816 "parseqt.go" + switch data[p] { + case 9: + goto st151 + case 10: + goto st0 + case 32: + goto st151 + case 41: + goto st76 + case 59: + goto tr194 + case 95: + goto tr191 + case 99: + goto tr211 + case 123: + goto st83 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto tr191 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto tr191 + } + default: + goto tr191 + } + goto st75 +tr211: +// line 111 "parseqt.rl" + + m0 = p + goto st152 + st152: + if p++; p == pe { + goto _test_eof152 + } + st_case_152: +// line 4858 "parseqt.go" + switch data[p] { + case 9: + goto tr195 + case 10: + goto st0 + case 32: + goto tr195 + case 41: + goto st76 + case 42: + goto tr196 + case 95: + goto st146 + case 111: + goto st153 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st146 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st146 + } + default: + goto st146 + } + goto st75 + st153: + if p++; p == pe { + goto _test_eof153 + } + st_case_153: + switch data[p] { + case 9: + goto tr195 + case 10: + goto st0 + case 32: + goto tr195 + case 41: + goto st76 + case 42: + goto tr196 + case 95: + goto st146 + case 110: + goto st154 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st146 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st146 + } + default: + goto st146 + } + goto st75 + st154: + if p++; p == pe { + goto _test_eof154 + } + st_case_154: + switch data[p] { + case 9: + goto tr195 + case 10: + goto st0 + case 32: + goto tr195 + case 41: + goto st76 + case 42: + goto tr196 + case 95: + goto st146 + case 115: + goto st155 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st146 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st146 + } + default: + goto st146 + } + goto st75 + st155: + if p++; p == pe { + goto _test_eof155 + } + st_case_155: + switch data[p] { + case 9: + goto tr195 + case 10: + goto st0 + case 32: + goto tr195 + case 41: + goto st76 + case 42: + goto tr196 + case 95: + goto st146 + case 116: + goto st156 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st146 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st146 + } + default: + goto st146 + } + goto st75 + st156: + if p++; p == pe { + goto _test_eof156 + } + st_case_156: + switch data[p] { + case 9: + goto tr216 + case 10: + goto st0 + case 32: + goto tr216 + case 41: + goto st76 + case 42: + goto tr196 + case 59: + goto st77 + case 95: + goto st146 + case 123: + goto st83 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st146 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st146 + } + default: + goto st146 + } + goto st75 +tr216: +// line 111 "parseqt.rl" + + m6 = 1 +// line 111 "parseqt.rl" + + m1 = p; m4 = 0 + goto st157 + st157: + if p++; p == pe { + goto _test_eof157 + } + st_case_157: +// line 5039 "parseqt.go" + switch data[p] { + case 9: + goto st157 + case 10: + goto st0 + case 32: + goto st157 + case 41: + goto st76 + case 42: + goto tr199 + case 59: + goto st77 + case 95: + goto tr218 + case 99: + goto tr219 + case 123: + goto st83 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto tr218 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto tr218 + } + default: + goto tr218 + } + goto st75 +tr236: +// line 111 "parseqt.rl" + + m2 = p; m5 = 0 + goto st158 +tr218: +// line 111 "parseqt.rl" + + m0 = p +// line 111 "parseqt.rl" + + m2 = p; m5 = 0 + goto st158 + st158: + if p++; p == pe { + goto _test_eof158 + } + st_case_158: +// line 5091 "parseqt.go" + switch data[p] { + case 9: + goto tr220 + case 10: + goto st0 + case 32: + goto tr220 + case 41: + goto tr203 + case 42: + goto tr196 + case 44: + goto tr204 + case 91: + goto tr206 + case 95: + goto st158 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st158 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st158 + } + default: + goto st158 + } + goto st75 +tr241: +// line 111 "parseqt.rl" + + m3 = p + goto st159 +tr220: +// line 111 "parseqt.rl" + + m1 = p; m4 = 0 +// line 111 "parseqt.rl" + + m3 = p + goto st159 + st159: + if p++; p == pe { + goto _test_eof159 + } + st_case_159: +// line 5141 "parseqt.go" + switch data[p] { + case 9: + goto st159 + case 10: + goto st0 + case 32: + goto st159 + case 41: + goto tr208 + case 42: + goto tr199 + case 44: + goto tr209 + case 95: + goto tr200 + case 99: + goto tr201 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto tr200 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto tr200 + } + default: + goto tr200 + } + goto st75 +tr204: +// line 111 "parseqt.rl" + + m3 = p +// line 112 "parseqt.rl" + + f.Param = append(f.Param, Param{Name: data[m2:m3], Type: data[m0:m1], Addr: m4, Array: m5, Const: m6 > 0}); m6 = 0 + goto st160 +tr209: +// line 112 "parseqt.rl" + + f.Param = append(f.Param, Param{Name: data[m2:m3], Type: data[m0:m1], Addr: m4, Array: m5, Const: m6 > 0}); m6 = 0 + goto st160 + st160: + if p++; p == pe { + goto _test_eof160 + } + st_case_160: +// line 5191 "parseqt.go" + switch data[p] { + case 9: + goto st160 + case 10: + goto st0 + case 32: + goto st160 + case 41: + goto st76 + case 59: + goto tr224 + case 95: + goto tr191 + case 99: + goto tr192 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto tr191 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto tr191 + } + default: + goto tr191 + } + goto st75 +tr224: +// line 1 "NONE" + +te = p+1 + +// line 114 "parseqt.rl" + +act = 10; + goto st452 + st452: + if p++; p == pe { + goto _test_eof452 + } + st_case_452: +// line 5235 "parseqt.go" + switch data[p] { + case 10: + goto tr533 + case 41: + goto st76 + } + goto st75 +tr192: +// line 111 "parseqt.rl" + + m0 = p + goto st161 + st161: + if p++; p == pe { + goto _test_eof161 + } + st_case_161: +// line 5253 "parseqt.go" + switch data[p] { + case 9: + goto tr195 + case 10: + goto st0 + case 32: + goto tr195 + case 41: + goto st76 + case 42: + goto tr196 + case 95: + goto st146 + case 111: + goto st162 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st146 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st146 + } + default: + goto st146 + } + goto st75 + st162: + if p++; p == pe { + goto _test_eof162 + } + st_case_162: + switch data[p] { + case 9: + goto tr195 + case 10: + goto st0 + case 32: + goto tr195 + case 41: + goto st76 + case 42: + goto tr196 + case 95: + goto st146 + case 110: + goto st163 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st146 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st146 + } + default: + goto st146 + } + goto st75 + st163: + if p++; p == pe { + goto _test_eof163 + } + st_case_163: + switch data[p] { + case 9: + goto tr195 + case 10: + goto st0 + case 32: + goto tr195 + case 41: + goto st76 + case 42: + goto tr196 + case 95: + goto st146 + case 115: + goto st164 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st146 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st146 + } + default: + goto st146 + } + goto st75 + st164: + if p++; p == pe { + goto _test_eof164 + } + st_case_164: + switch data[p] { + case 9: + goto tr195 + case 10: + goto st0 + case 32: + goto tr195 + case 41: + goto st76 + case 42: + goto tr196 + case 95: + goto st146 + case 116: + goto st165 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st146 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st146 + } + default: + goto st146 + } + goto st75 + st165: + if p++; p == pe { + goto _test_eof165 + } + st_case_165: + switch data[p] { + case 9: + goto tr229 + case 10: + goto st0 + case 32: + goto tr229 + case 41: + goto st76 + case 42: + goto tr196 + case 95: + goto st146 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st146 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st146 + } + default: + goto st146 + } + goto st75 +tr229: +// line 111 "parseqt.rl" + + m6 = 1 +// line 111 "parseqt.rl" + + m1 = p; m4 = 0 + goto st166 + st166: + if p++; p == pe { + goto _test_eof166 + } + st_case_166: +// line 5430 "parseqt.go" + switch data[p] { + case 9: + goto st166 + case 10: + goto st0 + case 32: + goto st166 + case 41: + goto st76 + case 42: + goto tr199 + case 95: + goto tr218 + case 99: + goto tr219 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto tr218 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto tr218 + } + default: + goto tr218 + } + goto st75 +tr219: +// line 111 "parseqt.rl" + + m0 = p +// line 111 "parseqt.rl" + + m2 = p; m5 = 0 + goto st167 + st167: + if p++; p == pe { + goto _test_eof167 + } + st_case_167: +// line 5473 "parseqt.go" + switch data[p] { + case 9: + goto tr220 + case 10: + goto st0 + case 32: + goto tr220 + case 41: + goto tr203 + case 42: + goto tr196 + case 44: + goto tr204 + case 91: + goto tr206 + case 95: + goto st158 + case 111: + goto st170 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st158 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st158 + } + default: + goto st158 + } + goto st75 +tr206: +// line 111 "parseqt.rl" + + m3 = p + goto st168 + st168: + if p++; p == pe { + goto _test_eof168 + } + st_case_168: +// line 5517 "parseqt.go" + switch data[p] { + case 10: + goto st0 + case 41: + goto st76 + } + if 48 <= data[p] && data[p] <= 57 { + goto tr232 + } + goto st75 +tr232: +// line 111 "parseqt.rl" + + m5 = m5*10 + (int(data[p]) - '0') + goto st169 + st169: + if p++; p == pe { + goto _test_eof169 + } + st_case_169: +// line 5538 "parseqt.go" + switch data[p] { + case 10: + goto st0 + case 41: + goto st76 + case 93: + goto st150 + } + if 48 <= data[p] && data[p] <= 57 { + goto tr232 + } + goto st75 + st170: + if p++; p == pe { + goto _test_eof170 + } + st_case_170: + switch data[p] { + case 9: + goto tr220 + case 10: + goto st0 + case 32: + goto tr220 + case 41: + goto tr203 + case 42: + goto tr196 + case 44: + goto tr204 + case 91: + goto tr206 + case 95: + goto st158 + case 110: + goto st171 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st158 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st158 + } + default: + goto st158 + } + goto st75 + st171: + if p++; p == pe { + goto _test_eof171 + } + st_case_171: + switch data[p] { + case 9: + goto tr220 + case 10: + goto st0 + case 32: + goto tr220 + case 41: + goto tr203 + case 42: + goto tr196 + case 44: + goto tr204 + case 91: + goto tr206 + case 95: + goto st158 + case 115: + goto st172 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st158 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st158 + } + default: + goto st158 + } + goto st75 + st172: + if p++; p == pe { + goto _test_eof172 + } + st_case_172: + switch data[p] { + case 9: + goto tr220 + case 10: + goto st0 + case 32: + goto tr220 + case 41: + goto tr203 + case 42: + goto tr196 + case 44: + goto tr204 + case 91: + goto tr206 + case 95: + goto st158 + case 116: + goto st173 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st158 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st158 + } + default: + goto st158 + } + goto st75 + st173: + if p++; p == pe { + goto _test_eof173 + } + st_case_173: + switch data[p] { + case 9: + goto tr220 + case 10: + goto st0 + case 32: + goto tr220 + case 41: + goto tr203 + case 42: + goto tr196 + case 44: + goto tr204 + case 91: + goto tr206 + case 95: + goto tr236 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto tr236 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto tr236 + } + default: + goto tr236 + } + goto st75 +tr201: +// line 111 "parseqt.rl" + + m2 = p; m5 = 0 + goto st174 + st174: + if p++; p == pe { + goto _test_eof174 + } + st_case_174: +// line 5711 "parseqt.go" + switch data[p] { + case 9: + goto tr202 + case 10: + goto st0 + case 32: + goto tr202 + case 41: + goto tr203 + case 44: + goto tr204 + case 91: + goto tr206 + case 95: + goto st149 + case 111: + goto st175 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st149 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st149 + } + default: + goto st149 + } + goto st75 + st175: + if p++; p == pe { + goto _test_eof175 + } + st_case_175: + switch data[p] { + case 9: + goto tr202 + case 10: + goto st0 + case 32: + goto tr202 + case 41: + goto tr203 + case 44: + goto tr204 + case 91: + goto tr206 + case 95: + goto st149 + case 110: + goto st176 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st149 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st149 + } + default: + goto st149 + } + goto st75 + st176: + if p++; p == pe { + goto _test_eof176 + } + st_case_176: + switch data[p] { + case 9: + goto tr202 + case 10: + goto st0 + case 32: + goto tr202 + case 41: + goto tr203 + case 44: + goto tr204 + case 91: + goto tr206 + case 95: + goto st149 + case 115: + goto st177 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st149 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st149 + } + default: + goto st149 + } + goto st75 + st177: + if p++; p == pe { + goto _test_eof177 + } + st_case_177: + switch data[p] { + case 9: + goto tr202 + case 10: + goto st0 + case 32: + goto tr202 + case 41: + goto tr203 + case 44: + goto tr204 + case 91: + goto tr206 + case 95: + goto st149 + case 116: + goto st178 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st149 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st149 + } + default: + goto st149 + } + goto st75 + st178: + if p++; p == pe { + goto _test_eof178 + } + st_case_178: + switch data[p] { + case 9: + goto tr241 + case 10: + goto st0 + case 32: + goto tr241 + case 41: + goto tr203 + case 42: + goto tr199 + case 44: + goto tr204 + case 91: + goto tr206 + case 95: + goto tr200 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto tr200 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto tr200 + } + default: + goto tr200 + } + goto st75 +tr193: +// line 111 "parseqt.rl" + + m0 = p + goto st179 + st179: + if p++; p == pe { + goto _test_eof179 + } + st_case_179: +// line 5897 "parseqt.go" + switch data[p] { + case 9: + goto tr195 + case 10: + goto st0 + case 32: + goto tr195 + case 41: + goto st76 + case 42: + goto tr196 + case 95: + goto st146 + case 111: + goto st180 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st146 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st146 + } + default: + goto st146 + } + goto st75 + st180: + if p++; p == pe { + goto _test_eof180 + } + st_case_180: + switch data[p] { + case 9: + goto tr195 + case 10: + goto st0 + case 32: + goto tr195 + case 41: + goto st76 + case 42: + goto tr196 + case 95: + goto st146 + case 105: + goto st181 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st146 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st146 + } + default: + goto st146 + } + goto st75 + st181: + if p++; p == pe { + goto _test_eof181 + } + st_case_181: + switch data[p] { + case 9: + goto tr195 + case 10: + goto st0 + case 32: + goto tr195 + case 41: + goto st76 + case 42: + goto tr196 + case 95: + goto st146 + case 100: + goto st182 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st146 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st146 + } + default: + goto st146 + } + goto st75 + st182: + if p++; p == pe { + goto _test_eof182 + } + st_case_182: + switch data[p] { + case 9: + goto tr245 + case 10: + goto st0 + case 32: + goto tr245 + case 41: + goto st145 + case 42: + goto tr196 + case 95: + goto st146 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st146 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st146 + } + default: + goto st146 + } + goto st75 +tr245: +// line 111 "parseqt.rl" + + m1 = p; m4 = 0 + goto st183 + st183: + if p++; p == pe { + goto _test_eof183 + } + st_case_183: +// line 6037 "parseqt.go" + switch data[p] { + case 9: + goto st183 + case 10: + goto st0 + case 32: + goto st183 + case 41: + goto st145 + case 42: + goto tr199 + case 95: + goto tr200 + case 99: + goto tr201 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto tr200 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto tr200 + } + default: + goto tr200 + } + goto st75 +tr83: +// line 84 "parseqt.rl" + + m1 = p + goto st184 + st184: + if p++; p == pe { + goto _test_eof184 + } + st_case_184: +// line 6077 "parseqt.go" + if data[p] == 41 { + goto st185 + } + goto st0 + st185: + if p++; p == pe { + goto _test_eof185 + } + st_case_185: + switch data[p] { + case 9: + goto st185 + case 32: + goto st185 + case 59: + goto st186 + case 123: + goto st187 + } + goto st0 + st186: + if p++; p == pe { + goto _test_eof186 + } + st_case_186: + switch data[p] { + case 9: + goto st186 + case 10: + goto tr250 + case 32: + goto st186 + } + goto st0 + st187: + if p++; p == pe { + goto _test_eof187 + } + st_case_187: + if data[p] == 125 { + goto st186 + } + goto st0 + st188: + if p++; p == pe { + goto _test_eof188 + } + st_case_188: + switch data[p] { + case 9: + goto st189 + case 32: + goto st189 + case 42: + goto tr252 + case 95: + goto st188 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 58 { + goto st188 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st188 + } + default: + goto st188 + } + goto st0 + st189: + if p++; p == pe { + goto _test_eof189 + } + st_case_189: + switch data[p] { + case 9: + goto st189 + case 32: + goto st189 + case 42: + goto tr252 + case 95: + goto st65 + case 99: + goto st193 + case 103: + goto st191 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 +tr252: +// line 127 "parseqt.rl" + + m4++ + goto st190 + st190: + if p++; p == pe { + goto _test_eof190 + } + st_case_190: +// line 6191 "parseqt.go" + switch data[p] { + case 9: + goto st189 + case 32: + goto st189 + case 42: + goto tr252 + case 95: + goto st65 + case 103: + goto st191 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st191: + if p++; p == pe { + goto _test_eof191 + } + st_case_191: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 108: + goto st192 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st192: + if p++; p == pe { + goto _test_eof192 + } + st_case_192: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 99: + goto st68 + case 123: + goto st73 + } + goto st0 + st193: + if p++; p == pe { + goto _test_eof193 + } + st_case_193: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 111: + goto st194 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st194: + if p++; p == pe { + goto _test_eof194 + } + st_case_194: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 110: + goto st195 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st195: + if p++; p == pe { + goto _test_eof195 + } + st_case_195: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 115: + goto st196 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st196: + if p++; p == pe { + goto _test_eof196 + } + st_case_196: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 116: + goto st197 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st197: + if p++; p == pe { + goto _test_eof197 + } + st_case_197: + switch data[p] { + case 9: + goto st198 + case 32: + goto st198 + case 40: + goto st75 + case 42: + goto tr252 + case 59: + goto st67 + case 95: + goto st65 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st198: + if p++; p == pe { + goto _test_eof198 + } + st_case_198: + switch data[p] { + case 9: + goto st198 + case 32: + goto st198 + case 42: + goto tr252 + case 59: + goto st67 + case 95: + goto st65 + case 99: + goto st193 + case 103: + goto st191 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 +tr67: +// line 84 "parseqt.rl" + + m0 = p +// line 107 "parseqt.rl" + + m0 = p + goto st199 + st199: + if p++; p == pe { + goto _test_eof199 + } + st_case_199: +// line 6490 "parseqt.go" + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st200 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st200: + if p++; p == pe { + goto _test_eof200 + } + st_case_200: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 68: + goto st201 + case 95: + goto st62 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st201: + if p++; p == pe { + goto _test_eof201 + } + st_case_201: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 69: + goto st202 + case 95: + goto st62 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st202: + if p++; p == pe { + goto _test_eof202 + } + st_case_202: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 67: + goto st203 + case 95: + goto st62 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st203: + if p++; p == pe { + goto _test_eof203 + } + st_case_203: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 76: + goto st204 + case 95: + goto st62 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st204: + if p++; p == pe { + goto _test_eof204 + } + st_case_204: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 65: + goto st205 + case 95: + goto st62 + } + switch { + case data[p] < 66: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st205: + if p++; p == pe { + goto _test_eof205 + } + st_case_205: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 82: + goto st206 + case 95: + goto st62 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st206: + if p++; p == pe { + goto _test_eof206 + } + st_case_206: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 69: + goto st207 + case 95: + goto st62 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st207: + if p++; p == pe { + goto _test_eof207 + } + st_case_207: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st208 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st208: + if p++; p == pe { + goto _test_eof208 + } + st_case_208: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 70: + goto st209 + case 95: + goto st62 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st209: + if p++; p == pe { + goto _test_eof209 + } + st_case_209: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 76: + goto st210 + case 95: + goto st62 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st210: + if p++; p == pe { + goto _test_eof210 + } + st_case_210: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 65: + goto st211 + case 95: + goto st62 + } + switch { + case data[p] < 66: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st211: + if p++; p == pe { + goto _test_eof211 + } + st_case_211: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 71: + goto st212 + case 95: + goto st62 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st212: + if p++; p == pe { + goto _test_eof212 + } + st_case_212: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 83: + goto st213 + case 95: + goto st62 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st213: + if p++; p == pe { + goto _test_eof213 + } + st_case_213: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr275 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 +tr275: +// line 84 "parseqt.rl" + + m1 = p + goto st214 + st214: + if p++; p == pe { + goto _test_eof214 + } + st_case_214: +// line 7000 "parseqt.go" + switch data[p] { + case 10: + goto st0 + case 41: + goto st217 + } + goto st215 + st215: + if p++; p == pe { + goto _test_eof215 + } + st_case_215: + switch data[p] { + case 10: + goto st0 + case 41: + goto st216 + } + goto st215 + st216: + if p++; p == pe { + goto _test_eof216 + } + st_case_216: + switch data[p] { + case 9: + goto st216 + case 10: + goto tr279 + case 32: + goto st216 + case 41: + goto st216 + } + goto st215 + st217: + if p++; p == pe { + goto _test_eof217 + } + st_case_217: + switch data[p] { + case 9: + goto st217 + case 10: + goto st0 + case 32: + goto st217 + case 41: + goto st216 + case 59: + goto st218 + case 123: + goto st219 + } + goto st215 + st218: + if p++; p == pe { + goto _test_eof218 + } + st_case_218: + switch data[p] { + case 9: + goto st218 + case 10: + goto tr250 + case 32: + goto st218 + case 41: + goto st216 + } + goto st215 + st219: + if p++; p == pe { + goto _test_eof219 + } + st_case_219: + switch data[p] { + case 10: + goto st0 + case 41: + goto st216 + case 125: + goto st218 + } + goto st215 +tr68: +// line 84 "parseqt.rl" + + m0 = p +// line 107 "parseqt.rl" + + m0 = p + goto st220 + st220: + if p++; p == pe { + goto _test_eof220 + } + st_case_220: +// line 7099 "parseqt.go" + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 111: + goto st221 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st221: + if p++; p == pe { + goto _test_eof221 + } + st_case_221: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 111: + goto st222 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st222: + if p++; p == pe { + goto _test_eof222 + } + st_case_222: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 108: + goto st223 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st223: + if p++; p == pe { + goto _test_eof223 + } + st_case_223: + switch data[p] { + case 9: + goto tr285 + case 32: + goto tr285 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 +tr285: +// line 107 "parseqt.rl" + + m1 = p; m4 = 0 + goto st224 + st224: + if p++; p == pe { + goto _test_eof224 + } + st_case_224: +// line 7239 "parseqt.go" + switch data[p] { + case 9: + goto st224 + case 32: + goto st224 + case 42: + goto tr87 + case 95: + goto st65 + case 99: + goto st134 + case 103: + goto tr90 + case 105: + goto st225 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st225: + if p++; p == pe { + goto _test_eof225 + } + st_case_225: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 110: + goto st226 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st226: + if p++; p == pe { + goto _test_eof226 + } + st_case_226: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 105: + goto st227 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st227: + if p++; p == pe { + goto _test_eof227 + } + st_case_227: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 116: + goto st228 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st228: + if p++; p == pe { + goto _test_eof228 + } + st_case_228: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 105: + goto st229 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st229: + if p++; p == pe { + goto _test_eof229 + } + st_case_229: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 97: + goto st230 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 98 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st230: + if p++; p == pe { + goto _test_eof230 + } + st_case_230: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 108: + goto st231 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st231: + if p++; p == pe { + goto _test_eof231 + } + st_case_231: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 105: + goto st232 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st232: + if p++; p == pe { + goto _test_eof232 + } + st_case_232: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 122: + goto st233 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 121 { + goto st65 + } + default: + goto st65 + } + goto st0 + st233: + if p++; p == pe { + goto _test_eof233 + } + st_case_233: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 101: + goto st234 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st234: + if p++; p == pe { + goto _test_eof234 + } + st_case_234: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 79: + goto st235 + case 95: + goto st65 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st235: + if p++; p == pe { + goto _test_eof235 + } + st_case_235: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 112: + goto st236 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st236: + if p++; p == pe { + goto _test_eof236 + } + st_case_236: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 101: + goto st237 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st237: + if p++; p == pe { + goto _test_eof237 + } + st_case_237: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 110: + goto st238 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st238: + if p++; p == pe { + goto _test_eof238 + } + st_case_238: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 71: + goto st239 + case 95: + goto st65 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st239: + if p++; p == pe { + goto _test_eof239 + } + st_case_239: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 76: + goto st240 + case 95: + goto st65 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st240: + if p++; p == pe { + goto _test_eof240 + } + st_case_240: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 70: + goto st241 + case 95: + goto st65 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st241: + if p++; p == pe { + goto _test_eof241 + } + st_case_241: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 117: + goto st242 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st242: + if p++; p == pe { + goto _test_eof242 + } + st_case_242: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 110: + goto st243 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st243: + if p++; p == pe { + goto _test_eof243 + } + st_case_243: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 99: + goto st244 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st244: + if p++; p == pe { + goto _test_eof244 + } + st_case_244: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 116: + goto st245 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st245: + if p++; p == pe { + goto _test_eof245 + } + st_case_245: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 105: + goto st246 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st246: + if p++; p == pe { + goto _test_eof246 + } + st_case_246: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 111: + goto st247 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st247: + if p++; p == pe { + goto _test_eof247 + } + st_case_247: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 110: + goto st248 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st248: + if p++; p == pe { + goto _test_eof248 + } + st_case_248: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 115: + goto st249 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st249: + if p++; p == pe { + goto _test_eof249 + } + st_case_249: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st250 + case 59: + goto st67 + case 95: + goto st65 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st250: + if p++; p == pe { + goto _test_eof250 + } + st_case_250: + switch data[p] { + case 10: + goto st0 + case 41: + goto st251 + } + goto st75 + st251: + if p++; p == pe { + goto _test_eof251 + } + st_case_251: + switch data[p] { + case 9: + goto st251 + case 10: + goto tr315 + case 32: + goto st251 + case 41: + goto st251 + case 59: + goto st253 + case 99: + goto st254 + case 123: + goto st259 + } + goto st252 + st252: + if p++; p == pe { + goto _test_eof252 + } + st_case_252: + switch data[p] { + case 10: + goto tr315 + case 41: + goto st251 + } + goto st252 + st253: + if p++; p == pe { + goto _test_eof253 + } + st_case_253: + switch data[p] { + case 9: + goto st253 + case 10: + goto tr315 + case 32: + goto st253 + case 41: + goto st251 + } + goto st252 + st254: + if p++; p == pe { + goto _test_eof254 + } + st_case_254: + switch data[p] { + case 10: + goto tr315 + case 41: + goto st251 + case 111: + goto st255 + } + goto st252 + st255: + if p++; p == pe { + goto _test_eof255 + } + st_case_255: + switch data[p] { + case 10: + goto tr315 + case 41: + goto st251 + case 110: + goto st256 + } + goto st252 + st256: + if p++; p == pe { + goto _test_eof256 + } + st_case_256: + switch data[p] { + case 10: + goto tr315 + case 41: + goto st251 + case 115: + goto st257 + } + goto st252 + st257: + if p++; p == pe { + goto _test_eof257 + } + st_case_257: + switch data[p] { + case 10: + goto tr315 + case 41: + goto st251 + case 116: + goto st258 + } + goto st252 + st258: + if p++; p == pe { + goto _test_eof258 + } + st_case_258: + switch data[p] { + case 9: + goto st258 + case 10: + goto tr315 + case 32: + goto st258 + case 41: + goto st251 + case 59: + goto st253 + case 123: + goto st259 + } + goto st252 + st259: + if p++; p == pe { + goto _test_eof259 + } + st_case_259: + switch data[p] { + case 10: + goto tr315 + case 41: + goto st260 + case 125: + goto st261 + } + goto st259 + st260: + if p++; p == pe { + goto _test_eof260 + } + st_case_260: + switch data[p] { + case 9: + goto st260 + case 10: + goto tr315 + case 32: + goto st260 + case 41: + goto st260 + case 59: + goto st261 + case 99: + goto st262 + case 125: + goto st261 + } + goto st259 + st261: + if p++; p == pe { + goto _test_eof261 + } + st_case_261: + switch data[p] { + case 9: + goto st261 + case 10: + goto tr315 + case 32: + goto st261 + case 41: + goto st260 + case 125: + goto st261 + } + goto st259 + st262: + if p++; p == pe { + goto _test_eof262 + } + st_case_262: + switch data[p] { + case 10: + goto tr315 + case 41: + goto st260 + case 111: + goto st263 + case 125: + goto st261 + } + goto st259 + st263: + if p++; p == pe { + goto _test_eof263 + } + st_case_263: + switch data[p] { + case 10: + goto tr315 + case 41: + goto st260 + case 110: + goto st264 + case 125: + goto st261 + } + goto st259 + st264: + if p++; p == pe { + goto _test_eof264 + } + st_case_264: + switch data[p] { + case 10: + goto tr315 + case 41: + goto st260 + case 115: + goto st265 + case 125: + goto st261 + } + goto st259 + st265: + if p++; p == pe { + goto _test_eof265 + } + st_case_265: + switch data[p] { + case 10: + goto tr315 + case 41: + goto st260 + case 116: + goto st266 + case 125: + goto st261 + } + goto st259 + st266: + if p++; p == pe { + goto _test_eof266 + } + st_case_266: + switch data[p] { + case 9: + goto st266 + case 10: + goto tr315 + case 32: + goto st266 + case 41: + goto st260 + case 59: + goto st261 + case 125: + goto st261 + } + goto st259 +tr69: +// line 84 "parseqt.rl" + + m0 = p +// line 107 "parseqt.rl" + + m0 = p + goto st267 + st267: + if p++; p == pe { + goto _test_eof267 + } + st_case_267: +// line 8406 "parseqt.go" + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 111: + goto st268 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st268: + if p++; p == pe { + goto _test_eof268 + } + st_case_268: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 110: + goto st269 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st269: + if p++; p == pe { + goto _test_eof269 + } + st_case_269: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 115: + goto st270 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st270: + if p++; p == pe { + goto _test_eof270 + } + st_case_270: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 116: + goto st271 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st271: + if p++; p == pe { + goto _test_eof271 + } + st_case_271: + switch data[p] { + case 9: + goto tr334 + case 32: + goto tr334 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 +tr334: +// line 107 "parseqt.rl" + + m1 = p; m4 = 0 + goto st272 + st272: + if p++; p == pe { + goto _test_eof272 + } + st_case_272: +// line 8580 "parseqt.go" + switch data[p] { + case 9: + goto st272 + case 32: + goto st272 + case 42: + goto tr87 + case 58: + goto st188 + case 95: + goto tr336 + case 99: + goto tr337 + case 103: + goto tr338 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto tr336 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto tr336 + } + default: + goto tr336 + } + goto st0 +tr336: +// line 107 "parseqt.rl" + + m0 = p + goto st273 + st273: + if p++; p == pe { + goto _test_eof273 + } + st_case_273: +// line 8620 "parseqt.go" + switch data[p] { + case 9: + goto tr339 + case 32: + goto tr339 + case 40: + goto st75 + case 42: + goto tr84 + case 58: + goto st188 + case 59: + goto st67 + case 95: + goto st273 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st273 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st273 + } + default: + goto st273 + } + goto st0 +tr337: +// line 107 "parseqt.rl" + + m0 = p + goto st274 + st274: + if p++; p == pe { + goto _test_eof274 + } + st_case_274: +// line 8662 "parseqt.go" + switch data[p] { + case 9: + goto tr339 + case 32: + goto tr339 + case 40: + goto st75 + case 42: + goto tr84 + case 58: + goto st188 + case 59: + goto st67 + case 95: + goto st273 + case 111: + goto st275 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st273 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st273 + } + default: + goto st273 + } + goto st0 + st275: + if p++; p == pe { + goto _test_eof275 + } + st_case_275: + switch data[p] { + case 9: + goto tr339 + case 32: + goto tr339 + case 40: + goto st75 + case 42: + goto tr84 + case 58: + goto st188 + case 59: + goto st67 + case 95: + goto st273 + case 110: + goto st276 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st273 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st273 + } + default: + goto st273 + } + goto st0 + st276: + if p++; p == pe { + goto _test_eof276 + } + st_case_276: + switch data[p] { + case 9: + goto tr339 + case 32: + goto tr339 + case 40: + goto st75 + case 42: + goto tr84 + case 58: + goto st188 + case 59: + goto st67 + case 95: + goto st273 + case 115: + goto st277 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st273 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st273 + } + default: + goto st273 + } + goto st0 + st277: + if p++; p == pe { + goto _test_eof277 + } + st_case_277: + switch data[p] { + case 9: + goto tr339 + case 32: + goto tr339 + case 40: + goto st75 + case 42: + goto tr84 + case 58: + goto st188 + case 59: + goto st67 + case 95: + goto st273 + case 116: + goto st278 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st273 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st273 + } + default: + goto st273 + } + goto st0 + st278: + if p++; p == pe { + goto _test_eof278 + } + st_case_278: + switch data[p] { + case 9: + goto tr339 + case 32: + goto tr339 + case 40: + goto st75 + case 42: + goto tr84 + case 58: + goto st188 + case 59: + goto st67 + case 95: + goto st273 + case 103: + goto tr345 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st273 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st273 + } + default: + goto st273 + } + goto st0 +tr345: +// line 109 "parseqt.rl" + + m2 = p + goto st279 + st279: + if p++; p == pe { + goto _test_eof279 + } + st_case_279: +// line 8858 "parseqt.go" + switch data[p] { + case 9: + goto tr339 + case 32: + goto tr339 + case 40: + goto st75 + case 42: + goto tr84 + case 58: + goto st188 + case 59: + goto st67 + case 95: + goto st273 + case 108: + goto st280 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st273 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st273 + } + default: + goto st273 + } + goto st0 + st280: + if p++; p == pe { + goto _test_eof280 + } + st_case_280: + switch data[p] { + case 9: + goto tr339 + case 32: + goto tr339 + case 40: + goto st75 + case 42: + goto tr84 + case 58: + goto st188 + case 59: + goto st67 + case 95: + goto st281 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st281 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st281 + } + default: + goto st281 + } + goto st0 + st281: + if p++; p == pe { + goto _test_eof281 + } + st_case_281: + switch data[p] { + case 9: + goto tr348 + case 32: + goto tr348 + case 40: + goto tr187 + case 42: + goto tr84 + case 58: + goto st188 + case 59: + goto st67 + case 95: + goto st281 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st281 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st281 + } + default: + goto st281 + } + goto st0 +tr348: +// line 107 "parseqt.rl" + + m1 = p; m4 = 0 +// line 109 "parseqt.rl" + + m3 = p; f = Func{Name: data[m2:m3], Type: data[m0:m1], Addr: m4} + goto st282 + st282: + if p++; p == pe { + goto _test_eof282 + } + st_case_282: +// line 8977 "parseqt.go" + switch data[p] { + case 9: + goto st282 + case 32: + goto st282 + case 40: + goto tr124 + case 42: + goto tr87 + case 59: + goto st67 + case 95: + goto st65 + case 99: + goto st134 + case 103: + goto tr90 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 +tr338: +// line 107 "parseqt.rl" + + m0 = p +// line 109 "parseqt.rl" + + m2 = p + goto st283 + st283: + if p++; p == pe { + goto _test_eof283 + } + st_case_283: +// line 9024 "parseqt.go" + switch data[p] { + case 9: + goto tr339 + case 32: + goto tr339 + case 40: + goto st75 + case 42: + goto tr84 + case 58: + goto st188 + case 59: + goto st67 + case 95: + goto st273 + case 108: + goto st284 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st273 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st273 + } + default: + goto st273 + } + goto st0 + st284: + if p++; p == pe { + goto _test_eof284 + } + st_case_284: + switch data[p] { + case 9: + goto tr339 + case 32: + goto tr339 + case 40: + goto st75 + case 42: + goto tr84 + case 58: + goto st188 + case 59: + goto st67 + case 95: + goto st285 + case 99: + goto st287 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st285 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st285 + } + default: + goto st285 + } + goto st0 + st285: + if p++; p == pe { + goto _test_eof285 + } + st_case_285: + switch data[p] { + case 9: + goto tr353 + case 32: + goto tr353 + case 40: + goto tr122 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st285 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st285 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st285 + } + default: + goto st285 + } + goto st0 +tr353: +// line 107 "parseqt.rl" + + m1 = p; m4 = 0 +// line 109 "parseqt.rl" + + m3 = p; f = Func{Name: data[m2:m3], Type: data[m0:m1], Addr: m4} + goto st286 + st286: + if p++; p == pe { + goto _test_eof286 + } + st_case_286: +// line 9141 "parseqt.go" + switch data[p] { + case 9: + goto st286 + case 32: + goto st286 + case 40: + goto tr124 + case 42: + goto tr87 + case 95: + goto st65 + case 99: + goto st134 + case 103: + goto tr90 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st287: + if p++; p == pe { + goto _test_eof287 + } + st_case_287: + switch data[p] { + case 9: + goto tr353 + case 32: + goto tr353 + case 40: + goto tr122 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st285 + case 111: + goto st288 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st285 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st285 + } + default: + goto st285 + } + goto st0 + st288: + if p++; p == pe { + goto _test_eof288 + } + st_case_288: + switch data[p] { + case 9: + goto tr353 + case 32: + goto tr353 + case 40: + goto tr122 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st285 + case 110: + goto st289 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st285 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st285 + } + default: + goto st285 + } + goto st0 + st289: + if p++; p == pe { + goto _test_eof289 + } + st_case_289: + switch data[p] { + case 9: + goto tr353 + case 32: + goto tr353 + case 40: + goto tr122 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st285 + case 115: + goto st290 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st285 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st285 + } + default: + goto st285 + } + goto st0 + st290: + if p++; p == pe { + goto _test_eof290 + } + st_case_290: + switch data[p] { + case 9: + goto tr353 + case 32: + goto tr353 + case 40: + goto tr122 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st285 + case 116: + goto st291 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st285 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st285 + } + default: + goto st285 + } + goto st0 + st291: + if p++; p == pe { + goto _test_eof291 + } + st_case_291: + switch data[p] { + case 9: + goto tr348 + case 32: + goto tr348 + case 40: + goto tr122 + case 42: + goto tr84 + case 58: + goto st188 + case 59: + goto st67 + case 95: + goto st285 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st285 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st285 + } + default: + goto st285 + } + goto st0 +tr70: +// line 84 "parseqt.rl" + + m0 = p +// line 107 "parseqt.rl" + + m0 = p + goto st292 + st292: + if p++; p == pe { + goto _test_eof292 + } + st_case_292: +// line 9356 "parseqt.go" + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 110: + goto st293 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st293: + if p++; p == pe { + goto _test_eof293 + } + st_case_293: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 117: + goto st294 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st294: + if p++; p == pe { + goto _test_eof294 + } + st_case_294: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 109: + goto st295 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st295: + if p++; p == pe { + goto _test_eof295 + } + st_case_295: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr362 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 +tr362: +// line 107 "parseqt.rl" + + m1 = p; m4 = 0 + goto st296 + st296: + if p++; p == pe { + goto _test_eof296 + } + st_case_296: +// line 9496 "parseqt.go" + switch data[p] { + case 9: + goto st63 + case 32: + goto st63 + case 42: + goto tr87 + case 79: + goto st297 + case 95: + goto st65 + case 99: + goto st134 + case 103: + goto tr90 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st297: + if p++; p == pe { + goto _test_eof297 + } + st_case_297: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 112: + goto st298 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st298: + if p++; p == pe { + goto _test_eof298 + } + st_case_298: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 101: + goto st299 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st299: + if p++; p == pe { + goto _test_eof299 + } + st_case_299: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 110: + goto st300 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st300: + if p++; p == pe { + goto _test_eof300 + } + st_case_300: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 71: + goto st301 + case 95: + goto st65 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st301: + if p++; p == pe { + goto _test_eof301 + } + st_case_301: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 76: + goto st302 + case 95: + goto st65 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st302: + if p++; p == pe { + goto _test_eof302 + } + st_case_302: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 70: + goto st303 + case 95: + goto st65 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st303: + if p++; p == pe { + goto _test_eof303 + } + st_case_303: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 101: + goto st304 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st304: + if p++; p == pe { + goto _test_eof304 + } + st_case_304: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 97: + goto st305 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 98 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st305: + if p++; p == pe { + goto _test_eof305 + } + st_case_305: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 116: + goto st306 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st306: + if p++; p == pe { + goto _test_eof306 + } + st_case_306: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 117: + goto st307 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st307: + if p++; p == pe { + goto _test_eof307 + } + st_case_307: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 114: + goto st308 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st308: + if p++; p == pe { + goto _test_eof308 + } + st_case_308: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 101: + goto st309 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st309: + if p++; p == pe { + goto _test_eof309 + } + st_case_309: + switch data[p] { + case 9: + goto st310 + case 10: + goto tr377 + case 32: + goto st310 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st310: + if p++; p == pe { + goto _test_eof310 + } + st_case_310: + switch data[p] { + case 9: + goto st310 + case 10: + goto tr377 + case 32: + goto st310 + case 59: + goto st67 + case 99: + goto st68 + case 123: + goto st73 + } + goto st0 +tr377: +// line 47 "parseqt.rl" + + curline++ + goto st311 + st311: + if p++; p == pe { + goto _test_eof311 + } + st_case_311: +// line 9998 "parseqt.go" + switch data[p] { + case 9: + goto st311 + case 32: + goto st311 + case 123: + goto st312 + } + goto st0 + st312: + if p++; p == pe { + goto _test_eof312 + } + st_case_312: + switch data[p] { + case 9: + goto st312 + case 10: + goto tr380 + case 32: + goto st312 + } + goto st0 +tr380: +// line 47 "parseqt.rl" + + curline++ + goto st313 + st313: + if p++; p == pe { + goto _test_eof313 + } + st_case_313: +// line 10032 "parseqt.go" + switch data[p] { + case 9: + goto st313 + case 32: + goto st313 + case 95: + goto tr382 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto tr382 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto tr382 + } + default: + goto tr382 + } + goto st0 +tr382: +// line 122 "parseqt.rl" + + m0 = p + goto st314 + st314: + if p++; p == pe { + goto _test_eof314 + } + st_case_314: +// line 10064 "parseqt.go" + switch data[p] { + case 9: + goto tr383 + case 32: + goto tr383 + case 61: + goto tr385 + case 95: + goto st314 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st314 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st314 + } + default: + goto st314 + } + goto st0 +tr383: +// line 122 "parseqt.rl" + + m1 = p + goto st315 + st315: + if p++; p == pe { + goto _test_eof315 + } + st_case_315: +// line 10098 "parseqt.go" + switch data[p] { + case 9: + goto st315 + case 32: + goto st315 + case 61: + goto st316 + } + goto st0 +tr385: +// line 122 "parseqt.rl" + + m1 = p + goto st316 + st316: + if p++; p == pe { + goto _test_eof316 + } + st_case_316: +// line 10118 "parseqt.go" + switch data[p] { + case 9: + goto st316 + case 32: + goto st316 + case 48: + goto tr388 + } + goto st0 +tr388: +// line 122 "parseqt.rl" + + m2 = p + goto st317 + st317: + if p++; p == pe { + goto _test_eof317 + } + st_case_317: +// line 10138 "parseqt.go" + if data[p] == 120 { + goto st318 + } + goto st0 + st318: + if p++; p == pe { + goto _test_eof318 + } + st_case_318: + if 48 <= data[p] && data[p] <= 57 { + goto st319 + } + goto st0 + st319: + if p++; p == pe { + goto _test_eof319 + } + st_case_319: + switch data[p] { + case 9: + goto tr391 + case 10: + goto tr392 + case 32: + goto tr391 + case 44: + goto tr391 + } + if 48 <= data[p] && data[p] <= 57 { + goto st319 + } + goto st0 +tr391: +// line 122 "parseqt.rl" + + m3 = p + goto st320 + st320: + if p++; p == pe { + goto _test_eof320 + } + st_case_320: +// line 10181 "parseqt.go" + switch data[p] { + case 9: + goto st320 + case 10: + goto tr394 + case 32: + goto st320 + } + goto st0 +tr392: +// line 122 "parseqt.rl" + + m3 = p +// line 123 "parseqt.rl" + + header.FeatureFlags = append(header.FeatureFlags, Const{Name: data[m0:m1], Value: data[m2:m3]}) +// line 47 "parseqt.rl" + + curline++ + goto st321 +tr394: +// line 123 "parseqt.rl" + + header.FeatureFlags = append(header.FeatureFlags, Const{Name: data[m0:m1], Value: data[m2:m3]}) +// line 47 "parseqt.rl" + + curline++ + goto st321 + st321: + if p++; p == pe { + goto _test_eof321 + } + st_case_321: +// line 10215 "parseqt.go" + switch data[p] { + case 9: + goto st321 + case 32: + goto st321 + case 95: + goto tr382 + case 125: + goto st322 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto tr382 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto tr382 + } + default: + goto tr382 + } + goto st0 + st322: + if p++; p == pe { + goto _test_eof322 + } + st_case_322: + if data[p] == 59 { + goto st323 + } + goto st0 + st323: + if p++; p == pe { + goto _test_eof323 + } + st_case_323: + if data[p] == 10 { + goto tr398 + } + goto st0 +tr71: +// line 84 "parseqt.rl" + + m0 = p +// line 107 "parseqt.rl" + + m0 = p + goto st324 + st324: + if p++; p == pe { + goto _test_eof324 + } + st_case_324: +// line 10270 "parseqt.go" + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 114: + goto st325 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st325: + if p++; p == pe { + goto _test_eof325 + } + st_case_325: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 105: + goto st326 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st326: + if p++; p == pe { + goto _test_eof326 + } + st_case_326: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 101: + goto st327 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st327: + if p++; p == pe { + goto _test_eof327 + } + st_case_327: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 110: + goto st328 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st328: + if p++; p == pe { + goto _test_eof328 + } + st_case_328: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 100: + goto st329 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st329: + if p++; p == pe { + goto _test_eof329 + } + st_case_329: + switch data[p] { + case 9: + goto tr404 + case 32: + goto tr404 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 +tr404: +// line 107 "parseqt.rl" + + m1 = p; m4 = 0 + goto st330 + st330: + if p++; p == pe { + goto _test_eof330 + } + st_case_330: +// line 10478 "parseqt.go" + switch data[p] { + case 9: + goto st330 + case 32: + goto st330 + case 42: + goto tr87 + case 95: + goto st65 + case 99: + goto st331 + case 103: + goto tr90 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st331: + if p++; p == pe { + goto _test_eof331 + } + st_case_331: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 108: + goto st332 + case 111: + goto st135 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st332: + if p++; p == pe { + goto _test_eof332 + } + st_case_332: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 97: + goto st333 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 98 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st333: + if p++; p == pe { + goto _test_eof333 + } + st_case_333: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 115: + goto st334 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st334: + if p++; p == pe { + goto _test_eof334 + } + st_case_334: + switch data[p] { + case 9: + goto st66 + case 32: + goto st66 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 115: + goto st335 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st335: + if p++; p == pe { + goto _test_eof335 + } + st_case_335: + switch data[p] { + case 9: + goto st336 + case 32: + goto st336 + case 40: + goto st75 + case 59: + goto st67 + case 95: + goto st65 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st336: + if p++; p == pe { + goto _test_eof336 + } + st_case_336: + switch data[p] { + case 9: + goto st336 + case 32: + goto st336 + case 59: + goto st67 + case 95: + goto st337 + case 99: + goto st340 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st337 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st337 + } + default: + goto st337 + } + goto st0 + st337: + if p++; p == pe { + goto _test_eof337 + } + st_case_337: + switch data[p] { + case 9: + goto st338 + case 32: + goto st338 + case 59: + goto st339 + case 95: + goto st337 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st337 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st337 + } + default: + goto st337 + } + goto st0 + st338: + if p++; p == pe { + goto _test_eof338 + } + st_case_338: + switch data[p] { + case 9: + goto st338 + case 32: + goto st338 + case 59: + goto st339 + } + goto st0 + st339: + if p++; p == pe { + goto _test_eof339 + } + st_case_339: + switch data[p] { + case 9: + goto st339 + case 10: + goto tr416 + case 32: + goto st339 + } + goto st0 + st340: + if p++; p == pe { + goto _test_eof340 + } + st_case_340: + switch data[p] { + case 9: + goto st338 + case 32: + goto st338 + case 59: + goto st339 + case 95: + goto st337 + case 111: + goto st341 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st337 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st337 + } + default: + goto st337 + } + goto st0 + st341: + if p++; p == pe { + goto _test_eof341 + } + st_case_341: + switch data[p] { + case 9: + goto st338 + case 32: + goto st338 + case 59: + goto st339 + case 95: + goto st337 + case 110: + goto st342 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st337 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st337 + } + default: + goto st337 + } + goto st0 + st342: + if p++; p == pe { + goto _test_eof342 + } + st_case_342: + switch data[p] { + case 9: + goto st338 + case 32: + goto st338 + case 59: + goto st339 + case 95: + goto st337 + case 115: + goto st343 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st337 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st337 + } + default: + goto st337 + } + goto st0 + st343: + if p++; p == pe { + goto _test_eof343 + } + st_case_343: + switch data[p] { + case 9: + goto st338 + case 32: + goto st338 + case 59: + goto st339 + case 95: + goto st337 + case 116: + goto st344 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st337 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st337 + } + default: + goto st337 + } + goto st0 + st344: + if p++; p == pe { + goto _test_eof344 + } + st_case_344: + switch data[p] { + case 9: + goto st345 + case 32: + goto st345 + case 59: + goto st346 + case 95: + goto st337 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st337 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st337 + } + default: + goto st337 + } + goto st0 + st345: + if p++; p == pe { + goto _test_eof345 + } + st_case_345: + switch data[p] { + case 9: + goto st345 + case 32: + goto st345 + case 59: + goto st346 + case 123: + goto st73 + } + goto st0 + st346: + if p++; p == pe { + goto _test_eof346 + } + st_case_346: + switch data[p] { + case 9: + goto st346 + case 10: + goto tr416 + case 32: + goto st346 + } + goto st0 +tr72: +// line 84 "parseqt.rl" + + m0 = p +// line 107 "parseqt.rl" + + m0 = p + goto st347 + st347: + if p++; p == pe { + goto _test_eof347 + } + st_case_347: +// line 10957 "parseqt.go" + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 114: + goto st348 + case 117: + goto st362 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st348: + if p++; p == pe { + goto _test_eof348 + } + st_case_348: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 105: + goto st349 + case 111: + goto st356 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st349: + if p++; p == pe { + goto _test_eof349 + } + st_case_349: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 118: + goto st350 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st350: + if p++; p == pe { + goto _test_eof350 + } + st_case_350: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 97: + goto st351 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 98 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st351: + if p++; p == pe { + goto _test_eof351 + } + st_case_351: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 116: + goto st352 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st352: + if p++; p == pe { + goto _test_eof352 + } + st_case_352: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 101: + goto st353 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st353: + if p++; p == pe { + goto _test_eof353 + } + st_case_353: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st354 + case 95: + goto st62 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st354: + if p++; p == pe { + goto _test_eof354 + } + st_case_354: + switch data[p] { + case 9: + goto st355 + case 10: + goto tr433 + case 32: + goto st355 + case 42: + goto tr252 + case 95: + goto st188 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 58 { + goto st188 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st188 + } + default: + goto st188 + } + goto st0 + st355: + if p++; p == pe { + goto _test_eof355 + } + st_case_355: + switch data[p] { + case 9: + goto st355 + case 10: + goto tr433 + case 32: + goto st355 + case 42: + goto tr252 + case 95: + goto st65 + case 99: + goto st193 + case 103: + goto st191 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st356: + if p++; p == pe { + goto _test_eof356 + } + st_case_356: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 116: + goto st357 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st357: + if p++; p == pe { + goto _test_eof357 + } + st_case_357: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 101: + goto st358 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st358: + if p++; p == pe { + goto _test_eof358 + } + st_case_358: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 99: + goto st359 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st359: + if p++; p == pe { + goto _test_eof359 + } + st_case_359: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 116: + goto st360 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st360: + if p++; p == pe { + goto _test_eof360 + } + st_case_360: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 101: + goto st361 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st361: + if p++; p == pe { + goto _test_eof361 + } + st_case_361: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 100: + goto st353 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st362: + if p++; p == pe { + goto _test_eof362 + } + st_case_362: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 98: + goto st363 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st363: + if p++; p == pe { + goto _test_eof363 + } + st_case_363: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 108: + goto st364 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st364: + if p++; p == pe { + goto _test_eof364 + } + st_case_364: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 105: + goto st365 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st365: + if p++; p == pe { + goto _test_eof365 + } + st_case_365: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 99: + goto st366 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st366: + if p++; p == pe { + goto _test_eof366 + } + st_case_366: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st367 + case 95: + goto st62 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st367: + if p++; p == pe { + goto _test_eof367 + } + st_case_367: + switch data[p] { + case 9: + goto st368 + case 10: + goto tr445 + case 32: + goto st368 + case 42: + goto tr252 + case 95: + goto st188 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 58 { + goto st188 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st188 + } + default: + goto st188 + } + goto st0 + st368: + if p++; p == pe { + goto _test_eof368 + } + st_case_368: + switch data[p] { + case 9: + goto st368 + case 10: + goto tr445 + case 32: + goto st368 + case 42: + goto tr252 + case 95: + goto st65 + case 99: + goto st193 + case 103: + goto st191 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 +tr73: +// line 84 "parseqt.rl" + + m0 = p +// line 107 "parseqt.rl" + + m0 = p + goto st369 + st369: + if p++; p == pe { + goto _test_eof369 + } + st_case_369: +// line 11706 "parseqt.go" + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 116: + goto st370 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st370: + if p++; p == pe { + goto _test_eof370 + } + st_case_370: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 97: + goto st371 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 98 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st371: + if p++; p == pe { + goto _test_eof371 + } + st_case_371: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 116: + goto st372 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st372: + if p++; p == pe { + goto _test_eof372 + } + st_case_372: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 105: + goto st373 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st373: + if p++; p == pe { + goto _test_eof373 + } + st_case_373: + switch data[p] { + case 9: + goto tr82 + case 32: + goto tr82 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + case 99: + goto st374 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 + st374: + if p++; p == pe { + goto _test_eof374 + } + st_case_374: + switch data[p] { + case 9: + goto tr451 + case 32: + goto tr451 + case 40: + goto tr83 + case 42: + goto tr84 + case 58: + goto st188 + case 95: + goto st62 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st62 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st62 + } + default: + goto st62 + } + goto st0 +tr451: +// line 107 "parseqt.rl" + + m1 = p; m4 = 0 + goto st375 + st375: + if p++; p == pe { + goto _test_eof375 + } + st_case_375: +// line 11914 "parseqt.go" + switch data[p] { + case 9: + goto st375 + case 32: + goto st375 + case 42: + goto tr87 + case 58: + goto st188 + case 95: + goto st376 + case 99: + goto st377 + case 103: + goto tr455 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st376 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st376 + } + default: + goto st376 + } + goto st0 + st376: + if p++; p == pe { + goto _test_eof376 + } + st_case_376: + switch data[p] { + case 9: + goto st198 + case 32: + goto st198 + case 40: + goto st75 + case 42: + goto tr252 + case 58: + goto st188 + case 59: + goto st67 + case 95: + goto st376 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st376 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st376 + } + default: + goto st376 + } + goto st0 + st377: + if p++; p == pe { + goto _test_eof377 + } + st_case_377: + switch data[p] { + case 9: + goto st198 + case 32: + goto st198 + case 40: + goto st75 + case 42: + goto tr252 + case 58: + goto st188 + case 59: + goto st67 + case 95: + goto st376 + case 111: + goto st378 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st376 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st376 + } + default: + goto st376 + } + goto st0 + st378: + if p++; p == pe { + goto _test_eof378 + } + st_case_378: + switch data[p] { + case 9: + goto st198 + case 32: + goto st198 + case 40: + goto st75 + case 42: + goto tr252 + case 58: + goto st188 + case 59: + goto st67 + case 95: + goto st376 + case 110: + goto st379 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st376 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st376 + } + default: + goto st376 + } + goto st0 + st379: + if p++; p == pe { + goto _test_eof379 + } + st_case_379: + switch data[p] { + case 9: + goto st198 + case 32: + goto st198 + case 40: + goto st75 + case 42: + goto tr252 + case 58: + goto st188 + case 59: + goto st67 + case 95: + goto st376 + case 115: + goto st380 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st376 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st376 + } + default: + goto st376 + } + goto st0 + st380: + if p++; p == pe { + goto _test_eof380 + } + st_case_380: + switch data[p] { + case 9: + goto st198 + case 32: + goto st198 + case 40: + goto st75 + case 42: + goto tr252 + case 58: + goto st188 + case 59: + goto st67 + case 95: + goto st376 + case 116: + goto st381 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st376 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st376 + } + default: + goto st376 + } + goto st0 + st381: + if p++; p == pe { + goto _test_eof381 + } + st_case_381: + switch data[p] { + case 9: + goto st382 + case 32: + goto st382 + case 40: + goto st75 + case 42: + goto tr87 + case 58: + goto st188 + case 59: + goto st67 + case 95: + goto st376 + case 103: + goto tr461 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st376 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st376 + } + default: + goto st376 + } + goto st0 + st382: + if p++; p == pe { + goto _test_eof382 + } + st_case_382: + switch data[p] { + case 9: + goto st382 + case 32: + goto st382 + case 42: + goto tr87 + case 58: + goto st188 + case 59: + goto st67 + case 95: + goto st376 + case 99: + goto st383 + case 103: + goto tr455 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st376 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st376 + } + default: + goto st376 + } + goto st0 + st383: + if p++; p == pe { + goto _test_eof383 + } + st_case_383: + switch data[p] { + case 9: + goto st198 + case 32: + goto st198 + case 40: + goto st75 + case 42: + goto tr252 + case 58: + goto st188 + case 59: + goto st67 + case 95: + goto st376 + case 111: + goto st384 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st376 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st376 + } + default: + goto st376 + } + goto st0 + st384: + if p++; p == pe { + goto _test_eof384 + } + st_case_384: + switch data[p] { + case 9: + goto st198 + case 32: + goto st198 + case 40: + goto st75 + case 42: + goto tr252 + case 58: + goto st188 + case 59: + goto st67 + case 95: + goto st376 + case 110: + goto st385 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st376 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st376 + } + default: + goto st376 + } + goto st0 + st385: + if p++; p == pe { + goto _test_eof385 + } + st_case_385: + switch data[p] { + case 9: + goto st198 + case 32: + goto st198 + case 40: + goto st75 + case 42: + goto tr252 + case 58: + goto st188 + case 59: + goto st67 + case 95: + goto st376 + case 115: + goto st386 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st376 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st376 + } + default: + goto st376 + } + goto st0 + st386: + if p++; p == pe { + goto _test_eof386 + } + st_case_386: + switch data[p] { + case 9: + goto st198 + case 32: + goto st198 + case 40: + goto st75 + case 42: + goto tr252 + case 58: + goto st188 + case 59: + goto st67 + case 95: + goto st376 + case 116: + goto st387 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st376 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st376 + } + default: + goto st376 + } + goto st0 + st387: + if p++; p == pe { + goto _test_eof387 + } + st_case_387: + switch data[p] { + case 9: + goto st139 + case 32: + goto st139 + case 40: + goto st75 + case 42: + goto tr87 + case 58: + goto st188 + case 59: + goto st67 + case 95: + goto st376 + case 103: + goto tr461 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st376 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st376 + } + default: + goto st376 + } + goto st0 +tr461: +// line 109 "parseqt.rl" + + m2 = p + goto st388 + st388: + if p++; p == pe { + goto _test_eof388 + } + st_case_388: +// line 12408 "parseqt.go" + switch data[p] { + case 9: + goto st198 + case 32: + goto st198 + case 40: + goto st75 + case 42: + goto tr252 + case 58: + goto st188 + case 59: + goto st67 + case 95: + goto st376 + case 108: + goto st389 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st376 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st376 + } + default: + goto st376 + } + goto st0 + st389: + if p++; p == pe { + goto _test_eof389 + } + st_case_389: + switch data[p] { + case 9: + goto st198 + case 32: + goto st198 + case 40: + goto st75 + case 42: + goto tr252 + case 58: + goto st188 + case 59: + goto st67 + case 95: + goto st390 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st390 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st390 + } + default: + goto st390 + } + goto st0 + st390: + if p++; p == pe { + goto _test_eof390 + } + st_case_390: + switch data[p] { + case 9: + goto tr469 + case 32: + goto tr469 + case 40: + goto tr187 + case 42: + goto tr252 + case 58: + goto st188 + case 59: + goto st67 + case 95: + goto st390 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st390 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st390 + } + default: + goto st390 + } + goto st0 +tr469: +// line 109 "parseqt.rl" + + m3 = p; f = Func{Name: data[m2:m3], Type: data[m0:m1], Addr: m4} + goto st391 + st391: + if p++; p == pe { + goto _test_eof391 + } + st_case_391: +// line 12524 "parseqt.go" + switch data[p] { + case 9: + goto st391 + case 32: + goto st391 + case 40: + goto tr124 + case 42: + goto tr252 + case 59: + goto st67 + case 95: + goto st65 + case 99: + goto st193 + case 103: + goto st191 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 +tr455: +// line 109 "parseqt.rl" + + m2 = p + goto st392 + st392: + if p++; p == pe { + goto _test_eof392 + } + st_case_392: +// line 12568 "parseqt.go" + switch data[p] { + case 9: + goto st198 + case 32: + goto st198 + case 40: + goto st75 + case 42: + goto tr252 + case 58: + goto st188 + case 59: + goto st67 + case 95: + goto st376 + case 108: + goto st393 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st376 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st376 + } + default: + goto st376 + } + goto st0 + st393: + if p++; p == pe { + goto _test_eof393 + } + st_case_393: + switch data[p] { + case 9: + goto st198 + case 32: + goto st198 + case 40: + goto st75 + case 42: + goto tr252 + case 58: + goto st188 + case 59: + goto st67 + case 95: + goto st394 + case 99: + goto st396 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st394 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st394 + } + default: + goto st394 + } + goto st0 + st394: + if p++; p == pe { + goto _test_eof394 + } + st_case_394: + switch data[p] { + case 9: + goto tr474 + case 32: + goto tr474 + case 40: + goto tr122 + case 42: + goto tr252 + case 58: + goto st188 + case 95: + goto st394 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st394 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st394 + } + default: + goto st394 + } + goto st0 +tr474: +// line 109 "parseqt.rl" + + m3 = p; f = Func{Name: data[m2:m3], Type: data[m0:m1], Addr: m4} + goto st395 + st395: + if p++; p == pe { + goto _test_eof395 + } + st_case_395: +// line 12682 "parseqt.go" + switch data[p] { + case 9: + goto st395 + case 32: + goto st395 + case 40: + goto tr124 + case 42: + goto tr252 + case 95: + goto st65 + case 99: + goto st193 + case 103: + goto st191 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st65 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st65 + } + default: + goto st65 + } + goto st0 + st396: + if p++; p == pe { + goto _test_eof396 + } + st_case_396: + switch data[p] { + case 9: + goto tr474 + case 32: + goto tr474 + case 40: + goto tr122 + case 42: + goto tr252 + case 58: + goto st188 + case 95: + goto st394 + case 111: + goto st397 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st394 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st394 + } + default: + goto st394 + } + goto st0 + st397: + if p++; p == pe { + goto _test_eof397 + } + st_case_397: + switch data[p] { + case 9: + goto tr474 + case 32: + goto tr474 + case 40: + goto tr122 + case 42: + goto tr252 + case 58: + goto st188 + case 95: + goto st394 + case 110: + goto st398 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st394 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st394 + } + default: + goto st394 + } + goto st0 + st398: + if p++; p == pe { + goto _test_eof398 + } + st_case_398: + switch data[p] { + case 9: + goto tr474 + case 32: + goto tr474 + case 40: + goto tr122 + case 42: + goto tr252 + case 58: + goto st188 + case 95: + goto st394 + case 115: + goto st399 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st394 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st394 + } + default: + goto st394 + } + goto st0 + st399: + if p++; p == pe { + goto _test_eof399 + } + st_case_399: + switch data[p] { + case 9: + goto tr474 + case 32: + goto tr474 + case 40: + goto tr122 + case 42: + goto tr252 + case 58: + goto st188 + case 95: + goto st394 + case 116: + goto st400 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st394 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st394 + } + default: + goto st394 + } + goto st0 + st400: + if p++; p == pe { + goto _test_eof400 + } + st_case_400: + switch data[p] { + case 9: + goto tr469 + case 32: + goto tr469 + case 40: + goto tr122 + case 42: + goto tr252 + case 58: + goto st188 + case 59: + goto st67 + case 95: + goto st394 + case 123: + goto st73 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st394 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st394 + } + default: + goto st394 + } + goto st0 + st401: + if p++; p == pe { + goto _test_eof401 + } + st_case_401: + switch data[p] { + case 9: + goto st401 + case 32: + goto st401 + case 59: + goto st402 + } + goto st0 + st402: + if p++; p == pe { + goto _test_eof402 + } + st_case_402: + if data[p] == 10 { + goto tr481 + } + goto st0 + st403: + if p++; p == pe { + goto _test_eof403 + } + st_case_403: + if data[p] == 95 { + goto tr482 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto tr482 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto tr482 + } + default: + goto tr482 + } + goto st0 +tr482: +// line 84 "parseqt.rl" + + m0 = p + goto st404 + st404: + if p++; p == pe { + goto _test_eof404 + } + st_case_404: +// line 12938 "parseqt.go" + switch data[p] { + case 40: + goto tr83 + case 95: + goto st404 + } + switch { + case data[p] < 65: + if 48 <= data[p] && data[p] <= 57 { + goto st404 + } + case data[p] > 90: + if 97 <= data[p] && data[p] <= 122 { + goto st404 + } + default: + goto st404 + } + goto st0 + st405: + if p++; p == pe { + goto _test_eof405 + } + st_case_405: + if data[p] == 105 { + goto st406 + } + goto st0 + st406: + if p++; p == pe { + goto _test_eof406 + } + st_case_406: + if data[p] == 102 { + goto st407 + } + goto st0 + st407: + if p++; p == pe { + goto _test_eof407 + } + st_case_407: + if data[p] == 32 { + goto st408 + } + goto st0 + st408: + if p++; p == pe { + goto _test_eof408 + } + st_case_408: + if data[p] == 81 { + goto st409 + } + goto st0 + st409: + if p++; p == pe { + goto _test_eof409 + } + st_case_409: + if data[p] == 84 { + goto st410 + } + goto st0 + st410: + if p++; p == pe { + goto _test_eof410 + } + st_case_410: + if data[p] == 95 { + goto st411 + } + goto st0 + st411: + if p++; p == pe { + goto _test_eof411 + } + st_case_411: + if data[p] == 68 { + goto st412 + } + goto st0 + st412: + if p++; p == pe { + goto _test_eof412 + } + st_case_412: + if data[p] == 69 { + goto st413 + } + goto st0 + st413: + if p++; p == pe { + goto _test_eof413 + } + st_case_413: + if data[p] == 80 { + goto st414 + } + goto st0 + st414: + if p++; p == pe { + goto _test_eof414 + } + st_case_414: + if data[p] == 82 { + goto st415 + } + goto st0 + st415: + if p++; p == pe { + goto _test_eof415 + } + st_case_415: + if data[p] == 69 { + goto st416 + } + goto st0 + st416: + if p++; p == pe { + goto _test_eof416 + } + st_case_416: + if data[p] == 67 { + goto st417 + } + goto st0 + st417: + if p++; p == pe { + goto _test_eof417 + } + st_case_417: + if data[p] == 65 { + goto st418 + } + goto st0 + st418: + if p++; p == pe { + goto _test_eof418 + } + st_case_418: + if data[p] == 84 { + goto st419 + } + goto st0 + st419: + if p++; p == pe { + goto _test_eof419 + } + st_case_419: + if data[p] == 69 { + goto st420 + } + goto st0 + st420: + if p++; p == pe { + goto _test_eof420 + } + st_case_420: + if data[p] == 68 { + goto st421 + } + goto st0 + st421: + if p++; p == pe { + goto _test_eof421 + } + st_case_421: + if data[p] == 95 { + goto st422 + } + goto st0 + st422: + if p++; p == pe { + goto _test_eof422 + } + st_case_422: + if data[p] == 83 { + goto st423 + } + goto st0 + st423: + if p++; p == pe { + goto _test_eof423 + } + st_case_423: + if data[p] == 73 { + goto st424 + } + goto st0 + st424: + if p++; p == pe { + goto _test_eof424 + } + st_case_424: + if data[p] == 78 { + goto st425 + } + goto st0 + st425: + if p++; p == pe { + goto _test_eof425 + } + st_case_425: + if data[p] == 67 { + goto st426 + } + goto st0 + st426: + if p++; p == pe { + goto _test_eof426 + } + st_case_426: + if data[p] == 69 { + goto st427 + } + goto st0 + st427: + if p++; p == pe { + goto _test_eof427 + } + st_case_427: + if data[p] == 40 { + goto st428 + } + goto st0 + st428: + if p++; p == pe { + goto _test_eof428 + } + st_case_428: + if data[p] == 10 { + goto st0 + } + goto st429 + st429: + if p++; p == pe { + goto _test_eof429 + } + st_case_429: + switch data[p] { + case 10: + goto st0 + case 41: + goto st430 + } + goto st429 + st430: + if p++; p == pe { + goto _test_eof430 + } + st_case_430: + switch data[p] { + case 9: + goto st430 + case 10: + goto tr509 + case 32: + goto st430 + case 41: + goto st430 + } + goto st429 +tr509: +// line 47 "parseqt.rl" + + curline++ + goto st431 + st431: + if p++; p == pe { + goto _test_eof431 + } + st_case_431: +// line 13212 "parseqt.go" + switch data[p] { + case 10: + goto tr511 + case 35: + goto st440 + } + goto st432 + st432: + if p++; p == pe { + goto _test_eof432 + } + st_case_432: + if data[p] == 10 { + goto tr511 + } + goto st432 +tr511: +// line 47 "parseqt.rl" + + curline++ + goto st433 + st433: + if p++; p == pe { + goto _test_eof433 + } + st_case_433: +// line 13239 "parseqt.go" + if data[p] == 35 { + goto st434 + } + goto st0 + st434: + if p++; p == pe { + goto _test_eof434 + } + st_case_434: + if data[p] == 101 { + goto st435 + } + goto st0 + st435: + if p++; p == pe { + goto _test_eof435 + } + st_case_435: + if data[p] == 110 { + goto st436 + } + goto st0 + st436: + if p++; p == pe { + goto _test_eof436 + } + st_case_436: + if data[p] == 100 { + goto st437 + } + goto st0 + st437: + if p++; p == pe { + goto _test_eof437 + } + st_case_437: + if data[p] == 105 { + goto st438 + } + goto st0 + st438: + if p++; p == pe { + goto _test_eof438 + } + st_case_438: + if data[p] == 102 { + goto st439 + } + goto st0 + st439: + if p++; p == pe { + goto _test_eof439 + } + st_case_439: + switch data[p] { + case 9: + goto st439 + case 10: + goto tr519 + case 32: + goto st439 + } + goto st0 + st440: + if p++; p == pe { + goto _test_eof440 + } + st_case_440: + switch data[p] { + case 10: + goto tr511 + case 101: + goto st441 + } + goto st432 + st441: + if p++; p == pe { + goto _test_eof441 + } + st_case_441: + switch data[p] { + case 10: + goto tr511 + case 110: + goto st442 + } + goto st432 + st442: + if p++; p == pe { + goto _test_eof442 + } + st_case_442: + switch data[p] { + case 10: + goto tr511 + case 100: + goto st443 + } + goto st432 + st443: + if p++; p == pe { + goto _test_eof443 + } + st_case_443: + switch data[p] { + case 10: + goto tr511 + case 105: + goto st444 + } + goto st432 + st444: + if p++; p == pe { + goto _test_eof444 + } + st_case_444: + switch data[p] { + case 10: + goto tr511 + case 102: + goto st445 + } + goto st432 + st445: + if p++; p == pe { + goto _test_eof445 + } + st_case_445: + if data[p] == 10 { + goto st0 + } + goto st432 + st_out: + _test_eof447: cs = 447; goto _test_eof + _test_eof1: cs = 1; goto _test_eof + _test_eof2: cs = 2; goto _test_eof + _test_eof3: cs = 3; goto _test_eof + _test_eof4: cs = 4; goto _test_eof + _test_eof5: cs = 5; goto _test_eof + _test_eof6: cs = 6; goto _test_eof + _test_eof7: cs = 7; goto _test_eof + _test_eof8: cs = 8; goto _test_eof + _test_eof9: cs = 9; goto _test_eof + _test_eof10: cs = 10; goto _test_eof + _test_eof11: cs = 11; goto _test_eof + _test_eof12: cs = 12; goto _test_eof + _test_eof13: cs = 13; goto _test_eof + _test_eof14: cs = 14; goto _test_eof + _test_eof15: cs = 15; goto _test_eof + _test_eof16: cs = 16; goto _test_eof + _test_eof17: cs = 17; goto _test_eof + _test_eof18: cs = 18; goto _test_eof + _test_eof19: cs = 19; goto _test_eof + _test_eof20: cs = 20; goto _test_eof + _test_eof21: cs = 21; goto _test_eof + _test_eof448: cs = 448; goto _test_eof + _test_eof22: cs = 22; goto _test_eof + _test_eof23: cs = 23; goto _test_eof + _test_eof24: cs = 24; goto _test_eof + _test_eof25: cs = 25; goto _test_eof + _test_eof26: cs = 26; goto _test_eof + _test_eof27: cs = 27; goto _test_eof + _test_eof28: cs = 28; goto _test_eof + _test_eof29: cs = 29; goto _test_eof + _test_eof30: cs = 30; goto _test_eof + _test_eof31: cs = 31; goto _test_eof + _test_eof32: cs = 32; goto _test_eof + _test_eof33: cs = 33; goto _test_eof + _test_eof34: cs = 34; goto _test_eof + _test_eof35: cs = 35; goto _test_eof + _test_eof36: cs = 36; goto _test_eof + _test_eof37: cs = 37; goto _test_eof + _test_eof38: cs = 38; goto _test_eof + _test_eof39: cs = 39; goto _test_eof + _test_eof40: cs = 40; goto _test_eof + _test_eof41: cs = 41; goto _test_eof + _test_eof42: cs = 42; goto _test_eof + _test_eof43: cs = 43; goto _test_eof + _test_eof44: cs = 44; goto _test_eof + _test_eof45: cs = 45; goto _test_eof + _test_eof46: cs = 46; goto _test_eof + _test_eof47: cs = 47; goto _test_eof + _test_eof48: cs = 48; goto _test_eof + _test_eof49: cs = 49; goto _test_eof + _test_eof50: cs = 50; goto _test_eof + _test_eof51: cs = 51; goto _test_eof + _test_eof52: cs = 52; goto _test_eof + _test_eof53: cs = 53; goto _test_eof + _test_eof54: cs = 54; goto _test_eof + _test_eof55: cs = 55; goto _test_eof + _test_eof56: cs = 56; goto _test_eof + _test_eof449: cs = 449; goto _test_eof + _test_eof57: cs = 57; goto _test_eof + _test_eof446: cs = 446; goto _test_eof + _test_eof453: cs = 453; goto _test_eof + _test_eof454: cs = 454; goto _test_eof + _test_eof450: cs = 450; goto _test_eof + _test_eof58: cs = 58; goto _test_eof + _test_eof59: cs = 59; goto _test_eof + _test_eof60: cs = 60; goto _test_eof + _test_eof61: cs = 61; goto _test_eof + _test_eof62: cs = 62; goto _test_eof + _test_eof63: cs = 63; goto _test_eof + _test_eof64: cs = 64; goto _test_eof + _test_eof65: cs = 65; goto _test_eof + _test_eof66: cs = 66; goto _test_eof + _test_eof67: cs = 67; goto _test_eof + _test_eof68: cs = 68; goto _test_eof + _test_eof69: cs = 69; goto _test_eof + _test_eof70: cs = 70; goto _test_eof + _test_eof71: cs = 71; goto _test_eof + _test_eof72: cs = 72; goto _test_eof + _test_eof73: cs = 73; goto _test_eof + _test_eof74: cs = 74; goto _test_eof + _test_eof75: cs = 75; goto _test_eof + _test_eof76: cs = 76; goto _test_eof + _test_eof77: cs = 77; goto _test_eof + _test_eof78: cs = 78; goto _test_eof + _test_eof79: cs = 79; goto _test_eof + _test_eof80: cs = 80; goto _test_eof + _test_eof81: cs = 81; goto _test_eof + _test_eof82: cs = 82; goto _test_eof + _test_eof83: cs = 83; goto _test_eof + _test_eof84: cs = 84; goto _test_eof + _test_eof85: cs = 85; goto _test_eof + _test_eof86: cs = 86; goto _test_eof + _test_eof87: cs = 87; goto _test_eof + _test_eof88: cs = 88; goto _test_eof + _test_eof89: cs = 89; goto _test_eof + _test_eof90: cs = 90; goto _test_eof + _test_eof91: cs = 91; goto _test_eof + _test_eof92: cs = 92; goto _test_eof + _test_eof93: cs = 93; goto _test_eof + _test_eof94: cs = 94; goto _test_eof + _test_eof95: cs = 95; goto _test_eof + _test_eof96: cs = 96; goto _test_eof + _test_eof97: cs = 97; goto _test_eof + _test_eof98: cs = 98; goto _test_eof + _test_eof99: cs = 99; goto _test_eof + _test_eof100: cs = 100; goto _test_eof + _test_eof101: cs = 101; goto _test_eof + _test_eof102: cs = 102; goto _test_eof + _test_eof103: cs = 103; goto _test_eof + _test_eof104: cs = 104; goto _test_eof + _test_eof105: cs = 105; goto _test_eof + _test_eof106: cs = 106; goto _test_eof + _test_eof107: cs = 107; goto _test_eof + _test_eof108: cs = 108; goto _test_eof + _test_eof109: cs = 109; goto _test_eof + _test_eof110: cs = 110; goto _test_eof + _test_eof111: cs = 111; goto _test_eof + _test_eof112: cs = 112; goto _test_eof + _test_eof113: cs = 113; goto _test_eof + _test_eof114: cs = 114; goto _test_eof + _test_eof115: cs = 115; goto _test_eof + _test_eof116: cs = 116; goto _test_eof + _test_eof117: cs = 117; goto _test_eof + _test_eof118: cs = 118; goto _test_eof + _test_eof119: cs = 119; goto _test_eof + _test_eof120: cs = 120; goto _test_eof + _test_eof121: cs = 121; goto _test_eof + _test_eof122: cs = 122; goto _test_eof + _test_eof123: cs = 123; goto _test_eof + _test_eof124: cs = 124; goto _test_eof + _test_eof125: cs = 125; goto _test_eof + _test_eof126: cs = 126; goto _test_eof + _test_eof127: cs = 127; goto _test_eof + _test_eof128: cs = 128; goto _test_eof + _test_eof129: cs = 129; goto _test_eof + _test_eof130: cs = 130; goto _test_eof + _test_eof131: cs = 131; goto _test_eof + _test_eof132: cs = 132; goto _test_eof + _test_eof133: cs = 133; goto _test_eof + _test_eof134: cs = 134; goto _test_eof + _test_eof135: cs = 135; goto _test_eof + _test_eof136: cs = 136; goto _test_eof + _test_eof137: cs = 137; goto _test_eof + _test_eof138: cs = 138; goto _test_eof + _test_eof139: cs = 139; goto _test_eof + _test_eof140: cs = 140; goto _test_eof + _test_eof141: cs = 141; goto _test_eof + _test_eof142: cs = 142; goto _test_eof + _test_eof143: cs = 143; goto _test_eof + _test_eof144: cs = 144; goto _test_eof + _test_eof145: cs = 145; goto _test_eof + _test_eof451: cs = 451; goto _test_eof + _test_eof146: cs = 146; goto _test_eof + _test_eof147: cs = 147; goto _test_eof + _test_eof148: cs = 148; goto _test_eof + _test_eof149: cs = 149; goto _test_eof + _test_eof150: cs = 150; goto _test_eof + _test_eof151: cs = 151; goto _test_eof + _test_eof152: cs = 152; goto _test_eof + _test_eof153: cs = 153; goto _test_eof + _test_eof154: cs = 154; goto _test_eof + _test_eof155: cs = 155; goto _test_eof + _test_eof156: cs = 156; goto _test_eof + _test_eof157: cs = 157; goto _test_eof + _test_eof158: cs = 158; goto _test_eof + _test_eof159: cs = 159; goto _test_eof + _test_eof160: cs = 160; goto _test_eof + _test_eof452: cs = 452; goto _test_eof + _test_eof161: cs = 161; goto _test_eof + _test_eof162: cs = 162; goto _test_eof + _test_eof163: cs = 163; goto _test_eof + _test_eof164: cs = 164; goto _test_eof + _test_eof165: cs = 165; goto _test_eof + _test_eof166: cs = 166; goto _test_eof + _test_eof167: cs = 167; goto _test_eof + _test_eof168: cs = 168; goto _test_eof + _test_eof169: cs = 169; goto _test_eof + _test_eof170: cs = 170; goto _test_eof + _test_eof171: cs = 171; goto _test_eof + _test_eof172: cs = 172; goto _test_eof + _test_eof173: cs = 173; goto _test_eof + _test_eof174: cs = 174; goto _test_eof + _test_eof175: cs = 175; goto _test_eof + _test_eof176: cs = 176; goto _test_eof + _test_eof177: cs = 177; goto _test_eof + _test_eof178: cs = 178; goto _test_eof + _test_eof179: cs = 179; goto _test_eof + _test_eof180: cs = 180; goto _test_eof + _test_eof181: cs = 181; goto _test_eof + _test_eof182: cs = 182; goto _test_eof + _test_eof183: cs = 183; goto _test_eof + _test_eof184: cs = 184; goto _test_eof + _test_eof185: cs = 185; goto _test_eof + _test_eof186: cs = 186; goto _test_eof + _test_eof187: cs = 187; goto _test_eof + _test_eof188: cs = 188; goto _test_eof + _test_eof189: cs = 189; goto _test_eof + _test_eof190: cs = 190; goto _test_eof + _test_eof191: cs = 191; goto _test_eof + _test_eof192: cs = 192; goto _test_eof + _test_eof193: cs = 193; goto _test_eof + _test_eof194: cs = 194; goto _test_eof + _test_eof195: cs = 195; goto _test_eof + _test_eof196: cs = 196; goto _test_eof + _test_eof197: cs = 197; goto _test_eof + _test_eof198: cs = 198; goto _test_eof + _test_eof199: cs = 199; goto _test_eof + _test_eof200: cs = 200; goto _test_eof + _test_eof201: cs = 201; goto _test_eof + _test_eof202: cs = 202; goto _test_eof + _test_eof203: cs = 203; goto _test_eof + _test_eof204: cs = 204; goto _test_eof + _test_eof205: cs = 205; goto _test_eof + _test_eof206: cs = 206; goto _test_eof + _test_eof207: cs = 207; goto _test_eof + _test_eof208: cs = 208; goto _test_eof + _test_eof209: cs = 209; goto _test_eof + _test_eof210: cs = 210; goto _test_eof + _test_eof211: cs = 211; goto _test_eof + _test_eof212: cs = 212; goto _test_eof + _test_eof213: cs = 213; goto _test_eof + _test_eof214: cs = 214; goto _test_eof + _test_eof215: cs = 215; goto _test_eof + _test_eof216: cs = 216; goto _test_eof + _test_eof217: cs = 217; goto _test_eof + _test_eof218: cs = 218; goto _test_eof + _test_eof219: cs = 219; goto _test_eof + _test_eof220: cs = 220; goto _test_eof + _test_eof221: cs = 221; goto _test_eof + _test_eof222: cs = 222; goto _test_eof + _test_eof223: cs = 223; goto _test_eof + _test_eof224: cs = 224; goto _test_eof + _test_eof225: cs = 225; goto _test_eof + _test_eof226: cs = 226; goto _test_eof + _test_eof227: cs = 227; goto _test_eof + _test_eof228: cs = 228; goto _test_eof + _test_eof229: cs = 229; goto _test_eof + _test_eof230: cs = 230; goto _test_eof + _test_eof231: cs = 231; goto _test_eof + _test_eof232: cs = 232; goto _test_eof + _test_eof233: cs = 233; goto _test_eof + _test_eof234: cs = 234; goto _test_eof + _test_eof235: cs = 235; goto _test_eof + _test_eof236: cs = 236; goto _test_eof + _test_eof237: cs = 237; goto _test_eof + _test_eof238: cs = 238; goto _test_eof + _test_eof239: cs = 239; goto _test_eof + _test_eof240: cs = 240; goto _test_eof + _test_eof241: cs = 241; goto _test_eof + _test_eof242: cs = 242; goto _test_eof + _test_eof243: cs = 243; goto _test_eof + _test_eof244: cs = 244; goto _test_eof + _test_eof245: cs = 245; goto _test_eof + _test_eof246: cs = 246; goto _test_eof + _test_eof247: cs = 247; goto _test_eof + _test_eof248: cs = 248; goto _test_eof + _test_eof249: cs = 249; goto _test_eof + _test_eof250: cs = 250; goto _test_eof + _test_eof251: cs = 251; goto _test_eof + _test_eof252: cs = 252; goto _test_eof + _test_eof253: cs = 253; goto _test_eof + _test_eof254: cs = 254; goto _test_eof + _test_eof255: cs = 255; goto _test_eof + _test_eof256: cs = 256; goto _test_eof + _test_eof257: cs = 257; goto _test_eof + _test_eof258: cs = 258; goto _test_eof + _test_eof259: cs = 259; goto _test_eof + _test_eof260: cs = 260; goto _test_eof + _test_eof261: cs = 261; goto _test_eof + _test_eof262: cs = 262; goto _test_eof + _test_eof263: cs = 263; goto _test_eof + _test_eof264: cs = 264; goto _test_eof + _test_eof265: cs = 265; goto _test_eof + _test_eof266: cs = 266; goto _test_eof + _test_eof267: cs = 267; goto _test_eof + _test_eof268: cs = 268; goto _test_eof + _test_eof269: cs = 269; goto _test_eof + _test_eof270: cs = 270; goto _test_eof + _test_eof271: cs = 271; goto _test_eof + _test_eof272: cs = 272; goto _test_eof + _test_eof273: cs = 273; goto _test_eof + _test_eof274: cs = 274; goto _test_eof + _test_eof275: cs = 275; goto _test_eof + _test_eof276: cs = 276; goto _test_eof + _test_eof277: cs = 277; goto _test_eof + _test_eof278: cs = 278; goto _test_eof + _test_eof279: cs = 279; goto _test_eof + _test_eof280: cs = 280; goto _test_eof + _test_eof281: cs = 281; goto _test_eof + _test_eof282: cs = 282; goto _test_eof + _test_eof283: cs = 283; goto _test_eof + _test_eof284: cs = 284; goto _test_eof + _test_eof285: cs = 285; goto _test_eof + _test_eof286: cs = 286; goto _test_eof + _test_eof287: cs = 287; goto _test_eof + _test_eof288: cs = 288; goto _test_eof + _test_eof289: cs = 289; goto _test_eof + _test_eof290: cs = 290; goto _test_eof + _test_eof291: cs = 291; goto _test_eof + _test_eof292: cs = 292; goto _test_eof + _test_eof293: cs = 293; goto _test_eof + _test_eof294: cs = 294; goto _test_eof + _test_eof295: cs = 295; goto _test_eof + _test_eof296: cs = 296; goto _test_eof + _test_eof297: cs = 297; goto _test_eof + _test_eof298: cs = 298; goto _test_eof + _test_eof299: cs = 299; goto _test_eof + _test_eof300: cs = 300; goto _test_eof + _test_eof301: cs = 301; goto _test_eof + _test_eof302: cs = 302; goto _test_eof + _test_eof303: cs = 303; goto _test_eof + _test_eof304: cs = 304; goto _test_eof + _test_eof305: cs = 305; goto _test_eof + _test_eof306: cs = 306; goto _test_eof + _test_eof307: cs = 307; goto _test_eof + _test_eof308: cs = 308; goto _test_eof + _test_eof309: cs = 309; goto _test_eof + _test_eof310: cs = 310; goto _test_eof + _test_eof311: cs = 311; goto _test_eof + _test_eof312: cs = 312; goto _test_eof + _test_eof313: cs = 313; goto _test_eof + _test_eof314: cs = 314; goto _test_eof + _test_eof315: cs = 315; goto _test_eof + _test_eof316: cs = 316; goto _test_eof + _test_eof317: cs = 317; goto _test_eof + _test_eof318: cs = 318; goto _test_eof + _test_eof319: cs = 319; goto _test_eof + _test_eof320: cs = 320; goto _test_eof + _test_eof321: cs = 321; goto _test_eof + _test_eof322: cs = 322; goto _test_eof + _test_eof323: cs = 323; goto _test_eof + _test_eof324: cs = 324; goto _test_eof + _test_eof325: cs = 325; goto _test_eof + _test_eof326: cs = 326; goto _test_eof + _test_eof327: cs = 327; goto _test_eof + _test_eof328: cs = 328; goto _test_eof + _test_eof329: cs = 329; goto _test_eof + _test_eof330: cs = 330; goto _test_eof + _test_eof331: cs = 331; goto _test_eof + _test_eof332: cs = 332; goto _test_eof + _test_eof333: cs = 333; goto _test_eof + _test_eof334: cs = 334; goto _test_eof + _test_eof335: cs = 335; goto _test_eof + _test_eof336: cs = 336; goto _test_eof + _test_eof337: cs = 337; goto _test_eof + _test_eof338: cs = 338; goto _test_eof + _test_eof339: cs = 339; goto _test_eof + _test_eof340: cs = 340; goto _test_eof + _test_eof341: cs = 341; goto _test_eof + _test_eof342: cs = 342; goto _test_eof + _test_eof343: cs = 343; goto _test_eof + _test_eof344: cs = 344; goto _test_eof + _test_eof345: cs = 345; goto _test_eof + _test_eof346: cs = 346; goto _test_eof + _test_eof347: cs = 347; goto _test_eof + _test_eof348: cs = 348; goto _test_eof + _test_eof349: cs = 349; goto _test_eof + _test_eof350: cs = 350; goto _test_eof + _test_eof351: cs = 351; goto _test_eof + _test_eof352: cs = 352; goto _test_eof + _test_eof353: cs = 353; goto _test_eof + _test_eof354: cs = 354; goto _test_eof + _test_eof355: cs = 355; goto _test_eof + _test_eof356: cs = 356; goto _test_eof + _test_eof357: cs = 357; goto _test_eof + _test_eof358: cs = 358; goto _test_eof + _test_eof359: cs = 359; goto _test_eof + _test_eof360: cs = 360; goto _test_eof + _test_eof361: cs = 361; goto _test_eof + _test_eof362: cs = 362; goto _test_eof + _test_eof363: cs = 363; goto _test_eof + _test_eof364: cs = 364; goto _test_eof + _test_eof365: cs = 365; goto _test_eof + _test_eof366: cs = 366; goto _test_eof + _test_eof367: cs = 367; goto _test_eof + _test_eof368: cs = 368; goto _test_eof + _test_eof369: cs = 369; goto _test_eof + _test_eof370: cs = 370; goto _test_eof + _test_eof371: cs = 371; goto _test_eof + _test_eof372: cs = 372; goto _test_eof + _test_eof373: cs = 373; goto _test_eof + _test_eof374: cs = 374; goto _test_eof + _test_eof375: cs = 375; goto _test_eof + _test_eof376: cs = 376; goto _test_eof + _test_eof377: cs = 377; goto _test_eof + _test_eof378: cs = 378; goto _test_eof + _test_eof379: cs = 379; goto _test_eof + _test_eof380: cs = 380; goto _test_eof + _test_eof381: cs = 381; goto _test_eof + _test_eof382: cs = 382; goto _test_eof + _test_eof383: cs = 383; goto _test_eof + _test_eof384: cs = 384; goto _test_eof + _test_eof385: cs = 385; goto _test_eof + _test_eof386: cs = 386; goto _test_eof + _test_eof387: cs = 387; goto _test_eof + _test_eof388: cs = 388; goto _test_eof + _test_eof389: cs = 389; goto _test_eof + _test_eof390: cs = 390; goto _test_eof + _test_eof391: cs = 391; goto _test_eof + _test_eof392: cs = 392; goto _test_eof + _test_eof393: cs = 393; goto _test_eof + _test_eof394: cs = 394; goto _test_eof + _test_eof395: cs = 395; goto _test_eof + _test_eof396: cs = 396; goto _test_eof + _test_eof397: cs = 397; goto _test_eof + _test_eof398: cs = 398; goto _test_eof + _test_eof399: cs = 399; goto _test_eof + _test_eof400: cs = 400; goto _test_eof + _test_eof401: cs = 401; goto _test_eof + _test_eof402: cs = 402; goto _test_eof + _test_eof403: cs = 403; goto _test_eof + _test_eof404: cs = 404; goto _test_eof + _test_eof405: cs = 405; goto _test_eof + _test_eof406: cs = 406; goto _test_eof + _test_eof407: cs = 407; goto _test_eof + _test_eof408: cs = 408; goto _test_eof + _test_eof409: cs = 409; goto _test_eof + _test_eof410: cs = 410; goto _test_eof + _test_eof411: cs = 411; goto _test_eof + _test_eof412: cs = 412; goto _test_eof + _test_eof413: cs = 413; goto _test_eof + _test_eof414: cs = 414; goto _test_eof + _test_eof415: cs = 415; goto _test_eof + _test_eof416: cs = 416; goto _test_eof + _test_eof417: cs = 417; goto _test_eof + _test_eof418: cs = 418; goto _test_eof + _test_eof419: cs = 419; goto _test_eof + _test_eof420: cs = 420; goto _test_eof + _test_eof421: cs = 421; goto _test_eof + _test_eof422: cs = 422; goto _test_eof + _test_eof423: cs = 423; goto _test_eof + _test_eof424: cs = 424; goto _test_eof + _test_eof425: cs = 425; goto _test_eof + _test_eof426: cs = 426; goto _test_eof + _test_eof427: cs = 427; goto _test_eof + _test_eof428: cs = 428; goto _test_eof + _test_eof429: cs = 429; goto _test_eof + _test_eof430: cs = 430; goto _test_eof + _test_eof431: cs = 431; goto _test_eof + _test_eof432: cs = 432; goto _test_eof + _test_eof433: cs = 433; goto _test_eof + _test_eof434: cs = 434; goto _test_eof + _test_eof435: cs = 435; goto _test_eof + _test_eof436: cs = 436; goto _test_eof + _test_eof437: cs = 437; goto _test_eof + _test_eof438: cs = 438; goto _test_eof + _test_eof439: cs = 439; goto _test_eof + _test_eof440: cs = 440; goto _test_eof + _test_eof441: cs = 441; goto _test_eof + _test_eof442: cs = 442; goto _test_eof + _test_eof443: cs = 443; goto _test_eof + _test_eof444: cs = 444; goto _test_eof + _test_eof445: cs = 445; goto _test_eof + + _test_eof: {} + if p == eof { + switch cs { + case 448: + goto tr529 + case 22: + goto tr24 + case 449: + goto tr529 + case 57: + goto tr24 + case 75: + goto tr102 + case 76: + goto tr102 + case 77: + goto tr102 + case 78: + goto tr102 + case 79: + goto tr102 + case 80: + goto tr102 + case 81: + goto tr102 + case 82: + goto tr102 + case 83: + goto tr102 + case 84: + goto tr102 + case 85: + goto tr102 + case 86: + goto tr102 + case 87: + goto tr102 + case 88: + goto tr102 + case 89: + goto tr102 + case 90: + goto tr102 + case 451: + goto tr533 + case 452: + goto tr533 + } + } + + _out: {} + } + +// line 161 "parseqt.rl" + + + if p < pe { + m0, m1 = p, p + for m0 > 0 && data[m0-1] != '\n' { + m0-- + } + for m1 < len(data) && data[m1] != '\n' { + m1++ + } + return fmt.Errorf("cannot parse header file:%d:%d: %s", curline, p-m0, data[m0:m1]) + } + + if foundclass == 0 { + return fmt.Errorf("cannot find C++ class in header file") + } + if foundclass == 1 { + return fmt.Errorf("cannot find end of C++ class in header file") + } + if foundclass > 2 { + return fmt.Errorf("found too many C++ classes in header file") + } + return nil +} diff --git a/gl/gengl/parseqt.rl b/gl/gengl/parseqt.rl new file mode 100644 index 00000000..4aa4a134 --- /dev/null +++ b/gl/gengl/parseqt.rl @@ -0,0 +1,184 @@ +// +// To compile: +// +// ragel -Z -G2 -o parseqt.go parseqt.rl +// +// To show a diagram of the state machine: +// +// ragel -V -G2 -p -o parseqt.dot parseqt.rl +// dot -Tsvg -o parseqt.svg parseqt.dot +// chrome parseqt.svg +// + +package main + +import ( + "fmt" +) + +%%{ + machine parseqt; + + write data; +}%% + +func parseQt(data string, header *Header) error { + var cs, p, pe int + var ts, te, act, eof int + + pe = len(data) + eof = len(data) + + _, _, _ = ts, te, act + + //stack := make([]int, 32) + //top := 0 + + var curline = 1 + + var m0, m1, m2, m3, m4, m5, m6 int + var foundclass int + var inpublic bool + var heading string + var lineblock int + var f Func + + %%{ + nl = '\n' @{ curline++ }; + cd = [^\n]; + sp = [ \t]; + id = [A-Za-z0-9_]+; + spnl = ( sp | nl ); + + main := |* + 'class Q_GUI_EXPORT ' id >{ m0 = p } %{ m1 = p } ' : public QAbstractOpenGLFunctions' nl '{' nl + { + header.Class = data[m0:m1] + foundclass++ + fgoto inclass; + }; + + 'class Q_GUI_EXPORT ' id >{ m0 = p } %{ m1 = p } nl '{' nl + { + if data[m0:m1] == "QOpenGLFunctions" { + header.Class = data[m0:m1] + foundclass++ + } + fgoto inclass; + }; + + # Ignore any other line. + cd* nl; + *|; + + inclass := |* + # Track heading comments. + sp* '//' sp* cd* >{ m0 = p } @{ m1 = p } sp* nl + { + heading = data[m0:m1] + _ = heading + lineblock++ + }; + + # Ignore constructor/destructor. + sp* '~'? id >{ m0 = p } %{ m1 = p } '()' sp* ( ';' | '{}' ) sp* nl { + if data[m0:m1] != header.Class { + fbreak; + } + }; + + # Ignore initialization function. + sp* 'bool' sp+ 'initializeOpenGLFunctions()' cd* nl; + + # Ignore friend classes. + sp* 'friend' sp+ 'class' sp+ id sp* ';' sp* nl; + + # Track public/private to ignore whatever isn't public. + sp* 'public:' sp* nl + { + inpublic = true + }; + sp* ( 'private:' | 'protected:' ) sp* nl + { + inpublic = false + }; + + # Record function prototypes. + sp* ( 'const' sp+ )? id >{ m0 = p } %{ m1 = p; m4 = 0 } ( sp 'const'? | '*'+ ${ m4++ } )+ + # Name + 'gl' >{ m2 = p } id %{ m3 = p; f = Func{Name: data[m2:m3], Type: data[m0:m1], Addr: m4} } sp* '(' >{ m6 = 0 } sp* + # Parameters + ( 'void'? sp* ')' | ( ( 'const' %{ m6 = 1 } sp+ )? id >{ m0 = p } %{ m1 = p; m4 = 0 } ( sp 'const'? | '*' ${ m4++ } )+ id >{ m2 = p; m5 = 0 } %{ m3 = p } ( '[' [0-9]+ ${ m5 = m5*10 + (int(data[p]) - '0') } ']' )? sp* [,)] + >{ f.Param = append(f.Param, Param{Name: data[m2:m3], Type: data[m0:m1], Addr: m4, Array: m5, Const: m6 > 0}); m6 = 0 } sp* )+ ) + sp* ';' + { + if (inpublic) { + header.Func = append(header.Func, f) + } + }; + + # Record feature flags. + sp* 'enum OpenGLFeature' sp* nl sp* '{' sp* nl + ( sp* id >{ m0 = p } %{ m1 = p } sp* '=' sp* '0x' >{ m2 = p } [0-9]+ %{ m3 = p } ','? sp* nl + >{ header.FeatureFlags = append(header.FeatureFlags, Const{Name: data[m0:m1], Value: data[m2:m3]}) } )+ + sp* '};' nl; + + # Ignore non-gl functions and fields. + sp* ( 'static' sp+ )? ( 'const' sp+ )? [A-Za-z0-9_:]+ ( sp 'const'? | '*'+ ${ m4++ } )+ ( id - ( 'gl' id ) ) ( '(' cd* ')' )? sp* 'const'? + sp* ( ';' | '{' cd* '}' ) sp* nl; + + # Ignore Q_DECLARE_FLAGS + sp* 'Q_DECLARE_FLAGS(' cd+ ')' sp* nl; + + # Ignore deprecated functionality. + '#if QT_DEPRECATED_SINCE(' cd+ ')' sp* nl + ( cd* - '#endif' ) sp* nl + '#endif' sp* nl; + + # Done. + sp* '}' sp* ';' nl + { + foundclass++; + fgoto main; + }; + + # Reset relevant states on empty lines. + sp* nl + { + // Reset heading comment. + heading = "" + + // Start new line block. + lineblock++ + }; + + *|; + + skiperror := [^\n]* (';' | nl ) @{ fgoto main; }; + + write init; + write exec; + }%% + + if p < pe { + m0, m1 = p, p + for m0 > 0 && data[m0-1] != '\n' { + m0-- + } + for m1 < len(data) && data[m1] != '\n' { + m1++ + } + return fmt.Errorf("cannot parse header file:%d:%d: %s", curline, p-m0, data[m0:m1]) + } + + if foundclass == 0 { + return fmt.Errorf("cannot find C++ class in header file") + } + if foundclass == 1 { + return fmt.Errorf("cannot find end of C++ class in header file") + } + if foundclass > 2 { + return fmt.Errorf("found too many C++ classes in header file") + } + return nil +} diff --git a/gl/glbase/glbase.go b/gl/glbase/glbase.go new file mode 100644 index 00000000..c483b15a --- /dev/null +++ b/gl/glbase/glbase.go @@ -0,0 +1,33 @@ +package glbase + +// A Context represents an OpenGL context that may be rendered on by the +// version-specific APIs under this package. +type Context struct { + // This is just a marker at the moment, as the GL.API functions will + // initialize their GL context from the current context in the + // renderer thread. The design supports proper expansion and fixes for + // upstream changes that break that model, though. + private struct{} +} + +// Contexter is implemented by values that have an assigned OpenGL context. +type Contexter interface { + GLContext() *Context +} + +type ( + Bitfield uint32 + Enum uint32 + Sync uintptr + Clampf float32 + Clampd float64 + + Uniform int32 + Attrib int32 + Texture uint32 + Program uint32 + Shader uint32 + Buffer uint32 + Framebuffer uint32 + Renderbuffer uint32 +) diff --git a/log.go b/log.go new file mode 100644 index 00000000..5301e63b --- /dev/null +++ b/log.go @@ -0,0 +1,157 @@ +package qml + +// #include "capi.h" +// +import "C" + +import ( + "fmt" + "log" + "path/filepath" + "strings" +) + +// SetLogger sets the target for messages logged by the qml package, +// including console.log and related calls from within qml code. +// +// The logger value must implement either the StdLogger interface, +// which is satisfied by the standard *log.Logger type, or the QmlLogger +// interface, which offers more control over the logged message. +// +// If no logger is provided, the qml package will send messages to the +// default log package logger. This behavior may also be restored by +// providing a nil logger to this function. +func SetLogger(logger interface{}) { + if logger == nil { + logHandler = defaultLogger{} + return + } + if qmll, ok := logger.(QmlLogger); ok { + logHandler = qmll + return + } + if stdl, ok := logger.(StdLogger); ok { + logHandler = wrappedStdLogger{stdl} + return + } + panic("unsupported logger interface") +} + +// The QmlLogger interface may be implemented to better control how +// log messages from the qml package are handled. Values that +// implement either StdLogger or QmlLogger may be provided to the +// SetLogger function. +type QmlLogger interface { + // QmlOutput is called whenever a new message is available for logging. + // The message value must not be used after the method returns. + QmlOutput(message LogMessage) error +} + +// The StdLogger interface is implemented by standard *log.Logger values. +// Values that implement either StdLogger or QmlLogger may be provided +// to the SetLogger function. +type StdLogger interface { + // Output is called whenever a new message is available for logging. + // See the standard log.Logger type for more details. + Output(calldepth int, s string) error +} + +// NOTE: LogMessage is an interface to avoid allocating and copying +// several strings for each logged message. + +// LogMessage is implemented by values provided to QmlLogger.QmlOutput. +type LogMessage interface { + Severity() LogSeverity + Text() string + File() string + Line() int + + String() string // returns "file:line: text" + + privateMarker() +} + +type LogSeverity int + +const ( + LogDebug LogSeverity = iota + LogWarning + LogCritical + LogFatal +) + +var logHandler QmlLogger = defaultLogger{} + +type defaultLogger struct{} + +func (defaultLogger) QmlOutput(msg LogMessage) error { + log.Println(msg.String()) + return nil +} + +func init() { + // Install the C++ log handler that diverts calls to the hook below. + C.installLogHandler() +} + +//export hookLogHandler +func hookLogHandler(cmsg *C.LogMessage) { + // Workarund for QTBUG-35943 + text := unsafeString(cmsg.text, cmsg.textLen) + if strings.HasPrefix(text, `"Qt Warning: Compose file:`) { + return + } + msg := logMessage{c: cmsg} + logHandler.QmlOutput(&msg) + msg.invalid = true +} + +type wrappedStdLogger struct { + StdLogger +} + +func (l wrappedStdLogger) QmlOutput(msg LogMessage) error { + return l.Output(0, msg.String()) +} + +type logMessage struct { + c *C.LogMessage + + // invalid flags that cmsg points to unreliable memory, + // since the log hook has already returned. + invalid bool +} + +func (m *logMessage) assertValid() { + if m.invalid { + panic("attempted to use log message outside of log hook") + } +} + +func (m *logMessage) Severity() LogSeverity { + return LogSeverity(m.c.severity) +} + +func (m *logMessage) Line() int { + m.assertValid() + return int(m.c.line) +} + +func (m *logMessage) String() string { + m.assertValid() + file := unsafeString(m.c.file, m.c.fileLen) + text := unsafeString(m.c.text, m.c.textLen) + return fmt.Sprintf("%s:%d: %s", filepath.Base(file), m.c.line, text) +} + +func (m *logMessage) File() string { + m.assertValid() + return C.GoStringN(m.c.file, m.c.fileLen) +} + +func (m *logMessage) Text() string { + m.assertValid() + return C.GoStringN(m.c.text, m.c.line) +} + +func (*logMessage) privateMarker() {} diff --git a/qml.go b/qml.go new file mode 100644 index 00000000..aa7356c9 --- /dev/null +++ b/qml.go @@ -0,0 +1,1118 @@ +package qml + +// #include +// +// #include "capi.h" +// +import "C" + +import ( + "errors" + "fmt" + "gopkg.in/qml.v1/gl/glbase" + "image" + "image/color" + "io" + "io/ioutil" + "os" + "path/filepath" + "reflect" + "strings" + "sync" + "unsafe" +) + +// Engine provides an environment for instantiating QML components. +type Engine struct { + Common + values map[interface{}]*valueFold + destroyed bool + + imageProviders map[string]*func(imageId string, width, height int) image.Image +} + +var engines = make(map[unsafe.Pointer]*Engine) + +// NewEngine returns a new QML engine. +// +// The Destory method must be called to finalize the engine and +// release any resources used. +func NewEngine() *Engine { + engine := &Engine{values: make(map[interface{}]*valueFold)} + RunMain(func() { + engine.addr = C.newEngine(nil) + engine.engine = engine + engine.imageProviders = make(map[string]*func(imageId string, width, height int) image.Image) + engines[engine.addr] = engine + stats.enginesAlive(+1) + }) + return engine +} + +func (e *Engine) assertValid() { + if e.destroyed { + panic("engine already destroyed") + } +} + +// Destroy finalizes the engine and releases any resources used. +// The engine must not be used after calling this method. +// +// It is safe to call Destroy more than once. +func (e *Engine) Destroy() { + if !e.destroyed { + RunMain(func() { + if !e.destroyed { + e.destroyed = true + C.delObjectLater(e.addr) + if len(e.values) == 0 { + delete(engines, e.addr) + } else { + // The engine reference keeps those values alive. + // The last value destroyed will clear it. + } + stats.enginesAlive(-1) + } + }) + } +} + +// Load loads a new component with the provided location and with the +// content read from r. The location informs the resource name for +// logged messages, and its path is used to locate any other resources +// referenced by the QML content. +// +// Once a component is loaded, component instances may be created from +// the resulting object via its Create and CreateWindow methods. +func (e *Engine) Load(location string, r io.Reader) (Object, error) { + var cdata *C.char + var cdatalen C.int + + qrc := strings.HasPrefix(location, "qrc:") + if qrc { + if r != nil { + return nil, fmt.Errorf("cannot load qrc resource while providing data: %s", location) + } + } else { + data, err := ioutil.ReadAll(r) + if err != nil { + return nil, err + } + if colon, slash := strings.Index(location, ":"), strings.Index(location, "/"); colon == -1 || slash <= colon { + if filepath.IsAbs(location) { + location = "file:///" + filepath.ToSlash(location) + } else { + dir, err := os.Getwd() + if err != nil { + return nil, fmt.Errorf("cannot obtain absolute path: %v", err) + } + location = "file:///" + filepath.ToSlash(filepath.Join(dir, location)) + } + } + + // Workaround issue #84 (QTBUG-41193) by not refering to an existent file. + if s := strings.TrimPrefix(location, "file:///"); s != location { + if _, err := os.Stat(filepath.FromSlash(s)); err == nil { + location = location + "." + } + } + + cdata, cdatalen = unsafeBytesData(data) + } + + var err error + cloc, cloclen := unsafeStringData(location) + comp := &Common{engine: e} + RunMain(func() { + // TODO The component's parent should probably be the engine. + comp.addr = C.newComponent(e.addr, nilPtr) + if qrc { + C.componentLoadURL(comp.addr, cloc, cloclen) + } else { + C.componentSetData(comp.addr, cdata, cdatalen, cloc, cloclen) + } + message := C.componentErrorString(comp.addr) + if message != nilCharPtr { + err = errors.New(strings.TrimRight(C.GoString(message), "\n")) + C.free(unsafe.Pointer(message)) + } + }) + if err != nil { + return nil, err + } + return comp, nil +} + +// LoadFile loads a component from the provided QML file. +// Resources referenced by the QML content will be resolved relative to its path. +// +// Once a component is loaded, component instances may be created from +// the resulting object via its Create and CreateWindow methods. +func (e *Engine) LoadFile(path string) (Object, error) { + if strings.HasPrefix(path, "qrc:") { + return e.Load(path, nil) + } + // TODO Test this. + f, err := os.Open(path) + if err != nil { + return nil, err + } + defer f.Close() + return e.Load(path, f) +} + +// LoadString loads a component from the provided QML string. +// The location informs the resource name for logged messages, and its +// path is used to locate any other resources referenced by the QML content. +// +// Once a component is loaded, component instances may be created from +// the resulting object via its Create and CreateWindow methods. +func (e *Engine) LoadString(location, qml string) (Object, error) { + return e.Load(location, strings.NewReader(qml)) +} + +// Context returns the engine's root context. +func (e *Engine) Context() *Context { + e.assertValid() + var ctx Context + ctx.engine = e + RunMain(func() { + ctx.addr = C.engineRootContext(e.addr) + }) + return &ctx +} + +// TODO ObjectOf is probably still worth it, but turned out unnecessary +// for GL functionality. Test it properly before introducing it. + +// ObjectOf returns the QML Object representation of the provided Go value +// within the e engine. +//func (e *Engine) ObjectOf(value interface{}) Object { +// // TODO Would be good to preserve identity on the Go side. See unpackDataValue as well. +// return &Common{ +// engine: e, +// addr: wrapGoValue(e, value, cppOwner), +// } +//} + +// Painter is provided to Paint methods on Go types that have displayable content. +type Painter struct { + engine *Engine + obj Object + glctxt glbase.Context +} + +// Object returns the underlying object being painted. +func (p *Painter) Object() Object { + return p.obj +} + +// GLContext returns the OpenGL context for this painter. +func (p *Painter) GLContext() *glbase.Context { + return &p.glctxt +} + +// AddImageProvider registers f to be called when an image is requested by QML code +// with the specified provider identifier. It is a runtime error to register the same +// provider identifier multiple times. +// +// The imgId provided to f is the requested image source, with the "image:" scheme +// and provider identifier removed. For example, with an image image source of +// "image://myprovider/icons/home.ext", the respective imgId would be "icons/home.ext". +// +// If either the width or the height parameters provided to f are zero, no specific +// size for the image was requested. If non-zero, the returned image should have the +// the provided size, and will be resized if the returned image has a different size. +// +// See the documentation for more details on image providers: +// +// http://qt-project.org/doc/qt-5.0/qtquick/qquickimageprovider.html +// +func (e *Engine) AddImageProvider(prvId string, f func(imgId string, width, height int) image.Image) { + if _, ok := e.imageProviders[prvId]; ok { + panic(fmt.Sprintf("engine already has an image provider with id %q", prvId)) + } + e.imageProviders[prvId] = &f + cprvId, cprvIdLen := unsafeStringData(prvId) + RunMain(func() { + qprvId := C.newString(cprvId, cprvIdLen) + defer C.delString(qprvId) + C.engineAddImageProvider(e.addr, qprvId, unsafe.Pointer(&f)) + }) +} + +//export hookRequestImage +func hookRequestImage(imageFunc unsafe.Pointer, cid *C.char, cidLen, cwidth, cheight C.int) unsafe.Pointer { + f := *(*func(imgId string, width, height int) image.Image)(imageFunc) + + id := unsafeString(cid, cidLen) + width := int(cwidth) + height := int(cheight) + + img := f(id, width, height) + + var cimage unsafe.Pointer + + rect := img.Bounds() + width = rect.Max.X - rect.Min.X + height = rect.Max.Y - rect.Min.Y + cimage = C.newImage(C.int(width), C.int(height)) + + var cbits []byte + cbitsh := (*reflect.SliceHeader)((unsafe.Pointer)(&cbits)) + cbitsh.Data = (uintptr)((unsafe.Pointer)(C.imageBits(cimage))) + cbitsh.Len = width * height * 4 // RGBA + cbitsh.Cap = cbitsh.Len + + i := 0 + for y := 0; y < height; y++ { + for x := 0; x < width; x++ { + r, g, b, a := img.At(x, y).RGBA() + *(*uint32)(unsafe.Pointer(&cbits[i])) = (a>>8)<<24 | (r>>8)<<16 | (g>>8)<<8 | (b >> 8) + i += 4 + } + } + return cimage +} + +// Context represents a QML context that can hold variables visible +// to logic running within it. +type Context struct { + Common +} + +// SetVar makes the provided value available as a variable with the +// given name for QML code executed within the c context. +// +// If value is a struct, its exported fields are also made accessible to +// QML code as attributes of the named object. The attribute name in the +// object has the same name of the Go field name, except for the first +// letter which is lowercased. This is conventional and enforced by +// the QML implementation. +// +// The engine will hold a reference to the provided value, so it will +// not be garbage collected until the engine is destroyed, even if the +// value is unused or changed. +func (ctx *Context) SetVar(name string, value interface{}) { + cname, cnamelen := unsafeStringData(name) + RunMain(func() { + var dvalue C.DataValue + packDataValue(value, &dvalue, ctx.engine, cppOwner) + + qname := C.newString(cname, cnamelen) + defer C.delString(qname) + + C.contextSetProperty(ctx.addr, qname, &dvalue) + }) +} + +// SetVars makes the exported fields of the provided value available as +// variables for QML code executed within the c context. The variable names +// will have the same name of the Go field names, except for the first +// letter which is lowercased. This is conventional and enforced by +// the QML implementation. +// +// The engine will hold a reference to the provided value, so it will +// not be garbage collected until the engine is destroyed, even if the +// value is unused or changed. +func (ctx *Context) SetVars(value interface{}) { + RunMain(func() { + C.contextSetObject(ctx.addr, wrapGoValue(ctx.engine, value, cppOwner)) + }) +} + +// Var returns the context variable with the given name. +func (ctx *Context) Var(name string) interface{} { + cname, cnamelen := unsafeStringData(name) + + var dvalue C.DataValue + RunMain(func() { + qname := C.newString(cname, cnamelen) + defer C.delString(qname) + + C.contextGetProperty(ctx.addr, qname, &dvalue) + }) + return unpackDataValue(&dvalue, ctx.engine) +} + +// Spawn creates a new context that has ctx as a parent. +func (ctx *Context) Spawn() *Context { + var result Context + result.engine = ctx.engine + RunMain(func() { + result.addr = C.contextSpawn(ctx.addr) + }) + return &result +} + +// Object is the common interface implemented by all QML types. +// +// See the documentation of Common for details about this interface. +type Object interface { + Common() *Common + Addr() uintptr + TypeName() string + Interface() interface{} + Set(property string, value interface{}) + Property(name string) interface{} + Int(property string) int + Int64(property string) int64 + Float64(property string) float64 + Bool(property string) bool + String(property string) string + Color(property string) color.RGBA + Object(property string) Object + Map(property string) *Map + List(property string) *List + ObjectByName(objectName string) Object + Call(method string, params ...interface{}) interface{} + Create(ctx *Context) Object + CreateWindow(ctx *Context) *Window + Destroy() + On(signal string, function interface{}) +} + +// List holds a QML list which may be converted to a Go slice of an +// appropriate type via Convert. +// +// In the future this will also be able to hold a reference +// to QML-owned maps, so they can be mutated in place. +type List struct { + // In the future this will be able to hold a reference to QML-owned + // lists, so they can be mutated. + data []interface{} +} + +// Len returns the number of elements in the list. +func (l *List) Len() int { + return len(l.data) +} + +// Convert allocates a new slice and copies the list content into it, +// performing type conversions as possible, and then assigns the result +// to the slice pointed to by sliceAddr. +// Convert panics if the list values are not compatible with the +// provided slice. +func (l *List) Convert(sliceAddr interface{}) { + toPtr := reflect.ValueOf(sliceAddr) + if toPtr.Kind() != reflect.Ptr || toPtr.Type().Elem().Kind() != reflect.Slice { + panic(fmt.Sprintf("List.Convert got a sliceAddr parameter that is not a slice address: %#v", sliceAddr)) + } + err := convertAndSet(toPtr.Elem(), reflect.ValueOf(l), reflect.Value{}) + if err != nil { + panic(err.Error()) + } +} + +// Map holds a QML map which may be converted to a Go map of an +// appropriate type via Convert. +// +// In the future this will also be able to hold a reference +// to QML-owned maps, so they can be mutated in place. +type Map struct { + data []interface{} +} + +// Len returns the number of pairs in the map. +func (m *Map) Len() int { + return len(m.data) / 2 +} + +// Convert allocates a new map and copies the content of m property to it, +// performing type conversions as possible, and then assigns the result to +// the map pointed to by mapAddr. Map panics if m contains values that +// cannot be converted to the type of the map at mapAddr. +func (m *Map) Convert(mapAddr interface{}) { + toPtr := reflect.ValueOf(mapAddr) + if toPtr.Kind() != reflect.Ptr || toPtr.Type().Elem().Kind() != reflect.Map { + panic(fmt.Sprintf("Map.Convert got a mapAddr parameter that is not a map address: %#v", mapAddr)) + } + err := convertAndSet(toPtr.Elem(), reflect.ValueOf(m), reflect.Value{}) + if err != nil { + panic(err.Error()) + } +} + +// Common implements the common behavior of all QML objects. +// It implements the Object interface. +type Common struct { + addr unsafe.Pointer + engine *Engine +} + +var _ Object = (*Common)(nil) + +// CommonOf returns the Common QML value for the QObject at addr. +// +// This is meant for extensions that integrate directly with the +// underlying QML logic. +func CommonOf(addr unsafe.Pointer, engine *Engine) *Common { + return &Common{addr, engine} +} + +// Common returns obj itself. +// +// This provides access to the underlying *Common for types that +// embed it, when these are used via the Object interface. +func (obj *Common) Common() *Common { + return obj +} + +// TypeName returns the underlying type name for the held value. +func (obj *Common) TypeName() string { + var name string + RunMain(func() { + name = C.GoString(C.objectTypeName(obj.addr)) + }) + return name +} + +// Addr returns the QML object address. +// +// This is meant for extensions that integrate directly with the +// underlying QML logic. +func (obj *Common) Addr() uintptr { + return uintptr(obj.addr) +} + +// Interface returns the underlying Go value that is being held by +// the object wrapper. +// +// It is a runtime error to call Interface on values that are not +// backed by a Go value. +func (obj *Common) Interface() interface{} { + var result interface{} + var cerr *C.error + RunMain(func() { + var foldr C.GoRef + if cerr = C.objectGoRef(obj.addr, &foldr); cerr == nil { + fold := getFoldFromGoRef(foldr) + result = fold.gvalue + } + }) + cmust(cerr) + return result +} + +// Set changes the named object property to the given value. +func (obj *Common) Set(property string, value interface{}) { + cproperty := C.CString(property) + defer C.free(unsafe.Pointer(cproperty)) + var cerr *C.error + RunMain(func() { + var dvalue C.DataValue + packDataValue(value, &dvalue, obj.engine, cppOwner) + cerr = C.objectSetProperty(obj.addr, cproperty, &dvalue) + }) + cmust(cerr) +} + +// Property returns the current value for a property of the object. +// If the property type is known, type-specific methods such as Int +// and String are more convenient to use. +// Property panics if the property does not exist. +func (obj *Common) Property(name string) interface{} { + cname := C.CString(name) + defer C.free(unsafe.Pointer(cname)) + + var dvalue C.DataValue + var found C.int + RunMain(func() { + found = C.objectGetProperty(obj.addr, cname, &dvalue) + }) + if found == 0 { + panic(fmt.Sprintf("object does not have a %q property", name)) + } + return unpackDataValue(&dvalue, obj.engine) +} + +// Int returns the int value of the named property. +// Int panics if the property cannot be represented as an int. +func (obj *Common) Int(property string) int { + switch value := obj.Property(property).(type) { + case int64: + return int(value) + case int: + return value + case uint64: + return int(value) + case uint32: + return int(value) + case uintptr: + return int(value) + case float32: + return int(value) + case float64: + return int(value) + default: + panic(fmt.Sprintf("value of property %q cannot be represented as an int: %#v", property, value)) + } +} + +// Int64 returns the int64 value of the named property. +// Int64 panics if the property cannot be represented as an int64. +func (obj *Common) Int64(property string) int64 { + switch value := obj.Property(property).(type) { + case int64: + return value + case int: + return int64(value) + case uint64: + return int64(value) + case uint32: + return int64(value) + case uintptr: + return int64(value) + case float32: + return int64(value) + case float64: + return int64(value) + default: + panic(fmt.Sprintf("value of property %q cannot be represented as an int64: %#v", property, value)) + } +} + +// Float64 returns the float64 value of the named property. +// Float64 panics if the property cannot be represented as float64. +func (obj *Common) Float64(property string) float64 { + switch value := obj.Property(property).(type) { + case int64: + return float64(value) + case int: + return float64(value) + case uint64: + return float64(value) + case uint32: + return float64(value) + case uintptr: + return float64(value) + case float32: + return float64(value) + case float64: + return value + default: + panic(fmt.Sprintf("value of property %q cannot be represented as a float64: %#v", property, value)) + } +} + +// Bool returns the bool value of the named property. +// Bool panics if the property is not a bool. +func (obj *Common) Bool(property string) bool { + value := obj.Property(property) + if b, ok := value.(bool); ok { + return b + } + panic(fmt.Sprintf("value of property %q is not a bool: %#v", property, value)) +} + +// String returns the string value of the named property. +// String panics if the property is not a string. +func (obj *Common) String(property string) string { + value := obj.Property(property) + if s, ok := value.(string); ok { + return s + } + panic(fmt.Sprintf("value of property %q is not a string: %#v", property, value)) +} + +// Color returns the RGBA value of the named property. +// Color panics if the property is not a color. +func (obj *Common) Color(property string) color.RGBA { + value := obj.Property(property) + c, ok := value.(color.RGBA) + if !ok { + panic(fmt.Sprintf("value of property %q is not a color: %#v", property, value)) + } + return c +} + +// Object returns the object value of the named property. +// Object panics if the property is not a QML object. +func (obj *Common) Object(property string) Object { + value := obj.Property(property) + object, ok := value.(Object) + if !ok { + panic(fmt.Sprintf("value of property %q is not a QML object: %#v", property, value)) + } + return object +} + +// List returns the list value of the named property. +// List panics if the property is not a list. +func (obj *Common) List(property string) *List { + value := obj.Property(property) + m, ok := value.(*List) + if !ok { + panic(fmt.Sprintf("value of property %q is not a QML list: %#v", property, value)) + } + return m +} + +// Map returns the map value of the named property. +// Map panics if the property is not a map. +func (obj *Common) Map(property string) *Map { + value := obj.Property(property) + m, ok := value.(*Map) + if !ok { + panic(fmt.Sprintf("value of property %q is not a QML map: %#v", property, value)) + } + return m +} + +// ObjectByName returns the Object value of the descendant object that +// was defined with the objectName property set to the provided value. +// ObjectByName panics if the object is not found. +func (obj *Common) ObjectByName(objectName string) Object { + cname, cnamelen := unsafeStringData(objectName) + var dvalue C.DataValue + var object Object + RunMain(func() { + qname := C.newString(cname, cnamelen) + defer C.delString(qname) + C.objectFindChild(obj.addr, qname, &dvalue) + // unpackDataValue will also initialize the Go type, if necessary. + value := unpackDataValue(&dvalue, obj.engine) + if dvalue.dataType == C.DTGoAddr { + datap := unsafe.Pointer(&dvalue.data) + fold := (*(**valueFold)(datap)) + if fold.init.IsValid() { + panic("internal error: custom Go type not initialized") + } + object = &Common{fold.cvalue, fold.engine} + } else { + object, _ = value.(Object) + } + }) + if object == nil { + panic(fmt.Sprintf("cannot find descendant with objectName == %q", objectName)) + } + return object +} + +// Call calls the given object method with the provided parameters. +// Call panics if the method does not exist. +func (obj *Common) Call(method string, params ...interface{}) interface{} { + if len(params) > len(dataValueArray) { + panic("too many parameters") + } + cmethod, cmethodLen := unsafeStringData(method) + var result C.DataValue + var cerr *C.error + RunMain(func() { + for i, param := range params { + packDataValue(param, &dataValueArray[i], obj.engine, jsOwner) + } + cerr = C.objectInvoke(obj.addr, cmethod, cmethodLen, &result, &dataValueArray[0], C.int(len(params))) + }) + cmust(cerr) + return unpackDataValue(&result, obj.engine) +} + +// Create creates a new instance of the component held by obj. +// The component instance runs under the ctx context. If ctx is nil, +// it runs under the same context as obj. +// +// The Create method panics if called on an object that does not +// represent a QML component. +func (obj *Common) Create(ctx *Context) Object { + if C.objectIsComponent(obj.addr) == 0 { + panic("object is not a component") + } + var root Common + root.engine = obj.engine + RunMain(func() { + ctxaddr := nilPtr + if ctx != nil { + ctxaddr = ctx.addr + } + root.addr = C.componentCreate(obj.addr, ctxaddr) + }) + return &root +} + +// CreateWindow creates a new instance of the component held by obj, +// and creates a new window holding the instance as its root object. +// The component instance runs under the ctx context. If ctx is nil, +// it runs under the same context as obj. +// +// The CreateWindow method panics if called on an object that +// does not represent a QML component. +func (obj *Common) CreateWindow(ctx *Context) *Window { + if C.objectIsComponent(obj.addr) == 0 { + panic("object is not a component") + } + var win Window + win.engine = obj.engine + RunMain(func() { + ctxaddr := nilPtr + if ctx != nil { + ctxaddr = ctx.addr + } + win.addr = C.componentCreateWindow(obj.addr, ctxaddr) + }) + return &win +} + +// Destroy finalizes the value and releases any resources used. +// The value must not be used after calling this method. +func (obj *Common) Destroy() { + // TODO We might hook into the destroyed signal, and prevent this object + // from being used in post-destruction crash-prone ways. + RunMain(func() { + if obj.addr != nilPtr { + C.delObjectLater(obj.addr) + obj.addr = nilPtr + } + }) +} + +var connectedFunction = make(map[C.GoRef]interface{}) + +// On connects the named signal from obj with the provided function, so that +// when obj next emits that signal, the function is called with the parameters +// the signal carries. +// +// The provided function must accept a number of parameters that is equal to +// or less than the number of parameters provided by the signal, and the +// resepctive parameter types must match exactly or be conversible according +// to normal Go rules. +// +// For example: +// +// obj.On("clicked", func() { fmt.Println("obj got a click") }) +// +// Note that Go uses the real signal name, rather than the one used when +// defining QML signal handlers ("clicked" rather than "onClicked"). +// +// For more details regarding signals and QML see: +// +// http://qt-project.org/doc/qt-5.0/qtqml/qml-qtquick2-connections.html +// +func (obj *Common) On(signal string, function interface{}) { + funcv := reflect.ValueOf(function) + funct := funcv.Type() + if funcv.Kind() != reflect.Func { + panic("function provided to On is not a function or method") + } + if funct.NumIn() > C.MaxParams { + panic("function takes too many arguments") + } + csignal, csignallen := unsafeStringData(signal) + var cerr *C.error + RunMain(func() { + funcr := C.GoRef(uintptr(unsafe.Pointer(&function))) + cerr = C.objectConnect(obj.addr, csignal, csignallen, obj.engine.addr, funcr, C.int(funcv.Type().NumIn())) + if cerr == nil { + connectedFunction[funcr] = function + stats.connectionsAlive(+1) + } + }) + cmust(cerr) +} + +//export hookSignalDisconnect +func hookSignalDisconnect(funcr C.GoRef) { + before := len(connectedFunction) + delete(connectedFunction, funcr) + if before == len(connectedFunction) { + panic("disconnecting unknown signal function") + } + stats.connectionsAlive(-1) +} + +//export hookSignalCall +func hookSignalCall(enginep unsafe.Pointer, funcr C.GoRef, args *C.DataValue) { + engine := engines[enginep] + if engine == nil { + panic("signal called after engine was destroyed") + } + + function := connectedFunction[funcr] + if function == nil { + panic("signal called on disconnected function") + } + + funcv := reflect.ValueOf(function) + funct := funcv.Type() + numIn := funct.NumIn() + var params [C.MaxParams]reflect.Value + for i := 0; i < numIn; i++ { + arg := (*C.DataValue)(unsafe.Pointer(uintptr(unsafe.Pointer(args)) + uintptr(i)*dataValueSize)) + param := reflect.ValueOf(unpackDataValue(arg, engine)) + if paramt := funct.In(i); param.Type() != paramt { + // TODO Provide a better error message when this fails. + param = param.Convert(paramt) + } + params[i] = param + } + funcv.Call(params[:numIn]) +} + +func cerror(cerr *C.error) error { + err := errors.New(C.GoString((*C.char)(unsafe.Pointer(cerr)))) + C.free(unsafe.Pointer(cerr)) + return err +} + +func cmust(cerr *C.error) { + if cerr != nil { + panic(cerror(cerr).Error()) + } +} + +// TODO Signal emitting support for go values. + +// Window represents a QML window where components are rendered. +type Window struct { + Common +} + +// Show exposes the window. +func (win *Window) Show() { + RunMain(func() { + C.windowShow(win.addr) + }) +} + +// Hide hides the window. +func (win *Window) Hide() { + RunMain(func() { + C.windowHide(win.addr) + }) +} + +// PlatformId returns the window's platform id. +// +// For platforms where this id might be useful, the value returned will +// uniquely represent the window inside the corresponding screen. +func (win *Window) PlatformId() uintptr { + var id uintptr + RunMain(func() { + id = uintptr(C.windowPlatformId(win.addr)) + }) + return id +} + +// Root returns the root object being rendered. +// +// If the window was defined in QML code, the root object is the window itself. +func (win *Window) Root() Object { + var obj Common + obj.engine = win.engine + RunMain(func() { + obj.addr = C.windowRootObject(win.addr) + }) + return &obj +} + +// Wait blocks the current goroutine until the window is closed. +func (win *Window) Wait() { + // XXX Test this. + var m sync.Mutex + m.Lock() + RunMain(func() { + // TODO Must be able to wait for the same Window from multiple goroutines. + // TODO If the window is not visible, must return immediately. + waitingWindows[win.addr] = &m + C.windowConnectHidden(win.addr) + }) + m.Lock() +} + +var waitingWindows = make(map[unsafe.Pointer]*sync.Mutex) + +//export hookWindowHidden +func hookWindowHidden(addr unsafe.Pointer) { + m, ok := waitingWindows[addr] + if !ok { + panic("window is not waiting") + } + delete(waitingWindows, addr) + m.Unlock() +} + +// Snapshot returns an image with the visible contents of the window. +// The main GUI thread is paused while the data is being acquired. +func (win *Window) Snapshot() image.Image { + // TODO Test this. + var cimage unsafe.Pointer + RunMain(func() { + cimage = C.windowGrabWindow(win.addr) + }) + defer C.delImage(cimage) + + // This should be safe to be done out of the main GUI thread. + var cwidth, cheight C.int + C.imageSize(cimage, &cwidth, &cheight) + + var cbits []byte + cbitsh := (*reflect.SliceHeader)((unsafe.Pointer)(&cbits)) + cbitsh.Data = (uintptr)((unsafe.Pointer)(C.imageConstBits(cimage))) + cbitsh.Len = int(cwidth * cheight * 8) // ARGB + cbitsh.Cap = cbitsh.Len + + image := image.NewRGBA(image.Rect(0, 0, int(cwidth), int(cheight))) + l := int(cwidth * cheight * 4) + for i := 0; i < l; i += 4 { + var c uint32 = *(*uint32)(unsafe.Pointer(&cbits[i])) + image.Pix[i+0] = byte(c >> 16) + image.Pix[i+1] = byte(c >> 8) + image.Pix[i+2] = byte(c) + image.Pix[i+3] = byte(c >> 24) + } + return image +} + +// TypeSpec holds the specification of a QML type that is backed by Go logic. +// +// The type specification must be registered with the RegisterTypes function +// before it will be visible to QML code, as in: +// +// qml.RegisterTypes("GoExtensions", 1, 0, []qml.TypeSpec{{ +// Init: func(p *Person, obj qml.Object) {}, +// }}) +// +// See the package documentation for more details. +// +type TypeSpec struct { + // Init must be set to a function that is called when QML code requests + // the creation of a new value of this type. The provided function must + // have the following type: + // + // func(value *CustomType, object qml.Object) + // + // Where CustomType is the custom type being registered. The function will + // be called with a newly created *CustomType and its respective qml.Object. + Init interface{} + + // Name optionally holds the identifier the type is known as within QML code, + // when the registered extension module is imported. If not specified, the + // name of the Go type provided as the first argument of Init is used instead. + Name string + + // Singleton defines whether a single instance of the type should be used + // for all accesses, as a singleton value. If true, all properties of the + // singleton value are directly accessible under the type name. + Singleton bool + + private struct{} // Force use of fields by name. +} + +var types = make(map[C.GoTypeSpec_]*TypeSpec) + +// RegisterTypes registers the provided list of type specifications for use +// by QML code. To access the registered types, they must be imported from the +// provided location and major.minor version numbers. +// +// For example, with a location "GoExtensions", major 4, and minor 2, this statement +// imports all the registered types in the module's namespace: +// +// import GoExtensions 4.2 +// +// See the documentation on QML import statements for details on these: +// +// http://qt-project.org/doc/qt-5.0/qtqml/qtqml-syntax-imports.html +// +func RegisterTypes(location string, major, minor int, types []TypeSpec) { + for i := range types { + err := registerType(location, major, minor, &types[i]) + if err != nil { + panic(err) + } + } +} + +func registerType(location string, major, minor int, spec *TypeSpec) error { + // Copy and hold a reference to the spec data. + localSpec := *spec + + f := reflect.ValueOf(localSpec.Init) + ft := f.Type() + if ft.Kind() != reflect.Func { + return fmt.Errorf("TypeSpec.Init must be a function, got %#v", localSpec.Init) + } + if ft.NumIn() != 2 { + return fmt.Errorf("TypeSpec.Init's function must accept two arguments: %s", ft) + } + firstArg := ft.In(0) + if firstArg.Kind() != reflect.Ptr || firstArg.Elem().Kind() == reflect.Ptr { + return fmt.Errorf("TypeSpec.Init's function must take a pointer type as the second argument: %s", ft) + } + if ft.In(1) != typeObject { + return fmt.Errorf("TypeSpec.Init's function must take qml.Object as the second argument: %s", ft) + } + customType := typeInfo(reflect.New(firstArg.Elem()).Interface()) + if localSpec.Name == "" { + localSpec.Name = firstArg.Elem().Name() + if localSpec.Name == "" { + panic("cannot determine registered type name; please provide one explicitly") + } + } + + var err error + RunMain(func() { + cloc := C.CString(location) + cname := C.CString(localSpec.Name) + cres := C.int(0) + localSpecRef := C.GoTypeSpec_(uintptr(unsafe.Pointer(&localSpec))) + if localSpec.Singleton { + cres = C.registerSingleton(cloc, C.int(major), C.int(minor), cname, customType, localSpecRef) + } else { + cres = C.registerType(cloc, C.int(major), C.int(minor), cname, customType, localSpecRef) + } + // It doesn't look like it keeps references to these, but it's undocumented and unclear. + C.free(unsafe.Pointer(cloc)) + C.free(unsafe.Pointer(cname)) + if cres == -1 { + err = fmt.Errorf("QML engine failed to register type; invalid type location or name?") + } else { + types[localSpecRef] = &localSpec + } + }) + + return err +} + +// RegisterConverter registers the convereter function to be called when a +// value with the provided type name is obtained from QML logic. The function +// must return the new value to be used in place of the original value. +func RegisterConverter(typeName string, converter func(engine *Engine, obj Object) interface{}) { + if converter == nil { + delete(converters, typeName) + } else { + converters[typeName] = converter + } +} + +var converters = make(map[string]func(engine *Engine, obj Object) interface{}) + +// LoadResources registers all resources in the provided resources collection, +// making them available to be loaded by any Engine and QML file. +// Registered resources are made available under "qrc:///some/path", where +// "some/path" is the path the resource was added with. +func LoadResources(r *Resources) { + var base unsafe.Pointer + if len(r.sdata) > 0 { + base = *(*unsafe.Pointer)(unsafe.Pointer(&r.sdata)) + } else if len(r.bdata) > 0 { + base = *(*unsafe.Pointer)(unsafe.Pointer(&r.bdata)) + } + tree := (*C.char)(unsafe.Pointer(uintptr(base)+uintptr(r.treeOffset))) + name := (*C.char)(unsafe.Pointer(uintptr(base)+uintptr(r.nameOffset))) + data := (*C.char)(unsafe.Pointer(uintptr(base)+uintptr(r.dataOffset))) + C.registerResourceData(C.int(r.version), tree, name, data) +} + +// UnloadResources unregisters all previously registered resources from r. +func UnloadResources(r *Resources) { + var base unsafe.Pointer + if len(r.sdata) > 0 { + base = *(*unsafe.Pointer)(unsafe.Pointer(&r.sdata)) + } else if len(r.bdata) > 0 { + base = *(*unsafe.Pointer)(unsafe.Pointer(&r.bdata)) + } + tree := (*C.char)(unsafe.Pointer(uintptr(base)+uintptr(r.treeOffset))) + name := (*C.char)(unsafe.Pointer(uintptr(base)+uintptr(r.nameOffset))) + data := (*C.char)(unsafe.Pointer(uintptr(base)+uintptr(r.dataOffset))) + C.unregisterResourceData(C.int(r.version), tree, name, data) +} diff --git a/qml_test.go b/qml_test.go new file mode 100644 index 00000000..2db23cd2 --- /dev/null +++ b/qml_test.go @@ -0,0 +1,1436 @@ +package qml_test + +import ( + "encoding/base64" + "flag" + "fmt" + "image" + "image/color" + "io/ioutil" + "os" + "reflect" + "regexp" + "runtime" + "strings" + "testing" + "time" + + . "gopkg.in/check.v1" + "gopkg.in/qml.v1" + "gopkg.in/qml.v1/cpptest" + "gopkg.in/qml.v1/gl/2.0" + "path/filepath" +) + +func init() { qml.SetupTesting() } + +func Test(t *testing.T) { TestingT(t) } + +type S struct { + engine *qml.Engine + context *qml.Context +} + +var _ = Suite(&S{}) + +func (s *S) SetUpTest(c *C) { + qml.SetLogger(c) + qml.CollectStats(true) + qml.ResetStats() + + stats := qml.Stats() + if stats.EnginesAlive > 0 || stats.ValuesAlive > 0 || stats.ConnectionsAlive > 0 { + panic(fmt.Sprintf("Test started with values alive: %#v\n", stats)) + } + + s.engine = qml.NewEngine() + s.context = s.engine.Context() +} + +func (s *S) TearDownTest(c *C) { + s.engine.Destroy() + + retries := 30 // Three seconds top. + for { + // Do not call qml.Flush here. It creates a nested event loop + // that attempts to process the deferred object deletes and cannot, + // because deferred deletes are only processed at the same loop level. + // So it *reposts* the deferred deletion event, in practice *preventing* + // these objects from being deleted. + runtime.GC() + stats := qml.Stats() + if stats.EnginesAlive == 0 && stats.ValuesAlive == 0 && stats.ConnectionsAlive == 0 { + break + } + if retries == 0 { + panic(fmt.Sprintf("there are values alive:\n%#v\n", stats)) + } + retries-- + time.Sleep(100 * time.Millisecond) + if retries%10 == 0 { + c.Logf("There are still objects alive; waiting for them to die: %#v\n", stats) + } + } + + qml.SetLogger(nil) +} + +type GoRect struct { + PaintCount int +} + +func (r *GoRect) Paint(p *qml.Painter) { + r.PaintCount++ + + obj := p.Object() + + gl := GL.API(p) + + width := float32(obj.Int("width")) + height := float32(obj.Int("height")) + + gl.Color3f(1.0, 0.0, 0.0) + gl.Begin(GL.QUADS) + gl.Vertex2f(0, 0) + gl.Vertex2f(width, 0) + gl.Vertex2f(width, height) + gl.Vertex2f(0, height) + gl.End() +} + +type GoType struct { + private bool // Besides being private, also adds a gap in the reflect field index. + + StringValue string + StringAddrValue *string + BoolValue bool + IntValue int + Int64Value int64 + Int32Value int32 + Uint32Value uint32 + Float64Value float64 + Float32Value float32 + AnyValue interface{} + ObjectValue qml.Object + ColorValue color.RGBA + IntsValue []int + ObjectsValue []qml.Object + MapValue map[string]interface{} + + SetterStringValue string + SetterObjectsValue []qml.Object + + setterStringValueChanged int + setterStringValueSet string + setterObjectsValueChanged int + setterObjectsValueSet []qml.Object + + getterStringValue string + getterStringValueChanged int + + // The object representing this value, on custom type tests. + object qml.Object +} + +// Force a gap in the reflect method index and ensure the handling +// of private methods is being done properly. +func (ts *GoType) privateMethod() {} + +func (ts *GoType) StringMethod() string { + return ts.StringValue +} + +func (ts *GoType) SetSetterStringValue(s string) { + ts.setterStringValueChanged++ + ts.setterStringValueSet = s +} + +func (ts *GoType) SetSetterObjectsValue(v []qml.Object) { + ts.setterObjectsValueChanged++ + ts.setterObjectsValueSet = v +} + +func (ts *GoType) GetterStringValue() string { + return ts.getterStringValue +} + +func (ts *GoType) SetGetterStringValue(s string) { + ts.getterStringValueChanged++ + ts.getterStringValue = s +} + +func (ts *GoType) SetMapValue(m map[string]interface{}) { + ts.MapValue = m +} + +func (ts *GoType) Mod(dividend, divisor int) (int, error) { + if divisor == 0 { + return 0, fmt.Errorf("") + } + return dividend % divisor, nil +} + +func (ts *GoType) ChangeString(new string) (old string) { + old = ts.StringValue + ts.StringValue = new + return +} + +func (ts *GoType) NotifyStringChanged() { + qml.Changed(ts, &ts.StringValue) +} + +func (ts *GoType) IncrementInt() { + ts.IntValue++ +} + +func (s *S) TestEngineDestroyedUse(c *C) { + s.engine.Destroy() + s.engine.Destroy() + c.Assert(s.engine.Context, PanicMatches, "engine already destroyed") +} + +var same = "" + +var getSetTests = []struct{ set, get interface{} }{ + {"value", same}, + {true, same}, + {false, same}, + {int(42), same}, + {int32(42), int(42)}, + {int64(42), same}, + {uint32(42), same}, + {uint64(42), same}, + {float64(42), same}, + {float32(42), same}, + {new(GoType), same}, + {nil, same}, + {42, same}, +} + +func (s *S) TestContextGetSet(c *C) { + for i, t := range getSetTests { + want := t.get + if t.get == same { + want = t.set + } + s.context.SetVar("key", t.set) + c.Assert(s.context.Var("key"), Equals, want, + Commentf("entry %d is {%v (%T), %v (%T)}", i, t.set, t.set, t.get, t.get)) + } +} + +func (s *S) TestContextGetMissing(c *C) { + c.Assert(s.context.Var("missing"), Equals, nil) +} + +func (s *S) TestContextSetVars(c *C) { + component, err := s.engine.LoadString("file.qml", "import QtQuick 2.0\nItem { width: 42 }") + c.Assert(err, IsNil) + root := component.Create(nil) + + vars := GoType{ + StringValue: "", + BoolValue: true, + IntValue: 42, + Int64Value: 42, + Int32Value: 42, + Float64Value: 4.2, + Float32Value: 4.2, + AnyValue: nil, + ObjectValue: root, + } + s.context.SetVars(&vars) + + c.Assert(s.context.Var("stringValue"), Equals, "") + c.Assert(s.context.Var("boolValue"), Equals, true) + c.Assert(s.context.Var("intValue"), Equals, 42) + c.Assert(s.context.Var("int64Value"), Equals, int64(42)) + c.Assert(s.context.Var("int32Value"), Equals, 42) + c.Assert(s.context.Var("float64Value"), Equals, float64(4.2)) + c.Assert(s.context.Var("float32Value"), Equals, float32(4.2)) + c.Assert(s.context.Var("anyValue"), Equals, nil) + + vars.AnyValue = 42 + c.Assert(s.context.Var("anyValue"), Equals, 42) + + c.Assert(s.context.Var("objectValue").(qml.Object).Int("width"), Equals, 42) +} + +func (s *S) TestComponentSetDataError(c *C) { + _, err := s.engine.LoadString("file.qml", "Item{}") + c.Assert(err, ErrorMatches, "file:.*/file.qml:1 Item is not a type") +} + +func (s *S) TestComponentCreateWindow(c *C) { + data := ` + import QtQuick 2.0 + Item { width: 300; height: 200; } + ` + component, err := s.engine.LoadString("file.qml", data) + c.Assert(err, IsNil) + + // TODO How to test this more effectively? + window := component.CreateWindow(nil) + window.Show() + + // Just a smoke test, as there isn't much to assert. + c.Assert(window.PlatformId(), Not(Equals), uintptr(0)) + + // Qt doesn't hide the Window if we call it too quickly. :-( + time.Sleep(100 * time.Millisecond) + window.Hide() +} + +func (s *S) TestContextSpawn(c *C) { + context1 := s.engine.Context() + context2 := context1.Spawn() + + context1.SetVar("mystr", "context1") + context2.SetVar("mystr", "context2") + + data := ` + import QtQuick 2.0 + Item { property var s: mystr } + ` + component, err := s.engine.LoadString("file.qml", data) + c.Assert(err, IsNil) + + obj1 := component.Create(context1) + obj2 := component.Create(context2) + + c.Assert(obj1.String("s"), Equals, "context1") + c.Assert(obj2.String("s"), Equals, "context2") +} + +func (s *S) TestReadVoidAddrProperty(c *C) { + obj := cpptest.NewTestType(s.engine) + addr := obj.Property("voidAddr").(uintptr) + c.Assert(addr, Equals, uintptr(42)) +} + +func (s *S) TestRegisterConverterPlainObject(c *C) { + qml.RegisterConverter("PlainTestType", func(engine *qml.Engine, obj qml.Object) interface{} { + c.Check(engine, Equals, s.engine) + c.Check(obj.String("plainType"), Matches, "(const )?PlainTestType[&*]?") + c.Check(obj.Property("plainAddr"), FitsTypeOf, uintptr(0)) + c.Check(cpptest.PlainTestTypeN(obj), Equals, 42) + return "" + }) + obj := cpptest.NewTestType(s.engine) + defer obj.Destroy() + + var calls int + obj.On("plainEmittedCpy", func(s string) { + c.Check(s, Equals, "") + calls++ + }) + obj.On("plainEmittedRef", func(s string) { + c.Check(s, Equals, "") + calls++ + }) + obj.On("plainEmittedPtr", func(s string) { + c.Check(s, Equals, "") + calls++ + }) + obj.Call("emitPlain") + c.Assert(calls, Equals, 3) +} + +func (s *S) TestIssue84(c *C) { + // Regression test for issue #84 (QTBUG-41193). + data := ` + import QtQuick 2.0 + Item { + id: item + property string s1: "" + property string s2: "" + states: State { + name: "after"; + PropertyChanges { target: item; s1: s2 } + } + Component.onCompleted: state = "after" + } + ` + filename := filepath.Join(c.MkDir(), "file.qml") + err := ioutil.WriteFile(filename, []byte(data), 0644) + c.Assert(err, IsNil) + + component, err := s.engine.LoadString(filename, data) + c.Assert(err, IsNil) + + root := component.Create(nil) + defer root.Destroy() + + c.Assert(root.String("s1"), Equals, "") +} + +func (s *S) TestResources(c *C) { + var rp qml.ResourcesPacker + rp.Add("sub/path/Foo.qml", []byte("import QtQuick 2.0\nItem { Component.onCompleted: console.log('') }")) + rp.AddString("sub/path/Bar.qml", "import QtQuick 2.0\nItem { Component.onCompleted: console.log('') }") + rp.AddString("/sub/Main.qml", "import QtQuick 2.0\nimport \"./path\"\nItem {\nFoo{}\nBar{}\n}") + + r := rp.Pack() + qml.LoadResources(r) + testResourcesLoaded(c, true) + qml.UnloadResources(r) + testResourcesLoaded(c, false) + + data := r.Bytes() + + rb, err := qml.ParseResources(data) + c.Assert(err, IsNil) + qml.LoadResources(rb) + testResourcesLoaded(c, true) + qml.UnloadResources(rb) + testResourcesLoaded(c, false) + + rs, err := qml.ParseResourcesString(string(data)) + c.Assert(err, IsNil) + qml.LoadResources(rs) + testResourcesLoaded(c, true) + qml.UnloadResources(rs) + testResourcesLoaded(c, false) +} + +func testResourcesLoaded(c *C, loaded bool) { + engine := qml.NewEngine() + defer engine.Destroy() + component, err := engine.LoadFile("qrc:///sub/Main.qml") + if loaded { + c.Assert(err, IsNil) + } else { + c.Assert(err, ErrorMatches, "qrc:///sub/Main.qml:-1 File not found") + return + } + root := component.Create(nil) + defer root.Destroy() + c.Assert(c.GetTestLog(), Matches, "(?s).*(.*|.*).*") +} + +func (s *S) TestResourcesIssue107(c *C) { + var rp qml.ResourcesPacker + + rp.Add("a/Foo.qml", []byte("import QtQuick 2.0\nItem { Component.onCompleted: console.log('') }")) + rp.Add("b/Bar.qml", []byte("import QtQuick 2.0\nItem { Component.onCompleted: console.log('') }")) + rp.Add("c/Baz.qml", []byte("import QtQuick 2.0\nItem { Component.onCompleted: console.log('') }")) + rp.Add("d/Buz.qml", []byte("import QtQuick 2.0\nItem { Component.onCompleted: console.log('') }")) + + r := rp.Pack() + qml.LoadResources(r) + + for _, name := range []string{"a/Foo", "b/Bar", "c/Baz", "d/Buz"} { + component, err := s.engine.LoadFile("qrc:///" + name + ".qml") + c.Assert(err, IsNil) + root := component.Create(nil) + defer root.Destroy() + } + c.Assert(c.GetTestLog(), Matches, "(?s).*.*.*.*.*") +} + +type TestData struct { + *C + engine *qml.Engine + context *qml.Context + component qml.Object + root qml.Object + value *GoType + createdValue []*GoType + createdRect []*GoRect + createdSingleton []*GoType +} + +var tests = []struct { + Summary string + Value GoType + Rect GoRect + + Init func(d *TestData) + + // The QML provided is run with the initial state above, and + // then checks are made to ensure the provided state is found. + QML string + QMLLog string + QMLValue GoType + + // The function provided is run with the post-QML state above, + // and then checks are made to ensure the provided state is found. + Done func(c *TestData) + DoneLog string + DoneValue GoType +}{ + { + Summary: "Read a context variable and its fields", + Value: GoType{StringValue: "", IntValue: 42}, + QML: ` + Item { + Component.onCompleted: { + console.log("String is", value.stringValue) + console.log("Int is", value.intValue) + console.log("Any is", value.anyValue) + } + } + `, + QMLLog: "String is .*Int is 42.*Any is undefined", + }, + { + Summary: "Read a nested field via a value (not pointer) in an interface", + Value: GoType{AnyValue: struct{ StringValue string }{""}}, + QML: `Item { Component.onCompleted: console.log("String is", value.anyValue.stringValue) }`, + QMLLog: "String is ", + }, + { + Summary: "Read a native property", + QML: `Item { width: 123 }`, + Done: func(c *TestData) { c.Check(c.root.Int("width"), Equals, 123) }, + }, + { + Summary: "Read object properties", + QML: ` + Item { + property bool boolp: true + property int intp: 1 + property var int64p: 4294967296 + property real float32p: 1.1 + property double float64p: 1.1 + property string stringp: "" + property var objectp: Rectangle { width: 123 } + property var nilp: null + } + `, + Done: func(c *TestData) { + obj := c.root + c.Check(obj.Bool("boolp"), Equals, true) + c.Check(obj.Int("intp"), Equals, 1) + c.Check(obj.Int64("intp"), Equals, int64(1)) + c.Check(obj.Int64("int64p"), Equals, int64(4294967296)) + c.Check(obj.Float64("intp"), Equals, float64(1)) + c.Check(obj.Float64("int64p"), Equals, float64(4294967296)) + c.Check(obj.Float64("float32p"), Equals, float64(1.1)) + c.Check(obj.Float64("float64p"), Equals, float64(1.1)) + c.Check(obj.String("stringp"), Equals, "") + c.Check(obj.Object("objectp").Int("width"), Equals, 123) + c.Check(obj.Property("nilp"), Equals, nil) + + c.Check(func() { obj.Bool("intp") }, Panics, `value of property "intp" is not a bool: 1`) + c.Check(func() { obj.Int("boolp") }, Panics, `value of property "boolp" cannot be represented as an int: true`) + c.Check(func() { obj.Int64("boolp") }, Panics, `value of property "boolp" cannot be represented as an int64: true`) + c.Check(func() { obj.Float64("boolp") }, Panics, `value of property "boolp" cannot be represented as a float64: true`) + c.Check(func() { obj.String("boolp") }, Panics, `value of property "boolp" is not a string: true`) + c.Check(func() { obj.Object("boolp") }, Panics, `value of property "boolp" is not a QML object: true`) + c.Check(func() { obj.Property("missing") }, Panics, `object does not have a "missing" property`) + }, + }, + { + Summary: "Lowercasing of object properties", + Init: func(c *TestData) { + obj := struct{ THE, THEName, Name, N string }{"", "", "", ""} + c.context.SetVar("obj", &obj) + }, + QML: `Item { Component.onCompleted: console.log("Names are", obj.the, obj.theName, obj.name, obj.n) }`, + QMLLog: "Names are ", + }, + { + Summary: "No access to private fields", + Value: GoType{private: true}, + QML: `Item { Component.onCompleted: console.log("Private is", value.private); }`, + QMLLog: "Private is undefined", + }, + { + Summary: "Set a custom property", + QML: ` + Item { + property var obj: null + + onObjChanged: console.log("String is", obj.stringValue) + onWidthChanged: console.log("Width is", width) + onHeightChanged: console.log("Height is", height) + } + `, + Done: func(c *TestData) { + value := GoType{StringValue: ""} + c.root.Set("obj", &value) + c.root.Set("width", 300) + c.root.Set("height", 200) + }, + DoneLog: "String is .*Width is 300.*Height is 200", + }, + { + Summary: "Read and set a QUrl property", + QML: `import QtWebKit 3.0; WebView {}`, + Done: func(c *TestData) { + c.Check(c.root.String("url"), Equals, "") + url := "http://localhost:54321" + c.root.Set("url", url) + c.Check(c.root.String("url"), Equals, url) + }, + }, + { + Summary: "Read and set a QColor property", + QML: `Text{ color: Qt.rgba(1/16, 1/8, 1/4, 1/2); function hasColor(c) { return Qt.colorEqual(color, c) }}`, + Done: func(c *TestData) { + c.Assert(c.root.Color("color"), Equals, color.RGBA{256 / 16, 256 / 8, 256 / 4, 256 / 2}) + c.root.Set("color", color.RGBA{256 / 2, 256 / 4, 256 / 8, 256 / 16}) + c.Assert(c.root.Call("hasColor", color.RGBA{256 / 2, 256 / 4, 256 / 8, 256 / 16}), Equals, true) + }, + }, + { + Summary: "Read and set a QColor property from a Go field", + Init: func(c *TestData) { c.value.ColorValue = color.RGBA{256 / 16, 256 / 8, 256 / 4, 256 / 2} }, + QML: `Text{ property var c: value.colorValue; Component.onCompleted: { console.log(value.colorValue); } }`, + Done: func(c *TestData) { + c.Assert(c.root.Color("c"), Equals, color.RGBA{256 / 16, 256 / 8, 256 / 4, 256 / 2}) + }, + }, + { + Summary: "Read a QQmlListProperty property into a Go slice", + QML: ` + Item { + states: [ + State { id: on; name: "on" }, + State { id: off; name: "off" } + ] + } + `, + Done: func(c *TestData) { + var states []qml.Object + c.root.List("states").Convert(&states) + c.Assert(states[0].String("name"), Equals, "on") + c.Assert(states[1].String("name"), Equals, "off") + c.Assert(len(states), Equals, 2) + c.Assert(c.root.Property("states").(*qml.List).Len(), Equals, 2) + }, + }, + { + Summary: "Read a QQmlListReference property into a Go slice", + QML: ` + Item { + property list mystates: [ + State { id: on; name: "on" }, + State { id: off; name: "off" } + ] + Component.onCompleted: value.objectsValue = mystates + } + `, + Done: func(c *TestData) { + var states []qml.Object + c.root.List("mystates").Convert(&states) + c.Assert(states[0].String("name"), Equals, "on") + c.Assert(states[1].String("name"), Equals, "off") + c.Assert(len(states), Equals, 2) + c.Assert(len(c.value.ObjectsValue), Equals, 2) + }, + }, + { + Summary: "Read a QVariantList property into a Go slice", + QML: ` + Item { + State { id: on; name: "on" } + State { id: off; name: "off" } + property var mystates: [on, off] + } + `, + Done: func(c *TestData) { + var states []qml.Object + c.root.List("mystates").Convert(&states) + c.Assert(states[0].String("name"), Equals, "on") + c.Assert(states[1].String("name"), Equals, "off") + c.Assert(len(states), Equals, 2) + }, + }, + { + Summary: "Set a Go slice property", + QML: `Item { Component.onCompleted: value.intsValue = [1, 2, 3.5] }`, + QMLValue: GoType{IntsValue: []int{1, 2, 3}}, + }, + { + Summary: "Set a Go slice property with objects", + QML: ` + Item { + State { id: on; name: "on" } + State { id: off; name: "off" } + Component.onCompleted: value.objectsValue = [on, off] + } + `, + Done: func(c *TestData) { + c.Assert(c.value.ObjectsValue[0].String("name"), Equals, "on") + c.Assert(c.value.ObjectsValue[1].String("name"), Equals, "off") + c.Assert(len(c.value.ObjectsValue), Equals, 2) + }, + }, + { + Summary: "Call a method with a JSON object (issue #48)", + QML: `Item { Component.onCompleted: value.setMapValue({a: 1, b: 2}) }`, + QMLValue: GoType{MapValue: map[string]interface{}{"a": 1, "b": 2}}, + }, + { + Summary: "Read a map from a QML property", + QML: `Item { property var m: {"a": 1, "b": 2} }`, + Done: func(c *TestData) { + var m1 map[string]interface{} + var m2 map[string]int + m := c.root.Map("m") + m.Convert(&m1) + m.Convert(&m2) + c.Assert(m1, DeepEquals, map[string]interface{}{"a": 1, "b": 2}) + c.Assert(m2, DeepEquals, map[string]int{"a": 1, "b": 2}) + c.Assert(m.Len(), Equals, 2) + }, + }, + { + Summary: "Identical values remain identical when possible", + Init: func(c *TestData) { + c.context.SetVar("a", c.value) + c.context.SetVar("b", c.value) + }, + QML: `Item { Component.onCompleted: console.log('Identical:', a === b); }`, + QMLLog: "Identical: true", + }, + { + Summary: "Object finding via ObjectByName", + QML: `Item { Item { objectName: "subitem"; property string s: "" } }`, + Done: func(c *TestData) { + obj := c.root.ObjectByName("subitem") + c.Check(obj.String("s"), Equals, "") + c.Check(func() { c.root.ObjectByName("foo") }, Panics, `cannot find descendant with objectName == "foo"`) + }, + }, + { + Summary: "Object finding via ObjectByName on GoType", + QML: `Item { GoType { objectName: "subitem"; property string s: "" } }`, + Done: func(c *TestData) { + obj := c.root.ObjectByName("subitem") + c.Check(obj.String("s"), Equals, "") + c.Check(func() { c.root.ObjectByName("foo") }, Panics, `cannot find descendant with objectName == "foo"`) + }, + }, + { + Summary: "Register Go type", + QML: `GoType { objectName: "test"; Component.onCompleted: console.log("String is", stringValue) }`, + QMLLog: "String is ", + Done: func(c *TestData) { + c.Assert(c.createdValue, HasLen, 1) + c.Assert(c.createdValue[0].object.String("objectName"), Equals, "test") + }, + }, + { + Summary: "Register Go type with an explicit name", + QML: `NamedGoType { objectName: "test"; Component.onCompleted: console.log("String is", stringValue) }`, + QMLLog: "String is ", + Done: func(c *TestData) { + c.Assert(c.createdValue, HasLen, 1) + c.Assert(c.createdValue[0].object.String("objectName"), Equals, "test") + }, + }, + { + Summary: "Write Go type property", + QML: `GoType { stringValue: ""; intValue: 300 }`, + Done: func(c *TestData) { + c.Assert(c.createdValue, HasLen, 1) + c.Assert(c.createdValue[0].StringValue, Equals, "") + c.Assert(c.createdValue[0].IntValue, Equals, 300) + }, + }, + { + Summary: "Write Go type property that has a setter", + QML: `GoType { setterStringValue: "" }`, + Done: func(c *TestData) { + c.Assert(c.createdValue, HasLen, 1) + c.Assert(c.createdValue[0].SetterStringValue, Equals, "") + c.Assert(c.createdValue[0].setterStringValueChanged, Equals, 1) + c.Assert(c.createdValue[0].setterStringValueSet, Equals, "") + }, + }, + { + Summary: "Write Go type property that has a setter and a getter", + QML: ` + GoType { + getterStringValue: "" + Component.onCompleted: console.log("Getter returned", getterStringValue) + } + `, + QMLLog: `Getter returned `, + Done: func(c *TestData) { + c.Assert(c.createdValue, HasLen, 1) + c.Assert(c.createdValue[0].getterStringValue, Equals, "") + c.Assert(c.createdValue[0].getterStringValueChanged, Equals, 1) + }, + }, + { + Summary: "Write an inline object list to a Go type property", + QML: ` + GoType { + objectsValue: [State{ name: "on" }, State{ name: "off" }] + Component.onCompleted: { + console.log("Length:", objectsValue.length) + console.log("Name:", objectsValue[0].name) + } + } + `, + QMLLog: "Length: 2.*Name: on", + Done: func(c *TestData) { + c.Assert(c.createdValue, HasLen, 1) + c.Assert(c.createdValue[0].ObjectsValue[0].String("name"), Equals, "on") + c.Assert(c.createdValue[0].ObjectsValue[1].String("name"), Equals, "off") + c.Assert(c.createdValue[0].ObjectsValue, HasLen, 2) + }, + }, + { + Summary: "Write an inline object list to a Go type property that has a setter", + QML: `GoType { setterObjectsValue: [State{ name: "on" }, State{ name: "off" }] }`, + Done: func(c *TestData) { + // Note that the setter is not actually updating the field value, for testing purposes. + c.Assert(c.createdValue, HasLen, 1) + c.Assert(c.createdValue[0].SetterObjectsValue, IsNil) + c.Assert(c.createdValue[0].setterObjectsValueChanged, Equals, 2) + c.Assert(c.createdValue[0].setterObjectsValueSet, HasLen, 1) + c.Assert(c.createdValue[0].setterObjectsValueSet[0].String("name"), Equals, "off") + }, + }, + { + Summary: "Clear an object list in a Go type property", + QML: ` + GoType { + objectsValue: [State{ name: "on" }, State{ name: "off" }] + Component.onCompleted: objectsValue = [] + } + `, + Done: func(c *TestData) { + c.Assert(c.createdValue, HasLen, 1) + c.Assert(c.createdValue[0].ObjectsValue, HasLen, 0) + }, + }, + { + Summary: "Clear an object list in a Go type property that has a setter", + Value: GoType{SetterObjectsValue: []qml.Object{nil, nil}}, + QML: ` + GoType { + objectsValue: [State{ name: "on" }, State{ name: "off" }] + function clear() { setterObjectsValue = [] } + } + `, + Done: func(c *TestData) { + // Note that the setter is not actually updating the field value, for testing purposes. + c.Assert(c.createdValue, HasLen, 1) + c.createdValue[0].SetterObjectsValue = c.createdValue[0].ObjectsValue + + c.createdValue[0].object.Call("clear") + + c.Assert(c.createdValue[0].SetterObjectsValue, HasLen, 2) + c.Assert(c.createdValue[0].setterObjectsValueChanged, Equals, 1) + c.Assert(c.createdValue[0].setterObjectsValueSet, DeepEquals, []qml.Object{}) + c.Assert(&c.createdValue[0].SetterObjectsValue[0], Equals, &c.createdValue[0].ObjectsValue[0]) + }, + }, + { + Summary: "Access underlying Go value with Interface", + QML: `GoType { stringValue: "" }`, + Done: func(c *TestData) { + c.Assert(c.root.Interface().(*GoType).StringValue, Equals, "") + c.Assert(c.context.Interface, Panics, "QML object is not backed by a Go value") + }, + }, + { + Summary: "Notification signals on custom Go type", + QML: ` + GoType { + id: custom + stringValue: "" + onStringValueChanged: if (custom.stringValue != "") { custom.stringValue = "" } + Component.onCompleted: custom.stringValue = "" + } + `, + Done: func(c *TestData) { + c.Assert(c.createdValue, HasLen, 1) + c.Assert(c.createdValue[0].StringValue, Equals, "") + }, + }, + { + Summary: "Singleton type registration", + QML: `Item { Component.onCompleted: console.log("String is", GoSingleton.stringValue) }`, + QMLLog: "String is ", + }, + { + Summary: "qml.Changed on unknown value is okay", + Value: GoType{StringValue: ""}, + Init: func(c *TestData) { + value := &GoType{} + qml.Changed(&value, &value.StringValue) + }, + QML: `Item{}`, + }, + { + Summary: "qml.Changed triggers a QML slot", + QML: ` + GoType { + stringValue: "" + onStringValueChanged: console.log("String is", stringValue) + onStringAddrValueChanged: console.log("String at addr is", stringAddrValue) + } + `, + QMLLog: "!String is", + Done: func(c *TestData) { + c.Assert(c.createdValue, HasLen, 1) + value := c.createdValue[0] + s := "" + value.StringValue = "" + value.StringAddrValue = &s + qml.Changed(value, &value.StringValue) + qml.Changed(value, &value.StringAddrValue) + }, + DoneLog: "String is .*String at addr is ", + }, + { + Summary: "qml.Changed must not trigger on the wrong field", + QML: ` + GoType { + stringValue: "" + onStringValueChanged: console.log("String is", stringValue) + } + `, + Done: func(c *TestData) { + c.Assert(c.createdValue, HasLen, 1) + value := c.createdValue[0] + value.StringValue = "" + qml.Changed(value, &value.IntValue) + }, + DoneLog: "!String is", + }, + { + Summary: "qml.Changed updates bindings", + Value: GoType{StringValue: ""}, + QML: `Item { property string s: "String is " + value.stringValue }`, + Done: func(c *TestData) { + c.value.StringValue = "" + qml.Changed(c.value, &c.value.StringValue) + c.Check(c.root.String("s"), Equals, "String is ") + }, + }, + { + Summary: "Call a Go method without arguments or result", + Value: GoType{IntValue: 42}, + QML: `Item { Component.onCompleted: console.log("Undefined is", value.incrementInt()); }`, + QMLLog: "Undefined is undefined", + QMLValue: GoType{IntValue: 43}, + }, + { + Summary: "Call a Go method with one argument and one result", + Value: GoType{StringValue: ""}, + QML: `Item { Component.onCompleted: console.log("String was", value.changeString("")); }`, + QMLLog: "String was ", + QMLValue: GoType{StringValue: ""}, + }, + { + Summary: "Call a Go method with multiple results", + QML: ` + Item { + Component.onCompleted: { + var r = value.mod(42, 4); + console.log("mod is", r[0], "and err is", r[1]); + } + } + `, + QMLLog: `mod is 2 and err is undefined`, + }, + { + Summary: "Call a Go method that returns an error", + QML: ` + Item { + Component.onCompleted: { + var r = value.mod(0, 0); + console.log("err is", r[1].error()); + } + } + `, + QMLLog: `err is `, + }, + { + Summary: "Call a Go method that recurses back into the GUI thread", + QML: ` + Item { + Connections { + target: value + onStringValueChanged: console.log("Notification arrived") + } + Component.onCompleted: { + value.notifyStringChanged() + } + } + `, + QMLLog: "Notification arrived", + }, + { + Summary: "Connect a QML signal to a Go method", + Value: GoType{StringValue: ""}, + QML: ` + Item { + id: item + signal testSignal(string s) + Component.onCompleted: { + item.testSignal.connect(value.changeString) + item.testSignal("") + } + } + `, + QMLValue: GoType{StringValue: ""}, + }, + { + Summary: "Call a QML method with no result or parameters from Go", + QML: `Item { function f() { console.log("f was called"); } }`, + Done: func(c *TestData) { c.Check(c.root.Call("f"), IsNil) }, + DoneLog: "f was called", + }, + { + Summary: "Call a QML method with result and parameters from Go", + QML: `Item { function add(a, b) { return a+b; } }`, + Done: func(c *TestData) { c.Check(c.root.Call("add", 1, 2.1), Equals, float64(3.1)) }, + }, + { + Summary: "Call a QML method with a custom type", + Value: GoType{StringValue: ""}, + QML: `Item { function log(value) { console.log("String is", value.stringValue) } }`, + Done: func(c *TestData) { c.root.Call("log", c.value) }, + DoneLog: "String is ", + }, + { + Summary: "Call a QML method that returns a QML object", + QML: ` + Item { + property var custom: Rectangle { width: 300; } + function f() { return custom } + } + `, + Done: func(c *TestData) { + c.Check(c.root.Call("f").(qml.Object).Int("width"), Equals, 300) + }, + }, + { + Summary: "Call a QML method that holds a custom type past the return point", + QML: ` + Item { + property var held + function hold(v) { held = v; gc(); gc(); } + function log() { console.log("String is", held.stringValue) } + }`, + Done: func(c *TestData) { + value := GoType{StringValue: ""} + stats := qml.Stats() + c.root.Call("hold", &value) + c.Check(qml.Stats().ValuesAlive, Equals, stats.ValuesAlive+1) + c.root.Call("log") + c.root.Call("hold", nil) + c.Check(qml.Stats().ValuesAlive, Equals, stats.ValuesAlive) + }, + DoneLog: "String is ", + }, + { + Summary: "Call a non-existent QML method", + QML: `Item {}`, + Done: func(c *TestData) { + c.Check(func() { c.root.Call("add", 1, 2) }, Panics, `object does not expose a method "add"`) + }, + }, + { + Summary: "Ensure URL of provided file is correct by loading a local file", + Init: func(c *TestData) { + data, err := base64.StdEncoding.DecodeString("R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==") + c.Assert(err, IsNil) + err = ioutil.WriteFile("test.gif", data, 0644) + c.Check(err, IsNil) + }, + QML: `Image { source: "test.gif"; Component.onCompleted: console.log("Ready:", status == Image.Ready) }`, + QMLLog: "Ready: true", + Done: func(c *TestData) { os.Remove("test.gif") }, + }, + { + Summary: "Create window with non-window root object", + QML: `Rectangle { width: 300; height: 200; function inc(x) { return x+1 } }`, + Done: func(c *TestData) { + win := c.component.CreateWindow(nil) + root := win.Root() + c.Check(root.Int("width"), Equals, 300) + c.Check(root.Int("height"), Equals, 200) + c.Check(root.Call("inc", 42.5), Equals, float64(43.5)) + root.Destroy() + }, + }, + { + Summary: "Create window with window root object", + QML: ` + import QtQuick.Window 2.0 + Window { title: ""; width: 300; height: 200 } + `, + Done: func(c *TestData) { + win := c.component.CreateWindow(nil) + root := win.Root() + c.Check(root.String("title"), Equals, "<title>") + c.Check(root.Int("width"), Equals, 300) + c.Check(root.Int("height"), Equals, 200) + }, + }, + { + Summary: "Window is object", + QML: `Item {}`, + Done: func(c *TestData) { + win := c.component.CreateWindow(nil) + c.Assert(win.Int("status"), Equals, 1) // Ready + }, + }, + { + Summary: "Pass a *Value back into a method", + QML: `Rectangle { width: 300; function log(r) { console.log("Width is", r.width) } }`, + Done: func(c *TestData) { c.root.Call("log", c.root) }, + DoneLog: "Width is 300", + }, + { + Summary: "Create a QML-defined component in Go", + QML: `Item { property var comp: Component { Rectangle { width: 300 } } }`, + Done: func(c *TestData) { + rect := c.root.Object("comp").Create(nil) + c.Check(rect.Int("width"), Equals, 300) + c.Check(func() { c.root.Create(nil) }, Panics, "object is not a component") + c.Check(func() { c.root.CreateWindow(nil) }, Panics, "object is not a component") + }, + }, + { + Summary: "Call a Qt method that has no result", + QML: `Item { Component.onDestruction: console.log("item destroyed") }`, + Done: func(c *TestData) { + // Create a local instance to avoid double-destroying it. + root := c.component.Create(nil) + root.Call("deleteLater") + time.Sleep(100 * time.Millisecond) + }, + DoneLog: "item destroyed", + }, + { + Summary: "Errors connecting to QML signals", + QML: `Item { signal doIt() }`, + Done: func(c *TestData) { + c.Check(func() { c.root.On("missing", func() {}) }, Panics, `object does not expose a "missing" signal`) + c.Check(func() { c.root.On("doIt", func(s string) {}) }, Panics, `signal "doIt" has too few parameters for provided function`) + }, + }, + { + Summary: "Connect to a QML signal without parameters", + QML: ` + Item { + id: item + signal doIt() + function emitDoIt() { item.doIt() } + } + `, + Done: func(c *TestData) { + itWorks := false + c.root.On("doIt", func() { itWorks = true }) + c.Check(itWorks, Equals, false) + c.root.Call("emitDoIt") + c.Check(itWorks, Equals, true) + }, + }, + { + Summary: "Connect to a QML signal with a parameters", + QML: ` + Item { + id: item + signal doIt(string s, int n) + function emitDoIt() { item.doIt("<arg>", 123) } + } + `, + Done: func(c *TestData) { + var stack []interface{} + c.root.On("doIt", func() { stack = append(stack, "A") }) + c.root.On("doIt", func(s string) { stack = append(stack, "B", s) }) + c.root.On("doIt", func(s string, i int) { stack = append(stack, "C", s, i) }) + c.Check(stack, IsNil) + c.root.Call("emitDoIt") + c.Check(stack, DeepEquals, []interface{}{"A", "B", "<arg>", "C", "<arg>", 123}) + }, + }, + { + Summary: "Connect to a QML signal with an object parameter", + QML: `import QtWebKit 3.0; WebView{}`, + Done: func(c *TestData) { + url := "http://localhost:54321/" + done := make(chan bool) + c.root.On("navigationRequested", func(request qml.Object) { + c.Check(request.String("url"), Equals, url) + done <- true + }) + c.root.Set("url", url) + <-done + }, + }, + { + Summary: "Load image from Go provider", + Init: func(c *TestData) { + c.engine.AddImageProvider("myprov", func(id string, width, height int) image.Image { + return image.NewRGBA(image.Rect(0, 0, 200, 100)) + }) + }, + QML: ` + Image { + source: "image://myprov/myid.png" + Component.onCompleted: console.log("Size:", width, height) + } + `, + QMLLog: "Size: 200 100", + }, + { + Summary: "TypeName", + QML: `Item{}`, + Done: func(c *TestData) { c.Assert(c.root.TypeName(), Equals, "QQuickItem") }, + }, + { + Summary: "Custom Go type with painting", + QML: ` + Rectangle { + width: 200; height: 200 + color: "black" + GoRect { + width: 100; height: 100; x: 50; y: 50 + } + } + `, + Done: func(c *TestData) { + c.Assert(c.createdRect, HasLen, 0) + + window := c.component.CreateWindow(nil) + defer window.Destroy() + window.Show() + + // Qt doesn't hide the Window if we call it too quickly. :-( + time.Sleep(100 * time.Millisecond) + + c.Assert(c.createdRect, HasLen, 1) + c.Assert(c.createdRect[0].PaintCount, Equals, 1) + + image := window.Snapshot() + c.Assert(image.At(25, 25), Equals, color.RGBA{0, 0, 0, 255}) + c.Assert(image.At(100, 100), Equals, color.RGBA{255, 0, 0, 255}) + }, + }, + { + Summary: "Set a property with the wrong type", + QML: ` + import QtQuick.Window 2.0 + Window { Rectangle { objectName: "rect" } } + `, + Done: func(c *TestData) { + window := c.component.CreateWindow(nil) + defer window.Destroy() + + root := window.Root() // It's the window itself in this case + rect := root.ObjectByName("rect") + + c.Assert(func() { rect.Set("parent", root) }, Panics, + `cannot set property "parent" with type QQuickItem* to value of QQuickWindow*`) + c.Assert(func() { rect.Set("parent", 42) }, Panics, + `cannot set property "parent" with type QQuickItem* to value of int`) + c.Assert(func() { rect.Set("non_existent", 0) }, Panics, + `cannot set non-existent property "non_existent" on type QQuickRectangle`) + }, + }, + { + Summary: "Register a type converter for a signal parameter", + QML: ` + Item { + id: item + property Item self + signal testSignal(Item obj) + function emitSignal() { item.testSignal(item) } + function getSelf() { return item } + Component.onCompleted: { self = item } + } + `, + Done: func(c *TestData) { + type Wrapper struct{ Item qml.Object } + qml.RegisterConverter(c.root.TypeName(), func(engine *qml.Engine, item qml.Object) interface{} { + return &Wrapper{item} + }) + defer qml.RegisterConverter(c.root.TypeName(), nil) + + // Check that it works on signal parameters... + c.root.On("testSignal", func(wrapped *Wrapper) { + c.Check(wrapped.Item.Addr(), Equals, c.root.Addr()) + c.Logf("Signal has run.") + }) + c.root.Call("emitSignal") + + // ... on properties ... + wrapped, ok := c.root.Property("self").(*Wrapper) + if c.Check(ok, Equals, true) { + c.Check(wrapped.Item.Addr(), Equals, c.root.Addr()) + } + + // ... and on results. + wrapped, ok = c.root.Call("getSelf").(*Wrapper) + if c.Check(ok, Equals, true) { + c.Check(wrapped.Item.Addr(), Equals, c.root.Addr()) + } + + // Now unregister and ensure it got disabled. + qml.RegisterConverter(c.root.TypeName(), nil) + _, ok = c.root.Property("self").(*qml.Common) + c.Check(ok, Equals, true) + }, + DoneLog: "Signal has run.", + }, + { + Summary: "References handed out must not be GCd (issue #68)", + Init: func(c *TestData) { + type B struct{ S string } + type A struct{ B *B } + c.context.SetVar("a", &A{&B{}}) + }, + QML: `Item { function f() { var x = [[],[],[]]; gc(); if (!a.b) console.log("BUG"); } }`, + Done: func(c *TestData) { + for i := 0; i < 100; i++ { + c.root.Call("f") + } + }, + DoneLog: "!BUG", + }, +} + +var tablef = flag.String("tablef", "", "if provided, TestTable only runs tests with a summary matching the regexp") + +func (s *S) TestTable(c *C) { + var testData TestData + + types := []qml.TypeSpec{{ + Init: func(v *GoType, obj qml.Object) { + v.object = obj + v.StringValue = "<initial>" + testData.createdValue = append(testData.createdValue, v) + }, + }, { + Name: "NamedGoType", + Init: func(v *GoType, obj qml.Object) { + v.object = obj + v.StringValue = "<initial>" + testData.createdValue = append(testData.createdValue, v) + }, + }, { + Name: "GoSingleton", + Init: func(v *GoType, obj qml.Object) { + v.object = obj + v.StringValue = "<initial>" + testData.createdSingleton = append(testData.createdSingleton, v) + }, + Singleton: true, + }, { + Init: func(v *GoRect, obj qml.Object) { + testData.createdRect = append(testData.createdRect, v) + }, + }} + + qml.RegisterTypes("GoTypes", 4, 2, types) + + filter := regexp.MustCompile("") + if tablef != nil { + filter = regexp.MustCompile(*tablef) + } + + for i := range tests { + s.TearDownTest(c) + t := &tests[i] + header := fmt.Sprintf("----- Running table test %d: %s -----", i, t.Summary) + if !filter.MatchString(header) { + continue + } + c.Log(header) + s.SetUpTest(c) + + value := t.Value + s.context.SetVar("value", &value) + + testData = TestData{ + C: c, + value: &value, + engine: s.engine, + context: s.context, + } + + if t.Init != nil { + t.Init(&testData) + if c.Failed() { + c.FailNow() + } + } + + component, err := s.engine.LoadString("file.qml", "import QtQuick 2.0\nimport GoTypes 4.2\n"+strings.TrimSpace(t.QML)) + c.Assert(err, IsNil) + + logMark := c.GetTestLog() + + // The component instance is destroyed before the loop ends below, + // but do a defer to ensure it will be destroyed if the test fails. + root := component.Create(nil) + defer root.Destroy() + + testData.component = component + testData.root = root + + if t.QMLLog != "" { + logged := c.GetTestLog()[len(logMark):] + if t.QMLLog[0] == '!' { + c.Check(logged, Not(Matches), "(?s).*"+t.QMLLog[1:]+".*") + } else { + c.Check(logged, Matches, "(?s).*"+t.QMLLog+".*") + } + } + + if !reflect.DeepEqual(t.QMLValue, GoType{}) { + c.Check(value.StringValue, Equals, t.QMLValue.StringValue) + c.Check(value.StringAddrValue, Equals, t.QMLValue.StringAddrValue) + c.Check(value.BoolValue, Equals, t.QMLValue.BoolValue) + c.Check(value.IntValue, Equals, t.QMLValue.IntValue) + c.Check(value.Int64Value, Equals, t.QMLValue.Int64Value) + c.Check(value.Int32Value, Equals, t.QMLValue.Int32Value) + c.Check(value.Float64Value, Equals, t.QMLValue.Float64Value) + c.Check(value.Float32Value, Equals, t.QMLValue.Float32Value) + c.Check(value.AnyValue, Equals, t.QMLValue.AnyValue) + c.Check(value.IntsValue, DeepEquals, t.QMLValue.IntsValue) + c.Check(value.MapValue, DeepEquals, t.QMLValue.MapValue) + } + + if !c.Failed() { + logMark := c.GetTestLog() + + if t.Done != nil { + t.Done(&testData) + } + + if t.DoneLog != "" { + logged := c.GetTestLog()[len(logMark):] + if t.DoneLog[0] == '!' { + c.Check(logged, Not(Matches), "(?s).*"+t.DoneLog[1:]+".*") + } else { + c.Check(logged, Matches, "(?s).*"+t.DoneLog+".*") + } + } + + if !reflect.DeepEqual(t.DoneValue, GoType{}) { + c.Check(value.StringValue, Equals, t.DoneValue.StringValue) + c.Check(value.StringAddrValue, Equals, t.DoneValue.StringAddrValue) + c.Check(value.BoolValue, Equals, t.DoneValue.BoolValue) + c.Check(value.IntValue, Equals, t.DoneValue.IntValue) + c.Check(value.Int64Value, Equals, t.DoneValue.Int64Value) + c.Check(value.Int32Value, Equals, t.DoneValue.Int32Value) + c.Check(value.Float64Value, Equals, t.DoneValue.Float64Value) + c.Check(value.Float32Value, Equals, t.DoneValue.Float32Value) + c.Check(value.AnyValue, Equals, t.DoneValue.AnyValue) + c.Check(value.IntsValue, DeepEquals, t.DoneValue.IntsValue) + c.Check(value.MapValue, DeepEquals, t.DoneValue.MapValue) + } + } + + root.Destroy() + + if c.Failed() { + c.FailNow() // So relevant logs are at the bottom. + } + } +} diff --git a/resources.go b/resources.go new file mode 100644 index 00000000..3809c113 --- /dev/null +++ b/resources.go @@ -0,0 +1,375 @@ +package qml + +import ( + "bytes" + "fmt" + "sort" + "strings" +) + +// ParseResources parses the resources collection serialized in data. +func ParseResources(data []byte) (*Resources, error) { + if len(data) < 20 || string(data[:4]) != "qres" { + return nil, fmt.Errorf("invalid resources data") + } + r, err := parseResourcesHeader(data[:20], len(data)) + if err != nil { + return nil, err + } + r.bdata = data + return r, nil +} + +// ParseResourcesString parses the resources collection serialized in data. +func ParseResourcesString(data string) (*Resources, error) { + if len(data) < 20 || data[:4] != "qres" { + return nil, fmt.Errorf("invalid resources data") + } + r, err := parseResourcesHeader([]byte(data[:20]), len(data)) + if err != nil { + return nil, err + } + r.sdata = data + return r, nil +} + +func parseResourcesHeader(h []byte, size int) (*Resources, error) { + r := &Resources{ + version: read32(h[4:]), + treeOffset: read32(h[8:]), + dataOffset: read32(h[12:]), + nameOffset: read32(h[16:]), + } + if r.version != resVersion { + return nil, fmt.Errorf("unsupported resources version: %d", r.version) + } + // Ideally this would do a full validation, but it's a good start. + if !(20 <= r.treeOffset && r.treeOffset < size && + 20 <= r.dataOffset && r.dataOffset < size && + 20 <= r.nameOffset && r.nameOffset < size) { + return nil, fmt.Errorf("corrupted resources data") + } + return r, nil +} + +func read32(b []byte) int { + return int(uint32(b[0])<<24 | uint32(b[1])<<16 | uint32(b[2])<<8 | uint32(b[3])) +} + +// Resources is a compact representation of a collection of resources +// (images, qml files, etc) that may be loaded by an Engine and referenced +// by QML at "qrc:///some/path", where "some/path" is the path the +// resource was added with. +// +// Resources must be registered with LoadResources to become available. +type Resources struct { + sdata string + bdata []byte + + version int + treeOffset int + dataOffset int + nameOffset int +} + +// Bytes returns a binary representation of the resources collection that +// may be parsed back with ParseResources or ParseResourcesString. +func (r *Resources) Bytes() []byte { + if len(r.sdata) > 0 { + return []byte(r.sdata) + } + return r.bdata +} + +// ResourcesPacker builds a Resources collection with provided resources. +type ResourcesPacker struct { + root resFile +} + +// Pack builds a resources collection with all resources previously added. +func (rp *ResourcesPacker) Pack() *Resources { + rw := newResourcesWriter(rp) + rw.write() + return &Resources{ + bdata: rw.out.Bytes(), + version: resVersion, + dataOffset: rw.dataOffset, + nameOffset: rw.nameOffset, + treeOffset: rw.treeOffset, + } +} + +type resFile struct { + name string + sdata string + bdata []byte + + children resFiles +} + +// Add adds a resource with the provided data under "qrc:///"+path. +func (rp *ResourcesPacker) Add(path string, data []byte) { + file := rp.addFile(path) + file.bdata = data +} + +// AddString adds a resource with the provided data under "qrc:///"+path. +func (rp *ResourcesPacker) AddString(path, data string) { + file := rp.addFile(path) + file.sdata = data +} + +func (rp *ResourcesPacker) addFile(path string) *resFile { + file := &rp.root + names := strings.Split(path, "/") + if len(names[0]) == 0 { + names = names[1:] + } +NextItem: + for _, name := range names { + for i := range file.children { + child := &file.children[i] + if child.name == name { + file = child + continue NextItem + } + } + file.children = append(file.children, resFile{name: name}) + file = &file.children[len(file.children)-1] + } + if len(file.children) > 0 || file.sdata != "" || file.bdata != nil { + panic("cannot add same resources path twice: " + path) + } + return file +} + +type resWriter struct { + root *resFile + + treeOffset int + dataOffset int + nameOffset int + + treeOffsets map[*resFile]int + dataOffsets map[*resFile]int + nameOffsets map[string]int + + pending []*resFile + out bytes.Buffer +} + +func newResourcesWriter(rp *ResourcesPacker) *resWriter { + rw := &resWriter{ + root: &rp.root, + treeOffsets: make(map[*resFile]int), + dataOffsets: make(map[*resFile]int), + nameOffsets: make(map[string]int), + pending: make([]*resFile, maxPending(&rp.root)), + } + + pending := rw.pending + pending[0] = rw.root + n := 1 + for n > 0 { + n-- + file := pending[n] + sort.Sort(file.children) + for i := range file.children { + child := &file.children[i] + if len(child.children) > 0 { + pending[n] = child + n++ + } + } + } + return rw +} + +func maxPending(file *resFile) int { + max := 1 + for i := range file.children { + if len(file.children) > 0 { + max += maxPending(&file.children[i]) + } + } + return max +} + +func (rw *resWriter) write() { + rw.writeHeader() + rw.writeDataBlobs() + rw.writeDataNames() + rw.writeDataTree() + rw.finishHeader() +} + +func (rw *resWriter) writeHeader() { + rw.out.WriteString("qres\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00") +} + +func (rw *resWriter) finishHeader() { + rw.write32at(4, resVersion) + rw.write32at(8, uint32(rw.treeOffset)) + rw.write32at(12, uint32(rw.dataOffset)) + rw.write32at(16, uint32(rw.nameOffset)) +} + +func (rw *resWriter) writeDataBlobs() { + rw.dataOffset = rw.out.Len() + pending := rw.pending + pending[0] = rw.root + n := 1 + for n > 0 { + n-- + file := pending[n] + for i := range file.children { + child := &file.children[i] + if len(child.children) > 0 { + pending[n] = child + n++ + } else { + rw.dataOffsets[child] = rw.out.Len() - rw.dataOffset + rw.writeDataBlob(child) + } + } + } +} + +func (rw *resWriter) writeDataBlob(file *resFile) { + if len(file.sdata) > 0 { + rw.write32(uint32(len(file.sdata))) + rw.out.WriteString(file.sdata) + } else { + rw.write32(uint32(len(file.bdata))) + rw.out.Write(file.bdata) + } +} + +func (rw *resWriter) writeDataNames() { + rw.nameOffset = rw.out.Len() + pending := rw.pending + pending[0] = rw.root + n := 1 + for n > 0 { + n-- + file := pending[n] + for i := range file.children { + child := &file.children[i] + if len(child.children) > 0 { + pending[n] = child + n++ + } + if _, ok := rw.nameOffsets[child.name]; !ok { + rw.nameOffsets[child.name] = rw.out.Len() - rw.nameOffset + rw.writeDataName(child.name) + } + } + } +} + +func (rw *resWriter) writeDataName(name string) { + rw.write16(uint16(len(name))) + rw.write32(qt_hash(name)) + for _, r := range name { + rw.write16(uint16(r)) + } +} + +func (rw *resWriter) writeDataTree() { + rw.treeOffset = rw.out.Len() + + // Compute first child offset for each parent. + pending := rw.pending + pending[0] = rw.root + n := 1 + offset := 1 + for n > 0 { + n-- + file := pending[n] + rw.treeOffsets[file] = offset + for i := range file.children { + child := &file.children[i] + offset++ + if len(child.children) > 0 { + pending[n] = child + n++ + } + } + } + + // Actually write it out. + rw.writeDataInfo(rw.root) + pending[0] = rw.root + n = 1 + for n > 0 { + n-- + file := pending[n] + for i := range file.children { + child := &file.children[i] + rw.writeDataInfo(child) + if len(child.children) > 0 { + pending[n] = child + n++ + } + } + } +} + +func (rw *resWriter) writeDataInfo(file *resFile) { + rw.write32(uint32(rw.nameOffsets[file.name])) + if len(file.children) > 0 { + rw.write16(uint16(resDirectory)) + rw.write32(uint32(len(file.children))) + rw.write32(uint32(rw.treeOffsets[file])) + } else { + rw.write16(uint16(resNone)) + rw.write16(0) // QLocale::AnyCountry + rw.write16(1) // QLocale::C + rw.write32(uint32(rw.dataOffsets[file])) + } +} + +const ( + resVersion = 1 + + resNone = 0 + resCompressed = 1 + resDirectory = 2 +) + +func (rw *resWriter) write16(v uint16) { + rw.out.Write([]byte{byte(v >> 8), byte(v)}) +} + +func (rw *resWriter) write32(v uint32) { + rw.out.Write([]byte{byte(v >> 24), byte(v >> 16), byte(v >> 8), byte(v)}) +} + +func (rw *resWriter) write32at(index int, v uint32) { + b := rw.out.Bytes() + b[index+0] = byte(v >> 24) + b[index+1] = byte(v >> 16) + b[index+2] = byte(v >> 8) + b[index+3] = byte(v) +} + +type resFiles []resFile + +func (rf resFiles) Len() int { return len(rf) } +func (rf resFiles) Less(i, j int) bool { return qt_hash(rf[i].name) < qt_hash(rf[j].name) } +func (rf resFiles) Swap(i, j int) { rf[i], rf[j] = rf[j], rf[i] } + +// qt_hash returns the hash of p as determined by the internal qt_hash function in Qt. +// +// According to the documentation in qhash.cpp this algorithm is used whenever +// the hash may be stored or reused across Qt versions, and must not change. +// The algorithm in qHash (used in QString, etc) is different and may change. +func qt_hash(p string) uint32 { + var h uint32 + for _, r := range p { + h = (h << 4) + uint32(r) + h ^= (h & 0xf0000000) >> 23 + h &= 0x0fffffff + } + return h +} diff --git a/stats.go b/stats.go new file mode 100644 index 00000000..9f6e94d8 --- /dev/null +++ b/stats.go @@ -0,0 +1,68 @@ +package qml + +import ( + "sync" +) + +var stats *Statistics +var statsMutex sync.Mutex + +func Stats() (snapshot Statistics) { + statsMutex.Lock() + snapshot = *stats + statsMutex.Unlock() + return +} + +func CollectStats(enabled bool) { + statsMutex.Lock() + if enabled { + if stats == nil { + stats = &Statistics{} + } + } else { + stats = nil + } + statsMutex.Unlock() +} + +func ResetStats() { + statsMutex.Lock() + old := stats + stats = &Statistics{} + // These are absolute values: + stats.EnginesAlive = old.EnginesAlive + stats.ValuesAlive = old.ValuesAlive + statsMutex.Unlock() + return +} + +type Statistics struct { + EnginesAlive int + ValuesAlive int + ConnectionsAlive int +} + +func (stats *Statistics) enginesAlive(delta int) { + if stats != nil { + statsMutex.Lock() + stats.EnginesAlive += delta + statsMutex.Unlock() + } +} + +func (stats *Statistics) valuesAlive(delta int) { + if stats != nil { + statsMutex.Lock() + stats.ValuesAlive += delta + statsMutex.Unlock() + } +} + +func (stats *Statistics) connectionsAlive(delta int) { + if stats != nil { + statsMutex.Lock() + stats.ConnectionsAlive += delta + statsMutex.Unlock() + } +} diff --git a/testing.go b/testing.go new file mode 100644 index 00000000..39a2a691 --- /dev/null +++ b/testing.go @@ -0,0 +1,69 @@ +package qml + +// #include <stdlib.h> +// int mprotect(void *addr, size_t len, int prot); +import "C" + +import ( + "bytes" + "encoding/binary" + "gopkg.in/qml.v1/cdata" + "reflect" + "unsafe" +) + +const pageSize = 4096 + +func qmain() { + Run(func() error { tmain(); return nil }) +} + +func tmain() { tstub() } +func tstub() { tstub() } + +func SetupTesting() { + ptr := func(f func()) uintptr { return reflect.ValueOf(f).Pointer() } + rmain, mmain := cdata.Addrs() + fset(rmain, mmain, ptr(qmain)) + fset(ptr(tmain), ptr(tstub), mmain) +} + +const ( + protREAD = 1 + protWRITE = 2 + protEXEC = 4 +) + +func fset(target, old, new uintptr) { + pageOffset := target % pageSize + pageAddr := target - pageOffset + + var mem []byte + memh := (*reflect.SliceHeader)(unsafe.Pointer(&mem)) + memh.Data = pageAddr + memh.Len = pageSize * 2 + memh.Cap = pageSize * 2 + + oldAddr := make([]byte, 8) + newAddr := make([]byte, 8) + + binary.LittleEndian.PutUint64(oldAddr, uint64(old)) + binary.LittleEndian.PutUint64(newAddr, uint64(new)) + + // BSD's syscall package misses Mprotect. Use cgo instead. + C.mprotect(unsafe.Pointer(pageAddr), C.size_t(len(mem)), protEXEC|protREAD|protWRITE) + defer C.mprotect(unsafe.Pointer(pageAddr), C.size_t(len(mem)), protEXEC|protREAD) + + delta := make([]byte, 4) + for i, c := range mem[pageOffset:] { + if c == 0xe8 && int(pageOffset)+i+5 < len(mem) { + instrAddr := pageAddr + pageOffset + uintptr(i) + binary.LittleEndian.PutUint32(delta, uint32(old-instrAddr-5)) + if bytes.Equal(mem[int(pageOffset)+i+1:int(pageOffset)+i+5], delta) { + binary.LittleEndian.PutUint32(mem[int(pageOffset)+i+1:], uint32(new-instrAddr-5)) + return + } + } + } + panic("cannot setup qml package for testing") +}